openstack
/
barbican
Code Issues Proposed changes

Fix order of arguments in assertEqual 

The correct order expected by testtools is assertEqual(expected, observed).

Change-Id: I93eaab96f170e72cfcbc763f384fd9358842ef69
Partial-Bug: #1259292
This commit is contained in:
Jiong Liu 2016-09-28 23:19:16 +08:00
parent 2c6a9a9bb0
commit 403e440f85
16 changed files with 345 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
barbican/tests/plugin/crypto/test_p11_crypto.py
View File

@ -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())

100
barbican/tests/plugin/crypto/test_pkcs11.py
View File

@ -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))

4
functionaltests/api/base.py
View File

@ -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)

6
functionaltests/api/v1/functional/test_cas.py
View File

@ -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()

10
functionaltests/api/v1/functional/test_certificate_orders.py
View File

@ -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)

12
functionaltests/api/v1/functional/test_consumers.py
View File

@ -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)

40
functionaltests/api/v1/functional/test_containers.py
View File

@ -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

68
functionaltests/api/v1/functional/test_orders.py
View File

@ -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:

2
functionaltests/api/v1/functional/test_quotas_enforce.py
View File

@ -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):

44
functionaltests/api/v1/functional/test_secretmeta.py
View File

@ -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)

120
functionaltests/api/v1/functional/test_secrets.py
View File

@ -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):

28
functionaltests/api/v1/smoke/test_consumers.py
View File

@ -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

46
functionaltests/api/v1/smoke/test_containers.py
View File

@ -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))

38
functionaltests/api/v1/smoke/test_orders.py
View File

@ -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)

44
functionaltests/api/v1/smoke/test_secrets.py
View File

@ -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)

6
functionaltests/api/v1/smoke/test_versions.py
View File

@ -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'])