diff --git a/barbican/tests/plugin/crypto/test_p11_crypto.py b/barbican/tests/plugin/crypto/test_p11_crypto.py
index caf12efa8..c2d51a1f5 100644
--- a/barbican/tests/plugin/crypto/test_p11_crypto.py
+++ b/barbican/tests/plugin/crypto/test_p11_crypto.py
@@ -82,14 +82,14 @@ class WhenTestingP11CryptoPlugin(utils.BaseTestCase):
         dto = plugin_import.KEKMetaDTO(kek_datum)
         dto = self.plugin.bind_kek_metadata(dto)
 
-        self.assertEqual(dto.algorithm, 'AES')
-        self.assertEqual(dto.bit_length, 256)
-        self.assertEqual(dto.mode, 'CBC')
+        self.assertEqual('AES', dto.algorithm)
+        self.assertEqual(256, dto.bit_length)
+        self.assertEqual('CBC', dto.mode)
 
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 2)
-        self.assertEqual(self.pkcs11.generate_key.call_count, 1)
-        self.assertEqual(self.pkcs11.wrap_key.call_count, 1)
-        self.assertEqual(self.pkcs11.compute_hmac.call_count, 1)
+        self.assertEqual(2, self.pkcs11.get_key_handle.call_count)
+        self.assertEqual(1, self.pkcs11.generate_key.call_count)
+        self.assertEqual(1, self.pkcs11.wrap_key.call_count)
+        self.assertEqual(1, self.pkcs11.compute_hmac.call_count)
 
     def test_bind_kek_metadata_with_existing_key(self):
         kek_datum = models.KEKDatum()
@@ -97,9 +97,9 @@ class WhenTestingP11CryptoPlugin(utils.BaseTestCase):
         dto.plugin_meta = '{}'
         dto = self.plugin.bind_kek_metadata(dto)
 
-        self.assertEqual(self.pkcs11.generate_key.call_count, 0)
-        self.assertEqual(self.pkcs11.wrap_key.call_count, 0)
-        self.assertEqual(self.pkcs11.compute_hmac.call_count, 0)
+        self.assertEqual(0, self.pkcs11.generate_key.call_count)
+        self.assertEqual(0, self.pkcs11.wrap_key.call_count)
+        self.assertEqual(0, self.pkcs11.compute_hmac.call_count)
 
     def test_encrypt(self):
         payload = b'test payload'
@@ -115,15 +115,15 @@ class WhenTestingP11CryptoPlugin(utils.BaseTestCase):
                                            kek_meta,
                                            mock.MagicMock())
 
-        self.assertEqual(response_dto.cypher_text, b'0')
+        self.assertEqual(b'0', response_dto.cypher_text)
         self.assertIn('iv', response_dto.kek_meta_extended)
 
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 2)
-        self.assertEqual(self.pkcs11.get_session.call_count, 2)
-        self.assertEqual(self.pkcs11.verify_hmac.call_count, 1)
-        self.assertEqual(self.pkcs11.unwrap_key.call_count, 1)
-        self.assertEqual(self.pkcs11.encrypt.call_count, 1)
-        self.assertEqual(self.pkcs11.return_session.call_count, 1)
+        self.assertEqual(2, self.pkcs11.get_key_handle.call_count)
+        self.assertEqual(2, self.pkcs11.get_session.call_count)
+        self.assertEqual(1, self.pkcs11.verify_hmac.call_count)
+        self.assertEqual(1, self.pkcs11.unwrap_key.call_count)
+        self.assertEqual(1, self.pkcs11.encrypt.call_count)
+        self.assertEqual(1, self.pkcs11.return_session.call_count)
 
     def test_encrypt_bad_session(self):
         self.pkcs11.get_session.return_value = mock.DEFAULT
@@ -145,12 +145,12 @@ class WhenTestingP11CryptoPlugin(utils.BaseTestCase):
                           kek_meta,
                           mock.MagicMock())
 
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 2)
-        self.assertEqual(self.pkcs11.get_session.call_count, 2)
-        self.assertEqual(self.pkcs11.verify_hmac.call_count, 1)
-        self.assertEqual(self.pkcs11.unwrap_key.call_count, 1)
-        self.assertEqual(self.pkcs11.encrypt.call_count, 0)
-        self.assertEqual(self.pkcs11.return_session.call_count, 0)
+        self.assertEqual(2, self.pkcs11.get_key_handle.call_count)
+        self.assertEqual(2, self.pkcs11.get_session.call_count)
+        self.assertEqual(1, self.pkcs11.verify_hmac.call_count)
+        self.assertEqual(1, self.pkcs11.unwrap_key.call_count)
+        self.assertEqual(0, self.pkcs11.encrypt.call_count)
+        self.assertEqual(0, self.pkcs11.return_session.call_count)
 
     def test_decrypt(self):
         ct = b'ctct'
@@ -168,14 +168,14 @@ class WhenTestingP11CryptoPlugin(utils.BaseTestCase):
                                  kek_meta_extended,
                                  mock.MagicMock())
 
-        self.assertEqual(pt, b'0')
+        self.assertEqual(b'0', pt)
 
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 2)
-        self.assertEqual(self.pkcs11.get_session.call_count, 2)
-        self.assertEqual(self.pkcs11.verify_hmac.call_count, 1)
-        self.assertEqual(self.pkcs11.unwrap_key.call_count, 1)
-        self.assertEqual(self.pkcs11.decrypt.call_count, 1)
-        self.assertEqual(self.pkcs11.return_session.call_count, 1)
+        self.assertEqual(2, self.pkcs11.get_key_handle.call_count)
+        self.assertEqual(2, self.pkcs11.get_session.call_count)
+        self.assertEqual(1, self.pkcs11.verify_hmac.call_count)
+        self.assertEqual(1, self.pkcs11.unwrap_key.call_count)
+        self.assertEqual(1, self.pkcs11.decrypt.call_count)
+        self.assertEqual(1, self.pkcs11.return_session.call_count)
 
     def test_decrypt_bad_session(self):
         self.pkcs11.get_session.return_value = mock.DEFAULT
@@ -199,12 +199,12 @@ class WhenTestingP11CryptoPlugin(utils.BaseTestCase):
                           kek_meta_extended,
                           mock.MagicMock())
 
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 2)
-        self.assertEqual(self.pkcs11.get_session.call_count, 2)
-        self.assertEqual(self.pkcs11.verify_hmac.call_count, 1)
-        self.assertEqual(self.pkcs11.unwrap_key.call_count, 1)
-        self.assertEqual(self.pkcs11.decrypt.call_count, 0)
-        self.assertEqual(self.pkcs11.return_session.call_count, 0)
+        self.assertEqual(2, self.pkcs11.get_key_handle.call_count)
+        self.assertEqual(2, self.pkcs11.get_session.call_count)
+        self.assertEqual(1, self.pkcs11.verify_hmac.call_count)
+        self.assertEqual(1, self.pkcs11.unwrap_key.call_count)
+        self.assertEqual(0, self.pkcs11.decrypt.call_count)
+        self.assertEqual(0, self.pkcs11.return_session.call_count)
 
     def test_generate_symmetric(self):
         secret = models.Secret()
@@ -225,16 +225,16 @@ class WhenTestingP11CryptoPlugin(utils.BaseTestCase):
                                                       kek_meta,
                                                       mock.MagicMock())
 
-        self.assertEqual(response_dto.cypher_text, b'0')
+        self.assertEqual(b'0', response_dto.cypher_text)
         self.assertIn('iv', response_dto.kek_meta_extended)
 
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 2)
-        self.assertEqual(self.pkcs11.get_session.call_count, 2)
-        self.assertEqual(self.pkcs11.generate_random.call_count, 1)
-        self.assertEqual(self.pkcs11.verify_hmac.call_count, 1)
-        self.assertEqual(self.pkcs11.unwrap_key.call_count, 1)
-        self.assertEqual(self.pkcs11.encrypt.call_count, 1)
-        self.assertEqual(self.pkcs11.return_session.call_count, 1)
+        self.assertEqual(2, self.pkcs11.get_key_handle.call_count)
+        self.assertEqual(2, self.pkcs11.get_session.call_count)
+        self.assertEqual(1, self.pkcs11.generate_random.call_count)
+        self.assertEqual(1, self.pkcs11.verify_hmac.call_count)
+        self.assertEqual(1, self.pkcs11.unwrap_key.call_count)
+        self.assertEqual(1, self.pkcs11.encrypt.call_count)
+        self.assertEqual(1, self.pkcs11.return_session.call_count)
 
     def test_generate_asymmetric_raises_error(self):
         self.assertRaises(NotImplementedError,
@@ -283,39 +283,39 @@ class WhenTestingP11CryptoPlugin(utils.BaseTestCase):
         self.pkcs11.get_key_handle.return_value = None
 
         mkek = self.plugin._generate_mkek(256, 'mkek_label_2')
-        self.assertEqual(mkek, 3)
+        self.assertEqual(3, mkek)
 
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 3)
-        self.assertEqual(self.pkcs11.generate_key.call_count, 1)
+        self.assertEqual(3, self.pkcs11.get_key_handle.call_count)
+        self.assertEqual(1, self.pkcs11.generate_key.call_count)
 
     def test_cached_generate_mkek(self):
         self.assertRaises(ex.P11CryptoPluginKeyException,
                           self.plugin._generate_mkek, 256, 'mkek_label')
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 2)
+        self.assertEqual(2, self.pkcs11.get_key_handle.call_count)
 
     def test_existing_generate_mkek(self):
         self.assertRaises(ex.P11CryptoPluginKeyException,
                           self.plugin._generate_mkek, 256, 'mkek2_label')
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 3)
+        self.assertEqual(3, self.pkcs11.get_key_handle.call_count)
 
     def test_generate_mkhk(self):
         self.pkcs11.get_key_handle.return_value = None
 
         mkhk = self.plugin._generate_mkhk(256, 'mkhk_label_2')
-        self.assertEqual(mkhk, 3)
+        self.assertEqual(3, mkhk)
 
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 3)
-        self.assertEqual(self.pkcs11.generate_key.call_count, 1)
+        self.assertEqual(3, self.pkcs11.get_key_handle.call_count)
+        self.assertEqual(1, self.pkcs11.generate_key.call_count)
 
     def test_cached_generate_mkhk(self):
         self.assertRaises(ex.P11CryptoPluginKeyException,
                           self.plugin._generate_mkhk, 256, 'hmac_label')
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 2)
+        self.assertEqual(2, self.pkcs11.get_key_handle.call_count)
 
     def test_existing_generate_mkhk(self):
         self.assertRaises(ex.P11CryptoPluginKeyException,
                           self.plugin._generate_mkhk, 256, 'mkhk2_label')
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 3)
+        self.assertEqual(3, self.pkcs11.get_key_handle.call_count)
 
     def test_create_pkcs11(self):
         def _generate_random(session, buf, length):
