Merge lp:~gary/juju-gui/sandboxEnv-3 into lp:juju-gui/experimental

[Gary Poster]

Add remaining incomplete components of sandbox

This adds a connection and Python juju API implementation of the in-browser-memory environment. The final test shows a complete integration of login from environment through to the fake backend.

https://codereview.appspot.com/7621048/

[Gary Poster (gary)]

Reviewers: mp+154403_code.launchpad.net,

Message:
Please take a look.

Description:
Add remaining incomplete components of sandbox

This adds a connection and Python juju API implementation of the
in-browser-memory environment. The final test shows a complete
integration of login from environment through to the fake backend.

This is from a spike, and I have a bit more to translate from the spike
in a follow-on branch. The follow-on branch will support deploying to
the in-memory state from the environment, and from the GUI itself. I
decided to propose this first since the branch size was getting a bit
large and it was reasonably self-sufficient as it was.

https://code.launchpad.net/~gary/juju-gui/sandboxEnv-3/+merge/154403

(do not edit description out of merge proposal)

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

Affected files:
   A [revision details]
   M app/modules-debug.js
   M app/store/env/base.js
   M app/store/env/fakebackend.js
   A app/store/env/sandbox.js
   M test/index.html
   M test/test_app.js
   M test/test_env.js
   M test/test_fakebackend.js
   A test/test_sandbox.js

[Jeff Pihach (hatch)]

LGTM Thanks for the branch!

https://codereview.appspot.com/7621048/

[Madison Scott-Clary (makyo)]

LGTM, thanks!

Few minor points that I don't really care about, just questions. Feel
free to ignore.

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

https://codereview.appspot.com/7621048/diff/1/app/store/env/base.js#newcode67
app/store/env/base.js:67: } // else we never connected.
Super minor: we haven't really been doing much in the way of inline
comments in the past. I'm pretty sure this is meant to be a fake 'else'
statement, but maybe it could go above the if:

// Close the socket, but only if we have connected.

https://codereview.appspot.com/7621048/diff/1/app/store/env/base.js#newcode84
app/store/env/base.js:84: this.ws.open(); // For the fake backends.
Super minor: inline comment as above.

https://codereview.appspot.com/7621048/

[Gary Poster (gary)]

*** Submitted:

Add remaining incomplete components of sandbox

This adds a connection and Python juju API implementation of the
in-browser-memory environment. The final test shows a complete
integration of login from environment through to the fake backend.

R=jeff.pihach, matthew.scott
CC=
https://codereview.appspot.com/7621048

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

https://codereview.appspot.com/7621048/diff/1/app/store/env/base.js#newcode67
app/store/env/base.js:67: } // else we never connected.
On 2013/03/20 15:53:39, matthew.scott wrote:
> Super minor: we haven't really been doing much in the way of inline
comments in
> the past. I'm pretty sure this is meant to be a fake 'else'
statement, but
> maybe it could go above the if:

> // Close the socket, but only if we have connected.

Done.

https://codereview.appspot.com/7621048/diff/1/app/store/env/base.js#newcode84
app/store/env/base.js:84: this.ws.open(); // For the fake backends.
On 2013/03/20 15:53:39, matthew.scott wrote:
> Super minor: inline comment as above.

Done.

https://codereview.appspot.com/7621048/

=== modified file 'app/modules-debug.js'
--- app/modules-debug.js	2013-03-13 22:43:40 +0000
+++ app/modules-debug.js	2013-03-20 15:20:29 +0000
@@ -216,6 +216,10 @@
           fullpath: '/juju-ui/store/env/fakebackend.js'
         },
 
+        'juju-env-sandbox': {
+          fullpath: '/juju-ui/store/env/sandbox.js'
+        },
+
         'juju-notification-controller': {
           fullpath: '/juju-ui/store/notifications.js'
         },

