ember-data-source 1.13.13 → 1.13.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93e4c4c2eed9329d209f59aecee26e31b08ec5ce
-  data.tar.gz: 8f5ec20dbef2a1faada8d7304f96e639329ef61e
+  metadata.gz: 9699a22612fb166ea94fbf6a0703780fc30d40ce
+  data.tar.gz: c5684aa09224ca6d0bcaf3581556f8cfcb370410
 SHA512:
-  metadata.gz: 9c645bd7be48d6c714249d2bc41e6ca3d4382d5371a40777a7413e73d2255774e193281a5aa58669b83cbbb42c3a2d927e930cb508812811183abaae6394640b
-  data.tar.gz: 488ccd915d9655654bc8d303d8f856fbc3bff073060c56ec1831e07600ea4b462c5f96d487d58569f6f7594257049d7a3aa273fb9e6c091c87a8f6a01afce2a7
+  metadata.gz: 96b247d5d2fb0cde63e9b11a5a2e2bc777bcecefb118d0d49e939aaf10ee181c4cedfb9cd1829c02a478a42ae6c3926f216fe509d9c17a151b543d9b46d8b1ee
+  data.tar.gz: 67871da0a165d7a434284d7e3a4d2804ff1ca593c36a0ac10980c7286e6d880eeb76f067aa83e596cba204bce69cf3c8f508a6fdf414525d104668399ee1deba

data/dist/ember-data-tests.js

