diff --git a/manila/tests/api/contrib/test_admin_actions.py b/manila/tests/api/contrib/test_admin_actions.py
index 16e269c035..d02d288555 100644
--- a/manila/tests/api/contrib/test_admin_actions.py
+++ b/manila/tests/api/contrib/test_admin_actions.py
@@ -129,7 +129,7 @@ class AdminActionsTest(test.TestCase):
         resp = req.get_response(app())
 
         # validate response code and model status
-        self.assertEqual(resp.status_int, valid_code)
+        self.assertEqual(valid_code, resp.status_int)
 
         if valid_code == 404:
             self.assertRaises(exception.NotFound,
@@ -138,7 +138,7 @@ class AdminActionsTest(test.TestCase):
                               model['id'])
         else:
             actual_model = db_access_method(ctxt, model['id'])
-            self.assertEqual(actual_model['status'], valid_status)
+            self.assertEqual(valid_status, actual_model['status'])
 
     @ddt.data(*fixture_reset_status_with_different_roles)
     @ddt.unpack
@@ -233,7 +233,7 @@ class AdminActionsTest(test.TestCase):
         resp = req.get_response(app())
 
         # validate response
-        self.assertEqual(resp.status_int, valid_code)
+        self.assertEqual(valid_code, resp.status_int)
 
         if valid_code == 202 and check_model_in_db:
             self.assertRaises(exception.NotFound,
diff --git a/manila/tests/api/contrib/test_services.py b/manila/tests/api/contrib/test_services.py
index 110cd633aa..21507ba032 100644
--- a/manila/tests/api/contrib/test_services.py
+++ b/manila/tests/api/contrib/test_services.py
@@ -196,7 +196,7 @@ class ServicesTest(test.TestCase):
     def test_services_list(self):
         req = FakeRequest()
         res_dict = self.controller.index(req)
-        self.assertEqual(res_dict, fake_response_service_list)
+        self.assertEqual(fake_response_service_list, res_dict)
 
     def test_services_list_with_host(self):
         req = FakeRequestWithHost()
@@ -206,7 +206,7 @@ class ServicesTest(test.TestCase):
             fake_response_service_list['services'][0],
             fake_response_service_list['services'][1],
         ]}
-        self.assertEqual(res_dict, response)
+        self.assertEqual(response, res_dict)
 
     def test_services_list_with_binary(self):
         req = FakeRequestWithBinary()
@@ -216,7 +216,7 @@ class ServicesTest(test.TestCase):
             fake_response_service_list['services'][3],
         ]}
 
-        self.assertEqual(res_dict, response)
+        self.assertEqual(response, res_dict)
 
     def test_services_list_with_zone(self):
         req = FakeRequestWithZone()
@@ -225,7 +225,7 @@ class ServicesTest(test.TestCase):
             fake_response_service_list['services'][0],
             fake_response_service_list['services'][1],
         ]}
-        self.assertEqual(res_dict, response)
+        self.assertEqual(response, res_dict)
 
     def test_services_list_with_status(self):
         req = FakeRequestWithStatus()
@@ -233,7 +233,7 @@ class ServicesTest(test.TestCase):
         response = {'services': [
             fake_response_service_list['services'][2],
         ]}
-        self.assertEqual(res_dict, response)
+        self.assertEqual(response, res_dict)
 
     def test_services_list_with_state(self):
         req = FakeRequestWithState()
@@ -242,22 +242,22 @@ class ServicesTest(test.TestCase):
             fake_response_service_list['services'][0],
             fake_response_service_list['services'][1],
         ]}
-        self.assertEqual(res_dict, response)
+        self.assertEqual(response, res_dict)
 
     def test_services_list_with_host_binary(self):
         req = FakeRequestWithHostBinary()
         res_dict = self.controller.index(req)
         response = {'services': [fake_response_service_list['services'][1], ]}
-        self.assertEqual(res_dict, response)
+        self.assertEqual(response, res_dict)
 
     def test_services_enable(self):
         body = {'host': 'host1', 'binary': 'manila-share'}
         req = fakes.HTTPRequest.blank('/v1/fake/os-services/enable')
         res_dict = self.controller.update(req, "enable", body)
-        self.assertEqual(res_dict['disabled'], False)
+        self.assertEqual(False, res_dict['disabled'])
 
     def test_services_disable(self):
         req = fakes.HTTPRequest.blank('/v1/fake/os-services/disable')
         body = {'host': 'host1', 'binary': 'manila-share'}
         res_dict = self.controller.update(req, "disable", body)
-        self.assertEqual(res_dict['disabled'], True)
+        self.assertTrue(res_dict['disabled'])
diff --git a/manila/tests/api/contrib/test_share_actions.py b/manila/tests/api/contrib/test_share_actions.py
index 2bd62dd988..8125a7a142 100644
--- a/manila/tests/api/contrib/test_share_actions.py
+++ b/manila/tests/api/contrib/test_share_actions.py
@@ -74,7 +74,7 @@ class ShareActionsTest(test.TestCase):
         expected = {'access': {'fake': 'fake'}}
         req = fakes.HTTPRequest.blank('/v1/tenant1/shares/%s/action' % id)
         res = self.controller._allow_access(req, id, body)
-        self.assertEqual(res, expected)
+        self.assertEqual(expected, res)
 
     @ddt.data(
         {'access_type': 'error_type', 'access_to': '127.0.0.1'},
@@ -108,7 +108,7 @@ class ShareActionsTest(test.TestCase):
         body = {"os-deny_access": {"access_id": 'fake_acces_id'}}
         req = fakes.HTTPRequest.blank('/v1/tenant1/shares/%s/action' % id)
         res = self.controller._deny_access(req, id, body)
-        self.assertEqual(res.status_int, 202)
+        self.assertEqual(202, res.status_int)
 
     def test_deny_access_not_found(self):
         def _stub_deny_access(*args, **kwargs):
@@ -140,7 +140,7 @@ class ShareActionsTest(test.TestCase):
         req = fakes.HTTPRequest.blank('/v1/tenant1/shares/%s/action' % id)
         res_dict = self.controller._access_list(req, id, body)
         expected = _fake_access_get_all()
-        self.assertEqual(res_dict['access_list'], expected)
+        self.assertEqual(expected, res_dict['access_list'])
 
     def test_extend(self):
         id = 'fake_share_id'
@@ -224,4 +224,4 @@ class ShareActionsTest(test.TestCase):
         self.mock_object(share_api.API, "shrink",
                          mock.Mock(side_effect=source('fake')))
 
-        self.assertRaises(target, self.controller._shrink, req, id, body)
\ No newline at end of file
+        self.assertRaises(target, self.controller._shrink, req, id, body)
diff --git a/manila/tests/api/contrib/test_types_extra_specs.py b/manila/tests/api/contrib/test_types_extra_specs.py
index bb1ba460fd..491feab80c 100644
--- a/manila/tests/api/contrib/test_types_extra_specs.py
+++ b/manila/tests/api/contrib/test_types_extra_specs.py
@@ -133,10 +133,10 @@ class ShareTypesExtraSpecsTest(test.TestCase):
         self.mock_object(manila.db, 'share_type_extra_specs_delete',
                          delete_share_type_extra_specs)
 
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
+        self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
         req = fakes.HTTPRequest.blank(self.api_path + '/key5')
         self.controller.delete(req, 1, 'key5')
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 1)
+        self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
 
     def test_delete_not_found(self):
         self.mock_object(manila.db, 'share_type_extra_specs_delete',
@@ -166,12 +166,12 @@ class ShareTypesExtraSpecsTest(test.TestCase):
         self.mock_object(
             manila.db, 'share_type_extra_specs_update_or_create',
             mock.Mock(return_value=return_create_share_type_extra_specs))
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
+        self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
         req = fakes.HTTPRequest.blank(self.api_path)
 
         res_dict = self.controller.create(req, 1, body)
 
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 1)
+        self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
         for k, v in data.items():
             self.assertIn(k, res_dict['extra_specs'])
             self.assertEqual(v, res_dict['extra_specs'][k])
