refactor: 💡 remove route-action usage for auth-methods (#2178)

* refactor: 💡 remove route-action usage for auth-methods

✅ Closes: https://hashicorp.atlassian.net/browse/ICU-12603

ui/admin/tests/unit/controllers/scopes/scope/auth-methods/auth-method/accounts/account/index-test.js

@@ -4,7 +4,7 @@
  */
 
 import { module, test } from 'qunit';
-import { setupTest } from 'admin/tests/helpers';
+import { setupTest } from 'ember-qunit';
 
 module(
   'Unit | Controller | scopes/scope/auth-methods/auth-method/accounts/account/index',

ui/admin/tests/unit/controllers/scopes/scope/auth-methods/auth-method/accounts/account/set-password-test.js

@@ -4,7 +4,7 @@
  */
 
 import { module, test } from 'qunit';
-import { setupTest } from 'admin/tests/helpers';
+import { setupTest } from 'ember-qunit';
 
 module(
   'Unit | Controller | scopes/scope/auth-methods/auth-method/accounts/account/set-password',

ui/admin/tests/unit/controllers/scopes/scope/auth-methods/auth-method/accounts/index-test.js

@@ -4,7 +4,7 @@
  */
 
 import { module, test } from 'qunit';
-import { setupTest } from 'admin/tests/helpers';
+import { setupTest } from 'ember-qunit';
 
 module(
   'Unit | Controller | scopes/scope/auth-methods/auth-method/accounts/index',

ui/admin/tests/unit/controllers/scopes/scope/auth-methods/auth-method/accounts/new-test.js

@@ -4,7 +4,7 @@
  */
 
 import { module, test } from 'qunit';
-import { setupTest } from 'admin/tests/helpers';
+import { setupTest } from 'ember-qunit';
 
 module(
   'Unit | Controller | scopes/scope/auth-methods/auth-method/accounts/new',

ui/admin/tests/unit/controllers/scopes/scope/auth-methods/auth-method/index-test.js

@@ -0,0 +1,16 @@
+import { module, test } from 'qunit';
+import { setupTest } from 'ember-qunit';
+
+module(
+  'Unit | Controller | scopes/scope/auth-methods/auth-method/index',
+  function (hooks) {
+    setupTest(hooks);
+
+    test('it exists', function (assert) {
+      let controller = this.owner.lookup(
+        'controller:scopes/scope/auth-methods/auth-method/index',
+      );
+      assert.ok(controller);
+    });
+  },
+);

ui/admin/tests/unit/controllers/scopes/scope/auth-methods/index-test.js

@@ -6,6 +6,10 @@
 import { module, test } from 'qunit';
 import { setupTest } from 'ember-qunit';
 import { waitUntil } from '@ember/test-helpers';
+import { visit } from '@ember/test-helpers';
+import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
+import { setupIndexedDb } from 'api/test-support/helpers/indexed-db';
+import { authenticateSession } from 'ember-simple-auth/test-support';
 import {
   TYPE_AUTH_METHOD_PASSWORD,
   TYPE_AUTH_METHOD_OIDC,
@@ -14,18 +18,41 @@ import {
 
 module('Unit | Controller | scopes/scope/auth-methods/index', function (hooks) {
   setupTest(hooks);
+  setupMirage(hooks);
+  setupIndexedDb(hooks);
 
-  test('it exists', function (assert) {
-    let controller = this.owner.lookup(
+  let store;
+  let controller;
+  let getAuthMethodCount;
+
+  const instances = {
+    scope: {
+      global: null,
+    },
+    authMethod: null,
+  };
+
+  hooks.beforeEach(async function () {
+    authenticateSession({});
+    store = this.owner.lookup('service:store');
+    controller = this.owner.lookup(
       'controller:scopes/scope/auth-methods/index',
     );
+
+    instances.scope.global = this.server.create('scope', { id: 'global' });
+    instances.authMethod = this.server.create('auth-method', {
+      scopeId: 'global',
+    });
+
+    getAuthMethodCount = () =>
+      this.server.schema.authMethods.all().models.length;
+  });
+
+  test('controller exists', function (assert) {
     assert.ok(controller);
   });
 
   test('primaryOptions returns expected object', function (assert) {
-    let controller = this.owner.lookup(
-      'controller:scopes/scope/auth-methods/index',
-    );
     assert.deepEqual(controller.primaryOptions, [
       { id: 'true', name: 'Yes' },
       { id: 'false', name: 'No' },
@@ -33,9 +60,6 @@ module('Unit | Controller | scopes/scope/auth-methods/index', function (hooks) {
   });
 
   test('authMethodTypeOptions returns expected object', function (assert) {
-    let controller = this.owner.lookup(
-      'controller:scopes/scope/auth-methods/index',
-    );
     assert.deepEqual(controller.authMethodTypeOptions, [
       { id: TYPE_AUTH_METHOD_PASSWORD, name: 'Password' },
       { id: TYPE_AUTH_METHOD_OIDC, name: 'OIDC' },
@@ -44,17 +68,11 @@ module('Unit | Controller | scopes/scope/auth-methods/index', function (hooks) {
   });
 
   test('filters returns expected entries', function (assert) {
-    let controller = this.owner.lookup(
-      'controller:scopes/scope/auth-methods/index',
-    );
     assert.ok(controller.filters.allFilters);
     assert.ok(controller.filters.selectedFilters);
   });
 
   test('handleSearchInput action sets expected values correctly', async function (assert) {
-    let controller = this.owner.lookup(
-      'controller:scopes/scope/auth-methods/index',
-    );
     const searchValue = 'test';
     controller.handleSearchInput({ target: { value: searchValue } });
     await waitUntil(() => controller.search === searchValue);
@@ -64,13 +82,173 @@ module('Unit | Controller | scopes/scope/auth-methods/index', function (hooks) {
   });
 
   test('applyFilter action sets expected values correctly', async function (assert) {
-    let controller = this.owner.lookup(
-      'controller:scopes/scope/auth-methods/index',
-    );
     const selectedItems = ['true'];
     controller.applyFilter('primary', selectedItems);
 
     assert.strictEqual(controller.page, 1);
     assert.deepEqual(controller.primary, selectedItems);
   });
+
+  test('cancel action rolls-back changes on the specified model', async function (assert) {
+    await visit('/scopes/global/auth-methods');
+    const authMethodModelBefore = await store.findRecord(
+      'auth-method',
+      instances.authMethod.id,
+    );
+    authMethodModelBefore.name = 'test';
+
+    assert.strictEqual(authMethodModelBefore.name, 'test');
+
+    await controller.cancel(authMethodModelBefore);
+    const authMethodModelAfter = await store.findRecord(
+      'auth-method',
+      instances.authMethod.id,
+    );
+
+    assert.notEqual(authMethodModelAfter.name, 'test');
+    assert.strictEqual(authMethodModelAfter.name, authMethodModelBefore.name);
+  });
+
+  test('save action saves changes on the specified model', async function (assert) {
+    await visit('/scopes/global/auth-methods');
+    const authMethodModelBefore = await store.findRecord(
+      'auth-method',
+      instances.authMethod.id,
+    );
+    authMethodModelBefore.name = 'test';
+
+    await controller.save(authMethodModelBefore);
+    const authMethodModelAfter = await store.findRecord(
+      'auth-method',
+      instances.authMethod.id,
+    );
+
+    assert.strictEqual(authMethodModelAfter.name, 'test');
+  });
+
+  test('delete action destroys specified model', async function (assert) {
+    await visit('/scopes/global/scopes');
+    const authMethodModel = await store.findRecord(
+      'auth-method',
+      instances.authMethod.id,
+    );
+    const authMethodCount = getAuthMethodCount();
+
+    await controller.delete(authMethodModel);
+
+    assert.strictEqual(getAuthMethodCount(), authMethodCount - 1);
+  });
+
+  test('makePrimary action updates scope with auth-method id', async function (assert) {
+    await visit('/scopes/global/auth-methods');
+    const authMethodModel = await store.findRecord(
+      'auth-method',
+      instances.authMethod.id,
+    );
+
+    await controller.makePrimary(authMethodModel);
+    const scopeModel = await store.findRecord(
+      'scope',
+      instances.scope.global.id,
+    );
+
+    assert.strictEqual(
+      scopeModel.primary_auth_method_id,
+      instances.authMethod.id,
+    );
+  });
+
+  test('removeAsPrimary action updates scope with null as auth-method id', async function (assert) {
+    await visit('/scopes/global/auth-methods');
+    const authMethodModel = await store.findRecord(
+      'auth-method',
+      instances.authMethod.id,
+    );
+
+    await controller.removeAsPrimary(authMethodModel);
+    const scopeModel = await store.findRecord(
+      'scope',
+      instances.scope.global.id,
+    );
+
+    assert.notOk(scopeModel.primary_auth_method_id);
+  });
+
+  test('addStringItem action adds item to field and removeItemByIndex removes correct item', async function (assert) {
+    const authMethodModel = await store.findRecord(
+      'auth-method',
+      instances.authMethod.id,
+    );
+
+    controller.addStringItem(authMethodModel, 'certificates', 'cert_123');
+
+    assert.deepEqual(authMethodModel.certificates, [{ value: 'cert_123' }]);
+
+    controller.addStringItem(authMethodModel, 'certificates', 'cert_456');
+    controller.removeItemByIndex(authMethodModel, 'certificates', 0);
+
+    assert.deepEqual(authMethodModel.certificates, [{ value: 'cert_456' }]);
+  });
+
+  test('addAccountMapItem action adds item to field and removeItemByIndex removes correct item', async function (assert) {
+    const authMethodModel = await store.findRecord(
+      'auth-method',
+      instances.authMethod.id,
+    );
+
+    controller.addAccountMapItem(
+      authMethodModel,
+      'account_attribute_maps',
+      'name123',
+      'fullName',
+    );
+
+    assert.deepEqual(authMethodModel.account_attribute_maps, [
+      { from: 'name123', to: 'fullName' },
+    ]);
+
+    controller.addAccountMapItem(
+      authMethodModel,
+      'account_attribute_maps',
+      'name456',
+      'fullName',
+    );
+    controller.removeItemByIndex(authMethodModel, 'account_attribute_maps', 0);
+
+    assert.deepEqual(authMethodModel.account_attribute_maps, [
+      { from: 'name456', to: 'fullName' },
+    ]);
+  });
+
+  test('edit action updates to a dirty state', async function (assert) {
+    const authMethodModel = await store.findRecord(
+      'auth-method',
+      instances.authMethod.id,
+    );
+
+    assert.false(authMethodModel.hasDirtyAttributes);
+
+    controller.edit(authMethodModel);
+
+    assert.true(authMethodModel.hasDirtyAttributes);
+  });
+
+  test('changeState action updates state of auth-method', async function (assert) {
+    instances.authMethod.update({ type: TYPE_AUTH_METHOD_LDAP });
+    const authMethodModelBefore = await store.findRecord(
+      'auth-method',
+      instances.authMethod.id,
+    );
+
+    assert.notOk(authMethodModelBefore.state);
+
+    await controller.changeState(authMethodModelBefore, 'public');
+
+    const authMethodModelAfter = await store.findRecord(
+      'auth-method',
+      instances.authMethod.id,
+    );
+
+    assert.strictEqual(authMethodModelAfter.state, 'public');
+  });
 });

ui/admin/tests/unit/controllers/scopes/scope/auth-methods/new-test.js

@@ -4,7 +4,7 @@
  */
 
 import { module, test } from 'qunit';
-import { setupTest } from 'admin/tests/helpers';
+import { setupTest } from 'ember-qunit';
 
 module('Unit | Controller | scopes/scope/auth-methods/new', function (hooks) {
   setupTest(hooks);