@@ -368,10 +368,10 @@ class WhenTestingP11CryptoPlugin(utils.BaseTestCase):
         self.plugin.encrypt(mock.MagicMock(), mock.MagicMock(),
                             mock.MagicMock())
 
-        self.assertEqual(self.pkcs11.get_key_handle.call_count, 2)
-        self.assertEqual(self.pkcs11.get_session.call_count, 1)
-        self.assertEqual(self.pkcs11.return_session.call_count, 0)
-        self.assertEqual(self.plugin._encrypt.call_count, 2)
+        self.assertEqual(2, self.pkcs11.get_key_handle.call_count)
+        self.assertEqual(1, self.pkcs11.get_session.call_count)
+        self.assertEqual(0, self.pkcs11.return_session.call_count)
+        self.assertEqual(2, self.plugin._encrypt.call_count)
 
     def test_reinitialize_pkcs11(self):
         pkcs11 = self.pkcs11
@@ -382,9 +382,9 @@ class WhenTestingP11CryptoPlugin(utils.BaseTestCase):
 
         self.plugin._reinitialize_pkcs11()
 
-        self.assertEqual(self.pkcs11.finalize.call_count, 1)
-        self.assertEqual(self.plugin._create_pkcs11.call_count, 1)
-        self.assertEqual(self.plugin._configure_object_cache.call_count, 1)
+        self.assertEqual(1, self.pkcs11.finalize.call_count)
+        self.assertEqual(1, self.plugin._create_pkcs11.call_count)
+        self.assertEqual(1, self.plugin._configure_object_cache.call_count)
 
     def test_get_plugin_name(self):
         self.assertEqual(self.plugin_name, self.plugin.get_plugin_name())
diff --git a/barbican/tests/plugin/crypto/test_pkcs11.py b/barbican/tests/plugin/crypto/test_pkcs11.py
index 0c776d977..56e272422 100644
--- a/barbican/tests/plugin/crypto/test_pkcs11.py
+++ b/barbican/tests/plugin/crypto/test_pkcs11.py
@@ -142,19 +142,19 @@ class WhenTestingPKCS11(utils.BaseTestCase):
         self.lib.C_GetSessionInfo.side_effect = self._get_session_public
         sess = self.pkcs11.get_session()
 
-        self.assertEqual(sess, 1)
+        self.assertEqual(1, sess)
 
-        self.assertEqual(self.lib.C_OpenSession.call_count, 2)
-        self.assertEqual(self.lib.C_GetSessionInfo.call_count, 2)
-        self.assertEqual(self.lib.C_Login.call_count, 1)
-        self.assertEqual(self.lib.C_CloseSession.call_count, 1)
+        self.assertEqual(2, self.lib.C_OpenSession.call_count)
+        self.assertEqual(2, self.lib.C_GetSessionInfo.call_count)
+        self.assertEqual(1, self.lib.C_Login.call_count)
+        self.assertEqual(1, self.lib.C_CloseSession.call_count)
 
     def test_user_get_session(self):
         self.pkcs11.get_session()
 
-        self.assertEqual(self.lib.C_OpenSession.call_count, 2)
-        self.assertEqual(self.lib.C_GetSessionInfo.call_count, 2)
-        self.assertEqual(self.lib.C_Login.call_count, 0)
+        self.assertEqual(2, self.lib.C_OpenSession.call_count)
+        self.assertEqual(2, self.lib.C_GetSessionInfo.call_count)
+        self.assertEqual(0, self.lib.C_Login.call_count)
 
     def test_seed_random(self):
         rd = "random-data"
@@ -166,9 +166,9 @@ class WhenTestingPKCS11(utils.BaseTestCase):
     def test_generate_random(self):
         r = self.pkcs11.generate_random(32, mock.MagicMock())
 
-        self.assertEqual(r, b'0' * 32)
+        self.assertEqual(b'0' * 32, r)
 
-        self.assertEqual(self.lib.C_GenerateRandom.call_count, 2)
+        self.assertEqual(2, self.lib.C_GenerateRandom.call_count)
 
     def test_rng_self_test_fail(self):
         def _bad_generate_random(session, buf, length):
@@ -181,11 +181,11 @@ class WhenTestingPKCS11(utils.BaseTestCase):
     def test_get_key_handle_one_key(self):
         key = self.pkcs11.get_key_handle('foo', mock.MagicMock())
 
-        self.assertEqual(key, 2)
+        self.assertEqual(2, key)
 
-        self.assertEqual(self.lib.C_FindObjectsInit.call_count, 1)
-        self.assertEqual(self.lib.C_FindObjects.call_count, 1)
-        self.assertEqual(self.lib.C_FindObjectsFinal.call_count, 1)
+        self.assertEqual(1, self.lib.C_FindObjectsInit.call_count)
+        self.assertEqual(1, self.lib.C_FindObjects.call_count)
+        self.assertEqual(1, self.lib.C_FindObjectsFinal.call_count)
 
     def test_get_key_handle_no_keys(self):
         self.lib.C_FindObjects.side_effect = self._find_objects_zero
@@ -193,9 +193,9 @@ class WhenTestingPKCS11(utils.BaseTestCase):
 
         self.assertIsNone(key)
 
-        self.assertEqual(self.lib.C_FindObjectsInit.call_count, 1)
-        self.assertEqual(self.lib.C_FindObjects.call_count, 1)
-        self.assertEqual(self.lib.C_FindObjectsFinal.call_count, 1)
+        self.assertEqual(1, self.lib.C_FindObjectsInit.call_count)
+        self.assertEqual(1, self.lib.C_FindObjects.call_count)
+        self.assertEqual(1, self.lib.C_FindObjectsFinal.call_count)
 
     def test_get_key_handle_multiple_keys(self):
         self.lib.C_FindObjects.side_effect = self._find_objects_two
@@ -203,24 +203,24 @@ class WhenTestingPKCS11(utils.BaseTestCase):
         self.assertRaises(exception.P11CryptoPluginKeyException,
                           self.pkcs11.get_key_handle, 'foo', mock.MagicMock())
 
-        self.assertEqual(self.lib.C_FindObjectsInit.call_count, 1)
-        self.assertEqual(self.lib.C_FindObjects.call_count, 1)
-        self.assertEqual(self.lib.C_FindObjectsFinal.call_count, 1)
+        self.assertEqual(1, self.lib.C_FindObjectsInit.call_count)
+        self.assertEqual(1, self.lib.C_FindObjects.call_count)
+        self.assertEqual(1, self.lib.C_FindObjectsFinal.call_count)
 
     def test_generate_session_key(self):
         key = self.pkcs11.generate_key(16, mock.MagicMock(), encrypt=True)
 
-        self.assertEqual(key, 3)
+        self.assertEqual(3, key)
 
-        self.assertEqual(self.lib.C_GenerateKey.call_count, 1)
+        self.assertEqual(1, self.lib.C_GenerateKey.call_count)
 
     def test_generate_master_key(self):
         key = self.pkcs11.generate_key(16, mock.MagicMock(), key_label='key',
                                        encrypt=True, master_key=True)
 
-        self.assertEqual(key, 3)
+        self.assertEqual(3, key)
 
