refact(e2e): Use fixtures for environment variables (#2452)

ui/admin/tests/e2e/playwright.config.mjs

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { defineConfig, devices } from '@playwright/test';
+import { defineConfig, devices, test as baseTest } from '@playwright/test';
 
 /** @type {import('@playwright/test').PlaywrightTestConfig} */
 export default defineConfig({
@@ -35,3 +35,35 @@ export default defineConfig({
     },
   ],
 });
+
+export const test = baseTest.extend({
+  adminAuthMethodId: process.env.E2E_PASSWORD_AUTH_METHOD_ID,
+  adminLoginName: process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
+  adminPassword: process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+  awsAccessKeyId: process.env.E2E_AWS_ACCESS_KEY_ID,
+  awsBucketName: process.env.E2E_AWS_BUCKET_NAME,
+  awsHostSetFilter: process.env.E2E_AWS_HOST_SET_FILTER,
+  awsHostSetIps: process.env.E2E_AWS_HOST_SET_IPS,
+  awsRegion: process.env.E2E_AWS_REGION,
+  awsSecretAccessKey: process.env.E2E_AWS_SECRET_ACCESS_KEY,
+  bucketAccessKeyId: process.env.E2E_BUCKET_ACCESS_KEY_ID,
+  bucketEndpointUrl: process.env.E2E_BUCKET_ENDPOINT_URL,
+  bucketName: process.env.E2E_BUCKET_NAME,
+  bucketSecretAccessKey: process.env.E2E_BUCKET_SECRET_ACCESS_KEY,
+  ldapAddr: process.env.E2E_LDAP_ADDR,
+  ldapAdminDn: process.env.E2E_LDAP_ADMIN_DN,
+  ldapAdminPassword: process.env.E2E_LDAP_ADMIN_PASSWORD,
+  ldapDomainDn: process.env.E2E_LDAP_DOMAIN_DN,
+  ldapGroupName: process.env.E2E_LDAP_GROUP_NAME,
+  ldapUserName: process.env.E2E_LDAP_USER_NAME,
+  ldapUserPassword: process.env.E2E_LDAP_USER_PASSWORD,
+  region: process.env.E2E_REGION,
+  sshCaKey: process.env.E2E_SSH_CA_KEY,
+  sshCaKeyPublic: process.env.E2E_SSH_CA_KEY_PUBLIC,
+  sshKeyPath: process.env.E2E_SSH_KEY_PATH,
+  sshUser: process.env.E2E_SSH_USER,
+  targetAddress: process.env.E2E_TARGET_ADDRESS,
+  targetPort: process.env.E2E_TARGET_PORT,
+  vaultAddr: process.env.E2E_VAULT_ADDR,
+  workerTagEgress: process.env.E2E_WORKER_TAG_EGRESS,
+});

ui/admin/tests/e2e/tests/alias-ent.spec.mjs

@@ -3,11 +3,11 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 import { customAlphabet } from 'nanoid';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   authorizeSessionByAliasCli,
@@ -27,19 +27,20 @@ import { TargetsPage } from '../pages/targets.mjs';
 test.use({ storageState: authenticatedState });
 
 test.beforeAll(async () => {
-  await checkEnv([
-    'E2E_SSH_USER',
-    'E2E_SSH_KEY_PATH',
-    'E2E_TARGET_ADDRESS',
-    'E2E_TARGET_PORT',
-  ]);
-
   await checkBoundaryCli();
 });
 
 test.describe('Aliases (Enterprise)', async () => {
   test('Set up alias from target details page @ent @aws @docker', async ({
     page,
+    baseURL,
+    adminAuthMethodId,
+    adminLoginName,
+    adminPassword,
+    sshUser,
+    sshKeyPath,
+    targetAddress,
+    targetPort,
   }) => {
     await page.goto('/');
     let orgName;
@@ -52,21 +53,11 @@ test.describe('Aliases (Enterprise)', async () => {
       await projectsPage.createProject();
 
       const targetsPage = new TargetsPage(page);
-      const targetName = await targetsPage.createSshTargetWithAddressEnt(
-        process.env.E2E_TARGET_ADDRESS,
-        process.env.E2E_TARGET_PORT,
-      );
+      const targetName = await targetsPage.createSshTargetWithAddressEnt(targetAddress, targetPort);
       const credentialStoresPage = new CredentialStoresPage(page);
       await credentialStoresPage.createStaticCredentialStore();
-      const credentialName =
-        await credentialStoresPage.createStaticCredentialKeyPair(
-          process.env.E2E_SSH_USER,
-          process.env.E2E_SSH_KEY_PATH,
-        );
-      await targetsPage.addInjectedCredentialsToTarget(
-        targetName,
-        credentialName,
-      );
+      const credentialName = await credentialStoresPage.createStaticCredentialKeyPair(sshUser, sshKeyPath);
+      await targetsPage.addInjectedCredentialsToTarget(targetName, credentialName);
 
       // Create alias for target
       await page
@@ -87,10 +78,10 @@ test.describe('Aliases (Enterprise)', async () => {
 
       // Connect to target using alias
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       await authorizeSessionByAliasCli(alias);
 
@@ -105,10 +96,10 @@ test.describe('Aliases (Enterprise)', async () => {
       await page.getByRole('button', { name: 'Dismiss' }).click();
     } finally {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       if (orgName) {
         const orgId = await getOrgIdFromNameCli(orgName);
@@ -124,6 +115,14 @@ test.describe('Aliases (Enterprise)', async () => {
 
   test('Set up alias from new target page @ent @aws @docker', async ({
     page,
+    baseURL,
+    adminAuthMethodId,
+    adminLoginName,
+    adminPassword,
+    sshUser,
+    sshKeyPath,
+    targetAddress,
+    targetPort,
   }) => {
     await page.goto('/');
     let orgName;
@@ -133,40 +132,29 @@ test.describe('Aliases (Enterprise)', async () => {
       const orgsPage = new OrgsPage(page);
       orgName = await orgsPage.createOrg();
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       const projectsPage = new ProjectsPage(page);
       await projectsPage.createProject();
       alias = 'example.alias.' + nanoid();
       const targetsPage = new TargetsPage(page);
-      const targetName = await targetsPage.createTargetWithAddressAndAlias(
-        process.env.E2E_TARGET_ADDRESS,
-        process.env.E2E_TARGET_PORT,
-        alias,
-      );
+      const targetName = await targetsPage.createTargetWithAddressAndAlias(targetAddress, targetPort, alias);
       const credentialStoresPage = new CredentialStoresPage(page);
       await credentialStoresPage.createStaticCredentialStore();
-      const credentialName =
-        await credentialStoresPage.createStaticCredentialKeyPair(
-          process.env.E2E_SSH_USER,
-          process.env.E2E_SSH_KEY_PATH,
-        );
-      await targetsPage.addInjectedCredentialsToTarget(
-        targetName,
-        credentialName,
-      );
+      const credentialName = await credentialStoresPage.createStaticCredentialKeyPair(sshUser, sshKeyPath);
+      await targetsPage.addInjectedCredentialsToTarget(targetName, credentialName);
 
       // Connect to target using alias
       await authorizeSessionByAliasCli(alias);
     } finally {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
 
       if (orgName) {
@@ -181,7 +169,17 @@ test.describe('Aliases (Enterprise)', async () => {
     }
   });
 
-  test('Set up alias from aliases page @ent @aws @docker', async ({ page }) => {
+  test('Set up alias from aliases page @ent @aws @docker', async ({
+    page,
+    baseURL,
+    adminAuthMethodId,
+    adminLoginName,
+    adminPassword,
+    sshUser,
+    sshKeyPath,
+    targetAddress,
+    targetPort,
+  }) => {
     await page.goto('/');
     const nanoid = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 10);
     let orgId;
@@ -192,28 +190,18 @@ test.describe('Aliases (Enterprise)', async () => {
       const projectsPage = new ProjectsPage(page);
       const projectName = await projectsPage.createProject();
       const targetsPage = new TargetsPage(page);
-      const targetName = await targetsPage.createSshTargetWithAddressEnt(
-        process.env.E2E_TARGET_ADDRESS,
-        process.env.E2E_TARGET_PORT,
-      );
+      const targetName = await targetsPage.createSshTargetWithAddressEnt(targetAddress, targetPort);
       const credentialStoresPage = new CredentialStoresPage(page);
       await credentialStoresPage.createStaticCredentialStore();
-      const credentialName =
-        await credentialStoresPage.createStaticCredentialKeyPair(
-          process.env.E2E_SSH_USER,
-          process.env.E2E_SSH_KEY_PATH,
-        );
-      await targetsPage.addInjectedCredentialsToTarget(
-        targetName,
-        credentialName,
-      );
+      const credentialName = await credentialStoresPage.createStaticCredentialKeyPair(sshUser, sshKeyPath);
+      await targetsPage.addInjectedCredentialsToTarget(targetName, credentialName);
 
       // Create new alias from scope page
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       orgId = await getOrgIdFromNameCli(orgName);
       const projectId = await getProjectIdFromNameCli(orgId, projectName);
@@ -225,10 +213,10 @@ test.describe('Aliases (Enterprise)', async () => {
       await authorizeSessionByAliasCli(alias);
     } finally {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
 
       if (orgId) {

ui/admin/tests/e2e/tests/alias.spec.mjs

@@ -3,11 +3,11 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 import { customAlphabet } from 'nanoid';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   authorizeSessionByAliasCli,
@@ -26,19 +26,18 @@ import { TargetsPage } from '../pages/targets.mjs';
 test.use({ storageState: authenticatedState });
 
 test.beforeAll(async () => {
-  await checkEnv([
-    'E2E_SSH_USER',
-    'E2E_SSH_KEY_PATH',
-    'E2E_TARGET_ADDRESS',
-    'E2E_TARGET_PORT',
-  ]);
-
   await checkBoundaryCli();
 });
 
 test.describe('Aliases', async () => {
   test('Set up alias from target details page @ce @aws @docker', async ({
     page,
+    baseURL,
+    adminAuthMethodId,
+    adminLoginName,
+    adminPassword,
+    targetAddress,
+    targetPort,
   }) => {
     await page.goto('/');
     let orgName;
@@ -50,10 +49,7 @@ test.describe('Aliases', async () => {
       const projectsPage = new ProjectsPage(page);
       await projectsPage.createProject();
       const targetsPage = new TargetsPage(page);
-      await targetsPage.createTargetWithAddress(
-        process.env.E2E_TARGET_ADDRESS,
-        process.env.E2E_TARGET_PORT,
-      );
+      await targetsPage.createTargetWithAddress(targetAddress, targetPort);
 
       // Create alias for target
       const aliasName = 'Alias ' + nanoid();
@@ -70,10 +66,10 @@ test.describe('Aliases', async () => {
 
       // Connect to target using alias
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       await authorizeSessionByAliasCli(alias);
 
@@ -88,10 +84,10 @@ test.describe('Aliases', async () => {
       await page.getByRole('button', { name: 'Dismiss' }).click();
     } finally {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       if (orgName) {
         const orgId = await getOrgIdFromNameCli(orgName);
@@ -107,6 +103,12 @@ test.describe('Aliases', async () => {
 
   test('Set up alias from new target page @ce @aws @docker', async ({
     page,
+    baseURL,
+    adminAuthMethodId,
+    adminLoginName,
+    adminPassword,
+    targetAddress,
+    targetPort,
   }) => {
     await page.goto('/');
     let orgName;
@@ -116,29 +118,25 @@ test.describe('Aliases', async () => {
       const orgsPage = new OrgsPage(page);
       orgName = await orgsPage.createOrg();
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       const projectsPage = new ProjectsPage(page);
       await projectsPage.createProject();
       alias = 'example.alias.' + nanoid();
       const targetsPage = new TargetsPage(page);
-      await targetsPage.createTargetWithAddressAndAlias(
-        process.env.E2E_TARGET_ADDRESS,
-        process.env.E2E_TARGET_PORT,
-        alias,
-      );
+      await targetsPage.createTargetWithAddressAndAlias(targetAddress, targetPort, alias);
 
       // Connect to target using alias
       await authorizeSessionByAliasCli(alias);
     } finally {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       if (orgName) {
         const orgId = await getOrgIdFromNameCli(orgName);
@@ -152,7 +150,15 @@ test.describe('Aliases', async () => {
     }
   });
 
-  test('Set up alias from aliases page @ce @aws @docker', async ({ page }) => {
+  test('Set up alias from aliases page @ce @aws @docker', async ({
+    page,
+    baseURL,
+    adminAuthMethodId,
+    adminLoginName,
+    adminPassword,
+    targetAddress,
+    targetPort,
+  }) => {
     await page.goto('/');
     const nanoid = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 10);
     let orgId;
@@ -163,17 +169,14 @@ test.describe('Aliases', async () => {
       const projectsPage = new ProjectsPage(page);
       const projectName = await projectsPage.createProject();
       const targetsPage = new TargetsPage(page);
-      const targetName = await targetsPage.createTargetWithAddress(
-        process.env.E2E_TARGET_ADDRESS,
-        process.env.E2E_TARGET_PORT,
-      );
+      const targetName = await targetsPage.createTargetWithAddress(targetAddress, targetPort);
 
       // Create new alias from scope page
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       orgId = await getOrgIdFromNameCli(orgName);
       const projectId = await getProjectIdFromNameCli(orgId, projectName);
@@ -185,10 +188,10 @@ test.describe('Aliases', async () => {
       await authorizeSessionByAliasCli(alias);
     } finally {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       if (orgId) {
         await deleteScopeCli(orgId);

ui/admin/tests/e2e/tests/auth-method-ldap.spec.mjs

@@ -3,10 +3,10 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 import { nanoid } from 'nanoid';
 
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   checkBoundaryCli,
@@ -20,29 +20,29 @@ import { RolesPage } from '../pages/roles.mjs';
 import { UsersPage } from '../pages/users.mjs';
 
 test.beforeAll(async () => {
-  await checkEnv([
-    'E2E_LDAP_ADDR',
-    'E2E_LDAP_DOMAIN_DN',
-    'E2E_LDAP_ADMIN_DN',
-    'E2E_LDAP_ADMIN_PASSWORD',
-    'E2E_LDAP_USER_NAME',
-    'E2E_LDAP_USER_PASSWORD',
-    'E2E_LDAP_GROUP_NAME',
-  ]);
-
   await checkBoundaryCli();
 });
 
-test('Set up LDAP auth method @ce @ent @docker', async ({ page }) => {
+test('Set up LDAP auth method @ce @ent @docker', async ({
+  page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  ldapAddr,
+  ldapAdminDn,
+  ldapAdminPassword,
+  ldapDomainDn,
+  ldapGroupName,
+  ldapUserName,
+  ldapUserPassword,
+}) => {
   await page.goto('/');
   let orgName;
   try {
     // Log in
     const loginPage = new LoginPage(page);
-    await loginPage.login(
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
-    );
+    await loginPage.login(adminLoginName, adminPassword);
     await expect(
       page.getByRole('navigation', { name: 'breadcrumbs' }).getByText('Orgs'),
     ).toBeVisible();
@@ -60,15 +60,15 @@ test('Set up LDAP auth method @ce @ent @docker', async ({ page }) => {
     const ldapAuthMethodName = 'LDAP ' + nanoid();
     await page.getByLabel('Name').fill(ldapAuthMethodName);
     await page.getByLabel('Description').fill('LDAP Auth Method');
-    await page.getByLabel('Address').fill(process.env.E2E_LDAP_ADDR);
-    await page.getByLabel('Bind DN').fill(process.env.E2E_LDAP_ADMIN_DN);
+    await page.getByLabel('Address').fill(ldapAddr);
+    await page.getByLabel('Bind DN').fill(ldapAdminDn);
     await page
       .getByLabel('Bind Password')
-      .fill(process.env.E2E_LDAP_ADMIN_PASSWORD);
+      .fill(ldapAdminPassword);
     await page.getByRole('switch', { name: 'Discover DN' }).click();
-    await page.getByLabel('User DN').fill(process.env.E2E_LDAP_DOMAIN_DN);
+    await page.getByLabel('User DN').fill(ldapDomainDn);
     await page.getByLabel('User Attribute').fill('uid');
-    await page.getByLabel('Group DN').fill(process.env.E2E_LDAP_DOMAIN_DN);
+    await page.getByLabel('Group DN').fill(ldapDomainDn);
     await page.getByRole('switch', { name: 'Enable Groups' }).click();
 
     await page
@@ -128,7 +128,7 @@ test('Set up LDAP auth method @ce @ent @docker', async ({ page }) => {
       .getByLabel('Name (Optional)', { exact: true })
       .fill(ldapAccountName);
     await page.getByLabel('Description').fill('This is an automated test');
-    await page.getByLabel('Login Name').fill(process.env.E2E_LDAP_USER_NAME);
+    await page.getByLabel('Login Name').fill(ldapUserName);
     await page.getByRole('button', { name: 'Save' }).click();
     await expect(
       page.getByRole('alert').getByText('Success', { exact: true }),
@@ -147,7 +147,7 @@ test('Set up LDAP auth method @ce @ent @docker', async ({ page }) => {
     await page.getByLabel('Description').fill('This is an automated test');
     await page
       .getByRole('textbox', { name: 'Value' })
-      .fill(process.env.E2E_LDAP_GROUP_NAME);
+      .fill(ldapGroupName);
     await page.getByRole('button', { name: 'Add' }).click();
 
     await page.getByRole('button', { name: 'Save' }).click();
@@ -164,7 +164,7 @@ test('Set up LDAP auth method @ce @ent @docker', async ({ page }) => {
     // Create a user and attach LDAP account to it
     const usersPage = new UsersPage(page);
     const userName = await usersPage.createUser();
-    await usersPage.addAccountToUser(process.env.E2E_LDAP_USER_NAME);
+    await usersPage.addAccountToUser(ldapUserName);
 
     // Create a second auth method so that there's multiple auth methods on the
     // login screen
@@ -172,15 +172,12 @@ test('Set up LDAP auth method @ce @ent @docker', async ({ page }) => {
     await authMethodsPage.createPasswordAuthMethod();
 
     // Log in using ldap account
-    await loginPage.logout(process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME);
+    await loginPage.logout(adminLoginName);
 
     await page.getByText('Choose a different scope').click();
     await page.getByRole('link', { name: orgName }).click();
     await page.getByRole('link', { name: ldapAuthMethodName }).click();
-    await loginPage.login(
-      process.env.E2E_LDAP_USER_NAME,
-      process.env.E2E_LDAP_USER_PASSWORD,
-    );
+    await loginPage.login(ldapUserName, ldapUserPassword);
     await expect(
       page
         .getByRole('navigation', { name: 'breadcrumbs' })
@@ -188,11 +185,8 @@ test('Set up LDAP auth method @ce @ent @docker', async ({ page }) => {
     ).toBeVisible();
 
     // Log back in as an admin
-    await loginPage.logout(process.env.E2E_LDAP_USER_NAME);
-    await loginPage.login(
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
-    );
+    await loginPage.logout(ldapUserName);
+    await loginPage.login(adminLoginName, adminPassword);
     await expect(
       page.getByRole('navigation', { name: 'breadcrumbs' }).getByText('Orgs'),
     ).toBeVisible();
@@ -232,7 +226,7 @@ test('Set up LDAP auth method @ce @ent @docker', async ({ page }) => {
         .getByRole('cell')
         .nth(fullNameIndex)
         .innerText(),
-    ).toBe(process.env.E2E_LDAP_USER_NAME);
+    ).toBe(ldapUserName);
     expect(
       await page
         .getByRole('cell', { name: ldapAccountName })
@@ -240,7 +234,7 @@ test('Set up LDAP auth method @ce @ent @docker', async ({ page }) => {
         .getByRole('cell')
         .nth(emailIndex)
         .innerText(),
-    ).toBe(process.env.E2E_LDAP_USER_NAME + '@mail.com');
+    ).toBe(ldapUserName + '@mail.com');
 
     // View the User account and verify attributes
     await page
@@ -257,14 +251,14 @@ test('Set up LDAP auth method @ce @ent @docker', async ({ page }) => {
         .getByRole('cell')
         .nth(0) // Name field
         .innerText(),
-    ).toContain(process.env.E2E_LDAP_USER_NAME + '@mail.com');
+    ).toContain(ldapUserName + '@mail.com');
   } finally {
     if (orgName) {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       const orgId = await getOrgIdFromNameCli(orgName);
       if (orgId) {

ui/admin/tests/e2e/tests/auth-method-password.spec.mjs

@@ -3,7 +3,8 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 import { execSync } from 'node:child_process';
 
 import {
@@ -23,6 +24,10 @@ test.beforeAll(async () => {
 
 test('Verify new auth-method can be created and assigned to users @ce @ent @aws @docker', async ({
   page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
 }) => {
   await page.goto('/');
   let orgName;
@@ -30,10 +35,7 @@ test('Verify new auth-method can be created and assigned to users @ce @ent @aws
   try {
     // Log in
     const loginPage = new LoginPage(page);
-    await loginPage.login(
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
-    );
+    await loginPage.login(adminLoginName, adminPassword);
     await expect(
       page.getByRole('navigation', { name: 'breadcrumbs' }).getByText('Orgs'),
     ).toBeVisible();
@@ -54,7 +56,7 @@ test('Verify new auth-method can be created and assigned to users @ce @ent @aws
     await usersPage.addAccountToUser(username);
 
     // Log in using new account
-    await loginPage.logout(process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME);
+    await loginPage.logout(adminLoginName);
     await page.getByText('Choose a different scope').click();
     await page.getByRole('link', { name: orgName }).click();
     await page.getByRole('link', { name: authMethodName }).click();
@@ -68,10 +70,7 @@ test('Verify new auth-method can be created and assigned to users @ce @ent @aws
 
     // Log back in as admin
     await loginPage.logout(username);
-    await loginPage.login(
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
-    );
+    await loginPage.login(adminLoginName, adminPassword);
 
     // Set a new password on the account
     await page
@@ -93,7 +92,7 @@ test('Verify new auth-method can be created and assigned to users @ce @ent @aws
     await authMethodsPage.setPasswordToAccount(newPassword);
 
     // Log in using new password
-    await loginPage.logout(process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME);
+    await loginPage.logout(adminLoginName);
 
     await page.getByText('Choose a different scope').click();
     await page.getByRole('link', { name: orgName }).click();
@@ -106,10 +105,10 @@ test('Verify new auth-method can be created and assigned to users @ce @ent @aws
     ).toBeVisible();
   } finally {
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
 
     // There is an issue with deleting an org that has an auth method unless you

ui/admin/tests/e2e/tests/credential-store-static-ent.spec.mjs

@@ -3,10 +3,10 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   checkBoundaryCli,
@@ -21,17 +21,20 @@ import { TargetsPage } from '../pages/targets.mjs';
 test.use({ storageState: authenticatedState });
 
 test.beforeAll(async () => {
-  await checkEnv([
-    'E2E_SSH_USER',
-    'E2E_SSH_KEY_PATH',
-    'E2E_TARGET_ADDRESS',
-    'E2E_TARGET_PORT',
-  ]);
-
   await checkBoundaryCli();
 });
 
-test('Multiple Credential Stores (ENT) @ent @aws @docker', async ({ page }) => {
+test('Multiple Credential Stores (ENT) @ent @aws @docker', async ({
+  page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  sshUser,
+  sshKeyPath,
+  targetAddress,
+  targetPort,
+}) => {
   let orgName;
   try {
     await page.goto('/');
@@ -41,20 +44,13 @@ test('Multiple Credential Stores (ENT) @ent @aws @docker', async ({ page }) => {
     const projectsPage = new ProjectsPage(page);
     await projectsPage.createProject();
     const targetsPage = new TargetsPage(page);
-    const targetName = await targetsPage.createSshTargetWithAddressEnt(
-      process.env.E2E_TARGET_ADDRESS,
-      process.env.E2E_TARGET_PORT,
-    );
+    const targetName = await targetsPage.createSshTargetWithAddressEnt(targetAddress, targetPort);
     const credentialStoresPage = new CredentialStoresPage(page);
     await credentialStoresPage.createStaticCredentialStore();
-    const credentialName =
-      await credentialStoresPage.createStaticCredentialKeyPair(
-        process.env.E2E_SSH_USER,
-        process.env.E2E_SSH_KEY_PATH,
-      );
+    const credentialName = await credentialStoresPage.createStaticCredentialKeyPair(sshUser, sshKeyPath);
     const credentialName2 =
       await credentialStoresPage.createStaticCredentialUsernamePassword(
-        process.env.E2E_SSH_USER,
+        sshUser,
         'testPassword',
       );
 
@@ -106,10 +102,10 @@ test('Multiple Credential Stores (ENT) @ent @aws @docker', async ({ page }) => {
   } finally {
     if (orgName) {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       const orgId = await getOrgIdFromNameCli(orgName);
       if (orgId) {

ui/admin/tests/e2e/tests/credential-store-static.spec.mjs

@@ -3,12 +3,12 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 import { readFile } from 'fs/promises';
 import { nanoid } from 'nanoid';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   authorizeSessionByTargetIdCli,
@@ -26,13 +26,6 @@ import { TargetsPage } from '../pages/targets.mjs';
 test.use({ storageState: authenticatedState });
 
 test.beforeAll(async () => {
-  await checkEnv([
-    'E2E_SSH_USER',
-    'E2E_SSH_KEY_PATH',
-    'E2E_TARGET_ADDRESS',
-    'E2E_TARGET_PORT',
-  ]);
-
   await checkBoundaryCli();
 });
 
@@ -40,7 +33,11 @@ let orgName;
 let projectName;
 let targetName;
 
-test.beforeEach(async ({ page }) => {
+test.beforeEach(async ({
+  page,
+  targetAddress,
+  targetPort,
+}) => {
   await page.goto('/');
 
   const orgsPage = new OrgsPage(page);
@@ -48,35 +45,31 @@ test.beforeEach(async ({ page }) => {
   const projectsPage = new ProjectsPage(page);
   projectName = await projectsPage.createProject();
   const targetsPage = new TargetsPage(page);
-  targetName = await targetsPage.createTargetWithAddress(
-    process.env.E2E_TARGET_ADDRESS,
-    process.env.E2E_TARGET_PORT,
-  );
+  targetName = await targetsPage.createTargetWithAddress(targetAddress, targetPort);
   const credentialStoresPage = new CredentialStoresPage(page);
   await credentialStoresPage.createStaticCredentialStore();
 });
 
 test('Static Credential Store (User & Key Pair) @ce @aws @docker', async ({
   page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  sshUser,
+  sshKeyPath,
 }) => {
   try {
     const credentialStoresPage = new CredentialStoresPage(page);
-    const credentialName =
-      await credentialStoresPage.createStaticCredentialKeyPair(
-        process.env.E2E_SSH_USER,
-        process.env.E2E_SSH_KEY_PATH,
-      );
+    const credentialName = await credentialStoresPage.createStaticCredentialKeyPair(sshUser, sshKeyPath);
     const targetsPage = new TargetsPage(page);
-    await targetsPage.addBrokeredCredentialsToTarget(
-      targetName,
-      credentialName,
-    );
+    await targetsPage.addBrokeredCredentialsToTarget(targetName, credentialName);
 
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     const orgId = await getOrgIdFromNameCli(orgName);
     const projectId = await getProjectIdFromNameCli(orgId, projectName);
@@ -85,9 +78,9 @@ test('Static Credential Store (User & Key Pair) @ce @aws @docker', async ({
     const retrievedUser = session.item.credentials[0].credential.username;
     const retrievedKey = session.item.credentials[0].credential.private_key;
 
-    expect(retrievedUser).toBe(process.env.E2E_SSH_USER);
+    expect(retrievedUser).toBe(sshUser);
 
-    const keyData = await readFile(process.env.E2E_SSH_KEY_PATH, {
+    const keyData = await readFile(sshKeyPath, {
       encoding: 'utf-8',
     });
     if (keyData != retrievedKey) {
@@ -96,10 +89,10 @@ test('Static Credential Store (User & Key Pair) @ce @aws @docker', async ({
   } finally {
     if (orgName) {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       const orgId = await getOrgIdFromNameCli(orgName);
       if (orgId) {
@@ -111,26 +104,24 @@ test('Static Credential Store (User & Key Pair) @ce @aws @docker', async ({
 
 test('Static Credential Store (Username & Password) @ce @aws @docker', async ({
   page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  sshUser
 }) => {
   try {
     const testPassword = 'password';
     const credentialStoresPage = new CredentialStoresPage(page);
-    const credentialName =
-      await credentialStoresPage.createStaticCredentialUsernamePassword(
-        process.env.E2E_SSH_USER,
-        testPassword,
-      );
+    const credentialName = await credentialStoresPage.createStaticCredentialUsernamePassword(sshUser, testPassword);
     const targetsPage = new TargetsPage(page);
-    await targetsPage.addBrokeredCredentialsToTarget(
-      targetName,
-      credentialName,
-    );
+    await targetsPage.addBrokeredCredentialsToTarget(targetName, credentialName);
 
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     const orgId = await getOrgIdFromNameCli(orgName);
     const projectId = await getProjectIdFromNameCli(orgId, projectName);
@@ -139,15 +130,15 @@ test('Static Credential Store (Username & Password) @ce @aws @docker', async ({
     const retrievedUser = session.item.credentials[0].credential.username;
     const retrievedPassword = session.item.credentials[0].credential.password;
 
-    expect(retrievedUser).toBe(process.env.E2E_SSH_USER);
+    expect(retrievedUser).toBe(sshUser);
     expect(retrievedPassword).toBe(testPassword);
   } finally {
     if (orgName) {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       const orgId = await getOrgIdFromNameCli(orgName);
       if (orgId) {
@@ -157,7 +148,13 @@ test('Static Credential Store (Username & Password) @ce @aws @docker', async ({
   }
 });
 
-test('Static Credential Store (JSON) @ce @aws @docker', async ({ page }) => {
+test('Static Credential Store (JSON) @ce @aws @docker', async ({
+  page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+}) => {
   try {
     const credentialName = 'Credential ' + nanoid();
     await page.getByRole('link', { name: 'Credentials', exact: true }).click();
@@ -186,16 +183,13 @@ test('Static Credential Store (JSON) @ce @aws @docker', async ({ page }) => {
     ).toBeVisible();
 
     const targetsPage = new TargetsPage(page);
-    await targetsPage.addBrokeredCredentialsToTarget(
-      targetName,
-      credentialName,
-    );
+    await targetsPage.addBrokeredCredentialsToTarget(targetName, credentialName);
 
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     const orgId = await getOrgIdFromNameCli(orgName);
     const projectId = await getProjectIdFromNameCli(orgId, projectName);
@@ -211,10 +205,10 @@ test('Static Credential Store (JSON) @ce @aws @docker', async ({ page }) => {
   } finally {
     if (orgName) {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       const orgId = await getOrgIdFromNameCli(orgName);
       if (orgId) {
@@ -224,29 +218,28 @@ test('Static Credential Store (JSON) @ce @aws @docker', async ({ page }) => {
   }
 });
 
-test('Multiple Credential Stores (CE) @ce @aws @docker', async ({ page }) => {
+test('Multiple Credential Stores (CE) @ce @aws @docker', async ({
+  page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  sshUser,
+  sshKeyPath,
+}) => {
   try {
     const credentialStoresPage = new CredentialStoresPage(page);
     const credentialName =
-      await credentialStoresPage.createStaticCredentialKeyPair(
-        process.env.E2E_SSH_USER,
-        process.env.E2E_SSH_KEY_PATH,
-      );
+      await credentialStoresPage.createStaticCredentialKeyPair(sshUser, sshKeyPath);
     const credentialName2 =
       await credentialStoresPage.createStaticCredentialUsernamePassword(
-        process.env.E2E_SSH_USER,
+        sshUser,
         'testPassword',
       );
 
     const targetsPage = new TargetsPage(page);
-    await targetsPage.addBrokeredCredentialsToTarget(
-      targetName,
-      credentialName,
-    );
-    await targetsPage.addBrokeredCredentialsToTarget(
-      targetName,
-      credentialName2,
-    );
+    await targetsPage.addBrokeredCredentialsToTarget(targetName, credentialName);
+    await targetsPage.addBrokeredCredentialsToTarget(targetName, credentialName2);
 
     // Remove the host source from the target
     await page
@@ -264,10 +257,10 @@ test('Multiple Credential Stores (CE) @ce @aws @docker', async ({ page }) => {
   } finally {
     if (orgName) {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       const orgId = await getOrgIdFromNameCli(orgName);
       if (orgId) {

ui/admin/tests/e2e/tests/credential-store-vault.spec.mjs

@@ -3,13 +3,13 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 import { execSync } from 'child_process';
 import { nanoid } from 'nanoid';
 import { readFile } from 'fs/promises';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   authorizeSessionByTargetIdCli,
@@ -33,15 +33,6 @@ const boundaryPolicyName = 'boundary-controller';
 test.use({ storageState: authenticatedState });
 
 test.beforeAll(async () => {
-  await checkEnv([
-    'VAULT_ADDR', // Address used by Vault CLI
-    'VAULT_TOKEN',
-    'E2E_VAULT_ADDR', // Address used by Boundary Server (could be different from VAULT_ADDR depending on network config (i.e. docker network))
-    'E2E_TARGET_ADDRESS',
-    'E2E_SSH_USER',
-    'E2E_SSH_KEY_PATH',
-  ]);
-
   await checkBoundaryCli();
   await checkVaultCli();
 });
@@ -56,6 +47,15 @@ test.beforeEach(async ({ page }) => {
 
 test('Vault Credential Store (User & Key Pair) @ce @aws @docker', async ({
   page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  sshUser,
+  sshKeyPath,
+  targetAddress,
+  targetPort,
+  vaultAddr,
 }) => {
   let orgId;
   try {
@@ -65,8 +65,8 @@ test('Vault Credential Store (User & Key Pair) @ce @aws @docker', async ({
     execSync(`vault secrets enable -path=${secretsPath} kv-v2`);
     execSync(
       `vault kv put -mount ${secretsPath} ${secretName} ` +
-      ` username=${process.env.E2E_SSH_USER}` +
-      ` private_key=@${process.env.E2E_SSH_KEY_PATH}`,
+      ` username=${sshUser}` +
+      ` private_key=@${sshKeyPath}`,
     );
     execSync(
       `vault policy write ${secretPolicyName} ./tests/e2e/tests/fixtures/kv-policy.hcl`,
@@ -90,15 +90,9 @@ test('Vault Credential Store (User & Key Pair) @ce @aws @docker', async ({
     const projectsPage = new ProjectsPage(page);
     const projectName = await projectsPage.createProject();
     const targetsPage = new TargetsPage(page);
-    const targetName = await targetsPage.createTargetWithAddress(
-      process.env.E2E_TARGET_ADDRESS,
-      process.env.E2E_TARGET_PORT,
-    );
+    const targetName = await targetsPage.createTargetWithAddress(targetAddress, targetPort);
     const credentialStoresPage = new CredentialStoresPage(page);
-    await credentialStoresPage.createVaultCredentialStore(
-      process.env.E2E_VAULT_ADDR,
-      clientToken,
-    );
+    await credentialStoresPage.createVaultCredentialStore(vaultAddr, clientToken);
 
     const credentialLibraryName = 'Credential Library ' + nanoid();
     await page.getByRole('link', { name: 'Credential Libraries' }).click();
@@ -124,10 +118,10 @@ test('Vault Credential Store (User & Key Pair) @ce @aws @docker', async ({
     );
 
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     orgId = await getOrgIdFromNameCli(orgName);
     const projectId = await getProjectIdFromNameCli(orgId, projectName);
@@ -138,9 +132,9 @@ test('Vault Credential Store (User & Key Pair) @ce @aws @docker', async ({
     const retrievedKey =
       session.item.credentials[0].secret.decoded.data.private_key;
 
-    expect(retrievedUser).toBe(process.env.E2E_SSH_USER);
+    expect(retrievedUser).toBe(sshUser);
 
-    const keyData = await readFile(process.env.E2E_SSH_KEY_PATH, {
+    const keyData = await readFile(sshKeyPath, {
       encoding: 'utf-8',
     });
     if (keyData != retrievedKey) {

ui/admin/tests/e2e/tests/delete-resources-ent.spec.mjs

@@ -3,11 +3,10 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
 import { execSync } from 'node:child_process';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   checkBoundaryCli,
@@ -42,34 +41,30 @@ 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 () => {
+test.beforeEach(async ({
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+}) => {
   execSync(`vault policy delete ${secretPolicyName}`);
   execSync(`vault policy delete ${boundaryPolicyName}`);
   await authenticateBoundaryCli(
-    process.env.BOUNDARY_ADDR,
-    process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-    process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-    process.env.E2E_PASSWORD_ADMIN_PASSWORD,
-    process.env.E2E_AWS_REGION,
+    baseURL,
+    adminAuthMethodId,
+    adminLoginName,
+    adminPassword,
   );
 });
 
 test('Verify resources can be deleted (enterprise) @ent @aws', async ({
   page,
+  awsRegion,
+  vaultAddr,
 }) => {
   let orgId;
   let orgDeleted = false;
@@ -88,25 +83,14 @@ test('Verify resources can be deleted (enterprise) @ent @aws', async ({
     let groupId = await createGroupCli(orgId);
     let userId = await createUserCli(orgId);
     let staticHostCatalogId = await createStaticHostCatalogCli(projectId);
-    let dynamicAwsHostCatalogId = await createDynamicAwsHostCatalogCli(
-      projectId,
-      process.env.E2E_AWS_REGION,
-    );
+    let dynamicAwsHostCatalogId = await createDynamicAwsHostCatalogCli(projectId, awsRegion);
     let staticHostId = await createStaticHostCli(staticHostCatalogId);
     let staticHostSetId = await createHostSetCli(staticHostCatalogId);
     let staticCredentialStoreId =
       await createStaticCredentialStoreCli(projectId);
-    const vaultToken = await getVaultToken(
-      boundaryPolicyName,
-      secretPolicyName,
-    );
-    let vaultCredentialStoreId = await createVaultCredentialStoreCli(
-      projectId,
-      process.env.E2E_VAULT_ADDR,
-      vaultToken,
-    );
-    let usernamePasswordCredentialId =
-      await createUsernamePasswordCredentialCli(staticCredentialStoreId);
+    const vaultToken = await getVaultToken(boundaryPolicyName, secretPolicyName);
+    let vaultCredentialStoreId = await createVaultCredentialStoreCli(projectId, vaultAddr, vaultToken);
+    let usernamePasswordCredentialId = await createUsernamePasswordCredentialCli(staticCredentialStoreId);
     let tcpTargetId = await createTcpTarget(projectId);
 
     // Create enterprise boundary resources using CLI

ui/admin/tests/e2e/tests/delete-resources.spec.mjs

@@ -3,11 +3,10 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
 import { execSync } from 'node:child_process';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   checkBoundaryCli,
@@ -41,33 +40,31 @@ 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 () => {
+test.beforeEach(async ({
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+}) => {
   execSync(`vault policy delete ${secretPolicyName}`);
   execSync(`vault policy delete ${boundaryPolicyName}`);
   await authenticateBoundaryCli(
-    process.env.BOUNDARY_ADDR,
-    process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-    process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-    process.env.E2E_PASSWORD_ADMIN_PASSWORD,
-    process.env.E2E_AWS_REGION,
+    baseURL,
+    adminAuthMethodId,
+    adminLoginName,
+    adminPassword,
   );
 });
 
-test('Verify resources can be deleted @ce @aws', async ({ page }) => {
+test('Verify resources can be deleted @ce @aws', async ({
+  page,
+  awsRegion,
+  vaultAddr,
+}) => {
   let orgId;
   let orgDeleted = false;
   try {
@@ -84,23 +81,12 @@ test('Verify resources can be deleted @ce @aws', async ({ page }) => {
     let groupId = await createGroupCli(orgId);
     let userId = await createUserCli(orgId);
     let staticHostCatalogId = await createStaticHostCatalogCli(projectId);
-    let dynamicAwsHostCatalogId = await createDynamicAwsHostCatalogCli(
-      projectId,
-      process.env.E2E_AWS_REGION,
-    );
+    let dynamicAwsHostCatalogId = await createDynamicAwsHostCatalogCli(projectId, awsRegion);
     let staticHostId = await createStaticHostCli(staticHostCatalogId);
     let staticHostSetId = await createHostSetCli(staticHostCatalogId);
-    let staticCredentialStoreId =
-      await createStaticCredentialStoreCli(projectId);
-    const vaultToken = await getVaultToken(
-      boundaryPolicyName,
-      secretPolicyName,
-    );
-    let vaultCredentialStoreId = await createVaultCredentialStoreCli(
-      projectId,
-      process.env.E2E_VAULT_ADDR,
-      vaultToken,
-    );
+    let staticCredentialStoreId = await createStaticCredentialStoreCli(projectId);
+    const vaultToken = await getVaultToken(boundaryPolicyName, secretPolicyName);
+    let vaultCredentialStoreId = await createVaultCredentialStoreCli(projectId, vaultAddr, vaultToken);
     let usernamePasswordCredentialId =
       await createUsernamePasswordCredentialCli(staticCredentialStoreId);
     let tcpTargetId = await createTcpTarget(projectId);

ui/admin/tests/e2e/tests/dynamic-host-catalog-aws.spec.mjs

@@ -3,11 +3,11 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 import { nanoid } from 'nanoid';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   deleteScopeCli,
@@ -20,17 +20,6 @@ import { TargetsPage } from '../pages/targets.mjs';
 
 test.use({ storageState: authenticatedState });
 
-test.beforeAll(async () => {
-  await checkEnv([
-    'E2E_AWS_ACCESS_KEY_ID',
-    'E2E_AWS_SECRET_ACCESS_KEY',
-    'E2E_AWS_HOST_SET_FILTER',
-    'E2E_AWS_HOST_SET_IPS',
-    'E2E_AWS_REGION',
-    'E2E_TARGET_PORT',
-  ]);
-});
-
 test.beforeEach(async ({ page }) => {
   await page.goto('/');
 });
@@ -38,6 +27,16 @@ test.beforeEach(async ({ page }) => {
 test.describe('AWS', async () => {
   test('Create an AWS Dynamic Host Catalog and set up Host Sets @ce @ent @aws', async ({
     page,
+    baseURL,
+    adminAuthMethodId,
+    adminLoginName,
+    adminPassword,
+    awsAccessKeyId,
+    awsHostSetFilter,
+    awsHostSetIps,
+    awsRegion,
+    awsSecretAccessKey,
+    targetPort,
   }) => {
     let orgName;
     try {
@@ -63,13 +62,13 @@ test.describe('AWS', async () => {
         .getByRole('group', { name: 'Provider' })
         .getByLabel('AWS')
         .click();
-      await page.getByLabel('AWS Region').fill(process.env.E2E_AWS_REGION);
+      await page.getByLabel('AWS Region').fill(awsRegion);
       await page
         .getByLabel('Access Key ID')
-        .fill(process.env.E2E_AWS_ACCESS_KEY_ID);
+        .fill(awsAccessKeyId);
       await page
         .getByLabel('Secret Access Key')
-        .fill(process.env.E2E_AWS_SECRET_ACCESS_KEY);
+        .fill(awsSecretAccessKey);
       await page
         .getByLabel('Disable credential rotation')
         .click({ force: true });
@@ -93,7 +92,7 @@ test.describe('AWS', async () => {
       await page
         .getByRole('group', { name: 'Filter' })
         .getByRole('textbox')
-        .fill(process.env.E2E_AWS_HOST_SET_FILTER);
+        .fill(awsHostSetFilter);
       await page
         .getByRole('group', { name: 'Filter' })
         .getByRole('button', { name: 'Add' })
@@ -119,7 +118,7 @@ test.describe('AWS', async () => {
       // Check number of hosts in host set
       let i = 0;
       let rowCount = 0;
-      let expectedHosts = JSON.parse(process.env.E2E_AWS_HOST_SET_IPS);
+      let expectedHosts = JSON.parse(awsHostSetIps);
       do {
         i = i + 1;
         // Getting the number of rows in the second rowgroup (the first rowgroup is the header row)
@@ -165,9 +164,7 @@ test.describe('AWS', async () => {
 
       // Create a target and add DHC host set as a host source
       const targetsPage = new TargetsPage(page);
-      const targetName = await targetsPage.createTarget(
-        process.env.E2E_TARGET_PORT,
-      );
+      const targetName = await targetsPage.createTarget(targetPort);
       await targetsPage.addHostSourceToTarget(hostSetName);
 
       // Add another host source
@@ -199,10 +196,10 @@ test.describe('AWS', async () => {
       await targetsPage.addHostSourceToTarget(newHostSetName);
     } finally {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
 
       if (orgName) {

ui/admin/tests/e2e/tests/global-settings.spec.mjs

@@ -3,7 +3,8 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 
 import { authenticatedState } from '../global-setup.mjs';
 import {
@@ -16,7 +17,13 @@ import { StoragePoliciesPage } from '../pages/storage-policies.mjs';
 
 test.use({ storageState: authenticatedState });
 
-test('Global Settings @ent @aws @docker', async ({ page }) => {
+test('Global Settings @ent @aws @docker', async ({
+  page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+}) => {
   await page.goto('/');
   let policyName;
   try {
@@ -46,10 +53,10 @@ test('Global Settings @ent @aws @docker', async ({ page }) => {
   } finally {
     if (policyName) {
       await authenticateBoundaryCli(
-        process.env.BOUNDARY_ADDR,
-        process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-        process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-        process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+        baseURL,
+        adminAuthMethodId,
+        adminLoginName,
+        adminPassword,
       );
       const storagePolicyId = await getPolicyIdFromNameCli(
         'global',

ui/admin/tests/e2e/tests/group-role.spec.mjs

@@ -3,7 +3,8 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 
 import { authenticatedState } from '../global-setup.mjs';
 import {
@@ -24,6 +25,10 @@ test.beforeAll(async () => {
 
 test('Verify a new role can be created and associated with a group @ce @ent @aws @docker', async ({
   page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
 }) => {
   await page.goto('/');
   let orgName;
@@ -39,10 +44,10 @@ test('Verify a new role can be created and associated with a group @ce @ent @aws
     await rolesPage.addGrantsToRole('ids=*;type=*;actions=read,list');
   } finally {
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     const orgId = await getOrgIdFromNameCli(orgName);
     if (orgId) {

ui/admin/tests/e2e/tests/login.spec.mjs

@@ -3,34 +3,31 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 
 import { LoginPage } from '../pages/login.mjs';
 
 test('Log in, log out, and then log back in @ce @ent @aws @docker', async ({
   page,
+  adminLoginName,
+  adminPassword,
 }) => {
   await page.goto('/');
 
   // Log in
   const loginPage = new LoginPage(page);
-  await loginPage.login(
-    process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-    process.env.E2E_PASSWORD_ADMIN_PASSWORD,
-  );
+  await loginPage.login(adminLoginName, adminPassword);
   await expect(
     page.getByRole('navigation', { name: 'breadcrumbs' }).getByText('Orgs'),
   ).toBeVisible();
 
   // Log out
-  await loginPage.logout(process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME);
+  await loginPage.logout(adminLoginName);
   await page.reload();
 
   // Log back in
-  await loginPage.login(
-    process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-    process.env.E2E_PASSWORD_ADMIN_PASSWORD,
-  );
+  await loginPage.login(adminLoginName, adminPassword);
   await expect(
     page.getByRole('navigation', { name: 'breadcrumbs' }).getByText('Orgs'),
   ).toBeVisible();
@@ -43,38 +40,46 @@ test.describe('Failure Cases', async () => {
 
   test('Log in with invalid password @ce @ent @aws @docker', async ({
     page,
+    adminLoginName,
   }) => {
     await page
       .getByLabel('Login Name')
-      .fill(process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME);
+      .fill(adminLoginName);
     await page.getByLabel('Password', { exact: true }).fill('badpassword');
     await page.getByRole('button', { name: 'Sign In' }).click();
     await expect(page.getByRole('alert').getByText('Error')).toBeVisible();
     await expect(page.getByRole('button', { name: 'Sign In' })).toBeVisible();
     await expect(
-      page.getByText(process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME),
+      page.getByText(adminLoginName),
     ).toBeHidden();
   });
 
-  test('Log in with only username @ce @ent @aws @docker', async ({ page }) => {
+  test('Log in with only username @ce @ent @aws @docker', async ({
+    page,
+    adminLoginName,
+  }) => {
     await page.getByLabel('Login Name').fill('testuser');
     await page.getByRole('button', { name: 'Sign In' }).click();
     await expect(page.getByRole('alert').getByText('Error')).toBeVisible();
     await expect(page.getByRole('button', { name: 'Sign In' })).toBeVisible();
     await expect(
-      page.getByText(process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME),
+      page.getByText(adminLoginName),
     ).toBeHidden();
   });
 
-  test('Log in with only password @ce @ent @aws @docker', async ({ page }) => {
+  test('Log in with only password @ce @ent @aws @docker', async ({
+    page,
+    adminLoginName,
+    adminPassword,
+  }) => {
     await page
       .getByLabel('Password', { exact: true })
-      .fill(process.env.E2E_PASSWORD_ADMIN_PASSWORD);
+      .fill(adminPassword);
     await page.getByRole('button', { name: 'Sign In' }).click();
     await expect(page.getByRole('alert').getByText('Error')).toBeVisible();
     await expect(page.getByRole('button', { name: 'Sign In' })).toBeVisible();
     await expect(
-      page.getByText(process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME),
+      page.getByText(adminLoginName),
     ).toBeHidden();
   });
 });

ui/admin/tests/e2e/tests/pagination.spec.mjs

@@ -3,7 +3,8 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 
 import { authenticatedState } from '../global-setup.mjs';
 import {

ui/admin/tests/e2e/tests/session-recording-aws-ent.spec.mjs

@@ -3,11 +3,11 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 import { execSync } from 'child_process';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   checkBoundaryCli,
@@ -33,22 +33,25 @@ import { TargetsPage } from '../pages/targets.mjs';
 test.use({ storageState: authenticatedState });
 
 test.beforeAll(async () => {
-  await checkEnv([
-    'E2E_SSH_USER',
-    'E2E_SSH_KEY_PATH',
-    'E2E_TARGET_ADDRESS',
-    'E2E_TARGET_PORT',
-    'E2E_AWS_BUCKET_NAME',
-    'E2E_AWS_REGION',
-    'E2E_AWS_ACCESS_KEY_ID',
-    'E2E_AWS_SECRET_ACCESS_KEY',
-    'E2E_WORKER_TAG_EGRESS',
-  ]);
-
   await checkBoundaryCli();
 });
 
-test('Session Recording Test (AWS) @ent @aws', async ({ page }) => {
+test('Session Recording Test (AWS) @ent @aws', async ({
+  page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  awsAccessKeyId,
+  awsBucketName,
+  awsRegion,
+  awsSecretAccessKey,
+  sshUser,
+  sshKeyPath,
+  targetAddress,
+  targetPort,
+  workerTagEgress,
+}) => {
   await page.goto('/');
   let orgId;
   let policyName;
@@ -56,10 +59,10 @@ test('Session Recording Test (AWS) @ent @aws', async ({ page }) => {
   let connect;
   try {
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
 
     // Create org
@@ -75,11 +78,11 @@ test('Session Recording Test (AWS) @ent @aws', async ({ page }) => {
     const storageBucketsPage = new StorageBucketsPage(page);
     const storageBucketName = await storageBucketsPage.createStorageBucketAws(
       orgName,
-      process.env.E2E_AWS_BUCKET_NAME,
-      process.env.E2E_AWS_REGION,
-      process.env.E2E_AWS_ACCESS_KEY_ID,
-      process.env.E2E_AWS_SECRET_ACCESS_KEY,
-      `"${process.env.E2E_WORKER_TAG_EGRESS}" in "/tags/type"`,
+      awsBucketName,
+      awsRegion,
+      awsAccessKeyId,
+      awsSecretAccessKey,
+      `"${workerTagEgress}" in "/tags/type"`,
     );
     const storageBuckets = JSON.parse(
       execSync('boundary storage-buckets list --recursive -format json'),
@@ -94,24 +97,14 @@ test('Session Recording Test (AWS) @ent @aws', async ({ page }) => {
     await page.getByRole('link', { name: orgName }).click();
     await page.getByRole('link', { name: projectName }).click();
     const targetsPage = new TargetsPage(page);
-    const targetName = await targetsPage.createSshTargetWithAddressEnt(
-      process.env.E2E_TARGET_ADDRESS,
-      process.env.E2E_TARGET_PORT,
-    );
+    const targetName = await targetsPage.createSshTargetWithAddressEnt(targetAddress, targetPort);
     await targetsPage.addEgressWorkerFilterToTarget(
-      `"${process.env.E2E_WORKER_TAG_EGRESS}" in "/tags/type"`,
+      `"${workerTagEgress}" in "/tags/type"`,
     );
     const credentialStoresPage = new CredentialStoresPage(page);
     await credentialStoresPage.createStaticCredentialStore();
-    const credentialName =
-      await credentialStoresPage.createStaticCredentialKeyPair(
-        process.env.E2E_SSH_USER,
-        process.env.E2E_SSH_KEY_PATH,
-      );
-    await targetsPage.addInjectedCredentialsToTarget(
-      targetName,
-      credentialName,
-    );
+    const credentialName = await credentialStoresPage.createStaticCredentialKeyPair(sshUser, sshKeyPath);
+    await targetsPage.addInjectedCredentialsToTarget(targetName, credentialName);
     await page.getByRole('link', { name: targetName }).click();
     await targetsPage.enableSessionRecording(storageBucketName);
 

ui/admin/tests/e2e/tests/session-recording-minio-ent.spec.mjs

@@ -3,11 +3,11 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 import { execSync } from 'child_process';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   checkBoundaryCli,
@@ -33,22 +33,26 @@ import { TargetsPage } from '../pages/targets.mjs';
 test.use({ storageState: authenticatedState });
 
 test.beforeAll(async () => {
-  await checkEnv([
-    'E2E_SSH_USER',
-    'E2E_SSH_KEY_PATH',
-    'E2E_TARGET_ADDRESS',
-    'E2E_TARGET_PORT',
-    'E2E_BUCKET_NAME',
-    'E2E_BUCKET_ENDPOINT_URL',
-    'E2E_BUCKET_ACCESS_KEY_ID',
-    'E2E_BUCKET_SECRET_ACCESS_KEY',
-    'E2E_REGION',
-  ]);
-
   await checkBoundaryCli();
 });
 
-test('Session Recording Test (MinIO) @ent @docker', async ({ page }) => {
+test('Session Recording Test (MinIO) @ent @docker', async ({
+  page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  bucketAccessKeyId,
+  bucketEndpointUrl,
+  bucketName,
+  bucketSecretAccessKey,
+  region,
+  sshUser,
+  sshKeyPath,
+  targetAddress,
+  targetPort,
+  workerTagEgress,
+}) => {
   await page.goto('/');
 
   let orgId;
@@ -57,10 +61,10 @@ test('Session Recording Test (MinIO) @ent @docker', async ({ page }) => {
   let connect;
   try {
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
 
     // Create org
@@ -76,12 +80,12 @@ test('Session Recording Test (MinIO) @ent @docker', async ({ page }) => {
     const storageBucketsPage = new StorageBucketsPage(page);
     const storageBucketName = await storageBucketsPage.createStorageBucketMinio(
       orgName,
-      process.env.E2E_BUCKET_ENDPOINT_URL,
-      process.env.E2E_BUCKET_NAME,
-      process.env.E2E_REGION,
-      process.env.E2E_BUCKET_ACCESS_KEY_ID,
-      process.env.E2E_BUCKET_SECRET_ACCESS_KEY,
-      `"${process.env.E2E_WORKER_TAG_EGRESS}" in "/tags/type"`,
+      bucketEndpointUrl,
+      bucketName,
+      region,
+      bucketAccessKeyId,
+      bucketSecretAccessKey,
+      `"${workerTagEgress}" in "/tags/type"`,
     );
     const storageBuckets = JSON.parse(
       execSync('boundary storage-buckets list --recursive -format json'),
@@ -96,25 +100,15 @@ test('Session Recording Test (MinIO) @ent @docker', async ({ page }) => {
     await page.getByRole('link', { name: orgName }).click();
     await page.getByRole('link', { name: projectName }).click();
     const targetsPage = new TargetsPage(page);
-    const targetName = await targetsPage.createSshTargetWithAddressEnt(
-      process.env.E2E_TARGET_ADDRESS,
-      process.env.E2E_TARGET_PORT,
-    );
+    const targetName = await targetsPage.createSshTargetWithAddressEnt(targetAddress, targetPort);
     await targetsPage.addEgressWorkerFilterToTarget(
-      `"${process.env.E2E_WORKER_TAG_EGRESS}" in "/tags/type"`,
+      `"${workerTagEgress}" in "/tags/type"`,
     );
 
     const credentialStoresPage = new CredentialStoresPage(page);
     await credentialStoresPage.createStaticCredentialStore();
-    const credentialName =
-      await credentialStoresPage.createStaticCredentialKeyPair(
-        process.env.E2E_SSH_USER,
-        process.env.E2E_SSH_KEY_PATH,
-      );
-    await targetsPage.addInjectedCredentialsToTarget(
-      targetName,
-      credentialName,
-    );
+    const credentialName = await credentialStoresPage.createStaticCredentialKeyPair(sshUser, sshKeyPath);
+    await targetsPage.addInjectedCredentialsToTarget(targetName, credentialName);
     await page.getByRole('link', { name: targetName }).click();
     await targetsPage.enableSessionRecording(storageBucketName);
 

ui/admin/tests/e2e/tests/ssh-certificate-injection-vault-ent.spec.mjs

@@ -3,11 +3,11 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 import { execSync } from 'child_process';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   checkBoundaryCli,
@@ -34,17 +34,6 @@ const secretName = 'boundary-client';
 test.use({ storageState: authenticatedState });
 
 test.beforeAll(async () => {
-  await checkEnv([
-    'VAULT_ADDR', // Address used by Vault CLI
-    'VAULT_TOKEN',
-    'E2E_VAULT_ADDR', // Address used by Boundary Server (could be different from VAULT_ADDR depending on network config (i.e. docker network))
-    'E2E_TARGET_ADDRESS',
-    'E2E_TARGET_PORT',
-    'E2E_SSH_USER',
-    'E2E_SSH_CA_KEY',
-    'E2E_SSH_CA_KEY_PUBLIC',
-  ]);
-
   await checkBoundaryCli();
   await checkVaultCli();
 });
@@ -53,7 +42,19 @@ test.beforeEach(async () => {
   execSync(`vault secrets disable ${secretsPath}`);
 });
 
-test('SSH Certificate Injection @ent @docker', async ({ page }) => {
+test('SSH Certificate Injection @ent @docker', async ({
+  page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  sshUser,
+  sshCaKey,
+  sshCaKeyPublic,
+  targetAddress,
+  targetPort,
+  vaultAddr,
+}) => {
   await page.goto('/');
   let orgId;
   let connect;
@@ -70,8 +71,8 @@ test('SSH Certificate Injection @ent @docker', async ({ page }) => {
       `vault write ${secretsPath}/roles/${secretName} @./tests/e2e/tests/fixtures/ssh-certificate-injection-role.json`,
     );
 
-    const private_key = atob(process.env.E2E_SSH_CA_KEY);
-    const public_key = atob(process.env.E2E_SSH_CA_KEY_PUBLIC);
+    const private_key = atob(sshCaKey);
+    const public_key = atob(sshCaKeyPublic);
 
     execSync(
       `vault write ${secretsPath}/config/ca` +
@@ -105,21 +106,15 @@ test('SSH Certificate Injection @ent @docker', async ({ page }) => {
 
     // Create target
     const targetsPage = new TargetsPage(page);
-    const targetName = await targetsPage.createSshTargetWithAddressEnt(
-      process.env.E2E_TARGET_ADDRESS,
-      process.env.E2E_TARGET_PORT,
-    );
+    const targetName = await targetsPage.createSshTargetWithAddressEnt(targetAddress, targetPort);
 
     // Create credentials
     const credentialStoresPage = new CredentialStoresPage(page);
-    await credentialStoresPage.createVaultCredentialStore(
-      process.env.E2E_VAULT_ADDR,
-      clientToken,
-    );
+    await credentialStoresPage.createVaultCredentialStore(vaultAddr, clientToken);
     const credentialLibraryName =
       await credentialStoresPage.createVaultSshCertificateCredentialLibrary(
         `${secretsPath}/issue/${secretName}`,
-        process.env.E2E_SSH_USER,
+        sshUser,
       );
     await targetsPage.addInjectedCredentialsToTarget(
       targetName,
@@ -128,10 +123,10 @@ test('SSH Certificate Injection @ent @docker', async ({ page }) => {
 
     // Connect to target
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     orgId = await getOrgIdFromNameCli(orgName);
     const projectId = await getProjectIdFromNameCli(orgId, projectName);

ui/admin/tests/e2e/tests/ssh-credential-injection-vault-ent.spec.mjs

@@ -3,11 +3,11 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 import { execSync } from 'child_process';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   checkBoundaryCli,
@@ -32,15 +32,6 @@ const boundaryPolicyName = 'boundary-controller';
 test.use({ storageState: authenticatedState });
 
 test.beforeAll(async () => {
-  await checkEnv([
-    'VAULT_ADDR', // Address used by Vault CLI
-    'VAULT_TOKEN',
-    'E2E_VAULT_ADDR', // Address used by Boundary Server (could be different from VAULT_ADDR depending on network config (i.e. docker network))
-    'E2E_TARGET_ADDRESS',
-    'E2E_SSH_USER',
-    'E2E_SSH_KEY_PATH',
-  ]);
-
   await checkBoundaryCli();
   await checkVaultCli();
 });
@@ -55,6 +46,15 @@ test.beforeEach(async ({ page }) => {
 
 test('SSH Credential Injection (Vault User & Key Pair) @ent @docker', async ({
   page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  sshUser,
+  sshKeyPath,
+  targetAddress,
+  targetPort,
+  vaultAddr,
 }) => {
   let orgId;
   let connect;
@@ -66,8 +66,8 @@ test('SSH Credential Injection (Vault User & Key Pair) @ent @docker', async ({
     execSync(`vault secrets enable -path=${secretsPath} kv-v2`);
     execSync(
       `vault kv put -mount ${secretsPath} ${secretName} ` +
-      ` username=${process.env.E2E_SSH_USER}` +
-      ` private_key=@${process.env.E2E_SSH_KEY_PATH}`,
+      ` username=${sshUser}` +
+      ` private_key=@${sshKeyPath}`,
     );
     execSync(
       `vault policy write ${secretPolicyName} ./tests/e2e/tests/fixtures/kv-policy.hcl`,
@@ -96,33 +96,24 @@ test('SSH Credential Injection (Vault User & Key Pair) @ent @docker', async ({
 
     // Create target
     const targetsPage = new TargetsPage(page);
-    const targetName = await targetsPage.createSshTargetWithAddressEnt(
-      process.env.E2E_TARGET_ADDRESS,
-      process.env.E2E_TARGET_PORT,
-    );
+    const targetName = await targetsPage.createSshTargetWithAddressEnt(targetAddress, targetPort);
 
     // Create credentials
     const credentialStoresPage = new CredentialStoresPage(page);
-    await credentialStoresPage.createVaultCredentialStore(
-      process.env.E2E_VAULT_ADDR,
-      clientToken,
-    );
+    await credentialStoresPage.createVaultCredentialStore(vaultAddr, clientToken);
     const credentialLibraryName =
       await credentialStoresPage.createVaultGenericCredentialLibrary(
         `${secretsPath}/data/${secretName}`,
         'SSH Private Key',
       );
-    await targetsPage.addInjectedCredentialsToTarget(
-      targetName,
-      credentialLibraryName,
-    );
+    await targetsPage.addInjectedCredentialsToTarget(targetName, credentialLibraryName);
 
     // Connect to target
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     orgId = await getOrgIdFromNameCli(orgName);
     const projectId = await getProjectIdFromNameCli(orgId, projectName);

ui/admin/tests/e2e/tests/target-ent.spec.mjs

@@ -3,10 +3,10 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   checkBoundaryCli,
@@ -27,18 +27,19 @@ import { TargetsPage } from '../pages/targets.mjs';
 test.use({ storageState: authenticatedState });
 
 test.beforeAll(async () => {
-  await checkEnv([
-    'E2E_SSH_USER',
-    'E2E_SSH_KEY_PATH',
-    'E2E_TARGET_ADDRESS',
-    'E2E_TARGET_PORT',
-  ]);
-
   await checkBoundaryCli();
 });
 
 test('Verify session created for TCP target @ent @aws @docker', async ({
   page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  sshUser,
+  sshKeyPath,
+  targetAddress,
+  targetPort,
 }) => {
   await page.goto('/');
   let orgId;
@@ -49,25 +50,18 @@ test('Verify session created for TCP target @ent @aws @docker', async ({
     const projectsPage = new ProjectsPage(page);
     const projectName = await projectsPage.createProject();
     const targetsPage = new TargetsPage(page);
-    const targetName = await targetsPage.createTcpTargetWithAddressEnt(
-      process.env.E2E_TARGET_ADDRESS,
-      process.env.E2E_TARGET_PORT,
-    );
+    const targetName = await targetsPage.createTcpTargetWithAddressEnt(targetAddress, targetPort);
 
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     orgId = await getOrgIdFromNameCli(orgName);
     const projectId = await getProjectIdFromNameCli(orgId, projectName);
     const targetId = await getTargetIdFromNameCli(projectId, targetName);
-    connect = await connectToTarget(
-      targetId,
-      process.env.E2E_SSH_USER,
-      process.env.E2E_SSH_KEY_PATH,
-    );
+    connect = await connectToTarget(targetId, sshUser, sshKeyPath);
     const sessionsPage = new SessionsPage(page);
     await sessionsPage.waitForSessionToBeVisible(targetName);
     await page
@@ -88,6 +82,14 @@ test('Verify session created for TCP target @ent @aws @docker', async ({
 
 test('Verify session created for SSH target @ent @aws @docker', async ({
   page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  sshUser,
+  sshKeyPath,
+  targetAddress,
+  targetPort,
 }) => {
   await page.goto('/');
   let orgId;
@@ -98,27 +100,18 @@ test('Verify session created for SSH target @ent @aws @docker', async ({
     const projectsPage = new ProjectsPage(page);
     const projectName = await projectsPage.createProject();
     const targetsPage = new TargetsPage(page);
-    const targetName = await targetsPage.createSshTargetWithAddressEnt(
-      process.env.E2E_TARGET_ADDRESS,
-      process.env.E2E_TARGET_PORT,
-    );
+    const targetName = await targetsPage.createSshTargetWithAddressEnt(targetAddress, targetPort);
     const credentialStoresPage = new CredentialStoresPage(page);
     await credentialStoresPage.createStaticCredentialStore();
     const credentialName =
-      await credentialStoresPage.createStaticCredentialKeyPair(
-        process.env.E2E_SSH_USER,
-        process.env.E2E_SSH_KEY_PATH,
-      );
-    await targetsPage.addInjectedCredentialsToTarget(
-      targetName,
-      credentialName,
-    );
+      await credentialStoresPage.createStaticCredentialKeyPair(sshUser, sshKeyPath);
+    await targetsPage.addInjectedCredentialsToTarget(targetName, credentialName);
 
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     orgId = await getOrgIdFromNameCli(orgName);
     const projectId = await getProjectIdFromNameCli(orgId, projectName);
@@ -142,7 +135,17 @@ test('Verify session created for SSH target @ent @aws @docker', async ({
   }
 });
 
-test('SSH target with host sources @ent @aws @docker', async ({ page }) => {
+test('SSH target with host sources @ent @aws @docker', async ({
+  page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  sshUser,
+  sshKeyPath,
+  targetAddress,
+  targetPort,
+}) => {
   await page.goto('/');
   let orgId;
   let connect;
@@ -156,7 +159,7 @@ test('SSH target with host sources @ent @aws @docker', async ({ page }) => {
     const hostCatalogsPage = new HostCatalogsPage(page);
     const hostCatalogName = await hostCatalogsPage.createHostCatalog();
     const hostSetName = await hostCatalogsPage.createHostSet();
-    await hostCatalogsPage.createHostInHostSet(process.env.E2E_TARGET_ADDRESS);
+    await hostCatalogsPage.createHostInHostSet(targetAddress);
 
     // Create another host set
     await page
@@ -168,9 +171,7 @@ test('SSH target with host sources @ent @aws @docker', async ({ page }) => {
 
     // Create target
     const targetsPage = new TargetsPage(page);
-    const targetName = await targetsPage.createSshTargetEnt(
-      process.env.E2E_TARGET_PORT,
-    );
+    const targetName = await targetsPage.createSshTargetEnt(targetPort);
     await targetsPage.addHostSourceToTarget(hostSetName);
 
     // Add/Remove another host source
@@ -191,22 +192,15 @@ test('SSH target with host sources @ent @aws @docker', async ({ page }) => {
     // Create credentials and attach to target
     const credentialStoresPage = new CredentialStoresPage(page);
     await credentialStoresPage.createStaticCredentialStore();
-    const credentialName =
-      await credentialStoresPage.createStaticCredentialKeyPair(
-        process.env.E2E_SSH_USER,
-        process.env.E2E_SSH_KEY_PATH,
-      );
-    await targetsPage.addInjectedCredentialsToTarget(
-      targetName,
-      credentialName,
-    );
+    const credentialName = await credentialStoresPage.createStaticCredentialKeyPair(sshUser, sshKeyPath);
+    await targetsPage.addInjectedCredentialsToTarget(targetName, credentialName);
 
     // Connect to target
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     orgId = await getOrgIdFromNameCli(orgName);
     const projectId = await getProjectIdFromNameCli(orgId, projectName);

ui/admin/tests/e2e/tests/target.spec.mjs

@@ -3,10 +3,10 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 
 import { authenticatedState } from '../global-setup.mjs';
-import { checkEnv } from '../helpers/general.mjs';
 import {
   authenticateBoundaryCli,
   checkBoundaryCli,
@@ -25,18 +25,19 @@ import { TargetsPage } from '../pages/targets.mjs';
 test.use({ storageState: authenticatedState });
 
 test.beforeAll(async () => {
-  await checkEnv([
-    'E2E_SSH_USER',
-    'E2E_SSH_KEY_PATH',
-    'E2E_TARGET_ADDRESS',
-    'E2E_TARGET_PORT',
-  ]);
-
   await checkBoundaryCli();
 });
 
 test('Verify session created to target with host, then cancel the session @ce @aws @docker', async ({
   page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  sshUser,
+  sshKeyPath,
+  targetAddress,
+  targetPort,
 }) => {
   await page.goto('/');
   let orgId;
@@ -51,7 +52,7 @@ test('Verify session created to target with host, then cancel the session @ce @a
     const hostCatalogsPage = new HostCatalogsPage(page);
     const hostCatalogName = await hostCatalogsPage.createHostCatalog();
     const hostSetName = await hostCatalogsPage.createHostSet();
-    await hostCatalogsPage.createHostInHostSet(process.env.E2E_TARGET_ADDRESS);
+    await hostCatalogsPage.createHostInHostSet(targetAddress);
 
     // Create another host set
     await page
@@ -63,9 +64,7 @@ test('Verify session created to target with host, then cancel the session @ce @a
 
     // Create target
     const targetsPage = new TargetsPage(page);
-    const targetName = await targetsPage.createTarget(
-      process.env.E2E_TARGET_PORT,
-    );
+    const targetName = await targetsPage.createTarget(targetPort);
     await targetsPage.addHostSourceToTarget(hostSetName);
 
     // Add/Remove another host source
@@ -74,19 +73,15 @@ test('Verify session created to target with host, then cancel the session @ce @a
 
     // Connect to target
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     orgId = await getOrgIdFromNameCli(orgName);
     const projectId = await getProjectIdFromNameCli(orgId, projectName);
     const targetId = await getTargetIdFromNameCli(projectId, targetName);
-    connect = await connectToTarget(
-      targetId,
-      process.env.E2E_SSH_USER,
-      process.env.E2E_SSH_KEY_PATH,
-    );
+    connect = await connectToTarget(targetId, sshUser, sshKeyPath);
     const sessionsPage = new SessionsPage(page);
     await sessionsPage.waitForSessionToBeVisible(targetName);
     await page
@@ -107,6 +102,14 @@ test('Verify session created to target with host, then cancel the session @ce @a
 
 test('Verify session created to target with address, then cancel the session @ce @aws @docker', async ({
   page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  sshUser,
+  sshKeyPath,
+  targetAddress,
+  targetPort,
 }) => {
   await page.goto('/');
   let orgId;
@@ -117,25 +120,18 @@ test('Verify session created to target with address, then cancel the session @ce
     const projectsPage = new ProjectsPage(page);
     const projectName = await projectsPage.createProject();
     const targetsPage = new TargetsPage(page);
-    const targetName = await targetsPage.createTargetWithAddress(
-      process.env.E2E_TARGET_ADDRESS,
-      process.env.E2E_TARGET_PORT,
-    );
+    const targetName = await targetsPage.createTargetWithAddress(targetAddress, targetPort);
 
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     orgId = await getOrgIdFromNameCli(orgName);
     const projectId = await getProjectIdFromNameCli(orgId, projectName);
     const targetId = await getTargetIdFromNameCli(projectId, targetName);
-    connect = await connectToTarget(
-      targetId,
-      process.env.E2E_SSH_USER,
-      process.env.E2E_SSH_KEY_PATH,
-    );
+    connect = await connectToTarget(targetId, sshUser, sshKeyPath);
     const sessionsPage = new SessionsPage(page);
     await sessionsPage.waitForSessionToBeVisible(targetName);
     await page
@@ -154,7 +150,15 @@ test('Verify session created to target with address, then cancel the session @ce
   }
 });
 
-test('Verify TCP target is updated @ce @aws @docker', async ({ page }) => {
+test('Verify TCP target is updated @ce @aws @docker', async ({
+  page,
+  baseURL,
+  adminAuthMethodId,
+  adminLoginName,
+  adminPassword,
+  targetAddress,
+  targetPort,
+}) => {
   await page.goto('/');
   let orgName;
   try {
@@ -163,10 +167,7 @@ test('Verify TCP target is updated @ce @aws @docker', async ({ page }) => {
     const projectsPage = new ProjectsPage(page);
     await projectsPage.createProject();
     const targetsPage = new TargetsPage(page);
-    await targetsPage.createTargetWithAddress(
-      process.env.E2E_TARGET_ADDRESS,
-      process.env.E2E_TARGET_PORT,
-    );
+    await targetsPage.createTargetWithAddress(targetAddress, targetPort);
 
     // Update target
     await page.getByRole('button', { name: 'Edit Form' }).click();
@@ -187,10 +188,10 @@ test('Verify TCP target is updated @ce @aws @docker', async ({ page }) => {
     await targetsPage.addEgressWorkerFilterToTarget('"dev" in "/tags/type"');
   } finally {
     await authenticateBoundaryCli(
-      process.env.BOUNDARY_ADDR,
-      process.env.E2E_PASSWORD_AUTH_METHOD_ID,
-      process.env.E2E_PASSWORD_ADMIN_LOGIN_NAME,
-      process.env.E2E_PASSWORD_ADMIN_PASSWORD,
+      baseURL,
+      adminAuthMethodId,
+      adminLoginName,
+      adminPassword,
     );
     const orgId = await getOrgIdFromNameCli(orgName);
     if (orgId) {

ui/admin/tests/e2e/tests/worker-ent.spec.mjs

@@ -3,7 +3,8 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 
 import { authenticatedState } from '../global-setup.mjs';
 

ui/admin/tests/e2e/tests/worker.spec.mjs

@@ -3,7 +3,8 @@
  * SPDX-License-Identifier: BUSL-1.1
  */
 
-import { test, expect } from '@playwright/test';
+import { test } from '../playwright.config.mjs'
+import { expect } from '@playwright/test';
 
 import { authenticatedState } from '../global-setup.mjs';