Refactor saveIdentityInformation to maintain a list of identities

Replace the three scalar World keys (identityNameForScenario,
identityTypeForScenario, accountNameForScenario) with a typed
SavedIdentity[] array. This makes multiple identities naturally
queryable and eliminates manual additionalAccountNames tracking.

- Add SavedIdentity interface and getSavedIdentities/getSavedIdentity helpers
- saveIdentityInformation now appends to the array
- useSavedIdentity uses getSavedIdentity() (defaults to last entry)
- Migrate direct getSaved reads in bucket-policies and iam-policies
- Simplify "{int} additional accounts" step
- Drop additional accounts After cleanup hook

Issue: ZENKO-5202

Author: delthas

tests/ctst/common/common.ts

@@ -107,12 +107,9 @@ async function getTopicsOffsets(topics: string[], kafkaAdmin: Admin) {
 }
 
 Given('{int} additional accounts', async function (this: Zenko, count: number) {
-    const accountNames: string[] = [];
     for (let i = 0; i < count; i++) {
-        const name = await this.createAccount();
-        accountNames.push(name);
+        await this.createAccount();
     }
-    this.addToSaved('additionalAccountNames', accountNames);
 });
 
 async function createBucket(world: Zenko, versioning: string, bucketName: string) {

tests/ctst/common/hooks.ts

@@ -104,16 +104,6 @@ After({ tags: '@AzureArchive' }, async function (this: Zenko) {
     );
 });
 
