Merge lp:~benji/juju-gui/go-sandbox into lp:juju-gui/experimental

[Benji York]

The beginings of a Go-flavored sandbox.

Logging in, deploying a service, and moving it around all work.

The beginings of a Go-flavored sandbox.

Logging in, deploying a service, and moving it around all work.

https://codereview.appspot.com/10235045/

[Gary Poster (gary)]

LGTM with questions

https://codereview.appspot.com/10235045/diff/1/app/store/env/sandbox.js
File app/store/env/sandbox.js (right):

https://codereview.appspot.com/10235045/diff/1/app/store/env/sandbox.js#newcode812
app/store/env/sandbox.js:812: client.receive({Response: {AllWatcherId:
'42'}});
Heh. :-)

https://codereview.appspot.com/10235045/diff/1/app/store/env/sandbox.js#newcode839
app/store/env/sandbox.js:839: var response = {RequestId:
data.RequestId};
I guess we make a new response because Juju Core does not send back the
whole original request the way PyJuju does, right? If so, cool...though
I wonder if we should therefore remove the copying code in line 766
("Y.merge(data)" and the preceding comment).

https://codereview.appspot.com/10235045/diff/1/app/store/env/sandbox.js#newcode879
app/store/env/sandbox.js:879: // We do not provide the optional Config
or Constraints in the response.
How do you get it then? Or do you mean that this will be in a future
branch? (If so, let's use TODO as you did elsewhere)

https://codereview.appspot.com/10235045/

[Jeff Pihach (hatch)]

LGTM Thanks this looks good. I am not sure about the method casing
senario :-)

https://codereview.appspot.com/10235045/diff/5001/app/store/env/sandbox.js
File app/store/env/sandbox.js (right):

https://codereview.appspot.com/10235045/diff/5001/app/store/env/sandbox.js#newcode774
app/store/env/sandbox.js:774: @method handle_Admin_Login
camel_Snake_Case? ;-)

https://codereview.appspot.com/10235045/diff/5001/test/test_sandbox.js
File test/test_sandbox.js (right):

https://codereview.appspot.com/10235045/diff/5001/test/test_sandbox.js#newcode1486
test/test_sandbox.js:1486: this.timeout(2000); // Long timeouts make
async failures hard to detect.
this technique has caused false failures on our CI before because of a
slow instance so I would suggest increasing it or removing all together.

https://codereview.appspot.com/10235045/diff/5001/test/test_sandbox.js#newcode1506
test/test_sandbox.js:1506: Y.each(cleanups, function(f) {f();});
cleanups is never used.

https://codereview.appspot.com/10235045/

[Jujugui Lander (jujugui-lander)]

No commit message specified.

[Jujugui Lander (jujugui-lander)]

Voting does not meet specified criteria. Required: Approve >= 1, Disapprove == 0. Got: 1 Pending.

[Diogo Matsubara (matsubara)]

review: Approve

[Jujugui Lander (jujugui-lander)]

The Jenkins job https://jenkins.qa.ubuntu.com/job/jujugui-merger-trunk/7/console reported an error when processing this lp:~benji/juju-gui/go-sandbox branch.
Not merging it.

=== modified file 'app/app.js'
--- app/app.js	2013-06-12 17:55:05 +0000
+++ app/app.js	2013-06-13 12:44:26 +0000
@@ -360,8 +360,7 @@
         }
       }
 
-
-      if (window.flags.websocket_capture) {
+      if (window.flags && window.flags.websocket_capture) {
         this.websocketLogging = new Y.juju.WebsocketLogging();
       }
 
@@ -448,7 +447,7 @@
         };
         var apiBackend = this.get('apiBackend');
         // The sandbox mode does not support the Go API (yet?).
-        if (this.get('sandbox') && apiBackend === 'python') {
+        if (this.get('sandbox')) {
           var sandboxModule = Y.namespace('juju.environments.sandbox');
           var State = Y.namespace('juju.environments').FakeBackend;
           var state = new State({charmStore: this.charm_store});
@@ -457,8 +456,16 @@
             credentials[envOptions.user] = envOptions.password;
             state.set('authorizedUsers', credentials);
           }
-          envOptions.conn = new sandboxModule.ClientConnection(
-              {juju: new sandboxModule.PyJujuAPI({state: state})});
+          if (apiBackend === 'python') {
+            envOptions.conn = new sandboxModule.ClientConnection(
+                {juju: new sandboxModule.PyJujuAPI({state: state})});
+          } else if (apiBackend === 'go') {
+            envOptions.conn = new sandboxModule.ClientConnection(
+                {juju: new sandboxModule.GoJujuAPI({state: state})});
+          } else {
+            throw 'unrecognized backend type: ' + apiBackend;
+          }
+
         }
         this.env = juju.newEnvironment(envOptions, apiBackend);
       }