@@ -185,7 +185,7 @@ class ShareTypesExtraSpecsTest(test.TestCase):
             mock.Mock(return_value=return_create_share_type_extra_specs))
         too_small_key = ""
         body = {"extra_specs": {too_small_key: "value"}}
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
+        self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
         req = fakes.HTTPRequest.blank(self.api_path)
 
         self.assertRaises(webob.exc.HTTPBadRequest,
@@ -200,7 +200,7 @@ class ShareTypesExtraSpecsTest(test.TestCase):
             mock.Mock(return_value=return_create_share_type_extra_specs))
         too_big_key = "k" * 256
         body = {"extra_specs": {too_big_key: "value"}}
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
+        self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
         req = fakes.HTTPRequest.blank(self.api_path)
 
         self.assertRaises(webob.exc.HTTPBadRequest,
@@ -215,7 +215,7 @@ class ShareTypesExtraSpecsTest(test.TestCase):
             mock.Mock(return_value=return_create_share_type_extra_specs))
         too_small_value = ""
         body = {"extra_specs": {"key": too_small_value}}
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
+        self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
         req = fakes.HTTPRequest.blank(self.api_path)
 
         self.assertRaises(webob.exc.HTTPBadRequest,
@@ -230,7 +230,7 @@ class ShareTypesExtraSpecsTest(test.TestCase):
             mock.Mock(return_value=return_create_share_type_extra_specs))
         too_big_value = "v" * 256
         body = {"extra_specs": {"key": too_big_value}}
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
+        self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
         req = fakes.HTTPRequest.blank(self.api_path)
 
         self.assertRaises(webob.exc.HTTPBadRequest,
@@ -251,11 +251,11 @@ class ShareTypesExtraSpecsTest(test.TestCase):
 
         body = get_extra_specs_dict({"other_alphanum.-_:": "value1"})
 
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
+        self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
 
         req = fakes.HTTPRequest.blank(self.api_path)
         res_dict = self.controller.create(req, 1, body)
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 1)
+        self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
         self.assertEqual(mock_return_value['key1'],
                          res_dict['extra_specs']['other_alphanum.-_:'])
         manila.db.share_type_extra_specs_update_or_create.\
@@ -278,12 +278,12 @@ class ShareTypesExtraSpecsTest(test.TestCase):
             "other3_alphanum.-_:": "value3"
         })
 
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
+        self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
         req = fakes.HTTPRequest.blank(self.api_path)
 
         res_dict = self.controller.create(req, 1, body)
 
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 1)
+        self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
         self.assertEqual(mock_return_value['key1'],
                          res_dict['extra_specs']['other_alphanum.-_:'])
         self.assertEqual(mock_return_value['key2'],
@@ -299,15 +299,15 @@ class ShareTypesExtraSpecsTest(test.TestCase):
             manila.db, 'share_type_extra_specs_update_or_create',
             mock.Mock(return_value=return_create_share_type_extra_specs))
         body = {DRIVER_HANDLES_SHARE_SERVERS: True}
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
+        self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
         req = fakes.HTTPRequest.blank(
             self.api_path + '/' + DRIVER_HANDLES_SHARE_SERVERS)
 
         res_dict = self.controller.update(
             req, 1, DRIVER_HANDLES_SHARE_SERVERS, body)
 
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 1)
-        self.assertEqual(True, res_dict[DRIVER_HANDLES_SHARE_SERVERS])
+        self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
+        self.assertTrue(res_dict[DRIVER_HANDLES_SHARE_SERVERS])
         manila.db.share_type_extra_specs_update_or_create.\
             assert_called_once_with(
                 req.environ['manila.context'], 1, body)
diff --git a/manila/tests/api/contrib/test_types_manage.py b/manila/tests/api/contrib/test_types_manage.py
index e979155eae..988629ecc1 100644
--- a/manila/tests/api/contrib/test_types_manage.py
+++ b/manila/tests/api/contrib/test_types_manage.py
@@ -102,22 +102,22 @@ class ShareTypesManageApiTest(test.TestCase):
 
     def test_share_types_delete(self):
         req = fakes.HTTPRequest.blank('/v2/fake/types/1')
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
+        self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
         self.controller._delete(req, 1)
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 1)
+        self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
 
     def test_share_types_delete_not_found(self):
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
+        self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
         req = fakes.HTTPRequest.blank('/v2/fake/types/777')
         self.assertRaises(webob.exc.HTTPNotFound, self.controller._delete,
                           req, '777')
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 1)
+        self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
 
     def test_share_types_with_volumes_destroy(self):
         req = fakes.HTTPRequest.blank('/v2/fake/types/1')
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0)
+        self.assertEqual(0, len(fake_notifier.NOTIFICATIONS))
         self.controller._delete(req, 1)
