From 29a5fa964d62f3634a20fb205a2fa2724ee397d5 Mon Sep 17 00:00:00 2001 From: pangratz Date: Thu, 21 Apr 2016 16:03:06 +0200 Subject: [PATCH] [CLEANUP ds-references] --- FEATURES.md | 4 - addon/-private/system/model/internal-model.js | 13 +- addon/-private/system/model/model.js | 244 +++-- addon/-private/system/store.js | 87 +- config/features.json | 1 - .../integration/references/belongs-to-test.js | 841 ++++++++-------- tests/integration/references/has-many-test.js | 943 +++++++++--------- tests/integration/references/record-test.js | 345 ++++--- .../relationships/belongs-to-test.js | 189 ++-- tests/unit/model-test.js | 26 - 10 files changed, 1309 insertions(+), 1384 deletions(-) diff --git a/FEATURES.md b/FEATURES.md index 2e883106167..9aed1080275 100644 --- a/FEATURES.md +++ b/FEATURES.md @@ -29,10 +29,6 @@ entry in `config/features.json`. `methodForRequest`, `urlForRequest`, `headersForRequest` and `bodyForRequest` in the `DS.RESTAdapter`. -- `ds-references` - - Adds references as described in [RFC 57](https://github.com/emberjs/rfcs/pull/57) - - `ds-transform-pass-options` Pass options specified for a `DS.attr` to the `DS.Tranform`'s `serialize` and diff --git a/addon/-private/system/model/internal-model.js b/addon/-private/system/model/internal-model.js index 58501ea5656..b4dec58313d 100644 --- a/addon/-private/system/model/internal-model.js +++ b/addon/-private/system/model/internal-model.js @@ -4,7 +4,6 @@ import RootState from "ember-data/-private/system/model/states"; import Relationships from "ember-data/-private/system/relationships/state/create"; import Snapshot from "ember-data/-private/system/snapshot"; import EmptyObject from "ember-data/-private/system/empty-object"; -import isEnabled from "ember-data/-private/features"; import { getOwner @@ -831,12 +830,9 @@ InternalModel.prototype = { } else { return `<${this.modelName}:${this.id}>`; } - } -}; - -if (isEnabled('ds-references')) { + }, - InternalModel.prototype.referenceFor = function(type, name) { + referenceFor(type, name) { var reference = this.references[name]; if (!reference) { @@ -852,6 +848,5 @@ if (isEnabled('ds-references')) { } return reference; - }; - -} + } +}; diff --git a/addon/-private/system/model/model.js b/addon/-private/system/model/model.js index cb8bb2cab0f..f42acb0d48f 100644 --- a/addon/-private/system/model/model.js +++ b/addon/-private/system/model/model.js @@ -2,7 +2,6 @@ import Ember from 'ember'; import { assert, deprecate } from "ember-data/-private/debug"; import { PromiseObject } from "ember-data/-private/system/promise-proxies"; import Errors from "ember-data/-private/system/model/errors"; -import isEnabled from 'ember-data/-private/features'; import DebuggerInfoMixin from 'ember-data/-private/system/debug/debug-info'; import { BelongsToMixin } from 'ember-data/-private/system/relationships/belongs-to'; import { HasManyMixin } from 'ember-data/-private/system/relationships/has-many'; @@ -784,12 +783,123 @@ var Model = Ember.Object.extend(Ember.Evented, { assert("The `attr` method is not available on DS.Model, a DS.Snapshot was probably expected. Are you passing a DS.Model instead of a DS.Snapshot to your serializer?", false); }, - belongsTo() { - assert("The `belongsTo` method is not available on DS.Model, a DS.Snapshot was probably expected. Are you passing a DS.Model instead of a DS.Snapshot to your serializer?", false); + /** + Get the reference for the specified belongsTo relationship. + + Example + + ```javascript + // models/blog.js + export default DS.Model.extend({ + user: DS.belongsTo({ async: true }) + }); + + var blog = store.push({ + type: 'blog', + id: 1, + relationships: { + user: { type: 'user', id: 1 } + } + }); + var userRef = blog.belongsTo('user'); + + // check if the user relationship is loaded + var isLoaded = userRef.value() !== null; + + // get the record of the reference (null if not yet available) + var user = userRef.value(); + + // get the identifier of the reference + if (userRef.remoteType() === "id") { + var id = userRef.id(); + } else if (userRef.remoteType() === "link") { + var link = userRef.link(); + } + + // load user (via store.findRecord or store.findBelongsTo) + userRef.load().then(...) + + // or trigger a reload + userRef.reload().then(...) + + // provide data for reference + userRef.push({ + type: 'user', + id: 1, + attributes: { + username: "@user" + } + }).then(function(user) { + userRef.value() === user; + }); + ``` + + @method belongsTo + @param {String} name of the relationship + @since 2.5.0 + @return {BelongsToReference} reference for this relationship + */ + belongsTo: function(name) { + return this._internalModel.referenceFor('belongsTo', name); }, - hasMany() { - assert("The `hasMany` method is not available on DS.Model, a DS.Snapshot was probably expected. Are you passing a DS.Model instead of a DS.Snapshot to your serializer?", false); + /** + Get the reference for the specified hasMany relationship. + + Example + + ```javascript + // models/blog.js + export default DS.Model.extend({ + comments: DS.hasMany({ async: true }) + }); + + var blog = store.push({ + type: 'blog', + id: 1, + relationships: { + comments: { + data: [ + { type: 'comment', id: 1 }, + { type: 'comment', id: 2 } + ] + } + } + }); + var commentsRef = blog.hasMany('comments'); + + // check if the comments are loaded already + var isLoaded = commentsRef.value() !== null; + + // get the records of the reference (null if not yet available) + var comments = commentsRef.value(); + + // get the identifier of the reference + if (commentsRef.remoteType() === "ids") { + var ids = commentsRef.ids(); + } else if (commentsRef.remoteType() === "link") { + var link = commentsRef.link(); + } + + // load comments (via store.findMany or store.findHasMany) + commentsRef.load().then(...) + + // or trigger a reload + commentsRef.reload().then(...) + + // provide data for reference + commentsRef.push([{ type: 'comment', id: 1 }, { type: 'comment', id: 2 }]).then(function(comments) { + commentsRef.value() === comments; + }); + ``` + + @method hasMany + @param {String} name of the relationship + @since 2.5.0 + @return {HasManyReference} reference for this relationship + */ + hasMany: function(name) { + return this._internalModel.referenceFor('hasMany', name); }, setId: Ember.observer('id', function () { @@ -872,130 +982,6 @@ if (Ember.setOwner) { }); } -if (isEnabled("ds-references")) { - - Model.reopen({ - - /** - Get the reference for the specified belongsTo relationship. - - Example - - ```javascript - // models/blog.js - export default DS.Model.extend({ - user: DS.belongsTo({ async: true }) - }); - - var blog = store.push({ - type: 'blog', - id: 1, - relationships: { - user: { type: 'user', id: 1 } - } - }); - var userRef = blog.belongsTo('user'); - - // check if the user relationship is loaded - var isLoaded = userRef.value() !== null; - - // get the record of the reference (null if not yet available) - var user = userRef.value(); - - // get the identifier of the reference - if (userRef.remoteType() === "id") { - var id = userRef.id(); - } else if (userRef.remoteType() === "link") { - var link = userRef.link(); - } - - // load user (via store.findRecord or store.findBelongsTo) - userRef.load().then(...) - - // or trigger a reload - userRef.reload().then(...) - - // provide data for reference - userRef.push({ - type: 'user', - id: 1, - attributes: { - username: "@user" - } - }).then(function(user) { - userRef.value() === user; - }); - ``` - - @method belongsTo - @param {String} name of the relationship - @return {BelongsToReference} reference for this relationship - */ - belongsTo: function(name) { - return this._internalModel.referenceFor('belongsTo', name); - }, - - /** - Get the reference for the specified hasMany relationship. - - Example - - ```javascript - // models/blog.js - export default DS.Model.extend({ - comments: DS.hasMany({ async: true }) - }); - - var blog = store.push({ - type: 'blog', - id: 1, - relationships: { - comments: { - data: [ - { type: 'comment', id: 1 }, - { type: 'comment', id: 2 } - ] - } - } - }); - var commentsRef = blog.hasMany('comments'); - - // check if the comments are loaded already - var isLoaded = commentsRef.value() !== null; - - // get the records of the reference (null if not yet available) - var comments = commentsRef.value(); - - // get the identifier of the reference - if (commentsRef.remoteType() === "ids") { - var ids = commentsRef.ids(); - } else if (commentsRef.remoteType() === "link") { - var link = commentsRef.link(); - } - - // load comments (via store.findMany or store.findHasMany) - commentsRef.load().then(...) - - // or trigger a reload - commentsRef.reload().then(...) - - // provide data for reference - commentsRef.push([{ type: 'comment', id: 1 }, { type: 'comment', id: 2 }]).then(function(comments) { - commentsRef.value() === comments; - }); - ``` - - @method hasMany - @param {String} name of the relationship - @return {HasManyReference} reference for this relationship - */ - hasMany: function(name) { - return this._internalModel.referenceFor('hasMany', name); - } - }); - -} - Model.reopenClass(RelationshipsClassMethodsMixin); Model.reopenClass(AttrClassMethodsMixin); diff --git a/addon/-private/system/store.js b/addon/-private/system/store.js index 6b1c068c69d..cf389fcb508 100644 --- a/addon/-private/system/store.js +++ b/addon/-private/system/store.js @@ -703,6 +703,47 @@ Store = Service.extend({ } }, + /** + Get the reference for the specified record. + + Example + + ```javascript + var userRef = store.getReference('user', 1); + + // check if the user is loaded + var isLoaded = userRef.value() !== null; + + // get the record of the reference (null if not yet available) + var user = userRef.value(); + + // get the identifier of the reference + if (userRef.remoteType() === "id") { + var id = userRef.id(); + } + + // load user (via store.find) + userRef.load().then(...) + + // or trigger a reload + userRef.reload().then(...) + + // provide data for reference + userRef.push({ id: 1, username: "@user" }).then(function(user) { + userRef.value() === user; + }); + ``` + + @method getReference + @param {String} type + @param {String|Integer} id + @since 2.5.0 + @return {RecordReference} + */ + getReference: function(type, id) { + return this._internalModelForId(type, id).recordReference; + }, + /** Get a record by a given type and ID without triggering a fetch. @@ -2006,52 +2047,6 @@ Store = Service.extend({ }); -if (isEnabled("ds-references")) { - - Store.reopen({ - /** - Get the reference for the specified record. - - Example - - ```javascript - var userRef = store.getReference('user', 1); - - // check if the user is loaded - var isLoaded = userRef.value() !== null; - - // get the record of the reference (null if not yet available) - var user = userRef.value(); - - // get the identifier of the reference - if (userRef.remoteType() === "id") { - var id = userRef.id(); - } - - // load user (via store.find) - userRef.load().then(...) - - // or trigger a reload - userRef.reload().then(...) - - // provide data for reference - userRef.push({ id: 1, username: "@user" }).then(function(user) { - userRef.value() === user; - }); - ``` - - @method getReference - @param {String} type - @param {String|Integer} id - @return {RecordReference} - */ - getReference: function(type, id) { - return this._internalModelForId(type, id).recordReference; - } - }); - -} - function deserializeRecordId(store, key, relationship, id) { if (isNone(id)) { return; diff --git a/config/features.json b/config/features.json index f8dced67655..5907b5e321d 100644 --- a/config/features.json +++ b/config/features.json @@ -2,7 +2,6 @@ "ds-boolean-transform-allow-null": null, "ds-finder-include": true, "ds-improved-ajax": null, - "ds-references": true, "ds-transform-pass-options": true, "ds-pushpayload-return": null, "ds-serialize-ids-and-types": true, diff --git a/tests/integration/references/belongs-to-test.js b/tests/integration/references/belongs-to-test.js index b66dc17f6c0..77031ff17ad 100644 --- a/tests/integration/references/belongs-to-test.js +++ b/tests/integration/references/belongs-to-test.js @@ -3,556 +3,551 @@ import Ember from 'ember'; import setupStore from 'dummy/tests/helpers/store'; import testInDebug from 'dummy/tests/helpers/test-in-debug'; import { module, test } from 'qunit'; -import isEnabled from 'ember-data/-private/features'; - -if (isEnabled("ds-references")) { - - var get = Ember.get; - var run = Ember.run; - var env, Family; - - module("integration/references/belongs-to", { - beforeEach() { - Family = DS.Model.extend({ - persons: DS.hasMany(), - name: DS.attr() - }); - var Person = DS.Model.extend({ - family: DS.belongsTo({ async: true }) - }); - - env = setupStore({ - person: Person, - family: Family - }); - }, - - afterEach() { - run(env.container, 'destroy'); - } - }); - test("record#belongsTo", function(assert) { - var person; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - data: { type: 'family', id: 1 } - } +var get = Ember.get; +var run = Ember.run; +var env, Family; + +module("integration/references/belongs-to", { + beforeEach() { + Family = DS.Model.extend({ + persons: DS.hasMany(), + name: DS.attr() + }); + var Person = DS.Model.extend({ + family: DS.belongsTo({ async: true }) + }); + + env = setupStore({ + person: Person, + family: Family + }); + }, + + afterEach() { + run(env.container, 'destroy'); + } +}); + +test("record#belongsTo", function(assert) { + var person; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + data: { type: 'family', id: 1 } } } - }); + } }); - - var familyReference = person.belongsTo('family'); - - assert.equal(familyReference.remoteType(), 'id'); - assert.equal(familyReference.type, 'family'); - assert.equal(familyReference.id(), 1); }); - test("record#belongsTo for a linked reference", function(assert) { - var person; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - links: { related: '/families/1' } - } + var familyReference = person.belongsTo('family'); + + assert.equal(familyReference.remoteType(), 'id'); + assert.equal(familyReference.type, 'family'); + assert.equal(familyReference.id(), 1); +}); + +test("record#belongsTo for a linked reference", function(assert) { + var person; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + links: { related: '/families/1' } } } - }); + } }); - - var familyReference = person.belongsTo('family'); - - assert.equal(familyReference.remoteType(), 'link'); - assert.equal(familyReference.type, 'family'); - assert.equal(familyReference.link(), "/families/1"); }); - test("BelongsToReference#parent is a reference to the parent where the relationship is defined", function(assert) { - var person; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - data: { type: 'family', id: 1 } - } + var familyReference = person.belongsTo('family'); + + assert.equal(familyReference.remoteType(), 'link'); + assert.equal(familyReference.type, 'family'); + assert.equal(familyReference.link(), "/families/1"); +}); + +test("BelongsToReference#parent is a reference to the parent where the relationship is defined", function(assert) { + var person; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + data: { type: 'family', id: 1 } } } - }); + } }); - - var personReference = env.store.getReference('person', 1); - var familyReference = person.belongsTo('family'); - - assert.ok(personReference); - assert.equal(familyReference.parent, personReference); }); - test("BelongsToReference#meta() returns the most recent meta for the relationship", function(assert) { - var person; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - links: { - related: '/families/1' - }, - meta: { - foo: true - } + var personReference = env.store.getReference('person', 1); + var familyReference = person.belongsTo('family'); + + assert.ok(personReference); + assert.equal(familyReference.parent, personReference); +}); + +test("BelongsToReference#meta() returns the most recent meta for the relationship", function(assert) { + var person; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + links: { + related: '/families/1' + }, + meta: { + foo: true } } } - }); + } }); - - var familyReference = person.belongsTo('family'); - assert.deepEqual(familyReference.meta(), { foo: true }); }); - test("push(object)", function(assert) { - var done = assert.async(); - - var person; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - data: { type: 'family', id: 1 } - } + var familyReference = person.belongsTo('family'); + assert.deepEqual(familyReference.meta(), { foo: true }); +}); + +test("push(object)", function(assert) { + var done = assert.async(); + + var person; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + data: { type: 'family', id: 1 } } } - }); + } }); + }); - var familyReference = person.belongsTo('family'); + var familyReference = person.belongsTo('family'); - run(function() { - var data = { - data: { - type: 'family', - id: 1, - attributes: { - name: "Coreleone" - } + run(function() { + var data = { + data: { + type: 'family', + id: 1, + attributes: { + name: "Coreleone" } - }; + } + }; - familyReference.push(data).then(function(record) { - assert.ok(Family.detectInstance(record), "push resolves with the referenced record"); - assert.equal(get(record, 'name'), "Coreleone", "name is set"); + familyReference.push(data).then(function(record) { + assert.ok(Family.detectInstance(record), "push resolves with the referenced record"); + assert.equal(get(record, 'name'), "Coreleone", "name is set"); - done(); - }); + done(); }); }); - - test("push(record)", function(assert) { - var done = assert.async(); - - var person, family; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - data: { type: 'family', id: 1 } - } +}); + +test("push(record)", function(assert) { + var done = assert.async(); + + var person, family; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + data: { type: 'family', id: 1 } } } - }); - family = env.store.push({ - data: { - type: 'family', - id: 1, - attributes: { - name: "Coreleone" - } + } + }); + family = env.store.push({ + data: { + type: 'family', + id: 1, + attributes: { + name: "Coreleone" } - }); + } }); + }); - var familyReference = person.belongsTo('family'); + var familyReference = person.belongsTo('family'); - run(function() { - familyReference.push(family).then(function(record) { - assert.ok(Family.detectInstance(record), "push resolves with the referenced record"); - assert.equal(get(record, 'name'), "Coreleone", "name is set"); - assert.equal(record, family); + run(function() { + familyReference.push(family).then(function(record) { + assert.ok(Family.detectInstance(record), "push resolves with the referenced record"); + assert.equal(get(record, 'name'), "Coreleone", "name is set"); + assert.equal(record, family); - done(); - }); + done(); }); }); - - test("push(promise)", function(assert) { - var done = assert.async(); - - var push; - var deferred = Ember.RSVP.defer(); - - run(function() { - var person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - data: { type: 'family', id: 1 } - } +}); + +test("push(promise)", function(assert) { + var done = assert.async(); + + var push; + var deferred = Ember.RSVP.defer(); + + run(function() { + var person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + data: { type: 'family', id: 1 } } } - }); - var familyReference = person.belongsTo('family'); - push = familyReference.push(deferred.promise); + } }); + var familyReference = person.belongsTo('family'); + push = familyReference.push(deferred.promise); + }); - assert.ok(push.then, 'BelongsToReference.push returns a promise'); + assert.ok(push.then, 'BelongsToReference.push returns a promise'); - run(function() { - deferred.resolve({ - data: { - type: 'family', - id: 1, - attributes: { - name: "Coreleone" - } + run(function() { + deferred.resolve({ + data: { + type: 'family', + id: 1, + attributes: { + name: "Coreleone" } - }); + } }); + }); - run(function() { - push.then(function(record) { - assert.ok(Family.detectInstance(record), "push resolves with the record"); - assert.equal(get(record, 'name'), "Coreleone", "name is updated"); + run(function() { + push.then(function(record) { + assert.ok(Family.detectInstance(record), "push resolves with the record"); + assert.equal(get(record, 'name'), "Coreleone", "name is updated"); - done(); - }); + done(); }); }); - - testInDebug("push(record) asserts for invalid type", function(assert) { - var person, anotherPerson; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - data: { type: 'family', id: 1 } - } +}); + +testInDebug("push(record) asserts for invalid type", function(assert) { + var person, anotherPerson; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + data: { type: 'family', id: 1 } } } - }); - anotherPerson = env.store.push({ - data: { - type: 'person', - id: 2 - } - }); + } }); + anotherPerson = env.store.push({ + data: { + type: 'person', + id: 2 + } + }); + }); - var familyReference = person.belongsTo('family'); + var familyReference = person.belongsTo('family'); - assert.expectAssertion(function() { - run(function() { - familyReference.push(anotherPerson); - }); - }, "You cannot add a record of type 'person' to the 'person.family' relationship (only 'family' allowed)"); - }); + assert.expectAssertion(function() { + run(function() { + familyReference.push(anotherPerson); + }); + }, "You cannot add a record of type 'person' to the 'person.family' relationship (only 'family' allowed)"); +}); - test("push(record) works with polymorphic type", function(assert) { - var done = assert.async(); +test("push(record) works with polymorphic type", function(assert) { + var done = assert.async(); - var person, mafiaFamily; + var person, mafiaFamily; - env.registry.register('model:mafia-family', Family.extend()); + env.registry.register('model:mafia-family', Family.extend()); - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1 - } - }); - mafiaFamily = env.store.push({ - data: { - type: 'mafia-family', - id: 1 - } - }); + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1 + } }); + mafiaFamily = env.store.push({ + data: { + type: 'mafia-family', + id: 1 + } + }); + }); - var familyReference = person.belongsTo('family'); - run(function() { - familyReference.push(mafiaFamily).then(function(family) { - assert.equal(family, mafiaFamily); + var familyReference = person.belongsTo('family'); + run(function() { + familyReference.push(mafiaFamily).then(function(family) { + assert.equal(family, mafiaFamily); - done(); - }); + done(); }); }); - - test("value() is null when reference is not yet loaded", function(assert) { - var person; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - data: { type: 'family', id: 1 } - } +}); + +test("value() is null when reference is not yet loaded", function(assert) { + var person; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + data: { type: 'family', id: 1 } } } - }); + } }); - - var familyReference = person.belongsTo('family'); - assert.strictEqual(familyReference.value(), null); }); - test("value() returns the referenced record when loaded", function(assert) { - var person, family; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - data: { type: 'family', id: 1 } - } + var familyReference = person.belongsTo('family'); + assert.strictEqual(familyReference.value(), null); +}); + +test("value() returns the referenced record when loaded", function(assert) { + var person, family; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + data: { type: 'family', id: 1 } } } - }); - family = env.store.push({ - data: { - type: 'family', - id: 1 - } - }); + } + }); + family = env.store.push({ + data: { + type: 'family', + id: 1 + } }); - - var familyReference = person.belongsTo('family'); - assert.equal(familyReference.value(), family); }); - test("load() fetches the record", function(assert) { - var done = assert.async(); + var familyReference = person.belongsTo('family'); + assert.equal(familyReference.value(), family); +}); - env.adapter.findRecord = function(store, type, id) { - return Ember.RSVP.resolve({ - id: 1, name: "Coreleone" - }); - }; +test("load() fetches the record", function(assert) { + var done = assert.async(); - var person; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - data: { type: 'family', id: 1 } - } + env.adapter.findRecord = function(store, type, id) { + return Ember.RSVP.resolve({ + id: 1, name: "Coreleone" + }); + }; + + var person; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + data: { type: 'family', id: 1 } } } - }); + } }); + }); - var familyReference = person.belongsTo('family'); + var familyReference = person.belongsTo('family'); - run(function() { - familyReference.load().then(function(record) { - assert.equal(get(record, 'name'), "Coreleone"); + run(function() { + familyReference.load().then(function(record) { + assert.equal(get(record, 'name'), "Coreleone"); - done(); - }); + done(); }); }); +}); - test("load() fetches link when remoteType is link", function(assert) { - var done = assert.async(); +test("load() fetches link when remoteType is link", function(assert) { + var done = assert.async(); - env.adapter.findBelongsTo = function(store, snapshot, link) { - assert.equal(link, "/families/1"); - - return Ember.RSVP.resolve({ - id: 1, name: "Coreleone" - }); - }; + env.adapter.findBelongsTo = function(store, snapshot, link) { + assert.equal(link, "/families/1"); - var person; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - links: { related: '/families/1' } - } + return Ember.RSVP.resolve({ + id: 1, name: "Coreleone" + }); + }; + + var person; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + links: { related: '/families/1' } } } - }); + } }); + }); - var familyReference = person.belongsTo('family'); - assert.equal(familyReference.remoteType(), "link"); + var familyReference = person.belongsTo('family'); + assert.equal(familyReference.remoteType(), "link"); - run(function() { - familyReference.load().then(function(record) { - assert.equal(get(record, 'name'), "Coreleone"); + run(function() { + familyReference.load().then(function(record) { + assert.equal(get(record, 'name'), "Coreleone"); - done(); - }); + done(); }); }); +}); - test("reload() - loads the record when not yet loaded", function(assert) { - var done = assert.async(); - - var count = 0; - env.adapter.findRecord = function(store, type, id) { - count++; - assert.equal(count, 1); +test("reload() - loads the record when not yet loaded", function(assert) { + var done = assert.async(); - return Ember.RSVP.resolve({ - id: 1, name: "Coreleone" - }); - }; + var count = 0; + env.adapter.findRecord = function(store, type, id) { + count++; + assert.equal(count, 1); - var person; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - data: { type: 'family', id: 1 } - } + return Ember.RSVP.resolve({ + id: 1, name: "Coreleone" + }); + }; + + var person; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + data: { type: 'family', id: 1 } } } - }); + } }); + }); - var familyReference = person.belongsTo('family'); + var familyReference = person.belongsTo('family'); - run(function() { - familyReference.reload().then(function(record) { - assert.equal(get(record, 'name'), "Coreleone"); + run(function() { + familyReference.reload().then(function(record) { + assert.equal(get(record, 'name'), "Coreleone"); - done(); - }); + done(); }); }); +}); - test("reload() - reloads the record when already loaded", function(assert) { - var done = assert.async(); +test("reload() - reloads the record when already loaded", function(assert) { + var done = assert.async(); - var count = 0; - env.adapter.findRecord = function(store, type, id) { - count++; - assert.equal(count, 1); + var count = 0; + env.adapter.findRecord = function(store, type, id) { + count++; + assert.equal(count, 1); - return Ember.RSVP.resolve({ - id: 1, name: "Coreleone" - }); - }; - - var person; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - data: { type: 'family', id: 1 } - } + return Ember.RSVP.resolve({ + id: 1, name: "Coreleone" + }); + }; + + var person; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + data: { type: 'family', id: 1 } } } - }); - env.store.push({ - data: { - type: 'family', - id: 1 - } - }); + } }); + env.store.push({ + data: { + type: 'family', + id: 1 + } + }); + }); - var familyReference = person.belongsTo('family'); + var familyReference = person.belongsTo('family'); - run(function() { - familyReference.reload().then(function(record) { - assert.equal(get(record, 'name'), "Coreleone"); + run(function() { + familyReference.reload().then(function(record) { + assert.equal(get(record, 'name'), "Coreleone"); - done(); - }); + done(); }); }); +}); - test("reload() - uses link to reload record", function(assert) { - var done = assert.async(); +test("reload() - uses link to reload record", function(assert) { + var done = assert.async(); - env.adapter.findBelongsTo = function(store, snapshot, link) { - assert.equal(link, "/families/1"); - - return Ember.RSVP.resolve({ - id: 1, name: "Coreleone" - }); - }; + env.adapter.findBelongsTo = function(store, snapshot, link) { + assert.equal(link, "/families/1"); - var person; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1, - relationships: { - family: { - links: { related: '/families/1' } - } + return Ember.RSVP.resolve({ + id: 1, name: "Coreleone" + }); + }; + + var person; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1, + relationships: { + family: { + links: { related: '/families/1' } } } - }); + } }); + }); - var familyReference = person.belongsTo('family'); + var familyReference = person.belongsTo('family'); - run(function() { - familyReference.reload().then(function(record) { - assert.equal(get(record, 'name'), "Coreleone"); + run(function() { + familyReference.reload().then(function(record) { + assert.equal(get(record, 'name'), "Coreleone"); - done(); - }); + done(); }); }); - -} +}); diff --git a/tests/integration/references/has-many-test.js b/tests/integration/references/has-many-test.js index 0742366158e..5e165c99eb0 100644 --- a/tests/integration/references/has-many-test.js +++ b/tests/integration/references/has-many-test.js @@ -3,594 +3,589 @@ import Ember from 'ember'; import setupStore from 'dummy/tests/helpers/store'; import testInDebug from 'dummy/tests/helpers/test-in-debug'; import { module, test } from 'qunit'; -import isEnabled from 'ember-data/-private/features'; - -if (isEnabled("ds-references")) { - - var get = Ember.get; - var run = Ember.run; - var env, Person; - - module("integration/references/has-many", { - beforeEach() { - var Family = DS.Model.extend({ - persons: DS.hasMany({ async: true }) - }); - Person = DS.Model.extend({ - name: DS.attr(), - family: DS.belongsTo() - }); - env = setupStore({ - person: Person, - family: Family - }); - }, - - afterEach() { - run(env.container, 'destroy'); - } - }); - test("record#hasMany", function(assert) { - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - data: [ - { type: 'person', id: 1 }, - { type: 'person', id: 2 } - ] - } +var get = Ember.get; +var run = Ember.run; +var env, Person; + +module("integration/references/has-many", { + beforeEach() { + var Family = DS.Model.extend({ + persons: DS.hasMany({ async: true }) + }); + Person = DS.Model.extend({ + name: DS.attr(), + family: DS.belongsTo() + }); + env = setupStore({ + person: Person, + family: Family + }); + }, + + afterEach() { + run(env.container, 'destroy'); + } +}); + +test("record#hasMany", function(assert) { + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + data: [ + { type: 'person', id: 1 }, + { type: 'person', id: 2 } + ] } } - }); + } }); - - var personsReference = family.hasMany('persons'); - - assert.equal(personsReference.remoteType(), 'ids'); - assert.equal(personsReference.type, 'person'); - assert.deepEqual(personsReference.ids(), ['1', '2']); }); - test("record#hasMany for linked references", function(assert) { - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - links: { related: '/families/1/persons' } - } + var personsReference = family.hasMany('persons'); + + assert.equal(personsReference.remoteType(), 'ids'); + assert.equal(personsReference.type, 'person'); + assert.deepEqual(personsReference.ids(), ['1', '2']); +}); + +test("record#hasMany for linked references", function(assert) { + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + links: { related: '/families/1/persons' } } } - }); + } }); - - var personsReference = family.hasMany('persons'); - - assert.equal(personsReference.remoteType(), 'link'); - assert.equal(personsReference.type, 'person'); - assert.equal(personsReference.link(), '/families/1/persons'); }); - test("HasManyReference#parent is a reference to the parent where the relationship is defined", function(assert) { - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - data: [ - { type: 'person', id: 1 }, - { type: 'person', id: 2 } - ] - } + var personsReference = family.hasMany('persons'); + + assert.equal(personsReference.remoteType(), 'link'); + assert.equal(personsReference.type, 'person'); + assert.equal(personsReference.link(), '/families/1/persons'); +}); + +test("HasManyReference#parent is a reference to the parent where the relationship is defined", function(assert) { + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + data: [ + { type: 'person', id: 1 }, + { type: 'person', id: 2 } + ] } } - }); + } }); - - var familyReference = env.store.getReference('family', 1); - var personsReference = family.hasMany('persons'); - - assert.ok(familyReference); - assert.equal(personsReference.parent, familyReference); }); - test("HasManyReference#meta() returns the most recent meta for the relationship", function(assert) { - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - links: { related: '/families/1/persons' }, - meta: { - foo: true - } + var familyReference = env.store.getReference('family', 1); + var personsReference = family.hasMany('persons'); + + assert.ok(familyReference); + assert.equal(personsReference.parent, familyReference); +}); + +test("HasManyReference#meta() returns the most recent meta for the relationship", function(assert) { + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + links: { related: '/families/1/persons' }, + meta: { + foo: true } } } - }); + } }); - - var personsReference = family.hasMany('persons'); - assert.deepEqual(personsReference.meta(), { foo: true }); }); - test("push(array)", function(assert) { - var done = assert.async(); - - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - data: [ - { type: 'person', id: 1 }, - { type: 'person', id: 2 } - ] - } + var personsReference = family.hasMany('persons'); + assert.deepEqual(personsReference.meta(), { foo: true }); +}); + +test("push(array)", function(assert) { + var done = assert.async(); + + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + data: [ + { type: 'person', id: 1 }, + { type: 'person', id: 2 } + ] } } - }); + } }); + }); - var personsReference = family.hasMany('persons'); + var personsReference = family.hasMany('persons'); - run(function() { - var data = [ - { data: { type: 'person', id: 1, attributes: { name: "Vito" } } }, - { data: { type: 'person', id: 2, attributes: { name: "Michael" } } } - ]; + run(function() { + var data = [ + { data: { type: 'person', id: 1, attributes: { name: "Vito" } } }, + { data: { type: 'person', id: 2, attributes: { name: "Michael" } } } + ]; - personsReference.push(data).then(function(records) { - assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); - assert.equal(get(records, 'length'), 2); - assert.equal(records.objectAt(0).get('name'), "Vito"); - assert.equal(records.objectAt(1).get('name'), "Michael"); + personsReference.push(data).then(function(records) { + assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); + assert.equal(get(records, 'length'), 2); + assert.equal(records.objectAt(0).get('name'), "Vito"); + assert.equal(records.objectAt(1).get('name'), "Michael"); - done(); - }); + done(); }); }); +}); - test("push(array) works with polymorphic type", function(assert) { - var done = assert.async(); +test("push(array) works with polymorphic type", function(assert) { + var done = assert.async(); - env.registry.register('model:mafia-boss', Person.extend()); + env.registry.register('model:mafia-boss', Person.extend()); - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1 - } - }); + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1 + } }); + }); - var personsReference = family.hasMany('persons'); + var personsReference = family.hasMany('persons'); - run(() => { - var data = { - data: [ - { data: { type: 'mafia-boss', id: 1, attributes: { name: "Vito" } } } - ] - }; + run(() => { + var data = { + data: [ + { data: { type: 'mafia-boss', id: 1, attributes: { name: "Vito" } } } + ] + }; - personsReference.push(data).then(function(records) { - assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); - assert.equal(get(records, 'length'), 1); - assert.equal(records.objectAt(0).get('name'), "Vito"); + personsReference.push(data).then(function(records) { + assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); + assert.equal(get(records, 'length'), 1); + assert.equal(records.objectAt(0).get('name'), "Vito"); - done(); - }); + done(); }); }); - - testInDebug("push(array) asserts polymorphic type", function(assert) { - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1 - } - }); +}); + +testInDebug("push(array) asserts polymorphic type", function(assert) { + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1 + } }); - - var personsReference = family.hasMany('persons'); - - assert.expectAssertion(() => { - run(() => { - var data = { - data: [ - { data: { type: 'family', id: 1 } } - ] - }; - - personsReference.push(data); - }); - }, "You cannot add a record of type 'family' to the 'family.persons' relationship (only 'person' allowed)"); }); - test("push(object) supports JSON-API payload", function(assert) { - var done = assert.async(); - - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - data: [ - { type: 'person', id: 1 }, - { type: 'person', id: 2 } - ] - } - } - } - }); - }); + var personsReference = family.hasMany('persons'); - var personsReference = family.hasMany('persons'); - - run(function() { + assert.expectAssertion(() => { + run(() => { var data = { data: [ - { data: { type: 'person', id: 1, attributes: { name: "Vito" } } }, - { data: { type: 'person', id: 2, attributes: { name: "Michael" } } } + { data: { type: 'family', id: 1 } } ] }; - personsReference.push(data).then(function(records) { - assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); - assert.equal(get(records, 'length'), 2); - assert.equal(records.objectAt(0).get('name'), "Vito"); - assert.equal(records.objectAt(1).get('name'), "Michael"); - - done(); - }); + personsReference.push(data); }); - }); - - test("push(promise)", function(assert) { - var done = assert.async(); - - var push; - var deferred = Ember.RSVP.defer(); - - run(function() { - var family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - data: [ - { type: 'person', id: 1 }, - { type: 'person', id: 2 } - ] - } + }, "You cannot add a record of type 'family' to the 'family.persons' relationship (only 'person' allowed)"); +}); + +test("push(object) supports JSON-API payload", function(assert) { + var done = assert.async(); + + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + data: [ + { type: 'person', id: 1 }, + { type: 'person', id: 2 } + ] } } - }); - var personsReference = family.hasMany('persons'); - push = personsReference.push(deferred.promise); + } }); + }); - assert.ok(push.then, 'HasManyReference.push returns a promise'); + var personsReference = family.hasMany('persons'); - run(function() { - var data = [ + run(function() { + var data = { + data: [ { data: { type: 'person', id: 1, attributes: { name: "Vito" } } }, { data: { type: 'person', id: 2, attributes: { name: "Michael" } } } - ]; - deferred.resolve(data); - }); + ] + }; - run(function() { - push.then(function(records) { - assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); - assert.equal(get(records, 'length'), 2); - assert.equal(records.objectAt(0).get('name'), "Vito"); - assert.equal(records.objectAt(1).get('name'), "Michael"); + personsReference.push(data).then(function(records) { + assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); + assert.equal(get(records, 'length'), 2); + assert.equal(records.objectAt(0).get('name'), "Vito"); + assert.equal(records.objectAt(1).get('name'), "Michael"); - done(); - }); + done(); }); }); - - test("value() returns null when reference is not yet loaded", function(assert) { - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - data: [ - { type: 'person', id: 1 }, - { type: 'person', id: 2 } - ] - } +}); + +test("push(promise)", function(assert) { + var done = assert.async(); + + var push; + var deferred = Ember.RSVP.defer(); + + run(function() { + var family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + data: [ + { type: 'person', id: 1 }, + { type: 'person', id: 2 } + ] } } - }); + } }); - var personsReference = family.hasMany('persons'); - assert.strictEqual(personsReference.value(), null); + push = personsReference.push(deferred.promise); }); - test("value() returns the referenced records when all records are loaded", function(assert) { - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - data: [ - { type: 'person', id: 1 }, - { type: 'person', id: 2 } - ] - } - } - } - }); - env.store.push({ data: { type: 'person', id: 1, attributes: { name: "Vito" } } }); - env.store.push({ data: { type: 'person', id: 2, attributes: { name: "Michael" } } }); - }); + assert.ok(push.then, 'HasManyReference.push returns a promise'); - var personsReference = family.hasMany('persons'); - var records = personsReference.value(); - assert.equal(get(records, 'length'), 2); - assert.equal(records.isEvery('isLoaded'), true); + run(function() { + var data = [ + { data: { type: 'person', id: 1, attributes: { name: "Vito" } } }, + { data: { type: 'person', id: 2, attributes: { name: "Michael" } } } + ]; + deferred.resolve(data); }); - test("load() fetches the referenced records", function(assert) { - var done = assert.async(); + run(function() { + push.then(function(records) { + assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); + assert.equal(get(records, 'length'), 2); + assert.equal(records.objectAt(0).get('name'), "Vito"); + assert.equal(records.objectAt(1).get('name'), "Michael"); - env.adapter.findMany = function(store, type, id) { - return Ember.RSVP.resolve([{ id: 1, name: "Vito" }, { id: 2, name: "Michael" }]); - }; - - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - data: [ - { type: 'person', id: 1 }, - { type: 'person', id: 2 } - ] - } + done(); + }); + }); +}); + +test("value() returns null when reference is not yet loaded", function(assert) { + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + data: [ + { type: 'person', id: 1 }, + { type: 'person', id: 2 } + ] } } - }); + } }); + }); - var personsReference = family.hasMany('persons'); - - run(function() { - personsReference.load().then(function(records) { - assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); - assert.equal(get(records, 'length'), 2); - assert.equal(records.objectAt(0).get('name'), "Vito"); - assert.equal(records.objectAt(1).get('name'), "Michael"); - - done(); - }); + var personsReference = family.hasMany('persons'); + assert.strictEqual(personsReference.value(), null); +}); + +test("value() returns the referenced records when all records are loaded", function(assert) { + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + data: [ + { type: 'person', id: 1 }, + { type: 'person', id: 2 } + ] + } + } + } }); + env.store.push({ data: { type: 'person', id: 1, attributes: { name: "Vito" } } }); + env.store.push({ data: { type: 'person', id: 2, attributes: { name: "Michael" } } }); }); - test("load() fetches link when remoteType is link", function(assert) { - var done = assert.async(); - - env.adapter.findHasMany = function(store, snapshot, link) { - assert.equal(link, "/families/1/persons"); - - return Ember.RSVP.resolve([{ id: 1, name: "Vito" }, { id: 2, name: "Michael" }]); - }; - - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - links: { related: '/families/1/persons' } - } + var personsReference = family.hasMany('persons'); + var records = personsReference.value(); + assert.equal(get(records, 'length'), 2); + assert.equal(records.isEvery('isLoaded'), true); +}); + +test("load() fetches the referenced records", function(assert) { + var done = assert.async(); + + env.adapter.findMany = function(store, type, id) { + return Ember.RSVP.resolve([{ id: 1, name: "Vito" }, { id: 2, name: "Michael" }]); + }; + + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + data: [ + { type: 'person', id: 1 }, + { type: 'person', id: 2 } + ] } } - }); + } }); + }); - var personsReference = family.hasMany('persons'); - assert.equal(personsReference.remoteType(), "link"); + var personsReference = family.hasMany('persons'); - run(function() { - personsReference.load().then(function(records) { - assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); - assert.equal(get(records, 'length'), 2); - assert.equal(records.objectAt(0).get('name'), "Vito"); - assert.equal(records.objectAt(1).get('name'), "Michael"); + run(function() { + personsReference.load().then(function(records) { + assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); + assert.equal(get(records, 'length'), 2); + assert.equal(records.objectAt(0).get('name'), "Vito"); + assert.equal(records.objectAt(1).get('name'), "Michael"); - done(); - }); + done(); }); }); - - test("load() - only a single find is triggered", function(assert) { - var done = assert.async(); - - var deferred = Ember.RSVP.defer(); - var count = 0; - - env.adapter.findMany = function(store, type, id) { - count++; - assert.equal(count, 1); - - return deferred.promise; - }; - - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - data: [ - { type: 'person', id: 1 }, - { type: 'person', id: 2 } - ] - } +}); + +test("load() fetches link when remoteType is link", function(assert) { + var done = assert.async(); + + env.adapter.findHasMany = function(store, snapshot, link) { + assert.equal(link, "/families/1/persons"); + + return Ember.RSVP.resolve([{ id: 1, name: "Vito" }, { id: 2, name: "Michael" }]); + }; + + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + links: { related: '/families/1/persons' } } } - }); + } }); + }); - var personsReference = family.hasMany('persons'); + var personsReference = family.hasMany('persons'); + assert.equal(personsReference.remoteType(), "link"); - run(function() { - personsReference.load(); - personsReference.load().then(function(records) { - assert.equal(get(records, 'length'), 2); - }); - }); + run(function() { + personsReference.load().then(function(records) { + assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); + assert.equal(get(records, 'length'), 2); + assert.equal(records.objectAt(0).get('name'), "Vito"); + assert.equal(records.objectAt(1).get('name'), "Michael"); - run(function() { - deferred.resolve([{ id: 1, name: "Vito" }, { id: 2, name: "Michael" }]); + done(); }); + }); +}); + +test("load() - only a single find is triggered", function(assert) { + var done = assert.async(); + + var deferred = Ember.RSVP.defer(); + var count = 0; + + env.adapter.findMany = function(store, type, id) { + count++; + assert.equal(count, 1); + + return deferred.promise; + }; + + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + data: [ + { type: 'person', id: 1 }, + { type: 'person', id: 2 } + ] + } + } + } + }); + }); - run(function() { - personsReference.load().then(function(records) { - assert.equal(get(records, 'length'), 2); + var personsReference = family.hasMany('persons'); - done(); - }); + run(function() { + personsReference.load(); + personsReference.load().then(function(records) { + assert.equal(get(records, 'length'), 2); }); }); - test("reload()", function(assert) { - var done = assert.async(); + run(function() { + deferred.resolve([{ id: 1, name: "Vito" }, { id: 2, name: "Michael" }]); + }); - env.adapter.findMany = function(store, type, id) { - return Ember.RSVP.resolve([ - { id: 1, name: "Vito Coreleone" }, - { id: 2, name: "Michael Coreleone" } - ]); - }; + run(function() { + personsReference.load().then(function(records) { + assert.equal(get(records, 'length'), 2); - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - data: [ - { type: 'person', id: 1 }, - { type: 'person', id: 2 } - ] - } + done(); + }); + }); +}); + +test("reload()", function(assert) { + var done = assert.async(); + + env.adapter.findMany = function(store, type, id) { + return Ember.RSVP.resolve([ + { id: 1, name: "Vito Coreleone" }, + { id: 2, name: "Michael Coreleone" } + ]); + }; + + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + data: [ + { type: 'person', id: 1 }, + { type: 'person', id: 2 } + ] } } - }); - env.store.push({ data: { type: 'person', id: 1, attributes: { name: "Vito" } } }); - env.store.push({ data: { type: 'person', id: 2, attributes: { name: "Michael" } } }); + } }); + env.store.push({ data: { type: 'person', id: 1, attributes: { name: "Vito" } } }); + env.store.push({ data: { type: 'person', id: 2, attributes: { name: "Michael" } } }); + }); - var personsReference = family.hasMany('persons'); + var personsReference = family.hasMany('persons'); - run(function() { - personsReference.reload().then(function(records) { - assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); - assert.equal(get(records, 'length'), 2); - assert.equal(records.objectAt(0).get('name'), "Vito Coreleone"); - assert.equal(records.objectAt(1).get('name'), "Michael Coreleone"); + run(function() { + personsReference.reload().then(function(records) { + assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); + assert.equal(get(records, 'length'), 2); + assert.equal(records.objectAt(0).get('name'), "Vito Coreleone"); + assert.equal(records.objectAt(1).get('name'), "Michael Coreleone"); - done(); - }); + done(); }); }); +}); - test("reload() fetches link when remoteType is link", function(assert) { - var done = assert.async(); - - var count = 0; - env.adapter.findHasMany = function(store, snapshot, link) { - count++; - assert.equal(link, "/families/1/persons"); - - if (count === 1) { - return Ember.RSVP.resolve([{ id: 1, name: "Vito" }, { id: 2, name: "Michael" }]); - } else { - return Ember.RSVP.resolve([ - { id: 1, name: "Vito Coreleone" }, - { id: 2, name: "Michael Coreleone" } - ]); - } - }; +test("reload() fetches link when remoteType is link", function(assert) { + var done = assert.async(); - var family; - run(function() { - family = env.store.push({ - data: { - type: 'family', - id: 1, - relationships: { - persons: { - links: { related: '/families/1/persons' } - } + var count = 0; + env.adapter.findHasMany = function(store, snapshot, link) { + count++; + assert.equal(link, "/families/1/persons"); + + if (count === 1) { + return Ember.RSVP.resolve([{ id: 1, name: "Vito" }, { id: 2, name: "Michael" }]); + } else { + return Ember.RSVP.resolve([ + { id: 1, name: "Vito Coreleone" }, + { id: 2, name: "Michael Coreleone" } + ]); + } + }; + + var family; + run(function() { + family = env.store.push({ + data: { + type: 'family', + id: 1, + relationships: { + persons: { + links: { related: '/families/1/persons' } } } - }); + } }); + }); - var personsReference = family.hasMany('persons'); - assert.equal(personsReference.remoteType(), "link"); - - run(function() { - personsReference.load().then(function() { - return personsReference.reload(); - }).then(function(records) { - assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); - assert.equal(get(records, 'length'), 2); - assert.equal(records.objectAt(0).get('name'), "Vito Coreleone"); - assert.equal(records.objectAt(1).get('name'), "Michael Coreleone"); - - done(); - }); + var personsReference = family.hasMany('persons'); + assert.equal(personsReference.remoteType(), "link"); + + run(function() { + personsReference.load().then(function() { + return personsReference.reload(); + }).then(function(records) { + assert.ok(records instanceof DS.ManyArray, "push resolves with the referenced records"); + assert.equal(get(records, 'length'), 2); + assert.equal(records.objectAt(0).get('name'), "Vito Coreleone"); + assert.equal(records.objectAt(1).get('name'), "Michael Coreleone"); + + done(); }); }); - -} +}); diff --git a/tests/integration/references/record-test.js b/tests/integration/references/record-test.js index 67983616b66..7f66074d8f4 100644 --- a/tests/integration/references/record-test.js +++ b/tests/integration/references/record-test.js @@ -2,236 +2,231 @@ import DS from 'ember-data'; import Ember from 'ember'; import setupStore from 'dummy/tests/helpers/store'; import { module, test } from 'qunit'; -import isEnabled from 'ember-data/-private/features'; -if (isEnabled("ds-references")) { +var get = Ember.get; +var run = Ember.run; +var env, Person; - var get = Ember.get; - var run = Ember.run; - var env, Person; - - module("integration/references/record", { - beforeEach() { - Person = DS.Model.extend({ - name: DS.attr() - }); - - env = setupStore({ - person: Person - }); - }, - - afterEach() { - run(env.store, 'unloadAll'); - run(env.container, 'destroy'); - } - }); - - test("a RecordReference can be retrieved via store.getReference(type, id)", function(assert) { - var recordReference = env.store.getReference('person', 1); - - assert.equal(recordReference.remoteType(), 'identity'); - assert.equal(recordReference.type, 'person'); - assert.equal(recordReference.id(), 1); - }); - - test("push(object)", function(assert) { - var done = assert.async(); - - var push; - var recordReference = env.store.getReference('person', 1); +module("integration/references/record", { + beforeEach() { + Person = DS.Model.extend({ + name: DS.attr() + }); - run(function() { - push = recordReference.push({ - data: { - type: 'person', - id: 1, - attributes: { - name: "le name" - } + env = setupStore({ + person: Person + }); + }, + + afterEach() { + run(env.store, 'unloadAll'); + run(env.container, 'destroy'); + } +}); + +test("a RecordReference can be retrieved via store.getReference(type, id)", function(assert) { + var recordReference = env.store.getReference('person', 1); + + assert.equal(recordReference.remoteType(), 'identity'); + assert.equal(recordReference.type, 'person'); + assert.equal(recordReference.id(), 1); +}); + +test("push(object)", function(assert) { + var done = assert.async(); + + var push; + var recordReference = env.store.getReference('person', 1); + + run(function() { + push = recordReference.push({ + data: { + type: 'person', + id: 1, + attributes: { + name: "le name" } - }); + } }); + }); - assert.ok(push.then, 'RecordReference.push returns a promise'); + assert.ok(push.then, 'RecordReference.push returns a promise'); - run(function() { - push.then(function(record) { - assert.ok(record instanceof Person, "push resolves with the record"); - assert.equal(get(record, 'name'), "le name"); + run(function() { + push.then(function(record) { + assert.ok(record instanceof Person, "push resolves with the record"); + assert.equal(get(record, 'name'), "le name"); - done(); - }); + done(); }); }); +}); - test("push(promise)", function(assert) { - var done = assert.async(); +test("push(promise)", function(assert) { + var done = assert.async(); - var push; - var deferred = Ember.RSVP.defer(); - var recordReference = env.store.getReference('person', 1); + var push; + var deferred = Ember.RSVP.defer(); + var recordReference = env.store.getReference('person', 1); - run(function() { - push = recordReference.push(deferred.promise); - }); + run(function() { + push = recordReference.push(deferred.promise); + }); - assert.ok(push.then, 'RecordReference.push returns a promise'); + assert.ok(push.then, 'RecordReference.push returns a promise'); - run(function() { - deferred.resolve({ - data: { - type: 'person', - id: 1, - attributes: { - name: "le name" - } + run(function() { + deferred.resolve({ + data: { + type: 'person', + id: 1, + attributes: { + name: "le name" } - }); + } }); + }); - run(function() { - push.then(function(record) { - assert.ok(record instanceof Person, "push resolves with the record"); - assert.equal(get(record, 'name'), "le name", "name is updated"); + run(function() { + push.then(function(record) { + assert.ok(record instanceof Person, "push resolves with the record"); + assert.equal(get(record, 'name'), "le name", "name is updated"); - done(); - }); + done(); }); }); - - test("value() returns null when not yet loaded", function(assert) { - var recordReference = env.store.getReference('person', 1); - assert.equal(recordReference.value(), null); - }); - - test("value() returns the record when loaded", function(assert) { - var person; - run(function() { - person = env.store.push({ - data: { - type: 'person', - id: 1 - } - }); +}); + +test("value() returns null when not yet loaded", function(assert) { + var recordReference = env.store.getReference('person', 1); + assert.equal(recordReference.value(), null); +}); + +test("value() returns the record when loaded", function(assert) { + var person; + run(function() { + person = env.store.push({ + data: { + type: 'person', + id: 1 + } }); - - var recordReference = env.store.getReference('person', 1); - assert.equal(recordReference.value(), person); }); - test("load() fetches the record", function(assert) { - var done = assert.async(); + var recordReference = env.store.getReference('person', 1); + assert.equal(recordReference.value(), person); +}); + +test("load() fetches the record", function(assert) { + var done = assert.async(); - env.adapter.findRecord = function(store, type, id) { - return Ember.RSVP.resolve({ - id: 1, name: "Vito" - }); - }; + env.adapter.findRecord = function(store, type, id) { + return Ember.RSVP.resolve({ + id: 1, name: "Vito" + }); + }; - var recordReference = env.store.getReference('person', 1); + var recordReference = env.store.getReference('person', 1); - run(function() { - recordReference.load().then(function(record) { - assert.equal(get(record, 'name'), "Vito"); - done(); - }); + run(function() { + recordReference.load().then(function(record) { + assert.equal(get(record, 'name'), "Vito"); + done(); }); }); +}); - test("load() only a single find is triggered", function(assert) { - var done = assert.async(); +test("load() only a single find is triggered", function(assert) { + var done = assert.async(); - var deferred = Ember.RSVP.defer(); - var count = 0; + var deferred = Ember.RSVP.defer(); + var count = 0; - env.adapter.shouldReloadRecord = function() { return false; }; - env.adapter.shouldBackgroundReloadRecord = function() { return false; }; - env.adapter.findRecord = function(store, type, id) { - count++; - assert.equal(count, 1); + env.adapter.shouldReloadRecord = function() { return false; }; + env.adapter.shouldBackgroundReloadRecord = function() { return false; }; + env.adapter.findRecord = function(store, type, id) { + count++; + assert.equal(count, 1); - return deferred.promise; - }; + return deferred.promise; + }; - var recordReference = env.store.getReference('person', 1); + var recordReference = env.store.getReference('person', 1); - run(function() { - recordReference.load(); - recordReference.load().then(function(record) { - assert.equal(get(record, 'name'), "Vito"); - }); + run(function() { + recordReference.load(); + recordReference.load().then(function(record) { + assert.equal(get(record, 'name'), "Vito"); }); + }); - run(function() { - deferred.resolve({ - id: 1, name: "Vito" - }); + run(function() { + deferred.resolve({ + id: 1, name: "Vito" }); + }); - run(function() { - recordReference.load().then(function(record) { - assert.equal(get(record, 'name'), "Vito"); + run(function() { + recordReference.load().then(function(record) { + assert.equal(get(record, 'name'), "Vito"); - done(); - }); + done(); }); }); +}); - test("reload() loads the record if not yet loaded", function(assert) { - var done = assert.async(); +test("reload() loads the record if not yet loaded", function(assert) { + var done = assert.async(); - var count = 0; - env.adapter.findRecord = function(store, type, id) { - count++; - assert.equal(count, 1); + var count = 0; + env.adapter.findRecord = function(store, type, id) { + count++; + assert.equal(count, 1); - return Ember.RSVP.resolve({ - id: 1, name: "Vito Coreleone" - }); - }; + return Ember.RSVP.resolve({ + id: 1, name: "Vito Coreleone" + }); + }; - var recordReference = env.store.getReference('person', 1); + var recordReference = env.store.getReference('person', 1); - run(function() { - recordReference.reload().then(function(record) { - assert.equal(get(record, 'name'), "Vito Coreleone"); + run(function() { + recordReference.reload().then(function(record) { + assert.equal(get(record, 'name'), "Vito Coreleone"); - done(); - }); + done(); }); }); +}); + +test("reload() fetches the record", function(assert) { + var done = assert.async(); - test("reload() fetches the record", function(assert) { - var done = assert.async(); - - env.adapter.findRecord = function(store, type, id) { - return Ember.RSVP.resolve({ - id: 1, name: "Vito Coreleone" - }); - }; - - run(function() { - env.store.push({ - data: { - type: 'person', - id: 1, - attributes: { - name: 'Vito' - } + env.adapter.findRecord = function(store, type, id) { + return Ember.RSVP.resolve({ + id: 1, name: "Vito Coreleone" + }); + }; + + run(function() { + env.store.push({ + data: { + type: 'person', + id: 1, + attributes: { + name: 'Vito' } - }); + } }); + }); - var recordReference = env.store.getReference('person', 1); + var recordReference = env.store.getReference('person', 1); - run(function() { - recordReference.reload().then(function(record) { - assert.equal(get(record, 'name'), "Vito Coreleone"); + run(function() { + recordReference.reload().then(function(record) { + assert.equal(get(record, 'name'), "Vito Coreleone"); - done(); - }); + done(); }); }); - -} +}); diff --git a/tests/integration/relationships/belongs-to-test.js b/tests/integration/relationships/belongs-to-test.js index c016e7f834f..9e8c0d0f46b 100644 --- a/tests/integration/relationships/belongs-to-test.js +++ b/tests/integration/relationships/belongs-to-test.js @@ -1,6 +1,5 @@ import setupStore from 'dummy/tests/helpers/store'; import Ember from 'ember'; -import isEnabled from 'ember-data/-private/features'; import testInDebug from 'dummy/tests/helpers/test-in-debug'; import {module, test} from 'qunit'; @@ -1109,136 +1108,132 @@ test("Updated related link should take precedence over local data", function(ass }); }); -if (isEnabled('ds-references')) { +test("A belongsTo relationship can be reloaded using the reference if it was fetched via link", function(assert) { + var done = assert.async(); - test("A belongsTo relationship can be reloaded using the reference if it was fetched via link", function(assert) { - var done = assert.async(); + Chapter.reopen({ + book: DS.belongsTo({ async: true }) + }); - Chapter.reopen({ - book: DS.belongsTo({ async: true }) + env.adapter.findRecord = function() { + return Ember.RSVP.resolve({ + id: 1, + links: { book: '/books/1' } }); + }; - env.adapter.findRecord = function() { - return Ember.RSVP.resolve({ - id: 1, - links: { book: '/books/1' } - }); - }; - - env.adapter.findBelongsTo = function() { - return Ember.RSVP.resolve({ id: 1, name: "book title" }); - }; + env.adapter.findBelongsTo = function() { + return Ember.RSVP.resolve({ id: 1, name: "book title" }); + }; - run(function() { - var chapter; - store.findRecord('chapter', 1).then(function(_chapter) { - chapter = _chapter; + run(function() { + var chapter; + store.findRecord('chapter', 1).then(function(_chapter) { + chapter = _chapter; - return chapter.get('book'); - }).then(function(book) { - assert.equal(book.get('name'), "book title"); + return chapter.get('book'); + }).then(function(book) { + assert.equal(book.get('name'), "book title"); - env.adapter.findBelongsTo = function() { - return Ember.RSVP.resolve({ id: 1, name: "updated book title" }); - }; + env.adapter.findBelongsTo = function() { + return Ember.RSVP.resolve({ id: 1, name: "updated book title" }); + }; - return chapter.belongsTo('book').reload(); - }).then(function(book) { - assert.equal(book.get('name'), "updated book title"); + return chapter.belongsTo('book').reload(); + }).then(function(book) { + assert.equal(book.get('name'), "updated book title"); - done(); - }); + done(); }); }); +}); - test("A sync belongsTo relationship can be reloaded using a reference if it was fetched via id", function(assert) { - var done = assert.async(); +test("A sync belongsTo relationship can be reloaded using a reference if it was fetched via id", function(assert) { + var done = assert.async(); - Chapter.reopen({ - book: DS.belongsTo() - }); + Chapter.reopen({ + book: DS.belongsTo() + }); - var chapter; - run(function() { - chapter = env.store.push({ - data: { - type: 'chapter', - id: 1, - relationships: { - book: { - data: { type: 'book', id: 1 } - } + var chapter; + run(function() { + chapter = env.store.push({ + data: { + type: 'chapter', + id: 1, + relationships: { + book: { + data: { type: 'book', id: 1 } } } - }); - env.store.push({ - data: { - type: 'book', - id: 1, - attributes: { - name: "book title" - } + } + }); + env.store.push({ + data: { + type: 'book', + id: 1, + attributes: { + name: "book title" } - }); + } }); + }); - env.adapter.findRecord = function() { - return Ember.RSVP.resolve({ id: 1, name: "updated book title" }); - }; + env.adapter.findRecord = function() { + return Ember.RSVP.resolve({ id: 1, name: "updated book title" }); + }; - run(function() { - var book = chapter.get('book'); - assert.equal(book.get('name'), "book title"); + run(function() { + var book = chapter.get('book'); + assert.equal(book.get('name'), "book title"); - chapter.belongsTo('book').reload().then(function(book) { - assert.equal(book.get('name'), "updated book title"); + chapter.belongsTo('book').reload().then(function(book) { + assert.equal(book.get('name'), "updated book title"); - done(); - }); + done(); }); }); +}); - test("A belongsTo relationship can be reloaded using a reference if it was fetched via id", function(assert) { - var done = assert.async(); +test("A belongsTo relationship can be reloaded using a reference if it was fetched via id", function(assert) { + var done = assert.async(); - Chapter.reopen({ - book: DS.belongsTo({ async: true }) - }); + Chapter.reopen({ + book: DS.belongsTo({ async: true }) + }); - var chapter; - run(function() { - chapter = env.store.push({ - data: { - type: 'chapter', - id: 1, - relationships: { - book: { - data: { type: 'book', id: 1 } - } + var chapter; + run(function() { + chapter = env.store.push({ + data: { + type: 'chapter', + id: 1, + relationships: { + book: { + data: { type: 'book', id: 1 } } } - }); + } }); + }); - env.adapter.findRecord = function() { - return Ember.RSVP.resolve({ id: 1, name: "book title" }); - }; + env.adapter.findRecord = function() { + return Ember.RSVP.resolve({ id: 1, name: "book title" }); + }; - run(function() { - chapter.get('book').then(function(book) { - assert.equal(book.get('name'), "book title"); + run(function() { + chapter.get('book').then(function(book) { + assert.equal(book.get('name'), "book title"); - env.adapter.findRecord = function() { - return Ember.RSVP.resolve({ id: 1, name: "updated book title" }); - }; + env.adapter.findRecord = function() { + return Ember.RSVP.resolve({ id: 1, name: "updated book title" }); + }; - return chapter.belongsTo('book').reload(); - }).then(function(book) { - assert.equal(book.get('name'), "updated book title"); + return chapter.belongsTo('book').reload(); + }).then(function(book) { + assert.equal(book.get('name'), "updated book title"); - done(); - }); + done(); }); }); - -} +}); diff --git a/tests/unit/model-test.js b/tests/unit/model-test.js index c476e39718a..a79cebb57be 100644 --- a/tests/unit/model-test.js +++ b/tests/unit/model-test.js @@ -429,32 +429,6 @@ testInDebug("Calling attr() throws a warning", function(assert) { }); }); -if (!isEnabled('ds-references')) { - testInDebug("Calling belongsTo() throws a warning", function(assert) { - assert.expect(1); - - run(function() { - var person = store.createRecord('person', { id: 1, name: 'TomHuda' }); - - assert.throws(function() { - person.belongsTo(); - }, /The `belongsTo` method is not available on DS.Model, a DS.Snapshot was probably expected/, "belongsTo() throws a warning"); - }); - }); - - testInDebug("Calling hasMany() throws a warning", function(assert) { - assert.expect(1); - - run(function() { - var person = store.createRecord('person', { id: 1, name: 'TomHuda' }); - - assert.throws(function() { - person.hasMany(); - }, /The `hasMany` method is not available on DS.Model, a DS.Snapshot was probably expected/, "hasMany() throws a warning"); - }); - }); -} - test("supports pushedData in root.deleted.uncommitted", function(assert) { var record; var hash = {