← Back to branch summary

~nskaggs/juju-ci-tools/add-essential-operations

« back to all changes in this revision

Viewing changes to tests/test_assess_user_grant_revoke.py

Merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_assess_user_grant_revoke.py
120
120
        for user in users:
121
121
            fake_client = fake_juju_client()
122
122
            fake_admin_client = fake_juju_client()
123
 
            ac = patch("assess_user_grant_revoke.assert_admin_controller",
 
123
            ac = patch("assess_user_grant_revoke.assert_admin_model",
124
124
                       return_value=True)
125
125
            with patch("jujupy.EnvJujuClient.revoke", return_value=True):
126
126
                with patch("assess_user_grant_revoke.assert_read_model",
149
149
    def test_assert_write_model(self):
150
150
        fake_client = fake_juju_client()
151
151
        with patch.object(fake_client, 'wait_for_started'):
152
 
            with patch.object(fake_client, 'deploy', return_value=True):
153
 
                with patch.object(
154
 
                        fake_client, 'remove_service', autospec=True):
155
 
                    assert_write_model(fake_client, 'write', True)
 
152
            with patch.object(fake_client, 'juju', return_value=True):
 
153
                assert_write_model(fake_client, 'write', True)
156
154
                with self.assertRaises(JujuAssertionError):
157
 
                    with patch.object(fake_client, 'remove_service',
158
 
                                      autospec=True):
159
 
                        assert_write_model(fake_client, 'write', False)
 
155
                    assert_write_model(fake_client, 'write', False)
160
156
            deploy_side_effect = CalledProcessError(None, None, None)
161
 
            with patch.object(fake_client, 'deploy', return_value=False,
 
157
            with patch.object(fake_client, 'juju', return_value=False,
162
158
                              side_effect=deploy_side_effect):
163
159
                assert_write_model(fake_client, 'write', False)
164
160
                with self.assertRaises(JujuAssertionError):
165
 
                    with patch.object(fake_client, 'remove_service',
166
 
                                      autospec=True):
167
 
                        assert_write_model(fake_client, 'write', True)
 
161
                    assert_write_model(fake_client, 'write', True)
168
162
 
169
163
 
170
164
def make_fake_client():
196
190
                     autospec=True)
197
191
        write = patch("assess_user_grant_revoke.assert_write_model",
198
192
                      autospec=True)
199
 
        admin = patch("assess_user_grant_revoke.assert_admin_controller",
 
193
        admin = patch("assess_user_grant_revoke.assert_admin_model",
200
194
                      autospec=True)
201
 
        rm = patch("assess_user_grant_revoke.wait_for_removed_services",
202
 
                   autospec=True)
203
195
        with cpass as pass_mock, able as able_mock, log as log_mock:
204
196
            with read as read_mock, write as write_mock, admin as admin_mock:
205
197
                with expect as expect_mock:
206
198
                    expect_mock.return_value.isalive.return_value = False
207
 
                    with rm:
208
 
                        assess_user_grant_revoke(fake_client)
209
 
 
210
 
                        self.assertEqual(pass_mock.call_count, 1)
211
 
                        self.assertEqual(able_mock.call_count, 1)
212
 
                        self.assertEqual(log_mock.call_count, 1)
213
 
 
214
 
                        self.assertEqual(read_mock.call_count, 6)
215
 
                        self.assertEqual(write_mock.call_count, 6)
216
 
                        self.assertEqual(admin_mock.call_count, 6)
217
 
 
218
 
                        read_calls = [
219
 
                            call[0][2] for call in
220
 
                            read_mock.call_args_list]
221
 
                        write_calls = [
222
 
                            call[0][2] for call in
223
 
                            write_mock.call_args_list]
224
 
                        admin_calls = [
225
 
                            call[0][2] for call in
226
 
                            admin_mock.call_args_list]
227
 
 
228
 
                        self.assertEqual(read_calls,
229
 
                                         assert_read_calls)
230
 
                        self.assertEqual(write_calls,
231
 
                                         assert_write_calls)
232
 
                        self.assertEqual(admin_calls,
233
 
                                         assert_admin_calls)
 
199
                    assess_user_grant_revoke(fake_client)
 
200
 
 
201
                    self.assertEqual(pass_mock.call_count, 1)
 
202
                    self.assertEqual(able_mock.call_count, 1)
 
203
                    self.assertEqual(log_mock.call_count, 1)
 
204
 
 
205
                    self.assertEqual(read_mock.call_count, 6)
 
206
                    self.assertEqual(write_mock.call_count, 6)
 
207
                    self.assertEqual(admin_mock.call_count, 6)
 
208
 
 
209
                    read_calls = [
 
210
                        call[0][2] for call in
 
211
                        read_mock.call_args_list]
 
212
                    write_calls = [
 
213
                        call[0][2] for call in
 
214
                        write_mock.call_args_list]
 
215
                    admin_calls = [
 
216
                        call[0][3] for call in
 
217
                        admin_mock.call_args_list]
 
218
 
 
219
                    self.assertEqual(read_calls,
 
220
                                     assert_read_calls)
 
221
                    self.assertEqual(write_calls,
 
222
                                     assert_write_calls)
 
223
                    self.assertEqual(admin_calls,
 
224
                                     assert_admin_calls)