code refactor

Author: thiyaguk09

handwritten/storage/conformance-test/conformanceCommon.ts

@@ -106,7 +106,7 @@ export function executeScenario(testCase: RetryTestCase) {
 
         describe(`${storageMethodString}`, async () => {
           beforeEach(async () => {
-            const rawStorageTransport = new StorageTransport({
+            const rawTransport = new StorageTransport({
               apiEndpoint: TESTBENCH_HOST,
               authClient: authClient,
               keyFilename: SERVICE_ACCOUNT,
@@ -131,65 +131,14 @@ export function executeScenario(testCase: RetryTestCase) {
             creationResult = await createTestBenchRetryTest(
               instructionSet.instructions,
               jsonMethod?.name.toString(),
-              rawStorageTransport,
+              rawTransport,
             );
-            if (!creationResult || !creationResult.id) {
-              throw new Error('Failed to get a valid test ID from test bench.');
-            }
-
-            /* // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const internalGaxios = (storageTransport as any).authClient
-              ?.gaxiosInstance;
-
-            if (internalGaxios) {
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              internalGaxios.interceptors.request.use((config: any) => {
-                config.headers = config.headers || {};
-                config.headers['x-retry-test-id'] = creationResult.id;
-                return config;
-              });
-            } */
 
             // Create a Proxy around rawStorageTransport to intercept makeRequest
-            storageTransport = new Proxy(rawStorageTransport, {
-              get(target, prop, receiver) {
-                if (prop === 'makeRequest') {
-                  return async <T>(
-                    reqOpts: StorageRequestOptions,
-                    callback?: StorageTransportCallback<T>,
-                  ): Promise<void | T> => {
-                    const config = reqOpts;
-                    config.headers = config.headers || {};
-
-                    if (creationResult && creationResult.id) {
-                      const retryId = creationResult.id;
-                      if (config.headers instanceof Headers) {
-                        config.headers.set('x-retry-test-id', retryId);
-                      } else if (
-                        typeof config.headers === 'object' &&
-                        config.headers !== null &&
-                        !Array.isArray(config.headers)
-                      ) {
-                        config.headers = {
-                          ...(config.headers as {
-                            [key: string]: string | string[];
-                          }),
-                          'x-retry-test-id': retryId,
-                        };
-                      } else {
-                        config.headers = {'x-retry-test-id': retryId};
-                      }
-                    }
-                    return Reflect.apply(
-                      rawStorageTransport.makeRequest,
-                      rawStorageTransport,
-                      [config, callback],
-                    );
-                  };
-                }
-                return Reflect.get(target, prop, receiver);
-              },
-            });
+            storageTransport = createRetryProxy(
+              rawTransport,
+              creationResult.id,
+            );
 
             storage = new Storage({
               apiEndpoint: TESTBENCH_HOST,
@@ -222,12 +171,12 @@ export function executeScenario(testCase: RetryTestCase) {
 
           it(`${instructionNumber}`, async () => {
             const methodParameters: libraryMethods.ConformanceTestOptions = {
-              storage: storage,
-              bucket: bucket,
-              file: file,
-              storageTransport: storageTransport,
-              notification: notification,
-              hmacKey: hmacKey,
+              storage,
+              bucket,
+              file,
+              storageTransport,
+              notification,
+              hmacKey,
               projectId: CONF_TEST_PROJECT_ID,
               preconditionRequired: testCase.preconditionProvided,
             };
@@ -251,85 +200,104 @@ export function executeScenario(testCase: RetryTestCase) {
   }
 }
 
+/**
+ * Creates a Proxy to automatically inject x-retry-test-id into all requests
+ */
+function createRetryProxy(
+  transport: StorageTransport,
+  retryId: string,
+): StorageTransport {
+  return new Proxy(transport, {
+    get(target, prop, receiver) {
+      const original = Reflect.get(target, prop, receiver);
+      if (prop === 'makeRequest' && typeof original === 'function') {
+        return async (
+          reqOpts: StorageRequestOptions,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          callback?: StorageTransportCallback<any>,
+        ) => {
+          reqOpts.headers = reqOpts.headers || {};
+
+          if (reqOpts.headers instanceof Headers) {
+            reqOpts.headers.set('x-retry-test-id', retryId);
+          } else {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (reqOpts.headers as any)['x-retry-test-id'] = retryId;
+          }
+
+          return original.apply(target, [reqOpts, callback]);
+        };
+      }
+      return original;
+    },
+  });
+}
+
 async function createBucketForTest(
   storage: Storage,
-  preconditionShouldBeOnInstance: boolean,
-  storageMethodString: String,
+  withPrecondition: boolean,
+  method: String,
 ) {
-  const name = generateName(storageMethodString, 'bucket');
-  const bucket = storage.bucket(name);
-  await bucket.create();
+  const bucket = storage.bucket(generateName(method, 'bucket'));
+  const [metadata] = await bucket.create();
   await bucket.setRetentionPeriod(DURATION_SECONDS);
-
-  if (preconditionShouldBeOnInstance) {
+  if (withPrecondition) {
     return new Bucket(storage, bucket.name, {
       preconditionOpts: {
-        ifMetagenerationMatch: 2,
+        ifMetagenerationMatch: metadata.metageneration,
       },
     });
   }
   return bucket;
 }
 
 async function createFileForTest(
-  preconditionShouldBeOnInstance: boolean,
-  storageMethodString: String,
+  withPrecondition: boolean,
+  method: String,
   bucket: Bucket,
 ) {
-  const name = generateName(storageMethodString, 'file');
-  const file = bucket.file(name);
-  await file.save(name);
-  if (preconditionShouldBeOnInstance) {
-    await file.getMetadata();
+  const file = bucket.file(generateName(method, 'file'));
+  await file.save('test-content');
+  if (withPrecondition) {
+    const [metadata] = await file.getMetadata();
     return new File(bucket, file.name, {
       preconditionOpts: {
-        ifMetagenerationMatch: file.metadata.metageneration,
-        ifGenerationMatch: file.metadata.generation,
+        ifMetagenerationMatch: metadata.metageneration,
+        ifGenerationMatch: metadata.generation,
       },
     });
   }
   return file;
 }
 
-function generateName(storageMethodString: String, bucketOrFile: string) {
-  return `${TESTS_PREFIX}${storageMethodString.toLowerCase()}${bucketOrFile}.${shortUUID()}`;
-}
-
 async function createTestBenchRetryTest(
   instructions: String[],
   methodName: string,
-  storageTransport: StorageTransport,
+  transport: StorageTransport,
 ): Promise<ConformanceTestCreationResult> {
-  const requestBody = {instructions: {[methodName]: instructions}};
-
-  const requestOptions: StorageRequestOptions = {
+  return (await transport.makeRequest({
     method: 'POST',
     url: 'retry_test',
-    body: JSON.stringify(requestBody),
+    body: JSON.stringify({instructions: {[methodName]: instructions}}),
     headers: {'Content-Type': 'application/json'},
-    timeout: 10000,
-  };
-
-  const response = await storageTransport.makeRequest(requestOptions);
-  return response as unknown as ConformanceTestCreationResult;
+  })) as ConformanceTestCreationResult;
 }
 
 async function getTestBenchRetryTest(
   testId: string,
-  storageTransport: StorageTransport,
+  transport: StorageTransport,
 ): Promise<ConformanceTestResult> {
-  const requestOptions: StorageRequestOptions = {
+  return (await transport.makeRequest({
     url: `retry_test/${testId}`,
     method: 'GET',
-    retry: true,
-    headers: {
-      'x-retry-test-id': testId,
-    },
-  };
-  const response = await storageTransport.makeRequest(requestOptions);
-  return response as unknown as ConformanceTestResult;
+    headers: {'x-retry-test-id': testId},
+  })) as ConformanceTestResult;
+}
+
+function generateName(method: String, type: string) {
+  return `${TESTS_PREFIX}${method.toLowerCase()}${type}.${shortUUID()}`;
 }
 
 function shortUUID() {
-  return uuid.v1().split('-').shift();
+  return uuid.v4().split('-').shift();
 }