From 0357efee2a3b0b81ac6261952aa4d5f5839fd972 Mon Sep 17 00:00:00 2001 From: Stan Ryzhov <60649800+stasryzhov@users.noreply.github.com> Date: Fri, 6 Oct 2023 11:10:25 -0400 Subject: [PATCH] =?UTF-8?q?test:=20=F0=9F=92=8D=20Add=20delete=20resources?= =?UTF-8?q?=20e2e=20UI=20test=20(#1931)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ✅ Closes: ICU-10897 --- ui/admin/tests/e2e/README.md | 10 + ui/admin/tests/e2e/helpers/boundary-cli.js | 451 +++++++++++++++++- ui/admin/tests/e2e/helpers/boundary-ui.js | 30 ++ ui/admin/tests/e2e/tests/auth-method.spec.js | 4 +- .../tests/e2e/tests/delete-resources.spec.js | 210 ++++++++ ui/admin/tests/e2e/tests/group-role.spec.js | 4 +- ui/admin/tests/e2e/tests/target.spec.js | 8 +- 7 files changed, 708 insertions(+), 9 deletions(-) create mode 100644 ui/admin/tests/e2e/tests/delete-resources.spec.js diff --git a/ui/admin/tests/e2e/README.md b/ui/admin/tests/e2e/README.md index ed97477e2..d08814b36 100644 --- a/ui/admin/tests/e2e/README.md +++ b/ui/admin/tests/e2e/README.md @@ -136,6 +136,16 @@ PWDEBUG=console yarn playwright test --headed --config ./tests/e2e/playwright.co PWDEBUG=console yarn playwright test --headed --config ./tests/e2e/playwright.config.js login.spec.js --debug ``` +To run the tests with a specific tag (e.g. @enterprise), use this command. +```bash +PWDEBUG=console yarn playwright test --grep @enterprise --headed --config ./tests/e2e/playwright.config.js delete-resources.spec.js +``` + +To run all tests except those with a specific tag (e.g. @enterprise), use this command. +```bash +PWDEBUG=console yarn playwright test --grep-invert @enterprise --headed --config ./tests/e2e/playwright.config.js delete-resources.spec.js +``` + [Playwright documentation about running tests](https://playwright.dev/docs/running-tests). ### Destroy Enos Scenario diff --git a/ui/admin/tests/e2e/helpers/boundary-cli.js b/ui/admin/tests/e2e/helpers/boundary-cli.js index 5e81ed8c7..9af672b99 100644 --- a/ui/admin/tests/e2e/helpers/boundary-cli.js +++ b/ui/admin/tests/e2e/helpers/boundary-cli.js @@ -5,6 +5,7 @@ /* eslint-disable no-undef */ const { execSync, exec } = require('child_process'); +const { nanoid } = require('nanoid'); /** * Checks that the boundary cli is available @@ -66,11 +67,33 @@ exports.connectToTarget = async (targetId) => { return connect; }; +/** + * Uses the boundary CLI to create a new org. + * @returns {string} new org's id + */ +exports.createNewOrgCli = async () => { + const orgName = 'Org ' + nanoid(); + let newOrg; + try { + newOrg = JSON.parse( + execSync( + `boundary scopes create \ + -name="${orgName}" \ + -scope-id=global \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return newOrg.id; +}; + /** * Uses the boundary CLI to delete the specified organization * @param {string} orgId ID of the organization to be deleted */ -exports.deleteOrg = async (orgId) => { +exports.deleteOrgCli = async (orgId) => { try { exec('boundary scopes delete -id=' + orgId); } catch (e) { @@ -78,6 +101,432 @@ exports.deleteOrg = async (orgId) => { } }; +/** + * Uses the boundary CLI to create a new project. + * @param {string} orgId ID of the organization under which the project will be created. + * @returns {string} new project's ID + */ +exports.createNewProjectCli = async (orgId) => { + const projectName = 'Project ' + nanoid(); + let newProject; + try { + newProject = JSON.parse( + execSync( + `boundary scopes create \ + -name="${projectName}" \ + -scope-id=${orgId} \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return newProject.id; +}; + +/** + * Uses the boundary CLI to create a new controller-led worker. + * @returns {string} new worker's ID + */ +exports.createNewControllerLedWorkerCli = async () => { + const workerName = 'worker-' + nanoid(); + let newWorker; + try { + newWorker = JSON.parse( + execSync( + `boundary workers create controller-led \ + -name="${workerName.toLowerCase()}" \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return newWorker.id; +}; + +/** + * Uses the boundary CLI to create a new password auth-method. + * @param {string} scopeId ID of the scope under which the auth-method will be created. + * @returns {string} new auth-method's ID + */ +exports.createNewPasswordAuthMethodCli = async (scopeId) => { + const authMethodName = 'auth-method-' + nanoid(); + let newAuthMethod; + try { + newAuthMethod = JSON.parse( + execSync( + `boundary auth-methods create password \ + -name "${authMethodName}" \ + -scope-id ${scopeId} \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return newAuthMethod.id; +}; + +/** + * Uses the boundary CLI to make an auth-method primary. + * @param {string} scopeId ID of the scope that the auth-method belongs to. + * @param {string} authMethodId ID of the auth method that will be made primary. + */ +exports.makeAuthMethodPrimaryCli = async (scopeId, authMethodId) => { + try { + execSync( + `boundary scopes update \ + -id=${scopeId} \ + -primary-auth-method-id ${authMethodId} \ + -format json` + ); + } catch (e) { + console.log(`${e.stderr}`); + } +}; + +/** + * Uses the boundary CLI to create a new password account. + * @param {string} authMethodId ID of the auth-method that the new account will be created for. + * @returns {string} new account's ID + */ +exports.createNewPasswordAccountCli = async (authMethodId) => { + let passwordAccount; + const login = 'test-login'; + process.env.ACCOUNT_PASSWORD = 'test-password'; + try { + passwordAccount = JSON.parse( + execSync( + `boundary accounts create password \ + -auth-method-id ${authMethodId} \ + -login-name ${login} \ + -password env://ACCOUNT_PASSWORD \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return passwordAccount.id; +}; + +/** + * Uses the boundary CLI to create a new role. + * @param {string} scopeId ID of the scope under which the role will be created. + * @returns {string} new role's ID + */ +exports.createNewRoleCli = async (scopeId) => { + const roleName = 'role-' + nanoid(); + let role; + try { + role = JSON.parse( + execSync( + `boundary roles create \ + -scope-id ${scopeId} \ + -name ${roleName} \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return role.id; +}; + +/** + * Uses the boundary CLI to create a new group. + * @param {string} scopeId ID of the scope under which the group will be created. + * @returns {string} new group's ID + */ +exports.createNewGroupCli = async (scopeId) => { + const groupName = 'group-' + nanoid(); + let group; + try { + group = JSON.parse( + execSync( + `boundary groups create \ + -scope-id ${scopeId} \ + -name ${groupName} \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return group.id; +}; + +/** + * Uses the boundary CLI to create a new user. + * @param {string} scopeId ID of the scope under which the user will be created. + * @returns {string} new user's ID + */ +exports.createNewUserCli = async (scopeId) => { + const userName = 'user-' + nanoid(); + let user; + try { + user = JSON.parse( + execSync( + `boundary users create \ + -scope-id ${scopeId} \ + -name ${userName} \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return user.id; +}; + +/** + * Uses the boundary CLI to create a new static host catalog. + * @param {string} projectId ID of the project under which the host catalog will be created. + * @returns {string} new host catalog's ID + */ +exports.createNewStaticHostCatalogCli = async (projectId) => { + const hostCatalogName = 'static-host-catalog-' + nanoid(); + let hostCatalog; + try { + hostCatalog = JSON.parse( + execSync( + `boundary host-catalogs create static \ + -scope-id ${projectId} \ + -name ${hostCatalogName} \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return hostCatalog.id; +}; + +/** + * Uses the boundary CLI to create a new dynamic AWS host catalog. + * @param {string} projectId ID of the project under which the host catalog will be created. + * @returns {string} new host catalog's ID + */ +exports.createDynamicAwsHostCatalogCli = async (projectId) => { + const hostCatalogName = 'dynamic-aws-host-catalog-' + nanoid(); + let hostCatalog; + try { + hostCatalog = JSON.parse( + execSync( + `boundary host-catalogs create plugin \ + -name ${hostCatalogName} \ + -scope-id ${projectId} \ + -plugin-name aws \ + -attr disable_credential_rotation=true \ + -attr region=us-east-1 \ + -secret access_key_id=env://E2E_AWS_ACCESS_KEY_ID \ + -secret secret_access_key=env://E2E_AWS_SECRET_ACCESS_KEY \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return hostCatalog.id; +}; + +/** + * Uses the boundary CLI to create a new static host. + * @param {string} hostCatalogId ID of the host catalog that the host will be created for. + * @returns {string} new host's ID + */ +exports.createNewStaticHostCli = async (hostCatalogId) => { + const hostName = 'static-host-' + nanoid(); + let host; + try { + host = JSON.parse( + execSync( + `boundary hosts create static \ + -host-catalog-id ${hostCatalogId} \ + -name ${hostName} \ + -address localhost \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return host.id; +}; + +/** + * Uses the boundary CLI to create a new static host set. + * @param {string} hostCatalogId ID of the host catalog that the host set will be created for. + * @returns {string} new host set's ID + */ +exports.createNewHostSetCli = async (hostCatalogId) => { + const hostSetName = 'static-host-' + nanoid(); + let hostSet; + try { + hostSet = JSON.parse( + execSync( + `boundary host-sets create static \ + -host-catalog-id ${hostCatalogId} \ + -name ${hostSetName} \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return hostSet.id; +}; + +/** + * Uses the boundary CLI to create a new static credential store. + * @param {string} projectId ID of the project under which the credential store will be created. + * @returns {string} new credential store's ID + */ +exports.createNewStaticCredentialStoreCli = async (projectId) => { + const credentialStoreName = 'static-credential-store-' + nanoid(); + let staticCredentialStore; + try { + staticCredentialStore = JSON.parse( + execSync( + `boundary credential-stores create static \ + -scope-id ${projectId} \ + -name ${credentialStoreName} \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return staticCredentialStore.id; +}; + +/** + * Uses the boundary CLI to create a new vault credential store. + * @param {string} projectId ID of the project under which the credential store will be created. + * @param {string} secretPolicyName Name of the secret policy that's used to create vault token. + * @param {string} boundaryPolicyName Name of the boundary policy that's used to create vault token. + * @returns {string} new credential store's ID + */ +exports.createNewVaultCredentialStoreCli = async ( + projectId, + secretPolicyName, + boundaryPolicyName +) => { + let credentialStore; + try { + execSync( + `vault policy write ${boundaryPolicyName} ./tests/e2e/tests/fixtures/boundary-controller-policy.hcl` + ); + execSync( + `vault policy write ${secretPolicyName} ./tests/e2e/tests/fixtures/kv-policy.hcl` + ); + const vaultToken = JSON.parse( + execSync( + `vault token create \ + -no-default-policy=true \ + -policy=${boundaryPolicyName} \ + -policy=${secretPolicyName} \ + -orphan=true \ + -period=20m \ + -renewable=true \ + -format=json` + ) + ); + const clientToken = vaultToken.auth.client_token; + const credentialStoreName = 'vault-credential-store-' + nanoid(); + credentialStore = JSON.parse( + execSync( + `boundary credential-stores create vault \ + -scope-id ${projectId} \ + -name ${credentialStoreName} \ + -vault-address ${process.env.E2E_VAULT_ADDR} \ + -vault-token ${clientToken} \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return credentialStore.id; +}; + +/** + * Uses the boundary CLI to create a new username-password credential. + * @param {string} credentialStoreId ID of the credential store that the credential will be created for. + * @returns {string} new credential's ID + */ +exports.createNewUsernamePasswordCredentialCli = async (credentialStoreId) => { + let usernamePasswordCredential; + const login = 'test-login'; + process.env.CREDENTIALS_PASSWORD = 'credentials-password'; + try { + usernamePasswordCredential = JSON.parse( + execSync( + `boundary credentials create username-password \ + -name ${login} \ + -credential-store-id ${credentialStoreId} \ + -username ${login} \ + -password env://CREDENTIALS_PASSWORD \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return usernamePasswordCredential.id; +}; + +/** + * Uses the boundary CLI to create a new TCP target. + * @param {string} projectId ID of the project under which the target will be created. + * @returns {string} new target's ID + */ +exports.createNewTcpTarget = async (projectId) => { + const targetName = 'target-' + nanoid(); + const defaultPort = 22; + let target; + try { + target = JSON.parse( + execSync( + `boundary targets create tcp \ + -default-port ${defaultPort} \ + -name ${targetName} \ + -scope-id ${projectId} \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return target.id; +}; + +/** + * Uses the boundary CLI to create a new SSH target. + * @param {string} projectId ID of the project under which the target will be created. + * @returns {string} new target's ID + */ +exports.createNewSshTarget = async (projectId) => { + const targetName = 'target-' + nanoid(); + const defaultPort = 22; + let target; + try { + target = JSON.parse( + execSync( + `boundary targets create ssh \ + -default-port ${defaultPort} \ + -name ${targetName} \ + -scope-id ${projectId} \ + -format json` + ) + ).item; + } catch (e) { + console.log(`${e.stderr}`); + } + return target.id; +}; + /** * Uses the boundary CLI to get a session created for the specified target * @param {string} orgName Name of the organization with the specified project diff --git a/ui/admin/tests/e2e/helpers/boundary-ui.js b/ui/admin/tests/e2e/helpers/boundary-ui.js index 0ec7b54f0..8fcc57e36 100644 --- a/ui/admin/tests/e2e/helpers/boundary-ui.js +++ b/ui/admin/tests/e2e/helpers/boundary-ui.js @@ -197,6 +197,36 @@ exports.createNewTargetWithAddress = async (page) => { return targetName; }; +/** + * Uses the UI to delete a Boundary resource. Assume you have selected the desired resource. + * Note: For a resource to be deleted using this method, + * the resource page should allow to delete the resource using the Manage button. + * @param {Page} page Playwright page object + */ +exports.deleteResource = async (page) => { + await page.getByTitle('Manage').click(); + await page.getByRole('button', { name: /^(Delete|Remove Worker)/ }).click(); + await page.getByText('OK', { exact: true }).click(); + await expect( + page.getByRole('alert').getByText('Success', { exact: true }) + ).toBeVisible(); + await page.getByRole('button', { name: 'Dismiss' }).click(); +}; + +/** + * Uses the UI to remove auth method as primary. Assume you have selected the desired auth method. + * @param {Page} page Playwright page object + */ +exports.removeAuthMethodAsPrimary = async (page) => { + await page.getByTitle('Manage').click(); + await page.getByRole('button', { name: 'Remove as primary' }).click(); + await page.getByText('OK', { exact: true }).click(); + await expect( + page.getByRole('alert').getByText('Success', { exact: true }) + ).toBeVisible(); + await page.getByRole('button', { name: 'Dismiss' }).click(); +}; + /** * Uses the UI to add a host source to a target. Assume you have selected the desired target. * @param {Page} page Playwright page object diff --git a/ui/admin/tests/e2e/tests/auth-method.spec.js b/ui/admin/tests/e2e/tests/auth-method.spec.js index 3a4c7d2e9..315dafc71 100644 --- a/ui/admin/tests/e2e/tests/auth-method.spec.js +++ b/ui/admin/tests/e2e/tests/auth-method.spec.js @@ -10,7 +10,7 @@ const { authenticatedState } = require('../helpers/general'); const { authenticateBoundaryCli, checkBoundaryCli, - deleteOrg, + deleteOrgCli, } = require('../helpers/boundary-cli'); const { createNewOrg, @@ -50,6 +50,6 @@ test('Verify new auth-method can be created and assigned to users', async ({ await createNewUser(page, 'UI Test User'); await addAccountToUser(page); } finally { - await deleteOrg(org.id); + await deleteOrgCli(org.id); } }); diff --git a/ui/admin/tests/e2e/tests/delete-resources.spec.js b/ui/admin/tests/e2e/tests/delete-resources.spec.js new file mode 100644 index 000000000..c59e6328f --- /dev/null +++ b/ui/admin/tests/e2e/tests/delete-resources.spec.js @@ -0,0 +1,210 @@ +/** + * Copyright (c) HashiCorp, Inc. + * SPDX-License-Identifier: MPL-2.0 + */ + +/* eslint-disable no-undef */ +const { test } = require('@playwright/test'); + +const { authenticatedState, checkEnv } = require('../helpers/general'); +const { + authenticateBoundaryCli, + checkBoundaryCli, + createNewOrgCli, + createNewProjectCli, + createNewControllerLedWorkerCli, + createNewPasswordAuthMethodCli, + makeAuthMethodPrimaryCli, + createNewPasswordAccountCli, + createNewRoleCli, + createNewGroupCli, + createNewUserCli, + createNewStaticHostCatalogCli, + createDynamicAwsHostCatalogCli, + createNewStaticHostCli, + createNewHostSetCli, + createNewStaticCredentialStoreCli, + createNewTcpTarget, + createNewSshTarget, + createNewVaultCredentialStoreCli, + createNewUsernamePasswordCredentialCli, + deleteOrgCli, +} = require('../helpers/boundary-cli'); + +const { + deleteResource, + removeAuthMethodAsPrimary, +} = require('../helpers/boundary-ui'); +const { checkVaultCli } = require('../helpers/vault-cli'); +const { execSync } = require('child_process'); + +const secretPolicyName = 'kv-policy'; +const boundaryPolicyName = 'boundary-controller'; + +test.use({ storageState: authenticatedState }); + +test.beforeAll(async () => { + await checkEnv([ + 'VAULT_ADDR', + 'VAULT_TOKEN', + 'E2E_VAULT_ADDR', + 'E2E_TARGET_ADDRESS', + 'E2E_SSH_USER', + 'E2E_SSH_KEY_PATH', + 'E2E_AWS_ACCESS_KEY_ID', + 'E2E_AWS_SECRET_ACCESS_KEY', + ]); + await checkBoundaryCli(); + await checkVaultCli(); +}); + +test.beforeEach(async () => { + execSync(`vault policy delete ${secretPolicyName}`); + execSync(`vault policy delete ${boundaryPolicyName}`); + await authenticateBoundaryCli(); +}); + +test('Verify resources can be deleted', async ({ page }) => { + let orgId; + try { + // Create boundary resources using CLI + orgId = await createNewOrgCli(); + let projectId = await createNewProjectCli(orgId); + let workerId = await createNewControllerLedWorkerCli(); + let authMethodId = await createNewPasswordAuthMethodCli(orgId); + await makeAuthMethodPrimaryCli(orgId, authMethodId); + let passwordAccountId = await createNewPasswordAccountCli(authMethodId); + let projectScopeRoleId = await createNewRoleCli(projectId); + let orgScopeRoleId = await createNewRoleCli(orgId); + let globalScopeRoleId = await createNewRoleCli('global'); + let groupId = await createNewGroupCli(orgId); + let userId = await createNewUserCli(orgId); + let staticHostCatalogId = await createNewStaticHostCatalogCli(projectId); + let dynamicAwsHostCatalogId = await createDynamicAwsHostCatalogCli( + projectId + ); + let staticHostId = await createNewStaticHostCli(staticHostCatalogId); + let staticHostSetId = await createNewHostSetCli(staticHostCatalogId); + let staticCredentialStoreId = await createNewStaticCredentialStoreCli( + projectId + ); + let vaultCredentialStoreId = await createNewVaultCredentialStoreCli( + projectId, + secretPolicyName, + boundaryPolicyName + ); + let usernamePasswordCredentialId = + await createNewUsernamePasswordCredentialCli(staticCredentialStoreId); + let tcpTargetId = await createNewTcpTarget(projectId); + + // Delete TCP target + await page.goto(`/scopes/${projectId}/targets/${tcpTargetId}`); + await deleteResource(page); + + // Delete username-password credentials + await page.goto( + `/scopes/${projectId}/credential-stores/${staticCredentialStoreId}/credentials/${usernamePasswordCredentialId}` + ); + await deleteResource(page); + + // Delete static credential store + await page.goto( + `/scopes/${projectId}/credential-stores/${staticCredentialStoreId}` + ); + await deleteResource(page); + + // Delete vault credential store + await page.goto( + `/scopes/${projectId}/credential-stores/${vaultCredentialStoreId}` + ); + await deleteResource(page); + + // Delete static host set + await page.goto( + `/scopes/${projectId}/host-catalogs/${staticHostCatalogId}/host-sets/${staticHostSetId}` + ); + await deleteResource(page); + + // Delete static host + await page.goto( + `/scopes/${projectId}/host-catalogs/${staticHostCatalogId}/hosts/${staticHostId}` + ); + await deleteResource(page); + + // Delete static host catalog + await page.goto( + `/scopes/${projectId}/host-catalogs/${staticHostCatalogId}` + ); + await deleteResource(page); + + // Delete dynamic aws host catalog + await page.goto( + `/scopes/${projectId}/host-catalogs/${dynamicAwsHostCatalogId}` + ); + await deleteResource(page); + + // Delete user + await page.goto(`/scopes/${projectId}/users/${userId}`); + await deleteResource(page); + + // Delete group + await page.goto(`/scopes/${projectId}/groups/${groupId}`); + await deleteResource(page); + + // Delete role under global scope + await page.goto(`/scopes/global/roles/${globalScopeRoleId}`); + await deleteResource(page); + + // Delete role under org scope + await page.goto(`/scopes/${projectId}/roles/${orgScopeRoleId}`); + await deleteResource(page); + + // Delete role under project scope + await page.goto(`/scopes/${projectId}/roles/${projectScopeRoleId}`); + await deleteResource(page); + + // Delete password account + await page.goto( + `/scopes/${orgId}/auth-methods/${authMethodId}/accounts/${passwordAccountId}` + ); + await deleteResource(page); + + // Delete auth method + await page.goto(`/scopes/${orgId}/auth-methods/${authMethodId}`); + await removeAuthMethodAsPrimary(page); + await deleteResource(page); + + // Delete worker + await page.goto(`/scopes/global/workers/${workerId}`); + await deleteResource(page); + + // Delete project + await page.goto(`/scopes/${projectId}`); + await deleteResource(page); + + // Delete org + await page.goto(`/scopes/${orgId}/edit`); + await deleteResource(page); + } finally { + // Delete org in case the test failed before deleting the org using UI + await deleteOrgCli(orgId); + } +}); + +test('Verify enterprise resources can be deleted @enterprise', async ({ page }) => { + let orgId; + try { + orgId = await createNewOrgCli(); + let projectId = await createNewProjectCli(orgId); + + // Create enterprise boundary resources using CLI + let sshTargetId = await createNewSshTarget(projectId); + + // Delete SSH target + await page.goto(`/scopes/${projectId}/targets/${sshTargetId}`); + await deleteResource(page); + } finally { + await deleteOrgCli(orgId); + } +}); + diff --git a/ui/admin/tests/e2e/tests/group-role.spec.js b/ui/admin/tests/e2e/tests/group-role.spec.js index fe3188ece..5da92938f 100644 --- a/ui/admin/tests/e2e/tests/group-role.spec.js +++ b/ui/admin/tests/e2e/tests/group-role.spec.js @@ -10,7 +10,7 @@ const { authenticatedState } = require('../helpers/general'); const { authenticateBoundaryCli, checkBoundaryCli, - deleteOrg, + deleteOrgCli, } = require('../helpers/boundary-cli'); const { createNewOrg, @@ -44,6 +44,6 @@ test('Verify a new role can be created and associated with a group', async ({ await addPrincipalToRole(page, groupName); await addGrantsToGroup(page, 'ids=*;type=*;actions=read,list'); } finally { - await deleteOrg(org.id); + await deleteOrgCli(org.id); } }); diff --git a/ui/admin/tests/e2e/tests/target.spec.js b/ui/admin/tests/e2e/tests/target.spec.js index 9e03db5a4..68b77d8ee 100644 --- a/ui/admin/tests/e2e/tests/target.spec.js +++ b/ui/admin/tests/e2e/tests/target.spec.js @@ -11,7 +11,7 @@ const { authenticateBoundaryCli, checkBoundaryCli, connectToTarget, - deleteOrg, + deleteOrgCli, } = require('../helpers/boundary-cli'); const { createNewOrg, @@ -73,7 +73,7 @@ test('Verify session created to target with host, then cancel the session', asyn .getByRole('button', { name: 'Cancel' }) .click(); } finally { - await deleteOrg(org.id); + await deleteOrgCli(org.id); // End `boundary connect` process if (connect) { connect.kill('SIGTERM'); @@ -112,7 +112,7 @@ test('Verify session created to target with address, then cancel the session', a .getByRole('button', { name: 'Cancel' }) .click(); } finally { - await deleteOrg(org.id); + await deleteOrgCli(org.id); // End `boundary connect` process if (connect) { connect.kill('SIGTERM'); @@ -150,6 +150,6 @@ test('Verify TCP target is updated', async ({ page }) => { await authenticateBoundaryCli(); const orgs = JSON.parse(execSync('boundary scopes list -format json')); const org = orgs.items.filter((obj) => obj.name === orgName)[0]; - await deleteOrg(org.id); + await deleteOrgCli(org.id); } });