Merge branch 'release/0.0.3' into production

Author: ritch

index.js

@@ -1,7 +1,7 @@
 var _describe = {};
 var _it = {};
 var _beforeEach = {};
-var helpers = module.exports = {
+var helpers = exports = module.exports = {
   describe: _describe,
   it: _it,
   beforeEach: _beforeEach
@@ -79,7 +79,7 @@ _beforeEach.withArgs = function() {
 }
 
 _beforeEach.givenModel = function(modelName, attrs, optionalHandler) {
-  var modelKey = modelName;
+  var modelKey = modelName
 
   if(typeof attrs === 'funciton') {
     optionalHandler = attrs;
@@ -94,6 +94,8 @@ _beforeEach.givenModel = function(modelName, attrs, optionalHandler) {
 
   var model = loopback.getModel(modelName);
 
+  assert(model, 'cannot get model of name ' + modelName);
+
   beforeEach(function(done) {
     var test = this;
 
@@ -132,6 +134,29 @@ _beforeEach.givenUser = function(attrs, optionalHandler) {
   _beforeEach.givenModel('user', attrs, optionalHandler);
 }
 
+_beforeEach.givenLoggedInUser = function(credentials, optionalHandler) {
+  _beforeEach.givenUser(credentials, function(done) {
+    var test = this;
+    this.user.constructor.login(credentials, function(err, token) {
+      if(err) {
+        done(err);
+      } else {
+        test.loggedInAccessToken = token;
+        done();
+      }
+    });
+  });
+
+  afterEach(function(done) {
+    var test = this;
+    this.loggedInAccessToken.destroy(function(err) {
+      if(err) return done(err);
+      test.loggedInAccessToken = undefined;
+      done();
+    });
+  });
+}
+
 _beforeEach.givenAnUnauthenticatedToken = function(attrs, optionalHandler) {
   _beforeEach.givenModel('accessToken', attrs, optionalHandler);
 }
@@ -158,14 +183,12 @@ _describe.whenCalledRemotely = function(verb, url, cb) {
       if(methodForVerb === 'delete') methodForVerb = 'del';
 
       this.http = this.request[methodForVerb](this.url);
-
-      // request settings
+      this.url = undefined;
       this.http.set('Accept', 'application/json');
-      this.http.set('authorization', null);
-      if(this.accessToken) {
-        this.http.set('authorization', this.accessToken.id);
+      if(this.loggedInAccessToken) {
+        this.http.set('authorization', this.loggedInAccessToken.id);
       }
-
+      this.req = this.http.req;
       var test = this;
       this.http.end(function(err) {
         test.req = test.http.req;
@@ -179,49 +202,31 @@ _describe.whenCalledRemotely = function(verb, url, cb) {
   });
 }
 
+_describe.whenLoggedInAsUser = function(credentials, cb) {
+  describe('when logged in as user', function () {
+    _beforeEach.givenLoggedInUser(credentials);
+    cb();
+  });
+}
+
 _describe.whenCalledByUser = function(credentials, verb, url, cb) {
-  _describe.whenLoggedInAsUser(credentials, function() {
+  describe('when called by logged in user', function () {
+    _beforeEach.givenLoggedInUser(credentials);
     _describe.whenCalledRemotely(verb, url, cb);
   });
 }
 
 _describe.whenCalledAnonymously = function(verb, url, cb) {
-  _describe.whenCalledRemotely(verb, url, function() {
+  describe('when called anonymously', function () {
     _beforeEach.givenAnAnonymousToken();
-    cb();
+    _describe.whenCalledRemotely(verb, url, cb);
   });
 }
 
 _describe.whenCalledUnauthenticated = function(verb, url, cb) {
-  _describe.whenCalledRemotely(verb, url, function() {
-    _beforeEach.givenAnUnauthenticatedToken();
-    cb();
-  });
-}
-
-_describe.whenLoggedInAsUser = function(credentials, cb) {
-  describe('when logged in user', function() {
-    _beforeEach.givenUser(credentials, function(done) {
-      var test = this;
-      this.user.constructor.login(credentials, function(err, token) {
-        if(err) {
-          done(err);
-        } else {
-          test.accessToken = token;
-          done();
-        }
-      });
-    });
-
-    afterEach(function(done) {
-      this.accessToken.destroy(done);
-    });
-    
-    afterEach(function() {
-      this.accessToken = undefined;
-    });
-
-    cb();
+  describe('when called with unauthenticated token', function () {
+    _beforeEach.givenAnAnonymousToken();
+    _describe.whenCalledRemotely(verb, url, cb);
   });
 }
 
@@ -241,6 +246,13 @@ _it.shouldBeDenied = function() {
   });
 }
 
+_it.shouldNotBeFound = function() {
+  it('should not be found', function() {
+    assert(this.res);
+    assert.equal(this.res.statusCode, 404);
+  });
+}
+
 _it.shouldBeAllowedWhenCalledAnonymously =
 function(verb, url) {
   _describe.whenCalledAnonymously(verb, url, function() {
@@ -282,3 +294,5 @@ function(credentials, verb, url) {
     _it.shouldBeDenied();
   });
 }
+
+exports.TestDataBuilder = require('./lib/test-data-builder');

lib/request-builder.js

@@ -0,0 +1,149 @@
+var extend = require('util')._extend;
+var async = require('async');
+
+module.exports = exports = TestFLow;
+
+/**
+ * Make HTTP requests against loopback apps.
+ *
+ * Usage:
+ * ```js
+
+ * ```
+ * @constructor
+ */
+function TestFLow() {
+  this._definitions = [];
+}
+
+/**
+ * Define a new model instance.
+ * @param {string} name Name of the instance.
+ *   `buildTo()` will save the instance created as context[name].
+ * @param {constructor} Model Model class/constructor.
+ * @param {Object.<string, Object>=} properties
+ *   Properties to set in the object.
+ *   Intelligent default values are supplied by the builder
+ *   for required properties not listed.
+ * @return TestFLow (fluent interface)
+ */
+TestFLow.prototype.define = function(name, Model, properties) {
+  this._definitions.push({
+    name: name,
+    model: Model,
+    properties: properties
+  });
+  return this;
+};
+
+/**
+ * Reference the value of a property from a model instance defined before.
+ * @param {string} path Generally in the form '{name}.{property}', where {name}
+ * is the name passed to `define()` and {property} is the name of
+ * the property to use.
+ */
+TestFLow.ref = function(path) {
+  return new Reference(path);
+};
+
+/**
+ * Asynchronously build all models defined via `define()` and save them in
+ * the supplied context object.
+ * @param {Object.<string, Object>} context The context to object to populate.
+ * @param {function(Error)} callback Callback.
+ */
+TestFLow.prototype.buildTo = function(context, callback) {
+  this._context = context;
+  async.eachSeries(
+    this._definitions,
+    this._buildObject.bind(this),
+    callback);
+};
+
+TestFLow.prototype._buildObject = function(definition, callback) {
+  var defaultValues = this._gatherDefaultPropertyValues(definition.model);
+  var values = extend(defaultValues, definition.properties || {});
+  var resolvedValues = this._resolveValues(values);
+
+  definition.model.create(resolvedValues, function(err, result) {
+    if (err) {
+      console.error(
+        'Cannot build object %j - %s\nDetails: %j',
+        definition,
+        err.message,
+        err.details);
+    } else {
+      this._context[definition.name] = result;
+    }
+
+    callback(err);
+  }.bind(this));
+};
+
+TestFLow.prototype._resolveValues = function(values) {
+  var result = {};
+  for (var key in values) {
+    var val = values[key];
+    if (val instanceof Reference) {
+      val = values[key].resolveFromContext(this._context);
+    }
+    result[key] = val;
+  }
+  return result;
+};
+
+var valueCounter = 0;
+TestFLow.prototype._gatherDefaultPropertyValues = function(Model) {
+  var result = {};
+  Model.forEachProperty(function createDefaultPropertyValue(name) {
+    var prop = Model.definition.properties[name];
+    if (!prop.required) return;
+
+    switch (prop.type) {
+      case String:
+        result[name] = 'a test ' + name + ' #' + (++valueCounter);
+        break;
+      case Number:
+        result[name] = 1230000 + (++valueCounter);
+        break;
+      case Date:
+        result[name] = new Date(
+          2222, 12, 12, // yyyy, mm, dd
+          12, 12, 12,   // hh, MM, ss
+          ++valueCounter // milliseconds
+        );
+        break;
+      case Boolean:
+        // There isn't much choice here, is it?
+        // Let's use "false" to encourage users to be explicit when they
+        // require "true" to turn some flag/behaviour on
+        result[name] = false;
+        break;
+      // TODO: support nested structures - array, object
+    }
+  });
+  return result;
+};
+
+/**
+ * Placeholder for values that will be resolved during build.
+ * @param path
+ * @constructor
+ * @private
+ */
+function Reference(path) {
+  this._path = path;
+}
+
+Reference.prototype.resolveFromContext = function(context) {
+  var elements = this._path.split('.');
+
+  var result = elements.reduce(
+    function(obj, prop) {
+      return obj[prop];
+    },
+    context
+  );
+
+  return result;
+};