-        self.assertEqual(len(fake_notifier.NOTIFICATIONS), 1)
+        self.assertEqual(1, len(fake_notifier.NOTIFICATIONS))
 
     @ddt.data(make_create_body("share_type_1"),
               make_create_body(spec_driver_handles_share_servers="false"),
diff --git a/manila/tests/api/contrib/test_used_limits.py b/manila/tests/api/contrib/test_used_limits.py
index 23698d0fd7..7649c5e49b 100644
--- a/manila/tests/api/contrib/test_used_limits.py
+++ b/manila/tests/api/contrib/test_used_limits.py
@@ -58,5 +58,5 @@ class UsedLimitsTestCase(test.TestCase):
             self.controller.index(fake_req, res)
             abs_limits = res.obj['limits']['absolute']
             for used_limit, value in six.iteritems(abs_limits):
-                self.assertEqual(value,
-                                 limits[quota_map[used_limit]]['in_use'])
+                self.assertEqual(limits[quota_map[used_limit]]['in_use'],
+                                 value)
diff --git a/manila/tests/api/middleware/test_auth.py b/manila/tests/api/middleware/test_auth.py
index bc8e8a57c5..593a683b06 100644
--- a/manila/tests/api/middleware/test_auth.py
+++ b/manila/tests/api/middleware/test_auth.py
@@ -37,23 +37,23 @@ class TestManilaKeystoneContextMiddleware(test.TestCase):
 
     def test_no_user_or_user_id(self):
         response = self.request.get_response(self.middleware)
-        self.assertEqual(response.status, '401 Unauthorized')
+        self.assertEqual('401 Unauthorized', response.status)
 
     def test_user_only(self):
         self.request.headers['X_USER_ID'] = 'testuserid'
         response = self.request.get_response(self.middleware)
-        self.assertEqual(response.status, '200 OK')
-        self.assertEqual(self.context.user_id, 'testuserid')
+        self.assertEqual('200 OK', response.status)
+        self.assertEqual('testuserid', self.context.user_id)
 
     def test_user_id_only(self):
         self.request.headers['X_USER'] = 'testuser'
         response = self.request.get_response(self.middleware)
-        self.assertEqual(response.status, '200 OK')
-        self.assertEqual(self.context.user_id, 'testuser')
+        self.assertEqual('200 OK', response.status)
+        self.assertEqual('testuser', self.context.user_id)
 
     def test_user_id_trumps_user(self):
         self.request.headers['X_USER_ID'] = 'testuserid'
         self.request.headers['X_USER'] = 'testuser'
         response = self.request.get_response(self.middleware)
-        self.assertEqual(response.status, '200 OK')
-        self.assertEqual(self.context.user_id, 'testuserid')
+        self.assertEqual('200 OK', response.status)
+        self.assertEqual('testuserid', self.context.user_id)
diff --git a/manila/tests/api/middleware/test_faults.py b/manila/tests/api/middleware/test_faults.py
index 202d6853d9..44874974a8 100644
--- a/manila/tests/api/middleware/test_faults.py
+++ b/manila/tests/api/middleware/test_faults.py
@@ -52,7 +52,7 @@ class TestFaults(test.TestCase):
             }
             actual = jsonutils.loads(response.body)
 
-            self.assertEqual(response.content_type, "application/json")
+            self.assertEqual("application/json", response.content_type)
             self.assertEqual(expected, actual)
 
     def test_413_fault_json(self):
@@ -77,7 +77,7 @@ class TestFaults(test.TestCase):
             }
             actual = jsonutils.loads(response.body)
 
-            self.assertEqual(response.content_type, "application/json")
+            self.assertEqual("application/json", response.content_type)
             self.assertEqual(expected, actual)
 
     def test_raise(self):
@@ -88,8 +88,8 @@ class TestFaults(test.TestCase):
 
         req = webob.Request.blank('/.json')
         resp = req.get_response(raiser)
-        self.assertEqual(resp.content_type, "application/json")
-        self.assertEqual(resp.status_int, 404)
+        self.assertEqual("application/json", resp.content_type)
+        self.assertEqual(404, resp.status_int)
         self.assertTrue(six.b('whut?') in resp.body)
 
     def test_raise_403(self):
@@ -100,12 +100,12 @@ class TestFaults(test.TestCase):
 
         req = webob.Request.blank('/.json')
         resp = req.get_response(raiser)
-        self.assertEqual(resp.content_type, "application/json")
-        self.assertEqual(resp.status_int, 403)
+        self.assertEqual("application/json", resp.content_type)
+        self.assertEqual(403, resp.status_int)
         self.assertTrue(six.b('resizeNotAllowed') not in resp.body)
         self.assertTrue(six.b('forbidden') in resp.body)
 
     def test_fault_has_status_int(self):
         """Ensure the status_int is set correctly on faults."""
         fault = wsgi.Fault(webob.exc.HTTPBadRequest(explanation='what?'))
-        self.assertEqual(fault.status_int, 400)
+        self.assertEqual(400, fault.status_int)
diff --git a/manila/tests/api/test_common.py b/manila/tests/api/test_common.py
index 523d3fd210..8581008abb 100644
--- a/manila/tests/api/test_common.py
+++ b/manila/tests/api/test_common.py
@@ -47,27 +47,27 @@ class LimiterTest(test.TestCase):
     def test_limiter_offset_zero(self):
         """Test offset key works with 0."""
         req = webob.Request.blank('/?offset=0')
-        self.assertEqual(common.limited(self.tiny, req), self.tiny)
-        self.assertEqual(common.limited(self.small, req), self.small)
-        self.assertEqual(common.limited(self.medium, req), self.medium)
-        self.assertEqual(common.limited(self.large, req), self.large[:1000])
+        self.assertEqual(self.tiny, common.limited(self.tiny, req))
+        self.assertEqual(self.small, common.limited(self.small, req))
+        self.assertEqual(self.medium, common.limited(self.medium, req))
+        self.assertEqual(self.large[:1000], common.limited(self.large, req))
 
     def test_limiter_offset_medium(self):
         """Test offset key works with a medium sized number."""
         req = webob.Request.blank('/?offset=10')
-        self.assertEqual(common.limited(self.tiny, req), [])
-        self.assertEqual(common.limited(self.small, req), self.small[10:])
-        self.assertEqual(common.limited(self.medium, req), self.medium[10:])
-        self.assertEqual(common.limited(self.large, req), self.large[10:1010])
+        self.assertEqual([], common.limited(self.tiny, req))
+        self.assertEqual(self.small[10:], common.limited(self.small, req))
+        self.assertEqual(self.medium[10:], common.limited(self.medium, req))
+        self.assertEqual(self.large[10:1010], common.limited(self.large, req))
 
     def test_limiter_offset_over_max(self):
         """Test offset key works with a number over 1000 (max_limit)."""
         req = webob.Request.blank('/?offset=1001')
-        self.assertEqual(common.limited(self.tiny, req), [])
-        self.assertEqual(common.limited(self.small, req), [])
-        self.assertEqual(common.limited(self.medium, req), [])
+        self.assertEqual([], common.limited(self.tiny, req))
+        self.assertEqual([], common.limited(self.small, req))
+        self.assertEqual([], common.limited(self.medium, req))
         self.assertEqual(
-            common.limited(self.large, req), self.large[1001:2001])
+            self.large[1001:2001], common.limited(self.large, req))
 
     def test_limiter_offset_blank(self):
         """Test offset key works with a blank offset."""
@@ -84,61 +84,61 @@ class LimiterTest(test.TestCase):
     def test_limiter_nothing(self):
         """Test request with no offset or limit."""
         req = webob.Request.blank('/')
-        self.assertEqual(common.limited(self.tiny, req), self.tiny)
-        self.assertEqual(common.limited(self.small, req), self.small)
-        self.assertEqual(common.limited(self.medium, req), self.medium)
-        self.assertEqual(common.limited(self.large, req), self.large[:1000])
+        self.assertEqual(self.tiny, common.limited(self.tiny, req))
+        self.assertEqual(self.small, common.limited(self.small, req))
+        self.assertEqual(self.medium, common.limited(self.medium, req))
+        self.assertEqual(self.large[:1000], common.limited(self.large, req))
 
     def test_limiter_limit_zero(self):
         """Test limit of zero."""
         req = webob.Request.blank('/?limit=0')
