Merge lp:~frankban/juju-quickstart/uncommitted-bundles into lp:juju-quickstart

[Francesco Banconi]

Add support for uncommitted bundles.

Add support for uncommitted bundles.

Introduce the -u/--uncommitted flag, which enables
uncommitted bundle support.

Improve output messages and tokens handling.

Also update jujubundlelib dep to latest version.

TESTS:
`make fcheck` and wait a while for the functional tests
to complete.

QA:
- deploy bundles as usual:
  `devenv/bin/juju-quickstart mediawiki-single`;
- deploy uncommitted bundles:
  `devenv/bin/juju-quickstart -u u/openstack-charmers/openstack`;

https://codereview.appspot.com/247800043/

[Francesco Banconi (frankban)]

Reviewers: mp+261200_code.launchpad.net,

Message:
Please take a look.

Description:
Add support for uncommitted bundles.

Introduce the -u/--uncommitted flag, which enables
uncommitted bundle support.

Improve output messages and tokens handling.

Also update jujubundlelib dep to latest version.

TESTS:
`make fcheck` and wait a while for the functional tests
to complete.

QA:
- deploy bundles as usual:
   `devenv/bin/juju-quickstart mediawiki-single`;
- deploy uncommitted bundles:
   `devenv/bin/juju-quickstart -u u/openstack-charmers/openstack`;

https://code.launchpad.net/~frankban/juju-quickstart/uncommitted-bundles/+merge/261200

(do not edit description out of merge proposal)

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

Affected files (+329, -57 lines):
   A [revision details]
   M quickstart/__init__.py
   M quickstart/app.py
   M quickstart/juju.py
   M quickstart/jujugui.py
   M quickstart/jujutools.py
   M quickstart/manage.py
   M quickstart/settings.py
   M quickstart/tests/functional/test_functional.py
   M quickstart/tests/test_app.py
   M quickstart/tests/test_juju.py
   M quickstart/tests/test_jujugui.py
   M quickstart/tests/test_manage.py
   M tox.ini

[Richard Harding (rharding)]

LGTM, I think most of my questions are answered in some way or another.
I understand that this is really checking is the version of the charm
ready, not the gui, so checking the version.js isn't a perfect match. I
still can't help but feel that the charm revision is tied to the gui
release inside and maybe it's a better overall solution to this.
However, this is a perfectly reasonable way to go about it and should
work out most of the time.

https://codereview.appspot.com/247800043/diff/1/quickstart/app.py
File quickstart/app.py (right):

https://codereview.appspot.com/247800043/diff/1/quickstart/app.py#newcode659
quickstart/app.py:659: 'deployed Juju GUI charm ({}): requested bundle
deployment '
should we hint at a juju-gui upgrade here?

