Merge lp:~makyo/juju-quickstart/env-manage-edit into lp:juju-quickstart

[Madison Scott-Clary]

Editable env. management

Check: make check

QA: -todo-

https://codereview.appspot.com/45390044/

Unmerged revisions

51. By Madison Scott-Clary on 2013-12-24

Lint for wip checkpoint

50. By Madison Scott-Clary on 2013-12-24

Checkpoint

=== added file 'quickstart/cli/forms.py'
--- quickstart/cli/forms.py	1970-01-01 00:00:00 +0000
+++ quickstart/cli/forms.py	2013-12-24 19:19:29 +0000
@@ -0,0 +1,199 @@
+# This file is part of the Juju Quickstart Plugin, which lets users set up a
+# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
+# Copyright (C) 2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Juju Quickstart CLI forms management.
+
+This module contains a collection of functions which help creating and
+manipulating forms in Urwid.
+"""
+
+from __future__ import unicode_literals
+
+import functools
+
+import urwid
+
+from quickstart.cli import ui
+
+
+# Define the value used in boolean widget to specify they allow mixed state.
+MIXED = 'mixed'
+
+
+def _generate(generate_callable, edit_widget):
+    """Update the widget contents using generate_callable.
+
+    The given callable function takes no arguments and returns a string.
+    """
+    edit_widget.set_edit_text(generate_callable())
+
+
+def create_string_widget(field, value, error):
+    """Create a string widget and return a tuple (widget, value_getter).
+
+    Receives a Field instance (see quickstart.models.fields), the field value,
+    and an error string (or None if the field has no errors).
+
+    In the tuple, widget is a Urwid widget suitable for editing string values,
+    and value_getter is a callable returning the value currently stored in the
+    widget. The value_getter callable must be called without arguments.
+    """
+    if value is None:
+        # Unset values are converted to empty strings.
+        value = ''
+    elif not isinstance(value, unicode):
+        # We do not expect byte strings, and all other values are converted to
+        # unicode strings.
+        value = unicode(value)
+    caption_class = 'highlight' if field.required else 'optional'
+    caption = []
+    widgets = []
+    if error:
+        caption.append(('error', '\N{BULLET} '))
+        # Display the error message above the edit widget.
+        widgets.append(urwid.Text(('error', error)))
+    caption.append((caption_class, '{}: '.format(field.label)))
+    edit_widget = urwid.Edit(edit_text=value)
+    widget = urwid.Columns([('pack', urwid.Text(caption)), edit_widget])
+    if field.readonly:
+        widgets.append(urwid.WidgetDisable(widget))
+    else:
+        widgets.append(urwid.AttrMap(widget, 'edit'))
+    if field.help:
+        # Display the field help message below the edit widget.
+        widgets.append(urwid.Text(field.help))
+    if not field.readonly:
+        # Can the value be automatically generated?
+        generate_method = getattr(field, 'generate', None)
+        if generate_method is not None:
+            generate_callable = ui.thunk(
+                _generate, generate_method, edit_widget)
+            generate_button = ui.MenuButton(
+                ('highlight', 'automatically generate'), generate_callable)
+            generate_columns = urwid.Columns([
+                ('pack', urwid.Text('it is possible to ')),
+                ('pack', generate_button),
+                urwid.Text(' this value'),
+            ])
+            widgets.append(generate_columns)
+    # If the value must be in a range of choices, display the possible choices
+    # as part of the help message.
+    choices = getattr(field, 'choices', None)
+    if choices is not None:
+        # TODO: the choices are clickable and update the edit widget.
+        text = 'possible values are {}'.format(', '.join(choices))
+        if not field.required:
+            text = '{}, but this field can also be left empty'.format(text)
+        widgets.append(urwid.Text(text))
+    if field.default is not None:
+        widgets.append(
+            urwid.Text('default if not set: {}'.format(field.default)))
+    widgets.append(urwid.Divider())
+    return urwid.Pile(widgets), edit_widget.get_edit_text
+
+
+def create_bool_widget(field, value, error):
+    """Create a boolean widget and return a tuple (widget, value_getter).
+
+    Receives a Field instance (see quickstart.models.fields), the field value,
+    and an error string (or None if the field has no errors).
+
+    In the tuple, widget is a Urwid widget suitable for editing boolean values
+    (a checkbox), and value_getter is a callable returning the value currently
+    stored in the widget. The value_getter callable receives no arguments.
+    """
+    if value is None:
+        # Unset values are converted to a more convenient value for the
+        # checkbox (a boolean or a mixed state if allowed by the field).
+        value = MIXED if field.allow_mixed else bool(field.default)
+    label = ('highlight', field.label)
+    widget = urwid.CheckBox(label, state=value, has_mixed=field.allow_mixed)
+    widgets = []
+    if error:
+        # Display the error message above the checkbox.
+        widgets.append(urwid.Text(('error', error)))
+    widgets.append(widget)
+    if field.help:
+        # Display the field help message below the checkbox.
+        widgets.append(urwid.Text(field.help))
+    widgets.append(urwid.Divider())
+
+    def get_state():
+        # Reconvert mixed value to None value.
+        state = widget.get_state()
+        return None if state == MIXED else state
+
+    return urwid.Pile(widgets), get_state
+
+
+def create_form(field_value_pairs, errors):
+    """Create and return the form widgets for each field/value pair.
+
+    Return a tuple (widgets, values_getter) in which:
+        - widgets is a list if Urwid objects that can be used to build view
+          contents (e.g. by wrapping them in a urwid.ListBox);
+        - data_getter is a function returning a dictionary mapping field names
+          to values. Using the data_getter function it is always possible to
+          retrieve the actual new field values as changed by the user.
+
+    The field_value_pairs argument is a list of (field, value) tuples where
+    field is a Field instance (see quickstart.models.fields) and value is
+    the corresponding field value.
+
+    The errors argument is a dictionary mapping field names to error messages.
+    Passing an empty dictionary means the form has no errors.
+    """
+    form = {}
+    widgets = []
+    if errors:
+        # Inform the user that the form has errors that need to be fixed.
+        widgets.extend([
+            urwid.Text(('error', 'please correct the errors below')),
+            urwid.Divider(),
+        ])
+    # Build a widget and populate the form for each field/value pair.
+    for field, value in field_value_pairs:
+        error = errors.get(field.name)
+        if field.field_type == 'bool':
+            # Boolean values as represented as a checkbox.
+            widget, value_getter = create_bool_widget(field, value, error)
+        else:
+            # All the other field types are displayed as strings.
+            widget, value_getter = create_string_widget(field, value, error)
+        widgets.append(widget)
+        form[field.name] = value_getter
+    return widgets, functools.partial(_get_data, form)
+
+
+def _get_data(form):
+    """Return a dictionary mapping the given form field names to values.
+
+    This is done just calling all the value getters in the form.
+    """
+    return dict((key, value_getter()) for key, value_getter in form.items())
+
+
+def create_actions(actions):
+    """Return the control widgets based on the given actions.
+
+    The actions arguments is as a sequence of (caption, callback) tuples. Those
+    pairs are used to generate the clickable controls (MenuButton instances)
+    used to manipulate the form.
+    """
+    controls = [
+        ui.MenuButton(caption, callback) for caption, callback in actions
+    ]
+    return ui.create_controls(*controls)

=== modified file 'quickstart/cli/ui.py'
--- quickstart/cli/ui.py	2013-12-20 10:30:37 +0000
+++ quickstart/cli/ui.py	2013-12-24 19:19:29 +0000
@@ -45,6 +45,8 @@
     ('highlight', 'white', 'black'),
     ('line header', 'dark gray', 'dark magenta'),
     ('line footer', 'light gray', 'light gray'),
+    ('optional', 'light magenta', 'black'),
+    ('optional status', 'light magenta', 'light gray'),
     ('selected', 'white', 'dark blue'),
 ]
 # Map attributes to new attributes to apply when the widget is selected.
@@ -52,6 +54,7 @@
     None: 'selected',
     'control alert': 'error selected',
     'error': 'error selected',
+    'highlight': 'selected',
 }
 # Define a default padding for the Urwid application.
 padding = functools.partial(urwid.Padding, left=2, right=2)

=== modified file 'quickstart/cli/views.py'
--- quickstart/cli/views.py	2013-12-19 17:40:36 +0000
+++ quickstart/cli/views.py	2013-12-24 19:19:29 +0000
@@ -104,6 +104,7 @@
 
 from quickstart.cli import (
     base,
+    forms,
     ui,
 )
 from quickstart.models import envs
@@ -132,6 +133,8 @@
     """Show the Juju environments list.
 
     The env_detail view is displayed when the user clicks on an environment.