-After(async function (this: Zenko, results) {
-    const additionalAccountNames = this.getSaved<string[]>('additionalAccountNames');
-    if (results.result?.status === 'FAILED' || !additionalAccountNames) {
-        return;
-    }
-    for (const accountName of additionalAccountNames) {
-        await cleanupAccount(this, accountName);
-    }
-});
-
 After({ tags: '@BP-ASSUME_ROLE_USER_CROSS_ACCOUNT'}, async function (this: Zenko, results) {
     const crossAccountName = this.getSaved<string>('crossAccountName');
 

tests/ctst/steps/bucket-policies/common.ts

@@ -152,14 +152,14 @@ Given('an {string} IAM Policy that {string} with {string} effect for the current
         || identityType === EntityType.DATA_CONSUMER) {
         const result = await IAM.attachRolePolicy({
             policyArn,
-            roleName: this.getSaved<string>('identityNameForScenario'),
+            roleName: this.getSavedIdentity().identityName,
         });
         assert.ifError(result.stderr || result.err);
     }
     if (identityType === EntityType.IAM_USER) {
         const result = await IAM.attachUserPolicy({
             policyArn,
-            userName: this.getSaved<string>('identityNameForScenario'),
+            userName: this.getSavedIdentity().identityName,
         });
         assert.ifError(result.stderr || result.err);
     }
@@ -361,13 +361,13 @@ Given('an environment setup for the API', async function (this: Zenko) {
         || identityType === EntityType.DATA_CONSUMER) {
         const result = await IAM.attachRolePolicy({
             policyArn,
-            roleName: this.getSaved<string>('identityNameForScenario'),
+            roleName: this.getSavedIdentity().identityName,
         });
         assert.ifError(result.stderr || result.err);
     } else if (identityType === EntityType.IAM_USER) { // accounts do not have any policy
         const result = await IAM.attachUserPolicy({
             policyArn,
-            userName: this.getSaved<string>('identityNameForScenario'),
+            userName: this.getSavedIdentity().identityName,
         });
         assert.ifError(result.stderr || result.err);
     }
@@ -434,13 +434,13 @@ Given('an environment setup for the API', async function (this: Zenko) {
         || identityType === EntityType.DATA_CONSUMER) {
         const result = await IAM.detachRolePolicy({
             policyArn,
-            roleName: this.getSaved<string>('identityNameForScenario'),
+            roleName: this.getSavedIdentity().identityName,
         });
         assert.ifError(result.stderr || result.err);
     } else if (identityType === EntityType.IAM_USER) { // accounts do not have any policy
         const detachResult = await IAM.detachUserPolicy({
             policyArn,
-            userName: this.getSaved<string>('identityNameForScenario'),
+            userName: this.getSavedIdentity().identityName,
         });
         assert.ifError(detachResult.stderr || detachResult.err);
     }

tests/ctst/steps/iam-policies/common.ts

@@ -1,18 +1,19 @@
 import { When, Then } from '@cucumber/cucumber';
 import { strict as assert } from 'assert';
 import Zenko from '../../world/Zenko';
-import { CacheHelper, ClientOptions, Command, Identity, IdentityEnum, VaultAuth } from 'cli-testing';
+import { CacheHelper, ClientOptions, Command, Identity, VaultAuth } from 'cli-testing';
 import { runActionAgainstBucket } from 'steps/utils/utils';
 
 When('the user tries to perform {string} on the bucket', async function (this: Zenko, action: string) {
     await runActionAgainstBucket(this, action);
 });
 
 When('the user tries to perform vault auth {string}', async function (this: Zenko, action: string) {
+    const lastIdentity = this.getSavedIdentity();
     const userCredentials = Identity.getCredentialsForIdentity(
-        this.getSaved<IdentityEnum>('identityTypeForScenario'),
-        this.getSaved<string>('identityNameForScenario'),
-        this.getSaved<string>('accountNameForScenario'),
+        lastIdentity.identityType,
+        lastIdentity.identityName,
+        lastIdentity.accountName,
     );
 
     if (!userCredentials) {
@@ -35,7 +36,7 @@ When('the user tries to perform vault auth {string}', async function (this: Zenk
     switch (action) {
     case 'GetAccountInfo':
         this.setResult(await VaultAuth.getAccounts([
-            this.getSaved<string>('accountNameForScenario') || this.parameters.AccountName,
+            lastIdentity.accountName || this.parameters.AccountName,
         ], null, null, {
             // @ts-expect-error accountNames is not generated by CTST yet
             accountNames: true,

tests/ctst/steps/reporting/storageUsageReporting.ts

@@ -1,6 +1,7 @@
 import { When, Then, ITestCaseHookParameter } from '@cucumber/cucumber';
 import { strict as assert } from 'assert';
 import Zenko from '../../world/Zenko';
+import { IdentityEnum } from 'cli-testing';
 import { prepareMetricsScenarios } from '../../common/utils';
 
 interface LocationUsage {
@@ -71,7 +72,9 @@ Then('the storage usage report contains the additional accounts',
     async function (this: Zenko) {
         const response = this.getSaved<{ statusCode: number; data: ReportingUsageResponse }>(
             'reportingResponse');
-        const accountNames = this.getSaved<string[]>('additionalAccountNames');
+        const accountNames = this.getSavedIdentities()
+            .filter(id => id.identityType === IdentityEnum.ACCOUNT)
+            .map(id => id.accountName);
         for (const accountName of accountNames) {
             assert.ok(accountName in response.data.accounts,
                 `Account ${accountName} should be present in the report`);

tests/ctst/world/Zenko.ts

@@ -32,6 +32,12 @@ interface ServiceUsersCredentials {
 }
 
 // Zenko entities
+export interface SavedIdentity {
+    identityName: string;
+    identityType: IdentityEnum;
+    accountName: string;
+}
+
 export enum EntityType {
     ACCOUNT = 'ACCOUNT',
     IAM_USER = 'IAM_USER',
@@ -770,17 +776,24 @@ export default class Zenko extends World<ZenkoWorldParameters> {
     }
 
     saveIdentityInformation(name: string, identity: IdentityEnum, accountName: string) {
-        this.addToSaved('identityNameForScenario', name);
-        this.addToSaved('identityTypeForScenario', identity);
-        this.addToSaved('accountNameForScenario', accountName);
+        const identities = this.getSavedIdentities();
+        identities.push({ identityName: name, identityType: identity, accountName });
+        this.addToSaved('savedIdentities', identities);
+    }
+
+    getSavedIdentities(): SavedIdentity[] {
+        return this.getSaved<SavedIdentity[]>('savedIdentities') || [];
+    }
+
+    getSavedIdentity(index = -1): SavedIdentity {
+        const identities = this.getSavedIdentities();
+        const i = index < 0 ? identities.length + index : index;
+        return identities[i];
     }
 
     useSavedIdentity() {
-        Identity.useIdentity(
-            this.getSaved<IdentityEnum>('identityTypeForScenario'),
-            this.getSaved<string>('identityNameForScenario'),
-            this.getSaved<string>('accountNameForScenario'),
-        );
+        const last = this.getSavedIdentity();
+        Identity.useIdentity(last.identityType, last.identityName, last.accountName);
     }
 
     /**