Add working test setup

Author: Baltazore

tests/builders/app/models/user-setting.ts

@@ -0,0 +1,5 @@
+import Model, { attr } from '@ember-data/model';
+
+export default class UserSetting extends Model {
+  @attr declare name: string;
+}

tests/builders/app/services/store.js

@@ -0,0 +1,38 @@
+import JSONAPICache from '@ember-data/json-api';
+import type Model from '@ember-data/model';
+import { instantiateRecord, teardownRecord } from '@ember-data/model';
+import { buildSchema, modelFor } from '@ember-data/model/hooks';
+import RequestManager from '@ember-data/request';
+import Fetch from '@ember-data/request/fetch';
+import DataStore, { CacheHandler } from '@ember-data/store';
+import type { Cache } from '@ember-data/types/cache/cache';
+import type { CacheCapabilitiesManager } from '@ember-data/types/q/cache-store-wrapper';
+import type { StableRecordIdentifier } from '@ember-data/types/q/identifier';
+
+export default class Store extends DataStore {
+  constructor(args: unknown) {
+    super(args);
+
+    const manager = (this.requestManager = new RequestManager());
+    manager.use([Fetch]);
+    manager.useCache(CacheHandler);
+
+    this.registerSchema(buildSchema(this));
+  }
+
+  createCache(capabilities: CacheCapabilitiesManager): Cache {
+    return new JSONAPICache(capabilities);
+  }
+
+  instantiateRecord(identifier: StableRecordIdentifier, createRecordArgs: { [key: string]: unknown }): unknown {
+    return instantiateRecord.call(this, identifier, createRecordArgs);
+  }
+
+  teardownRecord(record: Model): void {
+    return teardownRecord.call(this, record);
+  }
+
+  modelFor(type: string) {
+    return modelFor.call(this, type);
+  }
+}

tests/builders/app/services/store.ts

@@ -28,6 +28,15 @@
     "@ember-data/store": {
       "injected": true
     },
+    "@ember-data/model": {
+      "injected": true
+    },
+    "@ember-data/legacy-compat": {
+      "injected": true
+    },
+    "@ember-data/request": {
+      "injected": true
+    },
     "@ember-data/request-utils": {
       "injected": true
     },
@@ -47,7 +56,10 @@
     "@ember-data/active-record": "workspace:5.4.0-alpha.14",
     "@ember-data/graph": "workspace:5.4.0-alpha.14",
     "@ember-data/json-api": "workspace:5.4.0-alpha.14",
+    "@ember-data/model": "workspace:5.4.0-alpha.14",
+    "@ember-data/legacy-compat": "workspace:5.4.0-alpha.14",
     "@ember-data/private-build-infra": "workspace:5.4.0-alpha.14",
+    "@ember-data/request": "workspace:5.4.0-alpha.14",
     "@ember-data/request-utils": "workspace:5.4.0-alpha.14",
     "@ember-data/rest": "workspace:5.4.0-alpha.14",
     "@ember-data/store": "workspace:5.4.0-alpha.14",

tests/builders/package.json

@@ -4,7 +4,7 @@ import { setupTest } from 'ember-qunit';
 
 import { createRecord, deleteRecord, findRecord, query, updateRecord } from '@ember-data/json-api/request';
 import { setBuildURLConfig } from '@ember-data/request-utils';
-import Store from '@ember-data/store';
+import Store, { recordIdentifierFor } from '@ember-data/store';
 
 import { headersToObject } from '../helpers/utils';
 
@@ -115,14 +115,13 @@ module('JSON:API | Request Builders', function (hooks) {
     assert.deepEqual(headersToObject(result.headers), JSON_API_HEADERS);
   });
 