https://codereview.appspot.com/247800043/diff/1/quickstart/app.py#newcode663
quickstart/app.py:663: print('requesting uncommitted deployment of {}
with the following '
"uncommitted deployment" to "uncomitted loading"? deployment just
strikes me as very...deployed.

https://codereview.appspot.com/247800043/diff/1/quickstart/app.py#newcode679
quickstart/app.py:679: return response['Token']
does this open the gui url as it does when you just run juju-quickstart
without the deployment?

https://codereview.appspot.com/247800043/diff/1/quickstart/jujugui.py
File quickstart/jujugui.py (right):

https://codereview.appspot.com/247800043/diff/1/quickstart/jujugui.py#newcode62
quickstart/jujugui.py:62: def is_promulgated(reference):
I don't get this part. Can this not work if the gui you deployed is a
local deployment of the GUI?

Should this better be a check for a flag/config/call to the GUI source
instead? Can it just check something like a check against version.js in
some way?

https://codereview.appspot.com/247800043/diff/1/quickstart/jujutools.py
File quickstart/jujutools.py (right):

https://codereview.appspot.com/247800043/diff/1/quickstart/jujutools.py#newcode60
quickstart/jujutools.py:60: if not jujugui.is_promulgated(charm_ref):
oic, so we assume. I still wonder about using version.js vs
is_promulgated.

https://codereview.appspot.com/247800043/

[lp:~frankban/juju-quickstart/uncommitted-bundles]

145. By Francesco Banconi on 2015-06-05

Changes as per review.

[Francesco Banconi (frankban)]

Please take a look.

https://codereview.appspot.com/247800043/diff/1/quickstart/app.py
File quickstart/app.py (right):

https://codereview.appspot.com/247800043/diff/1/quickstart/app.py#newcode659
quickstart/app.py:659: 'deployed Juju GUI charm ({}): requested bundle
deployment '
On 2015/06/05 12:28:41, rharding wrote:
> should we hint at a juju-gui upgrade here?

Good idea, done.

https://codereview.appspot.com/247800043/diff/1/quickstart/app.py#newcode663
quickstart/app.py:663: print('requesting uncommitted deployment of {}
with the following '
On 2015/06/05 12:28:41, rharding wrote:
> "uncommitted deployment" to "uncomitted loading"? deployment just
strikes me as
> very...deployed.

Done.

https://codereview.appspot.com/247800043/diff/1/quickstart/app.py#newcode679
quickstart/app.py:679: return response['Token']
On 2015/06/05 12:28:41, rharding wrote:
> does this open the gui url as it does when you just run
juju-quickstart without
> the deployment?

This token, if returned, is used to build the GUI URL.
Opening the GUI on the browser is done by manage.run.

https://codereview.appspot.com/247800043/diff/1/quickstart/jujutools.py
File quickstart/jujutools.py (right):

https://codereview.appspot.com/247800043/diff/1/quickstart/jujutools.py#newcode60
quickstart/jujutools.py:60: if not jujugui.is_promulgated(charm_ref):
On 2015/06/05 12:28:42, rharding wrote:
> oic, so we assume. I still wonder about using version.js vs
is_promulgated.

Well, some of the features we check (e.g. bundle deployment, uncommitted
bundles or new API endpoints) must be implemented principally on the
server (because qucikstart interacts mostly with the GUI server via its
API), and that's why in the cases we know the promulgated revision we
can safely check for their availability.
Given this is quickstart, I'd expect that we are dealing with
promulgated GUI charms 99% of the times, as you already mentioned. For
the remaining cases we trust the user and we expect her to be smart
enough to handle possible (and graceful) quickstart errors, which is the
only bad thing that can happen if the current customized charm does not
support a requested feature.

https://codereview.appspot.com/247800043/

[Brad Crittenden (bac)]

Francesco I can no longer log in to Rietveld so I'm making comments here only.

The code looks good. I'll do QA now.

[Brad Crittenden (bac)]

QA was OK.

review: Approve (code + qa)

=== modified file 'quickstart/__init__.py'
--- quickstart/__init__.py	2015-05-22 11:33:00 +0000
+++ quickstart/__init__.py	2015-06-05 13:07:56 +0000
@@ -45,7 +45,7 @@
 Once Juju has been installed, the command can also be run as a juju plugin,
 without the hyphen ("juju quickstart").
 """
-VERSION = (2, 1, 2)
+VERSION = (2, 2, 0)
 
 
 def get_version():
 
=== modified file 'quickstart/app.py'
--- quickstart/app.py	2015-05-22 17:11:26 +0000
+++ quickstart/app.py	2015-06-05 13:07:56 +0000
@@ -621,23 +621,79 @@
     return dict((k, v.get('value')) for k, v in config.items())
 
 
-def deploy_bundle(env, bundle):
+def deploy_bundle(env, bundle, uncommitted, charm_ref):
     """Deploy the given bundle connecting to the given environment.
 
-    Receive the environment connection to use for deploying the bundle and the
-    bundle object as an instance of "quickstart.models.bundles.Bundle".
-
-    Raise a ProgramExit if the API server returns an error response.
+    Receive:
+        - env: the environment connection to use for deploying the bundle;
+        - bundle: the bundle to be deployed, as an instance of
+          "quickstart.models.bundles.Bundle";
+        - uncommitted: a flag indicating whether the given bundle must be
+          deployed in uncommitted mode;
+        - charm_ref: the Juju GUI charm reference, used in the case uncommitted
+          is True in order to verify that the GUI service supports uncommitted
+          bundle deployments.
+
+    If uncommitted is True, do not actually deploy the workload, but instead
+    register it as a set of changes on the GUI server, and return a token
+    identifying the change set, to be reused later by the Juju GUI.
+    If uncommitted is False, start the bundle deployment and return None.
+
+    Raise a ProgramExit if any of the API server calls return an error.
     """
+    services = ', '.join(bundle.services().keys())
+    ref = bundle.reference
+    details = ''
+    if ref is not None:
+        details = (
+            '\nmore details about this bundle can be found at\n'
+            '  {}'.format(ref.jujucharms_url()))
+
+    if uncommitted:
+        # Ensure the currently deployed Juju GUI service supports change sets.
+        series = charm_ref.series
+        revision = settings.MINIMUM_REVISIONS_FOR_UNCOMMITTED_BUNDLES[series]
+        if jujugui.is_promulgated(charm_ref) and charm_ref.revision < revision:
+            logging.warn(
+                'uncommitted bundles loading is not supported by currently '
+                'deployed Juju GUI charm ({}): requested bundle deployment '
+                'will be ignored'.format(charm_ref))
+            logging.warn(
+                'run "juju upgrade-charm {}" to enable uncommitted bundles '
+                'support'.format(settings.JUJU_GUI_SERVICE_NAME))
+            return None
+        # Register the changes in the GUI server.
+        print('requesting uncommitted bundle loading of {} with the following '
+              'services:\n  {}'.format(bundle, services))
+        try:
+            response = env.set_changes(bundle.serialize())
+        except jujuclient.EnvError as err:
+            raise ProgramExit(
+                'bad API server response: {}'.format(err.message))
+        errors = response.get('Errors')
+        if errors:
+            # This is unexpected, the bundle at this point is already validated
+            # using juju bundle lib.
+            msg = ', '.join(errors)
+            raise ProgramExit('cannot generate the change set: {}'.format(msg))
+        print('the bundle is ready to be deployed\n'
+              'use the GUI to configure the bundle and to start the '
+              'deployment process{}'.format(details))
+        return response['Token']
+
+    print('requesting a deployment of {} with the following services:\n'
+          '  {}'.format(bundle, services))
     # XXX frankban 2015-02-26: use new bundle format if the GUI server is
     # capable of handling bundle deployments with the API version 4.
     yaml = bundle.serialize_legacy()
     version = 3
     # XXX frankban 2015-02-26: find and implement a better way to increase the
     # bundle deployments count.
-    ref = bundle.reference
     bundle_id = None if ref is None else ref.charmworld_id
     try:
         env.deploy_bundle(yaml, version, bundle_id=bundle_id)
     except jujuclient.EnvError as err:
         raise ProgramExit('bad API server response: {}'.format(err.message))
+    print('bundle deployment request accepted\nuse the GUI to check the '
+          'bundle deployment progress{}'.format(details))
+    return None
 
=== modified file 'quickstart/juju.py'
--- quickstart/juju.py	2015-02-26 05:03:10 +0000
+++ quickstart/juju.py	2015-06-05 13:07:56 +0000
@@ -75,6 +75,15 @@
         }
         return self._rpc(request)
 
+    def set_changes(self, yaml):
+        """Register the bundle change set in the GUI server."""
+        request = {
+            'Type': 'ChangeSet',
+            'Request': 'SetChanges',
+            'Params': {'YAML': yaml},
+        }
+        return self._rpc(request)
+
     def create_auth_token(self):
         """Make an auth token creation request.
 
 
=== modified file 'quickstart/jujugui.py'
--- quickstart/jujugui.py	2015-05-22 16:04:02 +0000
+++ quickstart/jujugui.py	2015-06-05 13:07:56 +0000
@@ -28,6 +28,22 @@
 from quickstart import settings
 
 
+def add_tokens_to_url(url, auth_token, changes_token):
+    """Return an URL including the optional authentication and changes tokens.
+
+    If auth_token and changes_token are both None, the given URL is returned
+    without changes.
+    """
+    query = []
+    if auth_token is not None:
+        query.append('authtoken=' + auth_token)
+    if changes_token is not None:
+        query.append('changestoken=' + changes_token)
+    if query:
+        return '{}/?{}'.format(url, '&'.join(query))
+    return url
+
+
 def build_options(port, source):
     """Create a configuration dict suitable to be used when deploying the GUI.
 
@@ -43,6 +59,18 @@
     return options or None
 
 
+def is_promulgated(reference):
+    """Report whether the given reference represents a GUI promulgated charm.
+
+    The given reference is an instance of "jujubundlelib.references.Reference".
+    """
+    return (
+        reference.name == settings.JUJU_GUI_CHARM_NAME and
+        not reference.user and
+        not reference.is_local()
+    )
+
+
 def normalize_config(options):
     """Normalize the Juju GUI configuration options.
 
 
=== modified file 'quickstart/jujutools.py'
--- quickstart/jujutools.py	2015-05-22 16:04:02 +0000
+++ quickstart/jujutools.py	2015-06-05 13:07:56 +0000
@@ -19,6 +19,7 @@
 from __future__ import unicode_literals
 
 from quickstart import (
+    jujugui,
     serializers,
     settings,
 )
@@ -56,11 +57,7 @@
     # If a customized Juju GUI charm is in use, there is no way to check if the
     # GUI server is recent enough to support the new Juju API endpoints.
     # In these cases, assume the customized charm is recent enough.
-    if (
-        charm_ref.name != settings.JUJU_GUI_CHARM_NAME or
-        charm_ref.user or
-        charm_ref.is_local()
-    ):
+    if not jujugui.is_promulgated(charm_ref):
         return complete_url
     # This is the promulgated Juju GUI charm. Check if it supports new APIs.
     revision, series = charm_ref.revision, charm_ref.series
 
=== modified file 'quickstart/manage.py'
--- quickstart/manage.py	2015-05-22 16:04:02 +0000
+++ quickstart/manage.py	2015-06-05 13:07:56 +0000
@@ -374,6 +374,8 @@
         - open_browser: whether the GUI browser must be opened;
         - platform: The host platform;
         - port: the optional Juju GUI port, or None;
+        - uncommitted: whether the provided bundle must be deployed using the
+          Juju GUI uncommitted state;
         - upload_tools: whether to upload local version of tools;
         - upload_series: the comma-separated series list for which tools will
           be uploaded, or None if not set.
@@ -444,15 +446,18 @@
         '-i', '--interactive', action='store_true', dest='interactive',
         help='Start the environments management interactive session')
     parser.add_argument(
-        '--environments-file', dest='env_file',
-        default=os.path.join(settings.JUJU_HOME, 'environments.yaml'),
-        help='The path to the Juju environments YAML file\n(%(default)s)')
+        '-u', '--uncommitted', action='store_true', dest='uncommitted',
+        help='Do not start the bundle deployment. Open the GUI showing\n'
+             'an uncommitted bundle state instead, so that the bundle\n'
+             'can be finely tuned and tweaked before committing the\n'
+             'changes. This option is ignored if no bundle deployment\n'
+             'is requested.')
     parser.add_argument(
         '--gui-charm-url', dest='charm_url',
         help='The Juju GUI charm URL to deploy in the environment.\n'
              'If not provided, the last release of the GUI will be\n'
              'deployed. The charm URL must include the charm version,\n'
-             'e.g. "cs:~juju-gui/precise/juju-gui-162". This option is\n'
+             'e.g. "cs:~juju-gui/trusty/juju-gui-51". This option is\n'
              'ignored if the GUI is already present in the environment')
     parser.add_argument(
         '--gui-port', dest='port', type=int,
@@ -466,6 +471,10 @@
         '--no-browser', action='store_false', dest='open_browser',
         help='Avoid opening the browser to the GUI at the end of the\nprocess')
     parser.add_argument(
+        '--environments-file', dest='env_file',
+        default=os.path.join(settings.JUJU_HOME, 'environments.yaml'),
+        help='The path to the Juju environments YAML file\n(%(default)s)')
+    parser.add_argument(
         '--distro-only', action='store_true', dest='distro_only',
         default=default_distro_only, help=distro_only_help)
     parser.add_argument(
@@ -628,29 +637,30 @@
         '{}:{}'.format(address, gui_config['port']), juju_version, env_uuid,
         path_prefix='ws', charm_ref=charm_ref,
         insecure=not gui_config['secure'])
