fix lint

tests/ctst/common/common.ts

@@ -237,8 +237,7 @@ When('i restore object {string} for {int} days', async function (this: Zenko, ob
 });
 
 // wait for object to transition to a location or get restored from it
-Then('object {string} should be {string} and have the storage class {string}', { timeout: 130000 }, verifyObjectLocation
-    );
+Then('object {string} should be {string} and have the storage class {string}', { timeout: 130000 }, verifyObjectLocation);
 
 When('i delete object {string}', async function (this: Zenko, objectName: string) {
     const objName = getObjectNameWithBackendFlakiness.call(this, objectName) || this.getSaved<string>('objectName');

tests/ctst/steps/pra.ts

@@ -11,10 +11,6 @@ export function preparePRA(world: Zenko) {
     world.zenkoDrCtl = new ZenkoDrctl(world);
 }
 
-export function teardownPRA(world: Zenko) {
-    // in case of error
-}
-
 export async function displayDebuggingInformation(world: Zenko) {
     await displayCRStatus(world);
     await displayDRSinkStatus(world);
@@ -41,11 +37,12 @@ Given('a DR installed', { timeout: 130000 }, async function (this: Zenko) {
 
 Then('object {string} should be {string} and have the storage class {string} on {string} site',
     async function (this: Zenko, objName: string, objectTransitionStatus: string, storageClass: string, site: string) {
-    this.resetCommand();
-    if (site === 'DR')
-        this.useSite("sink");
-    else
-        this.useSite("source");
+        this.resetCommand();
+        if (site === 'DR') {
+            this.useSite('sink');
+        } else {
+            this.useSite('source');
+        }
 
-    await verifyObjectLocation.call(this, objName, objectTransitionStatus, storageClass);
+        await verifyObjectLocation.call(this, objName, objectTransitionStatus, storageClass);
 });

tests/ctst/steps/utils/utils.ts

@@ -9,7 +9,7 @@ import {
     AWSVersionObject,
     Command,
 } from 'cli-testing';
-import { extractPropertyFromResults, s3FunctionExtraParams } from 'common/utils';
+import { extractPropertyFromResults, s3FunctionExtraParams, safeJsonParse } from 'common/utils';
 import Zenko from 'world/Zenko';
 import assert from 'assert';
 
@@ -253,47 +253,48 @@ async function emptyVersionedBucket(world: Zenko) {
     }));
 }
 
-async function verifyObjectLocation(this: Zenko, objectName: string, objectTransitionStatus: string, storageClass: string) {
-    const objName =
-        getObjectNameWithBackendFlakiness.call(this, objectName) || this.getSaved<string>('objectName');
-    this.resetCommand();
-    this.addCommandParameter({ bucket: this.getSaved<string>('bucketName') });
-    this.addCommandParameter({ key: objName });
-    const versionId = this.getSaved<Map<string, string>>('createdObjects')?.get(objName);
-    if (versionId) {
-        this.addCommandParameter({ versionId });
-    }
-    let conditionOk = false;
-    while (!conditionOk) {
-        const res = await S3.headObject(this.getCommandParameters());
-        if (res.err) {
-            break;
-        }
-        assert(res.stdout);
-        const parsed = safeJsonParse(res.stdout);
-        assert(parsed.ok);
-        const head = parsed.result as {
-            StorageClass: string | undefined,
-            Restore: string | undefined,
-        };
-        const expectedClass = storageClass !== '' ? storageClass : undefined;
-        if (head?.StorageClass === expectedClass) {
-            conditionOk = true;
+async function verifyObjectLocation(this: Zenko, objectName: string,
+    objectTransitionStatus: string, storageClass: string) {
+        const objName =
+            getObjectNameWithBackendFlakiness.call(this, objectName) || this.getSaved<string>('objectName');
+        this.resetCommand();
+        this.addCommandParameter({ bucket: this.getSaved<string>('bucketName') });
+        this.addCommandParameter({ key: objName });
+        const versionId = this.getSaved<Map<string, string>>('createdObjects')?.get(objName);
+        if (versionId) {
+            this.addCommandParameter({ versionId });
         }
-        if (objectTransitionStatus == 'restored') {
-            const isRestored = !!head?.Restore &&
-                head.Restore.includes('ongoing-request="false", expiry-date=');
-            // if restore didn't get initiated fail immediately
-            const isPendingRestore = !!head?.Restore &&
-                head.Restore.includes('ongoing-request="true"');
-            assert(isRestored || isPendingRestore, 'Restore didn\'t get initiated');
-            conditionOk = conditionOk && isRestored;
-        } else if (objectTransitionStatus == 'cold') {
-            conditionOk = conditionOk && !head?.Restore;
+        let conditionOk = false;
+        while (!conditionOk) {
+            const res = await S3.headObject(this.getCommandParameters());
+            if (res.err) {
+                break;
+            }
+            assert(res.stdout);
+            const parsed = safeJsonParse(res.stdout);
+            assert(parsed.ok);
+            const head = parsed.result as {
+                StorageClass: string | undefined,
+                Restore: string | undefined,
+            };
+            const expectedClass = storageClass !== '' ? storageClass : undefined;
+            if (head?.StorageClass === expectedClass) {
+                conditionOk = true;
+            }
+            if (objectTransitionStatus == 'restored') {
+                const isRestored = !!head?.Restore &&
+                    head.Restore.includes('ongoing-request="false", expiry-date=');
+                // if restore didn't get initiated fail immediately
+                const isPendingRestore = !!head?.Restore &&
+                    head.Restore.includes('ongoing-request="true"');
+                assert(isRestored || isPendingRestore, 'Restore didn\'t get initiated');
+                conditionOk = conditionOk && isRestored;
+            } else if (objectTransitionStatus == 'cold') {
+                conditionOk = conditionOk && !head?.Restore;
+            }
+            await Utils.sleep(1000);
         }
-        await Utils.sleep(1000);
-    }
-    assert(conditionOk);
+        assert(conditionOk);
 }
 
 /**

tests/ctst/world/Zenko.ts

@@ -150,22 +150,22 @@ export default class Zenko extends World<ZenkoWorldParameters> {
                 accessKeyId: this.parameters.AdminAccessKey,
                 secretAccessKey: this.parameters.AdminSecretKey,
             });
-            this.sites["source"] = {
+            this.sites['source'] = {
                 subdomain: this.parameters.DRSubdomain,
                 identityName: 'admin',
             };
         }
 
         if (this.parameters.DRAdminAccessKey && this.parameters.DRAdminSecretKey && this.parameters.DRSubdomain && 
             !Identity.hasIdentity(IdentityEnum.ADMIN, 'dradmin')) {
-            this.sites["sink"] = {
-                subdomain: this.parameters.DRSubdomain,
-                identityName: 'dradmin',
-            };
             Identity.addIdentity(IdentityEnum.ADMIN, 'dradmin', {
                 accessKeyId: this.parameters.DRAdminAccessKey,
                 secretAccessKey: this.parameters.DRAdminSecretKey,
             });
+            this.sites['sink'] = {
+                subdomain: this.parameters.DRSubdomain,
+                identityName: 'dradmin',
+            };
         }
     }