diff --git a/keystone/test.py b/keystone/test.py
index 41487307dc..fe7ea85ff6 100644
--- a/keystone/test.py
+++ b/keystone/test.py
@@ -343,14 +343,32 @@ class TestCase(NoModule, unittest.TestCase):
     def assertNotEmpty(self, l):
         self.assertTrue(len(l))
 
-    def assertDictContainsSubset(self, dict1, dict2):
-        if len(dict1) < len(dict2):
-            (subset, fullset) = dict1, dict2
-        else:
-            (subset, fullset) = dict2, dict1
-        for x in subset:
-            self.assertIn(x, fullset)
-            self.assertEquals(subset.get(x), fullset.get(x))
+    def assertDictContainsSubset(self, expected, actual, msg=None):
+        """Checks whether actual is a superset of expected."""
+        safe_repr = unittest.util.safe_repr
+        missing = []
+        mismatched = []
+        for key, value in expected.iteritems():
+            if key not in actual:
+                missing.append(key)
+            elif value != actual[key]:
+                mismatched.append('%s, expected: %s, actual: %s' %
+                                  (safe_repr(key), safe_repr(value),
+                                   safe_repr(actual[key])))
+
+        if not (missing or mismatched):
+            return
+
+        standardMsg = ''
+        if missing:
+            standardMsg = 'Missing: %s' % ','.join(safe_repr(m) for m in
+                                                   missing)
+        if mismatched:
+            if standardMsg:
+                standardMsg += '; '
+            standardMsg += 'Mismatched values: %s' % ','.join(mismatched)
+
+        self.fail(self._formatMessage(msg, standardMsg))
 
     @staticmethod
     def skip_if_no_ipv6():
diff --git a/tests/test_backend.py b/tests/test_backend.py
index d3f830d1a1..5665fa54f9 100644
--- a/tests/test_backend.py
+++ b/tests/test_backend.py
@@ -134,7 +134,7 @@ class IdentityTests(object):
         user.pop('password')
         self.assertEquals(metadata_ref, {"roles":
                                          [CONF.member_role_id]})
-        self.assertDictContainsSubset(user_ref, user)
+        self.assertDictContainsSubset(user, user_ref)
         self.assertDictEqual(tenant_ref, self.tenant_baz)
 
     def test_password_hashed(self):
@@ -1870,12 +1870,12 @@ class IdentityTests(object):
                  'name': uuid.uuid4().hex}
         self.identity_man.create_group({}, group['id'], group)
         group_ref = self.identity_api.get_group(group['id'])
-        self.assertDictContainsSubset(group_ref, group)
+        self.assertDictContainsSubset(group, group_ref)
 
         group['name'] = uuid.uuid4().hex
         self.identity_api.update_group(group['id'], group)
         group_ref = self.identity_api.get_group(group['id'])
-        self.assertDictContainsSubset(group_ref, group)
+        self.assertDictContainsSubset(group, group_ref)
 
         self.identity_api.delete_group(group['id'])
         self.assertRaises(exception.GroupNotFound,
@@ -1946,12 +1946,12 @@ class IdentityTests(object):
                    'domain_id': domain['id']}
         self.identity_man.create_project({}, project['id'], project)
         project_ref = self.identity_api.get_project(project['id'])
-        self.assertDictContainsSubset(project_ref, project)
+        self.assertDictContainsSubset(project, project_ref)
 
         project['name'] = uuid.uuid4().hex
         self.identity_api.update_project(project['id'], project)
         project_ref = self.identity_api.get_project(project['id'])
-        self.assertDictContainsSubset(project_ref, project)
+        self.assertDictContainsSubset(project, project_ref)
 
         self.identity_api.delete_project(project['id'])
         self.assertRaises(exception.ProjectNotFound,
@@ -1983,14 +1983,14 @@ class IdentityTests(object):
         user_ref = self.identity_api.get_user(user['id'])
         del user['password']
         user_ref_dict = dict((x, user_ref[x]) for x in user_ref)
-        self.assertDictContainsSubset(user_ref_dict, user)
+        self.assertDictContainsSubset(user, user_ref_dict)
 
         user['password'] = uuid.uuid4().hex
         self.identity_api.update_user(user['id'], user)
         user_ref = self.identity_api.get_user(user['id'])
         del user['password']
         user_ref_dict = dict((x, user_ref[x]) for x in user_ref)
-        self.assertDictContainsSubset(user_ref_dict, user)
+        self.assertDictContainsSubset(user, user_ref_dict)
 
         self.identity_api.delete_user(user['id'])
         self.assertRaises(exception.UserNotFound,