-        self.assertEqual(common.limited(self.tiny, req), self.tiny)
-        self.assertEqual(common.limited(self.small, req), self.small)
-        self.assertEqual(common.limited(self.medium, req), self.medium)
-        self.assertEqual(common.limited(self.large, req), self.large[:1000])
+        self.assertEqual(self.tiny, common.limited(self.tiny, req))
+        self.assertEqual(self.small, common.limited(self.small, req))
+        self.assertEqual(self.medium, common.limited(self.medium, req))
+        self.assertEqual(self.large[:1000], common.limited(self.large, req))
 
     def test_limiter_limit_medium(self):
         """Test limit of 10."""
         req = webob.Request.blank('/?limit=10')
-        self.assertEqual(common.limited(self.tiny, req), self.tiny)
-        self.assertEqual(common.limited(self.small, req), self.small)
-        self.assertEqual(common.limited(self.medium, req), self.medium[:10])
-        self.assertEqual(common.limited(self.large, req), self.large[:10])
+        self.assertEqual(self.tiny, common.limited(self.tiny, req))
+        self.assertEqual(self.small, common.limited(self.small, req))
+        self.assertEqual(self.medium[:10], common.limited(self.medium, req))
+        self.assertEqual(self.large[:10], common.limited(self.large, req))
 
     def test_limiter_limit_over_max(self):
         """Test limit of 3000."""
         req = webob.Request.blank('/?limit=3000')
-        self.assertEqual(common.limited(self.tiny, req), self.tiny)
-        self.assertEqual(common.limited(self.small, req), self.small)
-        self.assertEqual(common.limited(self.medium, req), self.medium)
-        self.assertEqual(common.limited(self.large, req), self.large[:1000])
+        self.assertEqual(self.tiny, common.limited(self.tiny, req))
+        self.assertEqual(self.small, common.limited(self.small, req))
+        self.assertEqual(self.medium, common.limited(self.medium, req))
+        self.assertEqual(self.large[:1000], common.limited(self.large, req))
 
     def test_limiter_limit_and_offset(self):
         """Test request with both limit and offset."""
         items = list(range(2000))
         req = webob.Request.blank('/?offset=1&limit=3')
-        self.assertEqual(common.limited(items, req), items[1:4])
+        self.assertEqual(items[1:4], common.limited(items, req))
         req = webob.Request.blank('/?offset=3&limit=0')
-        self.assertEqual(common.limited(items, req), items[3:1003])
+        self.assertEqual(items[3:1003], common.limited(items, req))
         req = webob.Request.blank('/?offset=3&limit=1500')
-        self.assertEqual(common.limited(items, req), items[3:1003])
+        self.assertEqual(items[3:1003], common.limited(items, req))
         req = webob.Request.blank('/?offset=3000&limit=10')
-        self.assertEqual(common.limited(items, req), [])
+        self.assertEqual([], common.limited(items, req))
 
     def test_limiter_custom_max_limit(self):
         """Test a max_limit other than 1000."""
         items = list(range(2000))
         req = webob.Request.blank('/?offset=1&limit=3')
         self.assertEqual(
-            common.limited(items, req, max_limit=2000), items[1:4])
+            items[1:4], common.limited(items, req, max_limit=2000))
         req = webob.Request.blank('/?offset=3&limit=0')
         self.assertEqual(
-            common.limited(items, req, max_limit=2000), items[3:])
+            items[3:], common.limited(items, req, max_limit=2000))
         req = webob.Request.blank('/?offset=3&limit=2500')
         self.assertEqual(
-            common.limited(items, req, max_limit=2000), items[3:])
+            items[3:], common.limited(items, req, max_limit=2000))
         req = webob.Request.blank('/?offset=3000&limit=10')
-        self.assertEqual(common.limited(items, req, max_limit=2000), [])
+        self.assertEqual([], common.limited(items, req, max_limit=2000))
 
     def test_limiter_negative_limit(self):
         """Test a negative limit."""
@@ -163,19 +163,19 @@ class PaginationParamsTest(test.TestCase):
     def test_no_params(self):
         """Test no params."""
         req = webob.Request.blank('/')
-        self.assertEqual(common.get_pagination_params(req), {})
+        self.assertEqual({}, common.get_pagination_params(req))
 
     def test_valid_marker(self):
         """Test valid marker param."""
         req = webob.Request.blank(
             '/?marker=263abb28-1de6-412f-b00b-f0ee0c4333c2')
-        self.assertEqual(common.get_pagination_params(req),
-                         {'marker': '263abb28-1de6-412f-b00b-f0ee0c4333c2'})
+        self.assertEqual({'marker': '263abb28-1de6-412f-b00b-f0ee0c4333c2'},
+                         common.get_pagination_params(req))
 
     def test_valid_limit(self):
         """Test valid limit param."""
         req = webob.Request.blank('/?limit=10')
-        self.assertEqual(common.get_pagination_params(req), {'limit': 10})
+        self.assertEqual({'limit': 10}, common.get_pagination_params(req))
 
     def test_invalid_limit(self):
         """Test invalid limit param."""
@@ -187,8 +187,8 @@ class PaginationParamsTest(test.TestCase):
         """Test valid limit and marker parameters."""
         marker = '263abb28-1de6-412f-b00b-f0ee0c4333c2'
         req = webob.Request.blank('/?limit=20&marker=%s' % marker)
-        self.assertEqual(common.get_pagination_params(req),
-                         {'marker': marker, 'limit': 20})
+        self.assertEqual({'marker': marker, 'limit': 20},
+                         common.get_pagination_params(req))
 
 
 class MiscFunctionsTest(test.TestCase):
@@ -197,31 +197,31 @@ class MiscFunctionsTest(test.TestCase):
         fixture = 'http://www.testsite.com/v1/images'
         expected = 'http://www.testsite.com/images'
         actual = common.remove_version_from_href(fixture)
-        self.assertEqual(actual, expected)
+        self.assertEqual(expected, actual)
 
     def test_remove_version_from_href(self):
         fixture = 'http://www.testsite.com/v1.1/images'
         expected = 'http://www.testsite.com/images'
         actual = common.remove_version_from_href(fixture)
-        self.assertEqual(actual, expected)
+        self.assertEqual(expected, actual)
 
     def test_remove_version_from_href_2(self):
         fixture = 'http://www.testsite.com/v1.1/'
         expected = 'http://www.testsite.com/'
         actual = common.remove_version_from_href(fixture)
-        self.assertEqual(actual, expected)
+        self.assertEqual(expected, actual)
 
     def test_remove_version_from_href_3(self):
         fixture = 'http://www.testsite.com/v10.10'
         expected = 'http://www.testsite.com'
         actual = common.remove_version_from_href(fixture)
-        self.assertEqual(actual, expected)
+        self.assertEqual(expected, actual)
 
     def test_remove_version_from_href_4(self):
         fixture = 'http://www.testsite.com/v1.1/images/v10.5'
         expected = 'http://www.testsite.com/images/v10.5'
         actual = common.remove_version_from_href(fixture)
