Merge lp:~frankban/juju-quickstart/handle-jenv-envs into lp:juju-quickstart

[Francesco Banconi]

Promote jenv files as first class envs.

Quickstart no longer refuses to use an environment
which is only present as a jenv file.

Add some more helper functions to the

Also retrieve the environment type, in the case
the environment is already bootstrapped, from
the WebSocket connection and not from the jenv:
jenv files are not assumed to include the type.

Tests: `make check`.

QA:
- use quickstart to bootstrap an environment:
  `.venv/bin/python juju-quickstart`;

- re-run quickstart again to reopen the same environment:
  `.venv/bin/python juju-quickstart`;

- in both cases, check auto-login works and the output
  is sane;

- generate a new environment user and put the
  resulting jenv in your Juju home:
  `juju user add myuser --generate -o ~/.juju/environments/myenv.jenv`;

- use quickstart with the new environment:
  `.venv/bin/python juju-quickstart -e myenv`;

- check that the new credentials are printed to stdout
  and that the auto-login still works;

- destroy the environment.

Thanks a lot!

https://codereview.appspot.com/188300043/

[Francesco Banconi (frankban)]

Reviewers: mp+244880_code.launchpad.net,

Message:
Please take a look.

Description:
Promote jenv files as first class envs.

Quickstart no longer refuses to use an environment
which is only present as a jenv file.

Add some more helper functions to the

Also retrieve the environment type, in the case
the environment is already bootstrapped, from
the WebSocket connection and not from the jenv:
jenv files are not assumed to include the type.

Tests: `make check`.

QA:
- use quickstart to bootstrap an environment:
   `.venv/bin/python juju-quickstart`;

- re-run quickstart again to reopen the same environment:
   `.venv/bin/python juju-quickstart`;

- in both cases, check auto-login works and the output
   is sane;

- generate a new environment user and put the
   resulting jenv in your Juju home:
   `juju user add myuser --generate -o ~/.juju/environments/myenv.jenv`;

- use quickstart with the new environment:
   `.venv/bin/python juju-quickstart -e myenv`;

- check that the new credentials are printed to stdout
   and that the auto-login still works;

- destroy the environment.

Thanks a lot!

https://code.launchpad.net/~frankban/juju-quickstart/handle-jenv-envs/+merge/244880

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/188300043/

Affected files (+366, -80 lines):
   A [revision details]
   M quickstart/app.py
   M quickstart/manage.py
   M quickstart/models/jenv.py
   M quickstart/tests/helpers.py
   M quickstart/tests/models/test_jenv.py
   M quickstart/tests/test_app.py
   M quickstart/tests/test_juju.py
   M quickstart/tests/test_manage.py

[Brad Crittenden (bac)]

LGTM. WIll QA next.

https://codereview.appspot.com/188300043/diff/1/quickstart/manage.py
File quickstart/manage.py (right):

https://codereview.appspot.com/188300043/diff/1/quickstart/manage.py#newcode241
quickstart/manage.py:241: # If the environment was found in the
environments.yaml file, we can also
This comment seems wrong since we could've come through the second path,
meaning it was not in environments.yaml.

https://codereview.appspot.com/188300043/

[Brad Crittenden (bac)]

QA was OK.

Note juju will not let you destroy the environment with the generated
name. If 'local' was originally booted and a mytest.jenv file was
generated by 'juju user add' then 'juju destroy-environment mytest'
prints "removing empty environment file" but does not destroy the
environment.

Not a quickstart issue but interesting.

https://codereview.appspot.com/188300043/

[Richard Harding (rharding)]

LGTM

https://codereview.appspot.com/188300043/

[Francesco Banconi (frankban)]

Thanks for the reviews!

https://codereview.appspot.com/188300043/diff/1/quickstart/manage.py
File quickstart/manage.py (right):

https://codereview.appspot.com/188300043/diff/1/quickstart/manage.py#newcode241
quickstart/manage.py:241: # If the environment was found in the
environments.yaml file, we can also
On 2014/12/16 17:36:37, bac wrote:
> This comment seems wrong since we could've come through the second
path, meaning
> it was not in environments.yaml.

But this point is never reached in that case: the second path (outer
except block) always returns and exits the function.