=== modified file 'app/store/env/base.js'
--- app/store/env/base.js	2013-02-21 18:07:54 +0000
+++ app/store/env/base.js	2013-03-20 15:20:29 +0000
@@ -62,7 +62,9 @@
     },
 
     destructor: function() {
-      this.ws.close();
+      if (this.ws) {
+        this.ws.close();
+      } // else we never connected.
       this._txn_callbacks = {};
     },
 
@@ -78,6 +80,9 @@
       this.ws.onmessage = Y.bind(this.on_message, this);
       this.ws.onopen = Y.bind(this.on_open, this);
       this.ws.onclose = Y.bind(this.on_close, this);
+      if (this.ws.open) {
+        this.ws.open(); // For the fake backends.
+      }
       return this;
     },
 
@@ -192,6 +197,7 @@
   requires: [
     'base',
     'json-parse',
+    'json-stringify',
     'reconnecting-websocket'
   ]
 });

=== modified file 'app/store/env/fakebackend.js'
--- app/store/env/fakebackend.js	2013-03-12 13:34:26 +0000
+++ app/store/env/fakebackend.js	2013-03-20 15:20:29 +0000
@@ -75,8 +75,16 @@
       if (!this.get('authenticated')) {
         return UNAUTHENTICATEDERROR;
       }
-      var result = this.changes;
-      this._resetChanges();
+      var result;
+      if (Y.Object.isEmpty(this.changes.services) &&
+          Y.Object.isEmpty(this.changes.machines) &&
+          Y.Object.isEmpty(this.changes.units) &&
+          Y.Object.isEmpty(this.changes.relations)) {
+        result = null;
+      } else {
+        result = this.changes;
+        this._resetChanges();
+      }
       return result;
     },
 