+
+    # We need to connect to an API WebSocket server supporting bundle
+    # deployments and automatic auth-token login. The GUI builtin server,
+    # listening on the Juju GUI address, exposes a suitable API.
     gui_env = app.connect(gui_api_url, username, password)
-
+    changes_token = None
     # Handle bundle deployment.
     if options.bundle_source is not None:
-        services = ', '.join(options.bundle.services().keys())
-        print('requesting a deployment of {} with the following services:\n'
-              '  {}'.format(options.bundle, services))
-        if options.bundle.reference is not None:
-            print('more details about this bundle can be found at\n'
-                  '  {}'.format(options.bundle.reference.jujucharms_url()))
-        # We need to connect to an API WebSocket server supporting bundle
-        # deployments. The GUI builtin server, listening on the Juju GUI
-        # address, exposes an API suitable for deploying bundles.
-        app.deploy_bundle(gui_env, options.bundle)
-        print('bundle deployment request accepted\n'
-              'use the GUI to check the bundle deployment progress')
+        changes_token = app.deploy_bundle(
+            gui_env, options.bundle, options.uncommitted, charm_ref)
+    # Handle automatic auth-token login.
+    auth_token = app.create_auth_token(gui_env)
+    gui_env.close()
 
+    # Calculate the complete URL and optionally open the default browser.
+    url = jujugui.add_tokens_to_url(url, auth_token, changes_token)
     if options.open_browser:
