16 |
--------------------------------------------------------------------------------
/addon/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsonapi-suite/ember-data-extensions/b2d91ffe8372c3ddd07b9ffb8bff63f820d04e02/addon/.gitkeep
--------------------------------------------------------------------------------
/addon/mixins/model.js:
--------------------------------------------------------------------------------
1 | import Mixin from '@ember/object/mixin';
2 | import { computed } from '@ember/object';
3 | import EmberObject from '@ember/object';
4 | import { A } from '@ember/array';
5 | import { defineProperty } from '@ember/object';
6 | import { guidFor } from '@ember/object/internals';
7 |
8 | const resetRelations = function(record) {
9 | Object.keys(record.get('__recordsJustSaved')).forEach((relationName) => {
10 | let relationRecords = record.get('__recordsJustSaved')[relationName];
11 |
12 | relationRecords.forEach((r) => {
13 | let shouldUnload = r.get('isNew') || r.get('markedForDestruction');
14 | if (shouldUnload) {
15 | r.unloadRecord();
16 | } else if (r.get('markedForDeletion')) {
17 | record.get(relationName).removeObject(r);
18 | r.set('markedForDeletion', false);
19 | }
20 | });
21 | });
22 | record.set('__recordsJustSaved', []);
23 | };
24 |
25 | const defaultOptions = function(options) {
26 | if (options.resetRelations !== false) {
27 | options.resetRelations = true;
28 | }
29 | };
30 |
31 | export default Mixin.create({
32 | hasDirtyAttributes: computed('currentState.isDirty', 'markedForDestruction', 'markedForDeletion', '_manyToOneDeleted.[]', function() {
33 | let original = this._super(...arguments);
34 | return original || this.get('markedForDestruction') || this.get('markedForDeletion') || this.get('_manyToOneDeleted.length') > 0;
35 | }),
36 |
37 | markedForDeletion: computed('_markedForDeletion', function() {
38 | return this.get('_markedForDeletion') || false;
39 | }),
40 |
41 | markedForDestruction: computed('_markedForDestruction', function() {
42 | return this.get('_markedForDestruction') || false;
43 | }),
44 |
45 | markForDeletion() {
46 | this.set('_markedForDeletion', true);
47 | },
48 |
49 | unmarkForDeletion() {
50 | this.set('_markedForDeletion', false);
51 | },
52 |
53 | markForDestruction() {
54 | this.set('_markedForDestruction', true);
55 | },
56 |
57 | unmarkForDestruction() {
58 | this.set('_markedForDestruction', false);
59 | },
60 |
61 | markManyToOneDeletion(relation) {
62 | let deletedRelations = this.get('_manyToOneDeleted');
63 |
64 | if (!deletedRelations) {
65 | this.set('_manyToOneDeleted', A());
66 | deletedRelations = this.get('_manyToOneDeleted');
67 | }
68 |
69 | if (!deletedRelations.includes(relation)) {
70 | deletedRelations.pushObject(relation);
71 | }
72 | },
73 |
74 | unmarkManyToOneDeletion(relation) {
75 | return this.markedForManyToOneDeletion(relation) && this.get('_manyToOneDeleted').removeObject(relation);
76 | },
77 |
78 | markedForManyToOneDeletion(relation) {
79 | return this.get('_manyToOneDeleted') && this.get('_manyToOneDeleted').includes(relation);
80 | },
81 |
82 | markManyToManyDeletion(relation, model) {
83 | let deletedRelations = this.get('_manyToManyDeleted');
84 | if(!deletedRelations) {
85 | this.set('_manyToManyDeleted', EmberObject.create());
86 | deletedRelations = this.get('_manyToManyDeleted');
87 | }
88 |
89 | if(!deletedRelations.get(relation)) {
90 | deletedRelations.set(relation, A());
91 | defineProperty(
92 | this,
93 | `manyToManyDeleted${relation}`, computed.readOnly(`_manyToManyDeleted.${relation}`)
94 | );
95 | }
96 |
97 | if(!deletedRelations.get(relation).includes(model)) {
98 | deletedRelations.get(relation).pushObject(model);
99 | }
100 | },
101 |
102 | manyToManyMarkedForDeletionModels(relation) {
103 | const relationModels = this.get('_manyToManyDeleted') &&
104 | this.get(`_manyToManyDeleted.${relation}`);
105 | return relationModels && relationModels.toArray() || [];
106 | },
107 |
108 | unmarkManyToManyDeletion(relation, model) {
109 | return this.get('_manyToManyDeleted') &&
110 | this.get(`_manyToManyDeleted.${relation}`) &&
111 | this.get(`_manyToManyDeleted.${relation}`).removeObject(model);
112 | },
113 |
114 | tempId() {
115 | if (!this._tempId) {
116 | this._tempId = guidFor(this);
117 | }
118 | return this._tempId;
119 | },
120 |
121 | jsonapiType() {
122 | return this.store
123 | .adapterFor(this.constructor.modelName)
124 | .pathForType(this.constructor.modelName);
125 | },
126 |
127 | // Blank out all relations after saving
128 | // We will use the server response includes to 'reset'
129 | // these relations
130 | save(options = {}) {
131 | defaultOptions(options);
132 | let promise = this._super(...arguments);
133 | if (options.resetRelations === true) {
134 | promise.then(resetRelations);
135 | }
136 | return promise;
137 | }
138 | });
139 |
--------------------------------------------------------------------------------
/addon/mixins/nested-relations.js:
--------------------------------------------------------------------------------
1 | import Mixin from '@ember/object/mixin';
2 | import { copy } from '@ember/object/internals';
3 | import { merge } from '@ember/polyfills';
4 |
5 | // This is for reference in our post-save promise
6 | // We need to unload these records after save, otherwise
7 | // we will be left with 2 of the same object - one persisted
8 | // and one not.
9 | // This is only required for hasMany's
10 | let savedRecords = {};
11 |
12 | const iterateRelations = function(record, relations, callback) {
13 | Object.keys(relations).forEach((relationName) => {
14 | let subRelations = relations[relationName];
15 |
16 | let metadata = record.relationshipFor(relationName);
17 | let kind = metadata.kind;
18 | let relatedRecord = record.get(relationName);
19 | let manyToManyDeleted = record.manyToManyMarkedForDeletionModels(relationName);
20 | let isManyToOneDelete = record.markedForManyToOneDeletion(relationName);
21 |
22 | if (metadata.options.async !== false) {
23 | relatedRecord = relatedRecord.get('content');
24 | }
25 |
26 | if (relatedRecord) {
27 | callback(relationName, kind, relatedRecord, subRelations, manyToManyDeleted, isManyToOneDelete);
28 | }
29 | });
30 | };
31 |
32 | const isPresentObject = function(val) {
33 | return val && Object.keys(val).length > 0;
34 | };
35 |
36 | const attributesFor = function(record) {
37 | let attrs = {};
38 |
39 | let changes = record.changedAttributes();
40 | let serializer = record.store.serializerFor(record.constructor.modelName);
41 |
42 | record.eachAttribute((name/* meta */) => {
43 | let keyName = serializer.keyForAttribute(name);
44 |
45 | if (record.get('isNew') || changes[name]) {
46 | let value = record.get(name);
47 |
48 | if (value !== undefined) {
49 | attrs[keyName] = record.get(name);
50 | }
51 | }
52 | });
53 |
54 | return record.transformJsonapiAttrs ? record.transformJsonapiAttrs(attrs) : attrs;
55 | };
56 |
57 | const jsonapiPayload = function(record, relationshipMarkedForDeletion) {
58 | let attributes = attributesFor(record);
59 |
60 | let payload = { type: record.jsonapiType() };
61 |
62 | if (isPresentObject(attributes)) {
63 | payload.attributes = attributes;
64 | }
65 |
66 | if (record.get('isNew')) {
67 | payload['temp-id'] = record.tempId();
68 | payload['method'] = 'create';
69 | }
70 | else if (record.get('markedForDestruction')) {
71 | payload['method'] = 'destroy';
72 | }
73 | else if (record.get('markedForDeletion') || relationshipMarkedForDeletion) {
74 | payload['method'] = 'disassociate';
75 | }
76 | else if (record.get('currentState.isDirty')) {
77 | payload['method'] = 'update';
78 | }
79 |
80 | if (record.id) {
81 | payload.id = record.id;
82 | }
83 |
84 | return payload;
85 | };
86 |
87 | const payloadForInclude = function(payload) {
88 | let payloadCopy = copy(payload, true);
89 | delete(payloadCopy.method);
90 |
91 | return payloadCopy;
92 | };
93 |
94 | const payloadForRelationship = function(payload) {
95 | let payloadCopy = copy(payload, true);
96 | delete(payloadCopy.attributes);
97 | delete(payloadCopy.relationships);
98 |
99 | return payloadCopy;
100 | };
101 |
102 | const addToIncludes = function(payload, includedRecords) {
103 | let includedPayload = payloadForInclude(payload);
104 |
105 | if (!includedPayload.attributes && !isPresentObject(includedPayload.relationships)) {
106 | return;
107 | }
108 |
109 | const alreadyIncluded = includedRecords.find((includedRecord) =>
110 | includedPayload['type'] === includedRecord['type'] &&
111 | ((includedPayload['temp-id'] && includedPayload['temp-id'] === includedRecord['temp-id']) ||
112 | (includedPayload['id'] && includedPayload['id'] === includedRecord['id']))
113 | ) !== undefined;
114 |
115 | if (!alreadyIncluded) {
116 | includedRecords.push(includedPayload);
117 | }
118 | };
119 |
120 | const hasManyData = function(relationName, relatedRecords, subRelations, manyToManyDeleted, includedRecords) {
121 | let payloads = [];
122 | savedRecords[relationName] = [];
123 |
124 | relatedRecords.forEach((relatedRecord) => {
125 | let payload = jsonapiPayload(relatedRecord, manyToManyDeleted && manyToManyDeleted.includes(relatedRecord));
126 | processRelationships(subRelations, payload, relatedRecord, includedRecords);
127 | addToIncludes(payload, includedRecords);
128 |
129 | payloads.push(payloadForRelationship(payload));
130 | savedRecords[relationName].push(relatedRecord);
131 | });
132 | return { data: payloads };
133 | };
134 |
135 | const belongsToData = function(relatedRecord, subRelations, isManyToOneDelete, includedRecords) {
136 | let payload = jsonapiPayload(relatedRecord, isManyToOneDelete);
137 | processRelationships(subRelations, payload, relatedRecord, includedRecords);
138 | addToIncludes(payload, includedRecords);
139 |
140 | return { data: payloadForRelationship(payload) };
141 | };
142 |
143 | const processRelationship = function(name, kind, relationData, subRelations, manyToManyDeleted, isManyToOneDelete, includedRecords, callback) {
144 | let payload = null;
145 |
146 | if (kind === 'hasMany') {
147 | payload = hasManyData(name, relationData, subRelations, manyToManyDeleted, includedRecords);
148 | } else {
149 | payload = belongsToData(relationData, subRelations, isManyToOneDelete, includedRecords);
150 | }
151 |
152 | if (payload && payload.data) {
153 | callback(payload);
154 | }
155 | };
156 |
157 | const processRelationships = function(relationshipHash, jsonData, record, includedRecords) {
158 | if (isPresentObject(relationshipHash)) {
159 | jsonData.relationships = {};
160 |
161 | iterateRelations(record, relationshipHash, (name, kind, related, subRelations, manyToManyDeleted, isManyToOneDelete) => {
162 | processRelationship(name, kind, related, subRelations, manyToManyDeleted, isManyToOneDelete, includedRecords, (payload) => {
163 | let serializer = record.store.serializerFor(record.constructor.modelName);
164 | let serializedName = serializer.keyForRelationship(name);
165 | jsonData.relationships[serializedName] = payload;
166 | });
167 | });
168 | }
169 | };
170 |
171 | const relationshipsDirective = function(value) {
172 | let directive = {};
173 |
174 | if (value) {
175 | if (typeof(value) === 'string') {
176 | directive[value] = {};
177 | } else if(Array.isArray(value)) {
178 | value.forEach((key) => {
179 | merge(directive, relationshipsDirective(key));
180 | });
181 | } else {
182 | Object.keys(value).forEach((key) => {
183 | directive[key] = relationshipsDirective(value[key]);
184 | });
185 | }
186 | } else {
187 | return {};
188 | }
189 |
190 | return directive;
191 | };
192 |
193 | export default Mixin.create({
194 | serialize(snapshot/*, options */) {
195 | savedRecords = [];
196 |
197 | let json = this._super(...arguments);
198 | let includedRecords = [];
199 |
200 | if (snapshot.record.get('emberDataExtensions') !== false) {
201 | delete(json.data.relationships);
202 | delete(json.data.attributes);
203 |
204 | let adapterOptions = snapshot.adapterOptions || {};
205 |
206 | let attributes = attributesFor(snapshot.record);
207 | if (isPresentObject(attributes)) {
208 | json.data.attributes = attributes;
209 | }
210 |
211 | if (snapshot.record.id) {
212 | json.data.id = snapshot.record.id.toString();
213 | }
214 |
215 | if (adapterOptions.attributes === false) {
216 | delete(json.data.attributes);
217 | }
218 |
219 | if (adapterOptions.attributes) {
220 | if (!json.data.attributes) {
221 | json.data.attributes = {};
222 | }
223 |
224 | Object.keys(adapterOptions.attributes).forEach((k) => {
225 | json.data.attributes[k] = adapterOptions.attributes[k];
226 | });
227 | }
228 |
229 | let relationships = relationshipsDirective(adapterOptions.relationships);
230 | processRelationships(relationships, json.data, snapshot.record, includedRecords);
231 | if (includedRecords && includedRecords.length > 0) {
232 | json.included = includedRecords;
233 | }
234 | snapshot.record.set('__recordsJustSaved', savedRecords);
235 | }
236 |
237 | return json;
238 | }
239 | });
240 |
--------------------------------------------------------------------------------
/app/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsonapi-suite/ember-data-extensions/b2d91ffe8372c3ddd07b9ffb8bff63f820d04e02/app/.gitkeep
--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "ember-data-extensions",
3 | "dependencies": {
4 | "ember": "~2.7.0",
5 | "ember-cli-shims": "0.1.1",
6 | "ember-qunit-notifications": "0.1.0",
7 | "pretender": "~1.1.0",
8 | "Faker": "~3.1.0",
9 | "materialize": "0.97.0"
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/config/ember-try.js:
--------------------------------------------------------------------------------
1 | /*jshint node:true*/
2 | module.exports = {
3 | scenarios: [
4 | {
5 | name: 'default',
6 | bower: {
7 | dependencies: { }
8 | }
9 | },
10 | {
11 | name: 'ember-1.13',
12 | bower: {
13 | dependencies: {
14 | 'ember': '~1.13.0'
15 | },
16 | resolutions: {
17 | 'ember': '~1.13.0'
18 | }
19 | }
20 | },
21 | {
22 | name: 'ember-release',
23 | bower: {
24 | dependencies: {
25 | 'ember': 'components/ember#release'
26 | },
27 | resolutions: {
28 | 'ember': 'release'
29 | }
30 | }
31 | },
32 | {
33 | name: 'ember-beta',
34 | bower: {
35 | dependencies: {
36 | 'ember': 'components/ember#beta'
37 | },
38 | resolutions: {
39 | 'ember': 'beta'
40 | }
41 | }
42 | },
43 | {
44 | name: 'ember-canary',
45 | bower: {
46 | dependencies: {
47 | 'ember': 'components/ember#canary'
48 | },
49 | resolutions: {
50 | 'ember': 'canary'
51 | }
52 | }
53 | }
54 | ]
55 | };
56 |
--------------------------------------------------------------------------------
/config/environment.js:
--------------------------------------------------------------------------------
1 | /*jshint node:true*/
2 | 'use strict';
3 |
4 | module.exports = function(/* environment, appConfig */) {
5 | return { };
6 | };
7 |
--------------------------------------------------------------------------------
/ember-cli-build.js:
--------------------------------------------------------------------------------
1 | /*jshint node:true*/
2 | /* global require, module */
3 | var EmberAddon = require('ember-cli/lib/broccoli/ember-addon');
4 |
5 | module.exports = function(defaults) {
6 | var app = new EmberAddon(defaults, {
7 | // Add options here
8 | });
9 |
10 | app.import('bower_components/materialize/dist/css/materialize.css', { prepend: true });
11 |
12 | /*
13 | This build file specifies the options for the dummy test app of this
14 | addon, located in `/tests/dummy`
15 | This build file does *not* influence how the addon or the app using it
16 | behave. You most likely want to be modifying `./index.js` or app's build file
17 | */
18 |
19 | return app.toTree();
20 | };
21 |
--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
1 | /* jshint node: true */
2 | 'use strict';
3 |
4 | module.exports = {
5 | name: 'ember-data-extensions',
6 | isDevelopingAddon() {
7 | return true;
8 | }
9 | };
10 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "ember-data-jsonapi-extensions",
3 | "version": "0.8.0",
4 | "description": "The default blueprint for ember-cli addons.",
5 | "directories": {
6 | "doc": "doc",
7 | "test": "tests"
8 | },
9 | "scripts": {
10 | "build": "ember build",
11 | "start": "ember server",
12 | "test": "ember try:each"
13 | },
14 | "repository": "https://github.com/jsonapi-suite/ember-data-extensions",
15 | "engines": {
16 | "node": ">= 0.10.0"
17 | },
18 | "author": "",
19 | "license": "MIT",
20 | "devDependencies": {
21 | "broccoli-asset-rev": "^2.4.2",
22 | "ember-ajax": "^3.0.1",
23 | "ember-cli": "^2.7.0",
24 | "ember-cli-app-version": "^2.0.0",
25 | "ember-cli-dependency-checker": "^1.2.0",
26 | "ember-cli-eslint": "4.2.3",
27 | "ember-cli-htmlbars": "^1.0.3",
28 | "ember-cli-htmlbars-inline-precompile": "^0.4.0",
29 | "ember-cli-inject-live-reload": "^1.4.0",
30 | "ember-cli-mirage": "^0.2.1",
31 | "ember-cli-page-object": "^1.6.0",
32 | "ember-cli-qunit": "^3.0.0",
33 | "ember-cli-release": "^0.2.9",
34 | "ember-cli-sri": "^2.1.0",
35 | "ember-cli-test-loader": "^2.0.0",
36 | "ember-cli-uglify": "^1.2.0",
37 | "ember-disable-prototype-extensions": "^1.1.0",
38 | "ember-export-application-global": "^2.0.0",
39 | "ember-load-initializers": "^0.5.1",
40 | "ember-resolver": "^5.0.0",
41 | "eslint-plugin-ember": "^5.2.0",
42 | "loader.js": "^4.0.1"
43 | },
44 | "keywords": [
45 | "ember-addon"
46 | ],
47 | "dependencies": {
48 | "ember-cli-babel": "^6.6.0",
49 | "ember-data": "^2.7.0"
50 | },
51 | "ember-addon": {
52 | "configPath": "tests/dummy/config"
53 | }
54 | }
55 |
--------------------------------------------------------------------------------
/testem.js:
--------------------------------------------------------------------------------
1 | /*jshint node:true*/
2 | module.exports = {
3 | "framework": "qunit",
4 | "test_page": "tests/index.html?hidepassed",
5 | "disable_watching": true,
6 | "launch_in_ci": [
7 | "Chrome"
8 | ],
9 | "launch_in_dev": [
10 | "Chrome"
11 | ]
12 | };
13 |
--------------------------------------------------------------------------------
/tests/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | env: {
3 | embertest: true
4 | },
5 | globals: {
6 | server: true,
7 | QUnit: true
8 | }
9 | };
10 |
--------------------------------------------------------------------------------
/tests/acceptance/create-nested-relations-test.js:
--------------------------------------------------------------------------------
1 | import { test } from 'qunit';
2 | import moduleForAcceptance from '../../tests/helpers/module-for-acceptance';
3 | import page from 'dummy/tests/pages/post-form';
4 | import detailPage from 'dummy/tests/pages/show-post';
5 |
6 | moduleForAcceptance('Acceptance | create nested relations');
7 |
8 | test('creating a record with nested relations', function(assert) {
9 | page
10 | .visit()
11 | .title.fillIn('my post');
12 |
13 | page.addTag().tags(0).setName('new tag 1');
14 | page.addTag().tags(1).setName('new tag 2');
15 | page.addTag();
16 | page.authorName.fillIn('John Doe');
17 | page.submit();
18 |
19 | andThen(function() {
20 | assert.equal(detailPage.title, 'my post', 'saves basic attributes correctly');
21 | assert.equal(detailPage.tagList, 'new tag 1, new tag 2', 'saves one-to-many correctly');
22 | assert.equal(detailPage.tagIds, '1, 2', 'maintains one-to-many ids correctly');
23 | assert.equal(detailPage.authorName, 'John Doe', 'saves one-to-one correctly');
24 | assert.equal(detailPage.authorId, '1', 'maintains one-to-one ids correctly');
25 | });
26 | });
27 |
--------------------------------------------------------------------------------
/tests/acceptance/delete-nested-object-test.js:
--------------------------------------------------------------------------------
1 | import { test } from 'qunit';
2 | import moduleForAcceptance from '../../tests/helpers/module-for-acceptance';
3 | import page from 'dummy/tests/pages/post-form';
4 | import detailPage from 'dummy/tests/pages/show-post';
5 |
6 | moduleForAcceptance('Acceptance | delete nested objects');
7 |
8 | test('deleting a nested object', function(assert) {
9 | page.visit();
10 | page.addTag().tags(0).setName('a');
11 | page.submit();
12 |
13 | andThen(function() {
14 | assert.equal(detailPage.tagList, 'a');
15 | detailPage.edit();
16 |
17 | andThen(function() {
18 | page.addTag().tags(1).setName('b');
19 | page.submit();
20 |
21 | andThen(function() {
22 | detailPage.edit();
23 |
24 | andThen(function() {
25 | page.tags(0).remove();
26 |
27 | andThen(function() {
28 | assert.equal(page.tags().count, 1, 'should not show removed tag');
29 | page.submit();
30 |
31 | andThen(function() {
32 | assert.equal(detailPage.tagList, 'b', 'should delete removed tag');
33 | });
34 | });
35 | });
36 | });
37 | });
38 | });
39 | });
40 |
--------------------------------------------------------------------------------
/tests/acceptance/update-nested-relations-test.js:
--------------------------------------------------------------------------------
1 | import { test } from 'qunit';
2 | import moduleForAcceptance from '../../tests/helpers/module-for-acceptance';
3 | import page from 'dummy/tests/pages/post-form';
4 | import detailPage from 'dummy/tests/pages/show-post';
5 |
6 | moduleForAcceptance('Acceptance | update nested relations');
7 |
8 | test('updating nested relations', function(assert) {
9 | let author = server.create('author', { name: 'Joe Author' });
10 | let tag1 = server.create('tag', { name: 'tag1' });
11 | let tag2 = server.create('tag', { name: 'tag2' });
12 | let post = server.create('post', {
13 | author: author,
14 | tags: [tag1, tag2],
15 | title: 'test title'
16 | });
17 | visit(`/posts/${post.id}/edit`);
18 |
19 | andThen(function() {
20 | assert.equal(page.title.val, 'test title');
21 | assert.equal(page.authorName.val, 'Joe Author');
22 | assert.equal(page.tags().count, 2);
23 | assert.equal(page.tags(0).name, 'tag1');
24 | assert.equal(page.tags(1).name, 'tag2');
25 |
26 | page.authorName.fillIn('new author');
27 | page.tags(1).setName('tag2 changed');
28 | page.addTag();
29 | page.tags(2).setName('new tag');
30 | page.submit();
31 |
32 | andThen(function() {
33 | post.reload();
34 | assert.equal(post.author.id, author.id, 'updates existing author');
35 | assert.equal(detailPage.authorName, 'new author', 'updates author name');
36 | assert.equal(detailPage.tagList, 'tag1, tag2 changed, new tag', 'updates one-to-many correctly');
37 | });
38 | });
39 | });
40 |
41 | test('updating only one member of a hasMany relation', function(assert) {
42 | server.foo = 'bar';
43 | let tag1 = server.create('tag', { name: 'tag1' });
44 | let tag2 = server.create('tag', { name: 'tag2' });
45 | let post = server.create('post', {
46 | tags: [tag1, tag2],
47 | });
48 | visit(`/posts/${post.id}/edit`);
49 |
50 | andThen(function() {
51 | assert.equal(page.tags().count, 2);
52 | page.tags(0).setName('tag1 changed');
53 | page.submit();
54 |
55 | andThen(function() {
56 | assert.equal(detailPage.tagList, 'tag1 changed, tag2');
57 | });
58 | });
59 | });
60 |
--------------------------------------------------------------------------------
/tests/dummy/app/app.js:
--------------------------------------------------------------------------------
1 | import Ember from 'ember';
2 | import Application from '@ember/application';
3 | import Resolver from './resolver';
4 | import loadInitializers from 'ember-load-initializers';
5 | import config from './config/environment';
6 |
7 | let App;
8 |
9 | Ember.MODEL_FACTORY_INJECTIONS = true;
10 |
11 | App = Application.extend({
12 | modulePrefix: config.modulePrefix,
13 | podModulePrefix: config.podModulePrefix,
14 | Resolver
15 | });
16 |
17 | loadInitializers(App, config.modulePrefix);
18 |
19 | export default App;
20 |
--------------------------------------------------------------------------------
/tests/dummy/app/components/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsonapi-suite/ember-data-extensions/b2d91ffe8372c3ddd07b9ffb8bff63f820d04e02/tests/dummy/app/components/.gitkeep
--------------------------------------------------------------------------------
/tests/dummy/app/controllers/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsonapi-suite/ember-data-extensions/b2d91ffe8372c3ddd07b9ffb8bff63f820d04e02/tests/dummy/app/controllers/.gitkeep
--------------------------------------------------------------------------------
/tests/dummy/app/controllers/post-form.js:
--------------------------------------------------------------------------------
1 | import Controller from '@ember/controller';
2 | import { filterBy } from '@ember/object/computed';
3 |
4 | export default Controller.extend({
5 | tags: filterBy('model.tags', 'markedForDeletion', false)
6 | });
7 |
--------------------------------------------------------------------------------
/tests/dummy/app/edit-post/route.js:
--------------------------------------------------------------------------------
1 | import PostFormMixin from 'dummy/mixins/post-form-route';
2 | import Route from '@ember/routing/route';
3 |
4 | export default Route.extend(PostFormMixin, {
5 | model(params) {
6 | return this.store.findRecord('post', params.post_id, {
7 | include: 'tags,author'
8 | });
9 | }
10 | });
11 |
--------------------------------------------------------------------------------
/tests/dummy/app/helpers/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jsonapi-suite/ember-data-extensions/b2d91ffe8372c3ddd07b9ffb8bff63f820d04e02/tests/dummy/app/helpers/.gitkeep
--------------------------------------------------------------------------------
/tests/dummy/app/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |