Merge "Convert identity.domains tests into mock"

openstack_dashboard/dashboards/identity/domains/tests.py

@@ -12,20 +12,16 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-
-from django import http
 from django.urls import reverse
 
-from mox3.mox import IgnoreArg
+import mock
-from mox3.mox import IsA
 
 from horizon.workflows import views
 
 from openstack_dashboard import api
-from openstack_dashboard.test import helpers as test
-
 from openstack_dashboard.dashboards.identity.domains import constants
 from openstack_dashboard.dashboards.identity.domains import workflows
+from openstack_dashboard.test import helpers as test
 
 
 DOMAINS_INDEX_URL = reverse(constants.DOMAINS_INDEX_URL)
@@ -37,14 +33,9 @@ GROUP_ROLE_PREFIX = constants.DOMAIN_GROUP_MEMBER_SLUG + "_role_"
 
 class DomainsViewTests(test.BaseAdminViewTests):
 
-    use_mox = True
+    @test.create_mocks({api.keystone: ('domain_list',)})
-
-    @test.create_stubs({api.keystone: ('domain_get',
-                                       'domain_list',)})
     def test_index(self):
-        api.keystone.domain_list(IgnoreArg()).AndReturn(self.domains.list())
+        self.mock_domain_list.return_value = self.domains.list()
-
-        self.mox.ReplayAll()
 
         res = self.client.get(DOMAINS_INDEX_URL)
 
@@ -56,15 +47,13 @@ class DomainsViewTests(test.BaseAdminViewTests):
         self.assertContains(res, 'Disable Domain')
         self.assertContains(res, 'Enable Domain')
 