-        token = app.create_auth_token(gui_env)
-        if token is not None:
-            url += '/?authtoken={}'.format(token)
+        print('opening the browser at\n{}'.format(url))
         webbrowser.open(url)
-    gui_env.close()
+    else:
+        print('not opening the browser\n'
+              'you can automatically log in into the Juju GUI by visiting\n'
+              '{}\n(the login token will expire in two minutes)'.format(url))
+
     print(
         'done!\n\n'
         'Run "juju quickstart -e {env_name}" again if you want\n'
 
=== modified file 'quickstart/settings.py'
--- quickstart/settings.py	2015-03-09 17:50:28 +0000
+++ quickstart/settings.py	2015-06-05 13:07:56 +0000
@@ -37,8 +37,8 @@
 # temporary connection/charm store errors.
 # Keep this list sorted by release date (older first).
 DEFAULT_CHARM_URLS = collections.OrderedDict((
-    ('precise', 'cs:precise/juju-gui-108'),
-    ('trusty', 'cs:trusty/juju-gui-21'),
+    ('precise', 'cs:precise/juju-gui-115'),
+    ('trusty', 'cs:trusty/juju-gui-28'),
 ))
 
 # The quickstart app short description.
@@ -91,3 +91,8 @@
 # new endpoints.
 MINIMUM_REVISIONS_FOR_NEW_API_ENDPOINT = collections.defaultdict(
     lambda: 0, {'precise': 107, 'trusty': 19})
+
+# The minimum Juju GUI charm revision supporting uncommitted bundle
+# deployments. Assume not listed series to always support uncommitted state.
+MINIMUM_REVISIONS_FOR_UNCOMMITTED_BUNDLES = collections.defaultdict(
+    lambda: 0, {'precise': 115, 'trusty': 28})
 
=== modified file 'quickstart/tests/functional/test_functional.py'
--- quickstart/tests/functional/test_functional.py	2015-05-13 08:31:51 +0000
+++ quickstart/tests/functional/test_functional.py	2015-06-05 13:07:56 +0000
@@ -180,3 +180,11 @@
         self.assertEqual(0, retcode)
         self.assertIn('bundle deployment request accepted', output)
         self.assertEqual('', error)
+
+    def test_uncommitted_bundle_deployment(self):
+        # The application can be used to deploy uncommitted bundles.
+        retcode, output, error = run_quickstart(
+            self.env_name, '-u', 'u/openstack-charmers/openstack/25')
+        self.assertEqual(0, retcode)
+        self.assertIn('the bundle is ready to be deployed', output)
+        self.assertEqual('', error)
 
=== modified file 'quickstart/tests/test_app.py'
--- quickstart/tests/test_app.py	2015-05-22 17:11:26 +0000
+++ quickstart/tests/test_app.py	2015-06-05 13:07:56 +0000
@@ -1747,49 +1747,132 @@
             app.get_service_config(env, 'my-service')
 
 
[e-mail]_print
 class TestDeployBundle(ProgramExitTestsMixin, unittest.TestCase):
 
-    bundle_data = {'services': {}}
+    bundle_data = {'services': {'django': {}, 'haproxy': {}}}
     bundle = bundles.Bundle(bundle_data)
+    charm = references.Reference.from_string('cs:trusty/juju-gui-42')
 
-    def test_bundle_deployment(self):
+    def test_bundle_deployment(self, mock_print):
         # A bundle is successfully deployed.
-        env = mock.Mock()
-        app.deploy_bundle(env, self.bundle)
+        env, uncommitted = mock.Mock(), False
+        token = app.deploy_bundle(env, self.bundle, uncommitted, self.charm)
+        self.assertIsNone(token)
         # For the time being, the bundle version 3 is deployed by default.
         expected_yaml = yaml.safe_dump({'bundle': self.bundle_data})
         env.deploy_bundle.assert_called_once_with(
             expected_yaml, 3, bundle_id=None)
+        self.assertFalse(env.set_changes.called)
         self.assertFalse(env.close.called)
+        self.assertEqual(2, mock_print.call_count)
+        mock_print.assert_has_calls([
+            mock.call(
+                'requesting a deployment of bundle with the following '
+                'services:\n  django, haproxy'),
+            mock.call(
+                'bundle deployment request accepted\n'
+                'use the GUI to check the bundle deployment progress'),
+        ])
 
-    def test_bundle_deployment_with_id(self):
+    def test_bundle_deployment_with_id(self, mock_print):
         # If the bundle reference includes the charmworld id, it is passed when
         # calling the GUI server API.
         # XXX frankban 2015-02-26: remove this test once we get rid of the
         # charmworld id concept.
-        env = mock.Mock()
+        env, uncommitted = mock.Mock(), False
         ref = references.Reference.from_fully_qualified_url(
             'cs:bundle/django-single-42')
         ref.charmworld_id = 'django/single'
         bundle = bundles.Bundle(self.bundle_data, reference=ref)
-        app.deploy_bundle(env, bundle)
+        app.deploy_bundle(env, bundle, uncommitted, self.charm)
         env.deploy_bundle.assert_called_once_with(
             self.bundle.serialize_legacy(), 3, bundle_id='django/single')
 
-    def test_api_error(self):
-        # A ProgramExit is raised if an error occurs in one of the API calls.
-        env = mock.Mock()
+    def test_api_error(self, mock_print):
+        # A ProgramExit is raised if an error occurs while deploying the
+        # workload.
+        env, uncommitted = mock.Mock(), False
         env.deploy_bundle.side_effect = self.make_env_error(
             'bundle deployment failure')
         expected_error = 'bad API server response: bundle deployment failure'
         with self.assert_program_exit(expected_error):
-            app.deploy_bundle(env, self.bundle)
+            app.deploy_bundle(env, self.bundle, uncommitted, self.charm)
 
-    def test_other_errors(self):
-        # Any other errors occurred during the process are not trapped.
-        env = mock.Mock()
+    def test_other_errors(self, mock_print):
+        # Any other errors occurred during the bundle deployment process are
+        # not trapped.
+        env, uncommitted = mock.Mock(), False
         error = ValueError('explode!')
         env.deploy_bundle.side_effect = error
         with self.assertRaises(ValueError) as context_manager:
-            app.deploy_bundle(env, self.bundle)
-        self.assertIs(error, context_manager.exception)
+            app.deploy_bundle(env, self.bundle, uncommitted, self.charm)
+        self.assertIs(error, context_manager.exception)
+
+    def test_uncommitted_bundle_deployment(self, mock_print):
+        # A bundle is successfully registered as an uncommitted set of changes
+        # on the GUI server.
+        env, uncommitted = mock.Mock(), True
+        env.set_changes.return_value = {'Token': 'mytoken'}
+        token = app.deploy_bundle(env, self.bundle, uncommitted, self.charm)
+        self.assertEqual('mytoken', token)
+        expected_yaml = yaml.safe_dump(self.bundle_data)
+        env.set_changes.assert_called_once_with(expected_yaml)
+        self.assertFalse(env.deploy_bundle.called)
+        self.assertEqual(2, mock_print.call_count)
+        mock_print.assert_has_calls([
+            mock.call(
+                'requesting uncommitted bundle loading of bundle with the '
+                'following services:\n  django, haproxy'),
+            mock.call(
+                'the bundle is ready to be deployed\n'
+                'use the GUI to configure the bundle and to start the '
+                'deployment process'),
+        ])
+
+    def test_uncommitted_api_error(self, mock_print):
+        # A ProgramExit is raised if an error occurs while registering the
+        # change set to the GUI server.
+        env, uncommitted = mock.Mock(), True
+        env.set_changes.side_effect = self.make_env_error('bad wolf')
+        with self.assert_program_exit('bad API server response: bad wolf'):
+            app.deploy_bundle(env, self.bundle, uncommitted, self.charm)
+
+    def test_uncommitted_bundle_validation_error(self, mock_print):
+        # A ProgramExit is raised if the GUI server returns bundle validation
+        # errors in its response. This is really unlikely to happen.
+        env, uncommitted = mock.Mock(), True
+        env.set_changes.return_value = {'Errors': ['error 1', 'error2']}
+        expected_error = 'cannot generate the change set: error 1, error2'
+        with self.assert_program_exit(expected_error):
+            app.deploy_bundle(env, self.bundle, uncommitted, self.charm)
+
+    def test_uncommitted_other_errors(self, mock_print):
+        # Any other errors occurred during the change set process are not
+        # trapped.
+        env, uncommitted = mock.Mock(), True
+        error = ValueError('explode!')
+        env.set_changes.side_effect = error
+        with self.assertRaises(ValueError) as context_manager:
+            app.deploy_bundle(env, self.bundle, uncommitted, self.charm)
+        self.assertIs(error, context_manager.exception)
+
+    def test_uncommitted_not_supported(self, mock_print):
+        # The uncommitted set of changes cannot be registered if the Juju GUI
+        # service deployed in the environment does not support it.
+        env, uncommitted = mock.Mock(), True
+        charm = references.Reference.from_string('cs:trusty/juju-gui-0')
+        expected_logs = [
+            'uncommitted bundles loading is not supported by currently '
+            'deployed Juju GUI charm (cs:trusty/juju-gui-0): requested bundle '
+            'deployment will be ignored',
+            'run "juju upgrade-charm juju-gui" to enable uncommitted bundles '
+            'support',
+        ]
+        with helpers.assert_logs(expected_logs, level='warn'):
+            token = app.deploy_bundle(env, self.bundle, uncommitted, charm)
+        self.assertIsNone(token)
+        # No calls to deploy the bundle have been made.
+        self.assertFalse(env.deploy_bundle.called)
+        self.assertFalse(env.set_changes.called)
+        self.assertFalse(mock_print.called)
 
=== modified file 'quickstart/tests/test_juju.py'
--- quickstart/tests/test_juju.py	2015-05-22 10:48:55 +0000
+++ quickstart/tests/test_juju.py	2015-06-05 13:07:56 +0000
@@ -305,7 +305,19 @@
         })
 
     @patch_rpc
