Finished $http fallback.

Author: jmdobry

CHANGELOG.md

@@ -6,6 +6,7 @@
 ###### Other
 - #199 - Re-implement bindOne & bindAll in js-data-angular (they're missing from js-data)
 - #200 - Need to properly trigger digest where angular-data would have before
+- Added DSHttpAdapter fallback that uses $http if js-data-http isn't loaded
 
 ##### 1.0.0 - 04 October 2014
 

Gruntfile.js

@@ -35,14 +35,14 @@ module.exports = function (grunt) {
       main: {
         options: {
           banner: '/**\n' +
-            '* @author Jason Dobry <jason.dobry@gmail.com>\n' +
-            '* @file js-data-angular.min.js\n' +
-            '* @version <%= pkg.version %> - Homepage <https://www.js-data.io/js-data-angular/>\n' +
-            '* @copyright (c) 2014 Jason Dobry <https://github.com/jmdobry/>\n' +
-            '* @license MIT <https://github.com/js-data/js-data-angular/blob/master/LICENSE>\n' +
-            '*\n' +
-            '* @overview Angular wrapper for js-data.\n' +
-            '*/\n'
+          '* @author Jason Dobry <jason.dobry@gmail.com>\n' +
+          '* @file js-data-angular.min.js\n' +
+          '* @version <%= pkg.version %> - Homepage <https://www.js-data.io/js-data-angular/>\n' +
+          '* @copyright (c) 2014 Jason Dobry <https://github.com/jmdobry/>\n' +
+          '* @license MIT <https://github.com/js-data/js-data-angular/blob/master/LICENSE>\n' +
+          '*\n' +
+          '* @overview Angular wrapper for js-data.\n' +
+          '*/\n'
         },
         files: {
           'dist/js-data-angular.min.js': ['dist/js-data-angular.js']
@@ -63,6 +63,39 @@ module.exports = function (grunt) {
           'dist/js-data-angular.js': ['src/index.js']
         }
       }
+    },
+    karma: {
+      options: {
+        configFile: './karma.conf.js'
+      },
+      dev: {
+        browsers: ['Chrome'],
+        autoWatch: true,
+        singleRun: false,
+        reporters: ['spec'],
+        preprocessors: {}
+      },
+      min: {
+        browsers: ['Firefox', 'PhantomJS'],
+        options: {
+          files: [
+            'bower_components/angular-1.3.2/angular.js',
+            'bower_components/angular-mocks-1.3.2/angular-mocks.js',
+            'bower_components/js-data/dist/js-data.js',
+            'dist/js-data-angular.min.js',
+            'karma.start.js',
+            'test/**/*.js'
+          ]
+        }
+      },
+      ci: {
+        browsers: ['Firefox', 'PhantomJS']
+      }
+    },
+    coveralls: {
+      options: {
+        coverage_dir: 'coverage'
+      }
     }
   });
 
@@ -101,4 +134,5 @@ module.exports = function (grunt) {
   ]);
   grunt.registerTask('go', ['build', 'watch:dist']);
   grunt.registerTask('default', ['build']);
+  grunt.registerTask('test', ['build', 'karma:min']);
 };

bower.json

@@ -2,11 +2,11 @@
   "author": "Jason Dobry",
   "name": "js-data-angular",
   "description": "Angular wrapper for js-data (originally angular-data).",
-  "version": "2.0.0-alpha.1-0",
+  "version": "2.0.0-alpha.2-0",
   "homepage": "http://www.js-data.io/js-data-angular",
   "repository": {
     "type": "git",
-    "url": "git://github.com/js-data/js-data-angular.git"
+    "url": "https://github.com/js-data/js-data-angular.git"
   },
   "main": "./dist/js-data-angular.min.js",
   "ignore": [
@@ -18,7 +18,20 @@
     "node_modules/",
     "package.json"
   ],
+  "devDependencies": {
+    "angular-1.1.5": "angular-unstable#1.1.5",
+    "angular-1.2.16": "angular#1.2.16",
+    "angular-1.2.25": "angular#1.2.25",
+    "angular-1.3.2": "angular#1.3.2",
+    "angular-mocks-1.1.5": "angular-mocks-unstable#1.1.5",
+    "angular-mocks-1.2.16": "angular-mocks#1.2.16",
+    "angular-mocks-1.2.25": "angular-mocks#1.2.25",
+    "angular-mocks-1.3.2": "angular-mocks#1.3.2"
+  },
   "dependencies": {
     "js-data": "~1.0.x"
+  },
+  "resolutions": {
+    "angular": "1.3.2"
   }
 }

dist/js-data-angular.js

