Implemented add-relation for the fakebackend

test/test_fakebackend.js

 'use strict';
 
 (function() {
+
+  // Helpers
+  // Verify that an expected Error was found.
+  var ERROR = function(errString, done) {
+    return function(result) {
+      assert.equal(errString, result.error);
+      done();
+    };
+  };
+
 
   describe('FakeBackend.login', function() {
     var requires = ['node', 'juju-env-fakebackend'];
     var Y, environmentsModule, fakebackend;
 
     before(function(done) {
       Y = YUI(GlobalConfig).use(requires, function(Y) {
         environmentsModule = Y.namespace('juju.environments');
         done();
       });
@@ skipping 65 matching lines @@
       assert.isObject(service);
       assert.strictEqual(service, result.service);
       var attrs = service.getAttrs();
       // clientId varies.
       assert.isTrue(Y.Lang.isString(attrs.clientId));
       delete attrs.clientId;
       assert.deepEqual(attrs, {
         aggregated_status: undefined,
         charm: 'cs:precise/wordpress-10',
         config: undefined,
-        constraints: undefined,
+        constraints: {},
         destroyed: false,
         displayName: 'wordpress',
         exposed: false,
         id: 'wordpress',
         initialized: true,
         name: 'wordpress',
         pending: false,
         subordinate: false,
         unit_count: undefined
       });
@@ skipping 107 matching lines @@
           callback,
           {configYAML: 'auto_id: %n'});
       assert.equal(
           result.error,
           'Error parsing YAML.\n' +
           'JS-YAML: end of the stream or a document separator is expected ' +
           'at line 1, column 10:\n' +
           '    auto_id: %n\n' +
           '             ^');
     });
-
+  });
+
+  describe('FakeBackend.uniformOperations', function() {
+    var requires = [
+      'node', 'juju-tests-utils', 'juju-models', 'juju-charm-models'];
+    var Y, fakebackend, utils, setCharm;
+
+    before(function(done) {
+      Y = YUI(GlobalConfig).use(requires, function(Y) {
+        utils = Y.namespace('juju-tests.utils');
+        done();
+      });
+    });
+
+    beforeEach(function() {
+      var setupData = utils.makeFakeBackendWithCharmStore();
+      fakebackend = setupData.fakebackend;
+      setCharm = setupData.setCharm;
+    });
+
+    afterEach(function() {
+      fakebackend.destroy();
+    });
+
+    describe('FakeBackend.resolved', function(done) {
+
+      it('rejects unauthenticated calls', function() {
+        fakebackend.logout();
+        var result = fakebackend.resolved('wordpress/0');
+        assert.equal(result.error, 'Please log in.');
+      });
+
+      it('reports invalid untis', function() {
+        var result = fakebackend.resolved('wordpress/0');
+        assert.equal(result.error, 'Unit "wordpress/0" does not exist.');
+      });
+
+      it('reports invalid relations', function(done) {
+        fakebackend.deploy('cs:wordpress', function() {
+          var result = fakebackend.resolved('wordpress/0', 'db');
+          assert.equal(result.error, 'Relation db not found for wordpress/0');
+          done();
+        });
+      });
+    });
+
+    describe('FakeBackend.getCharm', function() {
+      it('rejects unauthenticated calls', function(done) {
+        fakebackend.logout();
+        fakebackend.getCharm('cs:wordpress', ERROR('Please log in.', done));
+      });
+
+      it('disallows malformed charm names', function(done) {
+        fakebackend.getCharm('^invalid', ERROR('Invalid charm id.', done));
+      });
+
+      it('successfully returns valid charms', function(done) {
+        fakebackend.getCharm('cs:wordpress', function(data) {
+          assert.equal(data.result.name, 'wordpress');
+          done();
+        });
+      });
+    });
+
+    describe('FakeBackend.getService', function() {
+      it('rejects unauthenticated calls', function() {
+        fakebackend.logout();
+        var result = fakebackend.getService('cs:wordpress');
+        assert.equal(result.error, 'Please log in.');
+      });
+
+      it('returns an error for a missing service', function() {
+        var result = fakebackend.getService('^invalid');
+        assert.equal(result.error, 'Invalid service id.');
+      });
+
+      it('successfully returns a valid service', function(done) {
+        fakebackend.deploy('cs:wordpress', function() {
+          var service = fakebackend.getService('wordpress').result;
+          assert.equal(service.name, 'wordpress');
+          done();
+        });
+      });
+    });
+
+    describe('FakeBackend.setConfig', function() {
+      it('rejects unauthenticated calls', function() {
+        fakebackend.logout();
+        var result = fakebackend.setConfig('wordpress', {'foo': 'bar'});
+        assert.equal(result.error, 'Please log in.');
+      });
+
+      it('returns an error for a missing service', function() {
+        var result = fakebackend.setConfig('scaling', {});
+        assert.equal(result.error, 'Service \"scaling\" does not exist.');
+      });
+
+      it('successfully returns a valid service configuration', function(done) {
+        fakebackend.deploy('cs:wordpress', function() {
+          fakebackend.setConfig('wordpress', {
+            'blog-title': 'Silence is Golden.'});
+          var service = fakebackend.getService('wordpress').result;
+          var config = service.config;
+          assert.equal(config['blog-title'], 'Silence is Golden.');
+          done();
+        });
+      });
+    });
+
+    describe('FakeBackend.setConstraints', function() {
+      it('rejects unauthenticated calls', function() {
+        fakebackend.logout();
+        var result = fakebackend.setConstraints('wordpress', {'cpu': '4'});
+        assert.equal(result.error, 'Please log in.');
+      });
+
+      it('returns an error for a missing service', function() {
+        var result = fakebackend.setConstraints('scaling', {});
+        assert.equal(result.error, 'Service \"scaling\" does not exist.');
+      });
+
+      it('successfully returns a valid constraints', function(done) {
+        fakebackend.deploy('cs:wordpress', function() {
+          fakebackend.setConstraints('wordpress', {'cpu': '4'});
+          var service = fakebackend.getService('wordpress').result;
+          var constraints = service.constraints;
+          assert.equal(constraints.cpu, '4');
+          assert.equal(constraints.mem, undefined);
+          done();
+        });
+      });
+
+      it('successfully returns a valid constraints as array', function(done) {
+        fakebackend.deploy('cs:wordpress', function() {
+          fakebackend.setConstraints('wordpress', ['cpu=4']);
+          var service = fakebackend.getService('wordpress').result;
+          var constraints = service.constraints;
+          assert.equal(constraints.cpu, '4');
+          assert.equal(constraints.mem, undefined);
+          done();
+        });
+      });
+    });
+
+    describe('FakeBackend.Annotations', function() {
+      it('must require authentication', function() {
+        fakebackend.logout();
+        var reply = fakebackend.getAnnotations('env');
+        assert.equal(reply.error, 'Please log in.');
+      });
+
+      it('must get annotations from a service', function(done) {
+        fakebackend.deploy('cs:wordpress', function() {
+          var service = fakebackend.getService('wordpress').result;
+          assert.equal(service.annotations, undefined);
+          var anno = fakebackend.getAnnotations('wordpress').result;
+          assert.equal(anno, undefined);
+          done();
+        });
+      });
+
+      it('must update annotations to a service', function(done) {
+        fakebackend.deploy('cs:wordpress', function() {
+          fakebackend.updateAnnotations('wordpress',
+                                        {'foo': 'bar', 'gone': 'away'});
+          var anno = fakebackend.getAnnotations('wordpress').result;
+          assert.equal(anno.foo, 'bar');
+          assert.equal(anno.gone, 'away');
+
+          // Apply an update and verify that merge happened.
+          fakebackend.updateAnnotations('wordpress', {'gone': 'too far'});
+          anno = fakebackend.getAnnotations('wordpress').result;
+          assert.equal(anno.foo, 'bar');
+          assert.equal(anno.gone, 'too far');
+          done();
+        });
+      });
+
+      it('must update annotations on a unit', function(done) {
+        fakebackend.deploy('cs:wordpress', function() {
+          fakebackend.updateAnnotations('wordpress/0',
+                                        {'foo': 'bar', 'gone': 'away'});
+          var anno = fakebackend.getAnnotations('wordpress/0').result;
+          assert.equal(anno.foo, 'bar');
+          assert.equal(anno.gone, 'away');
+
+          // Apply an update and verify that merge happened.
+          fakebackend.updateAnnotations('wordpress/0', {'gone': 'too far'});
+          anno = fakebackend.getAnnotations('wordpress/0').result;
+          assert.equal(anno.foo, 'bar');
+          assert.equal(anno.gone, 'too far');
+          done();
+        });
+      });
+
+      it('must update annotations on the environment', function() {
+        fakebackend.updateAnnotations('env',
+                                      {'foo': 'bar', 'gone': 'away'});
+        var anno = fakebackend.getAnnotations('env').result;
+        assert.equal(anno.foo, 'bar');
+        assert.equal(anno.gone, 'away');
+
+        // Apply an update and verify that merge happened.
+        fakebackend.updateAnnotations('env', {'gone': 'too far'});
+        anno = fakebackend.getAnnotations('env').result;
+        assert.equal(anno.foo, 'bar');
+        assert.equal(anno.gone, 'too far');
+
+        // Verify the annotations on the model directly.
+        anno = fakebackend.db.environment.get('annotations');
+        assert.equal(anno.foo, 'bar');
+        assert.equal(anno.gone, 'too far');
+
+        // Verify changes name it into nextAnnotations
+        var changes = fakebackend.nextAnnotations();
+        assert.deepEqual(changes.annotations.env,
+                         [fakebackend.db.environment, true]);
+      });
+
+      it('must remove annotations from a service', function(done) {
+        fakebackend.deploy('cs:wordpress', function() {
+          fakebackend.updateAnnotations('wordpress',
+                                        {'foo': 'bar', 'gone': 'away'});
+          var anno = fakebackend.getAnnotations('wordpress').result;
+          assert.equal(anno.foo, 'bar');
+          assert.equal(anno.gone, 'away');
+
+          // Remove an annotation and verify that happened.
+          fakebackend.removeAnnotations('wordpress', ['gone']);
+          anno = fakebackend.getAnnotations('wordpress').result;
+          assert.equal(anno.foo, 'bar');
+          assert.equal(anno.gone, undefined);
+
+          // Finally remove annotations with falsey keys.
+          fakebackend.removeAnnotations('wordpress');
+          anno = fakebackend.getAnnotations('wordpress').result;
+          assert.deepEqual(anno, {});
+          done();
+        });
+
+      });
+    });
   });
 
   describe('FakeBackend.addUnit', function() {
     var requires = [
       'node', 'juju-tests-utils', 'juju-models', 'juju-charm-models'];
     var Y, fakebackend, utils, setCharm, deployResult, callback;
 
     before(function(done) {
       Y = YUI(GlobalConfig).use(requires, function(Y) {
         utils = Y.namespace('juju-tests.utils');
@@ skipping 42 matching lines @@
     it('defaults to adding just one unit', function() {
       fakebackend.deploy('cs:wordpress', callback);
       assert.isUndefined(deployResult.error);
       assert.lengthOf(
           fakebackend.db.units.get_units_for_service(deployResult.service), 1);
       var result = fakebackend.addUnit('wordpress');
       assert.lengthOf(result.units, 1);
       assert.lengthOf(
           fakebackend.db.units.get_units_for_service(deployResult.service), 2);
       // Units are simple objects, not models.
-      assert.equal(result.units[0].id, 'wordpress/2');
+      assert.equal(result.units[0].id, 'wordpress/1');
       assert.equal(result.units[0].agent_state, 'started');
       assert.deepEqual(
-          result.units[0], fakebackend.db.units.getById('wordpress/2'));
+          result.units[0], fakebackend.db.units.getById('wordpress/1'));
       // Creating units also created/assigned associated machines.  Like units,
       // these are simple objects, not models.
       assert.lengthOf(result.machines, 1);
       assert.equal(
           result.machines[0].machine_id, result.units[0].machine);
       assert.isString(result.machines[0].machine_id);
       assert.isString(result.machines[0].public_address);
       assert.match(
           result.machines[0].public_address, /^[^.]+\.example\.com$/);
       assert.equal(result.machines[0].agent_state, 'running');
-      assert.equal(result.machines[0].instance_state, 'running');
     });
 
     it('adds multiple units', function() {
       fakebackend.deploy('cs:wordpress', callback);
       assert.isUndefined(deployResult.error);
       assert.lengthOf(
           fakebackend.db.units.get_units_for_service(deployResult.service), 1);
       var result = fakebackend.addUnit('wordpress', 5);
       assert.lengthOf(result.units, 5);
       assert.lengthOf(
           fakebackend.db.units.get_units_for_service(deployResult.service), 6);
-      assert.equal(result.units[0].id, 'wordpress/2');
-      assert.equal(result.units[1].id, 'wordpress/3');
-      assert.equal(result.units[2].id, 'wordpress/4');
-      assert.equal(result.units[3].id, 'wordpress/5');
-      assert.equal(result.units[4].id, 'wordpress/6');
+      assert.equal(result.units[0].id, 'wordpress/1');
+      assert.equal(result.units[1].id, 'wordpress/2');
+      assert.equal(result.units[2].id, 'wordpress/3');
+      assert.equal(result.units[3].id, 'wordpress/4');
+      assert.equal(result.units[4].id, 'wordpress/5');
       assert.lengthOf(result.machines, 5);
     });
 
   });
 
-  describe('FakeBackend.nextChanges', function() {
+  describe('FakeBackend.next*', function() {
     var requires = [
       'node', 'juju-tests-utils', 'juju-models', 'juju-charm-models'];
     var Y, fakebackend, utils, setCharm, deployResult, callback;
 
     before(function(done) {
       Y = YUI(GlobalConfig).use(requires, function(Y) {
         utils = Y.namespace('juju-tests.utils');
         done();
       });
     });
 
     beforeEach(function() {
       var setupData = utils.makeFakeBackendWithCharmStore();
       fakebackend = setupData.fakebackend;
       setCharm = setupData.setCharm;
       deployResult = undefined;
       callback = function(response) { deployResult = response; };
     });
 
     afterEach(function() {
       fakebackend.destroy();
     });
 
-    it('rejects unauthenticated calls.', function() {
-      fakebackend.logout();
-      var result = fakebackend.nextChanges();
-      assert.equal(result.error, 'Please log in.');
-    });
-
-    it('reports no changes initially.', function() {
-      assert.isNull(fakebackend.nextChanges());
-    });
-
-    it('reports a call to addUnit correctly.', function() {
-      fakebackend.deploy('cs:wordpress', callback);
-      assert.isUndefined(deployResult.error);
-      assert.isObject(fakebackend.nextChanges());
-      var result = fakebackend.addUnit('wordpress');
-      assert.lengthOf(result.units, 1);
-      var changes = fakebackend.nextChanges();
-      assert.lengthOf(Y.Object.keys(changes.services), 0);
-      assert.lengthOf(Y.Object.keys(changes.units), 1);
-      assert.lengthOf(Y.Object.keys(changes.machines), 1);
-      assert.lengthOf(Y.Object.keys(changes.relations), 0);
-      assert.deepEqual(
-          changes.units['wordpress/2'], [result.units[0], true]);
-      assert.deepEqual(
-          changes.machines[result.machines[0].machine_id],
-          [result.machines[0], true]);
-    });
-
-    it('reports a deploy correctly.', function() {
-      fakebackend.deploy('cs:wordpress', callback);
-      assert.isUndefined(deployResult.error);
-      var changes = fakebackend.nextChanges();
-      assert.lengthOf(Y.Object.keys(changes.services), 1);
-      assert.deepEqual(
-          changes.services.wordpress, [deployResult.service, true]);
-      assert.lengthOf(Y.Object.keys(changes.units), 1);
-      assert.deepEqual(
-          changes.units['wordpress/1'], [deployResult.units[0], true]);
-      assert.lengthOf(Y.Object.keys(changes.machines), 1);
-      assert.deepEqual(
-          changes.machines[deployResult.machines[0].machine_id],
-          [deployResult.machines[0], true]);
-      assert.lengthOf(Y.Object.keys(changes.relations), 0);
-    });
-
-    it('reports a deploy of multiple units correctly.', function() {
-      fakebackend.deploy('cs:wordpress', callback, {unitCount: 5});
-      assert.isUndefined(deployResult.error);
-      var changes = fakebackend.nextChanges();
-      assert.lengthOf(Y.Object.keys(changes.services), 1);
-      assert.lengthOf(Y.Object.keys(changes.units), 5);
-      assert.lengthOf(Y.Object.keys(changes.machines), 5);
-      assert.lengthOf(Y.Object.keys(changes.relations), 0);
-    });
-
-    it('reports no changes when no changes have occurred since the last call.',
-        function() {
-          fakebackend.deploy('cs:wordpress', callback);
-          assert.isUndefined(deployResult.error);
-          assert.isObject(fakebackend.nextChanges());
-          assert.isNull(fakebackend.nextChanges());
-        }
-    );
-
+    describe('FakeBackend.nextChanges', function() {
+      it('rejects unauthenticated calls.', function() {
+        fakebackend.logout();
+        var result = fakebackend.nextChanges();
+        assert.equal(result.error, 'Please log in.');
+      });
+
+      it('reports no changes initially.', function() {
+        assert.isNull(fakebackend.nextChanges());
+      });
+
+      it('reports a call to addUnit correctly.', function() {
+        fakebackend.deploy('cs:wordpress', callback);
+        assert.isUndefined(deployResult.error);
+        assert.isObject(fakebackend.nextChanges());
+        var result = fakebackend.addUnit('wordpress');
+        assert.lengthOf(result.units, 1);
+        var changes = fakebackend.nextChanges();
+        assert.lengthOf(Y.Object.keys(changes.services), 0);
+        assert.lengthOf(Y.Object.keys(changes.units), 1);
+        assert.lengthOf(Y.Object.keys(changes.machines), 1);
+        assert.lengthOf(Y.Object.keys(changes.relations), 0);
+        assert.deepEqual(
+            changes.units['wordpress/1'], [result.units[0], true]);
+        assert.deepEqual(
+            changes.machines[result.machines[0].machine_id],
+            [result.machines[0], true]);
+      });
+
+      it('reports a deploy correctly.', function() {
+        fakebackend.deploy('cs:wordpress', callback);
+        assert.isUndefined(deployResult.error);
+        var changes = fakebackend.nextChanges();
+        assert.lengthOf(Y.Object.keys(changes.services), 1);
+        assert.deepEqual(
+            changes.services.wordpress, [deployResult.service, true]);
+        assert.lengthOf(Y.Object.keys(changes.units), 1);
+        assert.deepEqual(
+            changes.units['wordpress/0'], [deployResult.units[0], true]);
+        assert.lengthOf(Y.Object.keys(changes.machines), 1);
+        assert.deepEqual(
+            changes.machines[deployResult.machines[0].machine_id],
+            [deployResult.machines[0], true]);
+        assert.lengthOf(Y.Object.keys(changes.relations), 0);
+      });
+
+      it('reports a deploy of multiple units correctly.', function() {
+        fakebackend.deploy('cs:wordpress', callback, {unitCount: 5});
+        assert.isUndefined(deployResult.error);
+        var changes = fakebackend.nextChanges();
+        assert.lengthOf(Y.Object.keys(changes.services), 1);
+        assert.lengthOf(Y.Object.keys(changes.units), 5);
+        assert.lengthOf(Y.Object.keys(changes.machines), 5);
+        assert.lengthOf(Y.Object.keys(changes.relations), 0);
+      });
+
+      it('reports no changes when no changes have occurred.',
+          function() {
+            fakebackend.deploy('cs:wordpress', callback);
+            assert.isUndefined(deployResult.error);
+            assert.isObject(fakebackend.nextChanges());
+            assert.isNull(fakebackend.nextChanges());
+          }
+      );
+    });
+
+    describe('FakeBackend.nextAnnotations', function() {
+      it('rejects unauthenticated calls.', function() {
+        fakebackend.logout();
+        var result = fakebackend.nextAnnotations();
+        assert.equal(result.error, 'Please log in.');
+      });
+
+      it('reports no changes initially.', function() {
+        assert.isNull(fakebackend.nextAnnotations());
+      });
+
+      it('reports service changes correctly', function(done) {
+        fakebackend.deploy('cs:wordpress', function() {
+          fakebackend.updateAnnotations('wordpress',
+                                        {'foo': 'bar', 'gone': 'away'});
+
+          var changes = fakebackend.nextAnnotations();
+          assert.deepEqual(changes.services.wordpress,
+                           [fakebackend.db.services.getById('wordpress'),
+                true]);
+          done();
+        });
+      });
+
+      it('reports env changes correctly', function() {
+        fakebackend.updateAnnotations('env',
+                                      {'foo': 'bar', 'gone': 'away'});
+
+        // Verify changes name it into nextAnnotations
+        var changes = fakebackend.nextAnnotations();
+        assert.deepEqual(changes.annotations.env,
+                         [fakebackend.db.environment, true]);
+      });
+    });
   });
 
   describe('FakeBackend.addRelation', function() {
     var requires = [
       'node', 'juju-tests-utils', 'juju-models', 'juju-charm-models'];
     var Y, fakebackend, utils, setCharm, deployResult, callback;
 
     before(function(done) {
       Y = YUI(GlobalConfig).use(requires, function(Y) {
         utils = Y.namespace('juju-tests.utils');
@@ skipping 71 matching lines @@
     it('can create a relation with an inferred subordinate charm', function() {
       // TODO
     });
 
     it('can create a relation with an inferred interface', function() {
       // TODO
     });
 
 
   });
+
 })();