+    def test_set_changes(self, mock_rpc):
+        # The ChangeSet:SetChanges API call is properly generated.
+        self.env.set_changes('YAML content')
+        expected = {
+            'Type': 'ChangeSet',
+            'Request': 'SetChanges',
+            'Params': {'YAML': 'YAML content'},
+        }
+        mock_rpc.assert_called_once_with(expected)
+
+    @patch_rpc
     def test_create_auth_token(self, mock_rpc):
+        # The GUIToken:Create API call is properly generated.
         self.env.create_auth_token()
         expected = dict(Type='GUIToken', Request='Create')
         mock_rpc.assert_called_once_with(expected)
 
=== modified file 'quickstart/tests/test_jujugui.py'
--- quickstart/tests/test_jujugui.py	2015-05-22 16:04:02 +0000
+++ quickstart/tests/test_jujugui.py	2015-06-05 13:07:56 +0000
@@ -27,6 +27,32 @@
 from quickstart.tests import helpers
 
 
+class TestAddTokensToUrl(unittest.TestCase):
+
+    def test_tokens(self):
+        # The URL is properly generated with both authentication and changes
+        # tokens.
+        url = jujugui.add_tokens_to_url(
+            'https://1.2.3.4', 'myauth', 'mychanges')
+        self.assertEqual(
+            'https://1.2.3.4/?authtoken=myauth&changestoken=mychanges', url)
+
+    def test_auth_token_only(self):
+        # The URL is properly generated with the authentication token only.
+        url = jujugui.add_tokens_to_url('https://1.2.3.4', 'login', None)
+        self.assertEqual('https://1.2.3.4/?authtoken=login', url)
+
+    def test_changes_token_only(self):
+        # The URL is properly generated with the changes token only.
+        url = jujugui.add_tokens_to_url('https://1.2.3.4', None, 'changeset')
+        self.assertEqual('https://1.2.3.4/?changestoken=changeset', url)
+
+    def test_no_tokens(self):
+        # The URL is left untouched if no tokens are provided.
+        url = 'http://example.com'
+        self.assertEqual(url, jujugui.add_tokens_to_url(url, None, None))
+
+
 class TestBuildOptions(unittest.TestCase):
 
     def test_no_options(self):
