Merge lp:~gz/juju-ci-tools/rename_admin_controller into lp:juju-ci-tools

[Martin Packman]

Refer to controller model in interfaces rather than admin model

Versions of juju that used the 'admin' name still return that, but the method for assess scripts to use is now get_controller_client() rather than get_admin_client() and so on.

The branch also renames variables used in assess scripts for clarity and mocks in tests.

One thing not changed is assess_user_grant_revoke which uses the variable name 'admin_client' but is not actually operating against the controller model. There is some kind of update needed there to make the multi-user behaviour more obvious if nothing else, but can be done as part of a separate change.

[Curtis Hovey (sinzui)]

Thank you.

review: Approve (code)

=== modified file 'assess_cs_staging.py'
--- assess_cs_staging.py	2016-03-18 03:02:01 +0000
+++ assess_cs_staging.py	2016-07-02 01:12:02 +0000
@@ -28,7 +28,7 @@
 
 
 def _set_charm_store_ip(client, ip):
-    client.get_admin_client().juju('ssh', ('0', _get_ssh_script(ip)))
+    client.get_controller_client().juju('ssh', ('0', _get_ssh_script(ip)))
 
 
 def assess_deploy(client, charm):

=== modified file 'assess_recovery.py'
--- assess_recovery.py	2016-06-27 11:41:04 +0000
+++ assess_recovery.py	2016-07-02 01:12:02 +0000
@@ -49,10 +49,10 @@
     log.info("%s is ready to testing", client.env.environment)
 
 
-def restore_present_state_server(admin_client, backup_file):
+def restore_present_state_server(controller_client, backup_file):
     """juju-restore won't restore when the state-server is still present."""
     try:
-        output = admin_client.restore_backup(backup_file)
+        output = controller_client.restore_backup(backup_file)
     except CalledProcessError as e:
         log.info(
             "juju-restore correctly refused to restore "
@@ -97,11 +97,11 @@
     return deleted_machines
 
 
-def restore_missing_state_server(client, admin_client, backup_file):
+def restore_missing_state_server(client, controller_client, backup_file):
     """juju-restore creates a replacement state-server for the services."""
     log.info("Starting restore.")
     try:
-        output = admin_client.restore_backup(backup_file)
+        output = controller_client.restore_backup(backup_file)
     except CalledProcessError as e:
         log.info('Call of juju restore exited with an error\n')
         log.info('Call:  %r\n', e.cmd)
@@ -109,7 +109,7 @@
         log.exception(e)
         raise LoggedException(e)
     log.info(output)
-    admin_client.wait_for_started(600).status
+    controller_client.wait_for_started(600).status
     log.info("%s restored", client.env.environment)
     log.info("PASS")
 
@@ -147,19 +147,19 @@
     deploy_stack(client, charm_series)
     log.info("Setup complete.")
     log.info("Test started.")
-    admin_client = client.get_admin_client()
+    controller_client = client.get_controller_client()
     if strategy in ('ha', 'ha-backup'):
-        admin_client.enable_ha()
-        admin_client.wait_for_ha()
+        controller_client.enable_ha()
+        controller_client.wait_for_ha()
     if strategy in ('ha-backup', 'backup'):
-        backup_file = admin_client.backup()
-        restore_present_state_server(admin_client, backup_file)
+        backup_file = controller_client.backup()
+        restore_present_state_server(controller_client, backup_file)
     if strategy == 'ha':
         leader_only = True
     else:
         leader_only = False
     deleted_machine_ids = delete_controller_members(
-        admin_client, leader_only=leader_only)
+        controller_client, leader_only=leader_only)
     log.info("Deleted {}".format(deleted_machine_ids))
     for m_id in deleted_machine_ids:
         if bs_manager.known_hosts.get(m_id):
@@ -169,7 +169,7 @@
         log.info("HA recovered from leader failure.")
         log.info("PASS")
     else:
-        restore_missing_state_server(client, admin_client, backup_file)
+        restore_missing_state_server(client, controller_client, backup_file)
     log.info("Test complete.")
 
 

=== modified file 'deploy_stack.py'
--- deploy_stack.py	2016-06-22 22:24:04 +0000
+++ deploy_stack.py	2016-07-02 01:12:02 +0000
@@ -698,8 +698,8 @@
         try:
             try:
                 if len(self.known_hosts) == 0:
-                    host = get_machine_dns_name(self.client.get_admin_client(),
-                                                '0')
+                    host = get_machine_dns_name(
+                        self.client.get_controller_client(), '0')
                     if host is None:
                         raise ValueError('Could not get machine 0 host')
                     self.known_hosts['0'] = host
@@ -740,7 +740,7 @@
         # be accurate for a model created by create_environment.
         if not self._should_dump():
             return
-        admin_client = self.client.get_admin_client()
+        controller_client = self.client.get_controller_client()
         if not self.jes_enabled:
             clients = [self.client]
         else:
@@ -748,13 +748,13 @@
                 clients = list(self.client.iter_model_clients())
             except Exception:
                 # Even if the controller is unreachable, we may still be able
-                # to gather some logs.  admin_client and self.client are all
-                # we have knowledge of.
-                clients = [admin_client]
-                if self.client is not admin_client:
+                # to gather some logs. The controller_client and self.client
+                # instances are all we have knowledge of.
+                clients = [controller_client]
+                if self.client is not controller_client:
                     clients.append(self.client)
         for client in clients:
-            if client.env.environment == admin_client.env.environment:
+            if client.env.environment == controller_client.env.environment:
                 known_hosts = self.known_hosts
                 if self.jes_enabled:
                     runtime_config = self.client.get_cache_path()

=== modified file 'industrial_test.py'
--- industrial_test.py	2016-06-01 13:57:51 +0000
+++ industrial_test.py	2016-07-02 01:12:02 +0000
@@ -611,10 +611,10 @@
         """Iterate the steps of this Stage.  See SteppedStageAttempt."""
         results = {'test_id': 'ensure-availability-n3'}
         yield results
-        admin_client = client.get_admin_client()
-        admin_client.enable_ha()
+        controller_client = client.get_controller_client()
+        controller_client.enable_ha()
         yield results
-        admin_client.wait_for_ha()
+        controller_client.wait_for_ha()
         results['result'] = True
         yield results
 
@@ -773,21 +773,22 @@
         """Iterate the steps of this Stage.  See SteppedStageAttempt."""
         results = {'test_id': 'back-up-restore'}
         yield results
-        admin_client = client.get_admin_client()
-        backup_file = admin_client.backup()
+        controller_client = client.get_controller_client()
+        backup_file = controller_client.backup()
         try:
-            status = admin_client.get_status()
+            status = controller_client.get_status()
             instance_id = status.get_instance_id('0')
-            host = get_machine_dns_name(admin_client, '0')
-            terminate_instances(admin_client.env, [instance_id])
-            yield results
-            wait_for_state_server_to_shutdown(host, admin_client, instance_id)
-            yield results
-            with admin_client.restore_backup(backup_file):
+            host = get_machine_dns_name(controller_client, '0')
+            terminate_instances(controller_client.env, [instance_id])
+            yield results
+            wait_for_state_server_to_shutdown(
+                host, controller_client, instance_id)
+            yield results
+            with controller_client.restore_backup(backup_file):
                 yield results
         finally:
             os.unlink(backup_file)
-        with wait_for_started(admin_client):
+        with wait_for_started(controller_client):
             yield results
         results['result'] = True
         yield results

=== modified file 'jujupy.py'
--- jujupy.py	2016-06-20 05:44:22 +0000
+++ jujupy.py	2016-07-02 01:12:02 +0000
@@ -704,11 +704,11 @@
     def get_cache_path(self):
         return get_cache_path(self.env.juju_home, models=True)
 
-    def _cmd_model(self, include_e, admin):
-        if admin:
+    def _cmd_model(self, include_e, controller):
+        if controller:
             return '{controller}:{model}'.format(
                 controller=self.env.controller.name,
-                model=self.get_admin_model_name())
+                model=self.get_controller_model_name())
         elif self.env is None or not include_e:
             return None
         else:
@@ -717,8 +717,8 @@
                 model=self.model_name)
 
     def _full_args(self, command, sudo, args,
-                   timeout=None, include_e=True, admin=False):
-        model = self._cmd_model(include_e, admin)
+                   timeout=None, include_e=True, controller=False):
+        model = self._cmd_model(include_e, controller)
         # sudo is not needed for devel releases.
         return self._backend.full_args(command, args, model, timeout)
 
@@ -924,7 +924,7 @@
         <environment> flag will be placed after <command> and before args.
         """
         model = self._cmd_model(kwargs.get('include_e', True),
-                                kwargs.get('admin', False))
+                                kwargs.get('controller', False))
         timeout = kwargs.get('timeout')
         return self._backend.get_juju_output(
             command, args, self.used_feature_flags, self.env.juju_home,
@@ -934,7 +934,7 @@
         """Print the status to output."""
         self.juju(self._show_status, ('--format', 'yaml'))
 
-    def get_status(self, timeout=60, raw=False, admin=False, *args):
+    def get_status(self, timeout=60, raw=False, controller=False, *args):
         """Get the current status as a dict."""
         # GZ 2015-12-16: Pass remaining timeout into get_juju_output call.
         for ignored in until_timeout(timeout):
@@ -943,7 +943,8 @@
                     return self.get_juju_output(self._show_status, *args)
                 return self.status_class.from_text(
                     self.get_juju_output(
-                        self._show_status, '--format', 'yaml', admin=admin))
+                        self._show_status, '--format', 'yaml',
+                        controller=controller))
             except subprocess.CalledProcessError:
                 pass
         raise Exception(
@@ -995,7 +996,7 @@
     def juju(self, command, args, sudo=False, check=True, include_e=True,
              timeout=None, extra_env=None):
         """Run a command under juju for the current environment."""
-        model = self._cmd_model(include_e, admin=False)
+        model = self._cmd_model(include_e, controller=False)
         return self._backend.juju(
             command, args, self.used_feature_flags, self.env.juju_home,
             model, check, timeout, extra_env)
@@ -1018,7 +1019,7 @@
           `args`.
 
         """
-        model = self._cmd_model(include_e, admin=False)
+        model = self._cmd_model(include_e, controller=False)
         return self._backend.expect(
             command, args, self.used_feature_flags, self.env.juju_home,
             model, timeout, extra_env)