=== added file 'app/store/env/sandbox.js'
--- app/store/env/sandbox.js	1970-01-01 00:00:00 +0000
+++ app/store/env/sandbox.js	2013-03-20 15:20:29 +0000
@@ -0,0 +1,259 @@
+'use strict';
+
+/**
+  Sandbox APIs mimicking communications with the Go and Juju backends.
+
+  @module env
+  @submodule env.sandbox
+ */
+
+YUI.add('juju-env-sandbox', function(Y) {
+
+  var sandboxModule = Y.namespace('juju.environments.sandbox');
+  var CLOSEDERROR = 'INVALID_STATE_ERR : Connection is closed.';
+
+  /**
+   * A client connection for interacting with a sandbox environment.
+   *
+   * @class ClientConnection
+   */
+  function ClientConnection(config) {
+    ClientConnection.superclass.constructor.apply(this, arguments);
+  }
+
+  ClientConnection.NAME = 'sandbox-client-connection';
+  ClientConnection.ATTRS = {
+    juju: {} // Required.
+  };
+
+  Y.extend(ClientConnection, Y.Base, {
+
+    /**
+      Initialize.
+
+      @method initializer
+      @return {undefined} Nothing.
+     */
+    initializer: function() {
+      this.connected = false;
+    },
+
+    /**
+      React to a new message from Juju.
+      You are expected to monkeypatch this method, as with websockets.
+
+      @method onmessage
+      @param {Object} event An object with a JSON string on the "data"
+        attribute.
+      @return {undefined} Nothing.
+     */
+    onmessage: function(event) {},
+
+    /**
+      Immediately give message to listener (contrast with receive).
+      Uses onmessage to deliver message, as with websockets.
+
+      @method receiveNow
+      @param {Object} data An object to be sent as JSON to the listener.
+      @return {undefined} Nothing.
+     */
+    receiveNow: function(data) {
+      if (this.connected) {
+        this.onmessage({data: Y.JSON.stringify(data)});
+      } else {
+        throw CLOSEDERROR;
+      }
+    },
+
+    /**
+      Give message to listener asynchronously (contrast with receiveNow).
+      Uses onmessage to deliver message, as with websockets.
+
+      @method receive
+      @param {Object} data An object to be sent as JSON to the listener.
+      @return {undefined} Nothing.
+     */
+    receive: function(data) {
+      if (this.connected) {
+        // 4 milliseconds is the smallest effective time available to wait.  See
+        // http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#timers
+        setTimeout(this.receiveNow.bind(this, data), 4);
+      } else {
+        throw CLOSEDERROR;
+      }
+    },
+
+    /**
+      Send a JSON string to the API.
+
+      @method send
+      @param {String} data A JSON string of the data to be sent.
+      @return {undefined} Nothing.
+     */
+    send: function(data) {
+      if (this.connected) {
+        this.get('juju').receive(Y.JSON.parse(data));
+      } else {
+        throw CLOSEDERROR;
+      }
+    },
+
+    /**
+      React to an opening connection.
+      You are expected to monkeypatch this method, as with websockets.
+
+      @method onopen
+      @return {undefined} Nothing.
+     */
+    onopen: function() {},
+
+    /**
+      Explicitly open the connection.
+      This does not have an analog with websockets, but requiring an explicit
+      "open" means less magic is necessary.  It is responsible for changing
+      the "connected" state, for calling the onopen hook, and for calling
+      the sandbox juju.open with itself.
+
+      @method open
+      @return {undefined} Nothing.
+     */
+    open: function() {
+      if (!this.connected) {
+        this.connected = true;
+        this.get('juju').open(this);
+        this.onopen();
+      }
+    },
+
+    /**
+      React to a closing connection.
+      You are expected to monkeypatch this method, as with websockets.
+
+      @method onclose
+      @return {undefined} Nothing.
+     */
+    onclose: function() {},
+
+    /**
+      Close the connection.
+      This is responsible for changing the "connected" state, for calling the
+      onclosed hook, and for calling the sandbox juju.close.
+
+      @method close
+      @return {undefined} Nothing.
+     */
+    close: function() {
+      if (this.connected) {
+        this.connected = false;
+        this.get('juju').close();
+        this.onclose();
+      }
+    }
+
+  });
+
+  sandboxModule.ClientConnection = ClientConnection;
+
+  /**
+   * A sandbox Juju environment using the Python API.
+   *
+   * @class PyJujuAPI
+   */
+  function PyJujuAPI(config) {
+    PyJujuAPI.superclass.constructor.apply(this, arguments);
+  }
+
+  PyJujuAPI.NAME = 'sandbox-py-juju-api';
+  PyJujuAPI.ATTRS = {
+    state: {}, // Required.
+    client: {} // Set in the "open" method.
+  };
+
+  Y.extend(PyJujuAPI, 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);
+        var state = this.get('state');
+        client.receive({
+          ready: true,
+          provider_type: state.get('providerType'),
+          default_series: state.get('defaultSeries')
+        });
+      } 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() {
+      this.connected = false;
+      this.set('client', undefined);
+    },
+
+    /**
+      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) {
+      // Make a shallow copy of the received data because handlers will mutate
+      // it to add an "err" or "result".
+      if (this.connected) {
+        this['performOp_' + data.op](Y.merge(data));
+      } else {
+        throw CLOSEDERROR;
+      }
+    },
+
+    /**
+      Handles login operations from the client.  Called by "receive".
+      client.receive will receive all sent values back, transparently,
+      plus a "result" value that will be true or false, representing whether
+      the authentication succeeded or failed.
+
+      @method performOp_login
+      @param {Object} data A hash minimally of user and password.
+      @return {undfefined} Nothing.
+     */
+    performOp_login: function(data) {
+      data.result = this.get('state').login(data.user, data.password);
+      this.get('client').receive(data);
+    }
+  });
+
+  sandboxModule.PyJujuAPI = PyJujuAPI;
+
+}, '0.1.0', {
+  requires: [
+    'base',
+    'json-parse'
+  ]
+});