@@ -57,6 +83,26 @@
         self.assertEqual(expected_options, options)
 
 
+class TestIsPromulgated(unittest.TestCase):
+
+    def test_promulgated(self):
+        # Promulgated Juju GUI charm references are properly recognized.
+        for url in ('cs:precise/juju-gui-0', 'cs:trusty/juju-gui-42'):
+            ref = references.Reference.from_string(url)
+            self.assertTrue(jujugui.is_promulgated(ref), url)
+
+    def test_customized(self):
+        # Customized Juju GUI charm references are properly recognized.
+        tests = (
+            'local:precise/juju-gui-0',
+            'cs:precise/mygui-1',
+            'cs:~who/trusty/juju-gui-2',
+        )
+        for url in tests:
+            ref = references.Reference.from_string(url)
+            self.assertFalse(jujugui.is_promulgated(ref), url)
+
+
 class TestNormalizeConfig(unittest.TestCase):
 
     def test_normal_options(self):
 
=== modified file 'quickstart/tests/test_manage.py'
--- quickstart/tests/test_manage.py	2015-05-22 14:28:23 +0000
+++ quickstart/tests/test_manage.py	2015-06-05 13:07:56 +0000
@@ -702,6 +702,7 @@
             'gui_source': None,
             'open_browser': True,
             'port': None,