-        self.assertEqual(self.lib.C_GenerateKey.call_count, 1)
+        self.assertEqual(1, self.lib.C_GenerateKey.call_count)
 
     def test_generate_key_no_flags(self):
         self.assertRaises(exception.P11CryptoPluginException,
@@ -239,9 +239,9 @@ class WhenTestingPKCS11(utils.BaseTestCase):
         self.assertEqual(ct['ct'][:len(pt)], pt[::-1])
         self.assertGreater(len(ct['iv']), 0)
 
-        self.assertEqual(self.lib.C_GenerateRandom.call_count, 1)
-        self.assertEqual(self.lib.C_EncryptInit.call_count, 1)
-        self.assertEqual(self.lib.C_Encrypt.call_count, 1)
+        self.assertEqual(1, self.lib.C_GenerateRandom.call_count)
+        self.assertEqual(1, self.lib.C_EncryptInit.call_count)
+        self.assertEqual(1, self.lib.C_Encrypt.call_count)
 
     def test_decrypt(self):
         ct = b'FEDCBA9876543210' + b'0' * self.pkcs11.gcmtagsize
@@ -251,8 +251,8 @@ class WhenTestingPKCS11(utils.BaseTestCase):
         pt_len = len(ct) - self.pkcs11.gcmtagsize
         self.assertEqual(pt[:pt_len], ct[:-self.pkcs11.gcmtagsize][::-1])
 
-        self.assertEqual(self.lib.C_DecryptInit.call_count, 1)
-        self.assertEqual(self.lib.C_Decrypt.call_count, 1)
+        self.assertEqual(1, self.lib.C_DecryptInit.call_count)
+        self.assertEqual(1, self.lib.C_Decrypt.call_count)
 
     def test_decrypt_with_pad(self):
         ct = b'\x03\x03\x03CBA9876543210' + b'0' * self.pkcs11.gcmtagsize
@@ -262,8 +262,8 @@ class WhenTestingPKCS11(utils.BaseTestCase):
         pt_len = len(ct) - self.pkcs11.gcmtagsize - 3
         self.assertEqual(pt[:pt_len], ct[3:-self.pkcs11.gcmtagsize][::-1])
 
-        self.assertEqual(self.lib.C_DecryptInit.call_count, 1)
-        self.assertEqual(self.lib.C_Decrypt.call_count, 1)
+        self.assertEqual(1, self.lib.C_DecryptInit.call_count)
+        self.assertEqual(1, self.lib.C_Decrypt.call_count)
 
     def test_decrypt_with_pad_new_iv(self):
         ct = b'\x03\x03\x03CBA9876543210' + b'0' * self.pkcs11.gcmtagsize
@@ -273,8 +273,8 @@ class WhenTestingPKCS11(utils.BaseTestCase):
         pt_len = len(ct) - self.pkcs11.gcmtagsize
         self.assertEqual(pt[:pt_len], ct[:-self.pkcs11.gcmtagsize][::-1])
 
-        self.assertEqual(self.lib.C_DecryptInit.call_count, 1)
-        self.assertEqual(self.lib.C_Decrypt.call_count, 1)
+        self.assertEqual(1, self.lib.C_DecryptInit.call_count)
+        self.assertEqual(1, self.lib.C_Decrypt.call_count)
 
     def test_decrypt_with_pad_wrong_size(self):
         ct = b'\x03\x03\x03CBA987654321' + b'0' * self.pkcs11.gcmtagsize
@@ -284,8 +284,8 @@ class WhenTestingPKCS11(utils.BaseTestCase):
         pt_len = len(ct) - self.pkcs11.gcmtagsize
         self.assertEqual(pt[:pt_len], ct[:-self.pkcs11.gcmtagsize][::-1])
 
-        self.assertEqual(self.lib.C_DecryptInit.call_count, 1)
-        self.assertEqual(self.lib.C_Decrypt.call_count, 1)
+        self.assertEqual(1, self.lib.C_DecryptInit.call_count)
+        self.assertEqual(1, self.lib.C_Decrypt.call_count)
 
     def test_decrypt_with_pad_wrong_length(self):
         ct = b'\x03EDCBA9876543210' + b'0' * self.pkcs11.gcmtagsize
@@ -295,8 +295,8 @@ class WhenTestingPKCS11(utils.BaseTestCase):
         pt_len = len(ct) - self.pkcs11.gcmtagsize
         self.assertEqual(pt[:pt_len], ct[:-self.pkcs11.gcmtagsize][::-1])
 
-        self.assertEqual(self.lib.C_DecryptInit.call_count, 1)
-        self.assertEqual(self.lib.C_Decrypt.call_count, 1)
+        self.assertEqual(1, self.lib.C_DecryptInit.call_count)
+        self.assertEqual(1, self.lib.C_Decrypt.call_count)
 
     def test_decrypt_with_too_large_pad(self):
         ct = b'\x11EDCBA9876543210' + b'0' * self.pkcs11.gcmtagsize
@@ -306,43 +306,43 @@ class WhenTestingPKCS11(utils.BaseTestCase):
         pt_len = len(ct) - self.pkcs11.gcmtagsize
         self.assertEqual(pt[:pt_len], ct[:-self.pkcs11.gcmtagsize][::-1])
 
-        self.assertEqual(self.lib.C_DecryptInit.call_count, 1)
-        self.assertEqual(self.lib.C_Decrypt.call_count, 1)
+        self.assertEqual(1, self.lib.C_DecryptInit.call_count)
+        self.assertEqual(1, self.lib.C_Decrypt.call_count)
 
     def test_wrap_key(self):
         wkek = self.pkcs11.wrap_key(mock.Mock(), mock.Mock(), mock.Mock())
         self.assertGreater(len(wkek['iv']), 0)
-        self.assertEqual(wkek['wrapped_key'], b'0' * 16)
+        self.assertEqual(b'0' * 16, wkek['wrapped_key'])
 
-        self.assertEqual(self.lib.C_GenerateRandom.call_count, 2)
-        self.assertEqual(self.lib.C_WrapKey.call_count, 2)
+        self.assertEqual(2, self.lib.C_GenerateRandom.call_count)
+        self.assertEqual(2, self.lib.C_WrapKey.call_count)
 
     def test_unwrap_key(self):
         kek = self.pkcs11.unwrap_key(mock.Mock(), b'0' * 16,
                                      b'0' * 16, mock.Mock())
-        self.assertEqual(kek, 1)
+        self.assertEqual(1, kek)
 
         self.assertEqual(self.lib.C_UnwrapKey.call_count, 1)
 
     def test_compute_hmac(self):
         buf = self.pkcs11.compute_hmac(mock.MagicMock(), mock.MagicMock(),
                                        mock.MagicMock())
-        self.assertEqual(len(buf), 32)
+        self.assertEqual(32, len(buf))
 
-        self.assertEqual(self.lib.C_SignInit.call_count, 1)
-        self.assertEqual(self.lib.C_Sign.call_count, 1)
+        self.assertEqual(1, self.lib.C_SignInit.call_count)
+        self.assertEqual(1, self.lib.C_Sign.call_count)
 
     def test_verify_hmac(self):
         self.pkcs11.verify_hmac(mock.MagicMock(), mock.MagicMock(),
                                 mock.MagicMock(), mock.MagicMock())
 
-        self.assertEqual(self.lib.C_VerifyInit.call_count, 1)
-        self.assertEqual(self.lib.C_Verify.call_count, 1)
+        self.assertEqual(1, self.lib.C_VerifyInit.call_count)
+        self.assertEqual(1, self.lib.C_Verify.call_count)
 
     def test_destroy_object(self):
         self.pkcs11.destroy_object(mock.MagicMock(), mock.MagicMock())
 
-        self.assertEqual(self.lib.C_DestroyObject.call_count, 1)
+        self.assertEqual(1, self.lib.C_DestroyObject.call_count)
 
     def test_invalid_build_attributes(self):
         self.assertRaises(TypeError, self.pkcs11._build_attributes,
@@ -351,7 +351,7 @@ class WhenTestingPKCS11(utils.BaseTestCase):
     def test_finalize(self):
         self.pkcs11.finalize()
 
-        self.assertEqual(self.lib.C_Finalize.call_count, 1)
+        self.assertEqual(1, self.lib.C_Finalize.call_count)
 
     def test_check_error(self):
         self.assertIsNone(self.pkcs11._check_error(pkcs11.CKR_OK))
diff --git a/functionaltests/api/base.py b/functionaltests/api/base.py
index 12d55af04..61c57b9dc 100644
--- a/functionaltests/api/base.py
+++ b/functionaltests/api/base.py
@@ -128,7 +128,7 @@ class PagingTestCase(TestCase):
         detect duplicates across multiple calls)
         """
         self.assertIsNotNone(resources)
-        self.assertEqual(len(resources), expected_size)
+        self.assertEqual(expected_size, len(resources))
         self.assertEqual(next_ref_should_be_none, next_ref is None)
         self.assertEqual(prev_ref_should_be_none, prev_ref is None)
 
@@ -139,7 +139,7 @@ class PagingTestCase(TestCase):
         if len(self._all_fetched_resources):
             duplicates = [entity for entity in resources if entity in
                           self._all_fetched_resources]
-            self.assertEqual(len(duplicates), 0)
+            self.assertEqual(0, len(duplicates))
 
         # add to our running list of resource refs
         self._all_fetched_resources.extend(resources)
diff --git a/functionaltests/api/v1/functional/test_cas.py b/functionaltests/api/v1/functional/test_cas.py
index 9ef645608..0967ba762 100644
--- a/functionaltests/api/v1/functional/test_cas.py
+++ b/functionaltests/api/v1/functional/test_cas.py
@@ -502,7 +502,7 @@ class CertificateAuthoritiesTestCase(CATestCommon):
 
         container_resp = self.container_behaviors.get_container(
             order_resp.model.container_ref)
-        self.assertEqual(container_resp.status_code, 200)
+        self.assertEqual(200, container_resp.status_code)
 
         secret_dict = {}
         for secret in container_resp.model.secret_refs:
@@ -551,7 +551,7 @@ class ListingCAsTestCase(CATestCommon):
         are specifically loaded.
         """
         (resp, cas, total, next_ref, prev_ref) = self.ca_behaviors.get_cas()
-        self.assertEqual(total, 2)
+        self.assertEqual(2, total)
 
     @depends_on_ca_plugins('dogtag')
     def test_list_dogtag_cas(self):
@@ -569,7 +569,7 @@ class ProjectCATestCase(CATestCommon):
     def test_addition_of_project_ca_affects_getting_ca_list(self):
         # Getting list of CAs should get the total configured CAs
         (resp, cas, initial_total, _, __) = self.ca_behaviors.get_cas()
-        self.assertEqual(initial_total, 2)
+        self.assertEqual(2, initial_total)
 
         # Set project CA
         ca_ref = self.get_snakeoil_root_ca_ref()
diff --git a/functionaltests/api/v1/functional/test_certificate_orders.py b/functionaltests/api/v1/functional/test_certificate_orders.py
index c4763ffe9..8f842a49c 100644
--- a/functionaltests/api/v1/functional/test_certificate_orders.py
+++ b/functionaltests/api/v1/functional/test_certificate_orders.py
@@ -196,7 +196,7 @@ class CertificatesTestCase(base.TestCase):
         test_model.secret_refs = [pub_key_ref, priv_key_ref]
         resp, container_ref = self.container_behaviors.create_container(
             test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         return container_ref
 
@@ -212,7 +212,7 @@ class CertificatesTestCase(base.TestCase):
             'secret_ref': secret_ref
         }]
         resp, container_ref = self.container_behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         return container_ref
 
     def get_dogtag_ca_id(self):
@@ -484,7 +484,7 @@ class CertificatesTestCase(base.TestCase):
         test_model = order_models.OrderModel(**self.simple_cmc_data)
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 400)
+        self.assertEqual(400, create_resp.status_code)
         self.assertIsNone(order_ref)
         self.confirm_error_message(
             create_resp,
@@ -498,7 +498,7 @@ class CertificatesTestCase(base.TestCase):
             certutil.create_good_csr())
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 400)
+        self.assertEqual(400, create_resp.status_code)
         self.assertIsNone(order_ref)
         self.confirm_error_message(
             create_resp,
@@ -729,7 +729,7 @@ class CertificatesTestCase(base.TestCase):
             certutil.create_good_csr())
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
         order_resp = self.wait_for_order(order_ref)
diff --git a/functionaltests/api/v1/functional/test_consumers.py b/functionaltests/api/v1/functional/test_consumers.py
index 0d8ee816f..14aafe0a2 100644
--- a/functionaltests/api/v1/functional/test_consumers.py
+++ b/functionaltests/api/v1/functional/test_consumers.py
@@ -80,7 +80,7 @@ class ConsumersBaseTestCase(base.TestCase):
     def _create_a_secret(self):
         secret_model = secret_models.SecretModel(**create_secret_data)
         resp, secret_ref = self.secret_behaviors.create_secret(secret_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertIsNotNone(secret_ref)
         return secret_ref
 
@@ -108,7 +108,7 @@ class ConsumersBaseTestCase(base.TestCase):
         resp, container_ref = self.container_behaviors.create_container(
             container_model
         )
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertIsNotNone(container_ref)
 
         return container_ref
@@ -128,13 +128,13 @@ class ConsumersCertContainerTestCase(ConsumersBaseTestCase):
         resp, consumer_data = self.consumer_behaviors.create_consumer(
             self.consumer_test_model, container_ref)
 
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
         return consumer_data
 
     def _get_decrypted_secrets_from_container(self, container_href):
         get_resp = self.container_behaviors.get_container(container_href)
-        self.assertEqual(get_resp.status_code, 200)
+        self.assertEqual(200, get_resp.status_code)
 
         private_key_ref = get_resp.model.secret_refs[0].secret_ref
         tls_cert_ref = get_resp.model.secret_refs[1].secret_ref
@@ -186,7 +186,7 @@ class ConsumersCertContainerTestCase(ConsumersBaseTestCase):
 
         resp, container_ref = self.container_behaviors.create_container(
             test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertIsNotNone(container_ref)
         return container_ref
 
@@ -194,7 +194,7 @@ class ConsumersCertContainerTestCase(ConsumersBaseTestCase):
         resp, consumer_data = self.consumer_behaviors.delete_consumer(
             self.consumer_test_model, container_ref
         )
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
         self.assertNotIn(self.consumer_test_model.name, consumer_data)
         self.assertNotIn(self.consumer_test_model.URL, consumer_data)
diff --git a/functionaltests/api/v1/functional/test_containers.py b/functionaltests/api/v1/functional/test_containers.py
index 46abbb5e3..227794525 100644
--- a/functionaltests/api/v1/functional/test_containers.py
+++ b/functionaltests/api/v1/functional/test_containers.py
@@ -120,7 +120,7 @@ class BaseContainerTestCase(base.TestCase):
 
         secret_model = secret_models.SecretModel(**secret_defaults_data)
         resp, secret_ref = self.secret_behaviors.create_secret(secret_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertIsNotNone(secret_ref)
 
         return secret_ref
@@ -136,7 +136,7 @@ class GenericContainersTestCase(BaseContainerTestCase):
         test_model.name = None
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @utils.parameterized_dataset({'0': [0], '1': [1], '50': [50]})
     @testcase.attr('positive')
@@ -151,7 +151,7 @@ class GenericContainersTestCase(BaseContainerTestCase):
             })
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @utils.parameterized_dataset(accepted_str_values)
     @testcase.attr('positive')
@@ -161,7 +161,7 @@ class GenericContainersTestCase(BaseContainerTestCase):
         test_model.name = name
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @utils.parameterized_dataset(accepted_str_values)
     @testcase.attr('positive')
@@ -174,10 +174,10 @@ class GenericContainersTestCase(BaseContainerTestCase):
         }]
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         get_resp = self.behaviors.get_container(container_ref)
-        self.assertEqual(get_resp.status_code, 200)
+        self.assertEqual(200, get_resp.status_code)
         self.assertEqual(get_resp.model.secret_refs[0].name, name)
 
     @testcase.attr('negative')
