Implemented fakebackend remove_relation

app/store/env/fakebackend.js

 'use strict';
 
 /**
 An in-memory fake Juju backend and supporting elements.
 
 @module env
 @submodule env.fakebackend
 */
 
 YUI.add('juju-env-fakebackend', function(Y) {
@@ skipping 186 matching lines @@
           Y.Object.isEmpty(this.annotations.relations) &&
           Y.Object.isEmpty(this.annotations.annotations)) {
         result = null;
       } else {
         result = this.annotations;
         this._resetAnnotations();
       }
       return result;
     },
 
+    /**
+      Takes two string endpoints and splits it into usable parts.
+
+      @method parseEndpointStrings
+      @param {Array} endpoints an array of endpoint strings
+        to split in the format wordpress:db.
+      @return {Object} A hash with four keys: service (the associated
+        service model), charm (the associated charm model for the
+        service), name (the user-defined service name), and type (the
+        charm-author-defined relation type name).
+    */
+    parseEndpointStrings: function(endpoints) {
+      return Y.Array.map(endpoints,
+          function(endpoint) {
+            var epData = endpoint.split(':'),
+                result = { name: epData[0], type: epData[1] };
+            result.service = this.db.services.getById(result.name);
+            if (result.service) {
+              result.charm = this.db.charms.getById(
+                  result.service.get('charm'));
+            }
+            return result;
+          }, this);
+    },
+
 
     /**
     Attempt to log a user in.
 
     @method login
     @param {String} username The id of the user.
     @param {String} submittedPassword The user-submitted password.
     @return {Bool} True if the authentication was successful.
     */
     login: function(username, submittedPassword) {
@@ skipping 472 matching lines @@
 
       return {
         error: error,
         warning: warning
       };
     },
 
     /**
       Add a relation between two services.
 
-      @method add_relation
+      @method addRelation
       @param {String} endpointA A string representation of the service name
         and endpoint connection type ie) wordpress:db.
       @param {String} endpointB A string representation of the service name
         and endpoint connection type ie) wordpress:db.
     */
     addRelation: function(endpointA, endpointB) {
       if (!this.get('authenticated')) {
         return UNAUTHENTICATEDERROR;
       }
       if ((typeof endpointA !== 'string') ||
           (typeof endpointB !== 'string')) {
         return {error: 'Two string endpoint names' +
               ' required to establish a relation'};
       }
 
-      var endpointData = Y.Array.map(
-          [endpointA, endpointB],
-          /**
-            Takes a string endpoint and splits it into usable parts.
-            @method endpointSplit
-            @param {String} endpoint the endpoint to split in the format
-              wordpress:db.
-            @return {Object} A hash with four keys: service (the associated
-              service model), charm (the associated charm model for the
-              service), name (the user-defined service name), and type (the
-              charm-author-defined relation type name).
-          */
-          function(endpoint) {
-            var epData = endpoint.split(':'),
-                result = { name: epData[0], type: epData[1] };
-            result.service = this.db.services.getById(result.name);
-            if (result.service) {
-              result.charm = this.db.charms.getById(
-                  result.service.get('charm'));
-            }
-            return result;
-          },
-          this);
+      // Parses the endpoint strings to extract all required data.
+      var endpointData = this.parseEndpointStrings([endpointA, endpointB]);
 
       // This error should never be hit but it's here JIC
       if (!endpointData[0].charm || !endpointData[1].charm) {
         return {error: 'Charm not loaded.'};
       }
       // If there are matching interfaces this will contain an object of the
       // charm interface type and scope (if supplied).
       var match = findMatch(endpointData);
 
       // If there is an error fetching a valid interface and scope
@@ skipping 40 matching lines @@
           displayName: endpointData[0].type,
           relation: relation
         };
       }
 
       // Fallback error If the relation was not able to be created
       // for any reason other than what has already been checked for.
       return false;
     },
 
