diff --git a/zaqar/tests/unit/transport/wsgi/v1_1/test_messages.py b/zaqar/tests/unit/transport/wsgi/v1_1/test_messages.py
index 8ae4beb92..01710d468 100644
--- a/zaqar/tests/unit/transport/wsgi/v1_1/test_messages.py
+++ b/zaqar/tests/unit/transport/wsgi/v1_1/test_messages.py
@@ -46,7 +46,7 @@ class TestMessagesMongoDB(base.V1_1Base):
                 doc = {'weight': 100, 'uri': uri}
                 self.simulate_put(self.url_prefix + '/pools/' + str(i),
                                   body=jsonutils.dumps(doc))
-                self.assertEqual(self.srmock.status, falcon.HTTP_201)
+                self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
         self.project_id = '7e55e1a7e'
         self.headers = {
@@ -81,27 +81,27 @@ class TestMessagesMongoDB(base.V1_1Base):
 
         self.simulate_post(messages_path % 'Nice-Boat_2',
                            body=sample_doc, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
         self.simulate_post(messages_path % 'Nice-Bo@t',
                            body=sample_doc, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
         self.simulate_post(messages_path % ('_niceboat' * 8),
                            body=sample_doc, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def _test_post(self, sample_messages):
         sample_doc = jsonutils.dumps({'messages': sample_messages})
 
         result = self.simulate_post(self.messages_path,
                                     body=sample_doc, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
         result_doc = jsonutils.loads(result[0])
 
         msg_ids = self._get_msg_ids(self.srmock.headers_dict)
-        self.assertEqual(len(msg_ids), len(sample_messages))
+        self.assertEqual(len(sample_messages), len(msg_ids))
 
         expected_resources = [six.text_type(self.messages_path + '/' + id)
                               for id in msg_ids]
@@ -111,7 +111,7 @@ class TestMessagesMongoDB(base.V1_1Base):
         # in the response document.
         self.assertNotIn('partial', result_doc)
 
-        self.assertEqual(len(msg_ids), len(sample_messages))
+        self.assertEqual(len(sample_messages), len(msg_ids))
 
         lookup = dict([(m['ttl'], m['body']) for m in sample_messages])
 
@@ -128,16 +128,16 @@ class TestMessagesMongoDB(base.V1_1Base):
                 headers['X-Project-ID'] = '777777'
                 # Wrong project ID
                 self.simulate_get(message_uri, headers=headers)
-                self.assertEqual(self.srmock.status, falcon.HTTP_404)
+                self.assertEqual(falcon.HTTP_404, self.srmock.status)
 
                 # Correct project ID
                 result = self.simulate_get(message_uri, headers=self.headers)
-                self.assertEqual(self.srmock.status, falcon.HTTP_200)
+                self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
                 # Check message properties
                 message = jsonutils.loads(result[0])
-                self.assertEqual(message['href'], message_uri)
-                self.assertEqual(message['body'], lookup[message['ttl']])
+                self.assertEqual(message_uri, message['href'])
+                self.assertEqual(lookup[message['ttl']], message['body'])
                 self.assertEqual(msg_id, message['id'])
 
                 # no negative age
@@ -151,7 +151,7 @@ class TestMessagesMongoDB(base.V1_1Base):
                                    query_string=query_string,
                                    headers=self.headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
         result_doc = jsonutils.loads(result[0])
         expected_ttls = set(m['ttl'] for m in sample_messages)
         actual_ttls = set(m['ttl'] for m in result_doc['messages'])
@@ -169,21 +169,21 @@ class TestMessagesMongoDB(base.V1_1Base):
         self.simulate_get(self.messages_path,
                           query_string=query_string, headers=self.headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
         # Listing restriction
         self.simulate_get(self.messages_path,
                           query_string='limit=21',
                           headers=self.headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
         # Bulk deletion restriction
         query_string = 'ids=' + ','.join([msg_id] * 22)
         self.simulate_delete(self.messages_path,
                              query_string=query_string, headers=self.headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_post_single(self):
         sample_messages = [
@@ -215,7 +215,7 @@ class TestMessagesMongoDB(base.V1_1Base):
         result = self.simulate_post(self.messages_path,
                                     body=sample_doc, headers=self.headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
         result_doc = jsonutils.loads(result[0])
 
         href = result_doc['resources'][0]
@@ -235,7 +235,7 @@ class TestMessagesMongoDB(base.V1_1Base):
             path = path.encode('utf-8')
 
         self._post_messages(path)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_post_with_long_queue_name(self):
         # NOTE(kgriffs): This test verifies that routes with
@@ -249,24 +249,24 @@ class TestMessagesMongoDB(base.V1_1Base):
             self.simulate_delete, queues_path + game_title,
             headers=self.headers)
         self._post_messages(queues_path + game_title + '/messages')
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
         game_title += 'v'
         self._post_messages(queues_path + game_title + '/messages')
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_post_to_missing_queue(self):
         self.addCleanup(
             self.simulate_delete, self.url_prefix + '/queues/nonexistent',
             headers=self.headers)
         self._post_messages(self.url_prefix + '/queues/nonexistent/messages')
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
     def test_get_from_missing_queue(self):
         body = self.simulate_get(self.url_prefix +
                                  '/queues/nonexistent/messages',
                                  headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
         self._empty_message_list(body)
 
     @ddt.data('', '0xdeadbeef', '550893e0-2b6e-11e3-835a-5cf9dd72369')
@@ -275,13 +275,13 @@ class TestMessagesMongoDB(base.V1_1Base):
                            body='{"ttl": 60, "body": ""}',
                            headers={'Client-ID': text_id})
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
         self.simulate_get(self.queue_path + '/messages',
                           query_string='limit=3&echo=true',
                           headers={'Client-ID': text_id})
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     @ddt.data(None, '[', '[]', '{}', '.')
     def test_post_bad_message(self, document):
@@ -289,7 +289,7 @@ class TestMessagesMongoDB(base.V1_1Base):
                            body=document,
                            headers=self.headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     @ddt.data(-1, 59, 1209601)
     def test_unacceptable_ttl(self, ttl):
@@ -299,7 +299,7 @@ class TestMessagesMongoDB(base.V1_1Base):
                            body=jsonutils.dumps(doc),
                            headers=self.headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_exceeded_message_posting(self):
         # Total (raw request) size
@@ -313,7 +313,7 @@ class TestMessagesMongoDB(base.V1_1Base):
                            body=long_body,
                            headers=self.headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     @ddt.data('{"overflow": 9223372036854775808}',
               '{"underflow": -9223372036854775809}')
@@ -322,7 +322,7 @@ class TestMessagesMongoDB(base.V1_1Base):
                            body=document,
                            headers=self.headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_delete(self):
         self._post_messages(self.messages_path)
@@ -330,17 +330,17 @@ class TestMessagesMongoDB(base.V1_1Base):
         target = self.messages_path + '/' + msg_id
 
         self.simulate_get(target, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         self.simulate_delete(target, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
         self.simulate_get(target, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_404)
+        self.assertEqual(falcon.HTTP_404, self.srmock.status)
 
         # Safe to delete non-existing ones
         self.simulate_delete(target, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
     def test_bulk_delete(self):
         path = self.queue_path + '/messages'
@@ -349,24 +349,24 @@ class TestMessagesMongoDB(base.V1_1Base):
 
         # Deleting the whole collection is denied
         self.simulate_delete(path, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
         self.simulate_delete(target, query_string=params, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
         self.simulate_get(target, query_string=params, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_404)
+        self.assertEqual(falcon.HTTP_404, self.srmock.status)
 
         # Safe to delete non-existing ones
         self.simulate_delete(target, query_string=params, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
         # Even after the queue is gone
         self.simulate_delete(self.queue_path, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
         self.simulate_delete(target, query_string=params, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
     def test_list(self):
         path = self.queue_path + '/messages'
@@ -377,7 +377,7 @@ class TestMessagesMongoDB(base.V1_1Base):
                                  query_string=query_string,
                                  headers=self.headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         cnt = 0
         while jsonutils.loads(body[0])['messages'] != []:
@@ -386,21 +386,21 @@ class TestMessagesMongoDB(base.V1_1Base):
 
             for msg in contents['messages']:
                 self.simulate_get(msg['href'], headers=self.headers)
-                self.assertEqual(self.srmock.status, falcon.HTTP_200)
+                self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
             body = self.simulate_get(target,
                                      query_string=params,
                                      headers=self.headers)
             cnt += 1
 
-        self.assertEqual(cnt, 4)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(4, cnt)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
         self._empty_message_list(body)
 
         # Stats
         body = self.simulate_get(self.queue_path + '/stats',
                                  headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         message_stats = jsonutils.loads(body[0])['messages']
 
@@ -415,7 +415,7 @@ class TestMessagesMongoDB(base.V1_1Base):
         body = self.simulate_get(self.url_prefix +
                                  '/queues/nonexistent/messages',
                                  headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
         self._empty_message_list(body)
 
     def test_list_with_bad_marker(self):
@@ -427,7 +427,7 @@ class TestMessagesMongoDB(base.V1_1Base):
                                  query_string=query_string,
                                  headers=self.headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
         self._empty_message_list(body)
 
     def test_no_uuid(self):
@@ -440,10 +440,10 @@ class TestMessagesMongoDB(base.V1_1Base):
         self.simulate_post(path, body='[{"body": 0, "ttl": 100}]',
                            headers=headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
         self.simulate_get(path, headers=headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_get_claimed_contains_claim_id_in_href(self):
         path = self.queue_path
@@ -455,7 +455,7 @@ class TestMessagesMongoDB(base.V1_1Base):
         self.simulate_post(path + '/claims',
                            body='{"ttl": 100, "grace": 100}',
                            headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
         for url in jsonutils.loads(res[0])['resources']:
             message = self.simulate_get(url)
             self.assertIn('claim_id', jsonutils.loads(message[0])['href'])
@@ -469,36 +469,36 @@ class TestMessagesMongoDB(base.V1_1Base):
         self.simulate_post(path + '/claims',
                            body='{"ttl": 100, "grace": 100}',
                            headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
         location = self.srmock.headers_dict['location']
 
         # release claim
         self.simulate_delete(location, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
         # get unclaimed messages
         self.simulate_get(path + '/messages',
                           query_string='echo=true',
                           headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
     # NOTE(cpp-cabrera): regression test against bug #1203842
     def test_get_nonexistent_message_404s(self):
         path = self.url_prefix + '/queues/notthere/messages/a'
         self.simulate_get(path, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_404)
+        self.assertEqual(falcon.HTTP_404, self.srmock.status)
 
     def test_get_multiple_invalid_messages_404s(self):
         path = self.url_prefix + '/queues/notthere/messages'
         self.simulate_get(path, query_string='ids=a,b,c',
                           headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_404)
+        self.assertEqual(falcon.HTTP_404, self.srmock.status)
 
     def test_delete_multiple_invalid_messages_204s(self):
         path = self.url_prefix + '/queues/notthere/messages'
         self.simulate_delete(path, query_string='ids=a,b,c',
                              headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
     def test_delete_message_with_invalid_claim_doesnt_delete_message(self):
         path = self.queue_path
@@ -507,10 +507,10 @@ class TestMessagesMongoDB(base.V1_1Base):
 
         self.simulate_delete(location, query_string='claim_id=invalid',
                              headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
         self.simulate_get(location, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
     def test_no_duplicated_messages_path_in_href(self):
         """Test for bug 1240897."""
@@ -549,36 +549,36 @@ class TestMessagesMongoDB(base.V1_1Base):
         target = self.messages_path + '/' + msg_id
 
         self.simulate_get(target, self.project_id)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         query_string = 'pop=' + str(message_count)
         result = self.simulate_delete(self.messages_path, self.project_id,
                                       query_string=query_string)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         result_doc = jsonutils.loads(result[0])
 
-        self.assertEqual(len(result_doc['messages']), message_count)
+        self.assertEqual(message_count, len(result_doc['messages']))
 
         self.simulate_get(target, self.project_id)
-        self.assertEqual(self.srmock.status, falcon.HTTP_404)
+        self.assertEqual(falcon.HTTP_404, self.srmock.status)
 
     @ddt.data('', 'pop=1000000', 'pop=10&ids=1', 'pop=-1')
     def test_pop_invalid(self, query_string):
 
         self.simulate_delete(self.messages_path, self.project_id,
                              query_string=query_string)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_pop_empty_queue(self):
 
         query_string = 'pop=1'
         result = self.simulate_delete(self.messages_path, self.project_id,
                                       query_string=query_string)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         result_doc = jsonutils.loads(result[0])
-        self.assertEqual(result_doc['messages'], [])
+        self.assertEqual([], result_doc['messages'])
 
     def test_pop_single_message(self):
 
@@ -587,13 +587,13 @@ class TestMessagesMongoDB(base.V1_1Base):
         target = self.messages_path + '/' + msg_id
 
         self.simulate_get(target, self.project_id)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         # Pop Single message from the queue
         query_string = 'pop=1'
         result = self.simulate_delete(self.messages_path, self.project_id,
                                       query_string=query_string)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         # Get messages from the queue & verify message count
         query_string = 'echo=True'
@@ -603,7 +603,7 @@ class TestMessagesMongoDB(base.V1_1Base):
         result_doc = jsonutils.loads(result[0])
         actual_msg_count = len(result_doc['messages'])
         expected_msg_count = 4
-        self.assertEqual(actual_msg_count, expected_msg_count)
+        self.assertEqual(expected_msg_count, actual_msg_count)
 
 
 class TestMessagesMongoDBPooled(TestMessagesMongoDB):
@@ -630,14 +630,14 @@ class TestMessagesFaultyDriver(base.V1_1BaseFaulty):
         self.simulate_post(path,
                            body=body,
                            headers=headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_503)
+        self.assertEqual(falcon.HTTP_503, self.srmock.status)
 
         self.simulate_get(path,
                           headers=headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_503)
+        self.assertEqual(falcon.HTTP_503, self.srmock.status)
 
         self.simulate_get(path + '/nonexistent', headers=headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_503)
+        self.assertEqual(falcon.HTTP_503, self.srmock.status)
 
         self.simulate_delete(path + '/nada', headers=headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_503)
+        self.assertEqual(falcon.HTTP_503, self.srmock.status)
diff --git a/zaqar/tests/unit/transport/wsgi/v1_1/test_ping.py b/zaqar/tests/unit/transport/wsgi/v1_1/test_ping.py
index 0594f67e5..abbbdb675 100644
--- a/zaqar/tests/unit/transport/wsgi/v1_1/test_ping.py
+++ b/zaqar/tests/unit/transport/wsgi/v1_1/test_ping.py
@@ -29,10 +29,10 @@ class TestPing(base.V1_1Base):
         #     response = self.simulate_get('/ping')
         #
         response = self.simulate_get('/v1.1/ping')
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
-        self.assertEqual(response, [])
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
+        self.assertEqual([], response)
 
     def test_head(self):
         response = self.simulate_head('/v1.1/ping')
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
-        self.assertEqual(response, [])
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
+        self.assertEqual([], response)
diff --git a/zaqar/tests/unit/transport/wsgi/v1_1/test_pools.py b/zaqar/tests/unit/transport/wsgi/v1_1/test_pools.py
index 488487401..b995a1015 100644
--- a/zaqar/tests/unit/transport/wsgi/v1_1/test_pools.py
+++ b/zaqar/tests/unit/transport/wsgi/v1_1/test_pools.py
@@ -95,28 +95,28 @@ class TestPoolsMongoDB(base.V1_1Base):
                     'uri': self.mongodb_url}
         self.pool = self.url_prefix + '/pools/' + str(uuid.uuid1())
         self.simulate_put(self.pool, body=jsonutils.dumps(self.doc))
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
     def tearDown(self):
         super(TestPoolsMongoDB, self).tearDown()
         self.simulate_delete(self.pool)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
     def test_put_pool_works(self):
         name = str(uuid.uuid1())
         weight, uri = self.doc['weight'], self.doc['uri']
         with pool(self, name, weight, uri, group='my-group'):
-            self.assertEqual(self.srmock.status, falcon.HTTP_201)
+            self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
     def test_put_raises_if_missing_fields(self):
         path = self.url_prefix + '/pools/' + str(uuid.uuid1())
         self.simulate_put(path, body=jsonutils.dumps({'weight': 100}))
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
         self.simulate_put(path,
                           body=jsonutils.dumps(
                               {'uri': self.mongodb_url}))
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     @ddt.data(-1, 2**32+1, 'big')
     def test_put_raises_if_invalid_weight(self, weight):
@@ -124,40 +124,40 @@ class TestPoolsMongoDB(base.V1_1Base):
         doc = {'weight': weight, 'uri': 'a'}
         self.simulate_put(path,
                           body=jsonutils.dumps(doc))
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     @ddt.data(-1, 2**32+1, [], 'localhost:27017')
     def test_put_raises_if_invalid_uri(self, uri):
         path = self.url_prefix + '/pools/' + str(uuid.uuid1())
         self.simulate_put(path,
                           body=jsonutils.dumps({'weight': 1, 'uri': uri}))
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     @ddt.data(-1, 'wee', [])
     def test_put_raises_if_invalid_options(self, options):
         path = self.url_prefix + '/pools/' + str(uuid.uuid1())
         doc = {'weight': 1, 'uri': 'a', 'options': options}
         self.simulate_put(path, body=jsonutils.dumps(doc))
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_put_existing_overwrites(self):
         # NOTE(cabrera): setUp creates default pool
         expect = self.doc
         self.simulate_put(self.pool,
                           body=jsonutils.dumps(expect))
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
         result = self.simulate_get(self.pool)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
         doc = jsonutils.loads(result[0])
-        self.assertEqual(doc['weight'], expect['weight'])
-        self.assertEqual(doc['uri'], expect['uri'])
+        self.assertEqual(expect['weight'], doc['weight'])
+        self.assertEqual(expect['uri'], doc['uri'])
 
     def test_put_capabilities_mismatch_pool(self):
         mongodb_doc = self.doc
         self.simulate_put(self.pool,
                           body=jsonutils.dumps(mongodb_doc))
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
         redis_doc = {'weight': 100,
                      'group': 'mygroup',
@@ -165,25 +165,25 @@ class TestPoolsMongoDB(base.V1_1Base):
 
         self.simulate_put(self.pool,
                           body=jsonutils.dumps(redis_doc))
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_delete_works(self):
         self.simulate_delete(self.pool)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
         self.simulate_get(self.pool)
-        self.assertEqual(self.srmock.status, falcon.HTTP_404)
+        self.assertEqual(falcon.HTTP_404, self.srmock.status)
 
     def test_get_nonexisting_raises_404(self):
         self.simulate_get(self.url_prefix + '/pools/nonexisting')
-        self.assertEqual(self.srmock.status, falcon.HTTP_404)
+        self.assertEqual(falcon.HTTP_404, self.srmock.status)
 
     def _pool_expect(self, pool, xhref, xweight, xuri):
         self.assertIn('href', pool)
         self.assertIn('name', pool)
-        self.assertEqual(pool['href'], xhref)
+        self.assertEqual(xhref, pool['href'])
         self.assertIn('weight', pool)
-        self.assertEqual(pool['weight'], xweight)
+        self.assertEqual(xweight, pool['weight'])
         self.assertIn('uri', pool)
 
         # NOTE(dynarro): we are using startwith because we are adding to
@@ -192,7 +192,7 @@ class TestPoolsMongoDB(base.V1_1Base):
 
     def test_get_works(self):
         result = self.simulate_get(self.pool)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
         pool = jsonutils.loads(result[0])
         self._pool_expect(pool, self.pool, self.doc['weight'],
                           self.doc['uri'])
@@ -200,30 +200,30 @@ class TestPoolsMongoDB(base.V1_1Base):
     def test_detailed_get_works(self):
         result = self.simulate_get(self.pool,
                                    query_string='detailed=True')
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
         pool = jsonutils.loads(result[0])
         self._pool_expect(pool, self.pool, self.doc['weight'],
                           self.doc['uri'])
         self.assertIn('options', pool)
-        self.assertEqual(pool['options'], {})
+        self.assertEqual({}, pool['options'])
 
     def test_patch_raises_if_missing_fields(self):
         self.simulate_patch(self.pool,
                             body=jsonutils.dumps({'location': 1}))
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def _patch_test(self, doc):
         self.simulate_patch(self.pool,
                             body=jsonutils.dumps(doc))
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         result = self.simulate_get(self.pool,
                                    query_string='detailed=True')
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
         pool = jsonutils.loads(result[0])
         self._pool_expect(pool, self.pool, doc['weight'],
                           doc['uri'])
-        self.assertEqual(pool['options'], doc['options'])
+        self.assertEqual(doc['options'], pool['options'])
 
     def test_patch_works(self):
         doc = {'weight': 101,
@@ -242,30 +242,30 @@ class TestPoolsMongoDB(base.V1_1Base):
     def test_patch_raises_400_on_invalid_weight(self, weight):
         self.simulate_patch(self.pool,
                             body=jsonutils.dumps({'weight': weight}))
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     @ddt.data(-1, 2**32+1, [], 'localhost:27017')
     def test_patch_raises_400_on_invalid_uri(self, uri):
         self.simulate_patch(self.pool,
                             body=jsonutils.dumps({'uri': uri}))
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     @ddt.data(-1, 'wee', [])
     def test_patch_raises_400_on_invalid_options(self, options):
         self.simulate_patch(self.pool,
                             body=jsonutils.dumps({'options': options}))
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_patch_raises_404_if_pool_not_found(self):
         self.simulate_patch(self.url_prefix + '/pools/notexists',
                             body=jsonutils.dumps({'weight': 1}))
-        self.assertEqual(self.srmock.status, falcon.HTTP_404)
+        self.assertEqual(falcon.HTTP_404, self.srmock.status)
 
     def test_empty_listing(self):
         self.simulate_delete(self.pool)
         result = self.simulate_get(self.url_prefix + '/pools')
         results = jsonutils.loads(result[0])
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
         self.assertTrue(len(results['pools']) == 0)
         self.assertIn('links', results)
 
@@ -281,7 +281,7 @@ class TestPoolsMongoDB(base.V1_1Base):
         with pools(self, count, self.doc['uri'], 'my-group') as expected:
             result = self.simulate_get(self.url_prefix + '/pools',
                                        query_string=query)
-            self.assertEqual(self.srmock.status, falcon.HTTP_200)
+            self.assertEqual(falcon.HTTP_200, self.srmock.status)
             results = jsonutils.loads(result[0])
             self.assertIsInstance(results, dict)
             self.assertIn('pools', results)
@@ -292,28 +292,28 @@ class TestPoolsMongoDB(base.V1_1Base):
             self.assertEqual('next', link['rel'])
             href = falcon.uri.parse_query_string(link['href'].split('?')[1])
             self.assertIn('marker', href)
-            self.assertEqual(href['limit'], str(limit))
-            self.assertEqual(href['detailed'], str(detailed).lower())
+            self.assertEqual(str(limit), href['limit'])
+            self.assertEqual(str(detailed).lower(), href['detailed'])
 
             next_query_string = ('marker={marker}&limit={limit}'
                                  '&detailed={detailed}').format(**href)
             next_result = self.simulate_get(link['href'].split('?')[0],
                                             query_string=next_query_string)
-            self.assertEqual(self.srmock.status, falcon.HTTP_200)
+            self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
             next_pool = jsonutils.loads(next_result[0])
             next_pool_list = next_pool['pools']
 
             self.assertIn('links', next_pool)
             if limit < count:
-                self.assertEqual(len(next_pool_list),
-                                 min(limit, count-limit))
+                self.assertEqual(min(limit, count-limit),
+                                 len(next_pool_list))
             else:
                 # NOTE(jeffrey4l): when limit >= count, there will be no
                 # pools in the 2nd page.
                 self.assertTrue(len(next_pool_list) == 0)
 
-            self.assertEqual(len(pool_list), min(limit, count))
+            self.assertEqual(min(limit, count), len(pool_list))
             for s in pool_list + next_pool_list:
                 # NOTE(flwang): It can't assumed that both sqlalchemy and
                 # mongodb can return query result with the same order. Just
@@ -346,8 +346,8 @@ class TestPoolsMongoDB(base.V1_1Base):
         with pools(self, 10, self.doc['uri'], 'my-group') as expected:
             result = self.simulate_get(self.url_prefix + '/pools',
                                        query_string='marker=3')
-            self.assertEqual(self.srmock.status, falcon.HTTP_200)
+            self.assertEqual(falcon.HTTP_200, self.srmock.status)
             pool_list = jsonutils.loads(result[0])['pools']
-            self.assertEqual(len(pool_list), 6)
+            self.assertEqual(6, len(pool_list))
             path, weight = expected[4][:2]
             self._pool_expect(pool_list[0], path, weight, self.doc['uri'])
diff --git a/zaqar/tests/unit/transport/wsgi/v1_1/test_queue_lifecycle.py b/zaqar/tests/unit/transport/wsgi/v1_1/test_queue_lifecycle.py
index e887b5515..3ddcc1301 100644
--- a/zaqar/tests/unit/transport/wsgi/v1_1/test_queue_lifecycle.py
+++ b/zaqar/tests/unit/transport/wsgi/v1_1/test_queue_lifecycle.py
@@ -59,10 +59,10 @@ class TestQueueLifecycleMongoDB(base.V1_1Base):
         }
 
         self.simulate_put(self.gumshoe_queue_path, headers=headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
         self.simulate_delete(self.gumshoe_queue_path, headers=headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     @ddt.data('480924', 'foo')
     def test_basics_thoroughly(self, project_id):
@@ -74,48 +74,48 @@ class TestQueueLifecycleMongoDB(base.V1_1Base):
 
         # Stats are empty - queue not created yet
         self.simulate_get(gumshoe_queue_path_stats, headers=headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         # Create
         doc = '{"messages": {"ttl": 600}}'
         self.simulate_put(self.gumshoe_queue_path,
                           headers=headers, body=doc)
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
         location = self.srmock.headers_dict['Location']
-        self.assertEqual(location, self.gumshoe_queue_path)
+        self.assertEqual(self.gumshoe_queue_path, location)
 
         # Fetch metadata
         result = self.simulate_get(self.gumshoe_queue_path,
                                    headers=headers)
         result_doc = jsonutils.loads(result[0])
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
-        self.assertEqual(result_doc, jsonutils.loads(doc))
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
+        self.assertEqual(jsonutils.loads(doc), result_doc)
 
         # Stats empty queue
         self.simulate_get(gumshoe_queue_path_stats, headers=headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         # Delete
         self.simulate_delete(self.gumshoe_queue_path, headers=headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
         # Get non-existent stats
         self.simulate_get(gumshoe_queue_path_stats, headers=headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
     def test_name_restrictions(self):
         self.simulate_put(self.queue_path + '/Nice-Boat_2',
                           headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
         self.simulate_put(self.queue_path + '/Nice-Bo@t',
                           headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
         self.simulate_put(self.queue_path + '/_' + 'niceboat' * 8,
                           headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_project_id_restriction(self):
         muvluv_queue_path = self.queue_path + '/Muv-Luv'
@@ -123,13 +123,13 @@ class TestQueueLifecycleMongoDB(base.V1_1Base):
         self.simulate_put(muvluv_queue_path,
                           headers={'Client-ID': str(uuid.uuid4()),
                                    'X-Project-ID': 'JAM Project' * 24})
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
         # no charset restrictions
         self.simulate_put(muvluv_queue_path,
                           headers={'Client-ID': str(uuid.uuid4()),
                                    'X-Project-ID': 'JAM Project'})
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
     def test_non_ascii_name(self):
         test_params = ((u'/queues/non-ascii-n\u0153me', 'utf-8'),
@@ -142,30 +142,30 @@ class TestQueueLifecycleMongoDB(base.V1_1Base):
                 uri = uri.encode(enc)
 
             self.simulate_put(uri, headers=self.headers)
-            self.assertEqual(self.srmock.status, falcon.HTTP_400)
+            self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
             self.simulate_delete(uri, headers=self.headers)
-            self.assertEqual(self.srmock.status, falcon.HTTP_400)
+            self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_no_metadata(self):
         self.simulate_put(self.fizbat_queue_path,
                           headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
         self.simulate_put(self.fizbat_queue_path, body='',
                           headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
     @ddt.data('{', '[]', '.', '  ')
     def test_bad_metadata(self, document):
         self.simulate_put(self.fizbat_queue_path,
                           headers=self.headers,
                           body=document)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_too_much_metadata(self):
         self.simulate_put(self.fizbat_queue_path, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
         doc = '{{"messages": {{"ttl": 600}}, "padding": "{pad}"}}'
 
         max_size = self.transport_cfg.max_queue_metadata
@@ -176,11 +176,11 @@ class TestQueueLifecycleMongoDB(base.V1_1Base):
         self.simulate_put(self.fizbat_queue_path,
                           headers=self.headers,
                           body=doc)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_way_too_much_metadata(self):
         self.simulate_put(self.fizbat_queue_path, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
         doc = '{{"messages": {{"ttl": 600}}, "padding": "{pad}"}}'
 
         max_size = self.transport_cfg.max_queue_metadata
@@ -190,7 +190,7 @@ class TestQueueLifecycleMongoDB(base.V1_1Base):
 
         self.simulate_put(self.fizbat_queue_path,
                           headers=self.headers, body=doc)
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_custom_metadata(self):
         # Set
@@ -203,14 +203,14 @@ class TestQueueLifecycleMongoDB(base.V1_1Base):
         self.simulate_put(self.fizbat_queue_path,
                           headers=self.headers,
                           body=doc)
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
         # Get
         result = self.simulate_get(self.fizbat_queue_path,
                                    headers=self.headers)
         result_doc = jsonutils.loads(result[0])
-        self.assertEqual(result_doc, jsonutils.loads(doc))
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(jsonutils.loads(doc), result_doc)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
     def test_update_metadata(self):
         self.skip("This should use patch instead")
@@ -219,28 +219,28 @@ class TestQueueLifecycleMongoDB(base.V1_1Base):
 
         # Create
         self.simulate_put(xyz_queue_path, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
         # Set meta
         doc1 = '{"messages": {"ttl": 600}}'
         self.simulate_put(xyz_queue_path_metadata,
                           headers=self.headers,
                           body=doc1)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
         # Update
         doc2 = '{"messages": {"ttl": 100}}'
         self.simulate_put(xyz_queue_path_metadata,
                           headers=self.headers,
                           body=doc2)
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
         # Get
         result = self.simulate_get(xyz_queue_path_metadata,
                                    headers=self.headers)
         result_doc = jsonutils.loads(result[0])
 
-        self.assertEqual(result_doc, jsonutils.loads(doc2))
+        self.assertEqual(jsonutils.loads(doc2), result_doc)
 
     def test_list(self):
         arbitrary_number = 644079696574693
@@ -258,16 +258,16 @@ class TestQueueLifecycleMongoDB(base.V1_1Base):
 
         # List empty
         result = self.simulate_get(self.queue_path, headers=header)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
         results = jsonutils.loads(result[0])
-        self.assertEqual(results['queues'], [])
+        self.assertEqual([], results['queues'])
         self.assertIn('links', results)
-        self.assertEqual(len(results['links']), 0)
+        self.assertEqual(0, len(results['links']))
 
         # Payload exceeded
         self.simulate_get(self.queue_path, headers=header,
                           query_string='limit=21')
-        self.assertEqual(self.srmock.status, falcon.HTTP_400)
+        self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
         # Create some
         def create_queue(name, project_id, body):
@@ -288,7 +288,7 @@ class TestQueueLifecycleMongoDB(base.V1_1Base):
                                    query_string='limit=2')
 
         result_doc = jsonutils.loads(result[0])
-        self.assertEqual(len(result_doc['queues']), 2)
+        self.assertEqual(2, len(result_doc['queues']))
 
         # List (no metadata, get all)
         result = self.simulate_get(self.queue_path,
@@ -297,33 +297,33 @@ class TestQueueLifecycleMongoDB(base.V1_1Base):
         result_doc = jsonutils.loads(result[0])
         [target, params] = result_doc['links'][0]['href'].split('?')
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         # Ensure we didn't pick up the queue from the alt project.
         queues = result_doc['queues']
-        self.assertEqual(len(queues), 3)
+        self.assertEqual(3, len(queues))
 
         # List with metadata
         result = self.simulate_get(self.queue_path, headers=header,
                                    query_string='detailed=true')
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
         result_doc = jsonutils.loads(result[0])
         [target, params] = result_doc['links'][0]['href'].split('?')
 
         queue = result_doc['queues'][0]
         result = self.simulate_get(queue['href'], headers=header)
         result_doc = jsonutils.loads(result[0])
-        self.assertEqual(result_doc, queue['metadata'])
-        self.assertEqual(result_doc, {'node': 31})
+        self.assertEqual(queue['metadata'], result_doc)
+        self.assertEqual({'node': 31}, result_doc)
 
         # List tail
         self.simulate_get(target, headers=header, query_string=params)
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
         # List manually-constructed tail
         self.simulate_get(target, headers=header, query_string='marker=zzz')
-        self.assertEqual(self.srmock.status, falcon.HTTP_200)
+        self.assertEqual(falcon.HTTP_200, self.srmock.status)
 
 
 class TestQueueLifecycleFaultyDriver(base.V1_1BaseFaulty):
@@ -341,7 +341,7 @@ class TestQueueLifecycleFaultyDriver(base.V1_1BaseFaulty):
         self.simulate_put(gumshoe_queue_path,
                           headers=self.headers,
                           body=doc)
-        self.assertEqual(self.srmock.status, falcon.HTTP_503)
+        self.assertEqual(falcon.HTTP_503, self.srmock.status)
 
         location = ('Location', gumshoe_queue_path)
         self.assertNotIn(location, self.srmock.headers)
@@ -349,16 +349,16 @@ class TestQueueLifecycleFaultyDriver(base.V1_1BaseFaulty):
         result = self.simulate_get(gumshoe_queue_path,
                                    headers=self.headers)
         result_doc = jsonutils.loads(result[0])
-        self.assertEqual(self.srmock.status, falcon.HTTP_503)
+        self.assertEqual(falcon.HTTP_503, self.srmock.status)
         self.assertNotEqual(result_doc, jsonutils.loads(doc))
 
         self.simulate_get(gumshoe_queue_path + '/stats',
                           headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_503)
+        self.assertEqual(falcon.HTTP_503, self.srmock.status)
 
         self.simulate_get(self.url_prefix + '/queues',
                           headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_503)
+        self.assertEqual(falcon.HTTP_503, self.srmock.status)
 
         self.simulate_delete(gumshoe_queue_path, headers=self.headers)
-        self.assertEqual(self.srmock.status, falcon.HTTP_503)
+        self.assertEqual(falcon.HTTP_503, self.srmock.status)
diff --git a/zaqar/tests/unit/transport/wsgi/v1_1/test_validation.py b/zaqar/tests/unit/transport/wsgi/v1_1/test_validation.py
index f4f84e9da..e79ce3587 100644
--- a/zaqar/tests/unit/transport/wsgi/v1_1/test_validation.py
+++ b/zaqar/tests/unit/transport/wsgi/v1_1/test_validation.py
@@ -47,7 +47,7 @@ class TestValidation(base.V1_1Base):
                           self.project_id,
                           body='{"timespace": "Shangri-la"}')
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_204)
+        self.assertEqual(falcon.HTTP_204, self.srmock.status)
 
         # Too long
         max_queue_metadata = 64
@@ -63,7 +63,7 @@ class TestValidation(base.V1_1Base):
                               self.project_id,
                               body=doc)
 
-            self.assertEqual(self.srmock.status, falcon.HTTP_400)
+            self.assertEqual(falcon.HTTP_400, self.srmock.status)
 
     def test_message_deserialization(self):
         # Normal case
@@ -72,7 +72,7 @@ class TestValidation(base.V1_1Base):
                            self.project_id, body=body,
                            headers=self.headers)
 
-        self.assertEqual(self.srmock.status, falcon.HTTP_201)
+        self.assertEqual(falcon.HTTP_201, self.srmock.status)
 
         # Both messages' size are too long
         max_messages_post_size = 256
@@ -88,4 +88,4 @@ class TestValidation(base.V1_1Base):
                                body=doc,
                                headers=self.headers)
 
-            self.assertEqual(self.srmock.status, falcon.HTTP_400)
+            self.assertEqual(falcon.HTTP_400, self.srmock.status)