@@ -1,7 +1,7 @@
 /**
 * @author Jason Dobry <jason.dobry@gmail.com>
 * @file js-data-angular.js
-* @version 2.0.0-alpha.1-0 - Homepage <http://www.js-data.io/js-data-angular/>
+* @version 2.0.0-alpha.2-0 - Homepage <http://www.js-data.io/js-data-angular/>
 * @copyright (c) 2014 Jason Dobry <https://github.com/jmdobry/>
 * @license MIT <https://github.com/js-data/js-data-angular/blob/master/LICENSE>
 *
@@ -107,6 +107,176 @@
     registerAdapter(adapters[i]);
   }
 
+  angular.module('js-data', ['ng'])
+    .value('DSUtils', JSData.DSUtils)
+    .value('DSErrors', JSData.DSErrors)
+    .provider('DS', function () {
+
+      var _this = this;
+      var DSUtils = JSData.DSUtils;
+      var DSErrors = JSData.DSErrors;
+      var deps = [];
+
+      for (var i = 0; i < adapters.length; i++) {
+        if (adapters[i].loaded) {
+          deps.push(adapters[i].class);
+        }
+      }
+
+      _this.defaults = {};
+
+      JSData.DS.prototype.bindAll = function (resourceName, params, scope, expr, cb) {
+        var _this = this;
+
+        params = params || {};
+
+        if (!_this.definitions[resourceName]) {
+          throw new DSErrors.NER(resourceName);
+        } else if (!DSUtils.isObject(params)) {
+          throw new DSErrors.IA('"params" must be an object!');
+        } else if (!DSUtils.isObject(scope)) {
+          throw new DSErrors.IA('"scope" must be an object!');
+        } else if (!DSUtils.isString(expr)) {
+          throw new DSErrors.IA('"expr" must be a string!');
+        }
+
+        try {
+          return scope.$watch(function () {
+            return _this.lastModified(resourceName);
+          }, function () {
+            var items = _this.filter(resourceName, params);
+            DSUtils.set(scope, expr, items);
+            if (cb) {
+              cb(null, items);
+            }
+          });
+        } catch (err) {
+          if (cb) {
+            cb(err);
+          } else {
+            throw err;
+          }
+        }
+      };
+
+      JSData.DS.prototype.bindOne = function (resourceName, id, scope, expr, cb) {
+        var _this = this;
+
+        id = DSUtils.resolveId(_this.definitions[resourceName], id);
+        if (!DS.definitions[resourceName]) {
+          throw new DSErrors.NER(resourceName);
+        } else if (!DSUtils.isString(id) && !DSUtils.isNumber(id)) {
+          throw new DSErrors.IA('"id" must be a string or a number!');
+        } else if (!DSUtils.isObject(scope)) {
+          throw new DSErrors.IA('"scope" must be an object!');
+        } else if (!DSUtils.isString(expr)) {
+          throw new DSErrors.IA('"expr" must be a string!');
+        }
+
+        try {
+          return scope.$watch(function () {
+            return _this.lastModified(resourceName, id);
+          }, function () {
+            var item = _this.get(resourceName, id);
+            DSUtils.set(scope, expr, item);
+            if (cb) {
+              cb(null, item);
+            }
+          });
+        } catch (err) {
+          if (cb) {
+            cb(err);
+          } else {
+            throw err;
+          }
+        }
+      };
+
+      function load() {
+        var args = Array.prototype.slice.call(arguments);
+        var $rootScope = args[args.length - 2];
+        var $q = args[args.length - 1];
+        var store = new JSData.DS(_this.defaults);
+        var originals = {};
+
+        function QPromise(cb) {
+          var deferred = $q.defer();
+          try {
+            cb(function (val) {
+              if (!$rootScope.$$phase) {
+                $rootScope.$apply(function () {
+                  deferred.resolve(val);
+                });
+              } else {
+                deferred.resolve(val);
+              }
+            }, function (err) {
+              console.log(err);
+              if (!$rootScope.$$phase) {
+                $rootScope.$apply(function () {
+                  deferred.reject(err);
+                });
+              } else {
+                deferred.reject(err);
+              }
+            });
+          } catch (err) {
+            deferred.reject(err);
+          }
+          return deferred.promise;
+        }
+
+        //QPromise.all = $q.all;
+        //QPromise.when = $q.when;
+        //QPromise.reject = $q.reject;
+        //
+        //DSUtils.Promise = QPromise;
+
+        // Register any adapters that have been loaded
+        for (var i = 0; i < adapters.length; i++) {
+          if (adapters[i].loaded) {
+            store.registerAdapter(adapters[i].name, arguments[i]);
+          }
+        }
+
+        // Wrap certain sync functions with $apply
+        for (i = 0; i < functionsToWrap.length; i++) {
+          originals[functionsToWrap[i]] = store[functionsToWrap[i]];
+          store[functionsToWrap[i]] = (function (name) {
+            return function () {
+              var args = arguments;
+              if (!$rootScope.$$phase) {
+                return $rootScope.$apply(function () {
+                  return originals[name].apply(store, args);
+                });
+              }
+              return originals[name].apply(store, args);
+            };
+          })(functionsToWrap[i]);
+        }
+
+        // Hook into the digest loop (throttled)
+        if (typeof Object.observe !== 'function' ||
+          typeof Array.observe !== 'function') {
+          $rootScope.$watch(function () {
+            // TODO: observe.Platform.performMicrotaskCheckpoint();
+            // Throttle angular-data's digest loop to tenths of a second
+            return new Date().getTime() / 100 | 0;
+          }, function () {
+            store.digest();
+          });
+        }
+
+        return store;
+      }
+
+      deps.push('$rootScope');
+      deps.push('$q');
+      deps.push(load);
+
+      _this.$get = deps;
+    });
+
   if (!httpLoaded) {
     var defaultsPrototype = Defaults.prototype;
 
@@ -120,8 +290,13 @@
 
     defaultsPrototype.httpConfig = {};
 
-    defaultsPrototype.log = console ? function (a, b, c, d, e) {
-      console.log(a, b, c, d, e);
+    defaultsPrototype.log = console ? function (a, b) {
+      console[typeof console.info === 'function' ? 'info' : 'log'](a, b);
+    } : function () {
+    };
+
+    defaultsPrototype.error = console ? function (a, b) {
+      console[typeof console.error === 'function' ? 'error' : 'log'](a, b);
     } : function () {
     };
 
@@ -283,161 +458,40 @@
     angular.module('js-data').provider('DSHttpAdapter', function () {
       var _this = this;
       _this.defaults = {};
-      _this.$get = ['$http', function ($http) {
+      _this.$get = ['$http', 'DS', '$q', function ($http, DS, $q) {
         dsHttpAdapterPrototype.HTTP = function (config) {
           var _this = this;
-          var start = new Date().getTime();
+          var start = new Date();
           config = deepMixIn(config, _this.defaults.httpConfig);
           if (_this.defaults.forceTrailingSlash && config.url[config.url.length] !== '/') {
             config.url += '/';
           }
           config.method = config.method.toUpperCase();
-          return $http(config).then(function (data) {
-            if (_this.defaults.log) {
-              _this.defaults.log(data.config.method.toUpperCase() + ' request: ' + data.config.url + ' Time taken: ' + (new Date().getTime() - start) + 'ms', data);
-            }
-            return data;
-          });
-        };
-
-        return new DSHttpAdapter(_this.defaults);
-      }];
-    });
-  }
-
-  angular.module('js-data', ['ng'])
-    .value('DSUtils', JSData.DSUtils)
-    .value('DSErrors', JSData.DSErrors)
-    .provider('DS', function () {
-
-      var _this = this;
-      var DSUtils = JSData.DSUtils;
-      var DSErrors = JSData.DSErrors;
-      var deps = [];
-
-      for (var i = 0; i < adapters.length; i++) {
-        if (adapters[i].loaded) {
-          deps.push(adapters[i].class);
-        }
-      }
-
-      _this.defaults = {};
-
-      JSData.DS.prototype.bindAll = function (scope, expr, resourceName, params, cb) {
-        var _this = this;
-
-        params = params || {};
-
-        if (!DSUtils.isObject(scope)) {
-          throw new DSErrors.IA('"scope" must be an object!');
-        } else if (!DSUtils.isString(expr)) {
-          throw new DSErrors.IA('"expr" must be a string!');
-        } else if (!_this.definitions[resourceName]) {
-          throw new DSErrors.NER(resourceName);
-        } else if (!DSUtils.isObject(params)) {
-          throw new DSErrors.IA('"params" must be an object!');
-        }
-
-        try {
-          return scope.$watch(function () {
-            return _this.lastModified(resourceName);
-          }, function () {
-            var items = _this.filter(resourceName, params);
-            DSUtils.set(scope, expr, items);
-            if (cb) {
-              cb(null, items);
-            }
-          });
-        } catch (err) {
-          if (cb) {
-            cb(err);
-          } else {
-            throw err;
-          }
-        }
-      };
-
-      JSData.DS.prototype.bindAll = function (scope, expr, resourceName, id, cb) {
-        var _this = this;
-
-        id = DSUtils.resolveId(_this.definitions[resourceName], id);
-        if (!DSUtils.isObject(scope)) {
-          throw new DSErrors.IA('"scope" must be an object!');
-        } else if (!DSUtils.isString(expr)) {
-          throw new DSErrors.IA('"expr" must be a string!');
-        } else if (!DS.definitions[resourceName]) {
-          throw new DSErrors.NER(resourceName);
-        } else if (!DSUtils.isString(id) && !DSUtils.isNumber(id)) {
-          throw new DSErrors.IA('"id" must be a string or a number!');
-        }
 
-        try {
-          return scope.$watch(function () {
-            return _this.lastModified(resourceName, id);
-          }, function () {
-            var item = _this.get(resourceName, id);
-            DSUtils.set(scope, expr, item);
-            if (cb) {
-              cb(null, item);
+          function logResponse(data) {
+            var str = start.toUTCString() + ' - ' + data.config.method.toUpperCase() + ' ' + data.config.url + ' - ' + data.status + ' ' + (new Date().getTime() - start.getTime()) + 'ms';
+            if (data.status >= 200 && data.status < 300) {
+              if (_this.defaults.log) {
+                _this.defaults.log(str, data);
+              }
+              return data;
+            } else {
+              if (_this.defaults.error) {
+                _this.defaults.error('FAILED: ' + str, data);
+              }
+              return $q.reject(data);
             }
-          });
-        } catch (err) {
-          if (cb) {
-            cb(err);
-          } else {
-            throw err;
           }
-        }
-      };
-
-      function load() {
-        var args = Array.prototype.slice.call(arguments);
-        var $rootScope = args[args.length - 1];
-        var store = new JSData.DS(_this.defaults);
-        var originals = {};
-
-        // Register any adapters that have been loaded
-        for (var i = 0; i < adapters.length; i++) {
-          if (adapters[i].loaded) {
-            store.registerAdapter(adapters[i].name, arguments[i]);
-          }
-        }
-
-        // Wrap certain sync functions with $apply
-        for (i = 0; i < functionsToWrap.length; i++) {
-          originals[functionsToWrap[i]] = store[functionsToWrap[i]];
-          store[functionsToWrap[i]] = (function (name) {
-            return function () {
-              var args = arguments;
-              if (!$rootScope.$$phase) {
-                return $rootScope.$apply(function () {
-                  return originals[name].apply(store, args);
-                });
-              }
-              return originals[name].apply(store, args);
-            };
-          })(functionsToWrap[i]);
-        }
-
-        // Hook into the digest loop (throttled)
-        if (typeof Object.observe !== 'function' ||
-          typeof Array.observe !== 'function') {
-          $rootScope.$watch(function () {
-            // Throttle angular-data's digest loop to tenths of a second
-            return new Date().getTime() / 100 | 0;
-          }, function () {
-            store.digest();
-          });
-        }
 
-        return store;
-      }
-
-      deps.push('$rootScope');
-      deps.push(load);
+          return $http(config).then(logResponse, logResponse);
+        };
 
-      _this.$get = deps;
+        var adapter = new DSHttpAdapter(_this.defaults);
+        DS.registerAdapter('http', adapter, { default: true });
+        return adapter;
+      }];
     });
+  }
 
 })(window, window.angular);
 

dist/js-data-angular.min.js

@@ -0,0 +1,63 @@
+// an example karma.conf.js
+module.exports = function (config) {
+  config.set({
+    // base path, that will be used to resolve files and exclude
+    basePath: './',
+    frameworks: ['sinon', 'chai', 'mocha'],
+    plugins: [
+      // these plugins will be require() by Karma
+      'karma-sinon',
+      'karma-mocha',
+      'karma-chai',
+      'karma-chrome-launcher',
+      'karma-phantomjs-launcher',
+      'karma-firefox-launcher',
+      'karma-coverage',
+      'karma-spec-reporter'
+    ],
+    autoWatch: false,
+    browserNoActivityTimeout: 30000,
+    browsers: ['Chrome'],
+
+    // list of files / patterns to load in the browser
+    files: [
+      'bower_components/angular-1.3.2/angular.js',
+      'bower_components/angular-mocks-1.3.2/angular-mocks.js',
+      'bower_components/js-data/dist/js-data.js',
+      'dist/js-data-angular.js',
+      'karma.start.js',
+      'test/**/*.js'
+    ],
+
+    reporters: ['spec', 'coverage'],
+
+    preprocessors: {
+      'dist/js-data-angular.js': ['coverage']
+    },
+
+    // optionally, configure the reporter
+    coverageReporter: {
+      type: 'lcov',
+      dir: 'coverage/'
+    },
+
+    // web server port
+    port: 9876,
+
+    // cli runner port
+    runnerPort: 9100,
+
+    // enable / disable colors in the output (reporters and logs)
+    colors: true,
+
+    // level of logging
+    logLevel: config.LOG_INFO,
+
+    // If browser does not capture in given timeout [ms], kill it
+    captureTimeout: 30000,
+
+    // Continuous Integration mode
+    // if true, it capture browsers, run tests and exit
+    singleRun: true
+  });
+};

karma.conf.js