https://codereview.appspot.com/188300043/

[Francesco Banconi (frankban)]

*** Submitted:

Promote jenv files as first class envs.

Quickstart no longer refuses to use an environment
which is only present as a jenv file.

Add some more helper functions to the

Also retrieve the environment type, in the case
the environment is already bootstrapped, from
the WebSocket connection and not from the jenv:
jenv files are not assumed to include the type.

Tests: `make check`.

QA:
- use quickstart to bootstrap an environment:
   `.venv/bin/python juju-quickstart`;

- re-run quickstart again to reopen the same environment:
   `.venv/bin/python juju-quickstart`;

- in both cases, check auto-login works and the output
   is sane;

- generate a new environment user and put the
   resulting jenv in your Juju home:
   `juju user add myuser --generate -o ~/.juju/environments/myenv.jenv`;

- use quickstart with the new environment:
   `.venv/bin/python juju-quickstart -e myenv`;

- check that the new credentials are printed to stdout
   and that the auto-login still works;

- destroy the environment.

Thanks a lot!

R=bac, rharding
CC=
https://codereview.appspot.com/188300043

https://codereview.appspot.com/188300043/

=== modified file 'quickstart/app.py'
--- quickstart/app.py	2014-12-16 11:10:10 +0000
+++ quickstart/app.py	2014-12-16 16:32:00 +0000
@@ -278,21 +278,6 @@
     raise ProgramExit('the state server is not ready:\n{}'.format(details))
 
 
-def get_env_type(env_name):
-    """Return the Juju environment type for the given environment name.
-
-    Since the environment type is retrieved by parsing the jenv file, the
-    environment must be already bootstrapped.
-
-    Raise a ProgramExit if the environment type cannot be retrieved.
-    """
-    try:
-        return jenv.get_value(env_name, 'bootstrap-config', 'type')
-    except ValueError as err:
-        msg = b'cannot retrieve environment type: {}'.format(err)
-        raise ProgramExit(msg)
-
-
 def get_credentials(env_name):
     """Return the Juju credentials for the given environment name.
 
@@ -353,6 +338,19 @@
     return env
 
 
+def get_env_type(env):
+    """Return the Juju environment type for the given environment connection.
+
+    Raise a ProgramExit if the environment type cannot be retrieved.
+    """
+    try:
+        info = env.info()
+    except jujuclient.EnvError as err:
+        msg = 'cannot retrieve the environment type: {}'.format(err.message)
+        raise ProgramExit(msg)
+    return info['ProviderType']
+
+
 def create_auth_token(env):
     """Return a new authentication token.
 
 
=== modified file 'quickstart/manage.py'
--- quickstart/manage.py	2014-12-15 17:31:23 +0000
+++ quickstart/manage.py	2014-12-16 16:32:00 +0000
@@ -42,6 +42,7 @@
 from quickstart.models import (
     charms,
     envs,
+    jenv,
 )
 
 
@@ -222,16 +223,23 @@
     return env_data
 
 
-def _retrieve_env_data(parser, env_type_db, env_db, env_name):
+def _retrieve_env_data(parser, env_type_db, env_db, jenv_db, env_name):
     """Retrieve and return the env_data corresponding to the given env_name.
 
     Invoke a parser error if the environment does not exist or is not valid.
     """
     try:
         env_data = envs.get_env_data(env_db, env_name)
-    except ValueError as err:
-        # The specified environment does not exist.
-        return parser.error(bytes(err))
+    except ValueError:
+        # The specified environment does not exist in the environments file.
+        # Check if this is an imported environment.
+        try:
+            return envs.get_env_data(jenv_db, env_name)
+        except ValueError as err:
+            # The environment cannot be found anywhere, exit with an error.
+            return parser.error(bytes(err))
+    # If the environment was found in the environments.yaml file, we can also
+    # validate it.
     env_metadata = envs.get_env_metadata(env_type_db, env_data)
     errors = envs.validate(env_metadata, env_data)
     if errors:
@@ -275,6 +283,7 @@
 
     # Retrieve the environment database (or create an in-memory empty one).
     env_db = _retrieve_env_db(parser, env_file if env_file_exists else None)