-        self.assertEqual(actual, expected)
+        self.assertEqual(expected, actual)
 
     def test_remove_version_from_href_bad_request(self):
         fixture = 'http://www.testsite.com/1.1/images'
diff --git a/manila/tests/api/test_extensions.py b/manila/tests/api/test_extensions.py
index c478f772b0..67ea4baf8a 100644
--- a/manila/tests/api/test_extensions.py
+++ b/manila/tests/api/test_extensions.py
@@ -58,7 +58,7 @@ class ExtensionControllerTest(ExtensionTestCase):
         names = [str(x['name']) for x in data['extensions']
                  if str(x['name']) in self.ext_list]
         names.sort()
-        self.assertEqual(names, self.ext_list)
+        self.assertEqual(self.ext_list, names)
 
         # Ensure all the timestamps are valid according to iso8601
         for ext in data['extensions']:
@@ -68,18 +68,19 @@ class ExtensionControllerTest(ExtensionTestCase):
         (fox_ext, ) = [
             x for x in data['extensions'] if x['alias'] == 'FOXNSOX']
         self.assertEqual(
-            fox_ext, {'name': 'Fox In Socks',
-                      'updated': '2011-01-22T13:25:27-06:00',
-                      'description': 'The Fox In Socks Extension.',
-                      'alias': 'FOXNSOX',
-                      'links': []}, )
+            {'name': 'Fox In Socks',
+             'updated': '2011-01-22T13:25:27-06:00',
+             'description': 'The Fox In Socks Extension.',
+             'alias': 'FOXNSOX',
+             'links': []},
+            fox_ext)
 
         for ext in data['extensions']:
             url = '/fake/extensions/%s' % ext['alias']
             request = webob.Request.blank(url)
             response = request.get_response(app)
             output = jsonutils.loads(response.body)
-            self.assertEqual(output['extension']['alias'], ext['alias'])
+            self.assertEqual(ext['alias'], output['extension']['alias'])
 
     def test_get_extension_json(self):
         app = router.APIRouter()
@@ -89,12 +90,12 @@ class ExtensionControllerTest(ExtensionTestCase):
 
         data = jsonutils.loads(response.body)
         self.assertEqual(
-            data['extension'],
             {"name": "Fox In Socks",
              "updated": "2011-01-22T13:25:27-06:00",
              "description": "The Fox In Socks Extension.",
              "alias": "FOXNSOX",
-             "links": []})
+             "links": []},
+            data['extension'])
 
     def test_get_non_existing_extension_json(self):
         app = router.APIRouter()
diff --git a/manila/tests/api/test_wsgi.py b/manila/tests/api/test_wsgi.py
index 42be08e1e4..bb53f76a97 100644
--- a/manila/tests/api/test_wsgi.py
+++ b/manila/tests/api/test_wsgi.py
@@ -41,7 +41,7 @@ class Test(test.TestCase):
 
         application = wsgi.Debug(Application())
         result = webob.Request.blank('/').get_response(application)
-        self.assertEqual(result.body, six.b("Test result"))
+        self.assertEqual(six.b("Test result"), result.body)
 
     def test_router(self):
 
@@ -61,6 +61,6 @@ class Test(test.TestCase):
                 super(Router, self).__init__(mapper)
 
         result = webob.Request.blank('/test').get_response(Router())
-        self.assertEqual(result.body, "Router result")
+        self.assertEqual("Router result", result.body)
         result = webob.Request.blank('/bad').get_response(Router())
         self.assertNotEqual(result.body, "Router result")
diff --git a/manila/tests/api/v1/test_limits.py b/manila/tests/api/v1/test_limits.py
index 50bb459561..339a0f3a57 100644
--- a/manila/tests/api/v1/test_limits.py
+++ b/manila/tests/api/v1/test_limits.py
@@ -264,7 +264,7 @@ class LimitMiddlewareTest(BaseLimitTestSuite):
 
         request = webob.Request.blank("/")
         response = request.get_response(self.app)
-        self.assertEqual(response.status_int, 413)
+        self.assertEqual(413, response.status_int)
 
         self.assertTrue('Retry-After' in response.headers)
         retry_after = int(response.headers['Retry-After'])
@@ -273,7 +273,7 @@ class LimitMiddlewareTest(BaseLimitTestSuite):
         body = jsonutils.loads(response.body)
         expected = "Only 1 GET request(s) can be made to * every minute."
         value = body["overLimitFault"]["details"].strip()
-        self.assertEqual(value, expected)
+        self.assertEqual(expected, value)
 
 
 class LimitTest(BaseLimitTestSuite):
@@ -349,28 +349,28 @@ class ParseLimitsTest(BaseLimitTestSuite):
             assert False, six.text_types(e)
 
         # Make sure the number of returned limits are correct
-        self.assertEqual(len(l), 4)
+        self.assertEqual(4, len(l))
 
         # Check all the verbs...
         expected = ['GET', 'PUT', 'POST', 'SAY']
-        self.assertEqual([t.verb for t in l], expected)
+        self.assertEqual(expected, [t.verb for t in l])
 
         # ...the URIs...
         expected = ['*', '/foo*', '/bar*', '/derp*']
-        self.assertEqual([t.uri for t in l], expected)
+        self.assertEqual(expected, [t.uri for t in l])
 
         # ...the regexes...
         expected = ['.*', '/foo.*', '/bar.*', '/derp.*']
-        self.assertEqual([t.regex for t in l], expected)
+        self.assertEqual(expected, [t.regex for t in l])
 
         # ...the values...
         expected = [20, 10, 5, 1]
-        self.assertEqual([t.value for t in l], expected)
+        self.assertEqual(expected, [t.value for t in l])
 
         # ...and the units...
         expected = [limits.PER_MINUTE, limits.PER_HOUR,
                     limits.PER_SECOND, limits.PER_DAY]
-        self.assertEqual([t.unit for t in l], expected)
+        self.assertEqual(expected, [t.unit for t in l])
 
 
 class LimiterTest(BaseLimitTestSuite):
@@ -399,7 +399,7 @@ class LimiterTest(BaseLimitTestSuite):
         didn"t set.
         """
         delay = self.limiter.check_for_delay("GET", "/anything")
-        self.assertEqual(delay, (None, None))
+        self.assertEqual((None, None), delay)
 
     def test_no_delay_PUT(self):
         """Test no delay on single call.
@@ -407,7 +407,7 @@ class LimiterTest(BaseLimitTestSuite):
         Simple test to ensure no delay on a single call for a known limit.
         """
         delay = self.limiter.check_for_delay("PUT", "/anything")
-        self.assertEqual(delay, (None, None))
+        self.assertEqual((None, None), delay)
 
     def test_delay_PUT(self):
         """Ensure 11th PUT will be delayed.
@@ -489,7 +489,7 @@ class LimiterTest(BaseLimitTestSuite):
 
     def test_user_limit(self):
         """Test user-specific limits."""
-        self.assertEqual(self.limiter.levels['user3'], [])
+        self.assertEqual([], self.limiter.levels['user3'])
 
     def test_multiple_users(self):
         """Tests involving multiple users."""