@@ -187,7 +187,7 @@ class GenericContainersTestCase(BaseContainerTestCase):
         test_model.type = 'bad_type'
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @testcase.attr('negative')
     def test_create_defaults_duplicate_secret_refs(self):
@@ -198,19 +198,19 @@ class GenericContainersTestCase(BaseContainerTestCase):
         test_model.secret_refs[2]['secret_ref'] = self.secret_ref_1
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @testcase.attr('negative')
     def test_get_non_existent_container(self):
         """A get on a container that does not exist should return a 404."""
         resp = self.behaviors.get_container("not_a_ref")
-        self.assertEqual(resp.status_code, 404)
+        self.assertEqual(404, resp.status_code)
 
     @testcase.attr('negative')
     def test_delete_non_existent_container(self):
         """A delete on a container that does not exist should return a 404."""
         resp = self.behaviors.delete_container("not_a_ref", expected_fail=True)
-        self.assertEqual(resp.status_code, 404)
+        self.assertEqual(404, resp.status_code)
 
     @testcase.skipIf(not base.conf_host_href_used, 'response href using '
                      'wsgi request instead of CONF.host_href')
@@ -226,7 +226,7 @@ class GenericContainersTestCase(BaseContainerTestCase):
         resp, container_ref = self.behaviors.create_container(
             test_model, extra_headers=changed_host_header)
 
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         # get Location field from result and assert that it is NOT the
         # malicious one.
@@ -248,7 +248,7 @@ class GenericContainersTestCase(BaseContainerTestCase):
         # container_href in response contains that host in url. That url is
         # used in deleting that container during cleanup step.
         resp, container_href = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         resp = self.behaviors.get_container(container_href,
                                             extra_headers=changed_host_header)
@@ -271,7 +271,7 @@ class RSAContainersTestCase(BaseContainerTestCase):
         test_model.secret_refs = [pub_key_ref, priv_key_ref]
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @utils.parameterized_dataset(accepted_str_values)
     @testcase.attr('positive')
@@ -281,7 +281,7 @@ class RSAContainersTestCase(BaseContainerTestCase):
         test_model.name = name
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @testcase.attr('negative')
     def test_create_rsa_invalid_key_names(self):
@@ -303,7 +303,7 @@ class RSAContainersTestCase(BaseContainerTestCase):
         ]
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @testcase.attr('negative')
     def test_create_rsa_no_public_key(self):
@@ -315,7 +315,7 @@ class RSAContainersTestCase(BaseContainerTestCase):
         test_model.secret_refs[0]['name'] = 'secret_1'
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @testcase.attr('negative')
     def test_create_rsa_no_private_key(self):
@@ -327,7 +327,7 @@ class RSAContainersTestCase(BaseContainerTestCase):
         test_model.secret_refs[1]['name'] = 'secret_1'
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @testcase.skipIf(not base.conf_host_href_used, 'response href using '
                      'wsgi request instead of CONF.host_href')
@@ -343,7 +343,7 @@ class RSAContainersTestCase(BaseContainerTestCase):
         resp, container_ref = self.behaviors.create_container(
             test_model, extra_headers=changed_host_header)
 
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         # get Location field from result and assert that it is NOT the
         # malicious one.
@@ -365,7 +365,7 @@ class RSAContainersTestCase(BaseContainerTestCase):
         # container_href in response contains that host in url. That url is
         # used in deleting that container during cleanup step.
         resp, container_href = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         resp = self.behaviors.get_container(container_href,
                                             extra_headers=changed_host_header)