=== modified file 'test/index.html'
--- test/index.html	2013-03-13 21:13:05 +0000
+++ test/index.html	2013-03-20 15:20:29 +0000
@@ -59,6 +59,7 @@
   <script src="test_panzoom.js"></script>
   <script src="test_prettify.js"></script>
   <script src="test_routing.js"></script>
+  <script src="test_sandbox.js"></script>
   <script src="test_service_config_view.js"></script>
   <script src="test_service_module.js"></script>
   <script src="test_service_view.js"></script>

=== modified file 'test/test_app.js'
--- test/test_app.js	2013-03-13 17:59:29 +0000
+++ test/test_app.js	2013-03-20 15:20:29 +0000
@@ -191,6 +191,7 @@
 
     it('should avoid trying to login if the env is not connected',
        function(done) {
+         conn.transient_close();
          var app = new Y.juju.App({env: env});
          app.after('ready', function() {
            assert.equal(0, conn.messages.length);

=== modified file 'test/test_env.js'
--- test/test_env.js	2013-02-15 12:29:14 +0000
+++ test/test_env.js	2013-03-20 15:20:29 +0000
@@ -41,4 +41,30 @@
 
   });
 
+  describe('Base Environment', function() {
+    var requires = ['juju-env-base', 'juju-env-sandbox'];
+    var environments, juju, Y, sandboxModule, ClientConnection;
+
+    before(function(done) {
+      Y = YUI(GlobalConfig).use(requires, function(Y) {
+        juju = Y.namespace('juju');
+        environments = juju.environments;
+        sandboxModule = Y.namespace('juju.environments.sandbox');
+        ClientConnection = sandboxModule.ClientConnection;
+        done();
+      });
+    });
+
+    it('calls "open" on connection if available.', function() {
+      var conn = new ClientConnection({juju: {open: function() {}}});
+      var env = new environments.BaseEnvironment({conn: conn});
+      assert.isFalse(conn.connected);
+      assert.isFalse(env.get('connected'));
+      env.connect();
+      assert.isTrue(conn.connected);
+      assert.isTrue(env.get('connected'));
+    });
+
+  });
+
 })();

=== modified file 'test/test_fakebackend.js'
--- test/test_fakebackend.js	2013-03-19 14:14:15 +0000
+++ test/test_fakebackend.js	2013-03-20 15:20:29 +0000
@@ -369,15 +369,7 @@
     });
 
     it('reports no changes initially.', function() {
-      assert.deepEqual(
-          fakebackend.nextChanges(),
-          {
-            services: {},
-            machines: {},
-            units: {},
-            relations: {}
-          }
-      );
+      assert.isNull(fakebackend.nextChanges());
     });
 
     it('reports a call to addUnit correctly.', function() {
@@ -430,15 +422,7 @@
           fakebackend.deploy('cs:wordpress', callback);
           assert.isUndefined(deployResult.error);
           assert.isObject(fakebackend.nextChanges());
-          assert.deepEqual(
-              fakebackend.nextChanges(),
-              {
-                services: {},
-                machines: {},
-                units: {},
-                relations: {}
-              }
-          );
+          assert.isNull(fakebackend.nextChanges());
         }
     );
 