@@ -553,17 +553,17 @@ class WsgiLimiterTest(BaseLimitTestSuite):
         response = request.get_response(self.app)
 
         if "X-Wait-Seconds" in response.headers:
-            self.assertEqual(response.status_int, 403)
+            self.assertEqual(403, response.status_int)
             return response.headers["X-Wait-Seconds"]
 
-        self.assertEqual(response.status_int, 204)
+        self.assertEqual(204, response.status_int)
 
     def test_invalid_methods(self):
         """Only POSTs should work."""
         for method in ["GET", "PUT", "DELETE", "HEAD", "OPTIONS"]:
             request = webob.Request.blank("/", method=method)
             response = request.get_response(self.app)
-            self.assertEqual(response.status_int, 405)
+            self.assertEqual(405, response.status_int)
 
     def test_good_url(self):
         delay = self._request("GET", "/something")
@@ -578,7 +578,7 @@ class WsgiLimiterTest(BaseLimitTestSuite):
         self.assertIsNone(delay)
 
         delay = self._request("GET", "/delayed")
-        self.assertEqual(delay, '60.00')
+        self.assertEqual('60.00', delay)
 
     def test_response_to_delays_usernames(self):
         delay = self._request("GET", "/delayed", "user1")
@@ -588,10 +588,10 @@ class WsgiLimiterTest(BaseLimitTestSuite):
         self.assertIsNone(delay)
 
         delay = self._request("GET", "/delayed", "user1")
-        self.assertEqual(delay, '60.00')
+        self.assertEqual('60.00', delay)
 
         delay = self._request("GET", "/delayed", "user2")
-        self.assertEqual(delay, '60.00')
+        self.assertEqual('60.00', delay)
 
 
 class FakeHttplibSocket(object):
@@ -703,19 +703,19 @@ class WsgiLimiterProxyTest(BaseLimitTestSuite):
     def test_200(self):
         """Successful request test."""
         delay = self.proxy.check_for_delay("GET", "/anything")
-        self.assertEqual(delay, (None, None))
+        self.assertEqual((None, None), delay)
 
     def test_403(self):
         """Forbidden request test."""
         delay = self.proxy.check_for_delay("GET", "/delayed")
-        self.assertEqual(delay, (None, None))
+        self.assertEqual((None, None), delay)
         delay, error = self.proxy.check_for_delay("GET", "/delayed")
         error = error.strip()
 
         expected = ("60.00", six.b("403 Forbidden\n\nOnly 1 GET request(s) "
                                    "can be made to /delayed every minute."))
 
-        self.assertEqual((delay, error), expected)
+        self.assertEqual(expected, (delay, error))
 
     def tearDown(self):
         # restore original HTTPConnection object
diff --git a/manila/tests/api/v1/test_security_service.py b/manila/tests/api/v1/test_security_service.py
index b464479034..7cd4ddcb65 100644
--- a/manila/tests/api/v1/test_security_service.py
+++ b/manila/tests/api/v1/test_security_service.py
@@ -92,8 +92,8 @@ class ShareApiTest(test.TestCase):
         res_dict = self.controller.show(req, '1')
         expected = self.ss_active_directory.copy()
         expected.update()
-        self.assertEqual(res_dict,
-                         {'security_service': self.ss_active_directory})
+        self.assertEqual({'security_service': self.ss_active_directory},
+                         res_dict)
 
     def test_security_service_show_not_found(self):
         db.security_service_get = mock.Mock(side_effect=exception.NotFound)
@@ -112,7 +112,7 @@ class ShareApiTest(test.TestCase):
         res_dict = self.controller.create(
             req, {"security_service": sec_service})
         expected = self.ss_active_directory.copy()
-        self.assertEqual(res_dict, {'security_service': expected})
+        self.assertEqual({'security_service': expected}, res_dict)
 
     def test_security_service_create_invalid_types(self):
         sec_service = self.ss_active_directory.copy()
@@ -138,7 +138,7 @@ class ShareApiTest(test.TestCase):
         resp = self.controller.delete(req, 1)
         db.security_service_delete.assert_called_once_with(
             req.environ['manila.context'], 1)
-        self.assertEqual(resp.status_int, 202)
+        self.assertEqual(202, resp.status_int)
 
     def test_security_service_delete_not_found(self):
         db.security_service_get = mock.Mock(side_effect=exception.NotFound)
@@ -171,7 +171,7 @@ class ShareApiTest(test.TestCase):
         body = {"security_service": {"name": "new"}}
         req = fakes.HTTPRequest.blank('/security_service/1')
         res_dict = self.controller.update(req, 1, body)['security_service']
-        self.assertEqual(res_dict['name'], updated['name'])
+        self.assertEqual(updated['name'], res_dict['name'])
         db.share_network_get_all_by_security_service.assert_called_once_with(
             req.environ['manila.context'], 1)
         self.assertEqual(2, security_service.policy.check_policy.call_count)
@@ -195,7 +195,7 @@ class ShareApiTest(test.TestCase):
         body = {"security_service": {"description": "new"}}
         req = fakes.HTTPRequest.blank('/security_service/1')
         res_dict = self.controller.update(req, 1, body)['security_service']
-        self.assertEqual(res_dict['description'], updated['description'])
+        self.assertEqual(updated['description'], res_dict['description'])
         db.share_network_get_all_by_security_service.assert_called_once_with(
             req.environ['manila.context'], 1)
         self.assertEqual(2, security_service.policy.check_policy.call_count)
@@ -251,8 +251,8 @@ class ShareApiTest(test.TestCase):
         }
         req = fakes.HTTPRequest.blank('/security_services/1')
         res_dict = self.controller.update(req, 1, body)['security_service']