@@ -0,0 +1,341 @@
+// Setup global test variables
+var $rootScope, $q, $log, $timeout, DSHttpAdapterProvider, DSProvider, DS, DSUtils, DSHttpAdapter, app, $httpBackend, p1, p2, p3, p4, p5;
+
+var Post, User, Organization, Comment, Profile;
+var user1, organization2, comment3, profile4;
+var comment11, comment12, comment13, organization14, profile15, user10, user16, user17, user18, organization15, user19, user20, comment19, user22, profile21;
+
+var lifecycle = {};
+
+// Helper globals
+var fail = function (msg) {
+    if (msg instanceof Error) {
+      console.log(msg.stack);
+    } else {
+      assert.equal('should not reach this!: ' + msg, 'failure');
+    }
+  },
+  TYPES_EXCEPT_STRING = [123, 123.123, null, undefined, {}, [], true, false, function () {
+  }],
+  TYPES_EXCEPT_STRING_OR_ARRAY = [123, 123.123, null, undefined, {}, true, false, function () {
+  }],
+  TYPES_EXCEPT_STRING_OR_OBJECT = [123, 123.123, null, undefined, [], true, false, function () {
+  }],
+  TYPES_EXCEPT_STRING_OR_NUMBER_OBJECT = [null, undefined, [], true, false, function () {
+  }],
+  TYPES_EXCEPT_ARRAY = ['string', 123, 123.123, null, undefined, {}, true, false, function () {
+  }],
+  TYPES_EXCEPT_STRING_OR_NUMBER = [null, undefined, {}, [], true, false, function () {
+  }],
+  TYPES_EXCEPT_STRING_OR_ARRAY_OR_NUMBER = [null, undefined, {}, true, false, function () {
+  }],
+  TYPES_EXCEPT_NUMBER = ['string', null, undefined, {}, [], true, false, function () {
+  }],
+  TYPES_EXCEPT_OBJECT = ['string', 123, 123.123, null, undefined, true, false, function () {
+  }],
+  TYPES_EXCEPT_BOOLEAN = ['string', 123, 123.123, null, undefined, {}, [], function () {
+  }],
+  TYPES_EXCEPT_FUNCTION = ['string', 123, 123.123, null, undefined, {}, [], true, false];
+
+angular.module('app', ['ng', 'js-data']);
+
+// Setup before each test
+beforeEach(function () {
+  lifecycle.beforeValidate = function (resourceName, attrs, cb) {
+    lifecycle.beforeValidate.callCount += 1;
+    cb(null, attrs);
+  };
+  lifecycle.validate = function (resourceName, attrs, cb) {
+    lifecycle.validate.callCount += 1;
+    cb(null, attrs);
+  };
+  lifecycle.afterValidate = function (resourceName, attrs, cb) {
+    lifecycle.afterValidate.callCount += 1;
+    cb(null, attrs);
+  };
+  lifecycle.beforeCreate = function (resourceName, attrs, cb) {
+    lifecycle.beforeCreate.callCount += 1;
+    cb(null, attrs);
+  };
+  lifecycle.afterCreate = function (resourceName, attrs, cb) {
+    lifecycle.afterCreate.callCount += 1;
+    cb(null, attrs);
+  };
+  lifecycle.beforeUpdate = function (resourceName, attrs, cb) {
+    lifecycle.beforeUpdate.callCount += 1;
+    cb(null, attrs);
+  };
+  lifecycle.afterUpdate = function (resourceName, attrs, cb) {
+    lifecycle.afterUpdate.callCount += 1;
+    cb(null, attrs);
+  };
+  lifecycle.beforeDestroy = function (resourceName, attrs, cb) {
+    lifecycle.beforeDestroy.callCount += 1;
+    cb(null, attrs);
+  };
+  lifecycle.afterDestroy = function (resourceName, attrs, cb) {
+    lifecycle.afterDestroy.callCount += 1;
+    cb(null, attrs);
+  };
+  lifecycle.beforeInject = function () {
+    lifecycle.beforeInject.callCount += 1;
+  };
+  lifecycle.afterInject = function () {
+    lifecycle.afterInject.callCount += 1;
+  };
+  lifecycle.serialize = function (resourceName, data) {
+    lifecycle.serialize.callCount += 1;
+    return data;
+  };
+  lifecycle.deserialize = function (resourceName, data) {
+    lifecycle.deserialize.callCount += 1;
+    return data ? (data.data ? data.data : data) : data;;
+  };
+  lifecycle.queryTransform = function (resourceName, query) {
+    lifecycle.queryTransform.callCount += 1;
+    return query;
+  };
+  module('app', function (_DSProvider_, _DSHttpAdapterProvider_) {
+    DSProvider = _DSProvider_;
+    DSProvider.defaults.basePath = 'http://test.angular-cache.com';
+    DSProvider.defaults.beforeValidate = lifecycle.beforeValidate;
+    DSProvider.defaults.validate = lifecycle.validate;
+    DSProvider.defaults.afterValidate = lifecycle.afterValidate;
+    DSProvider.defaults.beforeCreate = lifecycle.beforeCreate;
+    DSProvider.defaults.afterCreate = lifecycle.afterCreate;
+    DSProvider.defaults.beforeUpdate = lifecycle.beforeUpdate;
+    DSProvider.defaults.afterUpdate = lifecycle.afterUpdate;
+    DSProvider.defaults.beforeDestroy = lifecycle.beforeDestroy;
+    DSProvider.defaults.afterDestroy = lifecycle.afterDestroy;
+    DSProvider.defaults.beforeInject = lifecycle.beforeInject;
+    DSProvider.defaults.afterInject = lifecycle.afterInject;
+    DSProvider.defaults.serialize = lifecycle.serialize;
+    DSProvider.defaults.deserialize = lifecycle.deserialize;
+    DSHttpAdapterProvider = _DSHttpAdapterProvider_;
+    DSHttpAdapterProvider.defaults.queryTransform = lifecycle.queryTransform;
+    DSHttpAdapterProvider.defaults.log = false;
+  });
+});
+
+function startInjector() {
+  inject(function (_$rootScope_, _$q_, _$timeout_, _$httpBackend_, _DS_, _$log_, _DSUtils_, _DSHttpAdapter_) {
+    // Setup global mocks
+
+    localStorage.clear();
+    $q = _$q_;
+    $rootScope = _$rootScope_;
+    DS = _DS_;
+    $timeout = _$timeout_;
+    DSUtils = _DSUtils_;
+    DSHttpAdapter = _DSHttpAdapter_;
+    $httpBackend = _$httpBackend_;
+    Post = DS.defineResource({
+      name: 'post',
+      keepChangeHistory: true,
+      endpoint: '/posts'
+    });
+    User = DS.defineResource({
+      name: 'user',
+      relations: {
+        hasMany: {
+          comment: {
+            localField: 'comments',
+            foreignKey: 'approvedBy'
+          }
+        },
+        hasOne: {
+          profile: {
+            localField: 'profile',
+            foreignKey: 'userId'
+          }
+        },
+        belongsTo: {
+          organization: {
+            parent: true,
+            localKey: 'organizationId',
+            localField: 'organization'
+          }
+        }
+      }
+    });
+
+    Organization = DS.defineResource({
+      name: 'organization',
+      relations: {
+        hasMany: {
+          user: {
+            localField: 'users',
+            foreignKey: 'organizationId'
+          }
+        }
+      }
+    });
+
+    Profile = DS.defineResource({
+      name: 'profile',
+      relations: {
+        belongsTo: {
+          user: {
+            localField: 'user',
+            localKey: 'userId'
+          }
+        }
+      }
+    });
+
+    Comment = DS.defineResource({
+      name: 'comment',
+      relations: {
+        belongsTo: {
+          user: [
+            {
+              localField: 'user',
+              localKey: 'userId'
+            },
+            {
+              parent: true,
+              localField: 'approvedByUser',
+              localKey: 'approvedBy'
+            }
+          ]
+        }
+      }
+    });
+    $log = _$log_;
+
+    lifecycle.beforeValidate.callCount = 0;
+    lifecycle.validate.callCount = 0;
+    lifecycle.afterValidate.callCount = 0;
+    lifecycle.beforeCreate.callCount = 0;
+    lifecycle.afterCreate.callCount = 0;
+    lifecycle.beforeUpdate.callCount = 0;
+    lifecycle.afterUpdate.callCount = 0;
+    lifecycle.beforeDestroy.callCount = 0;
+    lifecycle.afterDestroy.callCount = 0;
+    lifecycle.beforeInject.callCount = 0;
+    lifecycle.afterInject.callCount = 0;
+    lifecycle.serialize.callCount = 0;
+    lifecycle.deserialize.callCount = 0;
+    lifecycle.queryTransform.callCount = 0;
+
+    p1 = { author: 'John', age: 30, id: 5 };
+    p2 = { author: 'Sally', age: 31, id: 6 };
+    p3 = { author: 'Mike', age: 32, id: 7 };
+    p4 = { author: 'Adam', age: 33, id: 8 };
+    p5 = { author: 'Adam', age: 33, id: 9 };
+
+    user1 = {
+      name: 'John Anderson',
+      id: 1,
+      organizationId: 2
+    };
+    organization2 = {
+      name: 'Test Corp 2',
+      id: 2
+    };
+    comment3 = {
+      content: 'test comment 3',
+      id: 3,
+      userId: 1
+    };
+    profile4 = {
+      content: 'test profile 4',
+      id: 4,
+      userId: 1
+    };
+
+    comment11 = {
+      id: 11,
+      userId: 10,
+      content: 'test comment 11'
+    };
+    comment12 = {
+      id: 12,
+      userId: 10,
+      content: 'test comment 12'
+    };
+    comment13 = {
+      id: 13,
+      userId: 10,
+      content: 'test comment 13'
+    };
+    organization14 = {
+      id: 14,
+      name: 'Test Corp'
+    };
+    profile15 = {
+      id: 15,
+      userId: 10,
+      email: 'john.anderson@test.com'
+    };
+    user10 = {
+      name: 'John Anderson',
+      id: 10,
+      organizationId: 14,
+      comments: [
+        comment11,
+        comment12,
+        comment13
+      ],
+      organization: organization14,
+      profile: profile15
+    };
+    user16 = {
+      id: 16,
+      organizationId: 15,
+      name: 'test user 16'
+    };
+    user17 = {
+      id: 17,
+      organizationId: 15,
+      name: 'test user 17'
+    };
+    user18 = {
+      id: 18,
+      organizationId: 15,
+      name: 'test user 18'
+    };
+    organization15 = {
+      name: 'Another Test Corp',
+      id: 15,
+      users: [
+        user16,
+        user17,
+        user18
+      ]
+    };
+    user19 = {
+      id: 19,
+      name: 'test user 19'
+    };
+    user20 = {
+      id: 20,
+      name: 'test user 20'
+    };
+    comment19 = {
+      content: 'test comment 19',
+      id: 19,
+      approvedBy: 19,
+      approvedByUser: user19,
+      userId: 20,
+      user: user20
+    };
+    user22 = {
+      id: 22,
+      name: 'test user 22'
+    };
+    profile21 = {
+      content: 'test profile 21',
+      id: 21,
+      userId: 22,
+      user: user22
+    };
+  });
+}
+
+// Clean up after each test
+afterEach(function () {
+  $httpBackend.verifyNoOutstandingExpectation();
+  $httpBackend.verifyNoOutstandingRequest();
+  $log.reset();
+});

karma.start.js

@@ -1,7 +1,7 @@
 {
   "name": "js-data-angular",
   "description": "Angular wrapper for js-data.",
-  "version": "2.0.0-alpha.1-0",
+  "version": "2.0.0-alpha.2-0",
   "homepage": "http://js-data-angular.pseudobry.com",
   "repository": {
     "type": "git",
@@ -20,11 +20,23 @@
   ],
   "devDependencies": {
     "grunt": "0.4.5",
-    "grunt-browserify": "3.1.0",
+    "grunt-browserify": "3.2.0",
     "grunt-contrib-clean": "0.6.0",
     "grunt-contrib-jshint": "0.10.0",
     "grunt-contrib-uglify": "0.6.0",
     "grunt-contrib-watch": "0.6.1",
+    "grunt-karma": "0.9.0",
+    "grunt-karma-coveralls": "2.5.2",
+    "karma": "0.12.24",
+    "karma-chai": "0.1.0",
+    "karma-chrome-launcher": "0.1.5",
+    "karma-coverage": "0.2.6",
+    "karma-script-launcher": "0.1.0",
+    "karma-firefox-launcher": "0.1.3",
+    "karma-phantomjs-launcher": "0.1.4",
+    "karma-mocha": "0.1.9",
+    "karma-sinon": "1.0.3",
+    "karma-spec-reporter": "0.0.13",
     "time-grunt": "1.0.0",
     "jit-grunt": "0.9.0"
   },

package.json

@@ -97,6 +97,176 @@
     registerAdapter(adapters[i]);
   }
 