=== added file 'test/test_sandbox.js'
--- test/test_sandbox.js	1970-01-01 00:00:00 +0000
+++ test/test_sandbox.js	2013-03-20 15:20:29 +0000
@@ -0,0 +1,308 @@
+'use strict';
+
+(function() {
+
+  describe('sandbox.ClientConnection', function() {
+    var requires = ['juju-env-sandbox', 'json-stringify'];
+    var Y, sandboxModule, ClientConnection;
+
+    before(function(done) {
+      Y = YUI(GlobalConfig).use(requires, function(Y) {
+        sandboxModule = Y.namespace('juju.environments.sandbox');
+        ClientConnection = sandboxModule.ClientConnection;
+        done();
+      });
+    });
+
+    it('opens successfully in isolation.', function() {
+      var receivedFromOpen;
+      var jujuopen = function(client) {
+        receivedFromOpen = client;
+      };
+      var conn = new ClientConnection({juju: {open: jujuopen}});
+      var onopenFlag = false;
+      conn.onopen = function() {
+        onopenFlag = true;
+      };
+      assert.isFalse(conn.connected);
+      conn.open();
+      assert.isTrue(conn.connected);
+      assert.isTrue(onopenFlag);
+      assert.strictEqual(receivedFromOpen, conn);
+    });
+
+    it('silently ignores requests to open when already open.', function() {
+      // This is the preparation.
+      var jujuopenFlag = false;
+      var jujuopen = function() {
+        jujuopenFlag = true;
+      };
+      var conn = new ClientConnection({juju: {open: jujuopen}});
+      assert.isFalse(conn.connected);
+      conn.open();
+      jujuopenFlag = false;
+      var onopenFlag = false;
+      conn.onopen = function() {
+        onopenFlag = true;
+      };
+      // This is the test.
+      conn.open();
+      assert.isTrue(conn.connected);
+      assert.isFalse(onopenFlag);
+      assert.isFalse(jujuopenFlag);
+    });
+
+    it('closes successfully in isolation.', function() {
+      var jujuclosedFlag;
+      var jujuclosed = function() {
+        jujuclosedFlag = true;
+      };
+      var conn = new ClientConnection({
+        juju: {
+          open: function() {},
+          close: jujuclosed
+        }
+      });
+      conn.open();
+      assert.isTrue(conn.connected);
+      var oncloseFlag = false;
+      conn.onclose = function() {
+        oncloseFlag = true;
+      };
+      conn.close();
+      assert.isFalse(conn.connected);
+      assert.isTrue(oncloseFlag);
+      assert.isTrue(jujuclosedFlag);
+    });
+
+    it('silently ignores requests to close when already closed', function() {
+      var jujuclosedFlag = false;
+      var jujuclosed = function() {
+        jujuclosedFlag = true;
+      };
+      var conn = new ClientConnection({
+        juju: {
+          open: function() {},
+          close: jujuclosed
+        }
+      });
+      assert.isFalse(conn.connected);
+      var oncloseFlag = false;
+      conn.onclose = function() {
+        oncloseFlag = true;
+      };
+      conn.close();
+      assert.isFalse(conn.connected);
+      assert.isFalse(oncloseFlag);
+      assert.isFalse(jujuclosedFlag);
+    });
+
+    it('sends messages to the API.', function() {
+      var received;
+      var sent = {response: 42, foo: ['bar', 'shazam']};
+      var conn = new ClientConnection({
+        juju: {
+          open: function() {},
+          receive: function(data) {received = data;}
+        }
+      });
+      conn.open();
+      conn.send(Y.JSON.stringify(sent));
+      assert.deepEqual(received, sent);
+    });
+
+    it('can receive messages from the API immediately.', function() {
+      var data = {sample: 'foo', bar: [42, 36]};
+      var conn = new ClientConnection({juju: {open: function() {}}});
+      var received;
+      conn.onmessage = function(event) {received = event;};
+      conn.open();
+      conn.receiveNow(data);
+      assert.isString(received.data);
+      assert.deepEqual(Y.JSON.parse(received.data), data);
+    });
+
+    it('receives messages from the API asynchronously.', function(done) {
+      var data = {sample: 'foo', bar: [42, 36]};
+      var conn = new ClientConnection({juju: {open: function() {}}});
+      var isAsync = false;
+      conn.onmessage = function(received) {
+        assert.isString(received.data);
+        assert.deepEqual(Y.JSON.parse(received.data), data);
+        assert.isTrue(isAsync);
+        done();
+      };
+      conn.open();
+      conn.receive(data);
+      isAsync = true;
+    });
+
+    it('refuses to send messages when not connected.', function() {
+      var conn = new ClientConnection({juju: {open: function() {}}});
+      assert.throws(
+          conn.send.bind(conn, {response: 42}),
+          'INVALID_STATE_ERR : Connection is closed.');
+    });
+
+    it('refuses to receive immediately when not connected.', function() {
+      var conn = new ClientConnection({juju: {open: function() {}}});
+      assert.throws(
+          conn.receiveNow.bind(conn, {response: 42}),
+          'INVALID_STATE_ERR : Connection is closed.');
+    });
+
+    it('refuses to receive asynchronously when not connected.', function() {
+      var conn = new ClientConnection({juju: {open: function() {}}});
+      assert.throws(
+          conn.receive.bind(conn, {response: 42}),
+          'INVALID_STATE_ERR : Connection is closed.');
+    });
+
+  });
+
+  describe('sandbox.PyJujuAPI', function() {
+    var requires = [
+      'juju-env-sandbox', 'juju-env-fakebackend', 'juju-env-python'];
+    var Y, sandboxModule, ClientConnection, PyJujuAPI, environmentsModule,
+        state, juju, client, env;
+
+    before(function(done) {
+      Y = YUI(GlobalConfig).use(requires, function(Y) {
+        sandboxModule = Y.namespace('juju.environments.sandbox');
+        environmentsModule = Y.namespace('juju.environments');
+        done();
+      });
+    });
+
+    beforeEach(function() {
+      state = new environmentsModule.FakeBackend();
+      juju = new sandboxModule.PyJujuAPI({state: state});
+      client = new sandboxModule.ClientConnection({juju: juju});
+      env = new environmentsModule.PythonEnvironment({conn: client});
+    });
+
+    afterEach(function() {
+      env.destroy();
+      client.destroy();
+      juju.destroy();
+      state.destroy();
+    });
+
+    it('opens successfully.', function(done) {
+      var isAsync = false;
+      client.onmessage = function(message) {
+        assert.isTrue(isAsync);
+        assert.deepEqual(
+            Y.JSON.parse(message.data),
+            {
+              ready: true,
+              provider_type: 'demonstration',
+              default_series: 'precise'
+            });
+        done();
+      };
+      assert.isFalse(juju.connected);
+      assert.isUndefined(juju.get('client'));
+      client.open();
+      assert.isTrue(juju.connected);
+      assert.strictEqual(juju.get('client'), client);
+      isAsync = true;
+    });
+
+    it('ignores "open" when already open to same client.', function() {
+      client.receive = function() {
+        assert.fail('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.fail 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: assert.fail});
+      assert.throws(
+          client.open.bind(client),
+          'INVALID_STATE_ERR : Connection is open to another client.');
+    });
+
+    it('closes successfully.', function(done) {
+      client.onmessage = function() {
+        client.close();
+        assert.isFalse(juju.connected);
+        assert.isUndefined(juju.get('client'));
+        done();
+      };
+      client.open();
+    });
+
+    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 = {op: 'testingTesting123', foo: 'bar'};
+      juju.performOp_testingTesting123 = 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 = {
+        op: 'login',
+        user: 'admin',
+        password: 'password',
+        request_id: 42
+      };
+      client.onmessage = function(received) {
+        // First message is the provider type and default series.  We ignore
+        // it, and prepare for the next one, which will be the reply to our
+        // login.
+        client.onmessage = function(received) {
+          data.result = true;
+          assert.deepEqual(Y.JSON.parse(received.data), data);
+          assert.isTrue(state.get('authenticated'));
+          done();
+        };
+        client.send(Y.JSON.stringify(data));
+      };
+      client.open();
+    });
+
+    it('can log in (environment integration).', function(done) {
+      env.after('defaultSeriesChange', function() {
+        // See FakeBackend's authorizedUsers for these default values.
+        env.setCredentials({user: 'admin', password: 'password'});
+        env.after('login', function() {
+          assert.isTrue(env.userIsAuthenticated);
+          done();
+        });
+        env.login();
+      });
+      env.connect();
+    });
+
+  });
+
+})();