openstack
/
keystone
Code Issues Proposed changes

assertEquals is deprecated, use assertEqual (H602) 

Also change uses of assert_ to assertTrue() alongway.

Change-Id: Ic6edd1d89127ae9de5d101c0983adb4b927bfc0e
This commit is contained in:
Dirk Mueller 2013-09-18 14:49:38 +02:00
parent 2f75699719
commit 5142d4f4c2
19 changed files with 271 additions and 278 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
keystone/tests/_ldap_livetest.py
View File

@ -82,7 +82,7 @@ class LiveLDAPIdentity(test_backend_ldap.LDAPIdentity):
#logic is different from the fake backend.
user_api = identity_ldap.UserApi(CONF)
self.assertTrue(user_api)
self.assertEquals(user_api.tree_dn, CONF.ldap.user_tree_dn)
self.assertEqual(user_api.tree_dn, CONF.ldap.user_tree_dn)
def tearDown(self):
tests.TestCase.tearDown(self)
@ -177,7 +177,7 @@ class LiveLDAPIdentity(test_backend_ldap.LDAPIdentity):
for x in range(0, USER_COUNT):
group_refs = self.identity_api.list_groups_for_user(
test_users[x]['id'])
self.assertEquals(len(group_refs), 0)
self.assertEqual(len(group_refs), 0)
for x in range(0, GROUP_COUNT):
new_group = {'id': uuid.uuid4().hex,
@ -188,36 +188,36 @@ class LiveLDAPIdentity(test_backend_ldap.LDAPIdentity):
group_refs = self.identity_api.list_groups_for_user(
positive_user['id'])
self.assertEquals(len(group_refs), x)
self.assertEqual(len(group_refs), x)
self.identity_api.add_user_to_group(
positive_user['id'],
new_group['id'])
group_refs = self.identity_api.list_groups_for_user(
positive_user['id'])
self.assertEquals(len(group_refs), x + 1)
self.assertEqual(len(group_refs), x + 1)
group_refs = self.identity_api.list_groups_for_user(
negative_user['id'])
self.assertEquals(len(group_refs), 0)
self.assertEqual(len(group_refs), 0)
CONF.ldap.group_filter = "(dn=xx)"
self.reload_backends(CONF.identity.default_domain_id)
group_refs = self.identity_api.list_groups_for_user(
positive_user['id'])
self.assertEquals(len(group_refs), 0)
self.assertEqual(len(group_refs), 0)
group_refs = self.identity_api.list_groups_for_user(
negative_user['id'])
self.assertEquals(len(group_refs), 0)
self.assertEqual(len(group_refs), 0)
CONF.ldap.group_filter = "(objectclass=*)"
self.reload_backends(CONF.identity.default_domain_id)
group_refs = self.identity_api.list_groups_for_user(
positive_user['id'])
self.assertEquals(len(group_refs), GROUP_COUNT)
self.assertEqual(len(group_refs), GROUP_COUNT)
group_refs = self.identity_api.list_groups_for_user(
negative_user['id'])
self.assertEquals(len(group_refs), 0)
self.assertEqual(len(group_refs), 0)
def test_user_enable_attribute_mask(self):
CONF.ldap.user_enabled_emulation = False

4
keystone/tests/core.py
View File

@ -421,8 +421,8 @@ class TestCase(NoModule, testtools.TestCase):
self.assertTrue(len(l))
def assertDictEqual(self, d1, d2, msg=None):
self.assert_(isinstance(d1, dict), 'First argument is not a dict')
self.assert_(isinstance(d2, dict), 'Second argument is not a dict')
self.assertTrue(isinstance(d1, dict), 'First argument is not a dict')
self.assertTrue(isinstance(d2, dict), 'Second argument is not a dict')
self.assertEqual(d1, d2, msg)
def assertRaisesRegexp(self, expected_exception, expected_regexp,

62
keystone/tests/test_auth.py
View File

@ -247,8 +247,8 @@ class AuthWithToken(AuthTest):
tenant = scoped_token["access"]["token"]["tenant"]
roles = scoped_token["access"]["metadata"]["roles"]
self.assertEquals(tenant["id"], self.tenant_bar['id'])
self.assertEquals(roles[0], self.role_member['id'])
self.assertEqual(tenant["id"], self.tenant_bar['id'])
self.assertEqual(roles[0], self.role_member['id'])
def test_auth_token_project_group_role(self):
"""Verify getting a token in a tenant with group roles."""
@ -280,7 +280,7 @@ class AuthWithToken(AuthTest):
tenant = scoped_token["access"]["token"]["tenant"]
roles = scoped_token["access"]["metadata"]["roles"]
self.assertEquals(tenant["id"], self.tenant_bar['id'])
self.assertEqual(tenant["id"], self.tenant_bar['id'])
self.assertIn(self.role_member['id'], roles)
self.assertIn(self.role_admin['id'], roles)
@ -333,7 +333,7 @@ class AuthWithToken(AuthTest):
scoped_token = self.controller.authenticate({}, body_dict)
tenant = scoped_token["access"]["token"]["tenant"]
roles = scoped_token["access"]["metadata"]["roles"]
self.assertEquals(tenant["id"], project1['id'])
self.assertEqual(tenant["id"], project1['id'])
self.assertIn(self.role_member['id'], roles)
self.assertIn(self.role_admin['id'], roles)
self.assertNotIn(role_foo_domain1['id'], roles)
@ -645,13 +645,11 @@ class AuthWithTrust(AuthTest):
self.new_trust = None
self.sample_data['roles'] = []
self.create_trust()
self.assertEquals(self.new_trust['roles'], [])
self.assertEqual(self.new_trust['roles'], [])
def test_create_trust(self):
self.assertEquals(self.new_trust['trustor_user_id'],
self.trustor['id'])
self.assertEquals(self.new_trust['trustee_user_id'],
self.trustee['id'])
self.assertEqual(self.new_trust['trustor_user_id'], self.trustor['id'])
self.assertEqual(self.new_trust['trustee_user_id'], self.trustee['id'])
role_ids = [self.role_browser['id'], self.role_member['id']]
self.assertTrue(timeutils.parse_strtime(self.new_trust['expires_at'],
fmt=TIME_FORMAT))
@ -667,26 +665,20 @@ class AuthWithTrust(AuthTest):
context = {'token_id': self.unscoped_token['access']['token']['id']}
trust = self.trust_controller.get_trust(context,
self.new_trust['id'])['trust']
self.assertEquals(trust['trustor_user_id'],
self.trustor['id'])
self.assertEquals(trust['trustee_user_id'],
self.trustee['id'])
self.assertEqual(trust['trustor_user_id'], self.trustor['id'])
self.assertEqual(trust['trustee_user_id'], self.trustee['id'])
role_ids = [self.role_browser['id'], self.role_member['id']]
for role in self.new_trust['roles']:
self.assertIn(role['id'], role_ids)
def test_create_trust_no_impersonation(self):
self.create_trust(expires_at=None, impersonation='False')
self.assertEquals(self.new_trust['trustor_user_id'],
self.trustor['id'])
self.assertEquals(self.new_trust['trustee_user_id'],
self.trustee['id'])
self.assertEquals(self.new_trust['impersonation'],
'False')
self.assertEqual(self.new_trust['trustor_user_id'], self.trustor['id'])
self.assertEqual(self.new_trust['trustee_user_id'], self.trustee['id'])
self.assertEqual(self.new_trust['impersonation'], 'False')
auth_response = self.fetch_v2_token_from_trust()
token_user = auth_response['access']['user']
self.assertEquals(token_user['id'],
self.new_trust['trustee_user_id'])
self.assertEqual(token_user['id'], self.new_trust['trustee_user_id'])
# TODO(ayoung): Endpoints
@ -731,17 +723,17 @@ class AuthWithTrust(AuthTest):
auth_response = self.fetch_v3_token_from_trust()
trust_token_user = auth_response.json['token']['user']
self.assertEquals(trust_token_user['id'], self.trustor['id'])
self.assertEqual(trust_token_user['id'], self.trustor['id'])
trust_token_trust = auth_response.json['token']['OS-TRUST:trust']
self.assertEquals(trust_token_trust['id'], self.new_trust['id'])
self.assertEquals(trust_token_trust['trustor_user']['id'],
self.trustor['id'])
self.assertEquals(trust_token_trust['trustee_user']['id'],
self.trustee['id'])
self.assertEqual(trust_token_trust['id'], self.new_trust['id'])
self.assertEqual(trust_token_trust['trustor_user']['id'],
self.trustor['id'])
self.assertEqual(trust_token_trust['trustee_user']['id'],
self.trustee['id'])
trust_token_roles = auth_response.json['token']['roles']
self.assertEquals(len(trust_token_roles), 2)
self.assertEqual(len(trust_token_roles), 2)
def test_v3_trust_token_get_token_fails(self):
auth_response = self.fetch_v3_token_from_trust()
@ -759,16 +751,16 @@ class AuthWithTrust(AuthTest):
auth_response = self.fetch_v2_token_from_trust()
self.assertIsNotNone(auth_response)
self.assertEquals(len(auth_response['access']['metadata']['roles']),
2,
"user_foo has three roles, but the token should"
" only get the two roles specified in the trust.")
self.assertEqual(len(auth_response['access']['metadata']['roles']),
2,
"user_foo has three roles, but the token should"
" only get the two roles specified in the trust.")
def assert_token_count_for_trust(self, expected_value):
tokens = self.trust_controller.token_api.list_tokens(
self.trustee['id'], trust_id=self.new_trust['id'])
token_count = len(tokens)
self.assertEquals(token_count, expected_value)
self.assertEqual(token_count, expected_value)
def test_delete_tokens_for_user_invalidates_tokens_from_trust(self):
self.assert_token_count_for_trust(0)
@ -792,11 +784,11 @@ class AuthWithTrust(AuthTest):
trust_id = self.new_trust['id']
tokens = self.token_api.list_tokens(self.trustor['id'],
trust_id=trust_id)
self.assertEquals(len(tokens), 1)
self.assertEqual(len(tokens), 1)
self.trust_controller.delete_trust(context, trust_id=trust_id)
tokens = self.token_api.list_tokens(self.trustor['id'],
trust_id=trust_id)
self.assertEquals(len(tokens), 0)
self.assertEqual(len(tokens), 0)
def test_token_from_trust_with_no_role_fails(self):
for assigned_role in self.assigned_roles:

188
keystone/tests/test_backend.py
View File

@ -147,7 +147,7 @@ class IdentityTests(object):
def test_list_user_ids_for_project(self):
user_ids = self.assignment_api.list_user_ids_for_project(
self.tenant_baz['id'])
self.assertEquals(len(user_ids), 2)
self.assertEqual(len(user_ids), 2)
self.assertIn(self.user_two['id'], user_ids)
self.assertIn(self.user_badguy['id'], user_ids)
@ -479,7 +479,7 @@ class IdentityTests(object):
# Read back the full list of assignments - check it is gone up by 4
assignment_list = self.assignment_api.list_role_assignments()
self.assertEquals(len(assignment_list), existing_assignments + 4)
self.assertEqual(len(assignment_list), existing_assignments + 4)
# Now check that each of our four new entries are in the list
self.assertIn(
@ -503,8 +503,8 @@ class IdentityTests(object):
# this only goes up by two.
assignment_list = self.assignment_api.list_role_assignments_for_role(
role_id='admin')
self.assertEquals(len(assignment_list),
existing_assignments_for_role + 2)
self.assertEqual(len(assignment_list),
existing_assignments_for_role + 2)
# Now check that each of our two new entries are in the list
self.assertIn(
@ -622,7 +622,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=new_user1['id'],
domain_id=new_domain['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
# Now create the grants (roles are defined in default_fixtures)
self.identity_api.create_grant(user_id=new_user1['id'],
domain_id=new_domain['id'],
@ -650,7 +650,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=new_user1['id'],
domain_id=new_domain['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
def test_get_roles_for_user_and_domain_404(self):
"""Test errors raised when getting roles for user on a domain.
@ -724,7 +724,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=self.user_foo['id'],
project_id=self.tenant_bar['id'])
self.assertEquals(len(roles_ref), 1)
self.assertEqual(len(roles_ref), 1)
self.identity_api.create_grant(user_id=self.user_foo['id'],
project_id=self.tenant_bar['id'],
role_id=self.role_admin['id'])
@ -762,7 +762,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=self.user_foo['id'],
project_id=self.tenant_baz['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.assertRaises(exception.NotFound,
self.identity_api.delete_grant,
user_id=self.user_foo['id'],
@ -784,7 +784,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
group_id=new_group['id'],
project_id=self.tenant_bar['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.identity_api.create_grant(group_id=new_group['id'],
project_id=self.tenant_bar['id'],
role_id='member')
@ -799,7 +799,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
group_id=new_group['id'],
project_id=self.tenant_bar['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.assertRaises(exception.NotFound,
self.identity_api.delete_grant,
group_id=new_group['id'],
@ -822,7 +822,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
group_id=new_group['id'],
domain_id=new_domain['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.identity_api.create_grant(group_id=new_group['id'],
domain_id=new_domain['id'],
@ -839,7 +839,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
group_id=new_group['id'],
domain_id=new_domain['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.assertRaises(exception.NotFound,
self.identity_api.delete_grant,
group_id=new_group['id'],
@ -872,7 +872,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
group_id=new_group['id'],
domain_id=new_domain['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
# Now add the grant we are going to test for, and some others as
# well just to make sure we get back the right one
self.identity_api.create_grant(group_id=new_group['id'],
@ -900,7 +900,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
group_id=new_group['id'],
domain_id=new_domain['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.assertRaises(exception.NotFound,
self.identity_api.delete_grant,
group_id=new_group['id'],
@ -917,7 +917,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=new_user['id'],
domain_id=new_domain['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.identity_api.create_grant(user_id=new_user['id'],
domain_id=new_domain['id'],
role_id='member')
@ -932,7 +932,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=new_user['id'],
domain_id=new_domain['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.assertRaises(exception.NotFound,
self.identity_api.delete_grant,
user_id=new_user['id'],
@ -958,11 +958,11 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
group_id=group1['id'],
domain_id=domain1['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
roles_ref = self.identity_api.list_grants(
group_id=group1['id'],
domain_id=domain2['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.identity_api.create_grant(group_id=group1['id'],
domain_id=domain1['id'],
role_id=group1_domain1_role['id'])
@ -984,7 +984,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
group_id=group1['id'],
domain_id=domain2['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.assertRaises(exception.NotFound,
self.identity_api.delete_grant,
group_id=group1['id'],
@ -1011,11 +1011,11 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
domain_id=domain1['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
domain_id=domain2['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.identity_api.create_grant(user_id=user1['id'],
domain_id=domain1['id'],
role_id=user1_domain1_role['id'])
@ -1037,7 +1037,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
domain_id=domain2['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.assertRaises(exception.NotFound,
self.identity_api.delete_grant,
user_id=user1['id'],
@ -1062,7 +1062,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
group_id=group1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.identity_api.create_grant(group_id=group1['id'],
project_id=project1['id'],
role_id=role1['id'])
@ -1085,7 +1085,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
group_id=group1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 1)
self.assertEqual(len(roles_ref), 1)
self.assertDictEqual(roles_ref[0], role2)
def test_role_grant_by_user_and_cross_domain_project(self):
@ -1107,7 +1107,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.identity_api.create_grant(user_id=user1['id'],
project_id=project1['id'],
role_id=role1['id'])
@ -1130,7 +1130,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 1)
self.assertEqual(len(roles_ref), 1)
self.assertDictEqual(roles_ref[0], role2)
def test_multi_role_grant_by_user_group_on_project_domain(self):
@ -1163,7 +1163,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.identity_api.create_grant(user_id=user1['id'],
domain_id=domain1['id'],
role_id=role_list[0]['id'])
@ -1190,22 +1190,22 @@ class IdentityTests(object):
role_id=role_list[7]['id'])
roles_ref = self.identity_api.list_grants(user_id=user1['id'],
domain_id=domain1['id'])
self.assertEquals(len(roles_ref), 2)
self.assertEqual(len(roles_ref), 2)
self.assertIn(role_list[0], roles_ref)
self.assertIn(role_list[1], roles_ref)
roles_ref = self.identity_api.list_grants(group_id=group1['id'],
domain_id=domain1['id'])
self.assertEquals(len(roles_ref), 2)
self.assertEqual(len(roles_ref), 2)
self.assertIn(role_list[2], roles_ref)
self.assertIn(role_list[3], roles_ref)
roles_ref = self.identity_api.list_grants(user_id=user1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 2)
self.assertEqual(len(roles_ref), 2)
self.assertIn(role_list[4], roles_ref)
self.assertIn(role_list[5], roles_ref)
roles_ref = self.identity_api.list_grants(group_id=group1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 2)
self.assertEqual(len(roles_ref), 2)
self.assertIn(role_list[6], roles_ref)
self.assertIn(role_list[7], roles_ref)
@ -1214,7 +1214,7 @@ class IdentityTests(object):
# the above results.
combined_role_list = self.identity_api.get_roles_for_user_and_project(
user1['id'], project1['id'])
self.assertEquals(len(combined_role_list), 4)
self.assertEqual(len(combined_role_list), 4)
self.assertIn(role_list[4]['id'], combined_role_list)
self.assertIn(role_list[5]['id'], combined_role_list)
self.assertIn(role_list[6]['id'], combined_role_list)
@ -1222,7 +1222,7 @@ class IdentityTests(object):
combined_role_list = self.identity_api.get_roles_for_user_and_domain(
user1['id'], domain1['id'])
self.assertEquals(len(combined_role_list), 4)
self.assertEqual(len(combined_role_list), 4)
self.assertIn(role_list[0]['id'], combined_role_list)
self.assertIn(role_list[1]['id'], combined_role_list)
self.assertIn(role_list[2]['id'], combined_role_list)
@ -1272,7 +1272,7 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
self.identity_api.create_grant(user_id=user1['id'],
domain_id=domain1['id'],
role_id=role_list[0]['id'])
@ -1296,14 +1296,14 @@ class IdentityTests(object):
# both project and domain
combined_role_list = self.identity_api.get_roles_for_user_and_project(
user1['id'], project1['id'])
self.assertEquals(len(combined_role_list), 3)
self.assertEqual(len(combined_role_list), 3)
self.assertIn(role_list[3]['id'], combined_role_list)
self.assertIn(role_list[4]['id'], combined_role_list)
self.assertIn(role_list[5]['id'], combined_role_list)
combined_role_list = self.identity_api.get_roles_for_user_and_domain(
user1['id'], domain1['id'])
self.assertEquals(len(combined_role_list), 3)
self.assertEqual(len(combined_role_list), 3)
self.assertIn(role_list[0]['id'], combined_role_list)
self.assertIn(role_list[1]['id'], combined_role_list)
self.assertIn(role_list[2]['id'], combined_role_list)
@ -1338,36 +1338,36 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 1)
self.assertEqual(len(roles_ref), 1)
roles_ref = self.identity_api.list_grants(
group_id=group1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 1)
self.assertEqual(len(roles_ref), 1)
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
domain_id=domain1['id'])
self.assertEquals(len(roles_ref), 1)
self.assertEqual(len(roles_ref), 1)
roles_ref = self.identity_api.list_grants(
group_id=group1['id'],
domain_id=domain1['id'])
self.assertEquals(len(roles_ref), 1)
self.assertEqual(len(roles_ref), 1)
self.identity_api.delete_role(role1['id'])
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
roles_ref = self.identity_api.list_grants(
group_id=group1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
domain_id=domain1['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
roles_ref = self.identity_api.list_grants(
group_id=group1['id'],
domain_id=domain1['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
def test_delete_user_with_group_project_domain_links(self):
role1 = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex}
@ -1395,11 +1395,11 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 1)
self.assertEqual(len(roles_ref), 1)
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
domain_id=domain1['id'])
self.assertEquals(len(roles_ref), 1)
self.assertEqual(len(roles_ref), 1)
self.identity_api.check_user_in_group(
user_id=user1['id'],
group_id=group1['id'])
@ -1435,11 +1435,11 @@ class IdentityTests(object):
roles_ref = self.identity_api.list_grants(
group_id=group1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 1)
self.assertEqual(len(roles_ref), 1)
roles_ref = self.identity_api.list_grants(
group_id=group1['id'],
domain_id=domain1['id'])
self.assertEquals(len(roles_ref), 1)
self.assertEqual(len(roles_ref), 1)
self.identity_api.check_user_in_group(
user_id=user1['id'],
group_id=group1['id'])
@ -1813,7 +1813,7 @@ class IdentityTests(object):
self.identity_api.create_group(group1['id'], group1)
self.identity_api.create_group(group2['id'], group2)
groups = self.identity_api.list_groups()
self.assertEquals(len(groups), 2)
self.assertEqual(len(groups), 2)
group_ids = []
for group in groups:
group_ids.append(group.get('id'))
@ -1826,7 +1826,7 @@ class IdentityTests(object):
self.identity_api.create_domain(domain1['id'], domain1)
self.identity_api.create_domain(domain2['id'], domain2)
domains = self.identity_api.list_domains()
self.assertEquals(len(domains), 3)
self.assertEqual(len(domains), 3)
domain_ids = []
for domain in domains:
domain_ids.append(domain.get('id'))
@ -1836,7 +1836,7 @@ class IdentityTests(object):
def test_list_projects(self):
projects = self.identity_api.list_projects()
self.assertEquals(len(projects), 4)
self.assertEqual(len(projects), 4)
project_ids = []
for project in projects:
project_ids.append(project.get('id'))
@ -1846,7 +1846,7 @@ class IdentityTests(object):
def test_list_projects_for_domain(self):
project_ids = ([x['id'] for x in
self.assignment_api.list_projects(DEFAULT_DOMAIN_ID)])
self.assertEquals(len(project_ids), 4)
self.assertEqual(len(project_ids), 4)
self.assertIn(self.tenant_bar['id'], project_ids)
self.assertIn(self.tenant_baz['id'], project_ids)
self.assertIn(self.tenant_mtu['id'], project_ids)
@ -1863,7 +1863,7 @@ class IdentityTests(object):
self.assignment_api.create_project(project2['id'], project2)
project_ids = ([x['id'] for x in
self.assignment_api.list_projects(domain1['id'])])
self.assertEquals(len(project_ids), 2)
self.assertEqual(len(project_ids), 2)
self.assertIn(project1['id'], project_ids)
self.assertIn(project2['id'], project_ids)
@ -2111,7 +2111,7 @@ class IdentityTests(object):
for x in range(0, USER_COUNT):
group_refs = self.identity_api.list_groups_for_user(
test_users[x]['id'])
self.assertEquals(len(group_refs), 0)
self.assertEqual(len(group_refs), 0)
for x in range(0, GROUP_COUNT):
before_count = x
@ -2126,19 +2126,19 @@ class IdentityTests(object):
#group count increases by one for each
group_refs = self.identity_api.list_groups_for_user(
positive_user['id'])
self.assertEquals(len(group_refs), before_count)
self.assertEqual(len(group_refs), before_count)
self.identity_api.add_user_to_group(
positive_user['id'],
new_group['id'])
group_refs = self.identity_api.list_groups_for_user(
positive_user['id'])
self.assertEquals(len(group_refs), after_count)
self.assertEqual(len(group_refs), after_count)
#Make sure the group count for the unrelated user
#did not change
group_refs = self.identity_api.list_groups_for_user(
negative_user['id'])
self.assertEquals(len(group_refs), 0)
self.assertEqual(len(group_refs), 0)
#remove the user from each group and ensure that
#the group count reduces by one for each
@ -2147,18 +2147,18 @@ class IdentityTests(object):
after_count = GROUP_COUNT - x - 1
group_refs = self.identity_api.list_groups_for_user(
positive_user['id'])
self.assertEquals(len(group_refs), before_count)
self.assertEqual(len(group_refs), before_count)
self.identity_api.remove_user_from_group(
positive_user['id'],
test_groups[x]['id'])
group_refs = self.identity_api.list_groups_for_user(
positive_user['id'])
self.assertEquals(len(group_refs), after_count)
self.assertEqual(len(group_refs), after_count)
#Make sure the group count for the unrelated user
#did not change
group_refs = self.identity_api.list_groups_for_user(
negative_user['id'])
self.assertEquals(len(group_refs), 0)
self.assertEqual(len(group_refs), 0)
def test_remove_user_from_group(self):
domain = self._get_domain_fixture()
@ -2386,7 +2386,7 @@ class IdentityTests(object):
'enabled': True}
self.identity_api.create_user(user1['id'], user1)
user_projects = self.assignment_api.list_projects_for_user(user1['id'])
self.assertEquals(len(user_projects), 0)
self.assertEqual(len(user_projects), 0)
self.identity_api.create_grant(user_id=user1['id'],
project_id=self.tenant_bar['id'],
role_id=self.role_member['id'])
@ -2394,7 +2394,7 @@ class IdentityTests(object):
project_id=self.tenant_baz['id'],
role_id=self.role_member['id'])
user_projects = self.assignment_api.list_projects_for_user(user1['id'])
self.assertEquals(len(user_projects), 2)
self.assertEqual(len(user_projects), 2)
def test_list_projects_for_user_with_grants(self):
# Create two groups each with a role on a different project, and
@ -2432,7 +2432,7 @@ class IdentityTests(object):
project_id=project2['id'],
role_id=self.role_admin['id'])
user_projects = self.assignment_api.list_projects_for_user(user1['id'])
self.assertEquals(len(user_projects), 3)
self.assertEqual(len(user_projects), 3)
def test_cache_layer_domain_crud(self):
domain = {'id': uuid.uuid4().hex, 'name': uuid.uuid4().hex,
@ -2603,7 +2603,7 @@ class TokenTests(object):
new_data_ref.pop('user_id')
new_data_ref.pop('id')
self.assertEquals(new_data_ref, data)
self.assertEqual(new_data_ref, data)
self.token_api.delete_token(token_id)
self.assertRaises(exception.TokenNotFound,
@ -2627,19 +2627,19 @@ class TokenTests(object):
def test_delete_tokens(self):
tokens = self.token_api.list_tokens('testuserid')
self.assertEquals(len(tokens), 0)
self.assertEqual(len(tokens), 0)
token_id1 = self.create_token_sample_data('testtenantid')
token_id2 = self.create_token_sample_data('testtenantid')
token_id3 = self.create_token_sample_data(tenant_id='testtenantid',
user_id="testuserid1")
tokens = self.token_api.list_tokens('testuserid')
self.assertEquals(len(tokens), 2)
self.assertEqual(len(tokens), 2)
self.assertIn(token_id2, tokens)
self.assertIn(token_id1, tokens)
self.token_api.delete_tokens(user_id='testuserid',
tenant_id='testtenantid')
tokens = self.token_api.list_tokens('testuserid')
self.assertEquals(len(tokens), 0)
self.assertEqual(len(tokens), 0)
self.assertRaises(exception.TokenNotFound,
self.token_api.get_token, token_id1)
self.assertRaises(exception.TokenNotFound,
@ -2649,14 +2649,14 @@ class TokenTests(object):
def test_delete_tokens_trust(self):
tokens = self.token_api.list_tokens(user_id='testuserid')
self.assertEquals(len(tokens), 0)
self.assertEqual(len(tokens), 0)
token_id1 = self.create_token_sample_data(tenant_id='testtenantid',
trust_id='testtrustid')
token_id2 = self.create_token_sample_data(tenant_id='testtenantid',
user_id="testuserid1",
trust_id="testtrustid1")
tokens = self.token_api.list_tokens('testuserid')
self.assertEquals(len(tokens), 1)
self.assertEqual(len(tokens), 1)
self.assertIn(token_id1, tokens)
self.token_api.delete_tokens(user_id='testuserid',
tenant_id='testtenantid',
@ -2667,14 +2667,14 @@ class TokenTests(object):
def test_token_list(self):
tokens = self.token_api.list_tokens('testuserid')
self.assertEquals(len(tokens), 0)
self.assertEqual(len(tokens), 0)
token_id1 = self.create_token_sample_data()
tokens = self.token_api.list_tokens('testuserid')
self.assertEquals(len(tokens), 1)
self.assertEqual(len(tokens), 1)
self.assertIn(token_id1, tokens)
token_id2 = self.create_token_sample_data()
tokens = self.token_api.list_tokens('testuserid')
self.assertEquals(len(tokens), 2)
self.assertEqual(len(tokens), 2)
self.assertIn(token_id2, tokens)
self.assertIn(token_id1, tokens)
self.token_api.delete_token(token_id1)
@ -2694,14 +2694,14 @@ class TokenTests(object):
# test for existing but empty tenant (LP:1078497)
token_id5 = self.create_token_sample_data(tenant_id=NULL_OBJECT)
tokens = self.token_api.list_tokens('testuserid')
self.assertEquals(len(tokens), 3)
self.assertEqual(len(tokens), 3)
self.assertNotIn(token_id1, tokens)
self.assertNotIn(token_id2, tokens)
self.assertIn(token_id3, tokens)
self.assertIn(token_id4, tokens)
self.assertIn(token_id5, tokens)
tokens = self.token_api.list_tokens('testuserid', tenant2)
self.assertEquals(len(tokens), 1)
self.assertEqual(len(tokens), 1)
self.assertNotIn(token_id1, tokens)
self.assertNotIn(token_id2, tokens)
self.assertNotIn(token_id3, tokens)
@ -2711,7 +2711,7 @@ class TokenTests(object):
trust_id = uuid.uuid4().hex
token_id5 = self.create_token_sample_data(trust_id=trust_id)
tokens = self.token_api.list_tokens('testuserid', trust_id=trust_id)
self.assertEquals(len(tokens), 1)
self.assertEqual(len(tokens), 1)
self.assertIn(token_id5, tokens)
def test_get_token_404(self):
@ -2829,11 +2829,11 @@ class TokenTests(object):
self.token_api.create_token(token_id, token_data)
self.token_api.create_token(token2_id, token2_data)
# Verify the revocation list is empty.
self.assertEquals([], self.token_api.list_revoked_tokens())
self.assertEqual([], self.token_api.list_revoked_tokens())
# Delete a token directly, bypassing the manager.
self.token_api.driver.delete_token(token_id)
# Verify the revocation list is still empty.
self.assertEquals([], self.token_api.list_revoked_tokens())
self.assertEqual([], self.token_api.list_revoked_tokens())
# Invalidate the revocation list.
self.token_api.invalidate_revocation_list()
# Verify the deleted token is in the revocation list.
@ -2989,7 +2989,7 @@ class TrustTests(object):
trust_id = trust_data['id']
self.assertIsNotNone(trust_data)
trust_data = self.trust_api.get_trust(trust_id)
self.assertEquals(new_id, trust_data['id'])
self.assertEqual(new_id, trust_data['id'])
self.trust_api.delete_trust(trust_id)
self.assertIsNone(self.trust_api.get_trust(trust_id))
@ -3005,21 +3005,21 @@ class TrustTests(object):
trust_id = trust_data['id']
self.assertIsNotNone(trust_data)
trust_data = self.trust_api.get_trust(trust_id)
self.assertEquals(new_id, trust_data['id'])
self.assertEqual(new_id, trust_data['id'])
def test_create_trust(self):
new_id = uuid.uuid4().hex
trust_data = self.create_sample_trust(new_id)
self.assertEquals(new_id, trust_data['id'])
self.assertEquals(self.trustee['id'], trust_data['trustee_user_id'])
self.assertEquals(self.trustor['id'], trust_data['trustor_user_id'])
self.assertEqual(new_id, trust_data['id'])
self.assertEqual(self.trustee['id'], trust_data['trustee_user_id'])
self.assertEqual(self.trustor['id'], trust_data['trustor_user_id'])
self.assertTrue(timeutils.normalize_time(trust_data['expires_at']) >
timeutils.utcnow())
self.assertEquals([{'id': 'member'},
{'id': 'other'},
{'id': 'browser'}], trust_data['roles'])
self.assertEqual([{'id': 'member'},
{'id': 'other'},
{'id': 'browser'}], trust_data['roles'])
def test_list_trust_by_trustee(self):
for i in range(3):
@ -3295,7 +3295,7 @@ class InheritanceTests(object):
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
# Create the first two roles - the domain one is not inherited
self.identity_api.create_grant(user_id=user1['id'],
@ -3309,7 +3309,7 @@ class InheritanceTests(object):
# should only include the direct role assignment on the project
combined_role_list = self.identity_api.get_roles_for_user_and_project(
user1['id'], project1['id'])
self.assertEquals(len(combined_role_list), 1)
self.assertEqual(len(combined_role_list), 1)
self.assertIn(role_list[0]['id'], combined_role_list)
# Now add an inherited role on the domain
@ -3322,7 +3322,7 @@ class InheritanceTests(object):
# should now include the inherited role on the domain
combined_role_list = self.identity_api.get_roles_for_user_and_project(
user1['id'], project1['id'])
self.assertEquals(len(combined_role_list), 2)
self.assertEqual(len(combined_role_list), 2)
self.assertIn(role_list[0]['id'], combined_role_list)
self.assertIn(role_list[2]['id'], combined_role_list)
@ -3330,7 +3330,7 @@ class InheritanceTests(object):
# directly assigned role on the domain itself
combined_role_list = self.identity_api.get_roles_for_user_and_domain(
user1['id'], domain1['id'])
self.assertEquals(len(combined_role_list), 1)
self.assertEqual(len(combined_role_list), 1)
self.assertIn(role_list[1]['id'], combined_role_list)
def test_inherited_role_grants_for_group(self):
@ -3380,7 +3380,7 @@ class InheritanceTests(object):
roles_ref = self.identity_api.list_grants(
user_id=user1['id'],
project_id=project1['id'])
self.assertEquals(len(roles_ref), 0)
self.assertEqual(len(roles_ref), 0)
# Create two roles - the domain one is not inherited
self.identity_api.create_grant(user_id=user1['id'],
@ -3394,7 +3394,7 @@ class InheritanceTests(object):
# should only include the direct role assignment on the project
combined_role_list = self.identity_api.get_roles_for_user_and_project(
user1['id'], project1['id'])
self.assertEquals(len(combined_role_list), 1)
self.assertEqual(len(combined_role_list), 1)
self.assertIn(role_list[0]['id'], combined_role_list)
# Now add to more group roles, both inherited, to the domain
@ -3411,7 +3411,7 @@ class InheritanceTests(object):
# should now include the inherited roles on the domain
combined_role_list = self.identity_api.get_roles_for_user_and_project(
user1['id'], project1['id'])
self.assertEquals(len(combined_role_list), 3)
self.assertEqual(len(combined_role_list), 3)
self.assertIn(role_list[0]['id'], combined_role_list)
self.assertIn(role_list[2]['id'], combined_role_list)
self.assertIn(role_list[3]['id'], combined_role_list)
@ -3453,7 +3453,7 @@ class InheritanceTests(object):
# Should get back all three projects, one by virtue of the direct
# grant, plus both projects in the domain
user_projects = self.assignment_api.list_projects_for_user(user1['id'])
self.assertEquals(len(user_projects), 3)
self.assertEqual(len(user_projects), 3)
def test_list_projects_for_user_with_inherited_group_grants(self):
"""Test inherited group roles.
@ -3518,4 +3518,4 @@ class InheritanceTests(object):
# Should get back all five projects, but without a duplicate for
# project3 (since it has both a direct user role and an inherited role)
user_projects = self.assignment_api.list_projects_for_user(user1['id'])
self.assertEquals(len(user_projects), 5)
self.assertEqual(len(user_projects), 5)

10
keystone/tests/test_backend_ldap.py
View File

@ -62,7 +62,7 @@ class BaseLDAPIdentity(test_backend.IdentityTests):
"""
user_api = identity.backends.ldap.UserApi(CONF)
self.assertTrue(user_api)
self.assertEquals(user_api.tree_dn, "ou=Users,%s" % CONF.ldap.suffix)
self.assertEqual(user_api.tree_dn, "ou=Users,%s" % CONF.ldap.suffix)
def test_configurable_allowed_user_actions(self):
user = {'id': 'fake1',
@ -260,7 +260,7 @@ class BaseLDAPIdentity(test_backend.IdentityTests):
def test_list_domains(self):
domains = self.identity_api.list_domains()
self.assertEquals(
self.assertEqual(
domains,
[assignment.DEFAULT_DOMAIN])
@ -832,7 +832,7 @@ class LDAPIdentity(tests.TestCase, BaseLDAPIdentity):
combined_role_list = self.identity_api.get_roles_for_user_and_project(
user1['id'], project1['id'])
self.assertEquals(len(combined_role_list), 2)
self.assertEqual(len(combined_role_list), 2)
self.assertIn(role_list[0]['id'], combined_role_list)
self.assertIn(role_list[1]['id'], combined_role_list)
@ -842,7 +842,7 @@ class LDAPIdentity(tests.TestCase, BaseLDAPIdentity):
combined_role_list = self.identity_api.get_roles_for_user_and_domain(
user1['id'], CONF.identity.default_domain_id)
self.assertEquals(len(combined_role_list), 0)
self.assertEqual(len(combined_role_list), 0)
def test_list_projects_for_alternate_domain(self):
self.skipTest(
@ -953,7 +953,7 @@ class LdapIdentitySqlAssignment(sql.Base, tests.TestCase, BaseLDAPIdentity):
def test_list_domains(self):
domains = self.identity_api.list_domains()
self.assertEquals(domains, [assignment.DEFAULT_DOMAIN])
self.assertEqual(domains, [assignment.DEFAULT_DOMAIN])
def test_project_filter(self):
self.skipTest(

8
keystone/tests/test_backend_memcache.py
View File

@ -165,7 +165,7 @@ class MemcacheToken(tests.TestCase, test_backend.TokenTests):
user_key = self.token_api.driver._prefix_user_id(user_id)
user_record = self.token_api.driver.client.get(user_key)
user_token_list = jsonutils.loads('[%s]' % user_record)
self.assertEquals(len(user_token_list), 2)
self.assertEqual(len(user_token_list), 2)
expired_token_ptk = self.token_api.driver._prefix_token_id(
expired_token_id)
expired_token = self.token_api.driver.client.get(expired_token_ptk)
@ -175,7 +175,7 @@ class MemcacheToken(tests.TestCase, test_backend.TokenTests):
self.token_api.create_token(second_valid_token_id, second_valid_data)
user_record = self.token_api.driver.client.get(user_key)
user_token_list = jsonutils.loads('[%s]' % user_record)
self.assertEquals(len(user_token_list), 2)
self.assertEqual(len(user_token_list), 2)
def test_cas_failure(self):
self.token_api.driver.client.reject_cas = True
@ -209,8 +209,8 @@ class MemcacheToken(tests.TestCase, test_backend.TokenTests):
data_get = self.token_api.get_token(data_in['id'])
self.assertIsNotNone(data_get, "TZ=%s" % test_utils.TZ)
self.assertEquals(data_in['id'], data_get['id'],
"TZ=%s" % test_utils.TZ)
self.assertEqual(data_in['id'], data_get['id'],
"TZ=%s" % test_utils.TZ)
expire_time_expired = timeutils.utcnow() + \
datetime.timedelta(minutes=-1)

4
keystone/tests/test_backend_sql.py
View File

@ -77,7 +77,7 @@ class SqlModels(SqlTests):
for col, type_, length in cols:
self.assertIsInstance(table.c[col].type, type_)
if length:
self.assertEquals(table.c[col].type.length, length)
self.assertEqual(table.c[col].type.length, length)
def test_user_model(self):
cols = (('id', sql.String, 64),
@ -219,7 +219,7 @@ class SqlIdentity(SqlTests, test_backend.IdentityTests):
user['id'])
self.assignment_api.delete_project(self.tenant_bar['id'])
tenants = self.assignment_api.list_projects_for_user(user['id'])
self.assertEquals(tenants, [])
self.assertEqual(tenants, [])
def test_metadata_removed_on_delete_user(self):
# A test to check that the internal representation

24
keystone/tests/test_cache.py
View File

@ -145,14 +145,14 @@ class CacheRegionTest(tests.TestCase):
'arg3.invalid']
config_dict = cache.build_cache_config()
self.assertEquals(
self.assertEqual(
config_dict['test_prefix.backend'], CONF.cache.backend)
self.assertEquals(
self.assertEqual(
config_dict['test_prefix.expiration_time'],
CONF.cache.expiration_time)
self.assertEquals(config_dict['test_prefix.arguments.arg1'], 'test')
self.assertEquals(config_dict['test_prefix.arguments.arg2'],
'test:test')
self.assertEqual(config_dict['test_prefix.arguments.arg1'], 'test')
self.assertEqual(config_dict['test_prefix.arguments.arg2'],
'test:test')
self.assertFalse('test_prefix.arguments.arg3' in config_dict)
def test_cache_debug_proxy(self):
@ -161,20 +161,20 @@ class CacheRegionTest(tests.TestCase):
multi_values = {'key1': 1, 'key2': 2, 'key3': 3}
self.region.set(single_key, single_value)
self.assertEquals(single_value, self.region.get(single_key))
self.assertEqual(single_value, self.region.get(single_key))
self.region.delete(single_key)
self.assertEquals(NO_VALUE, self.region.get(single_key))
self.assertEqual(NO_VALUE, self.region.get(single_key))
self.region.set_multi(multi_values)
cached_values = self.region.get_multi(multi_values.keys())
for value in multi_values.values():
self.assertIn(value, cached_values)
self.assertEquals(len(multi_values.values()), len(cached_values))
self.assertEqual(len(multi_values.values()), len(cached_values))
self.region.delete_multi(multi_values.keys())
for value in self.region.get_multi(multi_values.keys()):
self.assertEquals(NO_VALUE, value)
self.assertEqual(NO_VALUE, value)
def test_configure_non_region_object_raises_error(self):
self.assertRaises(exception.ValidationError,
@ -199,13 +199,13 @@ class CacheNoopBackendTest(tests.TestCase):
multi_values = {'key1': 1, 'key2': 2, 'key3': 3}
self.region.set(single_key, single_value)
self.assertEquals(NO_VALUE, self.region.get(single_key))
self.assertEqual(NO_VALUE, self.region.get(single_key))
self.region.set_multi(multi_values)
cached_values = self.region.get_multi(multi_values.keys())
self.assertEquals(len(cached_values), len(multi_values.values()))
self.assertEqual(len(cached_values), len(multi_values.values()))
for value in cached_values:
self.assertEquals(NO_VALUE, value)
self.assertEqual(NO_VALUE, value)
# Delete should not raise exceptions
self.region.delete(single_key)

105
keystone/tests/test_keystoneclient.py
View File

@ -103,14 +103,14 @@ class KeystoneClientTests(object):
def test_authenticate_tenant_name_and_tenants(self):
client = self.get_client()
tenants = client.tenants.list()
self.assertEquals(tenants[0].id, self.tenant_bar['id'])
self.assertEqual(tenants[0].id, self.tenant_bar['id'])
def test_authenticate_tenant_id_and_tenants(self):
client = self._client(username=self.user_foo['name'],
password=self.user_foo['password'],
tenant_id='bar')
tenants = client.tenants.list()
self.assertEquals(tenants[0].id, self.tenant_bar['id'])
self.assertEqual(tenants[0].id, self.tenant_bar['id'])
def test_authenticate_invalid_tenant_id(self):
from keystoneclient import exceptions as client_exceptions
@ -125,14 +125,14 @@ class KeystoneClientTests(object):
token = client.auth_token
token_client = self._client(token=token)
tenants = token_client.tenants.list()
self.assertEquals(tenants[0].id, self.tenant_bar['id'])
self.assertEqual(tenants[0].id, self.tenant_bar['id'])
def test_authenticate_token_tenant_id(self):
client = self.get_client()
token = client.auth_token
token_client = self._client(token=token, tenant_id='bar')
tenants = token_client.tenants.list()
self.assertEquals(tenants[0].id, self.tenant_bar['id'])
self.assertEqual(tenants[0].id, self.tenant_bar['id'])
def test_authenticate_token_invalid_tenant_id(self):
from keystoneclient import exceptions as client_exceptions
@ -155,8 +155,8 @@ class KeystoneClientTests(object):
token = client.auth_token
token_client = self._client(token=token, tenant_name='BAR')
tenants = token_client.tenants.list()
self.assertEquals(tenants[0].id, self.tenant_bar['id'])
self.assertEquals(tenants[0].id, self.tenant_bar['id'])
self.assertEqual(tenants[0].id, self.tenant_bar['id'])
self.assertEqual(tenants[0].id, self.tenant_bar['id'])
def test_authenticate_and_delete_token(self):
from keystoneclient import exceptions as client_exceptions
@ -165,7 +165,7 @@ class KeystoneClientTests(object):
token = client.auth_token
token_client = self._client(token=token)
tenants = token_client.tenants.list()
self.assertEquals(tenants[0].id, self.tenant_bar['id'])
self.assertEqual(tenants[0].id, self.tenant_bar['id'])
client.tokens.delete(token_client.auth_token)
@ -254,19 +254,19 @@ class KeystoneClientTests(object):
tenant = client.tenants.create(tenant_name=tenant_name,
description=tenant_description,
enabled=tenant_enabled)
self.assertEquals(tenant.name, tenant_name)
self.assertEquals(tenant.description, tenant_description)
self.assertEquals(tenant.enabled, tenant_enabled)
self.assertEqual(tenant.name, tenant_name)
self.assertEqual(tenant.description, tenant_description)
self.assertEqual(tenant.enabled, tenant_enabled)
tenant = client.tenants.get(tenant_id=tenant.id)
self.assertEquals(tenant.name, tenant_name)
self.assertEquals(tenant.description, tenant_description)
self.assertEquals(tenant.enabled, tenant_enabled)
self.assertEqual(tenant.name, tenant_name)
self.assertEqual(tenant.description, tenant_description)
self.assertEqual(tenant.enabled, tenant_enabled)
tenant = [t for t in client.tenants.list() if t.id == tenant.id].pop()
self.assertEquals(tenant.name, tenant_name)
self.assertEquals(tenant.description, tenant_description)
self.assertEquals(tenant.enabled, tenant_enabled)
self.assertEqual(tenant.name, tenant_name)
self.assertEqual(tenant.description, tenant_description)
self.assertEqual(tenant.enabled, tenant_enabled)
# update, get, and list a tenant
tenant_name = 'updated_tenant'
@ -276,19 +276,19 @@ class KeystoneClientTests(object):
tenant_name=tenant_name,
enabled=tenant_enabled,
description=tenant_description)
self.assertEquals(tenant.name, tenant_name)
self.assertEquals(tenant.description, tenant_description)
self.assertEquals(tenant.enabled, tenant_enabled)
self.assertEqual(tenant.name, tenant_name)
self.assertEqual(tenant.description, tenant_description)
self.assertEqual(tenant.enabled, tenant_enabled)
tenant = client.tenants.get(tenant_id=tenant.id)
self.assertEquals(tenant.name, tenant_name)
self.assertEquals(tenant.description, tenant_description)
self.assertEquals(tenant.enabled, tenant_enabled)
self.assertEqual(tenant.name, tenant_name)
self.assertEqual(tenant.description, tenant_description)
self.assertEqual(tenant.enabled, tenant_enabled)
tenant = [t for t in client.tenants.list() if t.id == tenant.id].pop()
self.assertEquals(tenant.name, tenant_name)
self.assertEquals(tenant.description, tenant_description)
self.assertEquals(tenant.enabled, tenant_enabled)
self.assertEqual(tenant.name, tenant_name)
self.assertEqual(tenant.description, tenant_description)
self.assertEqual(tenant.enabled, tenant_enabled)
# delete, get, and list a tenant
client.tenants.delete(tenant=tenant.id)
@ -328,12 +328,12 @@ class KeystoneClientTests(object):
def test_tenant_list(self):
client = self.get_client()
tenants = client.tenants.list()
self.assertEquals(len(tenants), 1)
self.assertEqual(len(tenants), 1)
# Admin endpoint should return *all* tenants
client = self.get_client(admin=True)
tenants = client.tenants.list()
self.assertEquals(len(tenants), len(default_fixtures.TENANTS))
self.assertEqual(len(tenants), len(default_fixtures.TENANTS))
def test_invalid_password(self):
from keystoneclient import exceptions as client_exceptions
@ -480,15 +480,15 @@ class KeystoneClientTests(object):
user = client.users.create(name=test_username,
password='password',
email='user1@test.com')
self.assertEquals(user.name, test_username)
self.assertEqual(user.name, test_username)
user = client.users.get(user=user.id)
self.assertEquals(user.name, test_username)
self.assertEqual(user.name, test_username)
user = client.users.update(user=user,
name=test_username,
email='user2@test.com')
self.assertEquals(user.email, 'user2@test.com')
self.assertEqual(user.email, 'user2@test.com')
# NOTE(termie): update_enabled doesn't return anything, probably a bug
client.users.update_enabled(user=user, enabled=False)
@ -520,7 +520,7 @@ class KeystoneClientTests(object):
password='password',
email='user1@test.com',
tenant_id='bar')
self.assertEquals(user2.name, test_username)
self.assertEqual(user2.name, test_username)
def test_update_default_tenant_to_existing_value(self):
client = self.get_client(admin=True)
@ -623,7 +623,7 @@ class KeystoneClientTests(object):
def test_role_get(self):
client = self.get_client(admin=True)
role = client.roles.get(role=self.role_admin['id'])
self.assertEquals(role.id, self.role_admin['id'])
self.assertEqual(role.id, self.role_admin['id'])
def test_role_crud(self):
from keystoneclient import exceptions as client_exceptions
@ -631,10 +631,10 @@ class KeystoneClientTests(object):
test_role = 'new_role'
client = self.get_client(admin=True)
role = client.roles.create(name=test_role)
self.assertEquals(role.name, test_role)
self.assertEqual(role.name, test_role)
role = client.roles.get(role=role.id)
self.assertEquals(role.name, test_role)
self.assertEqual(role.name, test_role)
client.roles.delete(role=role.id)
@ -700,19 +700,19 @@ class KeystoneClientTests(object):
service = client.services.create(name=service_name,
service_type=service_type,
description=service_desc)
self.assertEquals(service_name, service.name)
self.assertEquals(service_type, service.type)
self.assertEquals(service_desc, service.description)
self.assertEqual(service_name, service.name)
self.assertEqual(service_type, service.type)
self.assertEqual(service_desc, service.description)
service = client.services.get(id=service.id)
self.assertEquals(service_name, service.name)
self.assertEquals(service_type, service.type)
self.assertEquals(service_desc, service.description)
self.assertEqual(service_name, service.name)
self.assertEqual(service_type, service.type)
self.assertEqual(service_desc, service.description)
service = [x for x in client.services.list() if x.id == service.id][0]
self.assertEquals(service_name, service.name)
self.assertEquals(service_type, service.type)
self.assertEquals(service_desc, service.description)
self.assertEqual(service_name, service.name)
self.assertEqual(service_type, service.type)
self.assertEqual(service_desc, service.description)
# update is not supported in API v2...
@ -722,7 +722,7 @@ class KeystoneClientTests(object):
client.services.get,
id=service.id)
services = [x for x in client.services.list() if x.id == service.id]
self.assertEquals(len(services), 0)
self.assertEqual(len(services), 0)
def test_service_delete_404(self):
from keystoneclient import exceptions as client_exceptions
@ -809,7 +809,7 @@ class KcMasterTestCase(CompatTestCase, KeystoneClientTests):
user=self.user_two['id'],
role=self.role_other['id'])
user_refs = client.tenants.list_users(tenant=self.tenant_bar['id'])
self.assert_(self.user_two['id'] in [x.id for x in user_refs])
self.assertTrue(self.user_two['id'] in [x.id for x in user_refs])
client.roles.remove_user_role(tenant=self.tenant_bar['id'],
user=self.user_two['id'],
role=self.role_other['id'])
@ -972,7 +972,7 @@ class KcMasterTestCase(CompatTestCase, KeystoneClientTests):
(new_password, self.user_two['password']))
self.public_server.application(req.environ,
responseobject.start_fake_response)
self.assertEquals(403, responseobject.response_status)
self.assertEqual(403, responseobject.response_status)
self.user_two['password'] = new_password
self.assertRaises(client_exceptions.Unauthorized,
@ -1022,7 +1022,8 @@ class KcEssex3TestCase(CompatTestCase, KeystoneClientTests):
role_id=self.role_member['id'])
role_refs = client.roles.get_user_role_refs(
user_id=self.user_two['id'])
self.assert_(self.tenant_baz['id'] in [x.tenantId for x in role_refs])
self.assertTrue(self.tenant_baz['id'] in
[x.tenantId for x in role_refs])
# get the "role_refs" so we get the proper id, this is how the clients
# do it
@ -1040,8 +1041,8 @@ class KcEssex3TestCase(CompatTestCase, KeystoneClientTests):
role_refs = client.roles.get_user_role_refs(
user_id=self.user_two['id'])
self.assert_(self.tenant_baz['id'] not in
[x.tenantId for x in role_refs])
self.assertTrue(self.tenant_baz['id'] not in
[x.tenantId for x in role_refs])
def test_roles_get_by_user(self):
client = self.get_client(admin=True)
@ -1062,13 +1063,13 @@ class KcEssex3TestCase(CompatTestCase, KeystoneClientTests):
user = client.users.create(name=test_username,
password='password',
email='user1@test.com')
self.assertEquals(user.name, test_username)
self.assertEqual(user.name, test_username)
user = client.users.get(user=user.id)
self.assertEquals(user.name, test_username)
self.assertEqual(user.name, test_username)
user = client.users.update_email(user=user, email='user2@test.com')
self.assertEquals(user.email, 'user2@test.com')
self.assertEqual(user.email, 'user2@test.com')
# NOTE(termie): update_enabled doesn't return anything, probably a bug
client.users.update_enabled(user=user, enabled=False)

52
keystone/tests/test_keystoneclient_sql.py
View File

@ -78,11 +78,11 @@ class KcMasterSqlTestCase(test_keystoneclient.KcMasterTestCase, sql.Base):
adminurl=endpoint_adminurl,
internalurl=endpoint_internalurl)
self.assertEquals(endpoint.region, endpoint_region)
self.assertEquals(endpoint.service_id, service.id)
self.assertEquals(endpoint.publicurl, endpoint_publicurl)
self.assertEquals(endpoint.internalurl, endpoint_internalurl)
self.assertEquals(endpoint.adminurl, endpoint_adminurl)
self.assertEqual(endpoint.region, endpoint_region)
self.assertEqual(endpoint.service_id, service.id)
self.assertEqual(endpoint.publicurl, endpoint_publicurl)
self.assertEqual(endpoint.internalurl, endpoint_internalurl)
self.assertEqual(endpoint.adminurl, endpoint_adminurl)
client.endpoints.delete(id=endpoint.id)
self.assertRaises(client_exceptions.NotFound, client.endpoints.delete,
@ -126,20 +126,20 @@ class KcMasterSqlTestCase(test_keystoneclient.KcMasterTestCase, sql.Base):
def test_ec2_credential_crud(self):
creds = self.default_client.ec2.list(user_id=self.user_foo['id'])
self.assertEquals(creds, [])
self.assertEqual(creds, [])
cred = self.default_client.ec2.create(user_id=self.user_foo['id'],
tenant_id=self.tenant_bar['id'])
creds = self.default_client.ec2.list(user_id=self.user_foo['id'])
self.assertEquals(creds, [cred])
self.assertEqual(creds, [cred])
got = self.default_client.ec2.get(user_id=self.user_foo['id'],
access=cred.access)
self.assertEquals(cred, got)
self.assertEqual(cred, got)
self.default_client.ec2.delete(user_id=self.user_foo['id'],
access=cred.access)
creds = self.default_client.ec2.list(user_id=self.user_foo['id'])
self.assertEquals(creds, [])
self.assertEqual(creds, [])
def test_ec2_list_credentials(self):
cred_1 = self.default_client.ec2.create(
@ -155,10 +155,10 @@ class KcMasterSqlTestCase(test_keystoneclient.KcMasterTestCase, sql.Base):
cred_4 = two.ec2.create(user_id=self.user_two['id'],
tenant_id=self.tenant_bar['id'])
creds = self.default_client.ec2.list(user_id=self.user_foo['id'])
self.assertEquals(len(creds), 3)
self.assertEquals(sorted([cred_1, cred_2, cred_3],
key=lambda x: x.access),
sorted(creds, key=lambda x: x.access))
self.assertEqual(len(creds), 3)
self.assertEqual(sorted([cred_1, cred_2, cred_3],
key=lambda x: x.access),
sorted(creds, key=lambda x: x.access))
self.assertNotIn(cred_4, creds)
def test_ec2_credentials_create_404(self):
@ -274,20 +274,20 @@ class KcMasterSqlTestCase(test_keystoneclient.KcMasterTestCase, sql.Base):
blob=policy_blob,
type=policy_type,
endpoint=endpoint.id)
self.assertEquals(policy_blob, policy.policy)
self.assertEquals(policy_type, policy.type)
self.assertEquals(endpoint.id, policy.endpoint_id)
self.assertEqual(policy_blob, policy.policy)
self.assertEqual(policy_type, policy.type)
self.assertEqual(endpoint.id, policy.endpoint_id)
policy = client.policies.get(policy=policy.id)
self.assertEquals(policy_blob, policy.policy)
self.assertEquals(policy_type, policy.type)
self.assertEquals(endpoint.id, policy.endpoint_id)
self.assertEqual(policy_blob, policy.policy)
self.assertEqual(policy_type, policy.type)
self.assertEqual(endpoint.id, policy.endpoint_id)
endpoints = [x for x in client.endpoints.list() if x.id == endpoint.id]
endpoint = endpoints[0]
self.assertEquals(policy_blob, policy.policy)
self.assertEquals(policy_type, policy.type)
self.assertEquals(endpoint.id, policy.endpoint_id)
self.assertEqual(policy_blob, policy.policy)
self.assertEqual(policy_type, policy.type)
self.assertEqual(endpoint.id, policy.endpoint_id)
# update
policy_blob = uuid.uuid4().hex
@ -306,9 +306,9 @@ class KcMasterSqlTestCase(test_keystoneclient.KcMasterTestCase, sql.Base):
endpoint=endpoint.id)
policy = client.policies.get(policy=policy.id)
self.assertEquals(policy_blob, policy.policy)
self.assertEquals(policy_type, policy.type)
self.assertEquals(endpoint.id, policy.endpoint_id)
self.assertEqual(policy_blob, policy.policy)
self.assertEqual(policy_type, policy.type)
self.assertEqual(endpoint.id, policy.endpoint_id)
# delete
client.policies.delete(policy=policy.id)
@ -317,4 +317,4 @@ class KcMasterSqlTestCase(test_keystoneclient.KcMasterTestCase, sql.Base):
client.policies.get,
policy=policy.id)
policies = [x for x in client.policies.list() if x.id == policy.id]
self.assertEquals(len(policies), 0)
self.assertEqual(len(policies), 0)

24
keystone/tests/test_s3_token_middleware.py
View File

@ -211,23 +211,23 @@ class S3TokenMiddlewareTestUtil(testtools.TestCase):
self.assertRaises(ValueError, s3_token.split_path, '/a', 5, 4)
def test_split_path_success(self):
self.assertEquals(s3_token.split_path('/a'), ['a'])
self.assertEquals(s3_token.split_path('/a/'), ['a'])
self.assertEquals(s3_token.split_path('/a/c', 2), ['a', 'c'])
self.assertEquals(s3_token.split_path('/a/c/o', 3), ['a', 'c', 'o'])
self.assertEquals(s3_token.split_path('/a/c/o/r', 3, 3, True),
['a', 'c', 'o/r'])
self.assertEquals(s3_token.split_path('/a/c', 2, 3, True),
['a', 'c', None])
self.assertEquals(s3_token.split_path('/a/c/', 2), ['a', 'c'])
self.assertEquals(s3_token.split_path('/a/c/', 2, 3), ['a', 'c', ''])
self.assertEqual(s3_token.split_path('/a'), ['a'])
self.assertEqual(s3_token.split_path('/a/'), ['a'])
self.assertEqual(s3_token.split_path('/a/c', 2), ['a', 'c'])
self.assertEqual(s3_token.split_path('/a/c/o', 3), ['a', 'c', 'o'])
self.assertEqual(s3_token.split_path('/a/c/o/r', 3, 3, True),
['a', 'c', 'o/r'])
self.assertEqual(s3_token.split_path('/a/c', 2, 3, True),
['a', 'c', None])
self.assertEqual(s3_token.split_path('/a/c/', 2), ['a', 'c'])
self.assertEqual(s3_token.split_path('/a/c/', 2, 3), ['a', 'c', ''])
def test_split_path_invalid_path(self):
try:
s3_token.split_path('o\nn e', 2)
except ValueError as err:
self.assertEquals(str(err), 'Invalid path: o%0An%20e')
self.assertEqual(str(err), 'Invalid path: o%0An%20e')
try:
s3_token.split_path('o\nn e', 2, 3, True)
except ValueError as err:
self.assertEquals(str(err), 'Invalid path: o%0An%20e')
self.assertEqual(str(err), 'Invalid path: o%0An%20e')

12
keystone/tests/test_sql_upgrade.py
View File

@ -601,7 +601,7 @@ class SqlUpgradeTests(SqlMigrateBase):
self.upgrade(32)
user_table = self.select_table("user")
self.assertEquals(user_table.c.name.type.length, 255)
self.assertEqual(user_table.c.name.type.length, 255)
def test_downgrade_32_to_31(self):
self.upgrade(32)
@ -628,10 +628,10 @@ class SqlUpgradeTests(SqlMigrateBase):
q = q.filter(user_table.c.id == user_id)
r = q.one()
user_name = r[0]
self.assertEquals(len(user_name), 64)
self.assertEqual(len(user_name), 64)
user_table = self.select_table("user")
self.assertEquals(user_table.c.name.type.length, 64)
self.assertEqual(user_table.c.name.type.length, 64)
def test_downgrade_to_0(self):
self.upgrade(self.max_version)
@ -831,11 +831,11 @@ class SqlUpgradeTests(SqlMigrateBase):
return role_count
self.upgrade(16)
self.assertEquals(0, count_member_roles())
self.assertEqual(0, count_member_roles())
self.upgrade(17)
self.assertEquals(1, count_member_roles())
self.assertEqual(1, count_member_roles())
self.downgrade(16)
self.assertEquals(0, count_member_roles())
self.assertEqual(0, count_member_roles())
def check_uniqueness_constraints(self):
# Check uniqueness constraints for User & Project tables are

2
keystone/tests/test_utils.py
View File

@ -98,7 +98,7 @@ class UtilsTestCase(tests.TestCase):
@timezone
def _test_unixtime():
epoch = utils.unixtime(dt)
self.assertEquals(epoch, epoch_ans, "TZ=%s" % TZ)
self.assertEqual(epoch, epoch_ans, "TZ=%s" % TZ)
dt = datetime.datetime(1970, 1, 2, 3, 4, 56, 0)
epoch_ans = 56 + 4 * 60 + 3 * 3600 + 86400

2
keystone/tests/test_v3.py
View File

@ -458,7 +458,7 @@ class RestfulTestCase(test_content_types.RestfulTestCase):
if ref:
for k in keys:
msg = '%s not equal: %s != %s' % (k, ref[k], entity[k])
self.assertEquals(ref[k], entity[k])
self.assertEqual(ref[k], entity[k])
return entity

4
keystone/tests/test_v3_auth.py
View File

@ -1015,7 +1015,7 @@ class TestAuthExternalDomain(test_v3.RestfulTestCase):
'AUTH_TYPE': 'Negotiate'})
r = self.post('/auth/tokens', body=auth_data)
token = self.assertValidProjectScopedTokenResponse(r)
self.assertEquals(token['bind']['kerberos'], self.user['name'])
self.assertEqual(token['bind']['kerberos'], self.user['name'])
def test_unscoped_bind_with_remote_user(self):
CONF.token.bind = ['kerberos']
@ -1025,7 +1025,7 @@ class TestAuthExternalDomain(test_v3.RestfulTestCase):
'AUTH_TYPE': 'Negotiate'})
r = self.post('/auth/tokens', body=auth_data)
token = self.assertValidUnscopedTokenResponse(r)
self.assertEquals(token['bind']['kerberos'], self.user['name'])
self.assertEqual(token['bind']['kerberos'], self.user['name'])
class TestAuthJSON(test_v3.RestfulTestCase):

4
keystone/tests/test_v3_identity.py
View File

@ -559,7 +559,7 @@ class IdentityTestCase(test_v3.RestfulTestCase):
self.credential['id'])
# And the no tokens we remain valid
tokens = self.token_api.list_tokens(self.user['id'])
self.assertEquals(len(tokens), 0)
self.assertEqual(len(tokens), 0)
# But the credential for user2 is unaffected
r = self.credential_api.get_credential(self.credential2['id'])
self.assertDictEqual(r, self.credential2)
@ -1648,7 +1648,7 @@ class TestV3toV2Methods(tests.TestCase):
user_list = [self.user1, self.user2, self.user3, self.user4]
updated_list = self.identity_api.v3_to_v2_user(user_list)
self.assertEquals(len(updated_list), len(user_list))
self.assertEqual(len(updated_list), len(user_list))
for i, ref in enumerate(updated_list):
# Order should not change.

8
keystone/tests/test_v3_oauth1.py
View File

@ -337,14 +337,14 @@ class AuthTokenTests(OAuthFlowTests):
# now verify the oauth section
oauth_section = r.result['token']['OS-OAUTH1']
self.assertEquals(oauth_section['access_token_id'],
self.access_token.key)
self.assertEquals(oauth_section['consumer_id'], self.consumer.key)
self.assertEqual(oauth_section['access_token_id'],
self.access_token.key)
self.assertEqual(oauth_section['consumer_id'], self.consumer.key)
# verify the roles section
roles_list = r.result['token']['roles']
# we can just verify the 0th role since we are only assigning one role
self.assertEquals(roles_list[0]['id'], self.role_id)
self.assertEqual(roles_list[0]['id'], self.role_id)
# verify that the token can perform delegated tasks
ref = self.new_user_ref(domain_id=self.domain_id)

4
keystone/tests/test_v3_protection.py
View File

@ -175,7 +175,7 @@ class IdentityTestProtectedCase(test_v3.RestfulTestCase):
self._set_policy(new_policy)
url_by_name = '/users/%s' % self.user1['id']
r = self.get(url_by_name, auth=self.auth)
self.assertEquals(self.user1['id'], r.result['user']['id'])
self.assertEqual(self.user1['id'], r.result['user']['id'])
def test_get_user_protected_match_target(self):
"""GET /users/{id} (match target)
@ -202,7 +202,7 @@ class IdentityTestProtectedCase(test_v3.RestfulTestCase):
url_by_name = '/users/%s' % self.user1['id']
r = self.get(url_by_name, auth=self.auth)
self.assertEquals(self.user1['id'], r.result['user']['id'])
self.assertEqual(self.user1['id'], r.result['user']['id'])
url_by_name = '/users/%s' % uuid.uuid4().hex
r = self.get(url_by_name, auth=self.auth,

14
keystone/tests/test_wsgi.py
View File

@ -104,7 +104,7 @@ class ApplicationTest(BaseWSGITest):
app = FakeApp.factory({}, testkey="test")
self.assertIn("testkey", app.kwargs)
self.assertEquals("test", app.kwargs["testkey"])
self.assertEqual("test", app.kwargs["testkey"])
def test_render_exception(self):
e = exception.Unauthorized(message=u'\u7f51\u7edc')
@ -121,7 +121,7 @@ class ExtensionRouterTest(BaseWSGITest):
factory = FakeRouter.factory({}, testkey="test")
app = factory(self.app)
self.assertIn("testkey", app.kwargs)
self.assertEquals("test", app.kwargs["testkey"])
self.assertEqual("test", app.kwargs["testkey"])
class MiddlewareTest(BaseWSGITest):
@ -152,7 +152,7 @@ class MiddlewareTest(BaseWSGITest):
req = self._make_request()
req.environ['REMOTE_ADDR'] = '127.0.0.1'
resp = FakeMiddleware(self.app)(req)
self.assertEquals(resp.status_int, exception.Unauthorized.code)
self.assertEqual(resp.status_int, exception.Unauthorized.code)
def test_middleware_type_error(self):
class FakeMiddleware(wsgi.Middleware):
@ -163,7 +163,7 @@ class MiddlewareTest(BaseWSGITest):
req.environ['REMOTE_ADDR'] = '127.0.0.1'
resp = FakeMiddleware(self.app)(req)
# This is a validationerror type
self.assertEquals(resp.status_int, exception.ValidationError.code)
self.assertEqual(resp.status_int, exception.ValidationError.code)
def test_middleware_exception_error(self):
class FakeMiddleware(wsgi.Middleware):
@ -172,7 +172,7 @@ class MiddlewareTest(BaseWSGITest):
req = self._make_request()
resp = FakeMiddleware(self.app)(req)
self.assertEquals(resp.status_int, exception.UnexpectedError.code)
self.assertEqual(resp.status_int, exception.UnexpectedError.code)
self.assertIn("EXCEPTIONERROR", resp.body)
def test_middleware_local_config(self):
@ -183,7 +183,7 @@ class MiddlewareTest(BaseWSGITest):
factory = FakeMiddleware.factory({}, testkey="test")
app = factory(self.app)
self.assertIn("testkey", app.kwargs)
self.assertEquals("test", app.kwargs["testkey"])
self.assertEqual("test", app.kwargs["testkey"])
class WSGIFunctionTest(tests.TestCase):
@ -260,7 +260,7 @@ class LocalizedResponseTest(tests.TestCase):
self._set_expected_languages(all_locales=['it'])
req = wsgi.Request.blank('/', headers={'Accept-Language': 'it'})
self.assertEquals(req.best_match_language(), 'it')
self.assertEqual(req.best_match_language(), 'it')
def test_request_match_language_unexpected(self):
# If Accept-Language is a language we do not support,