+            'uncommitted': False,
         }
         options.update(kwargs)
         return mock.Mock(**options)
@@ -751,6 +752,8 @@
             'watch': '1.2.3.5',
             # Retrieve the Juju GUI service configuration.
             'get_service_config': {'port': None, 'secure': True},
+            # Optionally deploy a bundle.
+            'deploy_bundle': None,
             # Create the login token for the Juju GUI.
             'create_auth_token': 'TOKEN',
         }
@@ -965,7 +968,7 @@
 
     def test_bundle(self, mock_app, mock_open):
         # A bundle is correctly deployed by the application.
-        env = self.configure_app(mock_app, create_auth_token=None)
+        env = self.configure_app(mock_app)
         bundle_source = 'mediawiki-single'
         reference = references.Reference.from_jujucharms_url(bundle_source)
         bundle = bundles.Bundle(self.bundle_data, reference=reference)
@@ -974,7 +977,25 @@
         with self.patch_get_juju_command():
             manage.run(options)
         # Ensure the bundle is correctly deployed.
-        mock_app.deploy_bundle.assert_called_once_with(env, bundle)
+        ref = references.Reference.from_string('cs:trusty/juju-gui-42')
+        mock_app.deploy_bundle.assert_called_once_with(env, bundle, False, ref)
+
+    def test_uncommitted_bundle(self, mock_app, mock_open):
+        # An uncommitted bundle is correctly deployed by the application.
+        env = self.configure_app(mock_app, deploy_bundle='CHANGES-TOKEN')
+        bundle_source = 'mediawiki-single'
+        reference = references.Reference.from_jujucharms_url(bundle_source)
+        bundle = bundles.Bundle(self.bundle_data, reference=reference)
+        # Run the application.
+        options = self.make_options(
+            bundle_source=bundle_source, bundle=bundle, uncommitted=True)
+        with self.patch_get_juju_command():
+            manage.run(options)
+        # Ensure the bundle is correctly deployed.
+        ref = references.Reference.from_string('cs:trusty/juju-gui-42')
+        mock_app.deploy_bundle.assert_called_once_with(env, bundle, True, ref)
+        mock_open.assert_called_once_with(
+            'https://1.2.3.5/?authtoken=TOKEN&changestoken=CHANGES-TOKEN')
 
     def test_local_provider(self, mock_app, mock_open):
         # The application correctly handles working with local providers with
 