@@ -294,7 +294,8 @@ define(
         var json;
 
         run(function () {
-          json = env.amsSerializer.normalizeResponse(env.store, MediocreVillain, json_hash, '1', 'find');
+          var amsSerializer = env.store.serializerFor('application');
+          json = amsSerializer.normalizeResponse(env.store, MediocreVillain, json_hash, '1', 'find');
         });
 
         assert.deepEqual(json, {
@@ -329,7 +330,8 @@ define(
         var json;
 
         run(function () {
-          json = env.amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json_hash, '1', 'find');
+          var amsSerializer = env.store.serializerFor('application');
+          json = amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json_hash, '1', 'find');
         });
 
         assert.deepEqual(json, {
@@ -461,7 +463,8 @@ define(
       var json;
 
       run(function () {
-        json = env.amsSerializer.normalizeResponse(env.store, MediocreVillain, json_hash, '1', 'findRecord');
+        var amsSerializer = env.store.serializerFor('application');
+        json = amsSerializer.normalizeResponse(env.store, MediocreVillain, json_hash, '1', 'findRecord');
       });
 
       assert.deepEqual(json, {
@@ -496,7 +499,8 @@ define(
       var json;
 
       run(function () {
-        json = env.amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json_hash, '1', 'findRecord');
+        var amsSerializer = env.store.serializerFor('application');
+        json = amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json_hash, '1', 'findRecord');
       });
 
       assert.deepEqual(json, {
@@ -751,7 +755,8 @@ define(
         var json;
 
         run(function () {
-          json = env.amsSerializer.normalizeResponse(env.store, MediocreVillain, json_hash, '1', 'find');
+          var amsSerializer = env.store.serializerFor('application');
+          json = amsSerializer.normalizeResponse(env.store, MediocreVillain, json_hash, '1', 'find');
         });
 
         assert.deepEqual(json, {
@@ -794,7 +799,8 @@ define(
         var json;
 
         run(function () {
-          json = env.amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json_hash, '1', 'find');
+          var amsSerializer = env.store.serializerFor('application');
+          json = amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json_hash, '1', 'find');
         });
 
         assert.deepEqual(json, {
@@ -828,7 +834,8 @@ define(
         };
 
         run(function () {
-          json = env.amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json, '1', 'find');
+          var amsSerializer = env.store.serializerFor('application');
+          json = amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json, '1', 'find');
         });
 
         assert.deepEqual(json, {
@@ -857,7 +864,8 @@ define(
         };
 
         run(function () {
-          json = env.amsSerializer.normalizeResponse(env.store, MediocreVillain, json, '1', 'find');
+          var amsSerializer = env.store.serializerFor('application');
+          json = amsSerializer.normalizeResponse(env.store, MediocreVillain, json, '1', 'find');
         });
 
         assert.deepEqual(json, {
@@ -1210,7 +1218,8 @@ define(
       var json;
 
       run(function () {
-        json = env.amsSerializer.normalizeResponse(env.store, MediocreVillain, json_hash, '1', 'findRecord');
+        var amsSerializer = env.store.serializerFor('application');
+        json = amsSerializer.normalizeResponse(env.store, MediocreVillain, json_hash, '1', 'findRecord');
       });
 
       assert.deepEqual(json, {
@@ -1253,7 +1262,8 @@ define(
       var json;
 
       run(function () {
-        json = env.amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json_hash, '1', 'findRecord');
+        var amsSerializer = env.store.serializerFor('application');
+        json = amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json_hash, '1', 'findRecord');
       });
 
       assert.deepEqual(json, {
@@ -1301,7 +1311,8 @@ define(
       var json;
 
       run(function () {
-        json = env.amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json_hash, '1', 'findRecord');
+        var amsSerializer = env.store.serializerFor('application');
+        json = amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json_hash, '1', 'findRecord');
       });
 
       assert.deepEqual(json, {
@@ -1354,7 +1365,8 @@ define(
       var json;
 
       run(function () {
-        json = env.amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json_hash, '1', 'findRecord');
+        var amsSerializer = env.store.serializerFor('application');
+        json = amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json_hash, '1', 'findRecord');
       });
 
       assert.deepEqual(json, {
@@ -1389,7 +1401,8 @@ define(
       };
 
       run(function () {
-        json = env.amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json, '1', 'findRecord');
+        var amsSerializer = env.store.serializerFor('application');
+        json = amsSerializer.normalizeResponse(env.store, DoomsdayDevice, json, '1', 'findRecord');
       });
 
       assert.deepEqual(json, {
@@ -1418,7 +1431,8 @@ define(
       };
 
       run(function () {
-        json = env.amsSerializer.normalizeResponse(env.store, MediocreVillain, json, '1', 'findRecord');
+        var amsSerializer = env.store.serializerFor('application');
+        json = amsSerializer.normalizeResponse(env.store, MediocreVillain, json, '1', 'findRecord');
       });
 
       assert.deepEqual(json, {
@@ -1440,7 +1454,8 @@ define(
       };
 
       run(function () {
-        json = env.amsSerializer.normalizeResponse(env.store, MediocreVillain, json, '1', 'findRecord');
+        var amsSerializer = env.store.serializerFor('application');
+        json = amsSerializer.normalizeResponse(env.store, MediocreVillain, json, '1', 'findRecord');
       });
 
       assert.deepEqual(json, {
@@ -1498,7 +1513,8 @@ define(
       var json, minion;
 
       run(function () {
-        json = env.amsSerializer.normalizeResponse(env.store, DoomsdayDevice, payload, '1', 'findRecord');
+        var amsSerializer = env.store.serializerFor('application');
+        json = amsSerializer.normalizeResponse(env.store, DoomsdayDevice, payload, '1', 'findRecord');
         env.store.push(json);
         minion = env.store.findRecord('doomsday-device', 1);
       });
@@ -1524,7 +1540,8 @@ define(
       var json, villain;
 
       run(function () {
-        json = env.amsSerializer.normalizeResponse(env.store, MediocreVillain, payload, '1', 'findRecord');
+        var amsSerializer = env.store.serializerFor('application');
+        json = amsSerializer.normalizeResponse(env.store, MediocreVillain, payload, '1', 'findRecord');
         env.store.push(json);
         villain = env.store.findRecord('mediocre-villain', '1');
       });
@@ -9300,7 +9317,7 @@ define(
     });
 
     test("Repeated failed saves keeps the record in uncommited state", function () {
-      expect(2);
+      expect(4);
       var post;
 
       run(function () {
@@ -9313,15 +9330,70 @@ define(
 
       run(function () {
         post.save().then(null, function () {
+          ok(post.get('isError'));
           equal(post.get('currentState.stateName'), 'root.loaded.created.uncommitted');
 
           post.save().then(null, function () {
+            ok(post.get('isError'));
             equal(post.get('currentState.stateName'), 'root.loaded.created.uncommitted');
           });
         });
       });
     });
 
+    test("Repeated failed saves with invalid error marks the record as invalid", function () {
+      expect(2);
+      var post;
+
+      run(function () {
+        post = env.store.createRecord('post', { title: 'toto' });
+      });
+
+      env.adapter.createRecord = function (store, type, snapshot) {
+        var error = new DS.InvalidError([{
+          detail: 'is invalid',
+          source: { pointer: 'data/attributes/title' }
+        }]);
+
+        return Ember.RSVP.reject(error);
+      };
+
+      run(function () {
+        post.save().then(null, function () {
+          equal(post.get('isValid'), false);
+
+          post.save().then(null, function () {
+            equal(post.get('isValid'), false);
+          });
+        });
+      });
+    });
+
+    test("Repeated failed saves with invalid error without payload marks the record as invalid", function () {
+      expect(2);
+      var post;
+
+      run(function () {
+        post = env.store.createRecord('post', { title: 'toto' });
+      });
+
+      env.adapter.createRecord = function (store, type, snapshot) {
+        var error = new DS.InvalidError();
+
+        return Ember.RSVP.reject(error);
+      };
+
+      run(function () {
+        post.save().then(null, function () {
+          equal(post.get('isValid'), false);
+
+          post.save().then(null, function () {
+            equal(post.get('isValid'), false);
+          });
+        });
+      });
+    });
+
     test("Will reject save on invalid", function () {
       expect(1);
       var post;
@@ -16927,6 +16999,7 @@ define(
         User = DS.Model.extend({
           firstName: DS.attr('string'),
           lastName: DS.attr('string'),
+          title: DS.attr('string'),
           handles: DS.hasMany('handle', { async: true, polymorphic: true }),
           company: DS.belongsTo('company', { async: true })
         });
@@ -17016,6 +17089,71 @@ define(
         equal(get(user, 'handles.lastObject.nickname'), '@wycats', 'handles.lastObject.nickname is correct');
       });
     });
+
+    test('Serializer should respect the attrs hash when extracting attributes and relationships', function () {
+      env.registry.register("serializer:user", DS.JSONAPISerializer.extend({
+        attrs: {
+          title: "title_attribute_key",
+          company: { key: 'company_relationship_key' }
+        }
+      }));
+
+      var jsonHash = {
+        data: {
+          type: 'users',
+          id: '1',
+          attributes: {
+            'title_attribute_key': 'director'
+          },
+          relationships: {
+            'company_relationship_key': {
+              data: { type: 'companies', id: '2' }
+            }
+          }
+        },
+        included: [{
+          type: 'companies',
+          id: '2',
+          attributes: {
+            name: 'Tilde Inc.'
+          }
+        }]
+      };
+
+      var user = env.store.serializerFor("user").normalizeResponse(env.store, User, jsonHash, '1', 'findRecord');
+
+      equal(user.data.attributes.title, "director");
+      deepEqual(user.data.relationships.company.data, { id: "2", type: "company" });
+    });
+
+    test('Serializer should respect the attrs hash when serializing attributes and relationships', function () {
+      env.registry.register("serializer:user", DS.JSONAPISerializer.extend({
+        attrs: {
+          title: "title_attribute_key",
+          company: { key: 'company_relationship_key' }
+        }
+      }));
+      var company, user;
+
+      run(function () {
+        env.store.push({
+          data: {
+            type: 'company',
+            id: '1',
+            attributes: {
+              name: "Tilde Inc."
+            }
+          }
+        });
+        company = env.store.peekRecord('company', 1);
+        user = env.store.createRecord('user', { firstName: "Yehuda", title: "director", company: company });
+      });
+
+      var payload = env.store.serializerFor("user").serialize(user._createSnapshot());
+
+      equal(payload.data.relationships['company_relationship_key'].data.id, "1");
+      equal(payload.data.attributes['title_attribute_key'], "director");
+    });
   }
 );
 
@@ -17487,6 +17625,90 @@ define(
       equal(payload.my_parent, '2');
     });
 
+    test('Serializer respects if embedded model has an attribute named "type" - #3726', function () {
+      env.registry.register("serializer:parent", DS.JSONSerializer.extend(DS.EmbeddedRecordsMixin, {
+        isNewSerializerAPI: true,
+        attrs: {
+          child: { embedded: 'always' }
+        }
+      }));
+      env.registry.register("serializer:child", DS.JSONSerializer.extend({
+        isNewSerializerAPI: true
+      }));
+      env.registry.register("model:parent", DS.Model.extend({
+        child: DS.belongsTo('child')
+      }));
+      env.registry.register("model:child", DS.Model.extend({
+        type: DS.attr()
+      }));
+
+      var jsonHash = {
+        id: 1,
+        child: {
+          id: 1,
+          type: 'first_type'
+        }
+      };
+
+      Ember.run(function () {
+        var Parent = env.store.modelFor('parent');
+        var payload = env.store.serializerFor('parent').normalizeResponse(env.store, Parent, jsonHash, '1', 'findRecord');
+        deepEqual(payload.included, [{
+          id: '1',
+          type: 'child',
+          attributes: {
+            type: 'first_type'
+          },
+          relationships: {}
+        }]);
+      });
+    });
+
+    test('Serializer respects if embedded model has a relationship named "type" - #3726', function () {
+      env.registry.register("serializer:parent", DS.JSONSerializer.extend(DS.EmbeddedRecordsMixin, {
+        isNewSerializerAPI: true,
+        attrs: {
+          child: { embedded: 'always' }
+        }
+      }));
+      env.registry.register("serializer:child", DS.JSONSerializer.extend({
+        isNewSerializerAPI: true
+      }));
+      env.registry.register("model:parent", DS.Model.extend({
+        child: DS.belongsTo('child')
+      }));
+      env.registry.register("model:child", DS.Model.extend({
+        type: DS.belongsTo('le-type')
+      }));
+      env.registry.register("model:le-type", DS.Model.extend());
+
+      var jsonHash = {
+        id: 1,
+        child: {
+          id: 1,
+          type: "my_type_id"
+        }
+      };
+
+      Ember.run(function () {
+        var Parent = env.store.modelFor('parent');
+        var payload = env.store.serializerFor('parent').normalizeResponse(env.store, Parent, jsonHash, '1', 'findRecord');
+        deepEqual(payload.included, [{
+          id: '1',
+          type: 'child',
+          attributes: {},
+          relationships: {
+            type: {
+              data: {
+                id: 'my_type_id',
+                type: 'le-type'
+              }
+            }
+          }
+        }]);
+      });
+    });
+
     test('Serializer respects `serialize: false` on the attrs hash', function () {
       expect(2);
       env.registry.register("serializer:post", DS.JSONSerializer.extend({
@@ -18380,7 +18602,7 @@ define(
     }
 
     var get = Ember.get;
-    var HomePlanet, league, SuperVillain, EvilMinion, YellowMinion, DoomsdayDevice, Comment, Basket, env;
+    var HomePlanet, league, SuperVillain, EvilMinion, YellowMinion, DoomsdayDevice, Comment, Basket, Container, env;
     var run = Ember.run;
 
     module("integration/serializer/rest - RESTSerializer", {
@@ -18415,6 +18637,10 @@ define(
           type: DS.attr('string'),
           size: DS.attr('number')
         });
+        Container = DS.Model.extend({
+          type: DS.belongsTo('basket', { async: true }),
+          volume: DS.attr('string')
+        });
         env = setupStore({
           superVillain: SuperVillain,
           homePlanet: HomePlanet,
@@ -18422,7 +18648,8 @@ define(
           yellowMinion: YellowMinion,
           doomsdayDevice: DoomsdayDevice,
           comment: Comment,
-          basket: Basket
+          basket: Basket,
+          container: Container
         });
         env.store.modelFor('super-villain');
         env.store.modelFor('home-planet');
@@ -18899,9 +19126,9 @@ define(
       }));
 
       run(function () {
-        env.restSerializer.normalizeArrayResponse(env.store, Basket, {
-          basket: [env.store.createRecord('Basket', { type: 'bamboo', size: 10, id: '1' }), env.store.createRecord('Basket', { type: 'yellowMinion', size: 10, id: '65536' })]
-        });
+        env.store.push(env.restSerializer.normalizeArrayResponse(env.store, Basket, {
+          basket: [{ type: 'bamboo', size: 10, id: '1' }, { type: 'yellowMinion', size: 10, id: '65536' }]
+        }));
       });
 
       var normalRecord = env.store.peekRecord('basket', '1');
@@ -18914,6 +19141,47 @@ define(
       strictEqual(clashingRecord.get('type'), 'yellowMinion');
       strictEqual(clashingRecord.get('size'), 10);
     });
+
+    test("don't polymorphically deserialize base on the type key in payload when a type attribute exist on a singular response", function () {
+      env.registry.register('serializer:application', DS.RESTSerializer.extend({
+        isNewSerializerAPI: true
+      }));
+
+      run(function () {
+        var restSerializer = env.store.serializerFor('application');
+        env.store.push(restSerializer.normalizeSingleResponse(env.store, Basket, {
+          basket: { type: 'yellowMinion', size: 10, id: '65536' }
+        }, '65536'));
+      });
+
+      var clashingRecord = env.store.peekRecord('basket', '65536');
+      ok(clashingRecord, 'payload with type that matches another model name');
+      strictEqual(clashingRecord.get('type'), 'yellowMinion');
+      strictEqual(clashingRecord.get('size'), 10);
+    });
+
+    test("don't polymorphically deserialize based on the type key in payload when a relationship exists named type", function () {
+      env.registry.register('serializer:application', DS.RESTSerializer.extend({
+        isNewSerializerAPI: true
+      }));
+
+      env.adapter.findRecord = function () {
+        return {
+          containers: [{ id: 42, volume: '10 liters', type: 1 }],
+          baskets: [{ id: 1, size: 4 }]
+        };
+      };
+
+      run(function () {
+        env.store.findRecord('container', 42).then(function (container) {
+          strictEqual(container.get('volume'), '10 liters');
+          return container.get('type');
+        }).then(function (basket) {
+          ok(basket instanceof Basket);
+          equal(basket.get('size'), 4);
+        });
+      });
+    });
   }
 );
 
@@ -21326,13 +21594,13 @@ define(
           willChangeStartIdx = startIdx;
           willChangeRemoveAmt = removeAmt;
           willChangeAddAmt = addAmt;
-          return this._super.apply(arguments);
+          return this._super.apply(this, arguments);
         },
         arrayContentDidChange: function (startIdx, removeAmt, addAmt) {
           equal(startIdx, willChangeStartIdx, 'WillChange and DidChange startIdx should match');
           equal(removeAmt, willChangeRemoveAmt, 'WillChange and DidChange removeAmt should match');
           equal(addAmt, willChangeAddAmt, 'WillChange and DidChange addAmt should match');
-          return this._super.apply(arguments);
+          return this._super.apply(this, arguments);
         }
       });
       run(function () {
@@ -24339,6 +24607,49 @@ define(
       });
     });
 
+    test("invalid record's attributes can be rollbacked after multiple failed calls - #3677", function () {
+      var person;
+
+      var adapter = DS.RESTAdapter.extend({
+        ajax: function (url, type, hash) {
+          var error = new DS.InvalidError();
+          return Ember.RSVP.reject(error);
+        }
+      });
+
+      env = setupStore({ person: Person, adapter: adapter });
+
+      run(function () {
+        person = env.store.push({
+          data: {
+            type: 'person',
+            id: 1,
+            attributes: {
+              firstName: 'original name'
+            }
+          }
+        });
+
+        person.set('firstName', 'updated name');
+      });
+
+      run(function () {
+        equal(person.get('firstName'), 'updated name', "precondition: firstName is changed");
+
+        person.save().then(null, async(function () {
+          equal(person.get('hasDirtyAttributes'), true, "has dirty attributes");
+          equal(person.get('firstName'), 'updated name', "firstName is still changed");
+
+          return person.save();
+        })).then(null, async(function () {
+          person.rollbackAttributes();
+
+          equal(person.get('hasDirtyAttributes'), false, "has no dirty attributes");
+          equal(person.get('firstName'), 'original name', "after rollbackAttributes() firstName has the original value");
+        }));
+      });
+    });
+
     test("deleted record's attributes can be rollbacked", function () {
       var person, people;
 
@@ -27930,7 +28241,26 @@ define(
 
 // TODO enable import once this is possible
 // import { assertPolymorphicType } from "ember-data/utils";
-
+// import { modelHasAttributeOrRelationshipNamedType } from "ember-data/utils";
+
+// TODO enable once we can `import x from y;` in tests
+// test("modelHasAttributeOrRelationshipNamedType", function() {
+//   var ModelWithTypeAttribute = DS.Model.extend({
+//     type: DS.attr()
+//   });
+//   var ModelWithTypeBelongsTo = DS.Model.extend({
+//     type: DS.belongsTo()
+//   });
+//   var ModelWithTypeHasMany = DS.Model.extend({
+//     type: DS.hasMany()
+//   });
+//
+//   equal(modelHasAttributeOrRelationshipNamedType(DS.Model), false);
+//
+//   equal(modelHasAttributeOrRelationshipNamedType(ModelWithTypeAttribute), true);
+//   equal(modelHasAttributeOrRelationshipNamedType(ModelWithTypeBelongsTo), true);
+//   equal(modelHasAttributeOrRelationshipNamedType(ModelWithTypeHasMany), true);
+// });
 define("ember-data/tests/unit/utils-test", ["exports"], function(__exports__) {
   "use strict";