+    /**
+      Removes a relation between two services.
+
+      @method removeRelation
+      @param {String} endpointA A string representation of the service name
+        and endpoint connection type ie) wordpress:db.
+      @param {String} endpointB A string representation of the service name
+        and endpoint connection type ie) wordpress:db.
+    */
+    removeRelation: function(endpointA, endpointB) {
+      if (!this.get('authenticated')) {
+        return UNAUTHENTICATEDERROR;
+      }
+      if ((typeof endpointA !== 'string') ||
+          (typeof endpointB !== 'string')) {
+        return {error: 'Two string endpoint names' +
+              ' required to establish a relation'};
+      }
+
+      // Parses the endpoint strings to extract all required data.
+      var endpointData = this.parseEndpointStrings([endpointA, endpointB]);
+
+      // This error should never be hit but it's here JIC
+      if (!endpointData[0].charm || !endpointData[1].charm) {
+        return {error: 'Charm not loaded.'};
+      }
+
+      var relation;
+      this.db.relations.some(function(rel) {
+        var endpoints = rel.getAttrs().endpoints;
+        return [0, 1].some(function(index) {
+          // Check to see if the service names match an existing relation
+          if ((endpoints[index][0] === endpointData[0].name) &&
+              (endpoints[!index + 0][0] === endpointData[1].name)) {
+            // Check to see if the interface names match
+            if ((endpoints[index][1].name === endpointData[0].type) &&
+                (endpoints[!index + 0][1].name === endpointData[1].type)) {
+              relation = rel;
+              return true;
+            }
+          }
+        });
+      });
+
+      if (relation) {
+        // remove the relation from the relation db model list
+        var result = this.db.relations.remove(relation);
+        // add this change to the delta
+        this.changes.relations[relation.get('id')] = [relation, false];
+        return result;
+      } else {
+        return {error: 'Relationship does not exist'};
+      }
+    },
+
     // updateAnnotations: function() {
 
     // },
 
     // getAnnotations: function() {
 
     // },
 
     // removeAnnotations: function() {
 
@@ skipping 110 matching lines @@
       models.setAnnotations(entity, annotations);
 
       // Arrange delta stream updates.
       var annotationGroup = this._getAnnotationGroup(entity);
       // Note that we pass true here, even removing an annotation
       // is recorded as an object change/update.
       this.annotations[annotationGroup][entityName] = [entity, true];
       return {result: true};
     },
 
-    // removeRelation: function() {
+    /**
+      Sets the configuration settings on the supplied service to the supplied
+      config object while leaving the settings untouched if they are not in the
+      supplied config.
 
-    // },
-
+      @method setConfig
+      @param {String} serviceName the service id.
+      @param {Object} config properties to set.
+    */
     setConfig: function(serviceName, config) {
       if (!this.get('authenticated')) {
         return UNAUTHENTICATEDERROR;
       }
       var service = this.db.services.getById(serviceName);
       if (!service) {
         return {error: 'Service "' + serviceName + '" does not exist.'};
       }
 
       var existing = service.get('config');
       if (!existing) {
         existing = {};
       }
 
       if (!config) {
         config = {};
       }
       // Merge new constraints in.
       existing = Y.mix(existing, config, true, undefined, 0, true);
       //TODO: validate the config.
       // Reassign the attr.
       service.set('config', existing);
       // The callback indicates done, we can pass anything back.
       this.changes.services[service.get('id')] = [service, true];
       return {result: existing};
     },
 
+    /**
+      Sets the constraints on a service to restrict the type of machine to be
+      used for the service.
+
+      @method setConstraints
+      @param {String} serviceName the service id.
+      @param {Object | Array} data either an array of strings "foo=bar" or an
+      object {foo: 'bar'}.
+    */
     setConstraints: function(serviceName, data) {
       var constraints = {};
 
       if (!this.get('authenticated')) {
         return UNAUTHENTICATEDERROR;
       }
       var service = this.db.services.getById(serviceName);
       if (!service) {
         return {error: 'Service "' + serviceName + '" does not exist.'};
       }
@@ skipping 65 matching lines @@
 
   Y.namespace('juju.environments').FakeBackend = FakeBackend;
 
 }, '0.1.0', {
   requires: [
     'base',
     'js-yaml',
     'juju-models'
   ]
 });