Repository: pika/pika

Issue:
Rename the "no-ack" option of basic_consume to something clearer
Per discussion with @lukebakken and https://github.com/pika/pika/pull/948#discussion_r167042045.

“no-ack” is really confusing (yes, an unfortunate naming choice in the protocol) and should at least be “no manual ack”, which is the same as “auto-ack”. In some other clients (Bunny, Java, .NET) we renamed it to “manual ack” but "auto-ack" can work just as well, it only depends on what's the default
used by a particular client. I think changing the default is probably not worth the upgrade pain.


Discussion:
codecov[bot]: # [Codecov](https://codecov.io/gh/pika/pika/pull/955?src=pr&el=h1) Report
> :exclamation: No coverage uploaded for pull request base (`master@9acd768`). [Click here to learn what that means](https://docs.codecov.io/docs/error-reference#section-missing-base-commit).
> The diff coverage is `94.11%`.

[![Impacted file tree graph](https://codecov.io/gh/pika/pika/pull/955/graphs/tree.svg?token=cJFWQg66l4&width=650&src=pr&height=150)](https://codecov.io/gh/pika/pika/pull/955?src=pr&el=tree)

```diff
@@            Coverage Diff            @@
##             master     #955   +/-   ##
=========================================
  Coverage          ?   82.35%           
=========================================
  Files             ?       19           
  Lines             ?     3718           
  Branches          ?      554           
=========================================
  Hits              ?     3062           
  Misses            ?      504           
  Partials          ?      152
```


| [Impacted Files](https://codecov.io/gh/pika/pika/pull/955?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [pika/adapters/blocking\_connection.py](https://codecov.io/gh/pika/pika/pull/955/diff?src=pr&el=tree#diff-cGlrYS9hZGFwdGVycy9ibG9ja2luZ19jb25uZWN0aW9uLnB5) | `84.96% <100%> (ø)` | |
| [pika/channel.py](https://codecov.io/gh/pika/pika/pull/955/diff?src=pr&el=tree#diff-cGlrYS9jaGFubmVsLnB5) | `94.03% <81.81%> (ø)` | |

------

[Continue to review full report at Codecov](https://codecov.io/gh/pika/pika/pull/955?src=pr&el=continue).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/pika/pika/pull/955?src=pr&el=footer). Last update [9acd768...e54c68b](https://codecov.io/gh/pika/pika/pull/955?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).

vitaly-krugl: @michaelklishin @lukebakken  Please don't merge - I am going to provide feedback shortly
lukebakken: My two cents -

> I think that supporting the old argument is counter-productive

It is a `1.0.0` release so not supporting the old argument is to be expected, I think.

> Not to be disrespectful, but I question the value of this proposition. I haven't experienced confusion over the use of no-ack, which is at least consistent with the AMQP spec, and haven't encountered user confusion over it (nothing that really stood out, anyway), having thoroughly scrubbed pika issues a couple of years ago

If I were a new user of this library, I would have to look up what `no_ack` or `auto_ack` means anyway. Maybe I could guess what the latter means from its name, but I would have to be familiar with how acknowledgements work with AMQP to begin with.

> Is no_ack the only significant way that Pika args differ from the other AMQP clients under the RabbitMQ umbrella?

Probably (?) I did a quick comparison for `basic.consume`, `basic.get` and `queue.declare` between Pika and the .NET client.
vitaly-krugl: Okay, I would still prefer not supporting the old arg since we're moving to 1.0 and introduced other incompatibilities that will [break existing usage](https://github.com/pika/pika/pull/955#discussion_r168062473) of those same API methods. But feel free to override my recommendation so that we can move forward. Let's at least:

1. Check to make sure that nothing unexpected is in kwargs -
 [see my code example](https://github.com/pika/pika/pull/955#discussion_r168064170).
2. Use a shared function to process the kwargs, if practical.
3. Emit the deprecation and incompatibility warnings that @michaelklishin and I discussed.

michaelklishin: FTR, @lukebakken convinced me to drop support for `no_ack`. Oh the thousands of code examples on the Web that will be copied only to immediately fail…
vitaly-krugl: > Oh the thousands of code examples on the Web that will be copied only to immediately fail…

School of hard knocks of life :)
shinji-s: Would
`assert 'no_ack' not in kwargs, "'no_ack' is obsolete. Use 'auto_ack' instead."
`
be a too much hand-holding?

kmonson: > Would
assert 'no_ack' not in kwargs, "'no_ack' is obsolete. Use 'auto_ack' instead."
be a too much hand-holding?

Personally I love it when library developers do this kind of hand holding. It saves me time and saves them user help requests. 
lukebakken: I'm glad we received feedback from a couple users - thanks @kmonson and @shinji-s 

If we `assert` on `no_ack`, then we ought to do the same for other parameters that have changed.
vitaly-krugl: Okay to merge after addressing feedback about redundant test and AMQP no-ack correlation in `auto_ack` arg documentation 

Patch:
diff --git a/.gitignore b/.gitignore
index 9fdbeeb..d011fbd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,5 +16,5 @@ build
 dist
 docs/_build
 *.conf.in
-venvs/
+venv*/
 env/
diff --git a/docs/examples/direct_reply_to.rst b/docs/examples/direct_reply_to.rst
index 74072cf..ff552d3 100644
--- a/docs/examples/direct_reply_to.rst
+++ b/docs/examples/direct_reply_to.rst
@@ -46,12 +46,12 @@ direct_reply_to.py::
             # Also, client must create the consumer *before* starting to publish the
             # RPC requests.
             #
-            # Client must create its consumer with no_ack=True, because the reply-to
+            # Client must create its consumer with auto_ack=True, because the reply-to
             # queue isn't real.
 
             channel.basic_consume('amq.rabbitmq.reply-to',
                                   on_client_rx_reply_from_server,
-                                  no_ack=True)
+                                  auto_ack=True)
             channel.basic_publish(
                 exchange='',
                 routing_key=SERVER_QUEUE,
diff --git a/docs/examples/twisted_example.rst b/docs/examples/twisted_example.rst
index b73650f..44251a8 100644
--- a/docs/examples/twisted_example.rst
+++ b/docs/examples/twisted_example.rst
@@ -23,7 +23,7 @@ Example of writing a consumer using the :py:class:`Twisted connection adapter <p
 
         yield channel.basic_qos(prefetch_count=1)
 
-        queue_object, consumer_tag = yield channel.basic_consume('hello', no_ack=False)
+        queue_object, consumer_tag = yield channel.basic_consume('hello', auto_ack=False)
 
         l = task.LoopingCall(read, queue_object)
 
diff --git a/examples/consumer_queued.py b/examples/consumer_queued.py
index 22c8d57..3afe192 100644
--- a/examples/consumer_queued.py
+++ b/examples/consumer_queued.py
@@ -53,7 +53,7 @@ def callback(ch, method, properties, body):
     process_buffer()
 
 
-consumer_channel.basic_consume(queue, callback, no_ack=True)
+consumer_channel.basic_consume(queue, callback, auto_ack=True)
 
 try:
     consumer_channel.start_consuming()
diff --git a/examples/consumer_simple.py b/examples/consumer_simple.py
index 863cbf4..f9aa780 100644
--- a/examples/consumer_simple.py
+++ b/examples/consumer_simple.py
@@ -44,7 +44,7 @@ def callback(ch, method, properties, body):
 import logging
 logging.basicConfig(level=logging.INFO)
 
-consumer_channel.basic_consume(queue, callback, no_ack=True)
+consumer_channel.basic_consume(queue, callback, auto_ack=True)
 
 try:
     consumer_channel.start_consuming()
diff --git a/examples/direct_reply_to.py b/examples/direct_reply_to.py
index 4f52c41..4fd202e 100644
--- a/examples/direct_reply_to.py
+++ b/examples/direct_reply_to.py
@@ -41,12 +41,12 @@ def main():
         # Also, client must create the consumer *before* starting to publish the
         # RPC requests.
         #
-        # Client must create its consumer with no_ack=True, because the reply-to
+        # Client must create its consumer with auto_ack=True, because the reply-to
         # queue isn't real.
 
         channel.basic_consume('amq.rabbitmq.reply-to',
                               on_client_rx_reply_from_server,
-                              no_ack=True)
+                              auto_ack=True)
         channel.basic_publish(
             exchange='',
             routing_key=SERVER_QUEUE,
diff --git a/examples/twisted_service.py b/examples/twisted_service.py
index 5d9afc1..ced89a0 100644
--- a/examples/twisted_service.py
+++ b/examples/twisted_service.py
@@ -94,7 +94,7 @@ class PikaProtocol(twisted_connection.TwistedProtocolConnection):
 
         self.channel.queue_declare(queue=routing_key, durable=True)
 
-        (queue, consumer_tag,) = yield self.channel.basic_consume(queue=routing_key, no_ack=False)
+        (queue, consumer_tag,) = yield self.channel.basic_consume(queue=routing_key, auto_ack=False)
         d = queue.get()
         d.addCallback(self._read_item, queue, callback)
         d.addErrback(self._read_item_err)
diff --git a/pika/adapters/blocking_connection.py b/pika/adapters/blocking_connection.py
index d021e94..8649d2e 100644
--- a/pika/adapters/blocking_connection.py
+++ b/pika/adapters/blocking_connection.py
@@ -955,7 +955,7 @@ class ReturnedMessage(object):
 class _ConsumerInfo(object):
     """Information about an active consumer"""
 
-    __slots__ = ('consumer_tag', 'no_ack', 'on_message_callback',
+    __slots__ = ('consumer_tag', 'auto_ack', 'on_message_callback',
                  'alternate_event_sink', 'state')
 
     # Consumer states
@@ -964,13 +964,13 @@ class _ConsumerInfo(object):
     TEARING_DOWN = 3
     CANCELLED_BY_BROKER = 4
 
-    def __init__(self, consumer_tag, no_ack, on_message_callback=None,
+    def __init__(self, consumer_tag, auto_ack, on_message_callback=None,
                  alternate_event_sink=None):
         """
         NOTE: exactly one of callback/alternate_event_sink musts be non-None.
 
         :param str consumer_tag:
-        :param bool no_ack: the no-ack value for the consumer
+        :param bool auto_ack: the no-ack value for the consumer
         :param callable on_message_callback: The function for dispatching messages to
             user, having the signature:
             on_message_callback(channel, method, properties, body)
@@ -988,7 +988,7 @@ class _ConsumerInfo(object):
             'exactly one of on_message_callback/alternate_event_sink must be non-None',
             on_message_callback, alternate_event_sink)
         self.consumer_tag = consumer_tag
-        self.no_ack = no_ack
+        self.auto_ack = auto_ack
         self.on_message_callback = on_message_callback
         self.alternate_event_sink = alternate_event_sink
         self.state = self.SETTING_UP
@@ -1020,7 +1020,7 @@ class _QueueConsumerGeneratorInfo(object):
 
     def __init__(self, params, consumer_tag):
         """
-        :params tuple params: a three-tuple (queue, no_ack, exclusive) that were
+        :params tuple params: a three-tuple (queue, auto_ack, exclusive) that were
            used to create the queue consumer
         :param str consumer_tag: consumer tag
         """
@@ -1502,7 +1502,7 @@ class BlockingChannel(object):
     def basic_consume(self,
                       queue,
                       on_message_callback,
-                      no_ack=False,
+                      auto_ack=False,
                       exclusive=False,
                       consumer_tag=None,
                       arguments=None):
@@ -1528,8 +1528,10 @@ class BlockingChannel(object):
                 method: spec.Basic.Deliver
                 properties: spec.BasicProperties
                 body: str or unicode
-        :param bool no_ack: Tell the broker to not expect a response (i.e.,
-          no ack/nack)
+        :param bool auto_ack: if set to True, automatic acknowledgement mode will be used
+                              (see http://www.rabbitmq.com/confirms.html). This corresponds
+                              with the 'no_ack' parameter in the basic.consume AMQP 0.9.1
+                              method
         :param bool exclusive: Don't allow other consumers on the queue
         :param consumer_tag: You may specify your own consumer tag; if left
           empty, a consumer tag will be generated automatically
@@ -1549,14 +1551,14 @@ class BlockingChannel(object):
         return self._basic_consume_impl(
             queue=queue,
             on_message_callback=on_message_callback,
-            no_ack=no_ack,
+            auto_ack=auto_ack,
             exclusive=exclusive,
             consumer_tag=consumer_tag,
             arguments=arguments)
 
     def _basic_consume_impl(self,
                             queue,
-                            no_ack,
+                            auto_ack,
                             exclusive,
                             consumer_tag,
                             arguments=None,
@@ -1599,7 +1601,7 @@ class BlockingChannel(object):
         # Create new consumer
         self._consumer_infos[consumer_tag] = _ConsumerInfo(
             consumer_tag,
-            no_ack=no_ack,
+            auto_ack=auto_ack,
             on_message_callback=on_message_callback,
             alternate_event_sink=alternate_event_sink)
 
@@ -1608,7 +1610,7 @@ class BlockingChannel(object):
                 tag = self._impl.basic_consume(
                     on_message_callback=self._on_consumer_message_delivery,
                     queue=queue,
-                    no_ack=no_ack,
+                    auto_ack=auto_ack,
                     exclusive=exclusive,
                     consumer_tag=consumer_tag,
                     arguments=arguments)
@@ -1639,18 +1641,18 @@ class BlockingChannel(object):
         of messages in between sending the cancel method and receiving the
         cancel-ok reply.
 
-        NOTE: When cancelling a no_ack=False consumer, this implementation
+        NOTE: When cancelling an auto_ack=False consumer, this implementation
         automatically Nacks and suppresses any incoming messages that have not
         yet been dispatched to the consumer's callback. However, when cancelling
-        a no_ack=True consumer, this method will return any pending messages
+        a auto_ack=True consumer, this method will return any pending messages
         that arrived before broker confirmed the cancellation.
 
         :param str consumer_tag: Identifier for the consumer; the result of
             passing a consumer_tag that was created on another channel is
             undefined (bad things will happen)
 
-        :returns: (NEW IN pika 0.10.0) empty sequence for a no_ack=False
-            consumer; for a no_ack=True consumer, returns a (possibly empty)
+        :returns: (NEW IN pika 0.10.0) empty sequence for a auto_ack=False
+            consumer; for a auto_ack=True consumer, returns a (possibly empty)
             sequence of pending messages that arrived before broker confirmed
             the cancellation (this is done instead of via consumer's callback in
             order to prevent reentrancy/recursion. Each message is four-tuple:
@@ -1678,13 +1680,13 @@ class BlockingChannel(object):
             assert (consumer_info.cancelled_by_broker or
                     consumer_tag in self._impl._consumers), consumer_tag
 
-            no_ack = consumer_info.no_ack
+            auto_ack = consumer_info.auto_ack
 
             consumer_info.state = _ConsumerInfo.TEARING_DOWN
 
             with _CallbackResult() as cancel_ok_result:
-                # Nack pending messages for no_ack=False consumer
-                if not no_ack:
+                # Nack pending messages for auto_ack=False consumer
+                if not auto_ack:
                     pending_messages = self._remove_pending_deliveries(
                         consumer_tag)
                     if pending_messages:
@@ -1698,7 +1700,7 @@ class BlockingChannel(object):
                                                     requeue=True)
 
                 # Cancel the consumer; impl takes care of rejecting any
-                # additional deliveries that arrive for a no_ack=False
+                # additional deliveries that arrive for a auto_ack=False
                 # consumer
                 self._impl.basic_cancel(
                     consumer_tag=consumer_tag,
@@ -1710,8 +1712,8 @@ class BlockingChannel(object):
                     cancel_ok_result.is_ready,
                     lambda: consumer_tag not in self._impl._consumers)
 
-            if no_ack:
-                # Return pending messages for no_ack=True consumer
+            if auto_ack:
+                # Return pending messages for auto_ack=True consumer
                 return [
                     (evt.method, evt.properties, evt.body)
                     for evt in self._remove_pending_deliveries(consumer_tag)]
@@ -1795,7 +1797,7 @@ class BlockingChannel(object):
         else:
             self._cancel_all_consumers()
 
-    def consume(self, queue, no_ack=False,
+    def consume(self, queue, auto_ack=False,
                 exclusive=False, arguments=None,
                 inactivity_timeout=None):
         """Blocking consumption of a queue instead of via a callback. This
@@ -1813,13 +1815,13 @@ class BlockingChannel(object):
         generator loop.
 
         If you don't cancel this consumer, then next call on the same channel
-        to `consume()` with the exact same (queue, no_ack, exclusive) parameters
+        to `consume()` with the exact same (queue, auto_ack, exclusive) parameters
         will resume the existing consumer generator; however, calling with
         different parameters will result in an exception.
 
         :param queue: The queue name to consume
         :type queue: str or unicode
-        :param bool no_ack: Tell the broker to not expect a ack/nack response
+        :param bool auto_ack: Tell the broker to not expect a ack/nack response
         :param bool exclusive: Don't allow other consumers on the queue
         :param dict arguments: Custom key/value pair arguments for the consumer
         :param float inactivity_timeout: if a number is given (in
@@ -1837,7 +1839,7 @@ class BlockingChannel(object):
             of the existing queue consumer generator, if any.
             NEW in pika 0.10.0
         """
-        params = (queue, no_ack, exclusive)
+        params = (queue, auto_ack, exclusive)
 
         if self._queue_consumer_generator is not None:
             if params != self._queue_consumer_generator.params:
@@ -1846,7 +1848,7 @@ class BlockingChannel(object):
                     'queue consumer generator; previous params: %r; '
                     'new params: %r'
                     % (self._queue_consumer_generator.params,
-                       (queue, no_ack, exclusive)))
+                       (queue, auto_ack, exclusive)))
         else:
             LOGGER.debug('Creating new queue consumer generator; params: %r',
                          params)
@@ -1862,7 +1864,7 @@ class BlockingChannel(object):
             try:
                 self._basic_consume_impl(
                     queue=queue,
-                    no_ack=no_ack,
+                    auto_ack=auto_ack,
                     exclusive=exclusive,
                     consumer_tag=consumer_tag,
                     arguments=arguments,
@@ -1948,8 +1950,8 @@ class BlockingChannel(object):
             return 0
 
         try:
-            _, no_ack, _ = self._queue_consumer_generator.params
-            if not no_ack:
+            _, auto_ack, _ = self._queue_consumer_generator.params
+            if not auto_ack:
                 # Reject messages held by queue consumer generator; NOTE: we
                 # can't use basic_nack with the multiple option to avoid nacking
                 # messages already held by our client.
@@ -1965,7 +1967,7 @@ class BlockingChannel(object):
 
         # Return 0 for compatibility with legacy implementation; the number of
         # nacked messages is not meaningful since only messages consumed with
-        # no_ack=False may be nacked, and those arriving after calling
+        # auto_ack=False may be nacked, and those arriving after calling
         # basic_cancel will be rejected automatically by impl channel, so we'll
         # never know how many of those were nacked.
         return 0
@@ -2013,13 +2015,13 @@ class BlockingChannel(object):
                               requeue=requeue)
         self._flush_output()
 
-    def basic_get(self, queue, no_ack=False):
+    def basic_get(self, queue, auto_ack=False):
         """Get a single message from the AMQP broker. Returns a sequence with
         the method frame, message properties, and body.
 
         :param queue: Name of queue from which to get a message
         :type queue: str or unicode
-        :param bool no_ack: Tell the broker to not expect a reply
+        :param bool auto_ack: Tell the broker to not expect a reply
         :returns: a three-tuple; (None, None, None) if the queue was empty;
             otherwise (method, properties, body); NOTE: body may be None
         :rtype: (None, None, None)|(spec.Basic.GetOk,
@@ -2027,11 +2029,12 @@ class BlockingChannel(object):
                                     str or unicode or None)
         """
         assert not self._basic_getempty_result
+
         # NOTE: nested with for python 2.6 compatibility
         with _CallbackResult(self._RxMessageArgs) as get_ok_result:
             with self._basic_getempty_result:
                 self._impl.basic_get(queue=queue,
-                                     no_ack=no_ack,
+                                     auto_ack=auto_ack,
                                      callback=get_ok_result.set_value_once)
                 self._flush_output(get_ok_result.is_ready,
                                    self._basic_getempty_result.is_ready)
diff --git a/pika/channel.py b/pika/channel.py
index 5299d15..335a1b9 100644
--- a/pika/channel.py
+++ b/pika/channel.py
@@ -263,7 +263,7 @@ class Channel(object):
     def basic_consume(self,
                       queue,
                       on_message_callback,
-                      no_ack=False,
+                      auto_ack=False,
                       exclusive=False,
                       consumer_tag=None,
                       arguments=None,
@@ -287,8 +287,10 @@ class Channel(object):
                                 method: pika.spec.Basic.Deliver
                                 properties: pika.spec.BasicProperties
                                 body: str, unicode, or bytes (python 3.x)
-        :param bool no_ack: if set to True, automatic acknowledgement mode will be used
-                            (see http://www.rabbitmq.com/confirms.html)
+        :param bool auto_ack: if set to True, automatic acknowledgement mode will be used
+                              (see http://www.rabbitmq.com/confirms.html). This corresponds
+                              with the 'no_ack' parameter in the basic.consume AMQP 0.9.1
+                              method
         :param bool exclusive: Don't allow other consumers on the queue
         :param consumer_tag: Specify your own consumer tag
         :type consumer_tag: str or unicode
@@ -310,7 +312,7 @@ class Channel(object):
         if consumer_tag in self._consumers or consumer_tag in self._cancelled:
             raise exceptions.DuplicateConsumerTag(consumer_tag)
 
-        if no_ack:
+        if auto_ack:
             self._consumers_with_noack.add(consumer_tag)
 
         self._consumers[consumer_tag] = on_message_callback
@@ -319,11 +321,11 @@ class Channel(object):
 
         self._rpc(spec.Basic.Consume(queue=queue,
                                      consumer_tag=consumer_tag,
-                                     no_ack=no_ack,
+                                     no_ack=auto_ack,
                                      exclusive=exclusive,
                                      arguments=arguments or dict()),
                   rpc_callback, [(spec.Basic.ConsumeOk,
-                                 {'consumer_tag': consumer_tag})])
+                                  {'consumer_tag': consumer_tag})])
 
         return consumer_tag
 
@@ -339,7 +341,7 @@ class Channel(object):
         return 'ctag%i.%s' % (self.channel_number,
                               uuid.uuid4().hex)
 
-    def basic_get(self, queue, callback, no_ack=False):
+    def basic_get(self, queue, callback, auto_ack=False):
         """Get a single message from the AMQP broker. If you want to
         be notified of Basic.GetEmpty, use the Channel.add_callback method
         adding your Basic.GetEmpty callback which should expect only one
@@ -359,7 +361,7 @@ class Channel(object):
             method: pika.spec.Basic.GetOk
             properties: pika.spec.BasicProperties
             body: str, unicode, or bytes (python 3.x)
-        :param bool no_ack: Tell the broker to not expect a reply
+        :param bool auto_ack: Tell the broker to not expect a reply
         :raises ValueError:
 
         """
@@ -367,11 +369,12 @@ class Channel(object):
         if self._on_getok_callback is not None:
             raise exceptions.DuplicateGetOkCallback()
         self._on_getok_callback = callback
+
         # pylint: disable=W0511
         # TODO Strangely, not using _rpc for the synchronous Basic.Get. Would
         # need to extend _rpc to handle Basic.GetOk method, header, and body
         # frames (or similar)
-        self._send_method(spec.Basic.Get(queue=queue, no_ack=no_ack))
+        self._send_method(spec.Basic.Get(queue=queue, no_ack=auto_ack))
 
     def basic_nack(self, delivery_tag=None, multiple=False, requeue=True):
         """This method allows a client to reject one or more incoming messages.
@@ -1421,6 +1424,12 @@ class Channel(object):
                 'Completion callback must be callable if not None')
 
     def _validate_zero_or_greater(self, name, value):
+        """Verify that value is zero or greater. If not, 'name'
+        will be used in error message
+
+        :raises: ValueError
+
+        """
         if int(value) < 0:
             errmsg = '{} must be >= 0, but got {}'.format(name, value)
             raise ValueError(errmsg)


Test patch:
diff --git a/tests/acceptance/async_adapter_tests.py b/tests/acceptance/async_adapter_tests.py
index 81a8c3c..70220a8 100644
--- a/tests/acceptance/async_adapter_tests.py
+++ b/tests/acceptance/async_adapter_tests.py
@@ -94,7 +94,7 @@ class TestConsumeCancel(AsyncTestCase, AsyncAdapters):
             self.channel.basic_publish('', self.queue_name, msg_body)
         self.ctag = self.channel.basic_consume(self.queue_name,
                                                self.on_message,
-                                               no_ack=True)
+                                               auto_ack=True)
 
     def on_message(self, _channel, _frame, _header, body):
         self.channel.basic_cancel(self.ctag, callback=self.on_cancel)
diff --git a/tests/acceptance/blocking_adapter_test.py b/tests/acceptance/blocking_adapter_test.py
index 7628f89..c6e3125 100644
--- a/tests/acceptance/blocking_adapter_test.py
+++ b/tests/acceptance/blocking_adapter_test.py
@@ -208,8 +208,8 @@ class TestCreateAndCloseConnectionWithChannelAndConsumer(BlockingTestCaseBase):
         # Publish the message to the queue by way of default exchange
         ch.publish(exchange='', routing_key=q_name, body=body1)
 
-        # Create a non-ackable consumer
-        ch.basic_consume(q_name, lambda *x: None, no_ack=True,
+        # Create a consumer that uses automatic ack mode
+        ch.basic_consume(q_name, lambda *x: None, auto_ack=True,
                          exclusive=False, arguments=None)
 
         connection.close()
@@ -804,7 +804,7 @@ class TestBasicGet(BlockingTestCaseBase):
         LOGGER.info('%s DECLARED QUEUE (%s)', datetime.utcnow(), self)
 
         # Verify result of getting a message from an empty queue
-        msg = ch.basic_get(q_name, no_ack=False)
+        msg = ch.basic_get(q_name, auto_ack=False)
         self.assertTupleEqual(msg, (None, None, None))
         LOGGER.info('%s GOT FROM EMPTY QUEUE (%s)', datetime.utcnow(), self)
 
@@ -816,7 +816,7 @@ class TestBasicGet(BlockingTestCaseBase):
         LOGGER.info('%s PUBLISHED (%s)', datetime.utcnow(), self)
 
         # Get the message
-        (method, properties, body) = ch.basic_get(q_name, no_ack=False)
+        (method, properties, body) = ch.basic_get(q_name, auto_ack=False)
         LOGGER.info('%s GOT FROM NON-EMPTY QUEUE (%s)', datetime.utcnow(), self)
         self.assertIsInstance(method, pika.spec.Basic.GetOk)
         self.assertEqual(method.delivery_tag, 1)
@@ -867,10 +867,10 @@ class TestBasicReject(BlockingTestCaseBase):
                    mandatory=True)
 
         # Get the messages
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body, as_bytes('TestBasicReject1'))
 
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body, as_bytes('TestBasicReject2'))
 
         # Nack the second message
@@ -881,7 +881,7 @@ class TestBasicReject(BlockingTestCaseBase):
         self._assert_exact_message_count_with_retries(channel=ch,
                                                       queue=q_name,
                                                       expected_count=1)
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body, as_bytes('TestBasicReject2'))
 
 
@@ -913,11 +913,11 @@ class TestBasicRejectNoRequeue(BlockingTestCaseBase):
                    mandatory=True)
 
         # Get the messages
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body,
                          as_bytes('TestBasicRejectNoRequeue1'))
 
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body,
                          as_bytes('TestBasicRejectNoRequeue2'))
 
@@ -958,10 +958,10 @@ class TestBasicNack(BlockingTestCaseBase):
                    mandatory=True)
 
         # Get the messages
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body, as_bytes('TestBasicNack1'))
 
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body, as_bytes('TestBasicNack2'))
 
         # Nack the second message
@@ -972,7 +972,7 @@ class TestBasicNack(BlockingTestCaseBase):
         self._assert_exact_message_count_with_retries(channel=ch,
                                                       queue=q_name,
                                                       expected_count=1)
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body, as_bytes('TestBasicNack2'))
 
 
@@ -1004,11 +1004,11 @@ class TestBasicNackNoRequeue(BlockingTestCaseBase):
                    mandatory=True)
 
         # Get the messages
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body,
                          as_bytes('TestBasicNackNoRequeue1'))
 
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body,
                          as_bytes('TestBasicNackNoRequeue2'))
 
@@ -1049,11 +1049,11 @@ class TestBasicNackMultiple(BlockingTestCaseBase):
                    mandatory=True)
 
         # Get the messages
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body,
                          as_bytes('TestBasicNackMultiple1'))
 
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body,
                          as_bytes('TestBasicNackMultiple2'))
 
@@ -1064,10 +1064,10 @@ class TestBasicNackMultiple(BlockingTestCaseBase):
         self._assert_exact_message_count_with_retries(channel=ch,
                                                       queue=q_name,
                                                       expected_count=2)
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body,
                          as_bytes('TestBasicNackMultiple1'))
-        (rx_method, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (rx_method, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body,
                          as_bytes('TestBasicNackMultiple2'))
 
@@ -1106,7 +1106,7 @@ class TestBasicRecoverWithRequeue(BlockingTestCaseBase):
 
         rx_messages = []
         num_messages = 0
-        for msg in ch.consume(q_name, no_ack=False):
+        for msg in ch.consume(q_name, auto_ack=False):
             num_messages += 1
 
             if num_messages == 2:
@@ -1164,7 +1164,7 @@ class TestTxCommit(BlockingTestCaseBase):
         frame = ch.queue_declare(q_name, passive=True)
         self.assertEqual(frame.method.message_count, 1)
 
-        (_, _, rx_body) = ch.basic_get(q_name, no_ack=False)
+        (_, _, rx_body) = ch.basic_get(q_name, auto_ack=False)
         self.assertEqual(rx_body, as_bytes('TestTxCommit1'))
 
 
@@ -1567,7 +1567,7 @@ class TestPublishAndConsumeWithPubacksAndQosOfOne(BlockingTestCaseBase):
         consumer_tag = ch.basic_consume(
             q_name,
             lambda *args: rx_messages.append(args),
-            no_ack=False,
+            auto_ack=False,
             exclusive=False,
             arguments=None)
 
@@ -1695,7 +1695,7 @@ class TestTwoBasicConsumersOnSameChannel(BlockingTestCaseBase):
         q1_consumer_tag = ch.basic_consume(
             q1_name,
             lambda *args: q1_rx_messages.append(args),
-            no_ack=False,
+            auto_ack=False,
             exclusive=False,
             arguments=None)
 
@@ -1703,7 +1703,7 @@ class TestTwoBasicConsumersOnSameChannel(BlockingTestCaseBase):
         q2_consumer_tag = ch.basic_consume(
             q2_name,
             lambda *args: q2_rx_messages.append(args),
-            no_ack=False,
+            auto_ack=False,
             exclusive=False,
             arguments=None)
 
@@ -1852,7 +1852,7 @@ class TestBasicPublishWithoutPubacks(BlockingTestCaseBase):
         consumer_tag = ch.basic_consume(
             q_name,
             lambda *args: rx_messages.append(args),
-            no_ack=False,
+            auto_ack=False,
             exclusive=False,
             arguments=None)
 
@@ -1959,12 +1959,12 @@ class TestPublishFromBasicConsumeCallback(BlockingTestCaseBase):
 
         ch.basic_consume(src_q_name,
                          on_consume,
-                         no_ack=False,
+                         auto_ack=False,
                          exclusive=False,
                          arguments=None)
 
         # Consume from destination queue
-        for _, _, rx_body in ch.consume(dest_q_name, no_ack=True):
+        for _, _, rx_body in ch.consume(dest_q_name, auto_ack=True):
             self.assertEqual(rx_body, as_bytes('via-publish'))
             break
         else:
@@ -2009,7 +2009,7 @@ class TestStopConsumingFromBasicConsumeCallback(BlockingTestCaseBase):
 
         ch.basic_consume(q_name,
                          on_consume,
-                         no_ack=False,
+                         auto_ack=False,
                          exclusive=False,
                          arguments=None)
 
@@ -2064,7 +2064,7 @@ class TestCloseChannelFromBasicConsumeCallback(BlockingTestCaseBase):
 
         ch.basic_consume(q_name,
                          on_consume,
-                         no_ack=False,
+                         auto_ack=False,
                          exclusive=False,
                          arguments=None)
 
@@ -2118,7 +2118,7 @@ class TestCloseConnectionFromBasicConsumeCallback(BlockingTestCaseBase):
 
         ch.basic_consume(q_name,
                          on_consume,
-                         no_ack=False,
+                         auto_ack=False,
                          exclusive=False,
                          arguments=None)
 
@@ -2156,7 +2156,7 @@ class TestNonPubAckPublishAndConsumeHugeMessage(BlockingTestCaseBase):
         LOGGER.info('Published message body size=%s', len(body))
 
         # Consume the message
-        for rx_method, rx_props, rx_body in ch.consume(q_name, no_ack=False,
+        for rx_method, rx_props, rx_body in ch.consume(q_name, auto_ack=False,
                                                        exclusive=False,
                                                        arguments=None):
             self.assertIsInstance(rx_method, pika.spec.Basic.Deliver)
@@ -2209,7 +2209,7 @@ class TestNonPubackPublishAndConsumeManyMessages(BlockingTestCaseBase):
         # Consume the messages
         num_consumed = 0
         for rx_method, rx_props, rx_body in ch.consume(q_name,
-                                                       no_ack=False,
+                                                       auto_ack=False,
                                                        exclusive=False,
                                                        arguments=None):
             num_consumed += 1
@@ -2269,8 +2269,8 @@ class TestBasicCancelWithNonAckableConsumer(BlockingTestCaseBase):
                                                       queue=q_name,
                                                       expected_count=2)
 
-        # Create a non-ackable consumer
-        consumer_tag = ch.basic_consume(q_name, lambda *x: None, no_ack=True,
+        # Create a consumer that uses automatic ack mode
+        consumer_tag = ch.basic_consume(q_name, lambda *x: None, auto_ack=True,
                                         exclusive=False, arguments=None)
 
         # Wait for all messages to be sent by broker to client
@@ -2327,7 +2327,7 @@ class TestBasicCancelWithAckableConsumer(BlockingTestCaseBase):
                                                       expected_count=2)
 
         # Create an ackable consumer
-        consumer_tag = ch.basic_consume(q_name, lambda *x: None, no_ack=False,
+        consumer_tag = ch.basic_consume(q_name, lambda *x: None, auto_ack=False,
                                         exclusive=False, arguments=None)
 
         # Wait for all messages to be sent by broker to client
@@ -2376,7 +2376,7 @@ class TestUnackedMessageAutoRestoredToQueueOnChannelClose(BlockingTestCaseBase):
         # Consume the events, but don't ack
         rx_messages = []
         ch.basic_consume(q_name, lambda *args: rx_messages.append(args),
-                         no_ack=False, exclusive=False, arguments=None)
+                         auto_ack=False, exclusive=False, arguments=None)
         while len(rx_messages) != 2:
             connection.process_data_events(time_limit=None)
 
@@ -2422,7 +2422,7 @@ class TestNoAckMessageNotRestoredToQueueOnChannelClose(BlockingTestCaseBase):
 
         # Consume, but don't ack
         num_messages = 0
-        for rx_method, _, _ in ch.consume(q_name, no_ack=True, exclusive=False):
+        for rx_method, _, _ in ch.consume(q_name, auto_ack=True, exclusive=False):
             num_messages += 1
 
             self.assertEqual(rx_method.delivery_tag, num_messages)
diff --git a/tests/unit/channel_tests.py b/tests/unit/channel_tests.py
index 67e0325..0ba24cf 100644
--- a/tests/unit/channel_tests.py
+++ b/tests/unit/channel_tests.py
@@ -330,7 +330,7 @@ class ChannelTests(unittest.TestCase):
         expectation = spec.Basic.Consume(
             queue='test-queue',
             consumer_tag=consumer_tag,
-            no_ack=False,
+            auto_ack=False,
             exclusive=False)
         rpc.assert_called_once_with(expectation, self.obj._on_eventok,
                                     [(spec.Basic.ConsumeOk, {
@@ -350,7 +350,7 @@ class ChannelTests(unittest.TestCase):
         expectation = spec.Basic.Consume(
             queue='test-queue',
             consumer_tag=consumer_tag,
-            no_ack=False,
+            auto_ack=False,
             exclusive=False)
         rpc.assert_called_once_with(expectation, mock_callback,
                                     [(spec.Basic.ConsumeOk, {
@@ -378,7 +378,16 @@ class ChannelTests(unittest.TestCase):
         mock_callback = mock.Mock()
         self.obj.basic_get('test-queue', mock_callback)
         send_method.assert_called_once_with(
-            spec.Basic.Get(queue='test-queue', no_ack=False))
+            spec.Basic.Get(queue='test-queue', auto_ack=False))
+
+    @mock.patch('pika.spec.Basic.Get')
+    @mock.patch('pika.channel.Channel._send_method')
+    def test_basic_get_send_method_called_auto_ack(self, send_method, _unused):
+        self.obj._set_state(self.obj.OPEN)
+        mock_callback = mock.Mock()
+        self.obj.basic_get('test-queue', mock_callback, auto_ack=True)
+        send_method.assert_called_once_with(
+            spec.Basic.Get(queue='test-queue', auto_ack=True))
 
     def test_basic_nack_raises_channel_closed(self):
         self.assertRaises(exceptions.ChannelClosed, self.obj.basic_nack, 0,