@@ -400,7 +400,7 @@ class ContainersPagingTestCase(base.PagingTestCase):
 
         secret_model = secret_models.SecretModel(**secret_defaults_data)
         resp, secret_ref = self.secret_behaviors.create_secret(secret_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertIsNotNone(secret_ref)
 
         return secret_ref
diff --git a/functionaltests/api/v1/functional/test_orders.py b/functionaltests/api/v1/functional/test_orders.py
index d16044e67..8aaafa88a 100644
--- a/functionaltests/api/v1/functional/test_orders.py
+++ b/functionaltests/api/v1/functional/test_orders.py
@@ -109,7 +109,7 @@ class OrdersTestCase(base.TestCase):
         test_model.name = None
         create_resp, order_ref = self.behaviors.create_order(test_model)
 
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
     @testcase.attr('positive')
@@ -120,7 +120,7 @@ class OrdersTestCase(base.TestCase):
         test_model.name = ""
         create_resp, order_ref = self.behaviors.create_order(test_model)
 
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
     @testcase.attr('positive')
@@ -137,14 +137,14 @@ class OrdersTestCase(base.TestCase):
         create_resp, order_ref = self.behaviors.create_order(test_model)
 
         # verify that the order was created successfully
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
         # given the order href, retrieve the order
         order_resp = self.behaviors.get_order(order_ref)
 
         # verify that the get was successful
-        self.assertEqual(order_resp.status_code, 200)
+        self.assertEqual(200, order_resp.status_code)
         self.assertTrue(order_resp.model.status == "ACTIVE" or
                         order_resp.model.status == "PENDING")
 
@@ -156,7 +156,7 @@ class OrdersTestCase(base.TestCase):
         # in the newly created order.
         secret_resp = self.secret_behaviors.get_secret_metadata(
             order_resp.model.secret_ref)
-        self.assertEqual(secret_resp.status_code, 200)
+        self.assertEqual(200, secret_resp.status_code)
         self.assertEqual(secret_resp.model.name, test_model.meta['name'])
 
     @testcase.attr('negative')
@@ -169,10 +169,10 @@ class OrdersTestCase(base.TestCase):
         test_model = order_models.OrderModel(**self.create_default_data)
 
         resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(resp.status_code, 202)
+        self.assertEqual(202, resp.status_code)
 
         order_resp = self.behaviors.get_order(order_ref)
-        self.assertEqual(order_resp.status_code, 200)
+        self.assertEqual(200, order_resp.status_code)
 
         # PENDING orders may take a moment to be processed by the workers
         # when running tests with queue enabled
@@ -182,7 +182,7 @@ class OrdersTestCase(base.TestCase):
 
         secret_resp = self.secret_behaviors.get_secret(
             secret_ref, payload_content_type="text/plain")
-        self.assertEqual(secret_resp.status_code, 406)
+        self.assertEqual(406, secret_resp.status_code)
 
     @testcase.attr('positive')
     def test_order_and_secret_metadata_same(self):
@@ -195,10 +195,10 @@ class OrdersTestCase(base.TestCase):
         test_model = order_models.OrderModel(**self.create_default_data)
 
         resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(resp.status_code, 202)
+        self.assertEqual(202, resp.status_code)
 
         order_resp = self.behaviors.get_order(order_ref)
-        self.assertEqual(order_resp.status_code, 200)
+        self.assertEqual(200, order_resp.status_code)
 
         # PENDING orders may take a moment to be processed by the workers
         # when running tests with queue enabled
@@ -232,7 +232,7 @@ class OrdersTestCase(base.TestCase):
         order_resp = self.behaviors.get_order("a ref that does not exist")
 
         # verify that the order get failed
-        self.assertEqual(order_resp.status_code, 404)
+        self.assertEqual(404, order_resp.status_code)
 
     @testcase.attr('negative')
     def test_order_create_w_invalid_content_type(self):
@@ -243,7 +243,7 @@ class OrdersTestCase(base.TestCase):
         create_resp, order_ref = self.behaviors.create_order(
             test_model, extra_headers=extra_headers)
 
-        self.assertEqual(create_resp.status_code, 415)
+        self.assertEqual(415, create_resp.status_code)
         self.assertIsNone(order_ref)
 
     @testcase.attr('negative')
@@ -253,7 +253,7 @@ class OrdersTestCase(base.TestCase):
         test_model = order_models.OrderModel(**self.create_all_none_data)
         create_resp, order_ref = self.behaviors.create_order(test_model)
 
-        self.assertEqual(create_resp.status_code, 400)
+        self.assertEqual(400, create_resp.status_code)
         self.assertIsNone(order_ref)
 
     @testcase.attr('negative')
@@ -269,7 +269,7 @@ class OrdersTestCase(base.TestCase):
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
 
-        self.assertEqual(create_resp.status_code, 400)
+        self.assertEqual(400, create_resp.status_code)
         self.assertIsNone(order_ref)
 
     @testcase.attr('negative')
@@ -283,7 +283,7 @@ class OrdersTestCase(base.TestCase):
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
 
-        self.assertEqual(create_resp.status_code, 400)
+        self.assertEqual(400, create_resp.status_code)
         self.assertIsNone(order_ref)
 
     @testcase.attr('negative')
@@ -297,7 +297,7 @@ class OrdersTestCase(base.TestCase):
         # Make sure we actually get a message back
         error_msg = json.loads(resp.content).get('title')
 
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
         self.assertIsNotNone(error_msg)
         self.assertNotEqual(error_msg, 'None')
 
@@ -318,7 +318,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['bit_length'] = bit_length
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
     @utils.parameterized_dataset({
@@ -341,7 +341,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['bit_length'] = bit_length
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 400)
+        self.assertEqual(400, create_resp.status_code)
 
     @utils.parameterized_dataset({
         'array': [['array']],
@@ -357,7 +357,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['payload'] = payload
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 400)
+        self.assertEqual(400, create_resp.status_code)
 
     @utils.parameterized_dataset({
         'alphanumeric': ['1f34ds'],
@@ -373,7 +373,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['name'] = name
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
     @utils.parameterized_dataset({
@@ -386,7 +386,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['name'] = name
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 400)
+        self.assertEqual(400, create_resp.status_code)
 
     @utils.parameterized_dataset({
         'cbc': ['cbc']
@@ -398,7 +398,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['mode'] = mode
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
     @utils.parameterized_dataset({
@@ -411,7 +411,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['mode'] = mode
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 400)
+        self.assertEqual(400, create_resp.status_code)
 
     @utils.parameterized_dataset({
         'aes': ['aes']
@@ -423,7 +423,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['algorithm'] = algorithm
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
     @utils.parameterized_dataset({
@@ -436,7 +436,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['algorithm'] = algorithm
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 400)
+        self.assertEqual(400, create_resp.status_code)
 
     @utils.parameterized_dataset({
         'empty': [''],
@@ -450,7 +450,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['payload_content_type'] = pct
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
     @utils.parameterized_dataset({
@@ -467,7 +467,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['payload_content_type'] = pct
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 400)
+        self.assertEqual(400, create_resp.status_code)
 
     @utils.parameterized_dataset({
         'negative_five_long_expire': {
@@ -494,7 +494,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['expiration'] = timestamp
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
     @utils.parameterized_dataset({
@@ -510,7 +510,7 @@ class OrdersTestCase(base.TestCase):
         test_model.meta['expiration'] = timestamp
 
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 400)
+        self.assertEqual(400, create_resp.status_code)
 
     @testcase.skipIf(not base.conf_host_href_used, 'response href using '
                      'wsgi request instead of CONF.host_href')
@@ -526,7 +526,7 @@ class OrdersTestCase(base.TestCase):
         resp, order_ref = self.behaviors.create_order(
             test_model, extra_headers=changed_host_header)
 
-        self.assertEqual(resp.status_code, 202)
+        self.assertEqual(202, resp.status_code)
 
         # get Location field from result and assert that it is NOT the
         # malicious one.
@@ -548,7 +548,7 @@ class OrdersTestCase(base.TestCase):
         # order_ref in response contains that host in url. That url is
         # used in deleting that order during cleanup step.
         resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(resp.status_code, 202)
+        self.assertEqual(202, resp.status_code)
 
         order_resp = self.behaviors.get_order(
             order_ref, extra_headers=changed_host_header)
@@ -561,14 +561,14 @@ class OrdersTestCase(base.TestCase):
         """Tests functionality of a generated asymmetric key pair."""
         test_model = order_models.OrderModel(**self.asymmetric_data)
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
 
         order_resp = self.behaviors.get_order(order_ref)
-        self.assertEqual(order_resp.status_code, 200)
+        self.assertEqual(200, order_resp.status_code)
 
         container_resp = self.container_behaviors.get_container(
             order_resp.model.container_ref)
-        self.assertEqual(container_resp.status_code, 200)
+        self.assertEqual(200, container_resp.status_code)
 
         secret_dict = {}
         for secret in container_resp.model.secret_refs:
diff --git a/functionaltests/api/v1/functional/test_quotas_enforce.py b/functionaltests/api/v1/functional/test_quotas_enforce.py
index 13fd71e1a..eb6b30248 100644
--- a/functionaltests/api/v1/functional/test_quotas_enforce.py
+++ b/functionaltests/api/v1/functional/test_quotas_enforce.py
@@ -253,7 +253,7 @@ class QuotaEnforcementTestCase(base.TestCase):
             if resp.status_code == 202:
                 order_resp = self.order_behaviors.get_order(
                     order_ref, user_name=admin_b)
-                self.assertEqual(order_resp.status_code, 200)
+                self.assertEqual(200, order_resp.status_code)
                 self.order_secrets.append(order_resp.model.secret_ref)
 
     def get_default_consumer_data(self):
diff --git a/functionaltests/api/v1/functional/test_secretmeta.py b/functionaltests/api/v1/functional/test_secretmeta.py
index edbc2bda2..e30081a80 100644
--- a/functionaltests/api/v1/functional/test_secretmeta.py
+++ b/functionaltests/api/v1/functional/test_secretmeta.py
@@ -72,12 +72,12 @@ class SecretMetadataTestCase(base.TestCase):
             **self.default_secret_create_all_none_data)
 
         resp, secret_ref = self.secret_behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         meta_resp, metadata_ref = self.behaviors.create_or_update_metadata(
             secret_ref, self.valid_metadata)
 
-        self.assertEqual(meta_resp.status_code, 201)
+        self.assertEqual(201, meta_resp.status_code)
         self.assertEqual(secret_ref + '/metadata', metadata_ref)
 
     @testcase.attr('negative')
@@ -87,7 +87,7 @@ class SecretMetadataTestCase(base.TestCase):
         meta_resp, metadata_ref = self.behaviors.create_or_update_metadata(
             secret_ref, self.invalid_metadata)
 
-        self.assertEqual(meta_resp.status_code, 404)
+        self.assertEqual(404, meta_resp.status_code)
 
     @testcase.attr('positive')
     def test_secret_metadata_get(self):
@@ -95,16 +95,16 @@ class SecretMetadataTestCase(base.TestCase):
             **self.default_secret_create_all_none_data)
 
         resp, secret_ref = self.secret_behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         meta_resp, metadata_ref = self.behaviors.create_or_update_metadata(
             secret_ref, self.valid_metadata)
 
-        self.assertEqual(meta_resp.status_code, 201)
+        self.assertEqual(201, meta_resp.status_code)
         self.assertEqual(secret_ref + '/metadata', metadata_ref)
 
         get_resp = self.behaviors.get_metadata(secret_ref)
-        self.assertEqual(get_resp.status_code, 200)
+        self.assertEqual(200, get_resp.status_code)
         self.assertEqual(get_resp.content, json.dumps(self.valid_metadata))
 
     @testcase.attr('negative')
@@ -112,7 +112,7 @@ class SecretMetadataTestCase(base.TestCase):
         secret_ref = 'http://localhost:9311/secrets/%s' % uuid.uuid4().hex
 
         get_resp = self.behaviors.get_metadata(secret_ref)
-        self.assertEqual(get_resp.status_code, 404)
+        self.assertEqual(404, get_resp.status_code)
 
     @testcase.attr('positive')
     def test_secret_metadatum_create(self):
@@ -120,12 +120,12 @@ class SecretMetadataTestCase(base.TestCase):
             **self.default_secret_create_all_none_data)
 
         resp, secret_ref = self.secret_behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         meta_resp, metadata_ref = self.behaviors.create_metadatum(
             secret_ref, self.valid_metadatum)
 
-        self.assertEqual(meta_resp.status_code, 201)
+        self.assertEqual(201, meta_resp.status_code)
 
     @testcase.attr('positive')
     def test_secret_metadatum_update(self):
@@ -133,12 +133,12 @@ class SecretMetadataTestCase(base.TestCase):
             **self.default_secret_create_all_none_data)
 
         resp, secret_ref = self.secret_behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         meta_resp, metadata_ref = self.behaviors.create_metadatum(
             secret_ref, self.valid_metadatum)
 
-        self.assertEqual(meta_resp.status_code, 201)
+        self.assertEqual(201, meta_resp.status_code)
 
         updated_meta = {
             'key': self.valid_metadatum_key,
@@ -148,7 +148,7 @@ class SecretMetadataTestCase(base.TestCase):
         put_resp = self.behaviors.update_metadatum(
             secret_ref, self.valid_metadatum_key, updated_meta)
 
-        self.assertEqual(put_resp.status_code, 200)
+        self.assertEqual(200, put_resp.status_code)
 
     @testcase.attr('positive')
     def test_secret_metadatum_get(self):
@@ -156,16 +156,16 @@ class SecretMetadataTestCase(base.TestCase):
             **self.default_secret_create_all_none_data)
 
         resp, secret_ref = self.secret_behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         meta_resp, metadata_ref = self.behaviors.create_metadatum(
             secret_ref, self.valid_metadatum)
 
-        self.assertEqual(meta_resp.status_code, 201)
+        self.assertEqual(201, meta_resp.status_code)
 
         get_resp = self.behaviors.get_metadatum(secret_ref,
                                                 self.valid_metadatum_key)
-        self.assertEqual(get_resp.status_code, 200)
+        self.assertEqual(200, get_resp.status_code)
         self.assertEqual(get_resp.content, json.dumps(self.valid_metadatum,
                                                       sort_keys=True))
 
@@ -175,16 +175,16 @@ class SecretMetadataTestCase(base.TestCase):
             **self.default_secret_create_all_none_data)
 
         resp, secret_ref = self.secret_behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         meta_resp, metadata_ref = self.behaviors.create_metadatum(
             secret_ref, self.valid_metadatum)
 
-        self.assertEqual(meta_resp.status_code, 201)
+        self.assertEqual(201, meta_resp.status_code)
 
         get_resp = self.behaviors.get_metadatum(secret_ref,
                                                 'other_key')
-        self.assertEqual(get_resp.status_code, 404)
+        self.assertEqual(404, get_resp.status_code)
 
     @testcase.attr('positive')
     def test_secret_metadatum_delete(self):
@@ -192,16 +192,16 @@ class SecretMetadataTestCase(base.TestCase):
             **self.default_secret_create_all_none_data)
 
         resp, secret_ref = self.secret_behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         meta_resp, metadata_ref = self.behaviors.create_metadatum(
             secret_ref, self.valid_metadatum)
 
-        self.assertEqual(meta_resp.status_code, 201)
+        self.assertEqual(201, meta_resp.status_code)
 
         get_resp = self.behaviors.get_metadatum(secret_ref,
                                                 self.valid_metadatum_key)
-        self.assertEqual(get_resp.status_code, 200)
+        self.assertEqual(200, get_resp.status_code)
         delete_resp = self.behaviors.delete_metadatum(secret_ref,
                                                       self.valid_metadatum_key)
-        self.assertEqual(delete_resp.status_code, 204)
+        self.assertEqual(204, delete_resp.status_code)
diff --git a/functionaltests/api/v1/functional/test_secrets.py b/functionaltests/api/v1/functional/test_secrets.py
index c5408a0a0..238f58cab 100644
--- a/functionaltests/api/v1/functional/test_secrets.py
+++ b/functionaltests/api/v1/functional/test_secrets.py
@@ -156,7 +156,7 @@ class SecretsTestCase(base.TestCase):
         test_model.payload_content_type = 'application/octet-stream'
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @testcase.attr('positive')
     def test_secret_create_then_check_content_types(self):
@@ -165,10 +165,10 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         resp = self.behaviors.get_secret_metadata(secret_ref)
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         content_types = resp.model.content_types
         self.assertIsNotNone(content_types)
         self.assertIn('default', content_types)
@@ -182,7 +182,7 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_all_none_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_get_secret_doesnt_exist(self):
@@ -191,7 +191,7 @@ class SecretsTestCase(base.TestCase):
         Should return a 404.
         """
         resp = self.behaviors.get_secret_metadata('not_a_uuid')
-        self.assertEqual(resp.status_code, 404)
+        self.assertEqual(404, resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_get_secret_payload_doesnt_exist(self):
@@ -203,10 +203,10 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_all_none_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         resp = self.behaviors.get_secret(secret_ref, 'text/plain')
-        self.assertEqual(resp.status_code, 404)
+        self.assertEqual(404, resp.status_code)
 
     @testcase.attr('positive')
     def test_secret_get_payload_no_accept_header(self):
@@ -218,13 +218,13 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         get_resp = self.behaviors.get_secret(
             secret_ref,
             payload_content_type='',
             omit_headers=['Accept'])
-        self.assertEqual(get_resp.status_code, 200)
+        self.assertEqual(200, get_resp.status_code)
         self.assertIn(test_model.payload,
                       binascii.b2a_base64(get_resp.content))
 
@@ -235,7 +235,7 @@ class SecretsTestCase(base.TestCase):
         Should return a 404.
         """
         resp = self.behaviors.delete_secret('not_a_uuid', expected_fail=True)
-        self.assertEqual(resp.status_code, 404)
+        self.assertEqual(404, resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_get_invalid_mime_type(self):
@@ -246,7 +246,7 @@ class SecretsTestCase(base.TestCase):
         resp, secret_ref = self.behaviors.create_secret(test_model)
         resp = self.behaviors.get_secret(secret_ref,
                                          payload_content_type="i/m")
-        self.assertEqual(resp.status_code, 406)
+        self.assertEqual(406, resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_create_with_expiration_passed(self):
@@ -259,7 +259,7 @@ class SecretsTestCase(base.TestCase):
         test_model.expiration = '2000-01-10T14:58:52.546795'
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_create_with_empty_strings(self):
@@ -271,7 +271,7 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_emptystrings_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_create_with_invalid_content_type(self):
@@ -285,7 +285,7 @@ class SecretsTestCase(base.TestCase):
         headers = {"Content-Type": "crypto/boom"}
 
         resp, secret_ref = self.behaviors.create_secret(test_model, headers)
-        self.assertEqual(resp.status_code, 415)
+        self.assertEqual(415, resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_create_with_oversized_payload(self):
@@ -299,7 +299,7 @@ class SecretsTestCase(base.TestCase):
         test_model.payload = str(self.oversized_payload)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 413)
+        self.assertEqual(413, resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_put_when_payload_doesnt_exist(self):
@@ -313,7 +313,7 @@ class SecretsTestCase(base.TestCase):
             payload_content_encoding='base64',
             payload='testing putting to non-existent secret')
 
-        self.assertEqual(resp.status_code, 404)
+        self.assertEqual(404, resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_put_when_payload_already_exists(self):
@@ -325,14 +325,14 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         resp = self.behaviors.update_secret_payload(
             secret_ref=secret_ref,
             payload_content_type='application/octet-stream',
             payload_content_encoding='base64',
             payload='testing putting data in secret that already has data')
-        self.assertEqual(resp.status_code, 409)
+        self.assertEqual(409, resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_put_two_phase_empty_payload(self):
@@ -344,14 +344,14 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_two_phase_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         put_resp = self.behaviors.update_secret_payload(
             secret_ref=secret_ref,
             payload_content_type='application/octet-stream',
             payload_content_encoding='base64',
             payload='')
-        self.assertEqual(put_resp.status_code, 400)
+        self.assertEqual(400, put_resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_put_two_phase_invalid_content_type(self):
@@ -364,14 +364,14 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_two_phase_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         put_resp = self.behaviors.update_secret_payload(
             secret_ref=secret_ref,
             payload_content_type='crypto/boom',
             payload_content_encoding='base64',
             payload='invalid content type')
-        self.assertEqual(put_resp.status_code, 415)
+        self.assertEqual(415, put_resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_put_two_phase_no_payload(self):
@@ -383,14 +383,14 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_two_phase_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         put_resp = self.behaviors.update_secret_payload(
             secret_ref=secret_ref,
             payload_content_type='application/octet-stream',
             payload_content_encoding='base64',
             payload=None)
-        self.assertEqual(put_resp.status_code, 400)
+        self.assertEqual(400, put_resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_put_two_phase_w_oversized_binary_data_not_utf8(self):
@@ -408,14 +408,14 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_two_phase_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         put_resp = self.behaviors.update_secret_payload(
             secret_ref=secret_ref,
             payload_content_type='application/octet-stream',
             payload_content_encoding='base64',
             payload=str(oversized_payload))
-        self.assertEqual(put_resp.status_code, 413)
+        self.assertEqual(413, put_resp.status_code)
 
     @testcase.attr('negative')
     def test_secret_put_two_phase_oversized_payload(self):
@@ -430,14 +430,14 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_two_phase_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         put_resp = self.behaviors.update_secret_payload(
             secret_ref=secret_ref,
             payload_content_type='application/octet-stream',
             payload_content_encoding='base64',
             payload=oversized_payload)
-        self.assertEqual(put_resp.status_code, 413)
+        self.assertEqual(413, put_resp.status_code)
 
     @testcase.attr('positive')
     def test_secret_put_two_phase_valid_binary_data_not_utf8(self):
@@ -452,14 +452,14 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_two_phase_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         put_resp = self.behaviors.update_secret_payload(
             secret_ref=secret_ref,
             payload_content_type='application/octet-stream',
             payload_content_encoding='base64',
             payload=str(data))
-        self.assertEqual(put_resp.status_code, 204)
+        self.assertEqual(204, put_resp.status_code)
 
     @testcase.attr('positive')
     def test_secret_put_two_phase_high_range_unicode_character(self):
@@ -473,14 +473,14 @@ class SecretsTestCase(base.TestCase):
             **self.default_secret_create_two_phase_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         put_resp = self.behaviors.update_secret_payload(
             secret_ref=secret_ref,
             payload_content_type='application/octet-stream',
             payload_content_encoding='base64',
             payload=data)
-        self.assertEqual(put_resp.status_code, 204)
+        self.assertEqual(204, put_resp.status_code)
 
     @testcase.attr('positive')
     def test_secret_get_nones_payload_with_a_octet_stream(self):
@@ -492,13 +492,13 @@ class SecretsTestCase(base.TestCase):
         test_model.payload = base64.b64encode('abcdef')
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         get_resp = self.behaviors.get_secret(
             secret_ref,
             payload_content_type=test_model.payload_content_type,
             payload_content_encoding=test_model.payload_content_encoding)
-        self.assertEqual(get_resp.status_code, 200)
+        self.assertEqual(200, get_resp.status_code)
         self.assertIn(test_model.payload,
                       binascii.b2a_base64(get_resp.content))
 
@@ -512,7 +512,7 @@ class SecretsTestCase(base.TestCase):
         resp, secret_ref = self.behaviors.create_secret(test_model)
 
         # first, ensure that the return code is 400
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
         resp_dict = json.loads(resp.content)
 
@@ -540,18 +540,18 @@ class SecretsTestCase(base.TestCase):
         test_model.expiration = timestamp
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         # now get the secret - will be still valid
         get_resp = self.behaviors.get_secret_metadata(secret_ref)
-        self.assertEqual(get_resp.status_code, 200)
+        self.assertEqual(200, get_resp.status_code)
 
         # now wait 10 seconds
         time.sleep(10)
 
         # now get the secret - should be invalid (expired)
         resp = self.behaviors.get_secret_metadata(secret_ref)
-        self.assertEqual(resp.status_code, 404)
+        self.assertEqual(404, resp.status_code)
 
     @utils.parameterized_dataset({
         'alphanumeric': ['1f34ds'],
@@ -569,7 +569,7 @@ class SecretsTestCase(base.TestCase):
         test_model.name = name
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @utils.parameterized_dataset({
         'int': [400]
@@ -585,7 +585,7 @@ class SecretsTestCase(base.TestCase):
         test_model.name = name
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @testcase.attr('positive', 'non-standard-algorithm')
     @testtools.skipIf(utils.is_kmip_enabled(),
@@ -598,7 +598,7 @@ class SecretsTestCase(base.TestCase):
         test_model.algorithm = algorithm
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @utils.parameterized_dataset({
         'int': [400]
@@ -611,7 +611,7 @@ class SecretsTestCase(base.TestCase):
         test_model.algorithm = algorithm
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @testtools.skipIf(utils.is_kmip_enabled(),
                       "KMIP does not support non-standard bit lengths")
@@ -631,7 +631,7 @@ class SecretsTestCase(base.TestCase):
         test_model.bit_length = bit_length
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @utils.parameterized_dataset({
         '128': [128],
@@ -653,7 +653,7 @@ class SecretsTestCase(base.TestCase):
         test_model.payload = secret64
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @utils.parameterized_dataset({
         'str_type': ['not-an-int'],
@@ -671,7 +671,7 @@ class SecretsTestCase(base.TestCase):
         test_model.bit_length = bit_length
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @utils.parameterized_dataset({
         'cbc': ['cbc'],
@@ -685,7 +685,7 @@ class SecretsTestCase(base.TestCase):
         test_model.mode = mode
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @utils.parameterized_dataset({
         'zero': [0],
@@ -700,7 +700,7 @@ class SecretsTestCase(base.TestCase):
         test_model.mode = mode
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @utils.parameterized_dataset({
         'text_content_type_none_encoding': {
@@ -729,13 +729,13 @@ class SecretsTestCase(base.TestCase):
         test_model.payload_content_encoding = payload_content_encoding
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         get_resp = self.behaviors.get_secret(
             secret_ref,
             payload_content_type=payload_content_type,
             payload_content_encoding=payload_content_encoding)
-        self.assertEqual(get_resp.status_code, 200)
+        self.assertEqual(200, get_resp.status_code)
 
         if payload_content_encoding == 'base64':
             self.assertIn(test_model.payload,
@@ -770,13 +770,13 @@ class SecretsTestCase(base.TestCase):
         test_model.payload_content_encoding = payload_content_encoding
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         get_resp = self.behaviors.get_secret_based_on_content_type(
             secret_ref,
             payload_content_type=payload_content_type,
             payload_content_encoding=payload_content_encoding)
-        self.assertEqual(get_resp.status_code, 200)
+        self.assertEqual(200, get_resp.status_code)
 
         if payload_content_encoding == 'base64':
             self.assertIn(test_model.payload,
@@ -863,7 +863,7 @@ class SecretsTestCase(base.TestCase):
         test_model.payload_content_encoding = payload_content_encoding
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @utils.parameterized_dataset({
         'max_payload_string': [base.TestCase.max_sized_payload]
@@ -877,7 +877,7 @@ class SecretsTestCase(base.TestCase):
         test_model.override_values(**overrides)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @utils.parameterized_dataset({
         'empty': [''],
@@ -898,7 +898,7 @@ class SecretsTestCase(base.TestCase):
         test_model.override_values(**overrides)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @utils.parameterized_dataset({
         'negative_five_long_expire': {
@@ -928,7 +928,7 @@ class SecretsTestCase(base.TestCase):
         test_model.expiration = timestamp
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
     @utils.parameterized_dataset({
         'malformed_timezone': {
@@ -946,7 +946,7 @@ class SecretsTestCase(base.TestCase):
         test_model.expiration = timestamp
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
     @testcase.skipIf(not base.conf_host_href_used, 'response href using '
                      'wsgi request instead of CONF.host_href')
@@ -963,7 +963,7 @@ class SecretsTestCase(base.TestCase):
         resp, secret_ref = self.behaviors.create_secret(
             test_model, extra_headers=changed_host_header)
 
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         # get Location field from result and assert that it is NOT the
         # malicious one.
@@ -987,7 +987,7 @@ class SecretsTestCase(base.TestCase):
         # deleting that secret during cleanup step
         resp, secret_ref = self.behaviors.create_secret(
             test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         resp = self.behaviors.get_secret_metadata(
             secret_ref, extra_headers=changed_host_header)
@@ -1058,7 +1058,7 @@ class SecretsTestCase(base.TestCase):
         headers = {"Content-Type": http_content_type}
 
         resp, secret_ref = self.behaviors.create_secret(test_model, headers)
-        self.assertEqual(resp.status_code, 415)
+        self.assertEqual(415, resp.status_code)
 
     @utils.parameterized_dataset({
         'invalid_http_content_type_characaters_latin': {
@@ -1085,7 +1085,7 @@ class SecretsTestCase(base.TestCase):
         test_model.payload_content_type = payload_content_type
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(400, resp.status_code)
 
 
 class SecretsPagingTestCase(base.PagingTestCase):
diff --git a/functionaltests/api/v1/smoke/test_consumers.py b/functionaltests/api/v1/smoke/test_consumers.py
index 6c0d7b820..24b62d8de 100644
--- a/functionaltests/api/v1/smoke/test_consumers.py
+++ b/functionaltests/api/v1/smoke/test_consumers.py
@@ -60,7 +60,7 @@ class ConsumersTestCase(base.TestCase):
     def _create_a_secret(self):
         secret_model = secret_models.SecretModel(**create_secret_data)
         resp, secret_ref = self.secret_behaviors.create_secret(secret_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertIsNotNone(secret_ref)
 
         return secret_ref
@@ -91,7 +91,7 @@ class ConsumersTestCase(base.TestCase):
         resp, container_ref = self.container_behaviors.create_container(
             container_model
         )
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertIsNotNone(container_ref)
         self.container_ref = container_ref
 
@@ -112,7 +112,7 @@ class ConsumersTestCase(base.TestCase):
         resp, consumer_data = self.consumer_behaviors.create_consumer(
             test_model, self.container_ref)
 
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
 
     @testcase.attr('positive')
@@ -123,7 +123,7 @@ class ConsumersTestCase(base.TestCase):
         resp, consumer_data = self.consumer_behaviors.create_consumer(
             test_model, self.container_ref)
 
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
 
         # Create second consumer
@@ -133,14 +133,14 @@ class ConsumersTestCase(base.TestCase):
         resp, consumer_data = self.consumer_behaviors.create_consumer(
             test_model, self.container_ref)
 
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
 
         # Get list of consumers
         resp, consumers, nref, pref = self.consumer_behaviors.get_consumers(
             self.container_ref
         )
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIn("consumername", consumers[0].name)
         self.assertIn("consumername2", consumers[1].name)
 
@@ -155,14 +155,14 @@ class ConsumersTestCase(base.TestCase):
         resp, consumer_data = self.consumer_behaviors.create_consumer(
             test_model, self.container_ref)
 
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
 
         # Delete the consumer
         resp, consumer_data = self.consumer_behaviors.delete_consumer(
             test_model, self.container_ref
         )
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
         self.assertNotIn(test_model.name, consumer_data)
         self.assertNotIn(test_model.URL, consumer_data)
@@ -174,14 +174,14 @@ class ConsumersTestCase(base.TestCase):
         resp, consumer_data = self.consumer_behaviors.create_consumer(
             test_model, self.container_ref)
 
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
 
         # Delete the consumer
         resp, consumer_data = self.consumer_behaviors.delete_consumer(
             test_model, self.container_ref
         )
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
         self.assertNotIn(test_model.name, consumer_data)
         self.assertNotIn(test_model.URL, consumer_data)
@@ -191,7 +191,7 @@ class ConsumersTestCase(base.TestCase):
         resp, consumer_data = self.consumer_behaviors.create_consumer(
             test_model, self.container_ref)
 
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
 
     @testcase.attr('positive')
@@ -202,7 +202,7 @@ class ConsumersTestCase(base.TestCase):
         resp, consumer_data = self.consumer_behaviors.create_consumer(
             test_model, self.container_ref)
 
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
 
         # Register the consumer again, without deleting it first
@@ -212,7 +212,7 @@ class ConsumersTestCase(base.TestCase):
 
         count = consumer_data.count(self.consumer_data)
 
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
         self.assertIn(self.consumer_data, consumer_data)
         self.assertEqual(1, count)
@@ -232,7 +232,7 @@ class ConsumersTestCase(base.TestCase):
         resp, consumer_data = self.consumer_behaviors.create_consumer(
             test_model, self.container_ref, extra_headers=changed_host_header)
 
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         self.assertIsNotNone(consumer_data)
 
         # get Location field from result and assert that it is NOT the
diff --git a/functionaltests/api/v1/smoke/test_containers.py b/functionaltests/api/v1/smoke/test_containers.py
index 975061c6e..110540187 100644
--- a/functionaltests/api/v1/smoke/test_containers.py
+++ b/functionaltests/api/v1/smoke/test_containers.py
@@ -111,14 +111,14 @@ class ContainersTestCase(base.TestCase):
     def _create_a_secret(self):
         secret_model = secret_models.SecretModel(**create_secret_defaults_data)
         resp, secret_ref = self.secret_behaviors.create_secret(secret_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertIsNotNone(secret_ref)
 
         return secret_ref
 
     def _get_a_secret(self, secret_id):
         resp = self.client.get('secrets/{0}'.format(secret_id))
-        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(200, resp.status_code)
         return resp.json()
 
     @testcase.attr('positive')
@@ -129,7 +129,7 @@ class ContainersTestCase(base.TestCase):
 
         resp, container_ref = self.behaviors.create_container(
             test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertGreater(len(container_ref), 0)
 
     @testcase.attr('positive')
@@ -139,7 +139,7 @@ class ContainersTestCase(base.TestCase):
             **create_container_defaults_data)
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertGreater(len(container_ref), 0)
 
     @testcase.attr('positive')
@@ -149,7 +149,7 @@ class ContainersTestCase(base.TestCase):
             **create_container_rsa_data)
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertGreater(len(container_ref), 0)
 
     @utils.parameterized_dataset({
@@ -172,19 +172,19 @@ class ContainersTestCase(base.TestCase):
             secret_refs.append(secret_ref['secret_ref'])
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertGreater(len(container_ref), 0)
 
         get_resp = self.behaviors.get_container(container_ref)
 
         # Verify the response data
-        self.assertEqual(get_resp.status_code, 200)
-        self.assertEqual(get_resp.model.name, test_model.name)
-        self.assertEqual(get_resp.model.container_ref, container_ref)
-        self.assertEqual(get_resp.model.type, test_model.type)
+        self.assertEqual(200, get_resp.status_code)
+        self.assertEqual(test_model.name, get_resp.model.name)
+        self.assertEqual(container_ref, get_resp.model.container_ref)
+        self.assertEqual(test_model.type, get_resp.model.type)
 
         # Verify the secret refs in the response
-        self.assertEqual(len(get_resp.model.secret_refs), 3)
+        self.assertEqual(3, len(get_resp.model.secret_refs))
         self.assertIn(get_resp.model.secret_refs[0].secret_ref, secret_refs)
         self.assertIn(get_resp.model.secret_refs[1].secret_ref, secret_refs)
         self.assertIn(get_resp.model.secret_refs[2].secret_ref, secret_refs)
@@ -199,20 +199,20 @@ class ContainersTestCase(base.TestCase):
             secret_refs.append(secret_ref['secret_ref'])
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertGreater(len(container_ref), 0)
 
         get_resp = self.behaviors.get_container(
             container_ref)
 
         # Verify the response data
-        self.assertEqual(get_resp.status_code, 200)
-        self.assertEqual(get_resp.model.name, "rsacontainer")
-        self.assertEqual(get_resp.model.container_ref, container_ref)
-        self.assertEqual(get_resp.model.type, "rsa")
+        self.assertEqual(200, get_resp.status_code)
+        self.assertEqual("rsacontainer", get_resp.model.name)
+        self.assertEqual(container_ref, get_resp.model.container_ref)
+        self.assertEqual("rsa", get_resp.model.type)
 
         # Verify the secret refs in the response
-        self.assertEqual(len(get_resp.model.secret_refs), 3)
+        self.assertEqual(3, len(get_resp.model.secret_refs))
         self.assertIn(get_resp.model.secret_refs[0].secret_ref, secret_refs)
         self.assertIn(get_resp.model.secret_refs[1].secret_ref, secret_refs)
         self.assertIn(get_resp.model.secret_refs[2].secret_ref, secret_refs)
@@ -226,7 +226,7 @@ class ContainersTestCase(base.TestCase):
             **create_container_defaults_data)
         for i in range(11):
             resp, container_ref = self.behaviors.create_container(test_model)
-            self.assertEqual(resp.status_code, 201)
+            self.assertEqual(201, resp.status_code)
             self.assertGreater(len(container_ref), 0)
 
         resp, containers, next_ref, prev_ref = self.behaviors.get_containers(
@@ -234,8 +234,8 @@ class ContainersTestCase(base.TestCase):
             offset=offset
         )
 
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual(len(containers), limit)
+        self.assertEqual(200, resp.status_code)
+        self.assertEqual(limit, len(containers))
         self.assertIsNone(prev_ref)
         self.assertIsNotNone(next_ref)
 
@@ -245,9 +245,9 @@ class ContainersTestCase(base.TestCase):
             **create_container_defaults_data)
 
         resp, container_ref = self.behaviors.create_container(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertGreater(len(container_ref), 0)
 
         del_resp = self.behaviors.delete_container(container_ref)
-        self.assertEqual(del_resp.status_code, 204)
-        self.assertEqual(len(del_resp.content), 0)
+        self.assertEqual(204, del_resp.status_code)
+        self.assertEqual(0, len(del_resp.content))
diff --git a/functionaltests/api/v1/smoke/test_orders.py b/functionaltests/api/v1/smoke/test_orders.py
index 2553b9d4a..e3327f738 100644
--- a/functionaltests/api/v1/smoke/test_orders.py
+++ b/functionaltests/api/v1/smoke/test_orders.py
@@ -83,7 +83,7 @@ class OrdersTestCase(base.TestCase):
         create_resp, order_ref = self.behaviors.create_order(test_model)
 
         # verify that the order was created successfully
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
     @testcase.attr('positive')
@@ -98,26 +98,26 @@ class OrdersTestCase(base.TestCase):
         create_resp, order_ref = self.behaviors.create_order(test_model)
 
         # verify that the order was created successfully
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
         # given the order href, retrieve the order
         order_resp = self.behaviors.get_order(order_ref)
 
         # verify that the get was successful
-        self.assertEqual(order_resp.status_code, 200)
+        self.assertEqual(200, order_resp.status_code)
         self.assertTrue(order_resp.model.status == "ACTIVE" or
                         order_resp.model.status == "PENDING")
 
         # verify the metadata
-        self.assertEqual(order_resp.model.meta.get('name'),
-                         test_model.meta.get('name'))
-        self.assertEqual(order_resp.model.meta.get('mode'),
-                         test_model.meta.get('mode'))
-        self.assertEqual(order_resp.model.meta.get('algorithm'),
-                         test_model.meta.get('algorithm'))
-        self.assertEqual(order_resp.model.meta.get('bit_length'),
-                         test_model.meta.get('bit_length'))
+        self.assertEqual(test_model.meta.get('name'),
+                         order_resp.model.meta.get('name'))
+        self.assertEqual(test_model.meta.get('mode'),
+                         order_resp.model.meta.get('mode'))
+        self.assertEqual(test_model.meta.get('algorithm'),
+                         order_resp.model.meta.get('algorithm'))
+        self.assertEqual(test_model.meta.get('bit_length'),
+                         order_resp.model.meta.get('bit_length'))
 
     @testcase.attr('positive')
     def test_order_get(self):
@@ -129,16 +129,16 @@ class OrdersTestCase(base.TestCase):
         # create an order
         test_model = order_models.OrderModel(**self.create_default_data)
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
         # get the order
         order_resp = self.behaviors.get_order(order_ref)
 
         # verify the order
-        self.assertEqual(order_resp.status_code, 200)
+        self.assertEqual(200, order_resp.status_code)
         self.assertIsNotNone(order_resp.model.order_ref)
-        self.assertEqual(order_resp.model.type, 'key')
+        self.assertEqual('key', order_resp.model.type)
         self.assertTrue(order_resp.model.status == "ACTIVE" or
                         order_resp.model.status == "PENDING")
 
@@ -149,14 +149,14 @@ class OrdersTestCase(base.TestCase):
         # create an order
         test_model = order_models.OrderModel(**self.create_default_data)
         create_resp, order_ref = self.behaviors.create_order(test_model)
-        self.assertEqual(create_resp.status_code, 202)
+        self.assertEqual(202, create_resp.status_code)
         self.assertIsNotNone(order_ref)
 
         # delete the order
         delete_resp = self.behaviors.delete_order(order_ref)
 
         # verify the delete
-        self.assertEqual(delete_resp.status_code, 204)
+        self.assertEqual(204, delete_resp.status_code)
 
     @testcase.attr('positive')
     def test_orders_get(self):
@@ -166,7 +166,7 @@ class OrdersTestCase(base.TestCase):
         test_model = order_models.OrderModel(**self.create_default_data)
         for i in range(0, 11):
             create_resp, order_ref = self.behaviors.create_order(test_model)
-            self.assertEqual(create_resp.status_code, 202)
+            self.assertEqual(202, create_resp.status_code)
             self.assertIsNotNone(order_ref)
 
         # get a list of orders
@@ -176,7 +176,7 @@ class OrdersTestCase(base.TestCase):
             limit=limit, offset=offset)
 
         # verify that the get for the list was successful
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual(len(orders_list), limit)
+        self.assertEqual(200, resp.status_code)
+        self.assertEqual(limit, len(orders_list))
         self.assertIsNotNone(next_ref)
         self.assertIsNone(prev_ref)
diff --git a/functionaltests/api/v1/smoke/test_secrets.py b/functionaltests/api/v1/smoke/test_secrets.py
index 1e1143e9c..dc990d17d 100644
--- a/functionaltests/api/v1/smoke/test_secrets.py
+++ b/functionaltests/api/v1/smoke/test_secrets.py
@@ -97,11 +97,11 @@ class SecretsTestCase(base.TestCase):
         test_model.expiration = None
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         resp = self.behaviors.get_secret_metadata(secret_ref)
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual(resp.model.status, "ACTIVE")
+        self.assertEqual(200, resp.status_code)
+        self.assertEqual("ACTIVE", resp.model.status)
         self.assertGreater(resp.model.secret_ref, 0)
 
     @utils.parameterized_dataset({
@@ -119,15 +119,15 @@ class SecretsTestCase(base.TestCase):
         test_model.name = name
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         resp = self.behaviors.get_secret_metadata(secret_ref)
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual(resp.model.status, "ACTIVE")
-        self.assertEqual(resp.model.name, test_model.name)
-        self.assertEqual(resp.model.mode, test_model.mode)
-        self.assertEqual(resp.model.algorithm, test_model.algorithm)
-        self.assertEqual(resp.model.bit_length, test_model.bit_length)
+        self.assertEqual(200, resp.status_code)
+        self.assertEqual("ACTIVE", resp.model.status)
+        self.assertEqual(test_model.name, resp.model.name)
+        self.assertEqual(test_model.mode, resp.model.mode)
+        self.assertEqual(test_model.algorithm, resp.model.algorithm)
+        self.assertEqual(test_model.bit_length, resp.model.bit_length)
 
     @testcase.attr('positive')
     def test_secret_create(self):
@@ -139,7 +139,7 @@ class SecretsTestCase(base.TestCase):
         test_model = secret_models.SecretModel(**self.create_default_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
         self.assertIsNotNone(secret_ref)
 
     @testcase.attr('positive')
@@ -148,10 +148,10 @@ class SecretsTestCase(base.TestCase):
         test_model = secret_models.SecretModel(**self.create_default_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         del_resp = self.behaviors.delete_secret(secret_ref)
-        self.assertEqual(del_resp.status_code, 204)
+        self.assertEqual(204, del_resp.status_code)
 
     @testcase.attr('positive')
     def test_secret_delete_minimal_secret_w_no_metadata(self):
@@ -159,10 +159,10 @@ class SecretsTestCase(base.TestCase):
         test_model = secret_models.SecretModel(**self.create_all_none_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         del_resp = self.behaviors.delete_secret(secret_ref)
-        self.assertEqual(del_resp.status_code, 204)
+        self.assertEqual(204, del_resp.status_code)
 
     @testcase.attr('positive')
     def test_secret_get(self):
@@ -170,11 +170,11 @@ class SecretsTestCase(base.TestCase):
         test_model = secret_models.SecretModel(**self.create_default_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         get_resp = self.behaviors.get_secret(secret_ref,
                                              test_model.payload_content_type)
-        self.assertEqual(get_resp.status_code, 200)
+        self.assertEqual(200, get_resp.status_code)
         self.assertIn(test_model.payload,
                       binascii.b2a_base64(get_resp.content))
 
@@ -186,7 +186,7 @@ class SecretsTestCase(base.TestCase):
         test_model = secret_models.SecretModel(**self.create_two_phase_data)
 
         resp, secret_ref = self.behaviors.create_secret(test_model)
-        self.assertEqual(resp.status_code, 201)
+        self.assertEqual(201, resp.status_code)
 
         # Update
         payload = "gF6+lLoF3ohA9aPRpt+6bQ=="
@@ -197,13 +197,13 @@ class SecretsTestCase(base.TestCase):
             secret_ref, payload=payload,
             payload_content_type=payload_content_type,
             payload_content_encoding=payload_content_encoding)
-        self.assertEqual(update_resp.status_code, 204)
+        self.assertEqual(204, update_resp.status_code)
 
         # Get/Check Updated
         sec_resp = self.behaviors.get_secret(
             secret_ref=secret_ref,
             payload_content_type=payload_content_type)
-        self.assertEqual(sec_resp.status_code, 200)
+        self.assertEqual(200, sec_resp.status_code)
         self.assertIn('gF6+lLoF3ohA9aPRpt+6bQ==',
                       binascii.b2a_base64(sec_resp.content))
 
@@ -223,7 +223,7 @@ class SecretsTestCase(base.TestCase):
         resp, secrets_list, next_ref, prev_ref = self.behaviors.get_secrets(
             limit=limit, offset=offset)
 
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual(len(secrets_list), limit)
+        self.assertEqual(200, resp.status_code)
+        self.assertEqual(limit, len(secrets_list))
         self.assertIsNone(prev_ref)
         self.assertIsNotNone(next_ref)
diff --git a/functionaltests/api/v1/smoke/test_versions.py b/functionaltests/api/v1/smoke/test_versions.py
index df89c6746..3501b4dcf 100644
--- a/functionaltests/api/v1/smoke/test_versions.py
+++ b/functionaltests/api/v1/smoke/test_versions.py
@@ -35,7 +35,7 @@ class VersionDiscoveryTestCase(base.TestCase):
         resp = self.client.get(url_without_version, use_auth=use_auth)
         body = resp.json()
 
-        self.assertEqual(resp.status_code, 300)
+        self.assertEqual(300, resp.status_code)
         versions_response = body['versions']['values']
         v1_info = versions_response[0]
 
@@ -43,5 +43,5 @@ class VersionDiscoveryTestCase(base.TestCase):
         # might start using decimal numbers in the future. So when that happens
         # this test will still be valid.
         self.assertIn('v1', v1_info['id'])
-        self.assertEqual(len(v1_info['media-types']), 1)
-        self.assertEqual(v1_info['media-types'][0]['base'], 'application/json')
+        self.assertEqual(1, len(v1_info['media-types']))
+        self.assertEqual('application/json', v1_info['media-types'][0]['base'])