Merge branch 'sqs-deletion-test' of git://github.com/toastdriven/boto into toastdriven-sqs-deletion-test

3 files changed, 53 insertions, 33 deletions

diff --git a/boto/sqs/connection.py b/boto/sqs/connection.py
index d993064a..e076de12 100644
--- a/boto/sqs/connection.py
+++ b/boto/sqs/connection.py
@@ -100,12 +100,8 @@ class SQSConnection(AWSQueryConnection):
         :param queue: The SQS queue to be deleted
 
         :type force_deletion: Boolean
-        :param force_deletion: Normally, SQS will not delete a queue
-            that contains messages.  However, if the force_deletion
-            argument is True, the queue will be deleted regardless of
-            whether there are messages in the queue or not.  USE WITH
-            CAUTION.  This will delete all messages in the queue as
-            well.
+        :param force_deletion: A deprecated parameter that is no longer used by
+            SQS's API.
 
         :rtype: bool
         :return: True if the command succeeded, False otherwise
diff --git a/docs/source/sqs_tut.rst b/docs/source/sqs_tut.rst
index 9445de26..452dc7c3 100644
--- a/docs/source/sqs_tut.rst
+++ b/docs/source/sqs_tut.rst
@@ -217,7 +217,7 @@ If I want to delete the entire queue, I would use:
 
 >>> conn.delete_queue(q)
 
-However, and this is a good safe guard, this won't succeed unless the queue is empty.
+This will delete the queue, even if there are still messages within the queue.
 
 Additional Information
 ----------------------
diff --git a/tests/integration/sqs/test_connection.py b/tests/integration/sqs/test_connection.py
index 611d5219..9b2ab59a 100644
--- a/tests/integration/sqs/test_connection.py
+++ b/tests/integration/sqs/test_connection.py
@@ -30,6 +30,7 @@ from threading import Timer
 from tests.unit import unittest
 
 from boto.sqs.connection import SQSConnection
+from boto.sqs.message import Message
 from boto.sqs.message import MHMessage
 from boto.exception import SQSError
 
@@ -56,17 +57,18 @@ class SQSConnectionTest(unittest.TestCase):
         # now create one that should work and should be unique (i.e. a new one)
         queue_name = 'test%d' % int(time.time())
         timeout = 60
-        queue = c.create_queue(queue_name, timeout)
+        queue_1 = c.create_queue(queue_name, timeout)
+        self.addCleanup(c.delete_queue, queue_1, True)
         time.sleep(60)
         rs = c.get_all_queues()
         i = 0
         for q in rs:
             i += 1
         assert i == num_queues + 1
-        assert queue.count_slow() == 0
+        assert queue_1.count_slow() == 0
 
         # check the visibility timeout
-        t = queue.get_timeout()
+        t = queue_1.get_timeout()
         assert t == timeout, '%d != %d' % (t, timeout)
 
         # now try to get queue attributes
@@ -82,75 +84,73 @@ class SQSConnectionTest(unittest.TestCase):
 
         # now change the visibility timeout
         timeout = 45
-        queue.set_timeout(timeout)
+        queue_1.set_timeout(timeout)
         time.sleep(60)
-        t = queue.get_timeout()
+        t = queue_1.get_timeout()
         assert t == timeout, '%d != %d' % (t, timeout)
 
         # now add a message
         message_body = 'This is a test\n'
-        message = queue.new_message(message_body)
-        queue.write(message)
+        message = queue_1.new_message(message_body)
+        queue_1.write(message)
         time.sleep(60)
-        assert queue.count_slow() == 1
+        assert queue_1.count_slow() == 1
         time.sleep(90)
 
         # now read the message from the queue with a 10 second timeout
-        message = queue.read(visibility_timeout=10)
+        message = queue_1.read(visibility_timeout=10)
         assert message
         assert message.get_body() == message_body
 
         # now immediately try another read, shouldn't find anything
-        message = queue.read()
+        message = queue_1.read()
         assert message == None
 
         # now wait 30 seconds and try again
         time.sleep(30)
-        message = queue.read()
+        message = queue_1.read()
         assert message
 
         # now delete the message
-        queue.delete_message(message)
+        queue_1.delete_message(message)
         time.sleep(30)
-        assert queue.count_slow() == 0
+        assert queue_1.count_slow() == 0
 
         # try a batch write
         num_msgs = 10
         msgs = [(i, 'This is message %d' % i, 0) for i in range(num_msgs)]
-        queue.write_batch(msgs)
+        queue_1.write_batch(msgs)
 
         # try to delete all of the messages using batch delete
         deleted = 0
         while deleted < num_msgs:
             time.sleep(5)
-            msgs = queue.get_messages(num_msgs)
+            msgs = queue_1.get_messages(num_msgs)
             if msgs:
-                br = queue.delete_message_batch(msgs)
+                br = queue_1.delete_message_batch(msgs)
                 deleted += len(br.results)
 
         # create another queue so we can test force deletion
         # we will also test MHMessage with this queue
         queue_name = 'test%d' % int(time.time())
         timeout = 60
-        queue = c.create_queue(queue_name, timeout)
-        queue.set_message_class(MHMessage)
+        queue_2 = c.create_queue(queue_name, timeout)
+        self.addCleanup(c.delete_queue, queue_2, True)
+        queue_2.set_message_class(MHMessage)
         time.sleep(30)
 
         # now add a couple of messages
-        message = queue.new_message()
+        message = queue_2.new_message()
         message['foo'] = 'bar'
-        queue.write(message)
+        queue_2.write(message)
         message_body = {'fie': 'baz', 'foo': 'bar'}
-        message = queue.new_message(body=message_body)
-        queue.write(message)
+        message = queue_2.new_message(body=message_body)
+        queue_2.write(message)
         time.sleep(30)
 
-        m = queue.read()
+        m = queue_2.read()
         assert m['foo'] == 'bar'
 
-        # now delete that queue and messages
-        c.delete_queue(queue, True)
-
         print '--- tests completed ---'
 
     def test_sqs_timeout(self):
@@ -215,3 +215,27 @@ class SQSConnectionTest(unittest.TestCase):
         # we're giving +- .5 seconds for the total time the queue
         # was blocked on the read call.
         self.assertTrue(4.5 <= (end - start) <= 5.5)
+
+    def test_queue_deletion_affects_full_queues(self):
+        conn = SQSConnection()
+        initial_count = len(conn.get_all_queues())
+
+        empty = conn.create_queue('empty%d' % int(time.time()))
+        full = conn.create_queue('full%d' % int(time.time()))
+        time.sleep(60)
+        # Make sure they're both around.
+        self.assertEqual(len(conn.get_all_queues()), initial_count + 2)
+
+        # Put a message in the full queue.
+        m1 = Message()
+        m1.set_body('This is a test message.')
+        full.write(m1)
+        self.assertEqual(full.count(), 1)
+
+        self.assertTrue(conn.delete_queue(empty))
+        # Here's the regression for the docs. SQS will delete a queue with
+        # messages in it, no ``force_deletion`` needed.
+        self.assertTrue(conn.delete_queue(full))
+        # Wait long enough for SQS to finally remove the queues.
+        time.sleep(90)
+        self.assertEqual(len(conn.get_all_queues()), initial_count)