ember-data-source 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2eb4cb649c5ee137f864ad0f1e1f3016d2e40fe1
-  data.tar.gz: e0165c6093acdae51c9b85ee4bfba0a9ac639dfd
+  metadata.gz: 99cbb3e7aeb8402514a2c16df64ff6fa3dddbdbe
+  data.tar.gz: 0074152bef6776110c690b11c710f2989be1dc1a
 SHA512:
-  metadata.gz: 2d4456415e2c4da997c488d60bfdbd0b18b61992af101acf90956c07ebb7613f3b22d8b496030c24cc61d45a34aeca088f840e1941333a725d8241a2b4441724
-  data.tar.gz: eb1453c7da01d62be09739a8871518166ba999c569446d68dd8c4ffb78d78f6b7d3cf7804cee55b6ad5a64733b1596303df33507b57b34dbe5c564703ca9b7c2
+  metadata.gz: 7572751098acad398e2e478038b22093031aa42c227e1445547902a3cb08476a3a642c15ef77076545003950c27f3a9a3cf0eede684e7d0bc41ac384047e3066
+  data.tar.gz: e98bbfa7a24ce04ad082a26df0e616f93777b0db980ad7814cceb64e655722172b7ed639e77c2a7398a5dc149ba7537aff8bd281d05d6348e58d079cfe0148f7

data/dist/ember-data-tests.js