-        self.assertEqual(res_dict['description'], updated['description'])
-        self.assertEqual(res_dict['name'], updated['name'])
+        self.assertEqual(updated['description'], res_dict['description'])
+        self.assertEqual(updated['name'], res_dict['name'])
         db.security_service_get.assert_called_once_with(
             req.environ['manila.context'], 1)
         db.share_network_get_all_by_security_service.assert_called_once_with(
diff --git a/manila/tests/api/v1/test_share_networks.py b/manila/tests/api/v1/test_share_networks.py
index 87fd6517b6..4e10cb11e9 100644
--- a/manila/tests/api/v1/test_share_networks.py
+++ b/manila/tests/api/v1/test_share_networks.py
@@ -86,28 +86,28 @@ class ShareNetworkAPITest(test.TestCase):
         self.context = self.req.environ['manila.context']
 
     def _check_share_network_view_shortened(self, view, share_nw):
-        self.assertEqual(view['id'], share_nw['id'])
-        self.assertEqual(view['name'], share_nw['name'])
+        self.assertEqual(share_nw['id'], view['id'])
+        self.assertEqual(share_nw['name'], view['name'])
 
     def _check_share_network_view(self, view, share_nw):
-        self.assertEqual(view['id'], share_nw['id'])
-        self.assertEqual(view['project_id'], share_nw['project_id'])
-        self.assertEqual(view['created_at'], share_nw['created_at'])
-        self.assertEqual(view['updated_at'], share_nw['updated_at'])
-        self.assertEqual(view['neutron_net_id'],
-                         share_nw['neutron_net_id'])
-        self.assertEqual(view['neutron_subnet_id'],
-                         share_nw['neutron_subnet_id'])
-        self.assertEqual(view['network_type'], share_nw['network_type'])
-        self.assertEqual(view['segmentation_id'],
-                         share_nw['segmentation_id'])
-        self.assertEqual(view['cidr'], share_nw['cidr'])
-        self.assertEqual(view['ip_version'], share_nw['ip_version'])
-        self.assertEqual(view['name'], share_nw['name'])
-        self.assertEqual(view['description'], share_nw['description'])
+        self.assertEqual(share_nw['id'], view['id'])
+        self.assertEqual(share_nw['project_id'], view['project_id'])
+        self.assertEqual(share_nw['created_at'], view['created_at'])
+        self.assertEqual(share_nw['updated_at'], view['updated_at'])
+        self.assertEqual(share_nw['neutron_net_id'],
+                         view['neutron_net_id'])
+        self.assertEqual(share_nw['neutron_subnet_id'],
+                         view['neutron_subnet_id'])
+        self.assertEqual(share_nw['network_type'], view['network_type'])
+        self.assertEqual(share_nw['segmentation_id'],
+                         view['segmentation_id'])
+        self.assertEqual(share_nw['cidr'], view['cidr'])
+        self.assertEqual(share_nw['ip_version'], view['ip_version'])
+        self.assertEqual(share_nw['name'], view['name'])
+        self.assertEqual(share_nw['description'], view['description'])
 
-        self.assertEqual(view['created_at'], share_nw['created_at'])
-        self.assertEqual(view['updated_at'], share_nw['updated_at'])
+        self.assertEqual(share_nw['created_at'], view['created_at'])
+        self.assertEqual(share_nw['updated_at'], view['updated_at'])
         self.assertFalse('shares' in view)
         self.assertFalse('network_allocations' in view)
         self.assertFalse('security_services' in view)
@@ -337,7 +337,7 @@ class ShareNetworkAPITest(test.TestCase):
                 self.context,
                 self.context.project_id)
 
-            self.assertEqual(len(result[share_networks.RESOURCES_NAME]), 1)
+            self.assertEqual(1, len(result[share_networks.RESOURCES_NAME]))
             self._check_share_network_view_shortened(
                 result[share_networks.RESOURCES_NAME][0],
                 fake_share_network_shortened)
@@ -354,7 +354,7 @@ class ShareNetworkAPITest(test.TestCase):
                 self.context,
                 self.context.project_id)
 
-            self.assertEqual(len(result[share_networks.RESOURCES_NAME]), 1)
+            self.assertEqual(1, len(result[share_networks.RESOURCES_NAME]))
             self._check_share_network_view(
                 result[share_networks.RESOURCES_NAME][0],
                 fake_share_network)
diff --git a/manila/tests/api/v1/test_share_servers.py b/manila/tests/api/v1/test_share_servers.py
index 55224f4c8d..3ac0327b7e 100644
--- a/manila/tests/api/v1/test_share_servers.py
+++ b/manila/tests/api/v1/test_share_servers.py
@@ -167,54 +167,54 @@ class ShareServerAPITest(test.TestCase):
         policy.check_policy.assert_called_once_with(
             CONTEXT, share_servers.RESOURCE_NAME, 'index')
         db_api.share_server_get_all.assert_called_once_with(CONTEXT)
-        self.assertEqual(result, fake_share_server_list)
+        self.assertEqual(fake_share_server_list, result)
 
     def test_index_host_filter(self):
         result = self.controller.index(FakeRequestWithHost)
         policy.check_policy.assert_called_once_with(
             CONTEXT, share_servers.RESOURCE_NAME, 'index')
         db_api.share_server_get_all.assert_called_once_with(CONTEXT)
-        self.assertEqual(result['share_servers'],
-                         [fake_share_server_list['share_servers'][0]])
+        self.assertEqual([fake_share_server_list['share_servers'][0]],
+                         result['share_servers'])
 
     def test_index_status_filter(self):
         result = self.controller.index(FakeRequestWithStatus)
         policy.check_policy.assert_called_once_with(
             CONTEXT, share_servers.RESOURCE_NAME, 'index')
         db_api.share_server_get_all.assert_called_once_with(CONTEXT)
-        self.assertEqual(result['share_servers'],
-                         [fake_share_server_list['share_servers'][1]])
+        self.assertEqual([fake_share_server_list['share_servers'][1]],
+                         result['share_servers'])
 
     def test_index_project_id_filter(self):
         result = self.controller.index(FakeRequestWithProjectId)
         policy.check_policy.assert_called_once_with(
             CONTEXT, share_servers.RESOURCE_NAME, 'index')
         db_api.share_server_get_all.assert_called_once_with(CONTEXT)
-        self.assertEqual(result['share_servers'],
-                         [fake_share_server_list['share_servers'][0]])
+        self.assertEqual([fake_share_server_list['share_servers'][0]],
+                         result['share_servers'])
 
     def test_index_share_network_filter_by_name(self):
         result = self.controller.index(FakeRequestWithShareNetworkName)
         policy.check_policy.assert_called_once_with(
             CONTEXT, share_servers.RESOURCE_NAME, 'index')
         db_api.share_server_get_all.assert_called_once_with(CONTEXT)
-        self.assertEqual(result['share_servers'],
-                         [fake_share_server_list['share_servers'][0]])
+        self.assertEqual([fake_share_server_list['share_servers'][0]],
+                         result['share_servers'])
 
     def test_index_share_network_filter_by_id(self):
         result = self.controller.index(FakeRequestWithShareNetworkId)
         policy.check_policy.assert_called_once_with(
             CONTEXT, share_servers.RESOURCE_NAME, 'index')
         db_api.share_server_get_all.assert_called_once_with(CONTEXT)
-        self.assertEqual(result['share_servers'],
-                         [fake_share_server_list['share_servers'][0]])
+        self.assertEqual([fake_share_server_list['share_servers'][0]],
+                         result['share_servers'])
 
     def test_index_fake_filter(self):
         result = self.controller.index(FakeRequestWithFakeFilter)
         policy.check_policy.assert_called_once_with(
             CONTEXT, share_servers.RESOURCE_NAME, 'index')
         db_api.share_server_get_all.assert_called_once_with(CONTEXT)
-        self.assertEqual(len(result['share_servers']), 0)
+        self.assertEqual(0, len(result['share_servers']))
 
     def test_show(self):
         self.mock_object(db_api, 'share_server_get',
@@ -226,8 +226,8 @@ class ShareServerAPITest(test.TestCase):
             CONTEXT, share_servers.RESOURCE_NAME, 'show')
         db_api.share_server_get.assert_called_once_with(
             CONTEXT, fake_share_server_get_result['share_server']['id'])
