Icu 15477 refactor credentials update test selectors (#2866)

* Refactor credential-store/credentials update test selectors

ui/admin/tests/acceptance/accounts/create-test.js

@@ -81,7 +81,10 @@ module('Acceptance | accounts | create', function (hooks) {
       commonSelectors.FIELD_DESCRIPTION_VALUE,
     );
     await fillIn(selectors.FIELD_LOGIN_NAME, selectors.FIELD_LOGIN_NAME_VALUE);
-    await fillIn(selectors.FIELD_PASSWORD, selectors.FIELD_PASSWORD_VALUE);
+    await fillIn(
+      commonSelectors.FIELD_PASSWORD,
+      commonSelectors.FIELD_PASSWORD_VALUE,
+    );
     await click(commonSelectors.SAVE_BTN);
 
     assert.strictEqual(

ui/admin/tests/acceptance/accounts/selectors.js

@@ -20,6 +20,3 @@ export const FIELD_NEW_PASSWORD_VALUE = 'new password';
 
 export const FIELD_LOGIN_NAME = '[name=login_name]';
 export const FIELD_LOGIN_NAME_VALUE = 'username';
-
-export const FIELD_PASSWORD = '[name=password]';
-export const FIELD_PASSWORD_VALUE = 'password';

ui/admin/tests/acceptance/accounts/set-password-test.js

@@ -10,7 +10,6 @@ import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
 import a11yAudit from 'ember-a11y-testing/test-support/audit';
 import { Response } from 'miragejs';
 import { authenticateSession } from 'ember-simple-auth/test-support';
-import * as selectors from './selectors';
 import * as commonSelectors from 'admin/tests/helpers/selectors';
 
 module('Acceptance | accounts | set password', function (hooks) {
@@ -95,7 +94,7 @@ module('Acceptance | accounts | set password', function (hooks) {
 
     await visit(urls.setPassword);
 
-    await fillIn(selectors.FIELD_PASSWORD, 'update password');
+    await fillIn(commonSelectors.FIELD_PASSWORD, 'update password');
     await click(commonSelectors.SAVE_BTN);
     await a11yAudit();
   });
@@ -103,7 +102,10 @@ module('Acceptance | accounts | set password', function (hooks) {
   test('can cancel setting new password by navigating away', async function (assert) {
     await visit(urls.setPassword);
 
-    await fillIn(selectors.FIELD_PASSWORD, selectors.FIELD_PASSWORD_VALUE);
+    await fillIn(
+      commonSelectors.FIELD_PASSWORD,
+      commonSelectors.FIELD_PASSWORD_VALUE,
+    );
     await click(commonSelectors.HREF(urls.account));
 
     assert.strictEqual(currentURL(), urls.account);
@@ -123,7 +125,10 @@ module('Acceptance | accounts | set password', function (hooks) {
     });
 
     await visit(urls.setPassword);
-    await fillIn(selectors.FIELD_PASSWORD, selectors.FIELD_PASSWORD_VALUE);
+    await fillIn(
+      commonSelectors.FIELD_PASSWORD,
+      commonSelectors.FIELD_PASSWORD_VALUE,
+    );
     await click(commonSelectors.SAVE_BTN);
 
     assert.dom(commonSelectors.ALERT_TOAST).isVisible();

ui/admin/tests/acceptance/credential-store/credentials/selectors.js

@@ -6,11 +6,16 @@
 export const FIELD_TYPE_SSH = '[value=ssh_private_key]';
 export const FIELD_TYPE_USERNAME_PASSWORD = '[value=username_password]';
 export const FIELD_TYPE_JSON = '[value=json]';
-export const EDITOR = '[data-test-code-editor-field-editor]';
 export const FIELD_EDITOR = '[data-test-code-editor-field-editor] textarea';
 export const FIELD_EDITOR_VALUE = '{"test": "value"}';
-export const MANAGE_DROPDOWN_NEW_CREDENTIAL =
-  '[data-test-manage-credential-stores-dropdown] a';
 export const FIELD_PASSWORD_ERROR = '[data-test-error-message-password]';
+export const FIELD_SSH_PRIVATE_KEY = '[name=private_key]';
 export const FIELD_SSH_PRIVATE_KEY_ERROR =
   '[data-test-error-message-private-key]';
+export const FIELD_SSH_PRIVATE_KEY_PASSPHRASE = '[name=private_key_passphrase]';
+
+export const EDITOR = '[data-test-code-editor-field-editor]';
+export const MANAGE_DROPDOWN_NEW_CREDENTIAL =
+  '[data-test-manage-credential-stores-dropdown] a';
+
+export const REPLACE_SECRET_BTN = '.secret-editor button';

ui/admin/tests/acceptance/credential-store/credentials/update-test.js

@@ -16,6 +16,7 @@ import { setupApplicationTest } from 'admin/tests/helpers';
 import setupMirage from 'ember-cli-mirage/test-support/setup-mirage';
 import { Response } from 'miragejs';
 import { authenticateSession } from 'ember-simple-auth/test-support';
+import * as selectors from './selectors';
 import * as commonSelectors from 'admin/tests/helpers/selectors';
 
 module(
@@ -48,6 +49,28 @@ module(
       jsonCredential: null,
     };
 
+    const mockResponseMessage = 'Error in provided request.';
+    const mockResponseDescription = 'Name is required.';
+    const mockResponse = () => {
+      return new Response(
+        400,
+        {},
+        {
+          status: 400,
+          code: 'invalid_argument',
+          message: mockResponseMessage,
+          details: {
+            request_fields: [
+              {
+                name: 'name',
+                description: mockResponseDescription,
+              },
+            ],
+          },
+        },
+      );
+    };
+
     hooks.beforeEach(async function () {
       // Generate resources
       instances.scopes.global = this.server.create('scope', { id: 'global' });
@@ -92,47 +115,68 @@ module(
     });
 
     test('can save changes to existing username & password credential', async function (assert) {
-      const mockInput = 'random string';
-      assert.notEqual(instances.usernamePasswordCredential.name, mockInput);
+      assert.notEqual(
+        instances.usernamePasswordCredential.name,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
       await visit(urls.usernamePasswordCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      await fillIn('[name="name"]', mockInput);
-      await click('.rose-form-actions [type="submit"]');
+
+      await click(commonSelectors.EDIT_BTN);
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
+      await click(commonSelectors.SAVE_BTN);
+
       assert.strictEqual(currentURL(), urls.usernamePasswordCredential);
       assert.strictEqual(
         this.server.schema.credentials.where({ type: 'username_password' })
           .models[0].name,
-        mockInput,
+        commonSelectors.FIELD_NAME_VALUE,
       );
     });
 
     test('can save changes to existing username & key pair credential', async function (assert) {
-      const mockInput = 'random string';
-      assert.notEqual(instances.usernameKeyPairCredential.name, mockInput);
+      assert.notEqual(
+        instances.usernameKeyPairCredential.name,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
       await visit(urls.usernameKeyPairCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      await fillIn('[name="name"]', mockInput);
-      await click('.rose-form-actions [type="submit"]');
+
+      await click(commonSelectors.EDIT_BTN, 'Activate edit mode');
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
+      await click(commonSelectors.SAVE_BTN);
+
       assert.strictEqual(currentURL(), urls.usernameKeyPairCredential);
       assert.strictEqual(
         this.server.schema.credentials.where({ type: 'ssh_private_key' })
           .models[0].name,
-        mockInput,
+        commonSelectors.FIELD_NAME_VALUE,
       );
     });
 
     test('can save changes to existing JSON credential', async function (assert) {
       featuresService.enable('json-credentials');
-      const mockInput = 'random string';
-      assert.notEqual(instances.jsonCredential.name, mockInput);
+      assert.notEqual(
+        instances.jsonCredential.name,
+        commonSelectors.FIELD_NAME,
+      );
       await visit(urls.jsonCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      await fillIn('[name="name"]', mockInput);
-      await click('.rose-form-actions [type="submit"]');
+
+      await click(commonSelectors.EDIT_BTN, 'Activate edit mode');
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
+      await click(commonSelectors.SAVE_BTN);
+
       assert.strictEqual(currentURL(), urls.jsonCredential);
       assert.strictEqual(
         this.server.schema.credentials.where({ type: 'json' }).models[0].name,
-        mockInput,
+        commonSelectors.FIELD_NAME_VALUE,
       );
     });
 
@@ -141,10 +185,10 @@ module(
         instances.usernamePasswordCredential.authorized_actions.filter(
           (item) => item !== 'update',
         );
+
       await visit(urls.usernamePasswordCredential);
-      assert
-        .dom('.hds-page-header__actions .hds-button-secondary')
-        .doesNotExist();
+
+      assert.dom(commonSelectors.EDIT_BTN).doesNotExist();
     });
 
     test('cannot make changes to an existing username & key pair credential without proper authorization', async function (assert) {
@@ -153,9 +197,8 @@ module(
           (item) => item !== 'update',
         );
       await visit(urls.usernameKeyPairCredential);
-      assert
-        .dom('.hds-page-header__actions .hds-button-secondary')
-        .doesNotExist();
+
+      assert.dom(commonSelectors.EDIT_BTN).doesNotExist();
     });
 
     test('cannot make changes to an existing JSON credential without proper authorization', async function (assert) {
@@ -164,241 +207,245 @@ module(
           (item) => item !== 'update',
         );
       await visit(urls.jsonCredential);
-      assert
-        .dom('.hds-page-header__actions .hds-button-secondary')
-        .doesNotExist();
+
+      assert.dom(commonSelectors.EDIT_BTN).doesNotExist();
     });
 
     test('can cancel changes to existing username & password credential', async function (assert) {
-      const mockInput = 'random string';
       await visit(urls.usernamePasswordCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      await fillIn('[name="name"]', mockInput);
-      await click('.rose-form-actions [type="button"]');
-      assert.notEqual(instances.usernamePasswordCredential.name, mockInput);
-      assert.strictEqual(
-        find('[name="name"]').value,
-        instances.usernamePasswordCredential.name,
+      await click(commonSelectors.EDIT_BTN, 'Activate edit mode');
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
       );
+      await click(commonSelectors.CANCEL_BTN);
+
+      assert.notEqual(
+        instances.usernamePasswordCredential.name,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
+      assert
+        .dom(commonSelectors.FIELD_NAME)
+        .hasValue(instances.usernamePasswordCredential.name);
     });
 
     test('can cancel changes to existing username & key pair credential', async function (assert) {
-      const mockInput = 'random string';
       await visit(urls.usernameKeyPairCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      await fillIn('[name="name"]', mockInput);
-      await click('.rose-form-actions [type="button"]');
-      assert.notEqual(instances.usernameKeyPairCredential.name, mockInput);
-      assert.strictEqual(
-        find('[name="name"]').value,
-        instances.usernameKeyPairCredential.name,
+
+      await click(commonSelectors.EDIT_BTN, 'Activate edit mode');
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
       );
+      await click(commonSelectors.CANCEL_BTN);
+
+      assert.notEqual(
+        instances.usernameKeyPairCredential.name,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
+      assert
+        .dom(commonSelectors.FIELD_NAME)
+        .hasValue(instances.usernameKeyPairCredential.name);
     });
 
     test('can cancel changes to existing JSON credential', async function (assert) {
-      const mockInput = 'random string';
       await visit(urls.jsonCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      await fillIn('[name="name"]', mockInput);
-      await click('.rose-form-actions [type="button"]');
-      assert.notEqual(instances.jsonCredential.name, mockInput);
-      assert.strictEqual(
-        find('[name="name"]').value,
-        instances.jsonCredential.name,
+
+      await click(commonSelectors.EDIT_BTN, 'Activate edit mode');
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
       );
+      await click(commonSelectors.CANCEL_BTN);
+
+      assert.notEqual(
+        instances.jsonCredential.name,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
+      assert
+        .dom(commonSelectors.FIELD_NAME)
+        .hasValue(instances.jsonCredential.name);
     });
 
     test('saving an existing username & password credential with invalid fields displays error message', async function (assert) {
-      const mockInput = 'random string';
-      this.server.patch('/credentials/:id', () => {
-        return new Response(
-          400,
-          {},
-          {
-            status: 400,
-            code: 'invalid_argument',
-            message: 'Error in provided request.',
-            details: {
-              request_fields: [
-                {
-                  name: 'name',
-                  description: 'Name is required.',
-                },
-              ],
-            },
-          },
-        );
-      });
+      this.server.patch('/credentials/:id', mockResponse);
       await visit(urls.usernamePasswordCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      await fillIn('[name="name"]', mockInput);
-      await click('[type="submit"]');
-      assert
-        .dom(commonSelectors.ALERT_TOAST_BODY)
-        .hasText('Error in provided request.');
-      assert.ok(
-        find('[data-test-error-message-name]').textContent.trim(),
-        'Name is required.',
+
+      await click(commonSelectors.EDIT_BTN, 'Activate edit mode');
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
       );
+      await click(commonSelectors.SAVE_BTN);
+
+      assert.dom(commonSelectors.ALERT_TOAST_BODY).hasText(mockResponseMessage);
+      assert
+        .dom(commonSelectors.FIELD_NAME_ERROR)
+        .hasText(mockResponseDescription);
     });
 
     test('saving an existing username & key pair credential with invalid fields displays error message', async function (assert) {
-      const mockInput = 'random string';
-      this.server.patch('/credentials/:id', () => {
-        return new Response(
-          400,
-          {},
-          {
-            status: 400,
-            code: 'invalid_argument',
-            message: 'Error in provided request.',
-            details: {
-              request_fields: [
-                {
-                  name: 'name',
-                  description: 'Name is required.',
-                },
-              ],
-            },
-          },
-        );
-      });
+      this.server.patch('/credentials/:id', mockResponse);
       await visit(urls.usernameKeyPairCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      await fillIn('[name="name"]', mockInput);
-      await click('[type="submit"]');
-      assert
-        .dom(commonSelectors.ALERT_TOAST_BODY)
-        .hasText('Error in provided request.');
-      assert.ok(
-        find('[data-test-error-message-name]').textContent.trim(),
-        'Name is required.',
+
+      await click(commonSelectors.EDIT_BTN, 'Activate edit mode');
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
       );
+      await click(commonSelectors.SAVE_BTN);
+
+      assert.dom(commonSelectors.ALERT_TOAST_BODY).hasText(mockResponseMessage);
+      assert
+        .dom(commonSelectors.FIELD_NAME_ERROR)
+        .hasText(mockResponseDescription);
     });
 
     test('saving an existing JSON credential with invalid fields displays error message', async function (assert) {
-      const mockInput = 'random string';
-      this.server.patch('/credentials/:id', () => {
-        return new Response(
-          400,
-          {},
-          {
-            status: 400,
-            code: 'invalid_argument',
-            message: 'Error in provided request.',
-            details: {
-              request_fields: [
-                {
-                  name: 'name',
-                  description: 'Name is required.',
-                },
-              ],
-            },
-          },
-        );
-      });
+      this.server.patch('/credentials/:id', mockResponse);
       await visit(urls.jsonCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      await fillIn('[name="name"]', mockInput);
-      await click('[type="submit"]');
-      assert
-        .dom(commonSelectors.ALERT_TOAST_BODY)
-        .hasText('Error in provided request.');
-      assert.ok(
-        find('[data-test-error-message-name]').textContent.trim(),
-        'Name is required.',
+
+      await click(commonSelectors.EDIT_BTN, 'Activate edit mode');
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
       );
+      await click(commonSelectors.SAVE_BTN);
+
+      assert.dom(commonSelectors.ALERT_TOAST_BODY).hasText(mockResponseMessage);
+      assert
+        .dom(commonSelectors.FIELD_NAME_ERROR)
+        .hasText(mockResponseDescription);
     });
 
     test('can discard unsaved username & password credential changes via dialog', async function (assert) {
       assert.expect(5);
-      const mockInput = 'random string';
       const confirmService = this.owner.lookup('service:confirm');
       confirmService.enabled = true;
-      assert.notEqual(instances.usernamePasswordCredential.name, mockInput);
+      assert.notEqual(
+        instances.usernamePasswordCredential.name,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
       await visit(urls.usernamePasswordCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      await fillIn('[name="name"]', mockInput);
+
+      await click(commonSelectors.EDIT_BTN, 'Activate edit mode');
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
       assert.strictEqual(currentURL(), urls.usernamePasswordCredential);
       try {
         await visit(urls.credentials);
       } catch (e) {
         assert.dom(commonSelectors.MODAL_WARNING).isVisible();
+
         await click(commonSelectors.MODAL_WARNING_CONFIRM_BTN, 'Click Discard');
+
         assert.strictEqual(currentURL(), urls.credentials);
         assert.notEqual(
           this.server.schema.credentials.where({ type: 'username_password' })
             .models[0].name,
-          mockInput,
+          commonSelectors.FIELD_NAME_VALUE,
         );
       }
     });
 
     test('can discard unsaved username & key pair credential changes via dialog', async function (assert) {
       assert.expect(5);
-      const mockInput = 'random string';
       const confirmService = this.owner.lookup('service:confirm');
       confirmService.enabled = true;
-      assert.notEqual(instances.usernameKeyPairCredential.name, mockInput);
+      assert.notEqual(
+        instances.usernameKeyPairCredential.name,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
       await visit(urls.usernameKeyPairCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      await fillIn('[name="name"]', mockInput);
+
+      await click(commonSelectors.EDIT_BTN);
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
+
       assert.strictEqual(currentURL(), urls.usernameKeyPairCredential);
+
       try {
         await visit(urls.credentials);
       } catch (e) {
         assert.dom(commonSelectors.MODAL_WARNING).isVisible();
+
         await click(commonSelectors.MODAL_WARNING_CONFIRM_BTN, 'Click Discard');
+
         assert.strictEqual(currentURL(), urls.credentials);
         assert.notEqual(
           this.server.schema.credentials.where({ type: 'ssh_private_key' })
             .models[0].name,
-          mockInput,
+          commonSelectors.FIELD_NAME_VALUE,
         );
       }
     });
 
     test('can discard unsaved JSON credential changes via dialog', async function (assert) {
       assert.expect(5);
-      const mockInput = 'random string';
       const confirmService = this.owner.lookup('service:confirm');
       confirmService.enabled = true;
-      assert.notEqual(instances.jsonCredential.name, mockInput);
+      assert.notEqual(
+        instances.jsonCredential.name,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
       await visit(urls.jsonCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      await fillIn('[name="name"]', mockInput);
+
+      await click(commonSelectors.EDIT_BTN);
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
       assert.strictEqual(currentURL(), urls.jsonCredential);
+
       try {
         await visit(urls.credentials);
       } catch (e) {
         assert.dom(commonSelectors.MODAL_WARNING).isVisible();
+
         await click(commonSelectors.MODAL_WARNING_CONFIRM_BTN, 'Click Discard');
+
         assert.strictEqual(currentURL(), urls.credentials);
         assert.notEqual(
           this.server.schema.credentials.where({ type: 'json' }).models[0].name,
-          mockInput,
+          commonSelectors.FIELD_NAME_VALUE,
         );
       }
     });
 
     test('can cancel discard unsaved username & password credential changes via dialog', async function (assert) {
       assert.expect(6);
-      const mockInput = 'random string';
       const confirmService = this.owner.lookup('service:confirm');
       confirmService.enabled = true;
-      assert.notEqual(instances.usernamePasswordCredential.name, mockInput);
+      assert.notEqual(
+        instances.usernamePasswordCredential.name,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
       await visit(urls.usernamePasswordCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      const credentialName = find('[name="name"]').value;
-      await fillIn('[name="name"]', mockInput);
+
+      await click(commonSelectors.EDIT_BTN);
+      const credentialName = find(commonSelectors.FIELD_NAME).value;
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
+
       assert.strictEqual(currentURL(), urls.usernamePasswordCredential);
+
       try {
         await visit(urls.credentials);
       } catch (e) {
         assert.dom(commonSelectors.MODAL_WARNING).isVisible();
+
         await click(commonSelectors.MODAL_WARNING_CANCEL_BTN, 'Click Cancel');
+
         assert.strictEqual(currentURL(), urls.usernamePasswordCredential);
-        assert.strictEqual(find('[name="name"]').value, mockInput);
+        assert
+          .dom(commonSelectors.FIELD_NAME)
+          .hasValue(commonSelectors.FIELD_NAME_VALUE);
         assert.strictEqual(
           this.server.schema.credentials.where({ type: 'username_password' })
             .models[0].name,
@@ -409,22 +456,34 @@ module(
 
     test('can cancel discard unsaved username & key pair credential changes via dialog', async function (assert) {
       assert.expect(6);
-      const mockInput = 'random string';
       const confirmService = this.owner.lookup('service:confirm');
       confirmService.enabled = true;
-      assert.notEqual(instances.usernameKeyPairCredential.name, mockInput);
+      assert.notEqual(
+        instances.usernameKeyPairCredential.name,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
       await visit(urls.usernameKeyPairCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      const credentialName = find('[name="name"]').value;
-      await fillIn('[name="name"]', mockInput);
+
+      await click(commonSelectors.EDIT_BTN);
+      const credentialName = find(commonSelectors.FIELD_NAME).value;
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
+
       assert.strictEqual(currentURL(), urls.usernameKeyPairCredential);
+
       try {
         await visit(urls.credentials);
       } catch (e) {
         assert.dom(commonSelectors.MODAL_WARNING).isVisible();
+
         await click(commonSelectors.MODAL_WARNING_CANCEL_BTN, 'Click Cancel');
+
         assert.strictEqual(currentURL(), urls.usernameKeyPairCredential);
-        assert.strictEqual(find('[name="name"]').value, mockInput);
+        assert
+          .dom(commonSelectors.FIELD_NAME)
+          .hasValue(commonSelectors.FIELD_NAME_VALUE);
         assert.strictEqual(
           this.server.schema.credentials.where({ type: 'ssh_private_key' })
             .models[0].name,
@@ -435,14 +494,20 @@ module(
 
     test('can cancel discard unsaved JSON credential changes via dialog', async function (assert) {
       assert.expect(6);
-      const mockInput = 'random string';
       const confirmService = this.owner.lookup('service:confirm');
       confirmService.enabled = true;
-      assert.notEqual(instances.jsonCredential.name, mockInput);
+      assert.notEqual(
+        instances.jsonCredential.name,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
       await visit(urls.jsonCredential);
-      await click('form [type="button"]', 'Activate edit mode');
-      const credentialName = find('[name="name"]').value;
-      await fillIn('[name="name"]', mockInput);
+
+      await click(commonSelectors.EDIT_BTN);
+      const credentialName = find(commonSelectors.FIELD_NAME).value;
+      await fillIn(
+        commonSelectors.FIELD_NAME,
+        commonSelectors.FIELD_NAME_VALUE,
+      );
       assert.strictEqual(currentURL(), urls.jsonCredential);
       try {
         await visit(urls.credentials);
@@ -450,7 +515,9 @@ module(
         assert.dom(commonSelectors.MODAL_WARNING).isVisible();
         await click(commonSelectors.MODAL_WARNING_CANCEL_BTN, 'Click Cancel');
         assert.strictEqual(currentURL(), urls.jsonCredential);
-        assert.strictEqual(find('[name="name"]').value, mockInput);
+        assert
+          .dom(commonSelectors.FIELD_NAME)
+          .hasValue(commonSelectors.FIELD_NAME_VALUE);
         assert.strictEqual(
           this.server.schema.credentials.where({ type: 'json' }).models[0].name,
           credentialName,
@@ -460,40 +527,50 @@ module(
 
     test('password field renders in edit mode only for a username & password credential', async function (assert) {
       await visit(urls.usernamePasswordCredential);
-      assert.dom('[name="password"]').doesNotExist();
-      await click('form [type="button"]', 'Activate edit mode');
+
+      assert.dom(commonSelectors.FIELD_PASSWORD).doesNotExist();
+
+      await click(commonSelectors.EDIT_BTN);
+
       assert.strictEqual(currentURL(), urls.usernamePasswordCredential);
-      assert.dom('[name="password"]').isVisible();
+      assert.dom(commonSelectors.FIELD_PASSWORD).isVisible();
     });
 
     test('private_key and private_key_passphrase fields render in edit mode only for a username & key pair credential', async function (assert) {
       await visit(urls.usernameKeyPairCredential);
-      assert.dom('[name="private_key"]').doesNotExist();
-      assert.dom('[name="private_key_passphrase"]').doesNotExist();
-      await click('form [type="button"]', 'Activate edit mode');
+
+      assert.dom(selectors.FIELD_SSH_PRIVATE_KEY).doesNotExist();
+      assert.dom(selectors.FIELD_SSH_PRIVATE_KEY_PASSPHRASE).doesNotExist();
+
+      await click(commonSelectors.EDIT_BTN);
+
       assert.strictEqual(currentURL(), urls.usernameKeyPairCredential);
-      assert.dom('[name="private_key"]').isVisible();
-      assert.dom('[name="private_key_passphrase"]').isVisible();
+      assert.dom(selectors.FIELD_SSH_PRIVATE_KEY).isVisible();
+      assert.dom(selectors.FIELD_SSH_PRIVATE_KEY_PASSPHRASE).isVisible();
     });
 
     test('secret editor is in actionable state when entering edit mode of a JSON credential', async function (assert) {
       await visit(urls.jsonCredential);
-      assert.dom('.secret-editor-skeleton-message button').doesNotExist();
-      await click('form [type="button"]', 'Activate edit mode');
+
+      assert.dom(selectors.REPLACE_SECRET_BTN).doesNotExist();
+
+      await click(commonSelectors.EDIT_BTN);
+
       assert.strictEqual(currentURL(), urls.jsonCredential);
-      assert.dom('.secret-editor-skeleton-message button').isVisible();
+      assert.dom(selectors.REPLACE_SECRET_BTN).isVisible();
     });
 
     test('secret editor enters editing state when clicking edit button in the secret editor of a JSON credential', async function (assert) {
       await visit(urls.jsonCredential);
-      await click('form [type="button"]', 'Activate edit mode');
+
+      await click(commonSelectors.EDIT_BTN);
+
       assert.strictEqual(currentURL(), urls.jsonCredential);
-      assert.dom('.secret-editor-skeleton-message button').isVisible();
-      await click(
-        '.secret-editor-skeleton-message button',
-        'Enter editing mode',
-      );
-      assert.dom('.secret-editor-skeleton-message button').doesNotExist();
+      assert.dom(selectors.REPLACE_SECRET_BTN).isVisible();
+
+      await click(selectors.REPLACE_SECRET_BTN);
+
+      assert.dom(selectors.REPLACE_SECRET_BTN).doesNotExist();
       await waitUntil(() => assert.dom('.CodeMirror').isVisible());
     });
   },

ui/admin/tests/acceptance/targets/host-sources-test.js

@@ -146,9 +146,7 @@ module('Acceptance | targets | host-sources', function (hooks) {
 
     await click(`[href="${urls.targetHostSources}"]`);
 
-    assert
-      .dom(`tbody tr ${commonSelectors.DELETE_BTN}`)
-      .doesNotExist();
+    assert.dom(`tbody tr ${commonSelectors.DELETE_BTN}`).doesNotExist();
   });
 
   test('removing a target host set which errors displays error messages', async function (assert) {

ui/admin/tests/acceptance/targets/injected-application-credential-sources-test.js

@@ -366,9 +366,7 @@ module(
           (item) => item !== 'remove-credential-sources',
         );
       await visit(urls.injectedApplicationCredentialSources);
-      assert
-        .dom(`tbody tr ${commonSelectors.DELETE_BTN}`)
-        .doesNotExist();
+      assert.dom(`tbody tr ${commonSelectors.DELETE_BTN}`).doesNotExist();
     });
 
     test('removing a target credential library which errors displays error messages', async function (assert) {