@@ -4287,7 +4287,7 @@ define(
     var run = Ember.run;
     var Person, Dog, env, store, adapter;
 
-    module("integration/adapter/store_adapter - DS.Store and DS.Adapter integration test", {
+    module("integration/adapter/store-adapter - DS.Store and DS.Adapter integration test", {
       setup: function () {
         Person = DS.Model.extend({
           updatedAt: DS.attr('string'),
@@ -4731,7 +4731,13 @@ define(
         equal(type, Person, "the type is correct");
 
         if (snapshot.attr('name').indexOf('Bro') === -1) {
-          return Ember.RSVP.reject(new DS.InvalidError({ name: ['common... name requires a "bro"'] }));
+          return Ember.RSVP.reject(new DS.InvalidError([{
+            title: 'Invalid Attribute',
+            detail: 'common... name requires a "bro"',
+            source: {
+              pointer: '/data/attributes/name'
+            }
+          }]));
         } else {
           return Ember.RSVP.resolve();
         }
@@ -4770,7 +4776,13 @@ define(
     test("allows errors on arbitrary properties on create", function () {
       adapter.createRecord = function (store, type, snapshot) {
         if (snapshot.attr('name').indexOf('Bro') === -1) {
-          return Ember.RSVP.reject(new DS.InvalidError({ base: ['is a generally unsavoury character'] }));
+          return Ember.RSVP.reject(new DS.InvalidError([{
+            title: "Invalid Attribute",
+            detail: "is a generally unsavoury character",
+            source: {
+              pointer: "/data/attributes/base"
+            }
+          }]));
         } else {
           return Ember.RSVP.resolve();
         }
@@ -4816,7 +4828,13 @@ define(
         saveCount++;
 
         if (snapshot.attr('name').indexOf('Bro') === -1) {
-          return Ember.RSVP.reject(new DS.InvalidError({ name: ['common... name requires a "bro"'] }));
+          return Ember.RSVP.reject(new DS.InvalidError([{
+            title: 'Invalid Attribute',
+            detail: 'common... name requires a "bro"',
+            source: {
+              pointer: '/data/attributes/name'
+            }
+          }]));
         } else {
           return Ember.RSVP.resolve();
         }
@@ -4880,7 +4898,13 @@ define(
         equal(type, Person, "the type is correct");
 
         if (snapshot.attr('name').indexOf('Bro') === -1) {
-          return Ember.RSVP.reject(new DS.InvalidError({ name: ['common... name requires a "bro"'] }));
+          return Ember.RSVP.reject(new DS.InvalidError([{
+            title: 'Invalid Attribute',
+            detail: 'common... name requires a "bro"',
+            source: {
+              pointer: '/data/attributes/name'
+            }
+          }]));
         } else {
           return Ember.RSVP.resolve();
         }
@@ -4935,7 +4959,13 @@ define(
       };
       adapter.updateRecord = function (store, type, snapshot) {
         if (snapshot.attr('name').indexOf('Bro') === -1) {
-          return Ember.RSVP.reject(new DS.InvalidError({ base: ['is a generally unsavoury character'] }));
+          return Ember.RSVP.reject(new DS.InvalidError([{
+            title: "Invalid Attribute",
+            detail: "is a generally unsavoury character",
+            source: {
+              pointer: "/data/attributes/base"
+            }
+          }]));
         } else {
           return Ember.RSVP.resolve();
         }
@@ -4997,7 +5027,13 @@ define(
         equal(type, Person, "the type is correct");
         saveCount++;
         if (snapshot.attr('name').indexOf('Bro') === -1) {
-          return Ember.RSVP.reject(new DS.InvalidError({ name: ['common... name requires a "bro"'] }));
+          return Ember.RSVP.reject(new DS.InvalidError([{
+            title: 'Invalid Attribute',
+            detail: 'common... name requires a "bro"',
+            source: {
+              pointer: '/data/attributes/name'
+            }
+          }]));
         } else {
           return Ember.RSVP.resolve();
         }
@@ -9993,6 +10029,128 @@ define(
         ok(user._internalModel._relationships.has('favouriteMessage'), "Newly created record with relationships in params passed in its constructor should have relationships");
       });
     });
+
+    test("Related link should be fetched when no local data is present", function () {
+      expect(3);
+
+      Book.reopen({
+        author: DS.belongsTo('author', { async: true })
+      });
+
+      env.adapter.findBelongsTo = function (store, snapshot, url, relationship) {
+        equal(url, 'author', 'url is correct');
+        ok(true, "The adapter's findBelongsTo method should be called");
+        return Ember.RSVP.resolve({ id: 1, name: 'This is author' });
+      };
+
+      run(function () {
+        var book = env.store.push({
+          data: {
+            type: 'book',
+            id: '1',
+            relationships: {
+              author: {
+                links: {
+                  related: 'author'
+                }
+              }
+            }
+          }
+        });
+        book.get('author').then(function (author) {
+          equal(author.get('name'), 'This is author', 'author name is correct');
+        });
+      });
+    });
+
+    test("Local data should take precedence over related link", function () {
+      expect(1);
+
+      Book.reopen({
+        author: DS.belongsTo('author', { async: true })
+      });
+
+      env.adapter.findBelongsTo = function (store, snapshot, url, relationship) {
+        ok(false, "The adapter's findBelongsTo method should not be called");
+      };
+
+      env.adapter.findRecord = function (store, type, id, snapshot) {
+        return Ember.RSVP.resolve({ id: 1, name: 'This is author' });
+      };
+
+      run(function () {
+        var book = env.store.push({
+          data: {
+            type: 'book',
+            id: '1',
+            relationships: {
+              author: {
+                links: {
+                  related: 'author'
+                },
+                data: { type: 'author', id: '1' }
+              }
+            }
+          }
+        });
+        book.get('author').then(function (author) {
+          equal(author.get('name'), 'This is author', 'author name is correct');
+        });
+      });
+    });
+
+    test("Updated related link should take precedence over local data", function () {
+      expect(3);
+
+      Book.reopen({
+        author: DS.belongsTo('author', { async: true })
+      });
+
+      env.adapter.findBelongsTo = function (store, snapshot, url, relationship) {
+        equal(url, 'author-updated-link', 'url is correct');
+        ok(true, "The adapter's findBelongsTo method should be called");
+        return Ember.RSVP.resolve({ id: 1, name: 'This is author' });
+      };
+
+      env.adapter.findRecord = function (store, type, id, snapshot) {
+        ok(false, "The adapter's findRecord method should not be called");
+      };
+
+      run(function () {
+        var book = env.store.push({
+          data: {
+            type: 'book',
+            id: '1',
+            relationships: {
+              author: {
+                links: {
+                  related: 'author'
+                },
+                data: { type: 'author', id: '1' }
+              }
+            }
+          }
+        });
+
+        env.store.push({
+          data: {
+            type: 'book',
+            id: '1',
+            relationships: {
+              author: {
+                links: {
+                  related: 'author-updated-link'
+                }
+              }
+            }
+          }
+        });
+
+        book.get('author').then(function (author) {
+          equal(author.get('name'), 'This is author', 'author name is correct');
+        });
+      });
+    });
   }
 );
 
@@ -12224,6 +12382,128 @@ define(
         });
       });
     });
+
+    test("Related link should be fetched when no local data is present", function () {
+      expect(3);
+
+      Post.reopen({
+        comments: DS.hasMany('comment', { async: true })
+      });
+
+      env.adapter.findHasMany = function (store, snapshot, url, relationship) {
+        equal(url, 'comments', 'url is correct');
+        ok(true, "The adapter's findHasMany method should be called");
+        return Ember.RSVP.resolve([{ id: 1, body: 'This is comment' }]);
+      };
+
+      run(function () {
+        var post = env.store.push({
+          data: {
+            type: 'post',
+            id: '1',
+            relationships: {
+              comments: {
+                links: {
+                  related: 'comments'
+                }
+              }
+            }
+          }
+        });
+        post.get('comments').then(function (comments) {
+          equal(comments.get('firstObject.body'), 'This is comment', 'comment body is correct');
+        });
+      });
+    });
+
+    test("Local data should take precedence over related link", function () {
+      expect(1);
+
+      Post.reopen({
+        comments: DS.hasMany('comment', { async: true })
+      });
+
+      env.adapter.findHasMany = function (store, snapshot, url, relationship) {
+        ok(false, "The adapter's findHasMany method should not be called");
+      };
+
+      env.adapter.findRecord = function (store, type, id, snapshot) {
+        return Ember.RSVP.resolve({ id: 1, body: 'This is comment' });
+      };
+
+      run(function () {
+        var post = env.store.push({
+          data: {
+            type: 'post',
+            id: '1',
+            relationships: {
+              comments: {
+                links: {
+                  related: 'comments'
+                },
+                data: [{ type: 'comment', id: '1' }]
+              }
+            }
+          }
+        });
+        post.get('comments').then(function (comments) {
+          equal(comments.get('firstObject.body'), 'This is comment', 'comment body is correct');
+        });
+      });
+    });
+
+    test("Updated related link should take precedence over local data", function () {
+      expect(3);
+
+      Post.reopen({
+        comments: DS.hasMany('comment', { async: true })
+      });
+
+      env.adapter.findHasMany = function (store, snapshot, url, relationship) {
+        equal(url, 'comments-updated-link', 'url is correct');
+        ok(true, "The adapter's findHasMany method should be called");
+        return Ember.RSVP.resolve([{ id: 1, body: 'This is comment' }]);
+      };
+
+      env.adapter.findRecord = function (store, type, id, snapshot) {
+        ok(false, "The adapter's findRecord method should not be called");
+      };
+
+      run(function () {
+        var post = env.store.push({
+          data: {
+            type: 'post',
+            id: '1',
+            relationships: {
+              comments: {
+                links: {
+                  related: 'comments'
+                },
+                data: [{ type: 'comment', id: '1' }]
+              }
+            }
+          }
+        });
+
+        env.store.push({
+          data: {
+            type: 'post',
+            id: '1',
+            relationships: {
+              comments: {
+                links: {
+                  related: 'comments-updated-link'
+                }
+              }
+            }
+          }
+        });
+
+        post.get('comments').then(function (comments) {
+          equal(comments.get('firstObject.body'), 'This is comment', 'comment body is correct');
+        });
+      });
+    });
   }
 );
 
@@ -21451,7 +21731,7 @@ define(
       __exports__[name] = value;
     }
 
-    module("unit/adapter/errors - DS.AdapterError");
+    module("unit/adapter-errors - DS.AdapterError");
 
     test("DS.AdapterError", function () {
       var error = new DS.AdapterError();
@@ -21514,18 +21794,12 @@ define(
       deepEqual(result, { name: ['error message'] });
     });
 
-    test("DS.InvalidError will normalize errors hash with deprecation", function () {
+    test("DS.InvalidError will normalize errors hash will assert", function () {
       var error;
 
-      expectDeprecation(function () {
+      expectAssertion(function () {
         error = new DS.InvalidError({ name: ['is invalid'] });
       }, /expects json-api formatted errors/);
-
-      deepEqual(error.errors, [{
-        title: 'Invalid Attribute',
-        detail: 'is invalid',
-        source: { pointer: '/data/attributes/name' }
-      }]);
     });
   }
 );
@@ -23881,7 +24155,13 @@ define(
         updateRecord: function (store, type, snapshot) {
           equal(callCount, 0, "becameInvalid callback was not called until recordWasInvalid is called");
 
-          return Ember.RSVP.reject(new DS.InvalidError({ bar: 'error' }));
+          return Ember.RSVP.reject(new DS.InvalidError([{
+            title: "Invalid Attribute",
+            detail: "error",
+            source: {
+              pointer: "/data/attributes/bar"
+            }
+          }]));
         }
       });
 
@@ -26893,18 +27173,21 @@ define(
     var get = Ember.get;
     var set = Ember.set;
     var resolve = Ember.RSVP.resolve;
-    var TestAdapter, store, person;
+    var TestAdapter, store, person, oldFilterEnabled;
     var run = Ember.run;
 
     module("unit/store/adapter-interop - DS.Store working with a DS.Adapter", {
       setup: function () {
         TestAdapter = DS.Adapter.extend();
+        oldFilterEnabled = Ember.ENV.ENABLE_DS_FILTER;
+        Ember.ENV.ENABLE_DS_FILTER = false;
       },
       teardown: function () {
         run(function () {
           if (store) {
             store.destroy();
           }
+          Ember.ENV.ENABLE_DS_FILTER = oldFilterEnabled;
         });
       }
     });
@@ -28113,6 +28396,38 @@ define(
       equal(store.peekRecord('person', 1).get('name'), 'Tom');
     });
 
+    test("store should assert of the user tries to call store.filter", function () {
+      expect(1);
+
+      var Person = DS.Model.extend({
+        name: DS.attr('string')
+      });
+
+      store = createStore({
+        person: Person
+      });
+
+      expectAssertion(function () {
+        run(function () {
+          store.filter('person', {});
+        });
+      }, /The filter API has been moved to a plugin/);
+    });
+
+    test("Calling adapterFor with a model class should assert", function () {
+      var Person = DS.Model.extend({
+        name: DS.attr('string')
+      });
+
+      store = createStore({
+        person: Person
+      });
+
+      expectAssertion(function () {
+        store.adapterFor(Person);
+      }, /Passing classes to store.adapterFor has been removed/);
+    });
+
     module("unit/store/adapter_interop - find preload deprecations", {
       setup: function () {
         var Person = DS.Model.extend({
@@ -29379,12 +29694,13 @@ define(
       __exports__[name] = value;
     }
 
-    var container, store, registry;
+    var container, store, registry, Person;
     var run = Ember.run;
 
     module("unit/store/serializer_for - DS.Store#serializerFor", {
       setup: function () {
-        var env = setupStore({ person: DS.Model.extend() });
+        Person = DS.Model.extend({});
+        var env = setupStore({ person: Person });
         store = env.store;
         container = store.container;
         registry = env.registry;
@@ -29417,6 +29733,12 @@ define(
     test("Calling serializerFor with a type that has not been registered and in an application that does not have an ApplicationSerializer looks up the default Ember Data serializer", function () {
       ok(store.serializerFor('person') instanceof DS.JSONSerializer, "serializer returned from serializerFor is an instance of DS.JSONSerializer");
     });
+
+    test("Calling serializerFor with a model class should assert", function () {
+      expectAssertion(function () {
+        store.serializerFor(Person);
+      }, /Passing classes to store.serializerFor has been removed/);
+    });
   }
 );