=== modified file 'tox.ini'
--- tox.ini	2015-05-11 10:55:51 +0000
+++ tox.ini	2015-06-05 13:07:56 +0000
@@ -72,7 +72,7 @@
     # See https://launchpad.net/~juju/+archive/ubuntu/stable.
     websocket-client==0.18.0
     jujuclient==0.50.1
-    jujubundlelib==0.1.7
+    jujubundlelib==0.1.8
     urwid==1.2.1
     # The distribution PyYAML requirement is used in this case.
 
@@ -82,7 +82,7 @@
     # Ubuntu 14.04 (trusty) distro dependencies.
     websocket-client==0.12.0
     jujuclient==0.17.5
-    jujubundlelib==0.1.7
+    jujubundlelib==0.1.8
     PyYAML==3.10
     urwid==1.1.1
 
@@ -92,7 +92,7 @@
     # Ubuntu 14.10 (utopic) distro dependencies.
     websocket-client==0.12.0
     jujuclient==0.17.5
-    jujubundlelib==0.1.7
+    jujubundlelib==0.1.8
     PyYAML==3.11
     urwid==1.2.1
 
@@ -102,7 +102,7 @@
     # Ubuntu 15.04 (vivid) distro dependencies.
     websocket-client==0.18.0
     jujuclient==0.18.5
-    jujubundlelib==0.1.7
+    jujubundlelib==0.1.8
     PyYAML==3.11
     urwid==1.2.1