-    @test.create_stubs({api.keystone: ('domain_get',
+        self.mock_domain_list.assert_called_once_with(test.IsHttpRequest())
-                                       'domain_list',
+
+    @test.create_mocks({api.keystone: ('domain_list',
                                        'keystone_can_edit_domain')})
     def test_index_with_keystone_can_edit_domain_false(self):
-        api.keystone.domain_list(IgnoreArg()).AndReturn(self.domains.list())
+        self.mock_domain_list.return_value = self.domains.list()
-        api.keystone.keystone_can_edit_domain() \
+        self.mock_keystone_can_edit_domain.return_value = False
-            .MultipleTimes().AndReturn(False)
-
-        self.mox.ReplayAll()
 
         res = self.client.get(DOMAINS_INDEX_URL)
 
@@ -76,30 +65,32 @@ class DomainsViewTests(test.BaseAdminViewTests):
         self.assertNotContains(res, 'Disable Domain')
         self.assertNotContains(res, 'Enable Domain')
 
-    @test.create_stubs({api.keystone: ('domain_get',
+        self.mock_domain_list.assert_called_once_with(test.IsHttpRequest())
-                                       'domain_list',
+        self.assert_mock_multiple_calls_with_same_arguments(
+            self.mock_keystone_can_edit_domain, 20, mock.call())
+
+    @test.create_mocks({api.keystone: ('domain_list',
                                        'domain_delete')})
     def test_delete_domain(self):
         domain = self.domains.get(id="2")
 
-        api.keystone.domain_list(IgnoreArg()).AndReturn(self.domains.list())
+        self.mock_domain_list.return_value = self.domains.list()
-        api.keystone.domain_delete(IgnoreArg(), domain.id)
+        self.mock_domain_delete.return_value = None
-
-        self.mox.ReplayAll()
 
         formData = {'action': 'domains__delete__%s' % domain.id}
         res = self.client.post(DOMAINS_INDEX_URL, formData)
 
         self.assertRedirectsNoFollow(res, DOMAINS_INDEX_URL)
 
-    @test.create_stubs({api.keystone: ('domain_get',
+        self.mock_domain_list.assert_called_once_with(test.IsHttpRequest())
-                                       'domain_list', )})
+        self.mock_domain_delete.assert_called_once_with(test.IsHttpRequest(),
+                                                        domain.id)
+
+    @test.create_mocks({api.keystone: ('domain_list', )})
     def test_delete_with_enabled_domain(self):
         domain = self.domains.get(id="1")
 
-        api.keystone.domain_list(IgnoreArg()).AndReturn(self.domains.list())
+        self.mock_domain_list.return_value = self.domains.list()
-
-        self.mox.ReplayAll()
 
         formData = {'action': 'domains__delete__%s' % domain.id}
         res = self.client.post(DOMAINS_INDEX_URL, formData)
@@ -107,20 +98,15 @@ class DomainsViewTests(test.BaseAdminViewTests):
         self.assertRedirectsNoFollow(res, DOMAINS_INDEX_URL)
         self.assertMessageCount(error=2)
 
-    @test.create_stubs({api.keystone: ('domain_get',
+        self.mock_domain_list.assert_called_once_with(test.IsHttpRequest())
-                                       'domain_list',
+
+    @test.create_mocks({api.keystone: ('domain_list',
                                        'domain_update')})
     def test_disable(self):
         domain = self.domains.get(id="1")
 
-        api.keystone.domain_list(IgnoreArg()).AndReturn(self.domains.list())
+        self.mock_domain_list.return_value = self.domains.list()
-        api.keystone.domain_update(IsA(http.HttpRequest),
+        self.mock_domain_update.return_value = None
-                                   description=domain.description,
-                                   domain_id=domain.id,
-                                   enabled=False,
-                                   name=domain.name).AndReturn(None)
-
-        self.mox.ReplayAll()
 
         formData = {'action': 'domains__disable__%s' % domain.id}
         res = self.client.post(DOMAINS_INDEX_URL, formData)
@@ -128,20 +114,21 @@ class DomainsViewTests(test.BaseAdminViewTests):
         self.assertRedirectsNoFollow(res, DOMAINS_INDEX_URL)
         self.assertMessageCount(error=0)
 
-    @test.create_stubs({api.keystone: ('domain_get',
+        self.mock_domain_list.assert_called_once_with(test.IsHttpRequest())
-                                       'domain_list',
+        self.mock_domain_update.assert_called_once_with(
+            test.IsHttpRequest(),
+            description=domain.description,
+            domain_id=domain.id,
+            enabled=False,
+            name=domain.name)
+
+    @test.create_mocks({api.keystone: ('domain_list',
                                        'domain_update')})
     def test_enable(self):
         domain = self.domains.get(id="2")
 
-        api.keystone.domain_list(IgnoreArg()).AndReturn(self.domains.list())
+        self.mock_domain_list.return_value = self.domains.list()
-        api.keystone.domain_update(IsA(http.HttpRequest),
+        self.mock_domain_update.return_value = None
-                                   description=domain.description,
-                                   domain_id=domain.id,
-                                   enabled=True,
-                                   name=domain.name).AndReturn(None)
-
-        self.mox.ReplayAll()
 
         formData = {'action': 'domains__enable__%s' % domain.id}
         res = self.client.post(DOMAINS_INDEX_URL, formData)
@@ -149,17 +136,21 @@ class DomainsViewTests(test.BaseAdminViewTests):
         self.assertRedirectsNoFollow(res, DOMAINS_INDEX_URL)
         self.assertMessageCount(error=0)
 
-    @test.create_stubs({api.keystone: ('domain_get',
+        self.mock_domain_list.assert_called_once_with(test.IsHttpRequest())
+        self.mock_domain_update.assert_called_once_with(
+            test.IsHttpRequest(),
+            description=domain.description,
+            domain_id=domain.id,
+            enabled=True,
+            name=domain.name)
+
+    @test.create_mocks({api.keystone: ('domain_get',
                                        'domain_list', )})
     def test_set_clear_domain_context(self):
         domain = self.domains.get(id="3")
 
-        api.keystone.domain_get(IgnoreArg(), domain.id).AndReturn(domain)
+        self.mock_domain_get.return_value = domain
-        api.keystone.domain_get(IgnoreArg(), domain.id).AndReturn(domain)
+        self.mock_domain_list.return_value = self.domains.list()
-
-        api.keystone.domain_list(IgnoreArg()).AndReturn(self.domains.list())
-
-        self.mox.ReplayAll()
 
         formData = {'action': 'domains__set_domain_context__%s' % domain.id}
         res = self.client.post(DOMAINS_INDEX_URL, formData)
@@ -176,11 +167,14 @@ class DomainsViewTests(test.BaseAdminViewTests):
         self.assertNotContains(res, "<em>test_domain:</em>")
         self.assertNotContains(res, "<em>another_test_domain:</em>")
 
+        self.assert_mock_multiple_calls_with_same_arguments(
+            self.mock_domain_get, 2,
+            mock.call(test.IsHttpRequest(), domain.id))
+        self.mock_domain_list.assert_called_once_with(test.IsHttpRequest())
+
 
 class CreateDomainWorkflowTests(test.BaseAdminViewTests):
 
-    use_mox = True
-
     def _get_domain_info(self, domain):
         domain_info = {"name": domain.name,
                        "description": domain.description,
@@ -204,16 +198,11 @@ class CreateDomainWorkflowTests(test.BaseAdminViewTests):
         self.assertQuerysetEqual(workflow.steps,
                                  ['<CreateDomainInfo: create_domain>', ])
 
-    @test.create_stubs({api.keystone: ('domain_create', )})
+    @test.create_mocks({api.keystone: ('domain_create', )})
     def test_add_domain_post(self):
         domain = self.domains.get(id="1")
 
-        api.keystone.domain_create(IsA(http.HttpRequest),
+        self.mock_domain_create.return_value = domain
-                                   description=domain.description,
-                                   enabled=domain.enabled,
-                                   name=domain.name).AndReturn(domain)
-
-        self.mox.ReplayAll()
 
         workflow_data = self._get_workflow_data(domain)
 
@@ -222,11 +211,15 @@ class CreateDomainWorkflowTests(test.BaseAdminViewTests):
         self.assertNoFormErrors(res)
         self.assertRedirectsNoFollow(res, DOMAINS_INDEX_URL)
 
+        self.mock_domain_create.assert_called_once_with(
+            test.IsHttpRequest(),
+            description=domain.description,
+            enabled=domain.enabled,
+            name=domain.name)
+
 
 class UpdateDomainWorkflowTests(test.BaseAdminViewTests):
 
-    use_mox = True
-
     def _get_domain_info(self, domain):
         domain_info = {"domain_id": domain.id,
                        "name": domain.name,
@@ -262,7 +255,7 @@ class UpdateDomainWorkflowTests(test.BaseAdminViewTests):
         domain_scope = {'domain': {'id': domain_id}}
         return self.role_assignments.filter(scope=domain_scope)
 
-    @test.create_stubs({api.keystone: ('domain_get',
+    @test.create_mocks({api.keystone: ('domain_get',
                                        'get_default_role',
                                        'role_list',
                                        'user_list',
@@ -277,27 +270,13 @@ class UpdateDomainWorkflowTests(test.BaseAdminViewTests):
         roles = self.roles.list()
         role_assignments = self._get_domain_role_assignment(domain.id)
 
-        api.keystone.domain_get(IsA(http.HttpRequest), '1').AndReturn(domain)
+        self.mock_domain_get.return_value = domain
-        api.keystone.get_default_role(IsA(http.HttpRequest)) \
+        self.mock_get_default_role.return_value = default_role
-            .MultipleTimes().AndReturn(default_role)
+        self.mock_role_list.return_value = roles
-        api.keystone.role_list(IsA(http.HttpRequest)) \
+        self.mock_user_list.return_value = users
-            .MultipleTimes().AndReturn(roles)
+        self.mock_role_assignments_list.return_value = role_assignments
-        api.keystone.user_list(IsA(http.HttpRequest), domain=domain.id) \
+        self.mock_group_list.return_value = groups
-            .AndReturn(users)
+        self.mock_roles_for_group.return_value = roles
-        api.keystone.role_assignments_list(IsA(http.HttpRequest),
-                                           domain=domain.id,
-                                           include_subtree=False) \
-            .AndReturn(role_assignments)
-        api.keystone.group_list(IsA(http.HttpRequest), domain=domain.id) \
-            .AndReturn(groups)
-
-        for group in groups:
-            api.keystone.roles_for_group(IsA(http.HttpRequest),
-                                         group=group.id,
-                                         domain=domain.id) \
-                .AndReturn(roles)
-
-        self.mox.ReplayAll()
 
         res = self.client.get(DOMAIN_UPDATE_URL)
 
@@ -317,7 +296,24 @@ class UpdateDomainWorkflowTests(test.BaseAdminViewTests):
              '<UpdateDomainUsers: update_user_members>',
              '<UpdateDomainGroups: update_group_members>'])
 
-    @test.create_stubs({api.keystone: ('domain_get',
+        self.mock_domain_get.assert_called_once_with(test.IsHttpRequest(), '1')
+        self.assert_mock_multiple_calls_with_same_arguments(
+            self.mock_get_default_role, 2, mock.call(test.IsHttpRequest()))
+        self.assert_mock_multiple_calls_with_same_arguments(
+            self.mock_role_list, 2, mock.call(test.IsHttpRequest()))
+        self.mock_user_list.assert_called_once_with(test.IsHttpRequest(),
+                                                    domain=domain.id)
+        self.mock_role_assignments_list.assert_called_once_with(
+            test.IsHttpRequest(),
+            domain=domain.id,
+            include_subtree=False)
+        self.mock_group_list.assert_called_once_with(test.IsHttpRequest(),
+                                                     domain=domain.id)
+        self.mock_roles_for_group.assert_has_calls(
+            [mock.call(test.IsHttpRequest(), group=group.id, domain=domain.id)
+             for group in groups])
+
+    @test.create_mocks({api.keystone: ('domain_get',
                                        'domain_update',
                                        'get_default_role',
                                        'role_list',
@@ -340,25 +336,32 @@ class UpdateDomainWorkflowTests(test.BaseAdminViewTests):
         roles = self.roles.list()
         role_assignments = self._get_domain_role_assignment(domain.id)
 
-        api.keystone.domain_get(IsA(http.HttpRequest), '1').AndReturn(domain)
+        self.mock_domain_get.return_value = domain
-        api.keystone.get_default_role(IsA(http.HttpRequest)) \
+        self.mock_get_default_role.return_value = default_role
-            .MultipleTimes().AndReturn(default_role)
+        self.mock_role_list.return_value = roles
-        api.keystone.role_list(IsA(http.HttpRequest)) \
+        self.mock_user_list.return_value = users
-            .MultipleTimes().AndReturn(roles)
+        self.mock_role_assignments_list.return_value = role_assignments
-        api.keystone.user_list(IsA(http.HttpRequest), domain=domain.id) \
+        expected_group_list = []
-            .AndReturn(users)
+        retvals_group_list = []
-        api.keystone.role_assignments_list(IsA(http.HttpRequest),
+        self.mock_group_list.side_effect = retvals_group_list
-                                           domain=domain.id,
+        expected_roles_for_group = []
-                                           include_subtree=False) \
+        retvals_roles_for_group = []
-            .AndReturn(role_assignments)
+        self.mock_roles_for_group.side_effect = retvals_roles_for_group
-        api.keystone.group_list(IsA(http.HttpRequest), domain=domain.id) \
+        expected_remove_group_role = []
-            .AndReturn(groups)
+        expected_add_group_role = []
+        self.mock_remove_group_role.return_value = None
+        self.mock_add_group_role.return_value = None
+
+        expected_group_list.append(
+            mock.call(test.IsHttpRequest(), domain=domain.id))
+        retvals_group_list.append(groups)
 
         for group in groups:
-            api.keystone.roles_for_group(IsA(http.HttpRequest),
+            expected_roles_for_group.append(
-                                         group=group.id,
+                mock.call(test.IsHttpRequest(),
-                                         domain=domain.id) \
+                          group=group.id,
-                .AndReturn(roles)
+                          domain=domain.id))
+            retvals_roles_for_group.append(roles)
 
         workflow_data = self._get_workflow_data(domain)
         # update some fields
@@ -371,80 +374,53 @@ class UpdateDomainWorkflowTests(test.BaseAdminViewTests):
         workflow_data[GROUP_ROLE_PREFIX + "2"] = ['2']  # member role
 
         # handle
-        api.keystone.domain_update(IsA(http.HttpRequest),
+        self.mock_domain_update.return_value = None
-                                   domain.id,
-                                   name=domain.name,
-                                   description=test_description,
-                                   enabled=domain.enabled).AndReturn(None)
-
-        api.keystone.role_assignments_list(IsA(http.HttpRequest),
-                                           domain=domain.id,
-                                           include_subtree=False) \
-            .AndReturn(role_assignments)
-
-        api.keystone.user_list(IsA(http.HttpRequest),
-                               domain=domain.id).AndReturn(users)
 
         # Give user 3 role 1
-        api.keystone.add_domain_user_role(IsA(http.HttpRequest),
+        self.mock_add_domain_user_role.return_value = None
-                                          domain=domain.id,
-                                          user='3',
-                                          role='1')
 
         # remove role 2 from user 3
-        api.keystone.remove_domain_user_role(IsA(http.HttpRequest),
+        self.mock_remove_domain_user_role.return_value = None
-                                             domain=domain.id,
-                                             user='3',
-                                             role='2')
 
         # Group assignments
-        api.keystone.group_list(IsA(http.HttpRequest),
+        expected_group_list.append(
-                                domain=domain.id).AndReturn(domain_groups)
+            mock.call(test.IsHttpRequest(), domain=domain.id))
+        retvals_group_list.append(domain_groups)
 
         # admin group - try to remove all roles on current domain
-        api.keystone.roles_for_group(IsA(http.HttpRequest),
+        expected_roles_for_group.append(
-                                     group='1',
+            mock.call(test.IsHttpRequest(), group='1', domain=domain.id))
-                                     domain=domain.id) \
+        retvals_roles_for_group.append(roles)
-            .AndReturn(roles)
         for role in roles:
-            api.keystone.remove_group_role(IsA(http.HttpRequest),
+            expected_remove_group_role.append(
-                                           role=role.id,
+                mock.call(test.IsHttpRequest(),
-                                           group='1',
+                          role=role.id, group='1', domain=domain.id))
-                                           domain=domain.id)
 
         # member group 1 - has role 1, will remove it
-        api.keystone.roles_for_group(IsA(http.HttpRequest),
+        expected_roles_for_group.append(
-                                     group='2',
+            mock.call(test.IsHttpRequest(), group='2', domain=domain.id))
-                                     domain=domain.id) \
+        retvals_roles_for_group.append((roles[0],))
-            .AndReturn((roles[0],))
         # remove role 1
-        api.keystone.remove_group_role(IsA(http.HttpRequest),
+        expected_remove_group_role.append(
-                                       role='1',
+            mock.call(test.IsHttpRequest(),
-                                       group='2',
+                      role='1', group='2', domain=domain.id))
-                                       domain=domain.id)
         # add role 2
-        api.keystone.add_group_role(IsA(http.HttpRequest),
+        expected_add_group_role.append(
-                                    role='2',
+            mock.call(test.IsHttpRequest(),
-                                    group='2',
+                      role='2', group='2', domain=domain.id))
-                                    domain=domain.id)
 
         # member group 3 - has role 2
-        api.keystone.roles_for_group(IsA(http.HttpRequest),
+        expected_roles_for_group.append(
-                                     group='3',
+            mock.call(test.IsHttpRequest(), group='3', domain=domain.id))
-                                     domain=domain.id) \
+        retvals_roles_for_group.append((roles[1],))
-            .AndReturn((roles[1],))
         # remove role 2
-        api.keystone.remove_group_role(IsA(http.HttpRequest),
+        expected_remove_group_role.append(
-                                       role='2',
+            mock.call(test.IsHttpRequest(),
-                                       group='3',
+                      role='2', group='3', domain=domain.id))
-                                       domain=domain.id)
         # add role 1
-        api.keystone.add_group_role(IsA(http.HttpRequest),
+        expected_add_group_role.append(
-                                    role='1',
+            mock.call(test.IsHttpRequest(),
-                                    group='3',
+                      role='1', group='3', domain=domain.id))
-                                    domain=domain.id)
-
-        self.mox.ReplayAll()
 
         res = self.client.post(DOMAIN_UPDATE_URL, workflow_data)
 
@@ -452,20 +428,65 @@ class UpdateDomainWorkflowTests(test.BaseAdminViewTests):
         self.assertMessageCount(success=1)
         self.assertRedirectsNoFollow(res, DOMAINS_INDEX_URL)
 
-    @test.create_stubs({api.keystone: ('domain_get',)})
+        # init and handle
+        self.mock_domain_get.assert_called_once_with(test.IsHttpRequest(), '1')
+        self.assert_mock_multiple_calls_with_same_arguments(
+            self.mock_get_default_role, 2,
+            mock.call(test.IsHttpRequest()))
+        self.assert_mock_multiple_calls_with_same_arguments(
+            self.mock_role_list, 6,
+            mock.call(test.IsHttpRequest()))
+        self.assert_mock_multiple_calls_with_same_arguments(
+            self.mock_user_list, 2,
+            mock.call(test.IsHttpRequest(), domain=domain.id))
+        self.assert_mock_multiple_calls_with_same_arguments(
+            self.mock_role_assignments_list, 2,
+            mock.call(test.IsHttpRequest(),
+                      domain=domain.id, include_subtree=False))
+        self.mock_domain_update.assert_called_once_with(
+            test.IsHttpRequest(),
+            domain.id,
+            name=domain.name,
+            description=test_description,
+            enabled=domain.enabled)
+
+        # Give user 3 role 1
+        self.mock_add_domain_user_role.assert_called_once_with(
+            test.IsHttpRequest(), domain=domain.id, user='3', role='1')
+        # remove role 2 from user 3
+        self.mock_remove_domain_user_role.assert_called_once_with(
+            test.IsHttpRequest(), domain=domain.id, user='3', role='2')
+
+        self.mock_group_list.assert_has_calls(
+            expected_group_list)
+        self.assertEqual(len(expected_group_list),
+                         self.mock_group_list.call_count)
+        self.mock_roles_for_group.assert_has_calls(
+            expected_roles_for_group)
+        self.assertEqual(len(expected_roles_for_group),
+                         self.mock_roles_for_group.call_count)
+        self.mock_remove_group_role.assert_has_calls(
+            expected_remove_group_role)
+        self.assertEqual(len(expected_remove_group_role),
+                         self.mock_remove_group_role.call_count)
+        self.mock_add_group_role.assert_has_calls(
+            expected_add_group_role)
+        self.assertEqual(len(expected_add_group_role),
+                         self.mock_add_group_role.call_count)
+
+    @test.create_mocks({api.keystone: ('domain_get',)})
     def test_update_domain_get_error(self):
         domain = self.domains.get(id="1")
 
-        api.keystone.domain_get(IsA(http.HttpRequest), domain.id) \
+        self.mock_domain_get.side_effect = self.exceptions.keystone
-            .AndRaise(self.exceptions.keystone)
-
-        self.mox.ReplayAll()
 
         res = self.client.get(DOMAIN_UPDATE_URL)
 
         self.assertRedirectsNoFollow(res, DOMAINS_INDEX_URL)
+        self.mock_domain_get.assert_called_once_with(test.IsHttpRequest(),
+                                                     domain.id)
 
-    @test.create_stubs({api.keystone: ('domain_get',
+    @test.create_mocks({api.keystone: ('domain_get',
                                        'domain_update',
                                        'get_default_role',
                                        'role_list',
@@ -482,24 +503,24 @@ class UpdateDomainWorkflowTests(test.BaseAdminViewTests):
         roles = self.roles.list()
         role_assignments = self._get_domain_role_assignment(domain.id)
 
-        api.keystone.domain_get(IsA(http.HttpRequest), '1').AndReturn(domain)
+        self.mock_domain_get(test.IsHttpRequest(), '1').AndReturn(domain)
-        api.keystone.get_default_role(IsA(http.HttpRequest)) \
+        self.mock_get_default_role(test.IsHttpRequest()) \
             .MultipleTimes().AndReturn(default_role)
-        api.keystone.role_list(IsA(http.HttpRequest)) \
+        self.mock_role_list(test.IsHttpRequest()) \
             .MultipleTimes().AndReturn(roles)
-        api.keystone.user_list(IsA(http.HttpRequest), domain=domain.id) \
+        self.mock_user_list(test.IsHttpRequest(), domain=domain.id) \
             .AndReturn(users)
-        api.keystone.role_assignments_list(IsA(http.HttpRequest),
+        self.mock_role_assignments_list(test.IsHttpRequest(),
-                                           domain=domain.id,
+                                        domain=domain.id,
-                                           include_subtree=False) \
+                                        include_subtree=False) \
             .AndReturn(role_assignments)
-        api.keystone.group_list(IsA(http.HttpRequest), domain=domain.id) \
+        self.mock_group_list(test.IsHttpRequest(), domain=domain.id) \
             .AndReturn(groups)
 
         for group in groups:
-            api.keystone.roles_for_group(IsA(http.HttpRequest),
+            self.mock_roles_for_group(test.IsHttpRequest(),
-                                         group=group.id,
+                                      group=group.id,
-                                         domain=domain.id) \
+                                      domain=domain.id) \
                 .AndReturn(roles)
 
         workflow_data = self._get_workflow_data(domain)
@@ -514,17 +535,17 @@ class UpdateDomainWorkflowTests(test.BaseAdminViewTests):
         workflow_data[GROUP_ROLE_PREFIX + "2"] = ['2']  # member role
 
         # handle
-        api.keystone.domain_update(IsA(http.HttpRequest),
+        self.mock_domain_update.side_effect = self.exceptions.keystone
-                                   domain.id,
-                                   name=domain.name,
-                                   description=test_description,
-                                   enabled=domain.enabled) \
-            .AndRaise(self.exceptions.keystone)
-
-        self.mox.ReplayAll()
 
         res = self.client.post(DOMAIN_UPDATE_URL, workflow_data)
 
         self.assertNoFormErrors(res)
         self.assertMessageCount(error=1)
         self.assertRedirectsNoFollow(res, DOMAINS_INDEX_URL)
+
+        self.mock_domain_update.assert_called_once_with(
+            test.IsHttpRequest(),
+            domain.id,
+            name=domain.name,
+            description=test_description,
+            enabled=domain.enabled)