@@ -1034,7 +1035,7 @@
         return stringified_timings
 
     def juju_async(self, command, args, include_e=True, timeout=None):
-        model = self._cmd_model(include_e, admin=False)
+        model = self._cmd_model(include_e, controller=False)
         return self._backend.juju_async(command, args, self.used_feature_flags,
                                         self.env.juju_home, model, timeout)
 
@@ -1252,10 +1253,10 @@
         for model in models:
             yield self._acquire_model_client(model['name'])
 
-    def get_admin_model_name(self):
-        """Return the name of the 'admin' model.
+    def get_controller_model_name(self):
+        """Return the name of the 'controller' model.
 
-        Return the name of the environment when an 'admin' model does
+        Return the name of the environment when an 'controller' model does
         not exist.
         """
         return 'controller'
@@ -1271,13 +1272,13 @@
             env = self.env.clone(model_name=name)
             return self.clone(env=env)
 
-    def get_admin_client(self):
-        """Return a client for the admin model.  May return self.
+    def get_controller_client(self):
+        """Return a client for the controller model.  May return self.
 
         This may be inaccurate for models created using add_model
         rather than bootstrap.
         """
-        return self._acquire_model_client(self.get_admin_model_name())
+        return self._acquire_model_client(self.get_controller_model_name())
 
     def list_controllers(self):
         """List the controllers."""
@@ -1329,7 +1330,7 @@
         reporter = GroupReporter(sys.stdout, desired_state)
         try:
             for remaining in until_timeout(timeout):
-                status = self.get_status(admin=True)
+                status = self.get_status(controller=True)
                 states = {}
                 for machine, info in status.iter_machines():
                     status = self.get_controller_member_status(info)
@@ -1637,10 +1638,10 @@
 
 class EnvJujuClient2B7(EnvJujuClient2B8):
 
-    def get_admin_model_name(self):
-        """Return the name of the 'admin' model.
+    def get_controller_model_name(self):
+        """Return the name of the 'controller' model.
 
-        Return the name of the environment when an 'admin' model does
+        Return the name of the environment when an 'controller' model does
         not exist.
         """
         return 'admin'
@@ -1678,21 +1679,21 @@
             args.extend(['--bootstrap-series', bootstrap_series])
         return tuple(args)
 
-    def get_admin_client(self):
-        """Return a client for the admin model.  May return self."""
+    def get_controller_client(self):
+        """Return a client for the controller model.  May return self."""
         return self
 
-    def get_admin_model_name(self):
-        """Return the name of the 'admin' model.
+    def get_controller_model_name(self):
+        """Return the name of the 'controller' model.
 
-        Return the name of the environment when an 'admin' model does
+        Return the name of the environment when an 'controller' model does
         not exist.
         """
         models = self.get_models()
         # The dict can be empty because 1.x does not support the models.
         # This is an ambiguous case for the jes feature flag which supports
         # multiple models, but none is named 'admin' by default. Since the
-        # jes case also uses '-e' for models, the env is the admin model.
+        # jes case also uses '-e' for models, the env is the controller model.
         for model in models.get('models', []):
             if 'admin' in model['name']:
                 return 'admin'
@@ -1908,9 +1909,9 @@
 
     supported_container_types = frozenset([KVM_MACHINE, LXC_MACHINE])
 
-    def _cmd_model(self, include_e, admin):
-        if admin:
-            return self.get_admin_model_name()
+    def _cmd_model(self, include_e, controller):
+        if controller:
+            return self.get_controller_model_name()
         elif self.env is None or not include_e:
             return None
         else:

=== modified file 'tests/test_assess_cs_staging.py'
--- tests/test_assess_cs_staging.py	2016-05-23 03:02:18 +0000
+++ tests/test_assess_cs_staging.py	2016-07-02 01:12:02 +0000
@@ -44,7 +44,7 @@
 
 class TestSetCharmStoreIP(TestCase):
 
-    def test_default_as_admin(self):
+    def test_default_as_controller(self):
         client = fake_juju_client_optional_jes(jes_enabled=False)
         client.bootstrap()
         with patch.object(client, 'juju', autospec=True) as juju_mock:
@@ -52,15 +52,15 @@
         juju_mock.assert_called_once_with(
             'ssh', ('0', _get_ssh_script('1.2.3.4')))
 
-    def test_separate_admin(self):
+    def test_separate_controller(self):
         client = fake_juju_client()
         client.bootstrap()