+  angular.module('js-data', ['ng'])
+    .value('DSUtils', JSData.DSUtils)
+    .value('DSErrors', JSData.DSErrors)
+    .provider('DS', function () {
+
+      var _this = this;
+      var DSUtils = JSData.DSUtils;
+      var DSErrors = JSData.DSErrors;
+      var deps = [];
+
+      for (var i = 0; i < adapters.length; i++) {
+        if (adapters[i].loaded) {
+          deps.push(adapters[i].class);
+        }
+      }
+
+      _this.defaults = {};
+
+      JSData.DS.prototype.bindAll = function (resourceName, params, scope, expr, cb) {
+        var _this = this;
+
+        params = params || {};
+
+        if (!_this.definitions[resourceName]) {
+          throw new DSErrors.NER(resourceName);
+        } else if (!DSUtils.isObject(params)) {
+          throw new DSErrors.IA('"params" must be an object!');
+        } else if (!DSUtils.isObject(scope)) {
+          throw new DSErrors.IA('"scope" must be an object!');
+        } else if (!DSUtils.isString(expr)) {
+          throw new DSErrors.IA('"expr" must be a string!');
+        }
+
+        try {
+          return scope.$watch(function () {
+            return _this.lastModified(resourceName);
+          }, function () {
+            var items = _this.filter(resourceName, params);
+            DSUtils.set(scope, expr, items);
+            if (cb) {
+              cb(null, items);
+            }
+          });
+        } catch (err) {
+          if (cb) {
+            cb(err);
+          } else {
+            throw err;
+          }
+        }
+      };
+
+      JSData.DS.prototype.bindOne = function (resourceName, id, scope, expr, cb) {
+        var _this = this;
+
+        id = DSUtils.resolveId(_this.definitions[resourceName], id);
+        if (!DS.definitions[resourceName]) {
+          throw new DSErrors.NER(resourceName);
+        } else if (!DSUtils.isString(id) && !DSUtils.isNumber(id)) {
+          throw new DSErrors.IA('"id" must be a string or a number!');
+        } else if (!DSUtils.isObject(scope)) {
+          throw new DSErrors.IA('"scope" must be an object!');
+        } else if (!DSUtils.isString(expr)) {
+          throw new DSErrors.IA('"expr" must be a string!');
+        }
+
+        try {
+          return scope.$watch(function () {
+            return _this.lastModified(resourceName, id);
+          }, function () {
+            var item = _this.get(resourceName, id);
+            DSUtils.set(scope, expr, item);
+            if (cb) {
+              cb(null, item);
+            }
+          });
+        } catch (err) {
+          if (cb) {
+            cb(err);
+          } else {
+            throw err;
+          }
+        }
+      };
+
+      function load() {
+        var args = Array.prototype.slice.call(arguments);
+        var $rootScope = args[args.length - 2];
+        var $q = args[args.length - 1];
+        var store = new JSData.DS(_this.defaults);
+        var originals = {};
+
+        function QPromise(cb) {
+          var deferred = $q.defer();
+          try {
+            cb(function (val) {
+              if (!$rootScope.$$phase) {
+                $rootScope.$apply(function () {
+                  deferred.resolve(val);
+                });
+              } else {
+                deferred.resolve(val);
+              }
+            }, function (err) {
+              console.log(err);
+              if (!$rootScope.$$phase) {
+                $rootScope.$apply(function () {
+                  deferred.reject(err);
+                });
+              } else {
+                deferred.reject(err);
+              }
+            });
+          } catch (err) {
+            deferred.reject(err);
+          }
+          return deferred.promise;
+        }
+
+        //QPromise.all = $q.all;
+        //QPromise.when = $q.when;
+        //QPromise.reject = $q.reject;
+        //
+        //DSUtils.Promise = QPromise;
+
+        // Register any adapters that have been loaded
+        for (var i = 0; i < adapters.length; i++) {
+          if (adapters[i].loaded) {
+            store.registerAdapter(adapters[i].name, arguments[i]);
+          }
+        }
+
+        // Wrap certain sync functions with $apply
+        for (i = 0; i < functionsToWrap.length; i++) {
+          originals[functionsToWrap[i]] = store[functionsToWrap[i]];
+          store[functionsToWrap[i]] = (function (name) {
+            return function () {
+              var args = arguments;
+              if (!$rootScope.$$phase) {
+                return $rootScope.$apply(function () {
+                  return originals[name].apply(store, args);
+                });
+              }
+              return originals[name].apply(store, args);
+            };
+          })(functionsToWrap[i]);
+        }
+
+        // Hook into the digest loop (throttled)
+        if (typeof Object.observe !== 'function' ||
+          typeof Array.observe !== 'function') {
+          $rootScope.$watch(function () {
+            // TODO: observe.Platform.performMicrotaskCheckpoint();
+            // Throttle angular-data's digest loop to tenths of a second
+            return new Date().getTime() / 100 | 0;
+          }, function () {
+            store.digest();
+          });
+        }
+
+        return store;
+      }
+
+      deps.push('$rootScope');
+      deps.push('$q');
+      deps.push(load);
+
+      _this.$get = deps;
+    });
+
   if (!httpLoaded) {
     var defaultsPrototype = Defaults.prototype;
 
@@ -110,8 +280,13 @@
 
     defaultsPrototype.httpConfig = {};
 
-    defaultsPrototype.log = console ? function (a, b, c, d, e) {
-      console.log(a, b, c, d, e);
+    defaultsPrototype.log = console ? function (a, b) {
+      console[typeof console.info === 'function' ? 'info' : 'log'](a, b);
+    } : function () {
+    };
+
+    defaultsPrototype.error = console ? function (a, b) {
+      console[typeof console.error === 'function' ? 'error' : 'log'](a, b);
     } : function () {
     };
 
@@ -273,160 +448,39 @@
     angular.module('js-data').provider('DSHttpAdapter', function () {
       var _this = this;
       _this.defaults = {};
-      _this.$get = ['$http', function ($http) {
+      _this.$get = ['$http', 'DS', '$q', function ($http, DS, $q) {
         dsHttpAdapterPrototype.HTTP = function (config) {
           var _this = this;
-          var start = new Date().getTime();
+          var start = new Date();
           config = deepMixIn(config, _this.defaults.httpConfig);
           if (_this.defaults.forceTrailingSlash && config.url[config.url.length] !== '/') {
             config.url += '/';
           }
           config.method = config.method.toUpperCase();
-          return $http(config).then(function (data) {
-            if (_this.defaults.log) {
-              _this.defaults.log(data.config.method.toUpperCase() + ' request: ' + data.config.url + ' Time taken: ' + (new Date().getTime() - start) + 'ms', data);
-            }
-            return data;
-          });
-        };
-
-        return new DSHttpAdapter(_this.defaults);
-      }];
-    });
-  }
-
-  angular.module('js-data', ['ng'])
-    .value('DSUtils', JSData.DSUtils)
-    .value('DSErrors', JSData.DSErrors)
-    .provider('DS', function () {
-
-      var _this = this;
-      var DSUtils = JSData.DSUtils;
-      var DSErrors = JSData.DSErrors;
-      var deps = [];
-
-      for (var i = 0; i < adapters.length; i++) {
-        if (adapters[i].loaded) {
-          deps.push(adapters[i].class);
-        }
-      }
-
-      _this.defaults = {};
-
-      JSData.DS.prototype.bindAll = function (scope, expr, resourceName, params, cb) {
-        var _this = this;
-
-        params = params || {};
-
-        if (!DSUtils.isObject(scope)) {
-          throw new DSErrors.IA('"scope" must be an object!');
-        } else if (!DSUtils.isString(expr)) {
-          throw new DSErrors.IA('"expr" must be a string!');
-        } else if (!_this.definitions[resourceName]) {
-          throw new DSErrors.NER(resourceName);
-        } else if (!DSUtils.isObject(params)) {
-          throw new DSErrors.IA('"params" must be an object!');
-        }
-
-        try {
-          return scope.$watch(function () {
-            return _this.lastModified(resourceName);
-          }, function () {
-            var items = _this.filter(resourceName, params);
-            DSUtils.set(scope, expr, items);
-            if (cb) {
-              cb(null, items);
-            }
-          });
-        } catch (err) {
-          if (cb) {
-            cb(err);
-          } else {
-            throw err;
-          }
-        }
-      };
-
-      JSData.DS.prototype.bindAll = function (scope, expr, resourceName, id, cb) {
-        var _this = this;
-
-        id = DSUtils.resolveId(_this.definitions[resourceName], id);
-        if (!DSUtils.isObject(scope)) {
-          throw new DSErrors.IA('"scope" must be an object!');
-        } else if (!DSUtils.isString(expr)) {
-          throw new DSErrors.IA('"expr" must be a string!');
-        } else if (!DS.definitions[resourceName]) {
-          throw new DSErrors.NER(resourceName);
-        } else if (!DSUtils.isString(id) && !DSUtils.isNumber(id)) {
-          throw new DSErrors.IA('"id" must be a string or a number!');
-        }
 
-        try {
-          return scope.$watch(function () {
-            return _this.lastModified(resourceName, id);
-          }, function () {
-            var item = _this.get(resourceName, id);
-            DSUtils.set(scope, expr, item);
-            if (cb) {
-              cb(null, item);
+          function logResponse(data) {
+            var str = start.toUTCString() + ' - ' + data.config.method.toUpperCase() + ' ' + data.config.url + ' - ' + data.status + ' ' + (new Date().getTime() - start.getTime()) + 'ms';
+            if (data.status >= 200 && data.status < 300) {
+              if (_this.defaults.log) {
+                _this.defaults.log(str, data);
+              }
+              return data;
+            } else {
+              if (_this.defaults.error) {
+                _this.defaults.error('FAILED: ' + str, data);
+              }
+              return $q.reject(data);
             }
-          });
-        } catch (err) {
-          if (cb) {
-            cb(err);
-          } else {
-            throw err;
           }
-        }
-      };
-
-      function load() {
-        var args = Array.prototype.slice.call(arguments);
-        var $rootScope = args[args.length - 1];
-        var store = new JSData.DS(_this.defaults);
-        var originals = {};
-
-        // Register any adapters that have been loaded
-        for (var i = 0; i < adapters.length; i++) {
-          if (adapters[i].loaded) {
-            store.registerAdapter(adapters[i].name, arguments[i]);
-          }
-        }
-
-        // Wrap certain sync functions with $apply
-        for (i = 0; i < functionsToWrap.length; i++) {
-          originals[functionsToWrap[i]] = store[functionsToWrap[i]];
-          store[functionsToWrap[i]] = (function (name) {
-            return function () {
-              var args = arguments;
-              if (!$rootScope.$$phase) {
-                return $rootScope.$apply(function () {
-                  return originals[name].apply(store, args);
-                });
-              }
-              return originals[name].apply(store, args);
-            };
-          })(functionsToWrap[i]);
-        }
-
-        // Hook into the digest loop (throttled)
-        if (typeof Object.observe !== 'function' ||
-          typeof Array.observe !== 'function') {
-          $rootScope.$watch(function () {
-            // Throttle angular-data's digest loop to tenths of a second
-            return new Date().getTime() / 100 | 0;
-          }, function () {
-            store.digest();
-          });
-        }
 
-        return store;
-      }
-
-      deps.push('$rootScope');
-      deps.push(load);
+          return $http(config).then(logResponse, logResponse);
+        };
 
-      _this.$get = deps;
+        var adapter = new DSHttpAdapter(_this.defaults);
+        DS.registerAdapter('http', adapter, { default: true });
+        return adapter;
+      }];
     });
+  }
 
 })(window, window.angular);