-        self.assertEqual(result['share_server'],
-                         fake_share_server_get_result['share_server'])
+        self.assertEqual(fake_share_server_get_result['share_server'],
+                         result['share_server'])
 
     def test_details(self):
         self.mock_object(db_api, 'share_server_get',
@@ -239,8 +239,8 @@ class ShareServerAPITest(test.TestCase):
             CONTEXT, share_servers.RESOURCE_NAME, 'details')
         db_api.share_server_get.assert_called_once_with(
             CONTEXT, fake_share_server_get_result['share_server']['id'])
-        self.assertEqual(result,
-                         fake_share_server_backend_details_get_result)
+        self.assertEqual(fake_share_server_backend_details_get_result,
+                         result)
 
     def test_delete_active_server(self):
         share_server = FakeShareServer(status=constants.STATUS_ACTIVE)
diff --git a/manila/tests/api/v1/test_share_snapshots.py b/manila/tests/api/v1/test_share_snapshots.py
index 49fb7234af..696398acf8 100644
--- a/manila/tests/api/v1/test_share_snapshots.py
+++ b/manila/tests/api/v1/test_share_snapshots.py
@@ -127,7 +127,7 @@ class ShareSnapshotApiTest(test.TestCase):
                          stubs.stub_snapshot_delete)
         req = fakes.HTTPRequest.blank('/snapshots/200')
         resp = self.controller.delete(req, 200)
-        self.assertEqual(resp.status_int, 202)
+        self.assertEqual(202, resp.status_int)
 
     def test_snapshot_delete_nofound(self):
         self.mock_object(share_api.API, 'get_snapshot',
@@ -164,7 +164,7 @@ class ShareSnapshotApiTest(test.TestCase):
                 ],
             }
         }
-        self.assertEqual(res_dict, expected)
+        self.assertEqual(expected, res_dict)
 
     def test_snapshot_show_nofound(self):
         self.mock_object(share_api.API, 'get_snapshot',
@@ -198,7 +198,7 @@ class ShareSnapshotApiTest(test.TestCase):
                 }
             ]
         }
-        self.assertEqual(res_dict, expected)
+        self.assertEqual(expected, res_dict)
 
     def _snapshot_list_summary_with_search_opts(self, use_admin_context):
         search_opts = {
diff --git a/manila/tests/api/v1/test_share_types.py b/manila/tests/api/v1/test_share_types.py
index 29fafcdb94..f36fa3f731 100644
--- a/manila/tests/api/v1/test_share_types.py
+++ b/manila/tests/api/v1/test_share_types.py
@@ -93,7 +93,7 @@ class ShareTypesApiTest(test.TestCase):
 
         expected_names = ['share_type_1', 'share_type_2', 'share_type_3']
         actual_names = map(lambda e: e['name'], res_dict['share_types'])
-        self.assertEqual(set(actual_names), set(expected_names))
+        self.assertEqual(set(expected_names), set(actual_names))
         for entry in res_dict['share_types']:
             if admin:
                 self.assertEqual('value1', entry['extra_specs'].get('key1'))
diff --git a/manila/tests/api/v1/test_shares.py b/manila/tests/api/v1/test_shares.py
index 586c2bfd9c..8577c92f32 100644
--- a/manila/tests/api/v1/test_shares.py
+++ b/manila/tests/api/v1/test_shares.py
@@ -224,8 +224,8 @@ class ShareApiTest(test.TestCase):
         expected = self._get_expected_share_detailed_response(shr)
         expected['share'].pop('snapshot_support')
         self.assertEqual(expected, res_dict)
-        self.assertEqual(create_mock.call_args[1]['share_network_id'],
-                         "fakenetid")
+        self.assertEqual("fakenetid",
+                         create_mock.call_args[1]['share_network_id'])
 
     def test_migrate_share(self):
         share = db_utils.create_share()
@@ -342,8 +342,8 @@ class ShareApiTest(test.TestCase):
         expected = self._get_expected_share_detailed_response(shr)
         expected['share'].pop('snapshot_support')
         self.assertEqual(expected, res_dict)
-        self.assertEqual(create_mock.call_args[1]['share_network_id'],
-                         parent_share_net)
+        self.assertEqual(parent_share_net,
+                         create_mock.call_args[1]['share_network_id'])
 
     def test_share_create_from_snapshot_with_share_net_equals_parent(self):
         parent_share_net = 444
@@ -377,9 +377,9 @@ class ShareApiTest(test.TestCase):
         res_dict = self.controller.create(req, body)
         expected = self._get_expected_share_detailed_response(shr)
         expected['share'].pop('snapshot_support')
-        self.assertEqual(res_dict, expected)
-        self.assertEqual(create_mock.call_args[1]['share_network_id'],
-                         parent_share_net)
+        self.assertEqual(expected, res_dict)
+        self.assertEqual(parent_share_net,
+                         create_mock.call_args[1]['share_network_id'])
 
     def test_share_create_from_snapshot_invalid_share_net(self):
         self.mock_object(share_api.API, 'create')
@@ -483,7 +483,7 @@ class ShareApiTest(test.TestCase):
     def test_share_delete(self):
         req = fakes.HTTPRequest.blank('/shares/1')
         resp = self.controller.delete(req, 1)
-        self.assertEqual(resp.status_int, 202)
+        self.assertEqual(202, resp.status_int)
 
     def test_share_delete_in_consistency_group_param_not_provided(self):
         fake_share = stubs.stub_share('fake_share',
@@ -502,7 +502,7 @@ class ShareApiTest(test.TestCase):
         req = fakes.HTTPRequest.blank(
             '/shares/1?consistency_group_id=fake_cg_id')
         resp = self.controller.delete(req, 1)
-        self.assertEqual(resp.status_int, 202)
+        self.assertEqual(202, resp.status_int)
 
     def test_share_delete_in_consistency_group_wrong_id(self):
         fake_share = stubs.stub_share('fake_share',
@@ -636,7 +636,7 @@ class ShareApiTest(test.TestCase):
                 }
             ]
         }
-        self.assertEqual(res_dict, expected)
+        self.assertEqual(expected, res_dict)
 
     def _share_list_detail_with_search_opts(self, use_admin_context):
         search_opts = {
@@ -800,7 +800,7 @@ class ShareApiTest(test.TestCase):
         expected_opts = {'a': 'a', 'c': 'c'}
         allowed_opts = ['a', 'c']
         common.remove_invalid_options(ctx, search_opts, allowed_opts)
-        self.assertEqual(search_opts, expected_opts)
+        self.assertEqual(expected_opts, search_opts)
 
     def test_remove_invalid_options_admin(self):
         ctx = context.RequestContext('fakeuser', 'fakeproject', is_admin=True)
@@ -808,4 +808,4 @@ class ShareApiTest(test.TestCase):
         expected_opts = {'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd'}
         allowed_opts = ['a', 'c']
         common.remove_invalid_options(ctx, search_opts, allowed_opts)
-        self.assertEqual(search_opts, expected_opts)
+        self.assertEqual(expected_opts, search_opts)