@@ -938,7 +945,7 @@
       // If the Juju environment is not connected, exit without letting the
       // route dispatch proceed. On env connection change, the app will
       // re-dispatch and this route callback will be executed again.
-      if (!this.env.get('connected')) {
+      if (!this.env || !this.env.get('connected')) {
         return;
       }
       var credentials = this.env.getCredentials();

=== modified file 'app/models/models.js'
--- app/models/models.js	2013-06-12 15:41:45 +0000
+++ app/models/models.js	2013-06-13 12:44:26 +0000
@@ -344,7 +344,7 @@
       service.set('aggregated_status', aggregate);
 
       // Set Google Analytics tracking event.
-      if (previous_unit_count !== sum) {
+      if (previous_unit_count !== sum && window._gaq) {
         window._gaq.push(['_trackEvent', 'Service Stats', 'Update',
           service.get('id'), sum]);
       }

=== modified file 'app/store/env/sandbox.js'
--- app/store/env/sandbox.js	2013-05-17 14:51:05 +0000
+++ app/store/env/sandbox.js	2013-06-13 12:44:26 +0000
@@ -19,7 +19,7 @@
 'use strict';
 
 /**
-Sandbox APIs mimicking communications with the Go and Juju backends.
+Sandbox APIs mimicking communications with the Go and Python backends.
 
 @module env
 @submodule env.sandbox
@@ -682,6 +682,208 @@
   });
 
   sandboxModule.PyJujuAPI = PyJujuAPI;
+
+  /**
+  A sandbox Juju environment using the Go API.
+
+  @class GoJujuAPI
+  */
+  function GoJujuAPI(config) {
+    GoJujuAPI.superclass.constructor.apply(this, arguments);
+  }
+
+  GoJujuAPI.NAME = 'sandbox-py-juju-api';
+  GoJujuAPI.ATTRS = {
+    state: {},
+    client: {}
+  };
+
+  Y.extend(GoJujuAPI, Y.Base, {
+
+    /**
+    Initializes.
+
+    @method initializer
+    @return {undefined} Nothing.
+    */
+    initializer: function() {
+      this.connected = false;
+    },
+
+    /**
+    Opens the connection to the sandbox Juju environment.
+    Called by ClientConnection, which sends itself.
+
+    @method open
+    @param {Object} client A ClientConnection.
+    @return {undefined} Nothing.
+    */
+    open: function(client) {
+      if (!this.connected) {
+        this.connected = true;
+        this.set('client', client);
+      } else if (this.get('client') !== client) {
+        throw 'INVALID_STATE_ERR : Connection is open to another client.';
+      }
+    },
+
+    /**
+    Closes the connection to the sandbox Juju environment.
+    Called by ClientConnection.
+
+    @method close
+    @return {undefined} Nothing.
+    */
+    close: function() {
+      if (this.connected) {
+        this.connected = false;
+        this.set('client', undefined);
+      }
+    },
+
+    /**
+    Do any extra work to destroy the object.
+
+    @method destructor
+    @return {undefined} Nothing.
+    */
+    destructor: function() {
+      this.close();
+    },
+
+    /**
+    Receives messages from the client and dispatches them.
+
+    @method receive
+    @param {Object} data A hash of data sent from the client.
+    @return {undefined} Nothing.
+    */
+    receive: function(data) {
+      console.log('client message', data);
+      if (this.connected) {
+        this['handle' + data.Type + data.Request](data,
+            this.get('client'), this.get('state'));
+      } else {
+        throw CLOSEDERROR;
+      }
+    },
+
+    /**
+    Handle Login messages to the state object.
+
+    @method handleAdminLogin
+    @param {Object} data The contents of the API arguments.
+    @param {Object} client The active ClientConnection.
+    @param {Object} state An instance of FakeBackend.
+    */
+    handleAdminLogin: function(data, client, state) {
+      data.Error = !state.login(data.Params.AuthTag, data.Params.Password);
+      client.receive(data);
+    },
+
+    /**
+    Handle EnvironmentView messages.
+
+    @method handleClientServiceGet
+    @param {Object} data The contents of the API arguments.
+    @param {Object} client The active ClientConnection.
+    @param {Object} state An instance of FakeBackend.
+    */
+    handleClientEnvironmentInfo: function(data, client, state) {
+      client.receive({
+        ProviderType: state.get('providerType'),
+        DefaultSeries: state.get('defaultSeries'),
+        Name: 'Sandbox'
+      });
+    },
+
+    /**
+    Handle WatchAll messages.
+
+    @method handleClientWatchAll
+    @param {Object} data The contents of the API arguments.
+    @param {Object} client The active ClientConnection.
+    @param {Object} state An instance of FakeBackend.
+    */
+    handleClientWatchAll: function(data, client, state) {
+      // TODO wire up delta stream to "Next" responses here.
+      client.receive({Response: {AllWatcherId: '42'}});
+    },
+
+    /**
+    Handle AllWatcher Next messages.
+
+    @method handleAllWatcherNext
+    @param {Object} data The contents of the API arguments.
+    @param {Object} client The active ClientConnection.
+    @param {Object} state An instance of FakeBackend.
+    */
+    handleAllWatcherNext: function(data, client, state) {
+      // This is a noop for the moment because it must exist but the current
+      // functionality does not depend on it having any effect.
+      // TODO See if there are any changes and if so, send them.
+    },
+
+    /**
+    Handle ServiceDeploy messages
+
+    @method handleClientServiceDeploy
+    @param {Object} data The contents of the API arguments.
+    @param {Object} client The active ClientConnection.
+    @param {Object} state An instance of FakeBackend.
+    */
+    handleClientServiceDeploy: function(data, client, state) {
+      var callback = function(result) {
+        var response = {RequestId: data.RequestId};
+        if (result.error) {
+          response.Error = result.error;
+        }
+        client.receive(response);
+      };
+      state.deploy(data.Params.CharmUrl, callback, {
+        name: data.Params.ServiceName,
+        config: data.Params.Config,
+        configYAML: data.Params.ConfigYAML,
+        unitCount: data.Params.NumUnits
+      });
+    },
+
+    /**
+    Handle SetAnnotations messages
+
+    @method handleClientSetAnnotations
+    @param {Object} data The contents of the API arguments.
+    @param {Object} client The active ClientConnection.
+    @param {Object} state An instance of FakeBackend.
+    */
+    handleClientSetAnnotations: function(data, client, state) {
+      var serviceId = /service-([^ ]*)$/.exec(data.Params.Tag)[1];
+      var reply = state.updateAnnotations(serviceId, data.Params.Pairs);
+      client.receive({
+        RequestId: data.RequestId,
+        Error: reply.error});
+    },
+
+    /**
+    Handle ServiceGet messages
+
+    @method handleClientServiceGet
+    @param {Object} data The contents of the API arguments.
+    @param {Object} client The active ClientConnection.
+    @param {Object} state An instance of FakeBackend.
+    */
+    handleClientServiceGet: function(data, client, state) {
+      var reply = state.getService(data.Params.ServiceName);
+      // TODO Include the optional Config or Constraints in the response.
+      client.receive({
+        RequestId: data.RequestId,
+        Error: reply.error,
+        Response: {Service: data.Params.ServiceName}});
+    }
+
+  });
+
+  sandboxModule.GoJujuAPI = GoJujuAPI;
 }, '0.1.0', {
   requires: [
     'base',

=== modified file 'lib/deploy_charm_for_testing.py'
--- lib/deploy_charm_for_testing.py	2013-05-22 11:23:34 +0000
+++ lib/deploy_charm_for_testing.py	2013-06-13 12:44:26 +0000
@@ -88,7 +88,6 @@
     while True:
         state = get_state()
         if 'error' in state:
-            print(get_status())
             raise RuntimeError('error deploying service')
         if state == 'started':
             break

=== modified file 'test/test_app.js'
--- test/test_app.js	2013-06-11 12:23:12 +0000
+++ test/test_app.js	2013-06-13 12:44:26 +0000
@@ -112,6 +112,15 @@
           assert.equal(app.env.get('password'), undefined);
         });
 
+    it('should report backend misconfiguration', function() {
+      var config = {
+        sandbox: true,
+        apiBackend: 'not really a backend'};
+      assert.throws(
+          function() {var stupidLinter = new Y.juju.App(config);},
+          'unrecognized backend type: not really a backend');
+    });
+
     it('should propagate login credentials from the configuration',
         function(done) {
           var the_username = 'nehi';
@@ -487,7 +496,7 @@
 })();
 
 (function() {
-  describe('Application sandbox', function() {
+  describe('Application sandbox mode', function() {
     var Y, app, container, utils;
 
     before(function(done) {
@@ -507,7 +516,7 @@
       }
     });
 
-    it('app instantiates correctly in sandbox mode.', function() {
+    it('instantiates correctly', function() {
       app = new Y.juju.App(
           { container: container,
             viewContainer: container,

=== modified file 'test/test_deploy_charm_for_testing.py'
--- test/test_deploy_charm_for_testing.py	2013-05-28 14:00:30 +0000
+++ test/test_deploy_charm_for_testing.py	2013-06-13 12:44:26 +0000
@@ -102,7 +102,7 @@
         self.__class__.options = options
 
 
-# Mock argparse
+# Fake argparse output.
 def _options(**kwargs):
     def _wrapper():
         class _o(dict):
@@ -113,14 +113,15 @@
         return result
     return _wrapper
 
+
 class TestScript(unittest.TestCase):
     """The main() function is the entry point when run as a script."""
 
     def test_status_messages_are_displayed(self):
         # While running, the script tells the user what is happening.
         printed = []
-        main(options=_options(), print=printed.append, juju=noop, wait_for_service=noop,
-             wait_for_machine=noop)
+        main(options=_options(), print=printed.append, juju=noop,
+            wait_for_service=noop, wait_for_machine=noop)
         self.assertSequenceEqual(
             printed,
             ['Bootstrapping...',
@@ -136,22 +137,26 @@
         def juju(s):
             juju_commands.append(s)
 
-        main(options=_options(origin='lp:foo'), print=noop, juju=juju, wait_for_service=noop,
-             make_config_file=MakeConfigFile, wait_for_machine=noop,
-             make_environments_yaml=noop)
+        main(options=_options(origin='lp:foo'), print=noop, juju=juju,
+            wait_for_service=noop, make_config_file=MakeConfigFile,
+            wait_for_machine=noop, make_environments_yaml=noop)
         options = MakeConfigFile.options
         deploy_command = juju_commands[1]
         self.assertIn('--config my-config-file.yaml', deploy_command)
-        self.assertDictEqual({'serve-tests': True, 'staging': True,
-                              'juju-gui-source': 'lp:foo', 'secure': False}, options)
+        self.assertDictEqual(
+            {'serve-tests': True,
+             'staging': True,
+             'juju-gui-source': 'lp:foo',
+             'secure': False},
+            options)
 
     def test_providing_a_branch(self):
         # If the user provides a branch name on the command line, it will be
         # passed to the charm.
         printed = []
 
-        main(options=_options(origin='lp:foo'), print=printed.append, juju=noop,
-             wait_for_service=noop, make_config_file=MakeConfigFile,
+        main(options=_options(origin='lp:foo'), print=printed.append,
+            juju=noop, wait_for_service=noop, make_config_file=MakeConfigFile,
              wait_for_machine=noop, make_environments_yaml=noop)
         options = MakeConfigFile.options
         self.assertSequenceEqual(
@@ -164,6 +169,7 @@
         self.assertIn('juju-gui-source', options)
         self.assertEqual('lp:foo', options['juju-gui-source'])
 
+
 class TestParseImageData(unittest.TestCase):
     """Test the nova machine image data parsing."""
 
@@ -209,13 +215,17 @@
 
     def test_picks_last(self):
         data = '\n'.join([
-            "| abc-123 | ubuntu-released/ubuntu-precise-12.04-amd64-1.img | ACTIVE | |",
-            "| def-123 | smoser-proposed/ubuntu-precise-12.04-amd64-2.img | ACTIVE | |",
-            "| fad-123 | ubuntu-released/ubuntu-precise-12.04-amd64-3.img | ACTIVE | |"])
+            '| abc-123 | ubuntu-released/ubuntu-precise-12.04-amd64-1.img ' +
+                '| ACTIVE | |',
+            '| def-123 | smoser-proposed/ubuntu-precise-12.04-amd64-2.img ' +
+                '| ACTIVE | |',
+            '| fad-123 | ubuntu-released/ubuntu-precise-12.04-amd64-3.img ' +
+                '| ACTIVE | |'])
         img_id, desc = parse_image_data(data)
         self.assertEqual('fad-123', img_id)
         self.assertEqual(
-            'ubuntu-released/ubuntu-precise-12.04-amd64-3.img', desc)
+            'ubuntu-released/ubuntu-precise-12.04-amd64-3.img',
+            desc)
 
 
 if __name__ == '__main__':

=== modified file 'test/test_env_go.js'
--- test/test_env_go.js	2013-05-21 16:30:38 +0000
+++ test/test_env_go.js	2013-06-13 12:44:26 +0000
@@ -107,6 +107,8 @@
       // In order to avoid rewriting all of these go tests we need to destroy
       // the env created in the beforeEach
       env.destroy();
+      // We need to clear any credentials stored in sessionStorage.
+      env.setCredentials(null);
       oldHandleLogin = Y.juju.environments.GoEnvironment.handleLogin;
       Y.juju.environments.GoEnvironment.handleLogin = function() {};
       conn = new utils.SocketStub();

=== modified file 'test/test_sandbox.js'
--- test/test_sandbox.js	2013-05-17 14:51:05 +0000
+++ test/test_sandbox.js	2013-06-13 12:44:26 +0000
@@ -182,10 +182,8 @@
     var requires = [
       'juju-env-sandbox', 'juju-tests-utils', 'juju-env-python',
       'juju-models', 'promise'];
-    var Y, sandboxModule, ClientConnection, PyJujuAPI, environmentsModule,
-        state, juju, client, env, utils, cleanups;
-
-    this.timeout(2000); // Long timeouts make async failures hard to detect.
+    var Y, sandboxModule, ClientConnection, environmentsModule, state, juju,
+        client, env, utils, cleanups;
 
     before(function(done) {
       Y = YUI(GlobalConfig).use(requires, function(Y) {
@@ -1430,8 +1428,6 @@
     }
 
     it('should support export', function(done) {
-      this.timeout(250);
-
       client.open();
       promise(state, 'deploy', 'cs:wordpress')
        .then(promise(state, 'deploy', 'cs:mysql'))
@@ -1447,7 +1443,6 @@
     });
 
     it('should support import', function(done) {
-      this.timeout(300);
       var fixture = utils.loadFixture('data/sample-fakebackend.json', false);
 
       client.onmessage = function() {
@@ -1475,4 +1470,197 @@
 
   });
 
+
+  describe('sandbox.GoJujuAPI', function() {
+    var requires = [
+      'juju-env-sandbox', 'juju-tests-utils', 'juju-env-go',
+      'juju-models', 'promise'];
+    var Y, sandboxModule, ClientConnection, environmentsModule, state, juju,
+        client, env, utils;
+
+    before(function(done) {
+      Y = YUI(GlobalConfig).use(requires, function(Y) {
+        sandboxModule = Y.namespace('juju.environments.sandbox');
+        environmentsModule = Y.namespace('juju.environments');
+        utils = Y.namespace('juju-tests.utils');
+        done();
+      });
+    });
+
+    beforeEach(function() {
+      state = utils.makeFakeBackendWithCharmStore();
+      juju = new sandboxModule.GoJujuAPI({state: state});
+      client = new sandboxModule.ClientConnection({juju: juju});
+      env = new environmentsModule.GoEnvironment({conn: client});
+    });
+
+    afterEach(function() {
+      env.destroy();
+      client.destroy();
+      juju.destroy();
+      state.destroy();
+    });
+
+    it('opens successfully.', function() {
+      assert.isFalse(juju.connected);
+      assert.isUndefined(juju.get('client'));
+      client.open();
+      assert.isTrue(juju.connected);
+      assert.strictEqual(juju.get('client'), client);
+    });
+
+    it('ignores "open" when already open to same client.', function() {
+      client.receive = function() {
+        assert.ok(false, 'The receive method should not be called.');
+      };
+      // Whitebox test: duplicate "open" state.
+      juju.connected = true;
+      juju.set('client', client);
+      // This is effectively a re-open.
+      client.open();
+      // The assert.ok above is the verification.
+    });
+
+    it('refuses to open if already open to another client.', function() {
+      // This is a simple way to make sure that we don't leave multiple
+      // setInterval calls running.  If for some reason we want more
+      // simultaneous clients, that's fine, though that will require
+      // reworking the delta code generally.
+      juju.connected = true;
+      juju.set('client', {receive: function() {
+        assert.ok(false, 'The receive method should not have been called.');
+      }});
+      assert.throws(
+          client.open.bind(client),
+          'INVALID_STATE_ERR : Connection is open to another client.');
+    });
+
+    it('closes successfully.', function() {
+      client.open();
+      assert.isTrue(juju.connected);
+      assert.notEqual(juju.get('client'), undefined);
+      client.close();
+      assert.isFalse(juju.connected);
+      assert.isUndefined(juju.get('client'));
+    });
+
+    it('ignores "close" when already closed.', function() {
+      // This simply shows that we do not raise an error.
+      juju.close();
+    });
+
+    it('can dispatch on received information.', function(done) {
+      var data = {Type: 'TheType', Request: 'TheRequest'};
+      juju.handleTheTypeTheRequest = function(received) {
+        assert.notStrictEqual(received, data);
+        assert.deepEqual(received, data);
+        done();
+      };
+      client.open();
+      client.send(Y.JSON.stringify(data));
+    });
+
+    it('refuses to dispatch when closed.', function() {
+      assert.throws(
+          juju.receive.bind(juju, {}),
+          'INVALID_STATE_ERR : Connection is closed.'
+      );
+    });
+
+    it('can log in.', function(done) {
+      // See FakeBackend's authorizedUsers for these default authentication
+      // values.
+      var data = {
+        Type: 'Admin',
+        Request: 'Login',
+        Params: {
+          AuthTag: 'admin',
+          Password: 'password'
+        },
+        RequestId: 42
+      };
+      client.onmessage = function(received) {
+        // Add in the error indicator so the deepEqual is comparing apples to
+        // apples.
+        data.Error = false;
+        assert.deepEqual(Y.JSON.parse(received.data), data);
+        assert.isTrue(state.get('authenticated'));
+        done();
+      };
+      state.logout();
+      assert.isFalse(state.get('authenticated'));
+      client.open();
+      client.send(Y.JSON.stringify(data));
+    });
+
+    it('can log in (environment integration).', function(done) {
+      state.logout();
+      env.after('login', function() {
+        assert.isTrue(env.userIsAuthenticated);
+        done();
+      });
+      env.connect();
+      env.setCredentials({user: 'admin', password: 'password'});
+      env.login();
+    });
+
+    it('can deploy.', function(done) {
+      // We begin logged in.  See utils.makeFakeBackendWithCharmStore.
+      var data = {
+        Type: 'Client',
+        Request: 'ServiceDeploy',
+        Params: {
+          CharmUrl: 'cs:wordpress',
+          ServiceName: 'kumquat',
+          ConfigYAML: 'funny: business',
+          NumUnits: 2
+        },
+        RequestId: 42
+      };
+      client.onmessage = function(received) {
+        var receivedData = Y.JSON.parse(received.data);
+        assert.equal(receivedData.RequestId, data.RequestId);
+        assert.isUndefined(receivedData.Error);
+        assert.isObject(
+            state.db.charms.getById('cs:precise/wordpress-10'));
+        var service = state.db.services.getById('kumquat');
+        assert.isObject(service);
+        assert.equal(service.get('charm'), 'cs:precise/wordpress-10');
+        assert.deepEqual(service.get('config'), {funny: 'business'});
+        var units = state.db.units.get_units_for_service(service);
+        assert.lengthOf(units, 2);
+        done();
+      };
+      client.open();
+      client.send(Y.JSON.stringify(data));
+    });
+
+    it('can deploy (environment integration).', function() {
+      env.connect();
+      // We begin logged in.  See utils.makeFakeBackendWithCharmStore.
+      var callback = function(result) {
+        assert.isUndefined(result.err);
+        assert.equal(result.charm_url, 'cs:wordpress');
+        var service = state.db.services.getById('kumquat');
+        assert.equal(service.get('charm'), 'cs:precise/wordpress-10');
+        assert.deepEqual(service.get('config'), {llama: 'pajama'});
+      };
+      env.deploy(
+          'cs:wordpress', 'kumquat', {llama: 'pajama'}, null, 1, callback);
+    });
+
+    it('can communicate errors after attempting to deploy', function(done) {
+      env.connect();
+      state.deploy('cs:wordpress', function() {});
+      var callback = function(result) {
+        assert.equal(
+            result.err, 'A service with this name already exists.');
+        done();
+      };
+      env.deploy('cs:wordpress', undefined, undefined, undefined, 1,
+          callback);
+    });
+
+  });
+
 })();