-        admin_client = client.get_admin_client()
-        # Force get_admin_client to return the *same* client, instead of an
-        # equivalent one.
-        with patch.object(client, 'get_admin_client',
-                          return_value=admin_client, autospec=True):
-            with patch.object(admin_client, 'juju',
+        controller_client = client.get_controller_client()
+        # Force get_controller_client to return the *same* client, instead of
+        # an equivalent one.
+        with patch.object(client, 'get_controller_client',
+                          return_value=controller_client, autospec=True):
+            with patch.object(controller_client, 'juju',
                               autospec=True) as juju_mock:
                 _set_charm_store_ip(client, '1.2.3.4')
         juju_mock.assert_called_once_with(

=== modified file 'tests/test_assess_recovery.py'
--- tests/test_assess_recovery.py	2016-06-04 02:49:54 +0000
+++ tests/test_assess_recovery.py	2016-07-02 01:12:02 +0000
@@ -64,9 +64,9 @@
         client.bootstrap()
 
         def terminate(env, instance_ids):
+            model = client._backend.controller_state.controller_model
             for instance_id in instance_ids:
-                admin_model = client._backend.controller_state.admin_model
-                admin_model.remove_state_server(instance_id)
+                model.remove_state_server(instance_id)
 
         with patch('assess_recovery.wait_for_state_server_to_shutdown',
                    autospec=True):
@@ -93,19 +93,19 @@
         with self.assess_recovery_cxt(client):
             assess_recovery(bs_manager, 'ha-backup', 'trusty')
 
-    def test_admin_model_backup(self):
+    def test_controller_model_backup(self):
         client = fake_juju_client()
         bs_manager = Mock(client=client, known_hosts={})
         with self.assess_recovery_cxt(client):
             assess_recovery(bs_manager, 'backup', 'trusty')
 
-    def test_admin_model_ha(self):
+    def test_controller_model_ha(self):
         client = fake_juju_client()
         bs_manager = Mock(client=client, known_hosts={})
         with self.assess_recovery_cxt(client):
             assess_recovery(bs_manager, 'ha', 'trusty')
 
-    def test_admin_model_ha_backup(self):
+    def test_controller_model_ha_backup(self):
         client = fake_juju_client()
         bs_manager = Mock(client=client, known_hosts={})
         with self.assess_recovery_cxt(client):

=== modified file 'tests/test_chaos.py'
--- tests/test_chaos.py	2016-06-08 00:30:20 +0000
+++ tests/test_chaos.py	2016-07-02 01:12:02 +0000
@@ -332,7 +332,7 @@
         expected = ['abcd' * 9, '1234' * 9]
         self.assertEqual(
             [
-                call('show-status', '--format', 'yaml', admin=False),
+                call('show-status', '--format', 'yaml', controller=False),
                 call('run-action', 'chaos-monkey/1', 'start', 'mode=single',
                      'enablement-timeout=120'),
                 call('run-action', 'chaos-monkey/0', 'start', 'mode=single',
@@ -348,7 +348,7 @@
             monkey_runner.unleash_once()
         self.assertEqual(
             [
-                call('show-status', '--format', 'yaml', admin=False),
+                call('show-status', '--format', 'yaml', controller=False),
                 call('run-action',
                      'chaos-monkey/1', 'start', 'mode=single',
                      'enablement-timeout=120',

=== modified file 'tests/test_deploy_stack.py'
--- tests/test_deploy_stack.py	2016-06-13 20:14:35 +0000
+++ tests/test_deploy_stack.py	2016-07-02 01:12:02 +0000
@@ -736,7 +736,7 @@
         self.assertEqual(cc_mock.call_count, 4)
         self.assertEqual(
             [
-                call('show-status', '--format', 'yaml', admin=False)
+                call('show-status', '--format', 'yaml', controller=False)
             ],
             gjo_mock.call_args_list)
 

=== modified file 'tests/test_industrial_test.py'
--- tests/test_industrial_test.py	2016-06-08 00:30:20 +0000
+++ tests/test_industrial_test.py	2016-07-02 01:12:02 +0000
@@ -1439,21 +1439,21 @@
 
     def test_iter_steps(self):
         client = FakeEnvJujuClient()
-        admin_client = client.get_admin_client()
+        controller_client = client.get_controller_client()
         ensure_av = EnsureAvailabilityAttempt()
         ensure_iter = iter_steps_validate_info(self, ensure_av, client)
         self.assertEqual(ensure_iter.next(), {
             'test_id': 'ensure-availability-n3'})
         with patch('subprocess.check_call') as cc_mock:
-            with patch.object(client, 'get_admin_client',
-                              return_value=admin_client, autospec=True):
+            with patch.object(client, 'get_controller_client',
+                              return_value=controller_client, autospec=True):
                 self.assertEqual(ensure_iter.next(), {
                     'test_id': 'ensure-availability-n3'})
         assert_juju_call(
             self,
             cc_mock, client,
             ('juju', '--show-log', 'enable-ha', '-m',
-             'steve:{}'.format(admin_client.env.environment), '-n', '3'))
+             'steve:{}'.format(controller_client.env.environment), '-n', '3'))
         status = {
             'machines': {
                 '0': {'controller-member-status': 'has-vote'},
@@ -1462,10 +1462,10 @@
                 },
             'applications': {},
         }
-        with patch_status(admin_client, status) as gs_mock:
+        with patch_status(controller_client, status) as gs_mock:
             self.assertEqual(ensure_iter.next(), {
                 'test_id': 'ensure-availability-n3', 'result': True})
-        gs_mock.assert_called_once_with(admin=True)
+        gs_mock.assert_called_once_with(controller=True)
 
     def test_iter_steps_failure(self):
         client = FakeEnvJujuClient()
@@ -1473,9 +1473,9 @@
         ensure_iter = iter_steps_validate_info(self, ensure_av, client)
         ensure_iter.next()
         with patch('subprocess.check_call'):
-            admin_client = client.get_admin_client()
-            with patch.object(client, 'get_admin_client',
-                              return_value=admin_client, autospec=True):
+            controller_client = client.get_controller_client()
+            with patch.object(client, 'get_controller_client',
+                              return_value=controller_client, autospec=True):
                 ensure_iter.next()
         status = {
             'machines': {
@@ -1484,7 +1484,7 @@
                 },
             'applications': {},
         }
-        with patch_status(admin_client, status) as gs_mock:
+        with patch_status(controller_client, status) as gs_mock:
             with self.assertRaisesRegexp(
                     Exception, 'Timed out waiting for voting to be enabled.'):
                 ensure_iter.next()
@@ -1766,13 +1766,14 @@
         client.env.environment = aws_env.environment
         client.env.config = aws_env.config
         client.env.juju_home = aws_env.juju_home
-        admin_client = client.get_admin_client()
+        controller_client = client.get_controller_client()
         environ = dict(os.environ)
         environ.update(get_euca_env(client.env.config))
 
         def check_output(*args, **kwargs):
-            if args == (('juju', '--show-log', 'create-backup', '-m',
-                         'steve:{}'.format(admin_client.env.environment),),):
+            if args == ((
+                    'juju', '--show-log', 'create-backup', '-m',
+                    'steve:{}'.format(controller_client.env.environment),),):
                 return FakePopen('juju-backup-24.tgz', '', 0)
             self.assertEqual([], args)
         initial_status = {
@@ -1783,12 +1784,12 @@
         }
         iterator = iter_steps_validate_info(self, br_attempt, client)
         self.assertEqual(iterator.next(), {'test_id': 'back-up-restore'})
-        with patch_status(admin_client, initial_status) as gs_mock:
+        with patch_status(controller_client, initial_status) as gs_mock:
             with patch('subprocess.Popen',
                        side_effect=check_output) as co_mock:
                 with patch('subprocess.check_call') as cc_mock:
-                    with patch.object(client, 'get_admin_client',
-                                      return_value=admin_client,
+                    with patch.object(client, 'get_controller_client',
+                                      return_value=controller_client,
                                       autospec=True):
                         with patch('sys.stdout'):
                             self.assertEqual(
@@ -1799,7 +1800,7 @@
             co_mock,
             client,
             ('juju', '--show-log', 'create-backup',
-             '-m', 'steve:{}'.format(admin_client.env.environment)),
+             '-m', 'steve:{}'.format(controller_client.env.environment)),
             0)
         self.assertEqual(
             cc_mock.mock_calls[0],
@@ -1809,7 +1810,7 @@
                 self.assertEqual(iterator.next(),
                                  {'test_id': 'back-up-restore'})
         pn_mock.assert_called_with('Closed.')
-        with patch.object(admin_client, 'restore_backup') as rb_mock:
+        with patch.object(controller_client, 'restore_backup') as rb_mock:
             self.assertEqual(iterator.next(), {'test_id': 'back-up-restore'})
         rb_mock.assert_called_once_with(
             os.path.abspath('juju-backup-24.tgz'))
@@ -1823,7 +1824,7 @@
                 },
             'applications': {},
         }
-        with patch_status(admin_client, final_status) as gs_mock:
+        with patch_status(controller_client, final_status) as gs_mock:
             self.assertEqual(iterator.next(),
                              {'test_id': 'back-up-restore', 'result': True})
         gs_mock.assert_called_once_with()

=== modified file 'tests/test_jujupy.py'
--- tests/test_jujupy.py	2016-06-20 05:08:22 +0000
+++ tests/test_jujupy.py	2016-07-02 01:12:02 +0000
@@ -103,11 +103,11 @@
     return wrapper
 
 
-class AdminOperation(Exception):
+class ControllerOperation(Exception):
 
     def __init__(self, operation):
-        super(AdminOperation, self).__init__(
-            'Operation "{}" can only be performed on admin models.'.format(
+        super(ControllerOperation, self).__init__(
+            'Operation "{}" is only valid on controller models.'.format(
                 operation))
 
 
@@ -134,19 +134,19 @@
         state.controller.state = 'created'
         return state
 
-    def require_admin(self, operation, name):
-        if name != self.admin_model.name:
-            raise AdminOperation(operation)
+    def require_controller(self, operation, name):
+        if name != self.controller_model.name:
+            raise ControllerOperation(operation)
 
-    def bootstrap(self, model_name, config, separate_admin):
+    def bootstrap(self, model_name, config, separate_controller):
         default_model = self.add_model(model_name)
         default_model.name = model_name
-        if separate_admin:
-            admin_model = default_model.controller.add_model('controller')
+        if separate_controller:
+            controller_model = default_model.controller.add_model('controller')
         else:
-            admin_model = default_model
-        self.admin_model = admin_model
-        admin_model.state_servers.append(admin_model.add_machine())
+            controller_model = default_model
+        self.controller_model = controller_model
+        controller_model.state_servers.append(controller_model.add_machine())
         self.state = 'bootstrapped'
         default_model.model_config = copy.deepcopy(config)
         self.models[default_model.name] = default_model
@@ -234,7 +234,7 @@
         self.controller.state = 'model-destroyed'
 
     def restore_backup(self):
-        self.controller.require_admin('restore', self.name)
+        self.controller.require_controller('restore', self.name)
         if len(self.state_servers) > 0:
             exc = subprocess.CalledProcessError('Operation not permitted', 1,
                                                 2)
@@ -242,7 +242,7 @@
             raise exc
 
     def enable_ha(self):
-        self.controller.require_admin('enable-ha', self.name)
+        self.controller.require_controller('enable-ha', self.name)
         for n in range(2):
             self.state_servers.append(self.add_machine())
 
@@ -420,13 +420,13 @@
             for x in range(parsed.count):
                 model_state.add_machine()
 
-    def get_admin_model_name(self):
-        return self.controller_state.admin_model.name
+    def get_controller_model_name(self):
+        return self.controller_state.controller_model.name
 
     def make_controller_dict(self, controller_name):
-        admin_model = self.controller_state.admin_model
-        server_id = list(admin_model.state_servers)[0]
-        server_hostname = admin_model.machine_host_names[server_id]
+        controller_model = self.controller_state.controller_model
+        server_id = list(controller_model.state_servers)[0]
+        server_hostname = controller_model.machine_host_names[server_id]
         api_endpoint = '{}:23'.format(server_hostname)
         return {controller_name: {'details': {'api-endpoints': [
             api_endpoint]}}}
@@ -579,7 +579,7 @@
             # subset of YAML, so emit JSON.
             return json.dumps(status_dict)
         if command == 'create-backup':
-            self.controller_state.require_admin('backup', model)
+            self.controller_state.require_controller('backup', model)
             return 'juju-backup-0.tar.gz'
         return ''
 
@@ -658,8 +658,8 @@
 
 class FakeJujuClientOptionalJES(EnvJujuClient):
 
-    def get_admin_model_name(self):
-        return self._backend.controller_state.admin_model.name
+    def get_controller_model_name(self):
+        return self._backend.controller_state.controller_model.name
 
 
 class TestErroredUnit(TestCase):
@@ -1228,7 +1228,7 @@
         full = client._full_args('bar', True, ('baz', 'qux'))
         self.assertEqual((
             'bin', '--show-log', 'bar', '-m', 'foo:foo', 'baz', 'qux'), full)
-        full = client._full_args('bar', True, ('baz', 'qux'), admin=True)
+        full = client._full_args('bar', True, ('baz', 'qux'), controller=True)
         self.assertEqual(
             ('bin', '--show-log', 'bar', '-m', 'foo:controller', 'baz', 'qux'),
             full)
@@ -1252,12 +1252,13 @@
              'baz', 'qux'),
             full)
 
-    def test_full_args_admin(self):
+    def test_full_args_controller(self):
         env = JujuData('foo')
         client = EnvJujuClient(env, None, 'my/juju/bin')
-        with patch.object(client, 'get_admin_model_name',
+        with patch.object(client, 'get_controller_model_name',
                           return_value='controller') as gamn_mock:
-            full = client._full_args('bar', False, ('baz', 'qux'), admin=True)
+            full = client._full_args('bar', False, ('baz', 'qux'),
+                                     controller=True)
         self.assertEqual((
             'bin', '--show-log', 'bar', '-m', 'foo:controller', 'baz', 'qux'),
             full)
@@ -1593,7 +1594,7 @@
                           return_value=output_text) as gjo_mock:
             result = client.get_status()
         gjo_mock.assert_called_once_with(
-            'show-status', '--format', 'yaml', admin=False)
+            'show-status', '--format', 'yaml', controller=False)
         self.assertEqual(Status, type(result))
         self.assertEqual(['a', 'b', 'c'], result.status)
 
@@ -2227,7 +2228,7 @@
         self.assertIs(client, model_clients[0])
         self.assertEqual('bar', model_clients[1].env.environment)
 
-    def test_get_admin_model_name(self):
+    def test_get_controller_model_name(self):
         models = {
             'models': [
                 {'name': 'controller', 'model-uuid': 'aaaa'},
@@ -2237,11 +2238,11 @@
         client = EnvJujuClient(JujuData('foo'), None, None)
         with patch.object(client, 'get_models',
                           return_value=models) as gm_mock:
-            admin_name = client.get_admin_model_name()
+            controller_name = client.get_controller_model_name()
         self.assertEqual(0, gm_mock.call_count)
-        self.assertEqual('controller', admin_name)
+        self.assertEqual('controller', controller_name)
 
-    def test_get_admin_model_name_without_admin(self):
+    def test_get_controller_model_name_without_controller(self):
         models = {
             'models': [
                 {'name': 'bar', 'model-uuid': 'aaaa'},
@@ -2250,23 +2251,23 @@
         }
         client = EnvJujuClient(JujuData('foo'), None, None)
         with patch.object(client, 'get_models', return_value=models):
-            admin_name = client.get_admin_model_name()
-        self.assertEqual('controller', admin_name)
+            controller_name = client.get_controller_model_name()
+        self.assertEqual('controller', controller_name)
 
-    def test_get_admin_model_name_no_models(self):
+    def test_get_controller_model_name_no_models(self):
         client = EnvJujuClient(JujuData('foo'), None, None)
         with patch.object(client, 'get_models', return_value={}):
-            admin_name = client.get_admin_model_name()
-        self.assertEqual('controller', admin_name)
+            controller_name = client.get_controller_model_name()
+        self.assertEqual('controller', controller_name)
 
-    def test_get_admin_client(self):
+    def test_get_controller_client(self):
         client = EnvJujuClient(
             JujuData('foo', {'bar': 'baz'}, 'myhome'), None, None)
-        admin_client = client.get_admin_client()
-        admin_env = admin_client.env
-        self.assertEqual('controller', admin_env.environment)
+        controller_client = client.get_controller_client()
+        controller_env = controller_client.env
+        self.assertEqual('controller', controller_env.environment)
         self.assertEqual(
-            {'bar': 'baz', 'name': 'controller'}, admin_env.config)
+            {'bar': 'baz', 'name': 'controller'}, controller_env.config)
 
     def test_list_controllers(self):
         client = EnvJujuClient(JujuData('foo'), None, None)
@@ -2309,18 +2310,18 @@
               api-endpoints: ['[::1]:17070', '[fe80::216:3eff:0:9dc7]:17070']
         """
         client = EnvJujuClient(JujuData('foo', {}), None, None)
-        admin_client = client.get_admin_client()
+        controller_client = client.get_controller_client()
         client.env.controller.name = 'bar'
-        with patch.object(admin_client, 'get_juju_output',
+        with patch.object(controller_client, 'get_juju_output',
                           return_value=data) as gjo:
-            endpoint = admin_client.get_controller_endpoint()
+            endpoint = controller_client.get_controller_endpoint()
         gjo.assert_called_once_with('show-controller', 'bar',
                                     include_e=False)
         self.assertEqual('::1', endpoint)
 
     def test_get_controller_members(self):
         status = Status.from_text("""\
-            model: admin
+            model: controller
             machines:
               "0":
                 dns-name: 10.0.0.0
@@ -2370,7 +2371,7 @@
 
     def test_get_controller_members_one(self):
         status = Status.from_text("""\
-            model: admin
+            model: controller
             machines:
               "0":
                 dns-name: 10.0.0.0
@@ -2418,7 +2419,7 @@
                           return_value=value) as gjo_mock:
             client.wait_for_ha()
         gjo_mock.assert_called_once_with(
-            'show-status', '--format', 'yaml', admin=True)
+            'show-status', '--format', 'yaml', controller=True)
 
     def test_wait_for_ha_no_has_vote(self):
         value = yaml.safe_dump({
@@ -3266,7 +3267,7 @@
 
 class TestEnvJujuClient2B7(ClientTest):
 
-    def test_get_admin_model_name(self):
+    def test_get_controller_model_name(self):
         models = {
             'models': [
                 {'name': 'admin', 'model-uuid': 'aaaa'},
@@ -3276,11 +3277,11 @@
         client = EnvJujuClient2B7(JujuData('foo'), None, None)
         with patch.object(client, 'get_models',
                           return_value=models) as gm_mock:
-            admin_name = client.get_admin_model_name()
+            controller_name = client.get_controller_model_name()
         self.assertEqual(0, gm_mock.call_count)
-        self.assertEqual('admin', admin_name)
+        self.assertEqual('admin', controller_name)
 
-    def test_get_admin_model_name_without_admin(self):
+    def test_get_controller_model_name_without_controller(self):
         models = {
             'models': [
                 {'name': 'bar', 'model-uuid': 'aaaa'},
@@ -3289,22 +3290,23 @@
         }
         client = EnvJujuClient2B7(JujuData('foo'), None, None)
         with patch.object(client, 'get_models', return_value=models):
-            admin_name = client.get_admin_model_name()
-        self.assertEqual('admin', admin_name)
+            controller_name = client.get_controller_model_name()
+        self.assertEqual('admin', controller_name)
 
-    def test_get_admin_model_name_no_models(self):
+    def test_get_controller_model_name_no_models(self):
         client = EnvJujuClient2B7(JujuData('foo'), None, None)
         with patch.object(client, 'get_models', return_value={}):
-            admin_name = client.get_admin_model_name()
-        self.assertEqual('admin', admin_name)
+            controller_name = client.get_controller_model_name()
+        self.assertEqual('admin', controller_name)
 
-    def test_get_admin_client(self):
+    def test_get_controller_client(self):
         client = EnvJujuClient2B7(
             JujuData('foo', {'bar': 'baz'}, 'myhome'), None, None)
-        admin_client = client.get_admin_client()
-        admin_env = admin_client.env
-        self.assertEqual('admin', admin_env.environment)
-        self.assertEqual({'bar': 'baz', 'name': 'admin'}, admin_env.config)
+        controller_client = client.get_controller_client()
+        controller_env = controller_client.env
+        self.assertEqual('admin', controller_env.environment)
+        self.assertEqual({'bar': 'baz', 'name': 'admin'},
+                         controller_env.config)
 
 
 class TestEnvJujuClient2B3(ClientTest):
@@ -3431,7 +3433,7 @@
                 config = yaml.safe_load(config_file)
         self.assertEqual({'test-mode': True}, config)
 
-    def test_get_admin_model_name(self):
+    def test_get_controller_model_name(self):
         models = {
             'models': [
                 {'name': 'admin', 'model-uuid': 'aaaa'},
@@ -3441,11 +3443,11 @@
         client = EnvJujuClient2B2(JujuData('foo'), None, None)
         with patch.object(client, 'get_models',
                           return_value=models) as gm_mock:
-            admin_name = client.get_admin_model_name()
+            controller_name = client.get_controller_model_name()
         gm_mock.assert_called_once_with()
-        self.assertEqual('admin', admin_name)
+        self.assertEqual('admin', controller_name)
 
-    def test_get_admin_model_name_without_admin(self):
+    def test_get_controller_model_name_without_controller(self):
         models = {
             'models': [
                 {'name': 'bar', 'model-uuid': 'aaaa'},
@@ -3454,14 +3456,14 @@
         }
         client = EnvJujuClient2B2(JujuData('foo'), None, None)
         with patch.object(client, 'get_models', return_value=models):
-            admin_name = client.get_admin_model_name()
-        self.assertEqual('foo', admin_name)
+            controller_name = client.get_controller_model_name()
+        self.assertEqual('foo', controller_name)
 
-    def test_get_admin_model_name_no_models(self):
+    def test_get_controller_model_name_no_models(self):
         client = EnvJujuClient2B2(JujuData('foo'), None, None)
         with patch.object(client, 'get_models', return_value={}):
-            admin_name = client.get_admin_model_name()
-        self.assertEqual('foo', admin_name)
+            controller_name = client.get_controller_model_name()
+        self.assertEqual('foo', controller_name)
 
 
 class TestEnvJujuClient2A2(TestCase):
@@ -3690,10 +3692,10 @@
         self.assertEqual((
             'bin', '--debug', 'bar', '-e', 'foo', 'baz', 'qux'), full)
 
-    def test_full_args_admin(self):
+    def test_full_args_controller(self):
         env = SimpleEnvironment('foo')
         client = EnvJujuClient1X(env, None, 'my/juju/bin')
-        full = client._full_args('bar', False, ('baz', 'qux'), admin=True)
+        full = client._full_args('bar', False, ('baz', 'qux'), controller=True)
         self.assertEqual((
             'bin', '--show-log', 'bar', '-e', 'foo', 'baz', 'qux'), full)
 
@@ -3987,7 +3989,7 @@
                           return_value=output_text) as gjo_mock:
             result = client.get_status()
         gjo_mock.assert_called_once_with(
-            'status', '--format', 'yaml', admin=False)
+            'status', '--format', 'yaml', controller=False)
         self.assertEqual(ServiceStatus, type(result))
         self.assertEqual(['a', 'b', 'c'], result.status)
 
@@ -4029,7 +4031,7 @@
                     client.get_status(500)
         mock_ut.assert_called_with(500)
 
-    def test_get_status_admin(self):
+    def test_get_status_controller(self):
         output_text = """\
             - a
             - b
@@ -4039,9 +4041,9 @@
         client = EnvJujuClient1X(env, None, None)
         with patch.object(client, 'get_juju_output',
                           return_value=output_text) as gjo_mock:
-            client.get_status(admin=True)
+            client.get_status(controller=True)
         gjo_mock.assert_called_once_with(
-            'status', '--format', 'yaml', admin=True)
+            'status', '--format', 'yaml', controller=True)
 
     @staticmethod
     def make_status_yaml(key, machine_value, unit_value):
@@ -5051,18 +5053,18 @@
         self.assertIs(client, model_clients[0])
         self.assertEqual('bar', model_clients[1].env.environment)
 
-    def test_get_admin_model_name_no_models(self):
+    def test_get_controller_model_name_no_models(self):
         env = SimpleEnvironment('foo', {'type': 'local'})
         client = EnvJujuClient1X(env, '1.23-series-arch', None)
         with patch.object(client, 'get_models', return_value={}):
-            admin_name = client.get_admin_model_name()
-        self.assertEqual('foo', admin_name)
+            controller_name = client.get_controller_model_name()
+        self.assertEqual('foo', controller_name)
 
-    def test_get_admin_client(self):
+    def test_get_controller_client(self):
         client = EnvJujuClient1X(SimpleEnvironment('foo'), {'bar': 'baz'},
                                  'myhome')
-        admin_client = client.get_admin_client()
-        self.assertIs(client, admin_client)
+        controller_client = client.get_controller_client()
+        self.assertIs(client, controller_client)
 
     def test_list_controllers(self):
         env = SimpleEnvironment('foo', {'type': 'local'})

=== modified file 'tests/test_quickstart_deploy.py'
--- tests/test_quickstart_deploy.py	2016-06-02 17:25:41 +0000
+++ tests/test_quickstart_deploy.py	2016-07-02 01:12:02 +0000
@@ -85,9 +85,9 @@
         with patch('deploy_stack.get_machine_dns_name',
                    return_value='mocked_name') as dns_mock:
             # Test second yield
-            with patch.object(client, 'get_admin_client') as gac_mock:
+            with patch.object(client, 'get_controller_client') as gcc_mock:
                 step = steps.next()
-        dns_mock.assert_called_once_with(gac_mock.return_value, '0')
+        dns_mock.assert_called_once_with(gcc_mock.return_value, '0')
         self.assertEqual('mocked_name', step['bootstrap_host'])
         with patch.object(client, 'wait_for_deploy_started') as wds_mock:
             # Test third yield