[BUGFIX TEST] queries tests for adapter encapsulation side quest

packages/store/addon/-private/system/core-store.ts

@@ -1142,7 +1142,8 @@ abstract class CoreStore extends Service {
         if (IDENTIFIERS) {
           // ensure that regardless of id returned we assign to the correct record
           if (payload.data && !Array.isArray(payload.data)) {
-            payload.data.lid = identifier.lid;
+            payload = { ...payload };
+            payload.data = { ...payload.data, lid: identifier.lid };
           }
         }
 

packages/store/addon/-private/system/store/finders.js

@@ -61,7 +61,8 @@ export function _find(adapter, store, modelClass, id, internalModel, options) {
 
       if (IDENTIFIERS) {
         // ensure that regardless of id returned we assign to the correct record
-        payload.data.lid = identifier.lid;
+        payload = { ...payload };
+        payload.data = { ...payload.data, lid: identifier.lid };
       }
 
       return store._push(payload);

packages/unpublished-adapter-encapsulation-test-app/tests/integration/queries-test.js

@@ -0,0 +1,209 @@
+import { setupTest } from 'ember-qunit';
+import { module, test } from 'qunit';
+import EmberObject from '@ember/object';
+import Store from 'adapter-encapsulation-test-app/services/store';
+import Model, { attr } from '@ember-data/model';
+import { resolve } from 'rsvp';
+
+class MinimalSerializer extends EmberObject {
+  normalizeResponse(_, __, data) {
+    return data;
+  }
+
+  serialize(snapshot) {
+    return {
+      data: {
+        id: snapshot.id,
+        type: snapshot.modelName,
+        attributes: snapshot.attributes(),
+      },
+    };
+  }
+}
+
+class Person extends Model {
+  @attr
+  firstName;
+
+  @attr
+  lastName;
+}
+
+module('integration/queries - Queries Tests', function(hooks) {
+  setupTest(hooks);
+
+  hooks.beforeEach(function() {
+    this.owner.register('service:store', Store);
+    this.owner.register('serializer:application', MinimalSerializer);
+    this.owner.register('model:person', Person);
+  });
+
+  test('store.findRecord calls adapter.findRecord w/correct args', async function(assert) {
+    let findRecordCalled = 0;
+    let expectedResult = {
+      data: {
+        id: '12',
+        type: 'person',
+        attributes: {
+          firstName: 'Gaurav',
+          lastName: 'Munjal',
+        },
+      },
+    };
+    let { owner } = this;
+    let store = owner.lookup('service:store');
+
+    class TestFindRecordAdapter extends EmberObject {
+      findRecord(passedStore, type, id, snapshot) {
+        findRecordCalled++;
+
+        assert.equal(passedStore, store, 'instance of store is passed to findRecord');
+        assert.equal(type, Person, 'model is passed to findRecord');
+        assert.equal(id, '12', 'id is passed to findRecord');
+
+        assert.equal(snapshot.modelName, 'person', 'snapshot is passed to findRecord with correct modelName');
+        assert.equal(snapshot.id, '12', 'snapshot is passed to findRecord with correct id');
+
+        return resolve(expectedResult);
+      }
+    }
+
+    owner.register('adapter:application', TestFindRecordAdapter);
+
+    let record = await store.findRecord('person', '12');
+
+    assert.equal(findRecordCalled, 1, 'findRecord is called once');
+    assert.deepEqual(record.serialize(), expectedResult, 'findRecord returns expected result');
+  });
+
+  test('store.findAll calls adapter.findAll w/correct args', async function(assert) {
+    let findAllCalled = 0;
+    let expectedResult = {
+      data: [
+        {
+          id: '12',
+          type: 'person',
+          attributes: {
+            firstName: 'Gaurav',
+            lastName: 'Munjal',
+          },
+        },
+        {
+          id: '19',
+          type: 'person',
+          attributes: {
+            firstName: 'Chris',
+            lastName: 'Thoburn',
+          },
+        },
+      ],
+    };
+    let { owner } = this;
+    let store = owner.lookup('service:store');
+
+    class TestFindAllAdapter extends EmberObject {
+      findAll(passedStore, type, sinceToken, snapshot) {
+        findAllCalled++;
+
+        assert.equal(passedStore, store, 'instance of store is passed to findAll');
+        assert.equal(type, Person, 'model is passed to findAll');
+        assert.strictEqual(sinceToken, null, 'sinceToken passed to findAll is null');
+        assert.equal(snapshot.modelName, 'person', 'snapshot is passed to findAll with correct modelName');
+        assert.equal(snapshot.length, 0, 'snapshot is passed to findAll represnts empty array');
+
+        return resolve(expectedResult);
+      }
+    }
+
+    owner.register('adapter:application', TestFindAllAdapter);
+
+    let manyArray = await store.findAll('person');
+    let result = manyArray.toArray().map(person => person.serialize());
+    expectedResult = expectedResult.data.map(person => ({ data: person }));
+
+    assert.equal(findAllCalled, 1, 'findAll is called once');
+    assert.deepEqual(result, expectedResult, 'findAll returns expected result');
+  });
+
+  test('store.queryRecord calls adapter.queryRecord w/correct args', async function(assert) {
+    let queryRecordCalled = 0;
+    let expectedResult = {
+      data: {
+        id: '12',
+        type: 'person',
+        attributes: {
+          firstName: 'Gaurav',
+          lastName: 'Munjal',
+        },
+      },
+    };
+    let { owner } = this;
+    let store = owner.lookup('service:store');
+
+    class TestQueryRecordAdapter extends EmberObject {
+      queryRecord(passedStore, type, query) {
+        queryRecordCalled++;
+
+        assert.equal(passedStore, store, 'instance of store is passed to queryRecord');
+        assert.equal(type, Person, 'model is passed to queryRecord');
+        assert.deepEqual(query, { firstName: 'Gaurav' }, 'query is passed to queryRecord');
+
+        return resolve(expectedResult);
+      }
+    }
+
+    owner.register('adapter:application', TestQueryRecordAdapter);
+
+    let record = await store.queryRecord('person', { firstName: 'Gaurav' });
+
+    assert.equal(queryRecordCalled, 1, 'queryRecord is called once');
+    assert.deepEqual(record.serialize(), expectedResult, 'queryRecord returns expected result');
+  });
+
+  test('store.query calls adapter.query w/correct args', async function(assert) {
+    let queryCalled = 0;
+    let expectedResult = {
+      data: [
+        {
+          id: '14',
+          type: 'person',
+          attributes: {
+            firstName: 'Chris',
+            lastName: 'Tse',
+          },
+        },
+        {
+          id: '19',
+          type: 'person',
+          attributes: {
+            firstName: 'Chris',
+            lastName: 'Thoburn',
+          },
+        },
+      ],
+    };
+    let { owner } = this;
+    let store = owner.lookup('service:store');
+
+    class TestQueryAdapter extends EmberObject {
+      query(passedStore, type, query) {
+        queryCalled++;
+
+        assert.equal(passedStore, store, 'instance of store is passed to query');
+        assert.equal(type, Person, 'model is passed to query');
+        assert.deepEqual(query, { firstName: 'Chris' }, 'query is passed to query');
+
+        return resolve(expectedResult);
+      }
+    }
+
+    owner.register('adapter:application', TestQueryAdapter);
+
+    let manyArray = await store.query('person', { firstName: 'Chris' });
+    let result = manyArray.toArray().map(person => person.serialize());
+    expectedResult = expectedResult.data.map(person => ({ data: person }));
+
+    assert.equal(queryCalled, 1, 'query is called once');
+    assert.deepEqual(result, expectedResult, 'query returns expected result');
+  });
+});

packages/unpublished-adapter-encapsulation-test-app/tests/integration/reload-test.js

@@ -3,7 +3,6 @@ import { module, test } from 'qunit';
 import EmberObject from '@ember/object';
 import Store from 'adapter-encapsulation-test-app/services/store';
 import Model, { attr } from '@ember-data/model';
-import Transform from '@ember-data/serializer/transform';
 import { resolve } from 'rsvp';
 
 class MinimalSerializer extends EmberObject {
@@ -80,12 +79,6 @@ module('integration/reload - Reloading Tests', function(hooks) {
   setupTest(hooks);
 
   hooks.beforeEach(function() {
-    // Needed to avoid deprecation warning even though not using any transforms.
-    this.owner.register('transform:date', class DateTransform extends Transform {});
-    this.owner.register('transform:number', class NumberTransform extends Transform {});
-    this.owner.register('transform:boolean', class BooleanTransform extends Transform {});
-    this.owner.register('transform:string', class StringTransform extends Transform {});
-
     this.owner.register('service:store', Store);
     this.owner.register('serializer:application', MinimalSerializer);
     this.owner.register('model:person', Person);