+    jenv_db = jenv.get_env_db()
 
     # Validate the environment.
     env_type_db = envs.get_env_type_db()
@@ -285,7 +294,8 @@
     else:
         # This is a non-interactive session and we need to validate the
         # selected environment before proceeding.
-        env_data = _retrieve_env_data(parser, env_type_db, env_db, env_name)
+        env_data = _retrieve_env_data(
+            parser, env_type_db, env_db, jenv_db, env_name)
     # Check for local support, if requested.
     options.env_type = env_data['type']
     no_local_support = not platform_support.supports_local(options.platform)
@@ -510,8 +520,7 @@
     env_type = options.env_type
     api_url = app.check_bootstrapped(options.env_name)
     if api_url is None:
-        print('bootstrapping the {} environment (type: {})'.format(
-            options.env_name, env_type))
+        print('bootstrapping the {} environment'.format(options.env_name))
         if env_type == 'local':
             # If this is a local environment, notify the user that "sudo" will
             # be required by Juju to bootstrap the environment.
@@ -524,11 +533,8 @@
             upload_series=options.upload_series,
             constraints=options.constraints)
     if already_bootstrapped:
-        # Retrieve the environment type from the jenv file: it may be different
-        # from the one declared on the environments.yaml file.
-        env_type = app.get_env_type(options.env_name)
-        print('reusing the already bootstrapped {} environment '
-              '(type: {})'.format(options.env_name, env_type))
+        print('reusing the already bootstrapped {} environment'.format(
+            options.env_name))
 
     # Retrieve the environment status, ensure it is in a ready state and
     # contextually fetch the bootstrap node series.
@@ -548,6 +554,14 @@
     print('connecting to {}'.format(api_url))
     env = app.connect(api_url, username, password)
 
+    if already_bootstrapped:
+        # Retrieve the environment type from the live environment: it may be
+        # different from the one declared on the environments.yaml file.
+        # Moreover, an imported jenv file could be in use, in which case the
+        # environment type is probably still unknown.
+        env_type = app.get_env_type(env)
+    print('environment type: {}'.format(env_type))
+
     # Inspect the environment and deploy the charm if required.
     charm_url, machine, service_data, unit_data = app.check_environment(
         env, settings.JUJU_GUI_SERVICE_NAME, options.charm_url,
 
=== modified file 'quickstart/models/jenv.py'
--- quickstart/models/jenv.py	2014-12-16 11:10:10 +0000
+++ quickstart/models/jenv.py	2014-12-16 16:32:00 +0000
@@ -33,6 +33,8 @@
 
 # Define the default Juju user when an environment is initially bootstrapped.
 JUJU_DEFAULT_USER = 'admin'
+# Define an env type to use when the real type is not included in the jenv.
+UNKNOWN_ENV_TYPE = '__unknown__'
 
 
 def exists(env_name):
@@ -78,7 +80,20 @@
     """
     jenv_path = _get_jenv_path(env_name)
     data = serializers.yaml_load_from_path(jenv_path)
-
+    try:
+        return _get_credentials(data)
+    except ValueError as err:
+        msg = b'cannot parse {}: {}'.format(jenv_path.encode('utf-8'), err)
+        raise ValueError(msg)
+
+
+def _get_credentials(data):
+    """Return the Juju environment credentials from the YAML decoded data.
+
+    Raise a ValueError if the credentials cannot be found.
+    See get_credentials for further information on how the credentials are
+    retrieved.
+    """
     # Retrieve the user name.
     try:
         username = _get_value_from_yaml(data, 'user')
@@ -86,9 +101,8 @@
         # This is probably an old version of Juju not supporting multiple
         # users. Return the default user name.
         logging.warn(
-            'cannot retrieve the user name from {}: {}: '
-            'falling back to the default user name' .format(
-                jenv_path, bytes(err).decode('utf-8')))
+            b'cannot retrieve the user name: {}: '
+            b'falling back to the default user name'.format(err))
         username = JUJU_DEFAULT_USER
 
     # Retrieve the password.
@@ -97,9 +111,8 @@
     except ValueError as err:
         # This is probably an old version of Juju not supporting multiple
         # users. Fall back to the admin secret.
-        msg = b'cannot retrieve the password from {}: '.format(
-            jenv_path.encode('utf-8'))
-        logging.debug(msg + bytes(err))
+        msg = b'cannot retrieve the password: '
+        logging.debug(msg + bytes(err) + ': trying with the admin-secret')
         try:
             password = _get_value_from_yaml(
                 data, 'bootstrap-config', 'admin-secret')
@@ -109,6 +122,71 @@
     return username, password
 
 
+def get_env_db():
+    """Return an environment database parsing the existing jenv files.
+
+    The returned db is similar to what is returned by models.envs.load().
+
+    When a jenv file is created using "juju user add", the resulting YAML data
+    is very concise, not even including the environment type.
+    For this reason, the environment database returned by this function does
+    not contain the usual fields used as bootstrap options, but just the
+    environment name and the type. If the environment type is not included in
+    the jenv, UNKNOWN_ENV_TYPE is used.
+    """
+    db = {'environments': {}}
+    path = os.path.expanduser(os.path.join(settings.JUJU_HOME, 'environments'))
+    # Check if the Juju home is already configured.
+    if not os.path.isdir(path):
+        logging.debug('environments directory not found in the Juju home')
+        return db
+    # Collect the environments.
+    environments = db['environments']
+    for filename in os.listdir(path):
+        fullpath = os.path.join(path, filename)
+        # Check that the current file is a jenv file.
+        if not os.path.isfile(fullpath):
+            continue
+        name, ext = os.path.splitext(filename)
+        if ext != '.jenv':
+            continue
+        # Validate the jenv contents.
+        try:
+            data = serializers.yaml_load_from_path(fullpath)
+            validate(data)
+        except ValueError as err:
+            logging.warn('ignoring invalid jenv file {}: {}'. format(
+                filename, bytes(err).decode('utf-8')))
+            continue
+        # Try to retrieve the environment type from the jenv data.
+        try:
+            env_type = _get_value_from_yaml(data, 'bootstrap-config', 'type')
+        except ValueError:
+            # This is expected when a jenv is generated with "juju user add".
+            env_type = UNKNOWN_ENV_TYPE
+        environments[name] = {'type': env_type}
+    return db
+
+
+def validate(data):
+    """Validate the given YAML decoded jenv data.
+
+    This is a weak validation: from the quickstart point of view a jenv file is
+    valid if it includes the juju environment credentials and the API servers.
+
+    Raise a ValueError if:
+        - the environment file is not found;
+        - the environment file contents are not parsable by YAML;
+        - the environment data is not valid.
+    """
+    _get_credentials(data)
+    servers = data.get('state-servers')
+    if not isinstance(servers, (list, tuple)):
+        raise ValueError(b'invalid state-servers field')
+    if not len(servers):
+        raise ValueError(b'no state-servers found')
+
+
 def _get_value_from_yaml(data, *args):
     """Read and return a value from the given YAML decoded data.
 
 
=== modified file 'quickstart/tests/helpers.py'
--- quickstart/tests/helpers.py	2014-11-12 12:21:09 +0000
+++ quickstart/tests/helpers.py	2014-12-16 16:32:00 +0000
@@ -142,6 +142,7 @@
 
     jenv_data = {
         'user': 'admin',
+        'password': 'Secret!',
         'state-servers': ['localhost:17070', '10.0.3.1:17070'],
         'bootstrap-config': {
             'admin-secret': 'Secret!',
@@ -151,6 +152,24 @@
         'life': {'universe': {'everything': 42}},
     }
 
+    def _make_playground(self):
+        """Create and return a mock Juju home."""
+        playground = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, playground)
+        os.mkdir(os.path.join(playground, 'environments'))
+        return playground
+
+    def write_jenv(self, juju_home, name, contents):
+        """Create a jenv file in the given Juju home.
+
+        Use the given name and YAML encoded contents to create the jenv.
+        Return the resulting jenv path.
+        """
+        path = os.path.join(juju_home, 'environments', '{}.jenv'.format(name))
+        with open(path, 'w') as jenv_file:
+            jenv_file.write(contents)
+        return path
+
     @contextmanager
     def make_jenv(self, env_name, contents):
         """Create a temporary jenv file with the given env_name and contents.
@@ -160,19 +179,30 @@
 
         Return the jenv file path.
         """
-        # Create a temporary JUJU_HOME.
-        playground = tempfile.mkdtemp()
-        self.addCleanup(shutil.rmtree, playground)
-        environments_dir = os.path.join(playground, 'environments')
-        os.mkdir(environments_dir)
-        # Create the jenv file inside the temporary JUJU_HOME.
-        jenv_path = os.path.join(environments_dir, '{}.jenv'.format(env_name))
-        with open(jenv_path, 'w') as jenv_file:
-            jenv_file.write(contents)
+        playground = self._make_playground()
+        jenv_path = self.write_jenv(playground, env_name, contents)
         # Patch the JUJU_HOME and return the jenv file path.
         with mock.patch('quickstart.settings.JUJU_HOME', playground):
             yield jenv_path
 
+    @contextmanager
+    def make_multiple_jenvs(self, data):
+        """Create multiple temporary jenv files with the data.
+
+        Data is a dict mapping env names to jenv contents.
+
+        In the context manager block, the JUJU_HOME is set to the ancestor
+        of the generated temporary files.
+
+        Return the Juju home path.
+        """
+        playground = self._make_playground()
+        for name, contents in data.items():
+            self.write_jenv(playground, name, contents)
+        # Patch the JUJU_HOME and return the jenv file path.
+        with mock.patch('quickstart.settings.JUJU_HOME', playground):
+            yield playground
+
 
 def make_env_db(default=None, exclude_invalid=False):
     """Create and return an env_db.
@@ -229,6 +259,16 @@
     return env_db
 
 
+def make_jenv_db():
+    """Create and return a jenv files database."""
+    environments = {
+        'ec2-west': {'type': '__unknown__'},
+        'lxc': {'type': 'local'},
+        'test-jenv': {'type': '__unknown__'},
+    }
+    return {'environments': environments}
+
+
 # Mock the builtin print function.
 mock_print = mock.patch('__builtin__.print')
 
 
=== modified file 'quickstart/tests/models/test_jenv.py'
--- quickstart/tests/models/test_jenv.py	2014-12-16 11:10:10 +0000
+++ quickstart/tests/models/test_jenv.py	2014-12-16 16:32:00 +0000
@@ -18,8 +18,10 @@
 
 from __future__ import unicode_literals
 
+import os
 import unittest
 
+import mock
 import yaml
 
 from quickstart.models import jenv
@@ -126,12 +128,12 @@
         # The default user name is returned if it's not possible to retrieve it
         # otherwise.
         data = {'password': 'Secret!'}
-        with self.make_jenv('local', yaml.safe_dump(data)) as path:
+        with self.make_jenv('local', yaml.safe_dump(data)):
             expected_logs = [
-                'cannot retrieve the user name from {}: '
+                'cannot retrieve the user name: '
                 'invalid YAML contents: '
                 'user key not found in the root section: '
-                'falling back to the default user name'.format(path)]
+                'falling back to the default user name']
             with helpers.assert_logs(expected_logs, 'warn'):
                 username, password = jenv.get_credentials('local')
         self.assertEqual('admin', username)
@@ -144,11 +146,12 @@
             'user': 'who',
             'bootstrap-config': {'admin-secret': 'Admin!'},
         }
-        with self.make_jenv('local', yaml.safe_dump(data)) as path:
+        with self.make_jenv('local', yaml.safe_dump(data)):
             expected_logs = [
-                'cannot retrieve the password from {}: '
+                'cannot retrieve the password: '
                 'invalid YAML contents: '
-                'password key not found in the root section'.format(path)]
+                'password key not found in the root section: '
+                'trying with the admin-secret']
             with helpers.assert_logs(expected_logs, 'debug'):
                 username, password = jenv.get_credentials('local')
         self.assertEqual('Admin!', password)
@@ -157,8 +160,139 @@
         # A ValueError is raised if the password cannot be found anywhere.
         with self.make_jenv('local', yaml.safe_dump({})) as path:
             expected_error = (
-                'cannot retrieve the password from {}: '
+                'cannot parse {}: '
+                'cannot retrieve the password: '
                 'invalid YAML contents: bootstrap-config key '
                 'not found in the root section'.format(path))
             with self.assert_value_error(expected_error):
                 jenv.get_credentials('local')
+
+
+class TestGetEnvDb(helpers.JenvFileTestsMixin, unittest.TestCase):
+
+    def test_no_juju_home(self):
+        # An empty db is returned if the Juju home is not set up.
+        with mock.patch('quickstart.settings.JUJU_HOME', '/no/such/dir'):
+            jenv_db = jenv.get_env_db()
+        self.assertEqual({'environments': {}}, jenv_db)
+
+    def test_no_jenv_files(self):
+        # An empty db is returned if there are no jenv files.
+        with self.make_multiple_jenvs({}):
+            jenv_db = jenv.get_env_db()
+        self.assertEqual({'environments': {}}, jenv_db)
+
+    def test_no_valid_jenv_files(self):
+        # An empty db is returned if there are no valid jenv files.
+        with self.make_jenv('local', yaml.safe_dump({})):
+            expected_logs = [
+                'ignoring invalid jenv file local.jenv: '
+                'cannot retrieve the password: invalid YAML contents: '
+                'bootstrap-config key not found in the root section']
+            with helpers.assert_logs(expected_logs, 'warn'):
+                jenv_db = jenv.get_env_db()
+        self.assertEqual({'environments': {}}, jenv_db)
+
+    def test_single_valid_jenv(self):
+        # Only the valid environments are returned.
+        with self.make_multiple_jenvs({
+            'local': yaml.safe_dump({}),
+            'ec2': yaml.safe_dump(self.jenv_data),
+        }):
+            jenv_db = jenv.get_env_db()
+        self.assertEqual({
+            'environments': {'ec2': {'type': 'ec2'}},
+        }, jenv_db)
+
+    def test_multiple_jenv_files(self):
+        # Multiple environments are correctly returned.
+        jenv_data1 = {
+            'user': 'admin',
+            'password': 'Secret!',
+            'state-servers': ['localhost:17070'],
+            'bootstrap-config': {'type': 'hp'},
+        }
+        jenv_data2 = {
+            'user': 'admin',
+            'password': 'Secret!',
+            'state-servers': ['localhost:17070'],
+            'bootstrap-config': {'type': 'maas'},
+        }
+        with self.make_multiple_jenvs({
+            'hp': yaml.safe_dump(jenv_data1),
+            'maas': yaml.safe_dump(jenv_data2),
+        }):
+            jenv_db = jenv.get_env_db()
+        self.assertEqual({
+            'environments': {
+                'hp': {'type': 'hp'},
+                'maas': {'type': 'maas'},
+            },
+        }, jenv_db)
+
+    def test_unknown_env_type(self):
+        # If the jenv file does not include the env type, jenv.UNKNOWN_ENV_TYPE
+        # is used as the environment type.
+        jenv_data = {
+            'user': 'admin',
+            'password': 'Secret!',
+            'state-servers': ['localhost:17070'],
+        }
+        with self.make_jenv('local', yaml.safe_dump(jenv_data)):
+            jenv_db = jenv.get_env_db()
+        self.assertEqual({
+            'environments': {'local': {'type': jenv.UNKNOWN_ENV_TYPE}},
+        }, jenv_db)
+
+    def test_extraneous_files(self):
+        # Extraneous files are ignored.
+        with self.make_multiple_jenvs({}) as juju_home:
+            envs_dir = os.path.join(juju_home, 'environments')
+            os.mkdir(os.path.join(envs_dir, 'local.jenv'))
+            with open(os.path.join(envs_dir, 'not-a-jenv'), 'w') as stream:
+                stream.write('bad wolf')
+            jenv_db = jenv.get_env_db()
+        self.assertEqual({'environments': {}}, jenv_db)
+
+
+class TestValidate(
+        helpers.JenvFileTestsMixin, helpers.ValueErrorTestsMixin,
+        unittest.TestCase):
+
+    def test_validation_success(self):
+        # A valid jenv file is successfully validated.
+        jenv.validate(self.jenv_data)
+
+    def test_invalid_credentials(self):
+        # A ValueError is raised if the credentials cannot be retrieved.
+        expected_error = (
+            'cannot retrieve the password: invalid YAML contents: '
+            'bootstrap-config key not found in the root section')
+        with self.assert_value_error(expected_error):
+            jenv.validate({})
+
+    def test_missing_state_servers(self):
+        # A ValueError is raised if the Juju state servers cannot be retrieved.
+        with self.assert_value_error('invalid state-servers field'):
+            jenv.validate({
+                'user': 'admin',
+                'password': 'Secret!',
+            })
+
+    def test_invalid_state_servers(self):
+        # A ValueError is raised if the Juju servers have an invalid type.
+        with self.assert_value_error('invalid state-servers field'):
+            jenv.validate({
+                'user': 'admin',
+                'password': 'Secret!',
+                'state-servers': 'NO!',
+            })
+
+    def test_no_state_servers(self):
+        # A ValueError is raised if the state server list is empty.
+        with self.assert_value_error('no state-servers found'):
+            jenv.validate({
+                'user': 'admin',
+                'password': 'Secret!',
+                'state-servers': [],
+            })
 
=== modified file 'quickstart/tests/test_app.py'
--- quickstart/tests/test_app.py	2014-12-16 11:10:10 +0000
+++ quickstart/tests/test_app.py	2014-12-16 16:32:00 +0000
@@ -700,26 +700,6 @@
         mock_call.assert_has_calls(expected_calls)
 
 
-class TestGetEnvType(
-        helpers.JenvFileTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
-
-    def test_success(self):
-        # The environment type is successfully retrieved.
-        with self.make_jenv('ec2', yaml.safe_dump(self.jenv_data)):
-            env_type = app.get_env_type('ec2')
-        self.assertEqual('ec2', env_type)
-
-    def test_error(self):
-        # A ProgramExit is raised if the environment type cannot be retrieved.
-        with self.make_jenv('aws', '') as path:
-            expected_error = (
-                'cannot retrieve environment type: cannot read {}: invalid '
-                'YAML contents: bootstrap-config key not found in the root '
-                'section'.format(path))
-            with self.assert_program_exit(expected_error):
-                app.get_env_type('aws')
-
-
 class TestGetCredentials(
         helpers.JenvFileTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
 
@@ -734,9 +714,10 @@
         # A ProgramExit is raised if the credentials cannot be retrieved.
         with self.make_jenv('ec2', '') as path:
             expected_error = (
-                'cannot retrieve environment credentials: cannot retrieve the '
-                'password from {}: invalid YAML contents: bootstrap-config '
-                'key not found in the root section'.format(path))
+                'cannot retrieve environment credentials: cannot parse {}: '
+                'cannot retrieve the password: invalid YAML contents: '
+                'bootstrap-config key not found in the root section'
+                ''.format(path))
             with self.assert_program_exit(expected_error):
                 app.get_credentials('ec2')
 
@@ -842,6 +823,24 @@
         self.assertIs(error, context_manager.exception)
 
 
+class TestGetEnvType(ProgramExitTestsMixin, unittest.TestCase):
+
+    def test_success(self):
+        # The environment type is successfully retrieved.
+        env = mock.Mock()
+        env.info.return_value = {'ProviderType': 'ec2'}
+        env_type = app.get_env_type(env)
+        self.assertEqual('ec2', env_type)
+
+    def test_error(self):
+        # A ProgramExit is raised if the environment type cannot be retrieved.
+        env = mock.Mock()
+        env.info.side_effect = self.make_env_error('bad wolf')
+        expected_error = 'cannot retrieve the environment type: bad wolf'
+        with self.assert_program_exit(expected_error):
+            app.get_env_type(env)
+
+
 class TestCreateAuthToken(unittest.TestCase):
 
     def test_success(self):
 
=== modified file 'quickstart/tests/test_juju.py'
--- quickstart/tests/test_juju.py	2014-12-16 11:10:10 +0000
+++ quickstart/tests/test_juju.py	2014-12-16 16:32:00 +0000
@@ -277,6 +277,15 @@
         mock_rpc.assert_called_once_with(expected)
 
     @patch_rpc
+    def test_info(self, mock_rpc):
+        # The EnvironmentInfo API call is properly generated.
+        self.env.info()
+        mock_rpc.assert_called_once_with({
+            'Type': 'Client',
+            'Request': 'EnvironmentInfo',
+        })
+
+    @patch_rpc
     def test_create_auth_token(self, mock_rpc):
         self.env.create_auth_token()
         expected = dict(Type='GUIToken', Request='Create')
 
=== modified file 'quickstart/tests/test_manage.py'
--- quickstart/tests/test_manage.py	2014-12-15 17:31:23 +0000
+++ quickstart/tests/test_manage.py	2014-12-16 16:32:00 +0000
@@ -428,26 +428,37 @@
         self.parser = mock.Mock()
         self.env_type_db = envs.get_env_type_db()
         self.env_db = helpers.make_env_db()
+        self.jenv_db = helpers.make_jenv_db()
 
     def test_resulting_env_data(self):
         # The env_data is correctly validated and returned.
         expected_env_data = envs.get_env_data(self.env_db, 'lxc')
         env_data = manage._retrieve_env_data(
-            self.parser, self.env_type_db, self.env_db, 'lxc')
+            self.parser, self.env_type_db, self.env_db, self.jenv_db, 'lxc')
+        self.assertEqual(expected_env_data, env_data)
+
+    def test_jenv_data(self):
+        # The env_data is correctly retrieved from the jenv database.
+        expected_env_data = envs.get_env_data(self.jenv_db, 'test-jenv')
+        env_data = manage._retrieve_env_data(
+            self.parser, self.env_type_db, self.env_db, self.jenv_db,
+            'test-jenv')
         self.assertEqual(expected_env_data, env_data)
 
     def test_error_environment_not_found(self):
         # A parser error is invoked if the provided environment is not included
         # in the environments database.
         manage._retrieve_env_data(
-            self.parser, self.env_type_db, self.env_db, 'no-such')
+            self.parser, self.env_type_db, self.env_db, self.jenv_db,
+            'no-such')
         self.parser.error.assert_called_once_with(
             'environment no-such not found')
 
     def test_error_environment_not_valid(self):
         # A parser error is invoked if the selected environment is not valid.
         manage._retrieve_env_data(
-            self.parser, self.env_type_db, self.env_db, 'local-with-errors')
+            self.parser, self.env_type_db, self.env_db, self.jenv_db,
+            'local-with-errors')
         self.parser.error.assert_called_once_with(
             'cannot use the local-with-errors environment:\n'
             'the storage port field requires an integer value')
@@ -860,13 +871,14 @@
 
     def test_already_bootstrapped(self, mock_app, mock_open):
         # The application correctly reuses an already bootstrapped environment.
-        self.configure_app(mock_app, check_bootstrapped='wss://example.com')
+        env = self.configure_app(
+            mock_app, check_bootstrapped='wss://example.com')
         # Run the application.
         options = self.make_options()
         with self.patch_get_juju_command():
             manage.run(options)
         # The environment type is retrieved from the jenv.
-        mock_app.get_env_type.assert_called_once_with(options.env_name)
+        mock_app.get_env_type.assert_called_once_with(env)
         # No reason to call bootstrap or get_api_url functions.
         self.assertFalse(mock_app.bootstrap.called)
         self.assertFalse(mock_app.get_api_url.called)
@@ -875,7 +887,7 @@
         # The application correctly reuses an already bootstrapped environment.
         # In this case, the environment seems not bootstrapped at first, but
         # it ended up being up and running later.
-        self.configure_app(mock_app, bootstrap=True)
+        env = self.configure_app(mock_app, bootstrap=True)
         # Run the application.
         options = self.make_options()
         with self.patch_get_juju_command():
@@ -891,7 +903,7 @@
             constraints=options.constraints)
         mock_app.get_api_url.assert_called_once_with(
             options.env_name, self.juju_command)
-        mock_app.get_env_type.assert_called_once_with(options.env_name)
+        mock_app.get_env_type.assert_called_once_with(env)
 
     def test_no_token(self, mock_app, mock_open):
         # The process continues even if the authentication token cannot be