src/index.js

@@ -0,0 +1,36 @@
+describe('DSHttpAdapter.create', function () {
+
+  beforeEach(startInjector);
+
+  it('should make a POST request', function () {
+    $httpBackend.expectPOST('http://test.angular-cache.com/posts', {
+      author: 'John',
+      age: 30
+    }).respond(200, p1);
+
+    DSHttpAdapter.create(Post, { author: 'John', age: 30 }).then(function (data) {
+      assert.deepEqual(data, p1, 'post should have been created');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    $httpBackend.expectPOST('api2/posts', {
+      author: 'John',
+      age: 30
+    }).respond(200, p1);
+
+    DSHttpAdapter.create(Post, { author: 'John', age: 30 }, { basePath: 'api2' }).then(function (data) {
+      assert.deepEqual(data, p1, 'post should have been created');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    assert.equal(lifecycle.queryTransform.callCount, 0, 'queryTransform should not have been called');
+  });
+});

test/adapters/http/create.test.js

@@ -0,0 +1,30 @@
+describe('DSHttpAdapter.destroy', function () {
+
+  beforeEach(startInjector);
+
+  it('should make a DELETE request', function () {
+    $httpBackend.expectDELETE('http://test.angular-cache.com/posts/1').respond(200, 1);
+
+    DSHttpAdapter.destroy(Post, 1).then(function (data) {
+      assert.deepEqual(data, 1, 'post should have been deleted');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    $httpBackend.expectDELETE('api2/posts/1').respond(200, 1);
+
+    DSHttpAdapter.destroy(Post, 1, { basePath: 'api2' }).then(function (data) {
+      assert.deepEqual(data, 1, 'post should have been deleted');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    assert.equal(lifecycle.queryTransform.callCount, 0, 'queryTransform should not have been called');
+  });
+});

test/adapters/http/destroy.test.js

@@ -0,0 +1,36 @@
+describe('DSHttpAdapter.destroyAll', function () {
+
+  beforeEach(startInjector);
+
+  it('should make a DELETE request', function () {
+    $httpBackend.expectDELETE('http://test.angular-cache.com/posts').respond(204);
+
+    DSHttpAdapter.destroyAll(Post, {}).then(function (data) {
+      assert.isUndefined(data, 'posts should have been found');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    $httpBackend.expectDELETE('api2/posts?where=%7B%22author%22:%7B%22%3D%3D%22:%22John%22%7D%7D').respond(204);
+
+    DSHttpAdapter.destroyAll(Post, {
+      where: {
+        author: {
+          '==': 'John'
+        }
+      }
+    }, { basePath: 'api2' }).then(function (data) {
+      assert.isUndefined(data, 'posts should have been destroyed');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    assert.equal(lifecycle.queryTransform.callCount, 2, 'queryTransform should have been called');
+  });
+});

test/adapters/http/destroyAll.test.js

@@ -0,0 +1,52 @@
+describe('DSHttpAdapter.find', function () {
+
+  beforeEach(startInjector);
+
+  it('should make a GET request', function () {
+    $httpBackend.expectGET('http://test.angular-cache.com/posts/1').respond(200, p1);
+
+    DSHttpAdapter.find(Post, 1).then(function (data) {
+      assert.deepEqual(data, p1, 'post should have been found');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    $httpBackend.expectGET('api2/posts/1').respond(200, p1);
+
+    DSHttpAdapter.find(Post, 1, { basePath: 'api2' }).then(function (data) {
+      assert.deepEqual(data, p1, 'post should have been found');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    assert.equal(lifecycle.queryTransform.callCount, 0, 'queryTransform should not have been called');
+  });
+
+  it('should use default configs', function () {
+    $httpBackend.expectGET('http://test.angular-cache.com/posts/1?test=test', {
+      Authorization: 'test',
+      Accept: 'application/json, text/plain, */*'
+    }).respond(200, p1);
+
+    DSHttpAdapter.defaults.httpConfig.params = { test: 'test' };
+    DSHttpAdapter.defaults.httpConfig.headers = { Authorization: 'test' };
+
+    DSHttpAdapter.find(Post, 1).then(function (data) {
+      assert.deepEqual(data, p1, 'post should have been found');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    delete DSHttpAdapter.defaults.httpConfig.params;
+    delete DSHttpAdapter.defaults.httpConfig.headers;
+  });
+});

test/adapters/http/find.test.js

@@ -0,0 +1,36 @@
+describe('DSHttpAdapter.findAll', function () {
+
+  beforeEach(startInjector);
+
+  it('should make a GET request', function () {
+    $httpBackend.expectGET('http://test.angular-cache.com/posts').respond(200, [p1]);
+
+    DSHttpAdapter.findAll(Post, {}).then(function (data) {
+      assert.deepEqual(data, [p1], 'posts should have been found');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    $httpBackend.expectGET('api2/posts?where=%7B%22author%22:%7B%22%3D%3D%22:%22John%22%7D%7D').respond(200, [p1]);
+
+    DSHttpAdapter.findAll(Post, {
+      where: {
+        author: {
+          '==': 'John'
+        }
+      }
+    }, { basePath: 'api2' }).then(function (data) {
+      assert.deepEqual(data, [p1], 'posts should have been found');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    assert.equal(lifecycle.queryTransform.callCount, 2, 'queryTransform should have been called');
+  });
+});

test/adapters/http/findAll.test.js

@@ -0,0 +1,36 @@
+describe('DSHttpAdapter.update', function () {
+
+  beforeEach(startInjector);
+
+  it('should make a PUT request', function () {
+    $httpBackend.expectPUT('http://test.angular-cache.com/posts/1', {
+      author: 'John',
+      age: 30
+    }).respond(200, p1);
+
+    DSHttpAdapter.update(Post, 1, { author: 'John', age: 30 }).then(function (data) {
+      assert.deepEqual(data, p1, 'post 5 should have been updated');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    $httpBackend.expectPUT('api2/posts/1', {
+      author: 'John',
+      age: 30
+    }).respond(200, p1);
+
+    DSHttpAdapter.update(Post, 1, { author: 'John', age: 30 }, { basePath: 'api2' }).then(function (data) {
+      assert.deepEqual(data, p1, 'post 5 should have been updated');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    assert.equal(lifecycle.queryTransform.callCount, 0, 'queryTransform should not have been called');
+  });
+});

test/adapters/http/update.test.js

@@ -0,0 +1,36 @@
+describe('DSHttpAdapter.updateAll', function () {
+
+  beforeEach(startInjector);
+
+  it('should make a PUT request', function () {
+    $httpBackend.expectPUT('http://test.angular-cache.com/posts').respond(200, [p1]);
+
+    DSHttpAdapter.updateAll(Post, { author: 'John', age: 30 }).then(function (data) {
+      assert.deepEqual(data, [p1], 'posts should have been updated');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    $httpBackend.expectPUT('api2/posts?where=%7B%22author%22:%7B%22%3D%3D%22:%22John%22%7D%7D').respond(200, [p1]);
+
+    DSHttpAdapter.updateAll(Post, { author: 'John', age: 30 }, {
+      where: {
+        author: {
+          '==': 'John'
+        }
+      }
+    }, { basePath: 'api2' }).then(function (data) {
+      assert.deepEqual(data, [p1], 'posts should have been updated');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    $httpBackend.flush();
+
+    assert.equal(lifecycle.queryTransform.callCount, 1, 'queryTransform should have been called');
+  });
+});

test/adapters/http/updateAll.test.js

@@ -0,0 +1,337 @@
+describe('DS.create', function () {
+  beforeEach(startInjector);
+
+  it('should create an item and save it to the server', function (done) {
+    $httpBackend.expectPOST('http://test.angular-cache.com/posts').respond(200, p1);
+
+    DS.create('post', { author: 'John', age: 30 }).then(function (post) {
+      try {
+        assert.deepEqual(angular.toJson(post), angular.toJson(p1), 'post 5 should have been created');
+
+        assert.equal(lifecycle.beforeCreate.callCount, 1, 'beforeCreate should have been called');
+        assert.equal(lifecycle.afterCreate.callCount, 1, 'afterCreate should have been called');
+        assert.equal(lifecycle.beforeInject.callCount, 1, 'beforeInject should have been called');
+        assert.equal(lifecycle.afterInject.callCount, 1, 'afterInject should have been called');
+        assert.equal(lifecycle.serialize.callCount, 1, 'serialize should have been called');
+        assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');
+        assert.deepEqual(angular.toJson(DS.get('post', 5)), angular.toJson(p1));
+
+        done();
+      } catch (e) {
+        done(e);
+      }
+    }, function (err) {
+      console.error(err.stack);
+      done('should not have rejected');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should create an item and save it to the server but not inject the result', function (done) {
+    DSHttpAdapter.defaults.forceTrailingSlash = true;
+    $httpBackend.expectPOST('http://test.angular-cache.com/posts/').respond(200, p1);
+
+    DS.create('post', { author: 'John', age: 30 }, { cacheResponse: false }).then(function (post) {
+      assert.deepEqual(angular.toJson(post), angular.toJson(p1), 'post 5 should have been created');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        setTimeout(function () {
+          try {
+            DSHttpAdapter.defaults.forceTrailingSlash = false;
+
+            assert.equal(lifecycle.beforeCreate.callCount, 1, 'beforeCreate should have been called');
+            assert.equal(lifecycle.afterCreate.callCount, 1, 'afterCreate should have been called');
+            assert.equal(lifecycle.beforeInject.callCount, 0, 'beforeInject should not have been called');
+            assert.equal(lifecycle.afterInject.callCount, 0, 'afterInject should not have been called');
+            assert.equal(lifecycle.serialize.callCount, 1, 'serialize should have been called');
+            assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');
+            assert.isUndefined(DS.get('post', 5));
+
+            done();
+          } catch (e) {
+            done(e);
+          }
+        }, 30);
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should work with the upsert option', function (done) {
+    $httpBackend.expectPUT('http://test.angular-cache.com/posts/5').respond(200, p1);
+
+    DS.create('post', { author: 'John', age: 30, id: 5 }).then(function (post) {
+      assert.deepEqual(angular.toJson(post), angular.toJson(p1), 'post 5 should have been created');
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+        $httpBackend.expectPOST('http://test.angular-cache.com/posts').respond(200, p2);
+
+        setTimeout(function () {
+          try {
+            DS.create('post', { author: 'Sue', age: 70, id: 6 }, { upsert: false }).then(function (post) {
+              assert.deepEqual(angular.toJson(post), angular.toJson(p2), 'post 6 should have been created');
+            }, function (err) {
+              console.error(err.stack);
+              fail('should not have rejected');
+            });
+
+            setTimeout(function () {
+              try {
+                $httpBackend.flush();
+
+                setTimeout(function () {
+                  try {
+                    assert.equal(lifecycle.beforeUpdate.callCount, 1, 'beforeUpdate should have been called');
+                    assert.equal(lifecycle.afterUpdate.callCount, 1, 'afterUpdate should have been called');
+                    assert.equal(lifecycle.beforeCreate.callCount, 1, 'beforeCreate should have been called');
+                    assert.equal(lifecycle.afterCreate.callCount, 1, 'afterCreate should have been called');
+                    assert.equal(lifecycle.beforeInject.callCount, 2, 'beforeInject should have been called twice');
+                    assert.equal(lifecycle.afterInject.callCount, 2, 'afterInject should have been called twice');
+                    assert.equal(lifecycle.serialize.callCount, 2, 'serialize should have been called twice');
+                    assert.equal(lifecycle.deserialize.callCount, 2, 'deserialize should have been called twice');
+                    assert.isDefined(DS.get('post', 5));
+                    assert.isDefined(DS.get('post', 6));
+
+                    done();
+                  } catch (e) {
+                    done(e);
+                  }
+                }, 30);
+              } catch (e) {
+                done(e);
+              }
+            }, 30);
+          } catch (e) {
+            done(e);
+          }
+        }, 30);
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should create an item that includes relations, save them to the server and inject the results', function (done) {
+    var payload = {
+      id: 99,
+      name: 'Sally',
+      profile: {
+        id: 999,
+        userId: 99,
+        email: 'sally@test.com'
+      }
+    };
+
+    $httpBackend.expectPOST('http://test.angular-cache.com/user').respond(200, payload);
+
+    DS.create('user', {
+      name: 'Sally',
+      profile: {
+        email: 'sally@test.com'
+      }
+    }, {
+      findBelongsTo: true
+    }).then(function (user) {
+      assert.deepEqual(user.id, payload.id, 'user should have been created');
+
+      DS.find('user', 99); // should not trigger another http request
+    }, function (err) {
+      console.error(err.stack);
+      fail('should not have rejected');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        setTimeout(function () {
+          try {
+            assert.equal(lifecycle.beforeCreate.callCount, 1, 'beforeCreate should have been called twice');
+            assert.equal(lifecycle.afterCreate.callCount, 1, 'afterCreate should have been called twice');
+            assert.equal(lifecycle.beforeInject.callCount, 2, 'beforeInject should have been called twice');
+            assert.equal(lifecycle.afterInject.callCount, 2, 'afterInject should have been called twice');
+            assert.equal(lifecycle.serialize.callCount, 1, 'serialize should have been called');
+            assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');
+            assert.deepEqual(DS.get('user', 99).id, payload.id);
+            assert.isObject(DS.get('user', 99).profile);
+            assert.deepEqual(DS.get('profile', 999).id, 999);
+            assert.isObject(DS.get('profile', 999).user);
+
+            done();
+          } catch (e) {
+            done(e);
+          }
+        }, 30);
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should handle nested resources', function (done) {
+    var testComment = {
+      id: 5,
+      content: 'test',
+      approvedBy: 4
+    };
+    var testComment2 = {
+      id: 6,
+      content: 'test',
+      approvedBy: 4
+    };
+    $httpBackend.expectPOST('http://test.angular-cache.com/user/4/comment').respond(200, testComment);
+
+    DS.create('comment', {
+      content: 'test',
+      approvedBy: 4
+    }).then(function (comment) {
+      assert.deepEqual(angular.toJson(comment), angular.toJson(testComment));
+      assert.deepEqual(angular.toJson(comment), angular.toJson(DS.get('comment', 5)));
+    }, function () {
+      fail('Should not have failed!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+        $httpBackend.expectPOST('http://test.angular-cache.com/user/4/comment').respond(200, testComment2);
+
+        setTimeout(function () {
+          try {
+            DS.create('comment', {
+              content: 'test'
+            }, {
+              params: {
+                approvedBy: 4
+              }
+            }).then(function (comment) {
+              assert.deepEqual(angular.toJson(comment), angular.toJson(testComment2));
+              assert.deepEqual(angular.toJson(comment), angular.toJson(DS.get('comment', 6)));
+            }, function () {
+              fail('Should not have failed!');
+            });
+
+            setTimeout(function () {
+              try {
+                $httpBackend.flush();
+                $httpBackend.expectPOST('http://test.angular-cache.com/comment').respond(200, testComment2);
+
+                setTimeout(function () {
+                  try {
+                    DS.create('comment', {
+                      content: 'test',
+                      approvedBy: 4
+                    }, {
+                      params: {
+                        approvedBy: false
+                      }
+                    }).then(function (comment) {
+                      assert.deepEqual(angular.toJson(comment), angular.toJson(testComment2));
+                      assert.deepEqual(comment, DS.get('comment', 6));
+                    }, function () {
+                      fail('Should not have failed!');
+                    });
+                    setTimeout(function () {
+                      try {
+                        $httpBackend.flush();
+                        done();
+                      } catch (e) {
+                        done(e);
+                      }
+                    }, 30);
+                  } catch (e) {
+                    done(e);
+                  }
+                }, 30);
+              } catch (e) {
+                done(e);
+              }
+            }, 30);
+          } catch (e) {
+            done(e);
+          }
+        }, 30);
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should find inverse links', function (done) {
+    DS.inject('organization', {
+      id: 77
+    });
+
+    $httpBackend.expectPOST('http://test.angular-cache.com/organization/77/user').respond(200, {
+      organizationId: 77,
+      id: 88
+    });
+
+    DS.create('user', {
+      organizationId: 77,
+      id: 88
+    }, { upsert: false, findBelongsTo: true }).then(function (user) {
+      var organization = DS.link('organization', 77, ['user']);
+      assert.isArray(organization.users);
+      assert.equal(1, organization.users.length);
+      assert.isObject(user.organization);
+      assert.isTrue(user.organization === organization);
+      assert.isTrue(user === organization.users[0]);
+      done();
+    }, function () {
+      done('Should not have succeeded!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  // Not yet implemented in js-data
+  //it('should eager inject', function () {
+  //  $httpBackend.expectPOST('http://test.angular-cache.com/organization/77/user').respond(200, {
+  //    organizationId: 77,
+  //    id: 88
+  //  });
+  //
+  //  var eagerUser;
+  //
+  //  DS.create('user', {
+  //    organizationId: 77
+  //  }, { eagerInject: true }).then(function (user) {
+  //    assert.equal(user.id, 88);
+  //    assert.isTrue(eagerUser === user);
+  //    assert.isTrue(DS.filter('user')[0] === user);
+  //  }, function () {
+  //    fail('Should not have succeeded!');
+  //  });
+  //
+  //  $rootScope.$apply();
+  //
+  //  eagerUser = DS.filter('user')[0];
+  //  assert.isDefined(eagerUser);
+  //  assert.equal(eagerUser.organizationId, 77);
+  //  assert.notEqual(eagerUser.id, 88);
+  //
+  //  $httpBackend.flush();
+  //});
+});

test/datastore/async_methods/create.test.js

@@ -0,0 +1,148 @@
+describe('DS.destroy', function () {
+  beforeEach(startInjector);
+
+  it('should delete an item from the data store', function (done) {
+    $httpBackend.expectDELETE('http://test.angular-cache.com/posts/5').respond(200, 5);
+
+    DS.inject('post', p1);
+
+    DS.destroy('post', 5).then(function (id) {
+      try {
+        assert.equal(id, 5, 'post 5 should have been deleted');
+        assert.equal(lifecycle.beforeDestroy.callCount, 1, 'beforeDestroy should have been called');
+        assert.equal(lifecycle.afterDestroy.callCount, 1, 'afterDestroy should have been called');
+        assert.isUndefined(DS.get('post', 5));
+        assert.equal(DS.lastModified('post', 5), 0);
+        assert.equal(DS.lastSaved('post', 5), 0);
+        done();
+      } catch (err) {
+        done(err);
+      }
+    }, function (err) {
+      console.error(err.stack);
+      done('should not have rejected');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should handle nested resources', function (done) {
+    var testComment = {
+      id: 5,
+      content: 'test'
+    };
+    var testComment2 = {
+      id: 6,
+      content: 'test',
+      approvedBy: 4
+    };
+
+    DS.inject('comment', testComment);
+
+    $httpBackend.expectDELETE('http://test.angular-cache.com/user/4/comment/5').respond(204);
+
+    DS.destroy('comment', 5, {
+      params: {
+        approvedBy: 4
+      }
+    }).then(null, function () {
+      done('Should not have failed!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        $httpBackend.expectDELETE('http://test.angular-cache.com/user/4/comment/6').respond(204);
+
+        DS.inject('comment', testComment2);
+
+        DS.destroy('comment', 6, {
+          bypassCache: true
+        }).then(null, function () {
+          done('Should not have failed!');
+        });
+
+        setTimeout(function () {
+          try {
+            $httpBackend.flush();
+
+            setTimeout(function () {
+              try {
+                $httpBackend.expectDELETE('http://test.angular-cache.com/comment/6').respond(204);
+                DS.inject('comment', testComment2);
+                DS.destroy('comment', 6, {
+                  params: {
+                    approvedBy: false
+                  }
+                }).then(null, function (err) {
+                  console.log(err.stack);
+                  done('Should not have failed!');
+                });
+
+                setTimeout(function () {
+                  try {
+                    $httpBackend.flush();
+                    done();
+                  } catch (e) {
+                    done(e);
+                  }
+                }, 30);
+              } catch (e) {
+                done(e);
+              }
+            }, 30);
+          } catch (e) {
+            done(e);
+          }
+        }, 30);
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  // not yet implemented in js-data
+  //it('should eager eject', function (done) {
+  //  $httpBackend.expectDELETE('http://test.angular-cache.com/posts/5').respond(200, 5);
+  //
+  //  DS.inject('post', p1);
+  //
+  //  DS.destroy('post', 5, { eagerEject: true }).then(function (id) {
+  //    assert.equal(id, 5, 'post 5 should have been deleted');
+  //  }, function (err) {
+  //    console.error(err.stack);
+  //    fail('should not have rejected');
+  //  });
+  //
+  //  $rootScope.$apply();
+  //
+  //  assert.isUndefined(DS.get('post', 5));
+  //
+  //  setTimeout(function () {
+  //    try {
+  //      $httpBackend.flush();
+  //
+  //      setTimeout(function () {
+  //        try {
+  //          assert.equal(lifecycle.beforeDestroy.callCount, 1, 'beforeDestroy should have been called');
+  //          assert.equal(lifecycle.afterDestroy.callCount, 1, 'afterDestroy should have been called');
+  //          assert.isUndefined(DS.get('post', 5));
+  //          assert.equal(DS.lastModified('post', 5), 0);
+  //          assert.equal(DS.lastSaved('post', 5), 0);
+  //
+  //          done();
+  //        } catch (e) {
+  //          done(e);
+  //        }
+  //      });
+  //    } catch (e) {
+  //      done(e);
+  //    }
+  //  }, 30);
+  //});
+});

test/datastore/async_methods/destroy.test.js

@@ -0,0 +1,152 @@
+describe('DS.destroyAll', function () {
+  beforeEach(startInjector);
+
+  it('should query the server for a collection', function (done) {
+    $httpBackend.expectDELETE('http://test.angular-cache.com/posts?where=%7B%22age%22:33%7D').respond(200);
+
+    DS.inject('post', p1);
+    DS.inject('post', p2);
+    DS.inject('post', p3);
+    DS.inject('post', p4);
+    DS.inject('post', p5);
+
+    DS.destroyAll('post', { where: { age: 33 } }).then(null, function (err) {
+      console.error(err.stack);
+      done('Should not have rejected!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        setTimeout(function () {
+          try {
+            assert.isDefined(DS.get('post', 5));
+            assert.isDefined(DS.get('post', 6));
+            assert.isDefined(DS.get('post', 7));
+            assert.isUndefined(DS.get('post', 8));
+            assert.isUndefined(DS.get('post', 9));
+
+            $httpBackend.expectDELETE('http://test.angular-cache.com/posts').respond(200);
+
+            DS.inject('post', p1);
+            DS.inject('post', p2);
+            DS.inject('post', p3);
+            DS.inject('post', p4);
+            DS.inject('post', p5);
+
+            DS.destroyAll('post', {}).then(null, function (err) {
+              console.error(err.stack);
+              done('Should not have rejected!');
+            });
+
+            setTimeout(function () {
+              try {
+                $httpBackend.flush();
+
+                setTimeout(function () {
+                  try {
+                    assert.deepEqual(DS.filter('post', {}), [], 'The posts should not be in the store yet');
+
+                    done();
+                  } catch (e) {
+                    done(e);
+                  }
+                });
+              } catch (e) {
+                done(e);
+              }
+            }, 30);
+          } catch (e) {
+            done(e);
+          }
+        });
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should handle nested resources', function (done) {
+    $httpBackend.expectDELETE('http://test.angular-cache.com/user/4/comment?content=test').respond(204);
+
+    DS.destroyAll('comment', {
+      content: 'test'
+    }, {
+      params: {
+        approvedBy: 4
+      }
+    }).then(function () {
+    }, function (err) {
+      console.log(err);
+      fail('Should not have failed!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        setTimeout(function () {
+          try {
+            $httpBackend.expectDELETE('http://test.angular-cache.com/comment?content=test').respond(204);
+
+            DS.destroyAll('comment', {
+              content: 'test'
+            }).then(function () {
+            }, function (err) {
+              console.log(err);
+              fail('Should not have failed!');
+            });
+
+            setTimeout(function () {
+              try {
+                $httpBackend.flush();
+
+                setTimeout(function () {
+                  try {
+                    $httpBackend.expectDELETE('http://test.angular-cache.com/comment?content=test').respond(204);
+
+                    DS.destroyAll('comment', {
+                      content: 'test'
+                    }, {
+                      params: {
+                        approvedBy: false
+                      }
+                    }).then(function () {
+                    }, function (err) {
+                      console.log(err);
+                      fail('Should not have failed!');
+                    });
+
+                    setTimeout(function () {
+                      try {
+                        $httpBackend.flush();
+
+                        setTimeout(function () {
+                          try {
+                            done();
+                          } catch (e) {
+                            done(e);
+                          }
+                        });
+                      } catch (e) {
+                        done(e);
+                      }
+                    }, 30);
+                  } catch (e) {
+                    done(e);
+                  }
+                });
+              } catch (e) {
+                done(e);
+              }
+            }, 30);
+          } catch (e) {
+            done(e);
+          }
+        });
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+});

test/datastore/async_methods/destroyAll.test.js

@@ -0,0 +1,242 @@
+describe('DS.find', function () {
+  beforeEach(startInjector);
+
+  it('should get an item from the server', function (done) {
+    $httpBackend.expectGET('http://test.angular-cache.com/posts/5').respond(200, p1);
+
+    DS.find('post', 5).then(function (post) {
+      assert.deepEqual(angular.toJson(post), angular.toJson(p1));
+    }, function (err) {
+      console.error(err.stack);
+      fail('Should not have rejected!');
+    });
+
+    assert.isUndefined(DS.get('post', 5), 'The post should not be in the store yet');
+
+    // Should have no effect because there is already a pending query
+    DS.find('post', 5).then(function (post) {
+      assert.deepEqual(angular.toJson(post), angular.toJson(p1));
+    }, function (err) {
+      console.error(err.stack);
+      fail('Should not have rejected!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        setTimeout(function () {
+          try {
+            assert.deepEqual(angular.toJson(DS.get('post', 5)), angular.toJson(p1), 'The post is now in the store');
+            assert.isNumber(DS.lastModified('post', 5));
+            assert.isNumber(DS.lastSaved('post', 5));
+
+            // Should not make a request because the request was already completed
+            DS.find('post', 5).then(function (post) {
+              assert.deepEqual(angular.toJson(post), angular.toJson(p1));
+            }, function (err) {
+              console.error(err.stack);
+              fail('Should not have rejected!');
+            });
+
+            $httpBackend.expectGET('http://test.angular-cache.com/posts/5').respond(200, p1);
+
+            // Should make a request because bypassCache is set to true
+            DS.find('post', 5, { bypassCache: true }).then(function (post) {
+              assert.deepEqual(angular.toJson(post), angular.toJson(p1));
+            }, function (err) {
+              console.error(err.stack);
+              fail('Should not have rejected!');
+            });
+
+            setTimeout(function () {
+              try {
+                $httpBackend.flush();
+
+                setTimeout(function () {
+                  try {
+                    assert.equal(lifecycle.beforeInject.callCount, 2, 'beforeInject should have been called');
+                    assert.equal(lifecycle.afterInject.callCount, 2, 'afterInject should have been called');
+                    assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
+                    assert.equal(lifecycle.deserialize.callCount, 2, 'deserialize should have been called');
+
+                    done();
+                  } catch (e) {
+                    done(e);
+                  }
+                });
+              } catch (e) {
+                done(e);
+              }
+            }, 30);
+          } catch (e) {
+            done(e);
+          }
+        });
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should get an item from the server but not store it if cacheResponse is false', function (done) {
+    $httpBackend.expectGET('http://test.angular-cache.com/posts/5').respond(200, p1);
+
+    DS.find('post', 5, { cacheResponse: false }).then(function (post) {
+      assert.deepEqual(angular.toJson(post), angular.toJson(p1));
+    }, function (err) {
+      console.error(err.stack);
+      fail('Should not have rejected!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        setTimeout(function () {
+          try {
+            assert.isUndefined(DS.get('post', 5), 'The post should not have been injected into the store');
+            assert.equal(lifecycle.beforeInject.callCount, 0, 'beforeInject should have been called');
+            assert.equal(lifecycle.afterInject.callCount, 0, 'afterInject should have been called');
+            assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
+            assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');
+
+            done();
+          } catch (e) {
+            done(e);
+          }
+        });
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should correctly propagate errors', function (done) {
+    $httpBackend.expectGET('http://test.angular-cache.com/posts/5').respond(404, 'Not Found');
+
+    DS.find('post', 5).then(function () {
+      done('Should not have succeeded!');
+    }, function (err) {
+      assert.equal(err.data, 'Not Found');
+      done();
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+      } catch (e) {
+        console.log(e);
+        done(e);
+      }
+    }, 30);
+  });
+  it('should handle nested resources', function (done) {
+    var testComment = {
+      id: 5,
+      content: 'test',
+      approvedBy: 4
+    };
+    $httpBackend.expectGET('http://test.angular-cache.com/user/4/comment/5').respond(200, testComment);
+
+    DS.find('comment', 5, {
+      params: {
+        approvedBy: 4
+      }
+    }).then(function (comment) {
+      assert.deepEqual(angular.toJson(comment), angular.toJson(testComment));
+      assert.deepEqual(angular.toJson(comment), angular.toJson(DS.get('comment', 5)));
+    }, function () {
+      fail('Should not have failed!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        setTimeout(function () {
+          try {
+            $httpBackend.expectGET('http://test.angular-cache.com/user/4/comment/5').respond(200, testComment);
+
+            DS.find('comment', 5, {
+              bypassCache: true
+            }).then(function (comment) {
+              assert.deepEqual(angular.toJson(comment), angular.toJson(testComment));
+              assert.deepEqual(angular.toJson(comment), angular.toJson(DS.get('comment', 5)));
+            }, function () {
+              fail('Should not have failed!');
+            });
+
+            setTimeout(function () {
+              try {
+                $httpBackend.flush();
+
+                setTimeout(function () {
+                  try {
+                    $httpBackend.expectGET('http://test.angular-cache.com/comment/5').respond(200, testComment);
+
+                    DS.find('comment', 5, {
+                      bypassCache: true,
+                      params: {
+                        approvedBy: false
+                      }
+                    }).then(function (comment) {
+                      assert.deepEqual(angular.toJson(comment), angular.toJson(testComment));
+                      assert.deepEqual(angular.toJson(comment), angular.toJson(DS.get('comment', 5)));
+                    }, function () {
+                      fail('Should not have failed!');
+                    });
+
+                    setTimeout(function () {
+                      try {
+                        $httpBackend.flush();
+
+                        setTimeout(function () {
+                          try {
+                            $httpBackend.expectGET('http://test.angular-cache.com/organization/14/user/19/comment/19').respond(200, comment19);
+
+                            DS.find('comment', 19, {
+                              bypassCache: true,
+                              params: {
+                                approvedBy: 19,
+                                organizationId: 14
+                              }
+                            }).then(function (comment) {
+                              assert.equal(comment.id, comment19.id);
+                              assert.equal(comment.id, DS.get('comment', 19).id);
+                            }, function () {
+                              fail('Should not have failed!');
+                            });
+
+                            setTimeout(function () {
+                              try {
+                                $httpBackend.flush();
+                                done();
+                              } catch (e) {
+                                done(e);
+                              }
+                            }, 30);
+                          } catch (e) {
+                            done(e);
+                          }
+                        });
+                      } catch (e) {
+                        done(e);
+                      }
+                    }, 30);
+                  } catch (e) {
+                    done(e);
+                  }
+                });
+              } catch (e) {
+                done(e);
+              }
+            }, 30);
+          } catch (e) {
+            done(e);
+          }
+        });
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+});

test/datastore/async_methods/find.test.js

@@ -0,0 +1,387 @@
+describe('DS.findAll', function () {
+
+  beforeEach(startInjector);
+
+  it('should query the server for a collection', function (done) {
+    $httpBackend.expectGET(/http:\/\/test\.angular-cache\.com\/posts\??/).respond(200, [p1, p2, p3, p4]);
+
+    DS.findAll('post', {}).then(function (data) {
+      assert.deepEqual(angular.toJson(data), angular.toJson([p1, p2, p3, p4]));
+    }, function (err) {
+      console.error(err.stack);
+      fail('Should not have rejected!');
+    });
+
+    assert.deepEqual(DS.filter('post', {}), [], 'The posts should not be in the store yet');
+
+    // Should have no effect because there is already a pending query
+    DS.findAll('post', {}).then(function (data) {
+      assert.deepEqual(angular.toJson(data), angular.toJson([p1, p2, p3, p4]));
+    }, function (err) {
+      console.error(err.stack);
+      fail('Should not have rejected!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        setTimeout(function () {
+          try {
+            assert.deepEqual(angular.toJson(DS.filter('post', {})), angular.toJson([p1, p2, p3, p4]), 'The posts are now in the store');
+            assert.isNumber(DS.lastModified('post', 5));
+            assert.isNumber(DS.lastSaved('post', 5));
+            DS.find('post', p1.id); // should not trigger another XHR
+
+
+            // Should not make a request because the request was already completed
+            DS.findAll('post', {}).then(function (data) {
+              assert.deepEqual(angular.toJson(data), angular.toJson([p1, p2, p3, p4]));
+            }, function (err) {
+              console.error(err.stack);
+              fail('Should not have rejected!');
+            });
+
+            $httpBackend.expectGET(/http:\/\/test\.angular-cache\.com\/posts\??/).respond(200, [p1, p2, p3, p4]);
+
+            // Should make a request because bypassCache is set to true
+            DS.findAll('post', {}, { bypassCache: true }).then(function (data) {
+              assert.deepEqual(angular.toJson(data), angular.toJson([p1, p2, p3, p4]));
+            }, function (err) {
+              console.error(err.stack);
+              fail('Should not have rejected!');
+            });
+
+            setTimeout(function () {
+              try {
+                $httpBackend.flush();
+
+                setTimeout(function () {
+                  try {
+                    assert.equal(lifecycle.beforeInject.callCount, 2, 'beforeInject should have been called');
+                    assert.equal(lifecycle.afterInject.callCount, 2, 'afterInject should have been called');
+                    assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
+                    assert.equal(lifecycle.deserialize.callCount, 2, 'deserialize should have been called');
+                    done();
+                  } catch (e) {
+                    done(e);
+                  }
+                });
+              } catch (e) {
+                done(e);
+              }
+            }, 30);
+          } catch (e) {
+            done(e);
+          }
+        });
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should query the server for a collection but not store the data if cacheResponse is false', function (done) {
+    $httpBackend.expectGET(/http:\/\/test\.angular-cache\.com\/posts\??/).respond(200, [p1, p2, p3, p4]);
+
+    DS.findAll('post', {}, { cacheResponse: false }).then(function (data) {
+      assert.deepEqual(angular.toJson(data), angular.toJson([p1, p2, p3, p4]));
+    }, function (err) {
+      console.error(err.stack);
+      fail('Should not have rejected!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        setTimeout(function () {
+          try {
+            assert.deepEqual(angular.toJson(DS.filter('post', {})), angular.toJson([]), 'The posts should not have been injected into the store');
+
+            assert.equal(lifecycle.beforeInject.callCount, 0, 'beforeInject should have been called');
+            assert.equal(lifecycle.afterInject.callCount, 0, 'afterInject should have been called');
+            assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
+            assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');
+
+            done();
+          } catch (e) {
+            done(e);
+          }
+        });
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should correctly propagate errors', function (done) {
+    $httpBackend.expectGET(/http:\/\/test\.angular-cache\.com\/posts\??/).respond(404, 'Not Found');
+
+    DS.findAll('post', {}).then(function () {
+      done('Should not have succeeded!');
+    }, function (err) {
+      assert.equal(err.data, 'Not Found');
+      done();
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('"params" argument is optional', function (done) {
+    $httpBackend.expectGET(/http:\/\/test\.angular-cache\.com\/posts\??/).respond(200, [p1, p2, p3, p4]);
+
+    DS.findAll('post').then(function (data) {
+      assert.deepEqual(angular.toJson(data), angular.toJson([p1, p2, p3, p4]));
+    }, function (err) {
+      console.error(err.message);
+      fail('Should not have rejected!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        setTimeout(function () {
+          try {
+            assert.deepEqual(angular.toJson(DS.filter('post', {})), angular.toJson([p1, p2, p3, p4]), 'The posts are now in the store');
+
+            assert.equal(lifecycle.beforeInject.callCount, 1 , 'beforeInject should have been called');
+            assert.equal(lifecycle.afterInject.callCount, 1, 'afterInject should have been called');
+            assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
+            assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');
+
+            done();
+          } catch (e) {
+            done(e);
+          }
+        });
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('"params"', function (done) {
+    $httpBackend.expectGET('http://test.angular-cache.com/posts?where=%7B%22author%22:%22Adam%22%7D').respond(200, [p4, p5]);
+
+    var params = {
+      where: {
+        author: 'Adam'
+      }
+    };
+    DS.findAll('post', params).then(function (data) {
+      assert.deepEqual(angular.toJson(data), angular.toJson([p4, p5]));
+    }, function (err) {
+      console.error(err.message);
+      fail('Should not have rejected!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        setTimeout(function () {
+          try {
+            assert.deepEqual(angular.toJson(DS.filter('post', params)), angular.toJson([p4, p5]), 'The posts are now in the store');
+            assert.deepEqual(angular.toJson(DS.filter('post', {
+              where: {
+                id: {
+                  '>': 8
+                }
+              }
+            })), angular.toJson([p5]), 'The posts are now in the store');
+
+            assert.equal(lifecycle.beforeInject.callCount, 1, 'beforeInject should have been called');
+            assert.equal(lifecycle.afterInject.callCount, 1, 'afterInject should have been called');
+            assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
+            assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');
+
+            done();
+          } catch (e) {
+            done(e);
+          }
+        });
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should return already injected items', function (done) {
+    var u1 = {
+        id: 1,
+        name: 'John'
+      },
+      u2 = {
+        id: 2,
+        name: 'Sally'
+      };
+
+    DS.defineResource({
+      name: 'person',
+      endpoint: 'users',
+      methods: {
+        fullName: function () {
+          return this.first + ' ' + this.last;
+        }
+      }
+    });
+
+    $httpBackend.expectGET(/http:\/\/test\.angular-cache\.com\/users\??/).respond(200, [u1, u2]);
+
+    DS.findAll('person').then(function (data) {
+      assert.deepEqual(angular.toJson(data), angular.toJson([
+        DSUtils.deepMixIn(new DS.definitions.person[DS.definitions.person.class](), u1),
+        DSUtils.deepMixIn(new DS.definitions.person[DS.definitions.person.class](), u2)
+      ]));
+      angular.forEach(data, function (person) {
+        assert.isTrue(person instanceof DS.definitions.person[DS.definitions.person.class], 'should be an instance of User');
+      });
+    }, function (err) {
+      console.error(err.message);
+      fail('Should not have rejected!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+
+        setTimeout(function () {
+          try {
+            assert.deepEqual(angular.toJson(DS.filter('person')), angular.toJson([
+              DSUtils.deepMixIn(new DS.definitions.person[DS.definitions.person.class](), u1),
+              DSUtils.deepMixIn(new DS.definitions.person[DS.definitions.person.class](), u2)
+            ]), 'The users are now in the store');
+
+            assert.equal(lifecycle.beforeInject.callCount, 1, 'beforeInject should have been called');
+            assert.equal(lifecycle.afterInject.callCount, 1, 'afterInject should have been called');
+            assert.equal(lifecycle.serialize.callCount, 0, 'serialize should have been called');
+            assert.equal(lifecycle.deserialize.callCount, 1, 'deserialize should have been called');
+
+            done();
+          } catch (e) {
+            done(e);
+          }
+        });
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should handle nested resources', function (done) {
+    var testComment = {
+      id: 5,
+      content: 'test',
+      approvedBy: 4
+    };
+    var testComment2 = {
+      id: 6,
+      content: 'test',
+      approvedBy: 4
+    };
+    $httpBackend.expectGET('http://test.angular-cache.com/user/4/comment?content=test').respond(200, [testComment, testComment2]);
+
+    DS.findAll('comment', {
+      content: 'test'
+    }, {
+      params: {
+        approvedBy: 4
+      }
+    }).then(function (comments) {
+      assert.deepEqual(angular.toJson(comments), angular.toJson([testComment, testComment2]));
+      assert.deepEqual(angular.toJson(comments), angular.toJson(DS.filter('comment', {
+        content: 'test'
+      })));
+      done();
+    }, function () {
+      done('Should not have failed!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should handle nested resources 2', function (done) {
+    var testComment = {
+      id: 5,
+      content: 'test',
+      approvedBy: 4
+    };
+    var testComment2 = {
+      id: 6,
+      content: 'test',
+      approvedBy: 4
+    };
+
+    $httpBackend.expectGET('http://test.angular-cache.com/comment?content=test').respond(200, [testComment, testComment2]);
+
+    DS.findAll('comment', {
+      content: 'test'
+    }, {
+      bypassCache: true
+    }).then(function (comments) {
+      assert.deepEqual(angular.toJson(comments), angular.toJson([testComment, testComment2]));
+      assert.deepEqual(angular.toJson(comments), angular.toJson(DS.filter('comment', {
+        content: 'test'
+      })));
+      done();
+    }, function () {
+      done('Should not have failed!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+  it('should handle nested resources 3', function (done) {
+    var testComment = {
+      id: 5,
+      content: 'test',
+      approvedBy: 4
+    };
+    var testComment2 = {
+      id: 6,
+      content: 'test',
+      approvedBy: 4
+    };
+
+    DS.ejectAll('comment');
+
+    $httpBackend.expectGET('http://test.angular-cache.com/comment?content=test').respond(200, [testComment, testComment2]);
+
+    DS.findAll('comment', {
+      content: 'test'
+    }, {
+      bypassCache: true,
+      params: {
+        approvedBy: false
+      }
+    }).then(function (comments) {
+      assert.deepEqual(angular.toJson(comments), angular.toJson([testComment, testComment2]));
+      assert.deepEqual(angular.toJson(comments), angular.toJson(DS.filter('comment', {
+        content: 'test'
+      })));
+      done();
+    }, function () {
+      done('Should not have failed!');
+    });
+
+    setTimeout(function () {
+      try {
+        $httpBackend.flush();
+      } catch (e) {
+        done(e);
+      }
+    }, 30);
+  });
+});