Merge branch 'main' into filterable-store-api-addon

addons/api/tests/dummy/config/targets.js

@@ -6,13 +6,6 @@ const browsers = [
   'last 1 Safari versions',
 ];
 
-const isCI = Boolean(process.env.CI);
-const isProduction = process.env.EMBER_ENV === 'production';
-
-if (isCI || isProduction) {
-  browsers.push('ie 11');
-}
-
 module.exports = {
   browsers,
 };

addons/api/tests/unit/adapters/application-test.js

@@ -1,6 +1,5 @@
 import { module, test } from 'qunit';
 import { setupTest } from 'ember-qunit';
-import config from 'ember-get-config';
 import RESTAdapter from '@ember-data/adapter/rest';
 import { InvalidError } from '@ember-data/adapter/error';
 import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
@@ -10,6 +9,12 @@ module('Unit | Adapter | application', function (hooks) {
   setupTest(hooks);
   setupMirage(hooks);
 
+  let config;
+
+  hooks.beforeEach(function () {
+    config = this.owner.resolveRegistration('config:environment');
+  });
+
   test('its namespace is equal to the configured namespace', function (assert) {
     assert.expect(2);
     const adapter = this.owner.lookup('adapter:application');

addons/api/tests/unit/models/fragment-managed-group-attributes-test.js

@@ -0,0 +1,13 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Model | fragment managed group attributes', function (hooks) {
+  setupTest(hooks);
+
+  // Replace this with your real tests.
+  test('it exists', function (assert) {
+    let store = this.owner.lookup('service:store');
+    let model = store.createRecord('fragment-managed-group-attributes', {});
+    assert.ok(model);
+  });
+});

addons/api/tests/unit/models/managed-group-test.js

@@ -0,0 +1,12 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Model | managed group', function (hooks) {
+  setupTest(hooks);
+
+  test('it exists', function (assert) {
+    let store = this.owner.lookup('service:store');
+    let model = store.createRecord('managed-group', {});
+    assert.ok(model);
+  });
+});

addons/api/tests/unit/serializers/fragment-managed-group-attributes-test.js

@@ -0,0 +1,21 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module(
+  'Unit | Serializer | fragment managed groups attributes',
+  function (hooks) {
+    setupTest(hooks);
+
+    test('it serializes empty string to null', function (assert) {
+      assert.expect(1);
+      const store = this.owner.lookup('service:store');
+      const record = store.createRecord('fragment-managed-group-attributes', {
+        filter: '',
+      });
+      const serializedRecord = record.serialize();
+      assert.deepEqual(serializedRecord, {
+        filter: null,
+      });
+    });
+  }
+);

addons/api/tests/unit/serializers/managed-group-test.js

@@ -0,0 +1,161 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module('Unit | Serializer | Managed group', function (hooks) {
+  setupTest(hooks);
+
+  test('it serializes correctly on create with no filter provided', function (assert) {
+    assert.expect(1);
+    const store = this.owner.lookup('service:store');
+    const serializer = store.serializerFor('managed-group');
+    const record = store.createRecord('managed-group', {
+      name: 'Group',
+      description: 'Description',
+      member_ids: ['1', '2'],
+      version: 1,
+      auth_method_id: '1234',
+    });
+    const snapshot = record._createSnapshot();
+    snapshot.adapterOptions = {};
+    const serializedRecord = serializer.serialize(snapshot);
+    assert.deepEqual(serializedRecord, {
+      name: 'Group',
+      description: 'Description',
+      version: 1,
+      auth_method_id: '1234',
+      type: null,
+      attributes: {
+        filter: null,
+      },
+    });
+  });
+
+  test('it serializes correctly on create when filter provided', function (assert) {
+    assert.expect(1);
+    const store = this.owner.lookup('service:store');
+    const serializer = store.serializerFor('managed-group');
+    const record = store.createRecord('managed-group', {
+      name: 'Group',
+      description: 'Description',
+      member_ids: ['1', '2'],
+      version: 1,
+      auth_method_id: '1234',
+      type: 'oidc',
+      attributes: {
+        filter: 'key=value',
+      },
+    });
+    const snapshot = record._createSnapshot();
+    snapshot.adapterOptions = {};
+    const serializedRecord = serializer.serialize(snapshot);
+    assert.deepEqual(serializedRecord, {
+      name: 'Group',
+      description: 'Description',
+      version: 1,
+      auth_method_id: '1234',
+      type: 'oidc',
+      attributes: {
+        filter: 'key=value',
+      },
+    });
+  });
+
+  test('it does not serialize version when it has null or undefined value', function (assert) {
+    assert.expect(1);
+    const store = this.owner.lookup('service:store');
+    const serializer = store.serializerFor('managed-group');
+    store.push({
+      data: {
+        id: '1',
+        type: 'managed-group',
+        attributes: {
+          name: 'Group Test',
+          description: 'Description for the test',
+          member_ids: ['1', '2'],
+          version: undefined,
+          auth_method_id: '1234',
+          type: 'oidc',
+          attributes: {
+            filter: 'key=value',
+          },
+        },
+      },
+    });
+    const record = store.peekRecord('managed-group', '1');
+    const snapshot = record._createSnapshot();
+    const serializedRecord = serializer.serialize(snapshot);
+    assert.deepEqual(serializedRecord, {
+      name: 'Group Test',
+      description: 'Description for the test',
+      auth_method_id: '1234',
+      type: 'oidc',
+      attributes: {
+        filter: 'key=value',
+      },
+    });
+  });
+
+  test('it does not serialize readOnly attributes', function (assert) {
+    assert.expect(1);
+    const store = this.owner.lookup('service:store');
+    const serializer = store.serializerFor('managed-group');
+    const record = store.createRecord('managed-group', {
+      name: 'Group',
+      description: 'Description',
+      version: 1,
+      auth_method_id: '1234',
+      member_ids: ['1', '2'],
+      created_time: Date.now(),
+      updated_time: Date.now(),
+    });
+    const snapshot = record._createSnapshot();
+    snapshot.adapterOptions = {};
+    const serializedRecord = serializer.serialize(snapshot);
+    assert.deepEqual(serializedRecord, {
+      name: 'Group',
+      description: 'Description',
+      version: 1,
+      auth_method_id: '1234',
+      type: null,
+      attributes: {
+        filter: null,
+      },
+    });
+  });
+
+  test('it serializes correctly on update', function (assert) {
+    assert.expect(1);
+    const store = this.owner.lookup('service:store');
+    const serializer = store.serializerFor('managed-group');
+    store.push({
+      data: {
+        id: '1',
+        type: 'managed-group',
+        attributes: {
+          name: 'Group Test',
+          description: 'Description for the test',
+          member_ids: ['1', '2'],
+          version: 1,
+          auth_method_id: '1234',
+          type: 'oidc',
+          attributes: {
+            filter: 'key=value',
+          },
+        },
+      },
+    });
+    const record = store.peekRecord('managed-group', '1');
+    const snapshot = record._createSnapshot();
+    const serializedRecord = serializer.serialize(snapshot);
+    assert.deepEqual(serializedRecord, {
+      name: 'Group Test',
+      description: 'Description for the test',
+      version: 1,
+      auth_method_id: '1234',
+      type: 'oidc',
+      attributes: {
+        filter: 'key=value',
+      },
+    });
+  });
+});