-  test('createRecord with identifier', function (assert) {
+  test('createRecord with store.createRecord', function (assert) {
     const store = this.owner.lookup('service:store') as Store;
-    const record = { type: 'user-setting' };
-    const userSettingIdentifier = store.identifierCache.getOrCreateRecordIdentifier(record);
-
-    console.log({ userSettingIdentifier });
-    // TODO: This still fails: `is not a record instantiated by @ember-data/store`
-    const result = createRecord(userSettingIdentifier);
+    const userSetting = store.createRecord('user-setting', {
+      name: 'test',
+    });
+    const identifier = recordIdentifierFor(userSetting);
+    const result = createRecord(userSetting);
 
     assert.deepEqual(
       result,
@@ -132,83 +131,120 @@ module('JSON:API | Request Builders', function (hooks) {
         headers: new Headers(JSON_API_HEADERS),
         op: 'createRecord',
         data: {
-          record,
+          record: identifier,
         },
       },
       `createRecord works with record identifier passed`
     );
-    assert.deepEqual(headersToObject(result.headers), JSON_API_HEADERS);
+    assert.deepEqual(headersToObject(result.headers), JSON_API_HEADERS, "headers are set to JSON API's");
   });
 
-  // Do we need this?
-  skip('createRecord with store record object', function (assert) {});
-
-  skip('updateRecord with identifier', function (assert) {
+  test('updateRecord with identifier', function (assert) {
     const store = this.owner.lookup('service:store') as Store;
-    const record = { type: 'user-setting' };
-    const userSettingIdentifier = store.identifierCache.getOrCreateRecordIdentifier(record);
 
-    const result = updateRecord(userSettingIdentifier);
+    const expectedData = {
+      data: {
+        id: '12',
+        type: 'user-setting',
+        attributes: {
+          name: 'test',
+        },
+      },
+    };
+    store.push(expectedData);
+
+    const userSetting = store.peekRecord('user-setting', '12');
+    const identifier = recordIdentifierFor(userSetting);
+
+    userSetting.name = 'test2';
+
+    const result = updateRecord(userSetting);
 
     assert.deepEqual(
       result,
       {
-        url: 'https://api.example.com/api/v1/user-settings',
+        url: 'https://api.example.com/api/v1/user-settings/12',
         method: 'PUT',
         headers: new Headers(JSON_API_HEADERS),
         op: 'updateRecord',
         data: {
-          record,
+          record: identifier,
         },
       },
       `updateRecord works with record identifier passed`
     );
-    assert.deepEqual(headersToObject(result.headers), JSON_API_HEADERS);
+    assert.deepEqual(headersToObject(result.headers), JSON_API_HEADERS, "headers are set to JSON API's");
   });
 
-  skip('updateRecord with PATCH method', function (assert) {
+  test('updateRecord with PATCH method', function (assert) {
     const store = this.owner.lookup('service:store') as Store;
-    const record = { type: 'user-setting' };
-    const userSettingIdentifier = store.identifierCache.getOrCreateRecordIdentifier(record);
 
-    const result = updateRecord(userSettingIdentifier, { patch: true });
+    const expectedData = {
+      data: {
+        id: '12',
+        type: 'user-setting',
+        attributes: {
+          name: 'test',
+        },
+      },
+    };
+    store.push(expectedData);
+
+    const userSetting = store.peekRecord('user-setting', '12');
+    const identifier = recordIdentifierFor(userSetting);
+
+    userSetting.name = 'test2';
+
+    const result = updateRecord(userSetting, { patch: true });
 
     assert.deepEqual(
       result,
       {
-        url: 'https://api.example.com/api/v1/user-settings',
+        url: 'https://api.example.com/api/v1/user-settings/12',
         method: 'PATCH',
         headers: new Headers(JSON_API_HEADERS),
         op: 'updateRecord',
         data: {
-          record,
+          record: identifier,
         },
       },
       `updateRecord works with patch option`
     );
-    assert.deepEqual(headersToObject(result.headers), JSON_API_HEADERS);
+    assert.deepEqual(headersToObject(result.headers), JSON_API_HEADERS, "headers are set to JSON API's");
   });
 
-  skip('deleteRecord with identifier', function (assert) {
+  test('deleteRecord with identifier', function (assert) {
     const store = this.owner.lookup('service:store') as Store;
-    const record = { type: 'user-setting' };
-    const userSettingIdentifier = store.identifierCache.getOrCreateRecordIdentifier(record);
 
-    const result = deleteRecord(userSettingIdentifier);
+    const expectedData = {
+      data: {
+        id: '12',
+        type: 'user-setting',
+        attributes: {
+          name: 'test',
+        },
+      },
+    };
+    store.push(expectedData);
+
+    const userSetting = store.peekRecord('user-setting', '12');
+    const identifier = recordIdentifierFor(userSetting);
+
+    const result = deleteRecord(userSetting);
 
     assert.deepEqual(
       result,
       {
-        url: 'https://api.example.com/api/v1/user-settings',
+        url: 'https://api.example.com/api/v1/user-settings/12',
         method: 'DELETE',
         headers: new Headers(JSON_API_HEADERS),
         op: 'deleteRecord',
         data: {
-          record,
+          record: identifier,
         },
       },
       `deleteRecord works with patch option`
     );
-    assert.deepEqual(headersToObject(result.headers), JSON_API_HEADERS);
+    assert.deepEqual(headersToObject(result.headers), JSON_API_HEADERS, "headers are set to JSON API's");
   });
 });