+    From here it is also possible to switch to the edit view in order to create
+    a new environment.
 
     Receives:
         - env_type_db: the environments meta information;
@@ -145,6 +148,8 @@
     app.set_return_value_on_exit((env_db, None))
     detail_view = functools.partial(
         env_detail, app, env_type_db, env_db, save_callable)
+    edit_view = functools.partial(
+        env_edit, app, env_type_db, env_db, save_callable)
     # Alphabetically sort the existing environments.
     environments = sorted([
         envs.get_env_data(env_db, env_name)
@@ -153,7 +158,6 @@
     if environments:
         title = 'Select the Juju environment you want to use'
     else:
-        # XXX frankban 2013-12-18: implement the env creation view.
         title = 'No Juju environments already set up: please create one'
     app.set_title(title)
     app.set_status('')
@@ -179,9 +183,13 @@
         text = [bullet, ' {}'.format(env_short_description)]
         widgets.append(ui.MenuButton(text, ui.thunk(detail_view, env_data)))
     widgets.append(urwid.Divider())
-    contents = urwid.ListBox(urwid.SimpleFocusListWalker(widgets))
-    if focus_position is not None:
-        contents.set_focus(focus_position)
+    # Add the buttons used to create new environments.
+    widgets.extend([
+        ui.MenuButton(
+            '\N{BULLET} create new {} environment'.format(env_type),
+            ui.thunk(edit_view, {'type': env_type}))
+        for env_type in envs.get_supported_env_types(env_type_db)
+    ])
     # Set up the application status messages.
     status = []
     if default_found:
@@ -190,6 +198,10 @@
         status.extend([('error status', ' \N{BULLET}'), ' has errors '])
     if status:
         app.set_status(status)
+    # Set up the application contents.
+    contents = urwid.ListBox(urwid.SimpleFocusListWalker(widgets))
+    if focus_position is not None:
+        contents.set_focus(focus_position)
     app.set_contents(contents)
 
 
@@ -212,6 +224,8 @@
     app.set_return_value_on_exit((env_db, None))
     index_view = functools.partial(
         env_index, app, env_type_db, env_db, save_callable)
+    edit_view = functools.partial(
+        env_edit, app, env_type_db, env_db, save_callable, env_data)
 
     def use(env_data):
         # Quit the interactive session returning the (possibly modified)
@@ -231,8 +245,10 @@
     def remove(env_data):
         # The environment deletion is confirmed: remove the environment from
         # the database, save the new env_db and return to the index view.
-        envs.remove_env(env_db, env_data['name'])
+        env_name = env_data['name']
+        envs.remove_env(env_db, env_name)
         save_callable(env_db)
+        app.set_message('{} successfully removed'.format(env_name))
         index_view()
 
     def confirm_removal(env_data):
@@ -272,10 +288,111 @@
         controls.append(
             ui.MenuButton('set default', ui.thunk(set_default, env_data)))
     controls.extend([
-        # XXX frankban 2013-12-18: implement the env modification view.
+        ui.MenuButton('edit', ui.thunk(edit_view)),
         ui.MenuButton(
             ('control alert', 'remove'), ui.thunk(confirm_removal, env_data)),
     ])
     widgets.append(ui.create_controls(*controls))
     listbox = urwid.ListBox(urwid.SimpleFocusListWalker(widgets))
     app.set_contents(listbox)
+
+
+def env_edit(app, env_type_db, env_db, save_callable, env_data):
+    """Create or modify a Juju environment.
+
+    This view displays an edit form allowing for environment
+    creation/modification. Saving the form redirects to the environment detail
+    view if the values are valid.
+
+    Receives:
+        - env_type_db: the environments meta information;
+        - env_db: the environments database;
+        - save_callable: a function called to save a new environment database.
+        - env_data: the environment data.
+
+    The last value (env_data) indicates whether this view is used to create a
+    new environment or to change an existing one. In the former case, env_data
+    only includes the "type" key. If instead the environment already exists,
+    env_data includes the "name" key and all the other environment info.
+    """
+    env_db = copy.deepcopy(env_db)
+    # All the environment views return a tuple (new_env_db, env_data).
+    # Set the env_data to None in the case the user quits the application
+    # without selecting an environment to use.
+    app.set_return_value_on_exit((env_db, None))
+    env_metadata = envs.get_env_metadata(env_type_db, env_data)
+    index_view = functools.partial(
+        env_index, app, env_type_db, env_db, save_callable)
+    detail_view = functools.partial(
+        env_detail, app, env_type_db, env_db, save_callable)
+    if 'name' in env_data:
+        exists = True
+        title = 'Edit the {} environment'
+        # Retrieve all the errors for the existing environment.
+        initial_errors = envs.validate(env_metadata, env_data)
+    else:
+        exists = False
+        title = 'Create a new {} environment'
+        # The environment does not exist: avoid bothering the user with errors
+        # before the form is submitted.
+        initial_errors = {}
+    app.set_title(title.format(env_data['type']))
+    app.set_status([
+        ('optional status', ' \N{LOWER SEVEN EIGHTHS BLOCK}'),
+        ' optional field ',
+        ('error status', ' \N{BULLET}'),
+        ' field errors ',
+    ])
+
+    def save(env_data, get_new_env_data):
+        # Create a new environment or save changes for an existing one.
+        # The new values are saved only if the new env_data is valid, in which
+        # case also redirect to the environment detail view.
+        new_env_data = get_new_env_data()
+        # Validate the new env_data.
+        errors = envs.validate(env_metadata, new_env_data)
+        new_name = new_env_data['name']
+        initial_name = env_data.get('name')
+        if (new_name != initial_name) and new_name in env_db['environments']:
+            errors['name'] = 'an environment with this name already exists'
+        # If errors are found, re-render the form passing the errors. This way
+        # the errors are displayed as part of the form and the user is given
+        # the opportunity to fix the invalid values.
+        if errors:
+            return render_form(new_env_data, errors)
+        # Without errors, normalize the new values, update the env_db and save
+        # the resulting environments database.
+        env_data = envs.normalize(env_metadata, new_env_data)
+        envs.set_env_data(env_db, initial_name, env_data)
+        save_callable(env_db)
+        verb = 'modified' if exists else 'created'
+        app.set_message('{} successfully {}'.format(new_name, verb))
+        return detail_view(env_data)
+
+    def cancel(env_data):
+        # Dismiss any changes and return to the index or detail view.
+        return detail_view(env_data) if exists else index_view()
+
+    def render_form(data, errors):
+        widgets = [
+            urwid.Text(env_metadata['description']),
+            urwid.Divider(),
+        ]
+        field_value_pairs = envs.map_fields_to_env_data(env_metadata, data)
+        # Retrieve the form widgets and the data getter function. The latter
+        # can be used to retrieve the field name/value pairs included in the
+        # displayed form, including user's changes (see quickstart.cli.forms).
+        form_widgets, get_new_env_data = forms.create_form(
+            field_value_pairs, errors)
+        widgets.extend(form_widgets)
+        actions = (
+            ('save', ui.thunk(save, env_data, get_new_env_data)),
+            ('cancel', ui.thunk(cancel, env_data)),
+            ('restore', ui.thunk(render_form, env_data, initial_errors)),
+        )
+        widgets.append(forms.create_actions(actions))
+        contents = urwid.ListBox(urwid.SimpleFocusListWalker(widgets))
+        app.set_contents(contents)
+
+    # Render the initial form.
+    render_form(env_data, initial_errors)

=== modified file 'quickstart/models/envs.py'
--- quickstart/models/envs.py	2013-12-19 16:48:38 +0000
+++ quickstart/models/envs.py	2013-12-24 19:19:29 +0000
@@ -292,7 +292,7 @@
     environments[new_name] = new_env_data
     if is_default:
         env_db['default'] = new_name
-    elif env_db.get('default') == env_name:
+    elif (env_db.get('default') == env_name) and (env_name is not None):
         del env_db['default']
 
 

=== added file 'quickstart/tests/cli/test_forms.py'
--- quickstart/tests/cli/test_forms.py	1970-01-01 00:00:00 +0000
+++ quickstart/tests/cli/test_forms.py	2013-12-24 19:19:29 +0000
@@ -0,0 +1,148 @@
+# This file is part of the Juju Quickstart Plugin, which lets users set up a
+# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
+# Copyright (C) 2013 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Tests for the Juju Quickstart CLI forms management."""
+
+from __future__ import unicode_literals
+
+import unittest
+
+import mock
+import urwid
+
+from quickstart.cli import forms
+from quickstart.models import fields
+
+
+class TestGenerate(unittest.TestCase):
+
+    def test_generation(self):
+        # The text of the given widget is set to the return value of the given
+        # callable.
+        generate_callable = lambda: 'generated'
+        mock_edit_widget = mock.Mock()
+        forms._generate(generate_callable, mock_edit_widget)
+        mock_edit_widget.set_edit_text.assert_called_once_with('generated')
+
+
+class TestCreateStringWidget(unittest.TestCase):
+
+    def inspect_widget(self, widget):
+        """Return a list of sub-widgets composing the given string widget.
+
+        The sub-widgets are:
+            - the wrapper edit widget;
+            - the base edit widget;
+            - the caption text widget;
+            - the help widget;
+            - the error text widget (or None if not present);
+            - the generate text widget (or None if not present);
+            - the choices text widget (or None if not present).
+        """
+        help = error = generate = choices = None
+        # Retrieve the Pile contents ignoring the last Divider widget.
+        contents = list(widget.contents)[:-1]
+        first_widget = contents.pop(0)[0]
+        if isinstance(first_widget, urwid.Text):
+            # This is the error message.
+            error = first_widget
+            wrapper = contents.pop(0)[0]
+        else:
+            # The widget has no errors.
+            wrapper = first_widget
+        caption_attrs, edit_attrs = wrapper.base_widget.contents
+        if contents:
+            help = contents.pop(0)[0]
+        if contents:
+            if isinstance(contents[0][0], urwid.Text):
+                choices = contents.pop(0)[0]
+            else:
+                generate = contents.pop(0)[0]
+        if contents:
+            choices = contents.pop(0)[0]
+        if 'default if not set' in choices.get_text()[0]:
+            choices = None
+        return (
+            wrapper, edit_attrs[0], caption_attrs[0],
+            help, error, generate, choices,
+        )
+
+    def test_widget_structure(self):
+        # The widget includes all the information about a field.
+        field = fields.StringField(
+            'first-name', label='first name', help='your first name',
+            default='Jean')
+        widget, value_getter = forms.create_string_widget(
+            field, 'Luc', 'invalid name')
+        sub_widgets = self.inspect_widget(widget)
+        wrapper, edit, caption, help, error, generate, choices = sub_widgets
+        # Since the field is not read-only, the widget is properly enabled.
+        self.assertNotIsInstance(wrapper, urwid.WidgetDisable)
+        # The edit widget is set to the given value.
+        self.assertEqual('Luc', edit.get_edit_text())
+        # The caption and help are properly set.
+        self.assertEqual('\N{BULLET} first name: ', caption.text)
+        self.assertEqual('your first name', help.text)
+        # The error is displayed.
+        self.assertEqual('invalid name', error.text)
+        # The field is not able to generate a value, and there are no choices.
+        self.assertIsNone(generate)
+        self.assertIsNone(choices)
+
+    def test_empty_value(self):
+        # The widget includes all the information about a field.
+        field = fields.StringField(
+            'first-name', label='first name', help='your first name',
+            default='Jean')
+        widget, value_getter = forms.create_string_widget(
+            field, None, 'empty name')
+        sub_widgets = self.inspect_widget(widget)
+        error = sub_widgets[4]
+        self.assertEqual('empty name', error.text)
+
+    def test_nonunicode_value(self):
+        # The widget includes all the information about a field.
+        field = fields.StringField(
+            'first-name', label='first name', help='your first name',
+            default='Jean')
+        widget, value_getter = forms.create_string_widget(
+            field, 42, 'non-unicode name')
+        edit = self.inspect_widget(widget)[1]
+        self.assertIsInstance(edit.get_edit_text(), unicode)
+
+    def test_readonly(self):
+        # The widget includes all the information about a field.
+        field = fields.StringField(
+            'first-name', label='first name', help='your first name',
+            default='Jean', readonly=True)
+        widget, value_getter = forms.create_string_widget(
+            field, 42, 'disabled')
+        disable = self.inspect_widget(widget)[0]
+        self.assertIsInstance(disable, urwid.WidgetDisable)
+
+    def test_generate_method(self):
+        # The widget includes all the information about a field.
+        field = fields.AutoGeneratedStringField(
+            'first-name', label='first name', help='your first name',
+            default='Jean')
+        widget, value_getter = forms.create_string_widget(
+            field, 42, 'disabled')
+        generate = self.inspect_widget(widget)[5]
+        # Check that an autogenerate button is included.
+        self.assertIsInstance(generate.contents[1][0], urwid.Button)
+
+    def test_choices(self):
+        pass

=== modified file 'quickstart/tests/cli/test_views.py'
--- quickstart/tests/cli/test_views.py	2013-12-20 10:30:37 +0000
+++ quickstart/tests/cli/test_views.py	2013-12-24 19:19:29 +0000
@@ -149,17 +149,28 @@
             'No Juju environments already set up: please create one',
             self.app.get_title())
 
+    def test_view_contents(self):
+        # The view displays a list of the environments in env_db, and buttons
+        # to create new environments.
+        env_db = helpers.make_env_db()
+        views.env_index(self.app, self.env_type_db, env_db, self.save_callable)
+        buttons = self.get_widgets_in_contents(
+            filter_function=self.is_a(ui.MenuButton))
+        # A button is created for each existing environment (see details) and
+        # for each environment type supported by quickstart (create).
+        env_types = envs.get_supported_env_types(self.env_type_db)
+        expected_buttons_number = len(env_db['environments']) + len(env_types)
+        self.assertEqual(expected_buttons_number, len(buttons))
+
     @mock.patch('quickstart.cli.views.env_detail')
-    def test_view_contents(self, mock_env_detail):
-        # The view displays a list of the environments in env_db.
+    def test_environment_clicked(self, mock_env_detail):
+        # The environment detail view is called when clicking an environment.
         env_db = helpers.make_env_db()
         views.env_index(self.app, self.env_type_db, env_db, self.save_callable)
         buttons = self.get_widgets_in_contents(
             filter_function=self.is_a(ui.MenuButton))
         # The environments are listed in alphabetical order.
         environments = sorted(env_db['environments'])
-        # A button is created for each environment.
-        self.assertEqual(len(environments), len(buttons))
         for env_name, button in zip(environments, buttons):
             env_data = envs.get_env_data(env_db, env_name)
             # The caption includes the environment description.
@@ -176,6 +187,30 @@
             # loop cycle.
             mock_env_detail.reset_mock()
 
+    @mock.patch('quickstart.cli.views.env_edit')
+    def test_create_new_environment_clicked(self, mock_env_edit):
+        # The environment edit view is called when clicking to create a new
+        # environment.
+        env_db = helpers.make_env_db()
+        views.env_index(self.app, self.env_type_db, env_db, self.save_callable)
+        buttons = self.get_widgets_in_contents(
+            filter_function=self.is_a(ui.MenuButton))
+        env_types = envs.get_supported_env_types(self.env_type_db)
+        for env_type, button in zip(env_types, buttons[-len(env_types):]):
+            # The caption includes the environment type.
+            expected_caption = 'create new {} environment'.format(env_type)
+            caption = cli_helpers.get_button_caption(button)
+            self.assertIn(expected_caption, caption)
+            # When the button is clicked, the edit view is called passing the
+            # corresponding environment data.
+            cli_helpers.emit(button)
+            mock_env_edit.assert_called_once_with(
+                self.app, self.env_type_db, env_db, self.save_callable,
+                {'type': env_type})
+            # Reset the mock so that it does not include any calls on the next
+            # loop cycle.
+            mock_env_edit.reset_mock()
+
     def test_selected_environment(self):
         # The default environment is already selected in the list.
         env_db = helpers.make_env_db(default='lxc')
@@ -261,28 +296,30 @@
             self.assertEqual(expected_text, widget.text)
 
     def test_view_buttons(self):
-        # The following buttons are displayed: "back", "use", "set default" and
-        # "remove".
+        # The following buttons are displayed: "back", "use", "set default",
+        # "edit" and "remove".
         self.call_view(env_name='ec2-west')
         buttons = self.get_control_buttons()
         captions = map(cli_helpers.get_button_caption, buttons)
-        self.assertEqual(['back', 'use', 'set default', 'remove'], captions)
+        self.assertEqual(
+            ['back', 'use', 'set default', 'edit', 'remove'], captions)
 
     def test_view_buttons_default(self):
         # If the environment is the default one, the "set default" button is
-        # not displayed. The buttons we expect are "back", "use" and "remove".
+        # not displayed. The buttons we expect are "back", "use", "edit" and
+        # "remove".
         self.call_view(env_name='lxc')
         buttons = self.get_control_buttons()
         captions = map(cli_helpers.get_button_caption, buttons)
-        self.assertEqual(['back', 'use', 'remove'], captions)
+        self.assertEqual(['back', 'use', 'edit', 'remove'], captions)
 
     def test_view_buttons_error(self):
         # If the environment is not valid, the "use" button is not displayed.
-        # The buttons we expect are "back", "set default" and "remove".
+        # The buttons we expect are "back", "set default", "edit" and "remove".
         self.call_view(env_name='local-with-errors')
         buttons = self.get_control_buttons()
         captions = map(cli_helpers.get_button_caption, buttons)
-        self.assertEqual(['back', 'set default', 'remove'], captions)
+        self.assertEqual(['back', 'set default', 'edit', 'remove'], captions)
 
     @mock.patch('quickstart.cli.views.env_index')
     def test_back_button(self, mock_env_index):
@@ -323,6 +360,17 @@
         # The new env_db has been saved.
         self.save_callable.assert_called_once_with(new_env_db)
 
+    @mock.patch('quickstart.cli.views.env_edit')
+    def test_edit_button(self, mock_env_edit):
+        # The edit view is called if the "edit" button is clicked.
+        self.call_view(env_name='ec2-west')
+        # The "edit" button is the fourth one.
+        edit_button = self.get_control_buttons()[3]
+        cli_helpers.emit(edit_button)
+        mock_env_edit.assert_called_once_with(
+            self.app, self.env_type_db, self.env_db, self.save_callable,
+            self.env_data)
+
     def test_remove_button(self):
         # A confirmation dialog is displayed if the "remove" button is clicked.
         self.call_view(env_name='ec2-west')

=== modified file 'quickstart/tests/models/test_envs.py'
--- quickstart/tests/models/test_envs.py	2013-12-19 17:00:36 +0000
+++ quickstart/tests/models/test_envs.py	2013-12-24 19:19:29 +0000
@@ -386,6 +386,20 @@
             self.env_db['environments']['new-one'])
         self.assertEqual('new-one', self.env_db['default'])
 
+    def test_new_environment_with_no_default(self):
+        # A new environment is properly added in an env_db with no default.
+        env_data = {
+            'default-series': 'edgy',
+            'is-default': False,
+            'name': 'new-one',
+        }
+        del self.env_db['default']
+        envs.set_env_data(self.env_db, None, env_data)
+        self.assertEqual(
+            {'default-series': 'edgy'},
+            self.env_db['environments']['new-one'])
+        self.assertNotIn('default', self.env_db)
+
     def test_existing_environment_updated(self):
         # An existing environment is properly updated.
         env_data = {