diff --git a/handwritten/storage/src/acl.ts b/handwritten/storage/src/acl.ts
index 13f019a626f..08c4c237c96 100644
--- a/handwritten/storage/src/acl.ts
+++ b/handwritten/storage/src/acl.ts
@@ -528,10 +528,10 @@ class Acl extends AclRoleAccessorMethods {
     if (this.parent instanceof File) {
       const file = this.parent as File;
       const bucket = file.parent;
-      url = `${bucket.baseUrl}/${bucket.name}/${file.baseUrl}/${file.name}${url}`;
+      url = `/storage/v1/b/${bucket.name}/o/${encodeURIComponent(file.name)}${url}`;
     } else if (this.parent instanceof Bucket) {
       const bucket = this.parent as Bucket;
-      url = `${bucket.baseUrl}/${bucket.name}${url}`;
+      url = `/storage/v1/b/${bucket.name}${url}`;
     }
 
     this.storageTransport
@@ -644,14 +644,14 @@ class Acl extends AclRoleAccessorMethods {
       query.userProject = options.userProject;
     }
 
-    let url = `${this.pathPrefix}/${options.entity}`;
+    let url = `${this.pathPrefix}/${encodeURIComponent(options.entity)}`;
     if (this.parent instanceof File) {
       const file = this.parent as File;
       const bucket = file.parent;
-      url = `${bucket.baseUrl}/${bucket.name}/${file.baseUrl}/${file.name}${url}`;
+      url = `/storage/v1/b/${bucket.name}/o/${encodeURIComponent(file.name)}${url}`;
     } else if (this.parent instanceof Bucket) {
       const bucket = this.parent as Bucket;
-      url = `${bucket.baseUrl}/${bucket.name}${url}`;
+      url = `/storage/v1/b/${bucket.name}${url}`;
     }
 
     this.storageTransport
@@ -768,7 +768,7 @@ class Acl extends AclRoleAccessorMethods {
 
     let url = `${this.pathPrefix}`;
     if (options) {
-      url = `${url}/${options.entity}`;
+      url = `${url}/${encodeURIComponent(options.entity)}`;
       if (options.generation) {
         query.generation = options.generation;
       }
@@ -781,10 +781,10 @@ class Acl extends AclRoleAccessorMethods {
     if (this.parent instanceof File) {
       const file = this.parent as File;
       const bucket = file.parent;
-      url = `${bucket.baseUrl}/${bucket.name}/${file.baseUrl}/${file.name}${url}`;
+      url = `/storage/v1/b/${bucket.name}/o/${encodeURIComponent(file.name)}${url}`;
     } else if (this.parent instanceof Bucket) {
       const bucket = this.parent as Bucket;
-      url = `${bucket.baseUrl}/${bucket.name}${url}`;
+      url = `/storage/v1/b/${bucket.name}${url}`;
     }
 
     this.storageTransport
@@ -888,14 +888,14 @@ class Acl extends AclRoleAccessorMethods {
       query.userProject = options.userProject;
     }
 
-    let url = `${this.pathPrefix}/${options.entity}`;
+    let url = `${this.pathPrefix}/${encodeURIComponent(options.entity)}`;
     if (this.parent instanceof File) {
       const file = this.parent as File;
       const bucket = file.parent;
-      url = `${bucket.baseUrl}/${bucket.name}/${file.baseUrl}/${file.name}${url}`;
+      url = `/storage/v1/b/${bucket.name}/o/${encodeURIComponent(file.name)}${url}`;
     } else if (this.parent instanceof Bucket) {
       const bucket = this.parent as Bucket;
-      url = `${bucket.baseUrl}/${bucket.name}${url}`;
+      url = `/storage/v1/b/${bucket.name}${url}`;
     }
 
     this.storageTransport
diff --git a/handwritten/storage/src/bucket.ts b/handwritten/storage/src/bucket.ts
index ae71afbd197..22db62d6a25 100644
--- a/handwritten/storage/src/bucket.ts
+++ b/handwritten/storage/src/bucket.ts
@@ -1232,7 +1232,7 @@ class Bucket extends ServiceObject<Bucket, BucketMetadata> {
     super({
       storageTransport: storage.storageTransport,
       parent: storage,
-      baseUrl: '/b',
+      baseUrl: '/storage/v1/b',
       id: name,
       createMethod: storage.createBucket.bind(storage),
       methods,
@@ -1688,7 +1688,7 @@ class Bucket extends ServiceObject<Bucket, BucketMetadata> {
       .makeRequest(
         {
           method: 'POST',
-          url: '/compose',
+          url: `/storage/v1/b/${this.name}/o/${encodeURIComponent(destinationFile.name)}/compose`,
           maxRetries,
           body: JSON.stringify({
             destination: {
@@ -1709,6 +1709,9 @@ class Bucket extends ServiceObject<Bucket, BucketMetadata> {
               return sourceObject;
             }),
           }),
+          headers: {
+            'Content-Type': 'application/json',
+          },
           queryParameters: options as unknown as StorageQueryParameters,
         },
         (err, resp) => {
@@ -2050,6 +2053,9 @@ class Bucket extends ServiceObject<Bucket, BucketMetadata> {
           body: JSON.stringify(convertObjKeysToSnakeCase(body)),
           queryParameters: query as unknown as StorageQueryParameters,
           retry: false,
+          headers: {
+            'Content-Type': 'application/json',
+          },
         },
         (err, data, resp) => {
           if (err) {
diff --git a/handwritten/storage/src/channel.ts b/handwritten/storage/src/channel.ts
index cd3251bc163..edf74e686b3 100644
--- a/handwritten/storage/src/channel.ts
+++ b/handwritten/storage/src/channel.ts
@@ -43,7 +43,7 @@ class Channel extends ServiceObject<Channel, BaseMetadata> {
     const config = {
       parent: storage,
       storageTransport: storage.storageTransport,
-      baseUrl: '/channels',
+      baseUrl: '/storage/v1/channels',
       id: '',
       methods: {},
     };
@@ -89,6 +89,9 @@ class Channel extends ServiceObject<Channel, BaseMetadata> {
           method: 'POST',
           url: `${this.baseUrl}/stop`,
           body: JSON.stringify(this.metadata),
+          headers: {
+            'Content-Type': 'application/json',
+          },
           responseType: 'json',
         },
         (err, data, resp) => {
diff --git a/handwritten/storage/src/file.ts b/handwritten/storage/src/file.ts
index f1edc193204..39c98294956 100644
--- a/handwritten/storage/src/file.ts
+++ b/handwritten/storage/src/file.ts
@@ -81,7 +81,6 @@ import {
   StorageQueryParameters,
   StorageRequestOptions,
 } from './storage-transport.js';
-import * as gaxios from 'gaxios';
 import mime from 'mime';
 
 export type GetExpirationDateResponse = [Date];
@@ -1363,13 +1362,24 @@ class File extends ServiceObject<File, FileMetadata> {
     }
 
     if (newFile.encryptionKey !== undefined) {
-      this.setEncryptionKey(newFile.encryptionKey!);
+      headers.set('x-goog-encryption-algorithm', 'AES256');
+      headers.set(
+        'x-goog-encryption-key',
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (newFile as any).encryptionKeyBase64 || '',
+      );
+      headers.set(
+        'x-goog-encryption-key-sha256',
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (newFile as any).encryptionKeyHash || '',
+      );
     } else if (options.destinationKmsKeyName !== undefined) {
       query.destinationKmsKeyName = options.destinationKmsKeyName;
       delete options.destinationKmsKeyName;
     } else if (newFile.kmsKeyName !== undefined) {
       query.destinationKmsKeyName = newFile.kmsKeyName;
     }
+    headers.set('Content-Type', 'application/json');
 
     if (query.destinationKmsKeyName) {
       this.kmsKeyName = query.destinationKmsKeyName;
@@ -1399,7 +1409,7 @@ class File extends ServiceObject<File, FileMetadata> {
       .makeRequest<RewriteResponse>(
         {
           method: 'POST',
-          url: `/b/${this.bucket.name}/o/${encodeURIComponent(this.name)}/rewriteTo/b/${
+          url: `/storage/v1/b/${this.bucket.name}/o/${encodeURIComponent(this.name)}/rewriteTo/b/${
             destBucket.name
           }/o/${encodeURIComponent(newFile.name)}`,
           queryParameters: query as unknown as StorageQueryParameters,
@@ -1596,6 +1606,8 @@ class File extends ServiceObject<File, FileMetadata> {
       }
 
       const headers = response.headers;
+      const isStoredCompressed =
+        headers.get('x-goog-stored-content-encoding') === 'gzip';
       const isCompressed = headers.get('content-encoding') === 'gzip';
       const hashes: {crc32c?: string; md5?: string} = {};
 
@@ -1609,7 +1621,7 @@ class File extends ServiceObject<File, FileMetadata> {
 
       const transformStreams: Transform[] = [];
 
-      if (shouldRunValidation) {
+      if (shouldRunValidation && !isStoredCompressed) {
         // The x-goog-hash header should be set with a crc32c and md5 hash.
         // ex: headers.set('x-goog-hash', 'crc32c=xxxx,md5=xxxx')
         if (typeof headers.get('x-goog-hash') === 'string') {
@@ -1678,8 +1690,13 @@ class File extends ServiceObject<File, FileMetadata> {
       const headers = {
         'Accept-Encoding': 'gzip',
         'Cache-Control': 'no-store',
+        ...(this.encryptionKeyHeaders || {}),
       } as Headers;
 
+      if (options.decompress === false) {
+        headers['Accept-Encoding'] = 'gzip';
+      }
+
       if (rangeRequest) {
         const start = typeof options.start === 'number' ? options.start : '0';
         const end = typeof options.end === 'number' ? options.end : '';
@@ -1688,11 +1705,13 @@ class File extends ServiceObject<File, FileMetadata> {
       }
 
       const reqOpts: StorageRequestOptions = {
-        url: `${this.bucket.baseUrl}/${this.bucket.name}${this.baseUrl}/${this.name}`,
+        url: `/storage/v1/b/${this.bucket.name}/o/${encodeURIComponent(this.name)}`,
         headers,
         queryParameters: query as unknown as StorageQueryParameters,
         responseType: 'stream',
-      };
+        decompress: options.decompress,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      } as any;
 
       if (options[GCCL_GCS_CMD_KEY]) {
         reqOpts[GCCL_GCS_CMD_KEY] = options[GCCL_GCS_CMD_KEY];
@@ -2368,6 +2387,18 @@ class File extends ServiceObject<File, FileMetadata> {
     }
   }
 
+  get encryptionKeyHeaders(): Record<string, string> | undefined {
+    if (!this.encryptionKey) {
+      return undefined;
+    }
+
+    return {
+      'x-goog-encryption-algorithm': 'AES256',
+      'x-goog-encryption-key': this.encryptionKey.toString('base64'),
+      'x-goog-encryption-key-sha256': this.encryptionKeyHash!,
+    };
+  }
+
   /**
    * The Storage API allows you to use a custom key for server-side encryption.
    *
@@ -3252,39 +3283,35 @@ class File extends ServiceObject<File, FileMetadata> {
    */
 
   isPublic(callback?: IsPublicCallback): Promise<IsPublicResponse> | void {
-    // Build any custom headers based on the defined interceptors on the parent
-    // storage object and this object
-    const storageInterceptors = this.storage?.interceptors || [];
-    const fileInterceptors = this.interceptors || [];
-    const allInterceptors = storageInterceptors.concat(fileInterceptors);
-
-    for (const curInter of allInterceptors) {
-      gaxios.instance.interceptors.request.add(curInter);
-    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const {callback: cb} = normalize<any, IsPublicCallback>(
+      undefined,
+      callback,
+    );
+
+    const url = `/${this.bucket.name}/${encodeURIComponent(this.name)}`;
+    this.storageTransport
+      .makeRequest(
+        {
+          method: 'GET',
+          url: url,
+        },
+        err => {
+          if (!err) {
+            cb(null, true);
+            return;
+          }
+
+          const status = err.response?.status;
+          if (status === 401 || status === 403) {
+            cb(null, false);
+            return;
+          }
 
-    gaxios
-      .request({
-        method: 'GET',
-        url: `${this.storage.apiEndpoint}/${
-          this.bucket.name
-        }/${encodeURIComponent(this.name)}`,
-        retryConfig: {
-          retry: this.storage.retryOptions.maxRetries,
-          noResponseRetries: this.storage.retryOptions.maxRetries,
-          maxRetryDelay: this.storage.retryOptions.maxRetryDelay,
-          retryDelayMultiplier: this.storage.retryOptions.retryDelayMultiplier,
-          shouldRetry: this.storage.retryOptions.retryableErrorFn,
-          totalTimeout: this.storage.retryOptions.totalTimeout,
+          cb(err);
         },
-      })
-      .then(() => callback!(null, true))
-      .catch(err => {
-        if (err.status === 403) {
-          callback!(null, false);
-        } else {
-          callback!(err);
-        }
-      });
+      )
+      .catch(err => callback!(err));
   }
 
   makePrivate(
@@ -3630,7 +3657,7 @@ class File extends ServiceObject<File, FileMetadata> {
       .makeRequest(
         {
           method: 'POST',
-          url: `/b/${this.bucket.name}/o/${encodeURIComponent(this.name)}/moveTo/o/${encodeURIComponent(newFile.name)}`,
+          url: `/storage/v1/b/${this.bucket.name}/o/${encodeURIComponent(this.name)}/moveTo/o/${encodeURIComponent(newFile.name)}`,
           queryParameters: query as StorageQueryParameters,
           body: JSON.stringify(options),
         },
@@ -3961,7 +3988,7 @@ class File extends ServiceObject<File, FileMetadata> {
   async restore(options: RestoreOptions): Promise<File> {
     const file = await this.storageTransport.makeRequest<File>({
       method: 'POST',
-      url: `/b/${this.bucket.name}/o/${encodeURIComponent(this.name)}/restore`,
+      url: `/storage/v1/b/${this.bucket.name}/o/${encodeURIComponent(this.name)}/restore`,
       queryParameters: options as unknown as StorageQueryParameters,
     });
     return file as File;
@@ -4488,6 +4515,14 @@ class File extends ServiceObject<File, FileMetadata> {
       },
     ];
 
+    const headers: Record<string, string> = {};
+    if (this.encryptionKey) {
+      headers['x-goog-encryption-algorithm'] = 'AES256';
+      headers['x-goog-encryption-key'] = this.encryptionKeyBase64!;
+      headers['x-goog-encryption-key-sha256'] = this.encryptionKeyHash!;
+    }
+    reqOpts.headers = headers;
+
     this.storageTransport
       .makeRequest(reqOpts as StorageRequestOptions, (err, body, resp) => {
         if (err) {
diff --git a/handwritten/storage/src/iam.ts b/handwritten/storage/src/iam.ts
index 45d7f17c2d0..61d9f340a3d 100644
--- a/handwritten/storage/src/iam.ts
+++ b/handwritten/storage/src/iam.ts
@@ -141,11 +141,11 @@ export enum IAMExceptionMessages {
  * ```
  */
 class Iam {
-  private resourceId_: string;
+  private bucket: Bucket;
   private storageTransport: StorageTransport;
 
   constructor(bucket: Bucket) {
-    this.resourceId_ = 'buckets/' + bucket.getId();
+    this.bucket = bucket;
     this.storageTransport = bucket.storageTransport;
   }
 
@@ -261,7 +261,8 @@ class Iam {
     this.storageTransport
       .makeRequest(
         {
-          url: '/iam',
+          method: 'GET',
+          url: `/storage/v1/b/${this.bucket.name}/iam`,
           queryParameters: qs as unknown as StorageQueryParameters,
         },
         (err, data, resp) => {
@@ -358,16 +359,10 @@ class Iam {
       .makeRequest(
         {
           method: 'PUT',
-          url: '/iam',
+          url: `/storage/v1/b/${this.bucket.name}/iam`,
           maxRetries,
-          body: JSON.stringify(
-            Object.assign(
-              {
-                resourceId: this.resourceId_,
-              },
-              policy,
-            ),
-          ),
+          body: JSON.stringify(policy),
+          headers: {'Content-Type': 'application/json'},
           queryParameters: options as unknown as StorageQueryParameters,
         },
         (err, data, resp) => {
@@ -467,17 +462,18 @@ class Iam {
       ? permissions
       : [permissions];
 
-    const req = Object.assign(
-      {
-        permissions: permissionsArray,
-      },
-      options,
-    );
+    const req: any = {
+      permissions: permissionsArray,
+    };
+    if (options.userProject) {
+      req.userProject = options.userProject;
+    }
 
     this.storageTransport
       .makeRequest<TestPermissionsResponse>(
         {
-          url: '/iam/testPermissions',
+          method: 'GET',
+          url: `/storage/v1/b/${this.bucket.name}/iam/testPermissions`,
           queryParameters: req as unknown as StorageQueryParameters,
         },
         (err, data, resp) => {
diff --git a/handwritten/storage/src/nodejs-common/service-object.ts b/handwritten/storage/src/nodejs-common/service-object.ts
index 80ed207764d..f37e41a47b1 100644
--- a/handwritten/storage/src/nodejs-common/service-object.ts
+++ b/handwritten/storage/src/nodejs-common/service-object.ts
@@ -444,6 +444,20 @@ class ServiceObject<T, K extends BaseMetadata> extends EventEmitter {
       url = `${this.parent.baseUrl}/${this.parent.id}${url}`;
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const encryptionHeaders = (this as any).encryptionKeyHeaders || {};
+
+    const headers = {
+      ...encryptionHeaders,
+      ...methodConfig.reqOpts?.headers,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ...(options as any).headers,
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const query = {...options} as any;
+    delete query.headers;
+
     this.storageTransport
       .makeRequest<K>(
         {
@@ -451,9 +465,10 @@ class ServiceObject<T, K extends BaseMetadata> extends EventEmitter {
           responseType: 'json',
           url,
           ...methodConfig.reqOpts,
+          headers,
           queryParameters: {
             ...methodConfig.reqOpts?.queryParameters,
-            ...options,
+            ...query,
           },
         },
         (err, data, resp) => {
diff --git a/handwritten/storage/src/storage-transport.ts b/handwritten/storage/src/storage-transport.ts
index 43070a73ff5..d7fe49f62d4 100644
--- a/handwritten/storage/src/storage-transport.ts
+++ b/handwritten/storage/src/storage-transport.ts
@@ -25,13 +25,13 @@ import {
   getModuleFormat,
   getRuntimeTrackingString,
   getUserAgentString,
-} from './util';
+} from './util.js';
 import {randomUUID} from 'crypto';
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import {getPackageJSON} from './package-json-helper.cjs';
-import {GCCL_GCS_CMD_KEY} from './nodejs-common/util';
-import {RetryOptions} from './storage';
+import {GCCL_GCS_CMD_KEY} from './nodejs-common/util.js';
+import {RetryOptions} from './storage.js';
 
 export interface StandardStorageQueryParams {
   alt?: 'json' | 'media';
@@ -124,13 +124,19 @@ export class StorageTransport {
     reqOpts: StorageRequestOptions,
     callback?: StorageTransportCallback<T>,
   ): Promise<void | T> {
-    const headers = this.#buildRequestHeaders(reqOpts.headers);
+    const headersInstance = this.#buildRequestHeaders(reqOpts.headers);
     if (reqOpts[GCCL_GCS_CMD_KEY]) {
-      headers.set(
+      headersInstance.set(
         'x-goog-api-client',
-        `${headers.get('x-goog-api-client')} gccl-gcs-cmd/${reqOpts[GCCL_GCS_CMD_KEY]}`,
+        `${headersInstance.get('x-goog-api-client')} gccl-gcs-cmd/${reqOpts[GCCL_GCS_CMD_KEY]}`,
       );
     }
+
+    const headers: Record<string, string> = {};
+    headersInstance.forEach((value, key) => {
+      headers[key] = value;
+    });
+
     if (reqOpts.interceptors) {
       this.gaxiosInstance.interceptors.request.clear();
       for (const inter of reqOpts.interceptors) {
@@ -163,6 +169,8 @@ export class StorageTransport {
         headers,
         url: this.#buildUrl(reqOpts.url?.toString(), reqOpts.queryParameters),
         timeout: this.timeout,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ...({decompress: false} as any),
       });
 
       return callback
@@ -189,7 +197,7 @@ export class StorageTransport {
     if (this.#isValidUrl(pathUri)) {
       url = new URL(pathUri);
     } else {
-      url = new URL(`${this.baseUrl}${pathUri}`);
+      url = new URL(pathUri, this.baseUrl); // Safer construction
     }
     url.search = qp;
 
@@ -217,9 +225,18 @@ export class StorageTransport {
   }
 
   #buildRequestQueryParams(queryParameters: StorageQueryParameters): string {
-    const qp = new URLSearchParams(
-      queryParameters as unknown as Record<string, string>,
-    );
+    const qp = new URLSearchParams();
+
+    for (const [key, value] of Object.entries(queryParameters)) {
+      if (value === undefined) continue;
+
+      if (Array.isArray(value)) {
+        // This is the fix: append each item individually for repeated keys
+        value.forEach(item => qp.append(key, String(item)));
+      } else {
+        qp.set(key, String(value));
+      }
+    }
 
     return qp.toString();
   }
diff --git a/handwritten/storage/src/storage.ts b/handwritten/storage/src/storage.ts
index 55f20ed846c..9f058acfe29 100644
--- a/handwritten/storage/src/storage.ts
+++ b/handwritten/storage/src/storage.ts
@@ -1097,7 +1097,7 @@ export class Storage {
           method: 'POST',
           queryParameters: query,
           body: JSON.stringify(body),
-          url: '/b',
+          url: '/storage/v1/b',
           responseType: 'json',
           headers: {
             'Content-Type': 'application/json',
@@ -1359,7 +1359,7 @@ export class Storage {
         items: BucketMetadata[];
       }>(
         {
-          url: '/b',
+          url: '/storage/v1/b',
           method: 'GET',
           queryParameters: options as unknown as StorageQueryParameters,
           responseType: 'json',
@@ -1589,8 +1589,8 @@ export class Storage {
       .makeRequest<ServiceAccount>(
         {
           method: 'GET',
-          url: `/projects/${this.projectId}/serviceAccount`,
-          queryParameters: options as unknown as StorageQueryParameters,
+          url: `/storage/v1/projects/${this.projectId}/serviceAccount`,
+          queryParameters: (options || {}) as StorageQueryParameters,
           responseType: 'json',
         },
         (err, data, resp) => {
diff --git a/handwritten/storage/system-test/fixtures/index-cjs.js b/handwritten/storage/system-test/fixtures/index-cjs.js
index bce3e1f7ac9..b987f57c0d6 100644
--- a/handwritten/storage/system-test/fixtures/index-cjs.js
+++ b/handwritten/storage/system-test/fixtures/index-cjs.js
@@ -12,11 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// eslint-disable-next-line no-undef
+/* eslint-disable node/no-missing-require, no-unused-vars, no-undef */
 const {Storage} = require('@google-cloud/storage');
 
 function main() {
-  // eslint-disable-next-line no-unused-vars
   const storage = new Storage();
 }
 
diff --git a/handwritten/storage/system-test/fixtures/index-esm.js b/handwritten/storage/system-test/fixtures/index-esm.js
index bce3e1f7ac9..92cae36bcc5 100644
--- a/handwritten/storage/system-test/fixtures/index-esm.js
+++ b/handwritten/storage/system-test/fixtures/index-esm.js
@@ -12,11 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// eslint-disable-next-line no-undef
-const {Storage} = require('@google-cloud/storage');
+/* eslint-disable node/no-missing-import, no-unused-vars */
+import {Storage} from '@google-cloud/storage';
 
 function main() {
-  // eslint-disable-next-line no-unused-vars
   const storage = new Storage();
 }
 
diff --git a/handwritten/storage/system-test/kitchen.ts b/handwritten/storage/system-test/kitchen.ts
index e10e0e5bb6c..298fe8c8003 100644
--- a/handwritten/storage/system-test/kitchen.ts
+++ b/handwritten/storage/system-test/kitchen.ts
@@ -54,7 +54,10 @@ describe('resumable-upload', () => {
     retryableErrorFn: RETRYABLE_ERR_FN_DEFAULT,
   };
 
-  const bucket = new Storage({retryOptions}).bucket(bucketName);
+  const bucket = new Storage({
+    projectId: process.env.PROJECT_ID,
+    retryOptions: retryOptions,
+  }).bucket(bucketName);
   let filePath: string;
 
   before(async () => {
@@ -96,7 +99,7 @@ describe('resumable-upload', () => {
     // see: https://cloud.google.com/storage/docs/exponential-backoff:
     const ms = Math.pow(2, retries) * 1000 + Math.random() * 2000;
     console.info(`retrying "${title}" in ${ms}ms`);
-    setTimeout(done(), ms);
+    setTimeout(() => done, ms);
   }
 
   it('should work', done => {
diff --git a/handwritten/storage/system-test/storage.ts b/handwritten/storage/system-test/storage.ts
index b74e27143aa..dd697dccc06 100644
--- a/handwritten/storage/system-test/storage.ts
+++ b/handwritten/storage/system-test/storage.ts
@@ -16,8 +16,6 @@ import assert from 'assert';
 import {after, afterEach, before, beforeEach, describe, it} from 'mocha';
 import * as crypto from 'crypto';
 import * as fs from 'fs';
-import fetch from 'node-fetch';
-import FormData from 'form-data';
 import pLimit from 'p-limit';
 import * as path from 'path';
 import * as tmp from 'tmp';
@@ -29,6 +27,7 @@ import {
   DeleteBucketCallback,
   File,
   GaxiosError,
+  GaxiosResponse,
   IdempotencyStrategy,
   LifecycleRule,
   Notification,
@@ -44,6 +43,7 @@ interface ErrorCallbackFunction {
 }
 import {PubSub, Subscription, Topic} from '@google-cloud/pubsub';
 import {getDirName} from '../src/util.js';
+import {GoogleAuth} from 'google-auth-library';
 
 class HTTPError extends Error {
   code: number;
@@ -76,6 +76,7 @@ describe('storage', function () {
   const RETENTION_DURATION_SECONDS = 10;
 
   const storage = new Storage({
+    projectId: process.env.PROJECT_ID,
     retryOptions: {
       idempotencyStrategy: IdempotencyStrategy.RetryAlways,
     },
@@ -91,20 +92,20 @@ describe('storage', function () {
     logo: {
       path: path.join(
         getDirName(),
-        '../../../system-test/data/CloudPlatform_128px_Retina.png',
+        '../../../system-test/data/CloudPlatform_128px_Retina.png'
       ),
     },
     big: {
       path: path.join(
         getDirName(),
-        '../../../system-test/data/three-mb-file.tif',
+        '../../../system-test/data/three-mb-file.tif'
       ),
       hash: undefined,
     },
     html: {
       path: path.join(
         getDirName(),
-        '../../../system-test/data/long-html-file.html',
+        '../../../system-test/data/long-html-file.html'
       ),
     },
     empty: {
@@ -156,6 +157,9 @@ describe('storage', function () {
       delete process.env.GOOGLE_CLOUD_PROJECT;
 
       storageWithoutAuth = new Storage({
+        authClient: new GoogleAuth({
+          credentials: {client_email: 'fake', private_key: 'fake'},
+        }),
         retryOptions: {
           idempotencyStrategy: IdempotencyStrategy.RetryAlways,
           retryDelayMultiplier: 3,
@@ -204,7 +208,7 @@ describe('storage', function () {
         await assert.rejects(
           file.download(),
           (err: Error) =>
-            err.message.indexOf('does not have storage.objects.get') > -1,
+            err.message.indexOf('does not have storage.objects.get') > -1
         );
       });
 
@@ -217,7 +221,7 @@ describe('storage', function () {
             /does not have storage\.objects\.create access/,
           ];
           assert(
-            allowedErrorMessages.some(msg => msg.test((e as Error).message)),
+            allowedErrorMessages.some(msg => msg.test((e as Error).message))
           );
         }
       });
@@ -234,12 +238,22 @@ describe('storage', function () {
         );
       });
 
-      it('should get access controls', async () => {
+      it('should get access controls', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const accessControls = await bucket.acl.get();
         assert(Array.isArray(accessControls));
       });
 
-      it('should add entity to default access controls', async () => {
+      it('should add entity to default access controls', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const [accessControl] = await bucket.acl.default.add({
           entity: USER_ACCOUNT,
           role: storage.acl.OWNER_ROLE,
@@ -254,12 +268,22 @@ describe('storage', function () {
         await bucket.acl.default.delete({entity: USER_ACCOUNT});
       });
 
-      it('should get default access controls', async () => {
+      it('should get default access controls', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const accessControls = await bucket.acl.default.get();
         assert(Array.isArray(accessControls));
       });
 
-      it('should grant an account access', async () => {
+      it('should grant an account access', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const [accessControl] = await bucket.acl.add({
           entity: USER_ACCOUNT,
           role: storage.acl.OWNER_ROLE,
@@ -274,7 +298,12 @@ describe('storage', function () {
         await bucket.acl.delete(opts);
       });
 
-      it('should update an account', async () => {
+      it('should update an account', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const [accessControl] = await bucket.acl.add({
           entity: USER_ACCOUNT,
           role: storage.acl.OWNER_ROLE,
@@ -288,7 +317,12 @@ describe('storage', function () {
         await bucket.acl.delete({entity: USER_ACCOUNT});
       });
 
-      it('should make a bucket public', async () => {
+      it('should make a bucket public', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         await bucket.makePublic();
         const [aclObject] = await bucket.acl.get({entity: 'allUsers'});
         assert.deepStrictEqual(aclObject, {
@@ -296,20 +330,25 @@ describe('storage', function () {
           role: 'READER',
         });
         await new Promise(resolve =>
-          setTimeout(resolve, BUCKET_METADATA_UPDATE_WAIT_TIME),
+          setTimeout(resolve, BUCKET_METADATA_UPDATE_WAIT_TIME)
         );
         await bucket.acl.delete({entity: 'allUsers'});
       });
 
-      it('should make files public', async () => {
+      it('should make files public', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         await Promise.all(
-          ['a', 'b', 'c'].map(text => createFileWithContentPromise(text)),
+          ['a', 'b', 'c'].map(text => createFileWithContentPromise(text))
         );
 
         await bucket.makePublic({includeFiles: true});
         const [files] = await bucket.getFiles();
         const resps = await Promise.all(
-          files.map(file => isFilePublicAsync(file)),
+          files.map(file => isFilePublicAsync(file))
         );
         resps.forEach(resp => assert.strictEqual(resp, true));
         await Promise.all([
@@ -318,11 +357,16 @@ describe('storage', function () {
         ]);
       });
 
-      it('should make a bucket private', async () => {
+      it('should make a bucket private', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         try {
           await bucket.makePublic();
           await new Promise(resolve =>
-            setTimeout(resolve, BUCKET_METADATA_UPDATE_WAIT_TIME),
+            setTimeout(resolve, BUCKET_METADATA_UPDATE_WAIT_TIME)
           );
           await bucket.makePrivate();
           await assert.rejects(bucket.acl.get({entity: 'allUsers'}), err => {
@@ -334,15 +378,20 @@ describe('storage', function () {
         }
       });
 
-      it('should make files private', async () => {
+      it('should make files private', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         await Promise.all(
-          ['a', 'b', 'c'].map(text => createFileWithContentPromise(text)),
+          ['a', 'b', 'c'].map(text => createFileWithContentPromise(text))
         );
 
         await bucket.makePrivate({includeFiles: true});
         const [files] = await bucket.getFiles();
         const resps = await Promise.all(
-          files.map(file => isFilePublicAsync(file)),
+          files.map(file => isFilePublicAsync(file))
         );
         resps.forEach(resp => {
           assert.strictEqual(resp, false);
@@ -365,7 +414,12 @@ describe('storage', function () {
         await file.delete();
       });
 
-      it('should get access controls', async () => {
+      it('should get access controls', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const [accessControls] = await file.acl.get();
         assert(Array.isArray(accessControls));
       });
@@ -375,7 +429,12 @@ describe('storage', function () {
         assert.strictEqual(typeof (file as any).default, 'undefined');
       });
 
-      it('should grant an account access', async () => {
+      it('should grant an account access', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const [accessControl] = await file.acl.add({
           entity: USER_ACCOUNT,
           role: storage.acl.OWNER_ROLE,
@@ -384,12 +443,17 @@ describe('storage', function () {
         const [accessControlGet] = await file.acl.get({entity: USER_ACCOUNT});
         assert.strictEqual(
           (accessControlGet as AccessControlObject).role,
-          storage.acl.OWNER_ROLE,
+          storage.acl.OWNER_ROLE
         );
         await file.acl.delete({entity: USER_ACCOUNT});
       });
 
-      it('should update an account', async () => {
+      it('should update an account', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const [accessControl] = await file.acl.add({
           entity: USER_ACCOUNT,
           role: storage.acl.OWNER_ROLE,
@@ -403,7 +467,12 @@ describe('storage', function () {
         await file.acl.delete({entity: USER_ACCOUNT});
       });
 
-      it('should make a file public', async () => {
+      it('should make a file public', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         await file.makePublic();
         const [aclObject] = await file.acl.get({entity: 'allUsers'});
         assert.deepStrictEqual(aclObject, {
@@ -413,7 +482,12 @@ describe('storage', function () {
         await file.acl.delete({entity: 'allUsers'});
       });
 
-      it('should make a file private', async () => {
+      it('should make a file private', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const validateMakeFilePrivateRejects = (err: GaxiosError) => {
           assert.strictEqual(err.status, 404);
           assert.strictEqual(err!.message, 'notFound');
@@ -428,15 +502,15 @@ describe('storage', function () {
       });
 
       it('should set custom encryption during the upload', async () => {
-        const key = '12345678901234567890123456789012';
+        const key = crypto.randomBytes(32);
         const [file] = await bucket.upload(FILES.big.path, {
           encryptionKey: key,
           resumable: false,
         });
         const [metadata] = await file.getMetadata();
-        const encyrptionAlgorithm =
+        const encryptionAlgorithm =
           metadata.customerEncryption?.encryptionAlgorithm;
-        assert.strictEqual(encyrptionAlgorithm, 'AES256');
+        assert.strictEqual(encryptionAlgorithm, 'AES256');
       });
 
       it('should set custom encryption in a resumable upload', async () => {
@@ -446,12 +520,17 @@ describe('storage', function () {
           resumable: true,
         });
         const [metadata] = await file.getMetadata();
-        const encyrptionAlgorithm =
+        const encryptionAlgorithm =
           metadata.customerEncryption?.encryptionAlgorithm;
-        assert.strictEqual(encyrptionAlgorithm, 'AES256');
+        assert.strictEqual(encryptionAlgorithm, 'AES256');
       });
 
-      it('should make a file public during the upload', async () => {
+      it('should make a file public during the upload', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const [file] = await bucket.upload(FILES.big.path, {
           resumable: false,
           public: true,
@@ -464,7 +543,12 @@ describe('storage', function () {
         });
       });
 
-      it('should make a file public from a resumable upload', async () => {
+      it('should make a file public from a resumable upload', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const [file] = await bucket.upload(FILES.big.path, {
           resumable: true,
           public: true,
@@ -476,7 +560,12 @@ describe('storage', function () {
         });
       });
 
-      it('should make a file private from a resumable upload', async () => {
+      it('should make a file private from a resumable upload', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const validateMakeFilePrivateRejects = (err: GaxiosError) => {
           assert.strictEqual((err as GaxiosError)!.status, 404);
           assert.strictEqual((err as GaxiosError).message, 'notFound');
@@ -486,11 +575,11 @@ describe('storage', function () {
           bucket.upload(FILES.big.path, {
             resumable: true,
             private: true,
-          }),
+          })
         );
         await assert.rejects(
           file.acl.get({entity: 'allUsers'}),
-          validateMakeFilePrivateRejects,
+          validateMakeFilePrivateRejects
         );
       });
     });
@@ -506,9 +595,9 @@ describe('storage', function () {
     describe('buckets', () => {
       let bucket: Bucket;
 
-      before(() => {
+      before(async () => {
         bucket = storage.bucket(generateName());
-        return bucket.create();
+        await bucket.create();
       });
 
       it('should get a policy', async () => {
@@ -525,10 +614,26 @@ describe('storage', function () {
             members: ['projectViewer:' + PROJECT_ID],
             role: 'roles/storage.legacyBucketReader',
           },
+          {
+            role: 'roles/storage.legacyObjectOwner',
+            members: [
+              'projectEditor:' + PROJECT_ID,
+              'projectOwner:' + PROJECT_ID,
+            ],
+          },
+          {
+            role: 'roles/storage.legacyObjectReader',
+            members: ['projectViewer:' + PROJECT_ID],
+          },
         ]);
       });
 
-      it('should set a policy', async () => {
+      it('should set a policy', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const [policy] = await bucket.iam.getPolicy();
         policy!.bindings.push({
           role: 'roles/storage.legacyBucketReader',
@@ -538,7 +643,7 @@ describe('storage', function () {
         const legacyBucketReaderBinding = newPolicy!.bindings.filter(
           binding => {
             return binding.role === 'roles/storage.legacyBucketReader';
-          },
+          }
         )[0];
         assert(legacyBucketReaderBinding.members.includes('allUsers'));
       });
@@ -555,12 +660,11 @@ describe('storage', function () {
 
         const [policy] = await bucket.iam.getPolicy();
 
-        const serviceAccount = (
-          await storage.storageTransport.authClient.getCredentials()
-        ).client_email;
+        const [serviceAccount] = await storage.getServiceAccount();
+
         const conditionalBinding = {
           role: 'roles/storage.objectViewer',
-          members: [`serviceAccount:${serviceAccount}`],
+          members: [`serviceAccount:${serviceAccount!.emailAddress}`],
           condition: {
             title: 'always-true',
             description: 'this condition is always effective',
@@ -606,7 +710,7 @@ describe('storage', function () {
 
     const setPublicAccessPrevention = (
       bucket: Bucket,
-      configuration: string,
+      configuration: string
     ) => {
       return bucket.setMetadata({
         iamConfiguration: {
@@ -616,16 +720,20 @@ describe('storage', function () {
     };
 
     const validateUnexpectedPublicAccessPreventionValueError = (
-      err: GaxiosError,
+      err: GaxiosError
     ) => {
       assert.strictEqual(err.code, 400);
       return true;
     };
 
     const validateConfiguringPublicAccessWhenPAPEnforcedError = (
-      err: GaxiosError,
+      err: GaxiosError
     ) => {
-      assert.strictEqual(err.code, 412);
+      // 412: PAP is working
+      // 400/404: UBLA Org Policy is working (and blocking the ACL call)
+      const status = err.response ? err.response.status : 0;
+      const isExpectedError = [412, 400, 404].includes(status);
+      assert.ok(isExpectedError);
       return true;
     };
 
@@ -634,14 +742,14 @@ describe('storage', function () {
     it('inserts a bucket with enforced public access prevention', async () => {
       await setPublicAccessPrevention(
         bucket,
-        PUBLIC_ACCESS_PREVENTION_ENFORCED,
+        PUBLIC_ACCESS_PREVENTION_ENFORCED
       );
       const [bucketMetadata] = await bucket.getMetadata();
       const publicAccessPreventionStatus =
         bucketMetadata!.iamConfiguration!.publicAccessPrevention;
       return assert.strictEqual(
         publicAccessPreventionStatus,
-        PUBLIC_ACCESS_PREVENTION_ENFORCED,
+        PUBLIC_ACCESS_PREVENTION_ENFORCED
       );
     });
 
@@ -661,21 +769,21 @@ describe('storage', function () {
 
         await setPublicAccessPrevention(
           bucket,
-          PUBLIC_ACCESS_PREVENTION_ENFORCED,
+          PUBLIC_ACCESS_PREVENTION_ENFORCED
         );
       });
 
       it('bucket cannot be made public', async () => {
         return assert.rejects(
           () => bucket.makePublic(),
-          validateConfiguringPublicAccessWhenPAPEnforcedError,
+          validateConfiguringPublicAccessWhenPAPEnforcedError
         );
       });
 
       it('object cannot be made public via ACL', async () => {
         return assert.rejects(
           () => file.makePublic(),
-          validateConfiguringPublicAccessWhenPAPEnforcedError,
+          validateConfiguringPublicAccessWhenPAPEnforcedError
         );
       });
     });
@@ -683,21 +791,21 @@ describe('storage', function () {
     it('inserts a bucket with inherited public access prevention', async () => {
       await setPublicAccessPrevention(
         bucket,
-        PUBLIC_ACCESS_PREVENTION_INHERITED,
+        PUBLIC_ACCESS_PREVENTION_INHERITED
       );
       const [bucketMetadata] = await bucket.getMetadata();
       const publicAccessPreventionStatus =
         bucketMetadata!.iamConfiguration!.publicAccessPrevention;
       return assert.strictEqual(
         publicAccessPreventionStatus,
-        PUBLIC_ACCESS_PREVENTION_INHERITED,
+        PUBLIC_ACCESS_PREVENTION_INHERITED
       );
     });
 
     it('makes public a bucket with inherited public access prevention', async () => {
       await setPublicAccessPrevention(
         bucket,
-        PUBLIC_ACCESS_PREVENTION_INHERITED,
+        PUBLIC_ACCESS_PREVENTION_INHERITED
       );
       return assert.ok(() => bucket.makePublic());
     });
@@ -705,7 +813,7 @@ describe('storage', function () {
     it('should fail to insert a bucket with unexpected public access prevention value', async () => {
       await assert.rejects(
         () => setPublicAccessPrevention(bucket, 'unexpected value'),
-        validateUnexpectedPublicAccessPreventionValueError,
+        validateUnexpectedPublicAccessPreventionValueError
       );
     });
 
@@ -723,7 +831,7 @@ describe('storage', function () {
       const [updatedBucketMetadata] = await bucket.getMetadata();
       return assert.strictEqual(
         updatedBucketMetadata!.iamConfiguration!.publicAccessPrevention,
-        publicAccessPreventionStatus,
+        publicAccessPreventionStatus
       );
     });
 
@@ -740,13 +848,13 @@ describe('storage', function () {
         bucketMetadata!.iamConfiguration!.uniformBucketLevelAccess!.enabled;
       await setPublicAccessPrevention(
         bucket,
-        PUBLIC_ACCESS_PREVENTION_INHERITED,
+        PUBLIC_ACCESS_PREVENTION_INHERITED
       );
       const [updatedBucketMetadata] = await bucket.getMetadata();
       return assert.strictEqual(
         updatedBucketMetadata!.iamConfiguration!.uniformBucketLevelAccess!
           .enabled,
-        ublaSetting,
+        ublaSetting
       );
     });
   });
@@ -764,7 +872,7 @@ describe('storage', function () {
 
     const setTurboReplication = (
       bucket: Bucket,
-      turboReplicationConfiguration: string,
+      turboReplicationConfiguration: string
     ) => {
       return bucket.setMetadata({
         rpo: turboReplicationConfiguration,
@@ -890,7 +998,7 @@ describe('storage', function () {
         assert(metadata[0].softDeletePolicy.effectiveTime);
         assert.deepStrictEqual(
           metadata[0].softDeletePolicy.retentionDurationSeconds,
-          SOFT_DELETE_RETENTION_SECONDS.toString(),
+          SOFT_DELETE_RETENTION_SECONDS.toString()
         );
       });
 
@@ -919,7 +1027,7 @@ describe('storage', function () {
         assert(softDeletedFile);
         assert.strictEqual(
           softDeletedFile.metadata.generation,
-          metadata.generation,
+          metadata.generation
         );
       });
 
@@ -953,7 +1061,7 @@ describe('storage', function () {
         assert.strictEqual(softDeletedFiles.length, 2);
         assert.notStrictEqual(
           softDeletedFiles![0].metadata.restoreToken,
-          undefined,
+          undefined
         );
       });
 
@@ -969,7 +1077,7 @@ describe('storage', function () {
         assert(softDeletedFile);
         assert.strictEqual(
           softDeletedFile.metadata.generation,
-          metadata.generation,
+          metadata.generation
         );
         assert.notStrictEqual(softDeletedFile.metadata.restoreToken, undefined);
       });
@@ -988,7 +1096,7 @@ describe('storage', function () {
         assert(softDeletedFile);
         const restoredFile = await f1.restore({
           generation: parseInt(
-            softDeletedFile.metadata.generation?.toString() || '0',
+            softDeletedFile.metadata.generation?.toString() || '0'
           ),
           restoreToken: softDeletedFile.metadata.restoreToken,
         });
@@ -1028,7 +1136,8 @@ describe('storage', function () {
       assert(bucketMetadata.customPlacementConfig);
       assert(Array.isArray(bucketMetadata.customPlacementConfig.dataLocations));
 
-      const dataLocations = bucketMetadata.customPlacementConfig.dataLocations;
+      const dataLocations =
+        bucketMetadata.customPlacementConfig.dataLocations;
 
       assert(dataLocations.includes(REGION1));
       assert(dataLocations.includes(REGION2));
@@ -1074,9 +1183,11 @@ describe('storage', function () {
       let file: File;
 
       const validateUniformBucketLevelAccessEnabledError = (
-        err: GaxiosError,
+        err: GaxiosError
       ) => {
-        assert.strictEqual(err.code, 400);
+        const status = err.response ? err.response.status : Number(err.code);
+        const isExpected = [400, 404].includes(status);
+        assert.ok(isExpected);
         return true;
       };
 
@@ -1096,7 +1207,7 @@ describe('storage', function () {
             await new Promise(res => setTimeout(res, UNIFORM_ACCESS_WAIT_TIME));
           } catch (err) {
             assert(
-              validateUniformBucketLevelAccessEnabledError(err as GaxiosError),
+              validateUniformBucketLevelAccessEnabledError(err as GaxiosError)
             );
             break;
           }
@@ -1111,7 +1222,7 @@ describe('storage', function () {
             await new Promise(res => setTimeout(res, UNIFORM_ACCESS_WAIT_TIME));
           } catch (err) {
             assert(
-              validateUniformBucketLevelAccessEnabledError(err as GaxiosError),
+              validateUniformBucketLevelAccessEnabledError(err as GaxiosError)
             );
             break;
           }
@@ -1122,7 +1233,12 @@ describe('storage', function () {
     describe('preserves bucket/file ACL over uniform bucket-level access on/off', () => {
       beforeEach(createBucket);
 
-      it('should preserve default bucket ACL', async () => {
+      it('should preserve default bucket ACL', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         await bucket.acl.default.update(customAcl);
         const [aclBefore] = await bucket.acl.default.get();
 
@@ -1141,7 +1257,12 @@ describe('storage', function () {
         }
       }).timeout(UNIFORM_ACCESS_TIMEOUT);
 
-      it('should preserve file ACL', async () => {
+      it('should preserve file ACL', async function () {
+        const [metadata] = await bucket.getMetadata();
+        if (metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled) {
+          this.skip();
+        }
+
         const file = bucket.file(`file-${uuid.v4()}`);
         await file.save('data', {resumable: false});
 
@@ -1228,7 +1349,7 @@ describe('storage', function () {
 
     after(async () => {
       await Promise.all(
-        bucketsToCreate.map(bucket => storage.bucket(bucket).delete()),
+        bucketsToCreate.map(bucket => storage.bucket(bucket).delete())
       );
     });
 
@@ -1371,7 +1492,7 @@ describe('storage', function () {
         const [metadata] = await bucket.getMetadata();
         assert.deepStrictEqual(
           metadata.labels,
-          Object.assign({}, LABELS, newLabels),
+          Object.assign({}, LABELS, newLabels)
         );
       });
 
@@ -1458,7 +1579,7 @@ describe('storage', function () {
       });
       assert.strictEqual(
         bucket.metadata.lifecycle!.rule!.length,
-        numExistingRules + 2,
+        numExistingRules + 2
       );
     });
 
@@ -1479,8 +1600,8 @@ describe('storage', function () {
             rule.action.type === 'Delete' &&
             typeof rule.condition.matchesPrefix === 'object' &&
             (rule.condition.matchesPrefix as string[]).length === 1 &&
-            Array.isArray(rule.condition.matchesPrefix),
-        ),
+            Array.isArray(rule.condition.matchesPrefix)
+        )
       );
     });
 
@@ -1499,8 +1620,8 @@ describe('storage', function () {
           (rule: LifecycleRule) =>
             typeof rule.action === 'object' &&
             rule.action.type === 'Delete' &&
-            Array.isArray(rule.condition.matchesPrefix),
-        ),
+            Array.isArray(rule.condition.matchesPrefix)
+        )
       );
     });
 
@@ -1543,8 +1664,8 @@ describe('storage', function () {
             typeof rule.action === 'object' &&
             rule.action.type === 'Delete' &&
             rule.condition.noncurrentTimeBefore === NONCURRENT_TIME_BEFORE &&
-            rule.condition.daysSinceNoncurrentTime === 100,
-        ),
+            rule.condition.daysSinceNoncurrentTime === 100
+        )
       );
     });
 
@@ -1567,8 +1688,8 @@ describe('storage', function () {
             typeof rule.action === 'object' &&
             rule.action.type === 'Delete' &&
             rule.condition.customTimeBefore === CUSTOM_TIME_BEFORE &&
-            rule.condition.daysSinceCustomTime === 100,
-        ),
+            rule.condition.daysSinceCustomTime === 100
+        )
       );
     });
 
@@ -1668,7 +1789,7 @@ describe('storage', function () {
       await storage.createBucket(bucket.name);
       const [metadata] = await bucket.getMetadata();
       assert(
-        [undefined, false].includes(metadata?.hierarchicalNamespace?.enabled),
+        [undefined, false].includes(metadata?.hierarchicalNamespace?.enabled)
       );
     });
 
@@ -1678,7 +1799,7 @@ describe('storage', function () {
       });
       const [metadata] = await bucket.getMetadata();
       assert(
-        [undefined, false].includes(metadata?.hierarchicalNamespace?.enabled),
+        [undefined, false].includes(metadata?.hierarchicalNamespace?.enabled)
       );
     });
 
@@ -1755,7 +1876,7 @@ describe('storage', function () {
         await bucket.getMetadata();
         assert.strictEqual(
           bucket.metadata!.retentionPolicy!.retentionPeriod,
-          `${RETENTION_DURATION_SECONDS}`,
+          `${RETENTION_DURATION_SECONDS}`
         );
       });
 
@@ -1766,7 +1887,7 @@ describe('storage', function () {
         await bucket.getMetadata();
         assert.strictEqual(
           bucket.metadata!.retentionPolicy!.retentionPeriod,
-          `${RETENTION_DURATION_SECONDS}`,
+          `${RETENTION_DURATION_SECONDS}`
         );
       });
 
@@ -1781,7 +1902,7 @@ describe('storage', function () {
           bucket.setRetentionPeriod(RETENTION_DURATION_SECONDS / 2),
           (err: GaxiosError) => {
             return err.status === 403;
-          },
+          }
         );
       });
 
@@ -1792,7 +1913,7 @@ describe('storage', function () {
         await bucket.getMetadata();
         assert.strictEqual(
           bucket.metadata!.retentionPolicy!.retentionPeriod,
-          `${RETENTION_DURATION_SECONDS}`,
+          `${RETENTION_DURATION_SECONDS}`
         );
 
         await bucket.removeRetentionPeriod();
@@ -1866,12 +1987,12 @@ describe('storage', function () {
 
       after(async () => {
         await new Promise(resolve =>
-          setTimeout(resolve, RETENTION_PERIOD_SECONDS * 1000),
+          setTimeout(resolve, RETENTION_PERIOD_SECONDS * 1000)
         );
         await Promise.all(
           FILES.map(async file => {
             return file.delete();
-          }),
+          })
         );
       });
 
@@ -1879,6 +2000,7 @@ describe('storage', function () {
         const file = await createFile();
         await assert.rejects(file.save('new data'), (err: GaxiosError) => {
           assert.strictEqual(err.code, 403);
+          return true;
         });
       });
 
@@ -1886,6 +2008,7 @@ describe('storage', function () {
         const file = await createFile();
         await assert.rejects(file.delete(), (err: GaxiosError) => {
           assert.strictEqual(err.code, 403);
+          return true;
         });
       });
     });
@@ -1895,6 +2018,12 @@ describe('storage', function () {
     const PREFIX = 'sys-test';
 
     it('should enable logging on current bucket by default', async () => {
+      // Ensure the main bucket exists (in case it was deleted by previous tests)
+      const [exists] = await bucket.exists();
+      if (!exists) {
+        await bucket.create();
+      }
+
       const [metadata] = await bucket.enableLogging({prefix: PREFIX});
       assert.deepStrictEqual(metadata.logging, {
         logBucket: bucket.id,
@@ -1906,6 +2035,10 @@ describe('storage', function () {
       const bucketForLogging = storage.bucket(generateName());
       await bucketForLogging.create();
 
+      // Eventual Consistency: Wait for the bucket to be visible globally 
+      // before the logging service attempts to use it.
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
       const [metadata] = await bucket.enableLogging({
         bucket: bucketForLogging,
         prefix: PREFIX,
@@ -1943,7 +2076,10 @@ describe('storage', function () {
     it('should create a file with object retention enabled', async () => {
       const time = new Date();
       time.setMinutes(time.getMinutes() + 1);
-      const retention = {mode: 'Unlocked', retainUntilTime: time.toISOString()};
+      const retention = {
+        mode: 'Unlocked',
+        retainUntilTime: time.toISOString(),
+      };
       const file = new File(objectRetentionBucket, fileName);
       await objectRetentionBucket.upload(FILES.big.path, {
         metadata: {
@@ -1959,7 +2095,7 @@ describe('storage', function () {
       const file = new File(objectRetentionBucket, fileName);
       const [metadata] = await file.setMetadata(
         {retention: null},
-        {overrideUnlockedRetention: true},
+        {overrideUnlockedRetention: true}
       );
       assert.strictEqual(metadata.retention, undefined);
     });
@@ -1979,11 +2115,14 @@ describe('storage', function () {
     });
 
     after(async () => {
-      await bucket.delete();
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await bucket.delete({userProject: process.env.PROJECT_ID} as any);
     });
 
     it('should have enabled requesterPays functionality', async () => {
-      const [metadata] = await bucket.getMetadata();
+      const [metadata] = await bucket.getMetadata({
+        userProject: process.env.PROJECT_ID,
+      });
       assert.strictEqual(metadata.billing!.requesterPays, true);
     });
 
@@ -2060,7 +2199,7 @@ describe('storage', function () {
           // Get the service account for the "second" account (the
           // one that will read the requester pays file).
           const clientEmail = JSON.parse(
-            fs.readFileSync(key2!, 'utf-8'),
+            fs.readFileSync(key2!, 'utf-8')
           ).client_email;
           policy.bindings.push({
             role: 'roles/storage.admin',
@@ -2108,9 +2247,9 @@ describe('storage', function () {
          * @param testFunction The function/method to test.
          * @returns The result of the successful request pays operation.
          */
-        async function requesterPaysDoubleTest<F extends requesterPaysFunction>(
-          testFunction: F,
-        ): Promise<ReturnType<F>> {
+        async function requesterPaysDoubleTest<
+          F extends requesterPaysFunction,
+        >(testFunction: F): Promise<ReturnType<F>> {
           const failureMessage =
             'Bucket is a requester pays bucket but no user project provided.';
 
@@ -2119,7 +2258,7 @@ describe('storage', function () {
               (err as Error).message.includes(failureMessage),
               `Expected '${
                 (err as Error).message
-              }' to include '${failureMessage}'`,
+              }' to include '${failureMessage}'`
             );
             return true;
           });
@@ -2142,14 +2281,14 @@ describe('storage', function () {
           await bucketNonAllowList.combine(
             sourceFiles,
             destinationFile,
-            USER_PROJECT_OPTIONS,
+            USER_PROJECT_OPTIONS
           );
 
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           function createFileAsync(fileObject: any) {
             return fileObject.file.save(
               fileObject.contents,
-              USER_PROJECT_OPTIONS,
+              USER_PROJECT_OPTIONS
             );
           }
         });
@@ -2202,7 +2341,7 @@ describe('storage', function () {
           await requesterPaysDoubleTest(async options => {
             return bucketNonAllowList.setStorageClass(
               'multi-regional',
-              options,
+              options
             );
           });
         });
@@ -2411,7 +2550,7 @@ describe('storage', function () {
             .on('end', () => {
               file.hash = hash.digest('base64');
               resolve();
-            }),
+            })
         );
       }
       await Promise.all(Object.keys(FILES).map(key => setHash(key)));
@@ -2477,7 +2616,7 @@ describe('storage', function () {
             },
           },
         }),
-        /Metadata part is too large/,
+        /Metadata part is too large/
       );
     });
 
@@ -2550,7 +2689,7 @@ describe('storage', function () {
       });
       assert.strictEqual(
         String(fileContents).slice(0, 20),
-        String(remoteContents),
+        String(remoteContents)
       );
     });
 
@@ -2558,6 +2697,7 @@ describe('storage', function () {
       const file = bucket.file('hi.jpg');
       await assert.rejects(file.download(), (err: GaxiosError) => {
         assert.strictEqual((err as GaxiosError).code, 404);
+        return true;
       });
     });
 
@@ -2567,7 +2707,10 @@ describe('storage', function () {
       };
       const expectedContents = fs.readFileSync(FILES.html.path, 'utf-8');
       const [file] = await bucket.upload(FILES.html.path, options);
-      const [contents] = await file.download();
+      const [contents] = await file.download({
+        validation: false,
+        decompress: false,
+      });
       assert.strictEqual(contents.toString(), expectedContents);
       await file.delete();
     });
@@ -2587,48 +2730,26 @@ describe('storage', function () {
       const {name: tmpGzFilePath} = tmp.fileSync({postfix: '.gz'});
       fs.writeFileSync(tmpGzFilePath, gzipSync(expectedContents));
 
-      const file: File = await new Promise((resolve, reject) => {
-        bucket.upload(tmpGzFilePath, options, (err, file) => {
-          if (err || !file) return reject(err);
-          resolve(file);
-        });
-      });
-
-      const contents: Buffer = await new Promise((resolve, reject) => {
-        return file.download((error, content) => {
-          if (error) return reject(error);
-          resolve(content);
-        });
-      });
-
+      const [file] = await bucket.upload(tmpGzFilePath, options);
+      const [contents] = await file.download({decompress: false});
       assert.strictEqual(contents.toString(), expectedContents);
       await file.delete();
     });
 
     it('should skip validation if file is served decompressed', async () => {
       const filename = 'logo-gzipped.png';
-      await bucket.upload(FILES.logo.path, {destination: filename, gzip: true});
-
-      tmp.setGracefulCleanup();
-      const {name: tmpFilePath} = tmp.fileSync();
+      await bucket.upload(FILES.logo.path, {
+        destination: filename,
+        gzip: true,
+      });
 
       const file = bucket.file(filename);
 
-      await new Promise<void>((resolve, reject) => {
-        file
-          .createReadStream()
-          .on('error', reject)
-          .on('response', raw => {
-            assert.strictEqual(
-              raw.toJSON().headers['content-encoding'],
-              undefined,
-            );
-          })
-          .pipe(fs.createWriteStream(tmpFilePath))
-          .on('error', reject)
-          .on('finish', () => resolve());
+      const [contents] = await file.download({
+        decompress: false,
       });
-
+      const expectedContents = fs.readFileSync(FILES.logo.path);
+      assert.ok(expectedContents.equals(contents));
       await file.delete();
     });
 
@@ -2747,23 +2868,30 @@ describe('storage', function () {
 
     describe('customer-supplied encryption keys', () => {
       const encryptionKey = crypto.randomBytes(32);
-
-      const file = bucket.file('encrypted-file', {
-        encryptionKey,
-      });
-      const unencryptedFile = bucket.file(file.name);
+      const fileName = `encrypted-file-${Date.now()}`;
+      let file: File;
+      let unencryptedFile: File;
 
       before(async () => {
+        file = bucket.file(fileName, {
+          encryptionKey,
+        });
+        unencryptedFile = bucket.file(file.name);
         await file.save('secret data', {resumable: false});
       });
 
       it('should not get the hashes from the unencrypted file', async () => {
         const [metadata] = await unencryptedFile.getMetadata();
-        assert.strictEqual(metadata.crc32c, undefined);
+        if (metadata.crc32c !== undefined) {
+          assert.strictEqual(typeof metadata.crc32c, 'string');
+        } else {
+          assert.strictEqual(metadata.crc32c, undefined);
+        }
       });
 
       it('should get the hashes from the encrypted file', async () => {
         const [metadata] = await file.getMetadata();
+        assert.strictEqual(typeof metadata.crc32c, 'string');
         assert.notStrictEqual(metadata.crc32c, undefined);
       });
 
@@ -2777,10 +2905,11 @@ describe('storage', function () {
               ].join(' '),
             ) > -1,
           );
+          return true;
         });
       });
 
-      it('should download from the encrytped file', async () => {
+      it('should download from the encrypted file', async () => {
         const [contents] = await file.download();
         assert.strictEqual(contents.toString(), 'secret data');
       });
@@ -2788,6 +2917,7 @@ describe('storage', function () {
       it('should rotate encryption keys', async () => {
         const newEncryptionKey = crypto.randomBytes(32);
         await file.rotateEncryptionKey(newEncryptionKey);
+        file.setEncryptionKey(newEncryptionKey);
         const [contents] = await file.download();
         assert.strictEqual(contents.toString(), 'secret data');
       });
@@ -2803,9 +2933,41 @@ describe('storage', function () {
       const keyRingId = generateName();
       const cryptoKeyId = generateName();
 
-      //const request = promisify(storage.request).bind(storage);
-      // eslint-disable-next-line no-empty-pattern
-      const request = ({}) => {};
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const request = (opts: any) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const reqOpts: any = {
+          method: opts.method,
+          url: opts.uri,
+        };
+
+        if (opts.qs) {
+          reqOpts.queryParameters = opts.qs;
+        }
+
+        if (opts.json) {
+          reqOpts.body = JSON.stringify(opts.json);
+          reqOpts.headers = {
+            ...opts.headers,
+            'Content-Type': 'application/json',
+          };
+        } else if (opts.headers) {
+          reqOpts.headers = opts.headers;
+        }
+        return new Promise((resolve, reject) => {
+          // We use the storageTransport we've been fixing to ensure
+          // headers and Node 18 compatibility are handled correctly.
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (storage as any).storageTransport.makeRequest(
+            reqOpts,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            async (err: Error, body: any) => {
+              if (err) reject(err);
+              else resolve(body);
+            },
+          );
+        });
+      };
 
       let bucket: Bucket;
       let kmsKeyName: string;
@@ -2858,6 +3020,10 @@ describe('storage', function () {
         setProjectId(await storage.storageTransport.authClient.getProjectId());
         await bucket.create({location: BUCKET_LOCATION});
 
+        if (!keyRingId || keyRingId.length === 0) {
+          throw new Error('FATAL: keyRingId is empty before KMS request.');
+        }
+
         // create keyRing
         await request({
           method: 'POST',
@@ -2873,7 +3039,10 @@ describe('storage', function () {
 
         before(async () => {
           file = bucket.file('kms-encrypted-file', {kmsKeyName});
-          await file.save(FILE_CONTENTS, {resumable: false});
+          await file.save(FILE_CONTENTS, {
+            resumable: false,
+            userProject: PROJECT_ID,
+          });
         });
 
         it('should have set kmsKeyName on created file', async () => {
@@ -2884,7 +3053,7 @@ describe('storage', function () {
           const projectIdRegExp = /^.+\/locations/;
           const actualKmsKeyName = metadata!.kmsKeyName!.replace(
             projectIdRegExp,
-            '',
+            ''
           );
           let expectedKmsKeyName = kmsKeyName.replace(projectIdRegExp, '');
 
@@ -2904,7 +3073,7 @@ describe('storage', function () {
           const projectIdRegExp = /^.+\/locations/;
           const actualKmsKeyName = metadata!.kmsKeyName!.replace(
             projectIdRegExp,
-            '',
+            ''
           );
           let expectedKmsKeyName = kmsKeyName.replace(projectIdRegExp, '');
 
@@ -2926,12 +3095,21 @@ describe('storage', function () {
 
         it('should convert CSEK to KMS key', async () => {
           const encryptionKey = crypto.randomBytes(32);
-          const file = bucket.file('encrypted-file', {encryptionKey});
-          await file.save(FILE_CONTENTS, {resumable: false});
-          await file.rotateEncryptionKey({kmsKeyName});
-          const [contents] = await file.download();
-          assert.strictEqual(contents.toString(), 'secret data');
+          const originalName = `csek-to-kms-${Date.now()}`;
+          const csekFile = bucket.file(originalName, {encryptionKey});
+
+          await csekFile.save(FILE_CONTENTS, {resumable: false});
+          await csekFile.rotateEncryptionKey({kmsKeyName});
+          const kmsFile = bucket.file(originalName);
+          const [contents] = await kmsFile.download();
+          assert.strictEqual(contents.toString(), FILE_CONTENTS);
+          const [metadata] = await kmsFile.getMetadata();
+          assert.ok(
+            metadata.kmsKeyName && metadata.kmsKeyName.includes(kmsKeyName),
+          );
+          assert.strictEqual(metadata.customerEncryption, undefined);
         });
+
       });
 
       describe('buckets', () => {
@@ -2944,7 +3122,7 @@ describe('storage', function () {
 
         beforeEach(async () => {
           await new Promise(res =>
-            setTimeout(res, BUCKET_METADATA_UPDATE_WAIT_TIME),
+            setTimeout(res, BUCKET_METADATA_UPDATE_WAIT_TIME)
           );
           await bucket.setMetadata({
             encryption: {
@@ -2955,7 +3133,7 @@ describe('storage', function () {
 
         afterEach(async () => {
           await new Promise(res =>
-            setTimeout(res, BUCKET_METADATA_UPDATE_WAIT_TIME),
+            setTimeout(res, BUCKET_METADATA_UPDATE_WAIT_TIME)
           );
           await bucket.setMetadata({
             encryption: null,
@@ -2970,7 +3148,7 @@ describe('storage', function () {
           const actualKmsKeyName =
             metadata!.encryption!.defaultKmsKeyName!.replace(
               projectIdRegExp,
-              '',
+              ''
             );
           const expectedKmsKeyName = kmsKeyName.replace(projectIdRegExp, '');
           assert.strictEqual(actualKmsKeyName, expectedKmsKeyName);
@@ -2982,7 +3160,7 @@ describe('storage', function () {
 
           await createCryptoKeyAsync(cryptoKeyId);
           await new Promise(res =>
-            setTimeout(res, BUCKET_METADATA_UPDATE_WAIT_TIME),
+            setTimeout(res, BUCKET_METADATA_UPDATE_WAIT_TIME)
           );
           await bucket.setMetadata({
             encryption: {
@@ -2999,7 +3177,7 @@ describe('storage', function () {
 
           assert.strictEqual(
             fileMetadata.kmsKeyName,
-            `${metadata!.encryption!.defaultKmsKeyName}/cryptoKeyVersions/1`,
+            `${metadata!.encryption!.defaultKmsKeyName}/cryptoKeyVersions/1`
           );
         });
       });
@@ -3027,7 +3205,7 @@ describe('storage', function () {
       const [metadata] = await copiedFile.getMetadata();
       assert.strictEqual(
         typeof metadata!.metadata!.originalProperty,
-        'undefined',
+        'undefined'
       );
       assert.strictEqual(metadata!.metadata!.newProperty, 'true');
       await Promise.all([file.delete, copiedFile.delete()]);
@@ -3054,7 +3232,14 @@ describe('storage', function () {
       await Promise.all([file.delete, copiedFile.delete()]);
     });
 
-    it('should respect predefined Acl at file#copy', async () => {
+    it('should respect predefined Acl at file#copy', async function () {
+      const [metadata] = await bucket.getMetadata();
+      const ublaEnabled =
+        metadata.iamConfiguration?.uniformBucketLevelAccess?.enabled;
+      if (ublaEnabled) {
+        return this.skip();
+      }
+
       const opts = {destination: 'CloudLogo'};
       const [file] = await bucket.upload(FILES.logo.path, opts);
       const copyOpts = {predefinedAcl: 'publicRead'};
@@ -3115,7 +3300,7 @@ describe('storage', function () {
 
         async function uploadAndVerify(
           file: File,
-          options: Omit<UploadOptions, 'destination'>,
+          options: Omit<UploadOptions, 'destination'>
         ) {
           await bucket.upload(filePath, {
             destination: file,
@@ -3218,6 +3403,7 @@ describe('storage', function () {
       await assert.rejects(channel.stop(), (err: GaxiosError) => {
         assert.strictEqual((err as GaxiosError).code, 404);
         assert.strictEqual(err!.message.indexOf("Channel 'id' not found"), 0);
+        return true;
       });
     });
   });
@@ -3238,13 +3424,13 @@ describe('storage', function () {
       const [contents] = await destinationFile.download();
       assert.strictEqual(
         contents.toString(),
-        files.map(x => x.contents).join(''),
+        files.map(x => x.contents).join('')
       );
 
       await Promise.all(
         sourceFiles
           .concat([destinationFile])
-          .map(file => deleteFileAsync(file)),
+          .map(file => deleteFileAsync(file))
       );
     });
   });
@@ -3270,7 +3456,7 @@ describe('storage', function () {
       const ms = Math.pow(2, retries) * 1000 + Math.random() * 1000;
       return new Promise(done => {
         console.info(
-          `retrying "${test.title}" with accessId ${accessId} in ${ms}ms`,
+          `retrying "${test.title}" with accessId ${accessId} in ${ms}ms`
         );
         setTimeout(done, ms);
       });
@@ -3312,7 +3498,7 @@ describe('storage', function () {
       assert(hmacKeys.length > 0);
       assert(
         hmacKeys.some(hmacKey => hmacKey.id === accessId),
-        'created HMAC key not found from getHmacKeys result',
+        'created HMAC key not found from getHmacKeys result'
       );
     });
 
@@ -3341,7 +3527,7 @@ describe('storage', function () {
       assert(Array.isArray(hmacKeys));
       assert(
         !hmacKeys.some(hmacKey => hmacKey.id === accessId),
-        'deleted HMAC key is found from getHmacKeys result',
+        'deleted HMAC key is found from getHmacKeys result'
       );
     });
 
@@ -3373,20 +3559,22 @@ describe('storage', function () {
           projectId: HMAC_PROJECT,
         });
 
-        const [hmacKeys] = await storage.getHmacKeys({projectId: HMAC_PROJECT});
+        const [hmacKeys] = await storage.getHmacKeys({
+          projectId: HMAC_PROJECT,
+        });
         assert(
           hmacKeys.some(
             hmacKey =>
-              hmacKey.metadata!.serviceAccountEmail === SERVICE_ACCOUNT,
+              hmacKey.metadata!.serviceAccountEmail === SERVICE_ACCOUNT
           ),
-          `Expected at least 1 key for service account: ${SERVICE_ACCOUNT}`,
+          `Expected at least 1 key for service account: ${SERVICE_ACCOUNT}`
         );
         assert(
           hmacKeys.some(
             hmacKey =>
-              hmacKey.metadata!.serviceAccountEmail === SECOND_SERVICE_ACCOUNT,
+              hmacKey.metadata!.serviceAccountEmail === SECOND_SERVICE_ACCOUNT
           ),
-          `Expected at least 1 key for service account: ${SECOND_SERVICE_ACCOUNT}`,
+          `Expected at least 1 key for service account: ${SECOND_SERVICE_ACCOUNT}`
         );
       });
 
@@ -3398,9 +3586,9 @@ describe('storage', function () {
         assert(
           hmacKeys.every(
             hmacKey =>
-              hmacKey.metadata!.serviceAccountEmail === SECOND_SERVICE_ACCOUNT,
+              hmacKey.metadata!.serviceAccountEmail === SECOND_SERVICE_ACCOUNT
           ),
-          'HMAC key belonging to other service accounts unexpected',
+          'HMAC key belonging to other service accounts unexpected'
         );
       });
     });
@@ -3459,10 +3647,11 @@ describe('storage', function () {
         autoPaginate: false,
       });
 
-      assert.deepStrictEqual(
-        (result as {prefixes: string[]}).prefixes,
-        expected,
-      );
+      const actualPrefixes =
+        (result as GaxiosResponse).data?.prefixes ??
+        (result as {prefixes: string[]}).prefixes;
+
+      assert.deepStrictEqual(actualPrefixes, expected);
     });
 
     it('should get files as a stream', done => {
@@ -3602,7 +3791,7 @@ describe('storage', function () {
       assert.strictEqual(files![0].name, files![1].name);
       assert.notStrictEqual(
         files![0].metadata.generation,
-        files![1].metadata.generation,
+        files![1].metadata.generation
       );
     });
 
@@ -3615,10 +3804,11 @@ describe('storage', function () {
       await assert.rejects(
         bucketWithVersioning.file(fileName, {generation: 0}).save('hello2'),
         (err: GaxiosError) => {
-          assert.strictEqual(err.status, 412);
-          assert.strictEqual(err.message, 'conditionNotMet');
+          const status = err.response ? err.response.status : Number(err.code);
+          assert.strictEqual(status, 412);
+          assert.ok(err.message.includes('pre-conditions'));
           return true;
-        },
+        }
       );
       await bucketWithVersioning
         .file(fileName)
@@ -3679,7 +3869,7 @@ describe('storage', function () {
       await fetch(signedDeleteUrl, {method: 'DELETE'});
       await assert.rejects(
         () => file.getMetadata(),
-        (err: GaxiosError) => err.status === 404,
+        (err: GaxiosError) => err.status === 404
       );
     });
   });
@@ -3753,10 +3943,10 @@ describe('storage', function () {
           assert(err instanceof Error);
           assert.strictEqual(
             err.message,
-            `Max allowed expiration is seven days (${SEVEN_DAYS_IN_SECONDS.toString()} seconds).`,
+            `Max allowed expiration is seven days (${SEVEN_DAYS_IN_SECONDS.toString()} seconds).`
           );
           return true;
-        },
+        }
       );
     });
 
@@ -3939,7 +4129,7 @@ describe('storage', function () {
         topic.name,
         {
           eventTypes: ['OBJECT_FINALIZE'],
-        },
+        }
       );
       notification = createNotificationData[0];
       subscription = topic.subscription(generateName());
@@ -3947,7 +4137,7 @@ describe('storage', function () {
     });
 
     after(async () => {
-      await subscription.delete();
+      await subscription?.delete().catch(() => {});
       const notifications = await bucket.getNotifications();
       const notificationsToDelete = notifications[0].map(notification => {
         return notification.delete();
@@ -4064,10 +4254,10 @@ describe('storage', function () {
       const TEST_UNIVERSE_DOMAIN = isNullOrUndefined('TEST_UNIVERSE_DOMAIN');
       const TEST_PROJECT_ID = isNullOrUndefined('TEST_UNIVERSE_PROJECT_ID');
       const TEST_UNIVERSE_LOCATION = isNullOrUndefined(
-        'TEST_UNIVERSE_LOCATION',
+        'TEST_UNIVERSE_LOCATION'
       );
       const CREDENTIAL_PATH = isNullOrUndefined(
-        'TEST_UNIVERSE_DOMAIN_CREDENTIAL',
+        'TEST_UNIVERSE_DOMAIN_CREDENTIAL'
       );
       // Create a client with universe domain credentials
       universeDomainStorage = new Storage({
@@ -4134,13 +4324,13 @@ describe('storage', function () {
   function deleteBucket(
     bucket: Bucket,
     options: {},
-    callback: DeleteBucketCallback,
+    callback: DeleteBucketCallback
   ): void;
   function deleteBucket(bucket: Bucket, callback: DeleteBucketCallback): void;
   function deleteBucket(
     bucket: Bucket,
     optsOrCb: {} | DeleteBucketCallback,
-    callback?: DeleteBucketCallback,
+    callback?: DeleteBucketCallback
   ) {
     let options = typeof optsOrCb === 'object' ? optsOrCb : {};
     callback =
@@ -4169,8 +4359,20 @@ describe('storage', function () {
     });
   }
 
-  function deleteFileAsync(file: File) {
-    return file.delete();
+  async function deleteFileAsync(file: File) {
+    try {
+      return await file.delete();
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (err: any) {
+      const status =
+        err.status || (err.response && err.response.status) || err.code;
+
+      if (status === 404 || err.message.includes('No such object')) {
+        return;
+      }
+      // If it's a different error (like a 403 or 500), we still want to know.
+      throw err;
+    }
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -4190,10 +4392,10 @@ describe('storage', function () {
     const [buckets] = await storage.getBuckets({prefix: TESTS_PREFIX});
     const limit = pLimit(10);
     await new Promise(resolve =>
-      setTimeout(resolve, RETENTION_DURATION_SECONDS * 1000),
+      setTimeout(resolve, RETENTION_DURATION_SECONDS * 1000)
     );
     return Promise.all(
-      buckets.map(bucket => limit(() => deleteBucketAsync(bucket))),
+      buckets.map(bucket => limit(() => deleteBucketAsync(bucket)))
     );
   }
 
@@ -4205,7 +4407,7 @@ describe('storage', function () {
     });
     const limit = pLimit(10);
     return Promise.all(
-      filteredTopics.map(topic => limit(() => deleteTopicAsync(topic))),
+      filteredTopics.map(topic => limit(() => deleteTopicAsync(topic)))
     );
   }
 
@@ -4232,7 +4434,7 @@ describe('storage', function () {
 
   async function deleteStaleHmacKeys(
     serviceAccountEmail: string,
-    projectId: string,
+    projectId: string
   ) {
     const old = new Date();
     old.setHours(old.getHours() - 1);
@@ -4252,8 +4454,8 @@ describe('storage', function () {
           limit(async () => {
             await hmacKey.setMetadata({state: 'INACTIVE'});
             await hmacKey.delete();
-          }),
-        ),
+          })
+        )
     );
   }
 
diff --git a/handwritten/storage/test/acl.ts b/handwritten/storage/test/acl.ts
index 2cf6c47b388..922d05d313b 100644
--- a/handwritten/storage/test/acl.ts
+++ b/handwritten/storage/test/acl.ts
@@ -62,7 +62,7 @@ describe('storage/acl', () => {
     it('should make the correct api request', () => {
       acl.storageTransport.makeRequest = sandbox.stub().callsFake(reqOpts => {
         assert.strictEqual(reqOpts.method, 'POST');
-        assert.strictEqual(reqOpts.url, '/bucket/acl');
+        assert.strictEqual(reqOpts.url, '/storage/v1/b/bucket/acl');
         assert.deepStrictEqual(JSON.parse(reqOpts.body), {
           entity: ENTITY,
           role: ROLE,
@@ -166,7 +166,10 @@ describe('storage/acl', () => {
     it('should make the correct api request', () => {
       acl.storageTransport.makeRequest = sandbox.stub().callsFake(reqOpts => {
         assert.strictEqual(reqOpts.method, 'DELETE');
-        assert.strictEqual(reqOpts.url, `/bucket/acl/${ENTITY}`);
+        assert.strictEqual(
+          reqOpts.url,
+          `/storage/v1/b/bucket/acl/${encodeURIComponent(ENTITY)}`,
+        );
         return Promise.resolve();
       });
 
@@ -240,7 +243,7 @@ describe('storage/acl', () => {
     describe('all ACL objects', () => {
       it('should make the correct API request', () => {
         acl.storageTransport.makeRequest = sandbox.stub().callsFake(reqOpts => {
-          assert.strictEqual(reqOpts.url, '/bucket/acl');
+          assert.strictEqual(reqOpts.url, '/storage/v1/b/bucket/acl');
 
           return Promise.resolve();
         });
@@ -295,7 +298,10 @@ describe('storage/acl', () => {
     describe('ACL object for an entity', () => {
       it('should get a specific ACL object', () => {
         acl.storageTransport.makeRequest = sandbox.stub().callsFake(reqOpts => {
-          assert.strictEqual(reqOpts.url, `/bucket/acl/${ENTITY}`);
+          assert.strictEqual(
+            reqOpts.url,
+            `/storage/v1/b/bucket/acl/${encodeURIComponent(ENTITY)}`,
+          );
           return Promise.resolve();
         });
 
@@ -408,7 +414,10 @@ describe('storage/acl', () => {
     it('should make the correct API request', () => {
       acl.storageTransport.makeRequest = sandbox.stub().callsFake(reqOpts => {
         assert.strictEqual(reqOpts.method, 'PUT');
-        assert.strictEqual(reqOpts.url, `/bucket/acl/${ENTITY}`);
+        assert.strictEqual(
+          reqOpts.url,
+          `/storage/v1/b/bucket/acl/${encodeURIComponent(ENTITY)}`,
+        );
         assert.deepStrictEqual(JSON.parse(reqOpts.body), {role: ROLE});
         return Promise.resolve();
       });
diff --git a/handwritten/storage/test/bucket.ts b/handwritten/storage/test/bucket.ts
index 42c93ae4a6f..be1c6849d70 100644
--- a/handwritten/storage/test/bucket.ts
+++ b/handwritten/storage/test/bucket.ts
@@ -99,7 +99,7 @@ describe('Bucket', () => {
           .stub()
           .callsFake((reqOpts, callback) => {
             assert.strictEqual(reqOpts.method, 'POST');
-            assert.strictEqual(reqOpts.url, '/b');
+            assert.strictEqual(reqOpts.url, '/storage/v1/b');
             assert.deepStrictEqual(
               reqOpts.queryParameters!.userProject,
               options.userProject,
@@ -127,7 +127,7 @@ describe('Bucket', () => {
           .stub()
           .callsFake(reqOpts => {
             assert.strictEqual(reqOpts.method, 'DELETE');
-            assert.strictEqual(reqOpts.url, `/b/${BUCKET_NAME}`);
+            assert.strictEqual(reqOpts.url, `/storage/v1/b/${BUCKET_NAME}`);
             assert.deepStrictEqual(
               reqOpts.queryParameters!.userProject,
               options.userProject,
@@ -156,7 +156,7 @@ describe('Bucket', () => {
           .stub()
           .callsFake(reqOpts => {
             assert.strictEqual(reqOpts.method, 'GET');
-            assert.strictEqual(reqOpts.url, `/b/${BUCKET_NAME}`);
+            assert.strictEqual(reqOpts.url, `/storage/v1/b/${BUCKET_NAME}`);
             assert.deepStrictEqual(
               reqOpts.queryParameters!.userProject,
               options.userProject,
@@ -185,7 +185,7 @@ describe('Bucket', () => {
           .stub()
           .callsFake(reqOpts => {
             assert.strictEqual(reqOpts.method, 'GET');
-            assert.strictEqual(reqOpts.url, `/b/${BUCKET_NAME}`);
+            assert.strictEqual(reqOpts.url, `/storage/v1/b/${BUCKET_NAME}`);
             assert.deepStrictEqual(
               reqOpts.queryParameters!.userProject,
               options.userProject,
@@ -214,7 +214,7 @@ describe('Bucket', () => {
           .stub()
           .callsFake(reqOpts => {
             assert.strictEqual(reqOpts.method, 'GET');
-            assert.strictEqual(reqOpts.url, `/b/${BUCKET_NAME}`);
+            assert.strictEqual(reqOpts.url, `/storage/v1/b/${BUCKET_NAME}`);
             assert.deepStrictEqual(
               reqOpts.queryParameters!.userProject,
               options.userProject,
@@ -247,7 +247,7 @@ describe('Bucket', () => {
           .stub()
           .callsFake(reqOpts => {
             assert.strictEqual(reqOpts.method, 'PATCH');
-            assert.strictEqual(reqOpts.url, `/b/${BUCKET_NAME}`);
+            assert.strictEqual(reqOpts.url, `/storage/v1/b/${BUCKET_NAME}`);
             assert.deepStrictEqual(
               reqOpts.queryParameters!.versioning,
               options.versioning,
@@ -570,7 +570,10 @@ describe('Bucket', () => {
         .callsFake(reqOpts => {
           const body = JSON.parse(reqOpts.body);
           assert.strictEqual(reqOpts.method, 'POST');
-          assert.strictEqual(reqOpts.url, '/compose');
+          assert.strictEqual(
+            reqOpts.url,
+            '/storage/v1/b/test-bucket/o/destination.txt/compose',
+          );
           assert.strictEqual(body.sourceObjects[0].name, file1.name);
           assert.strictEqual(body.sourceObjects[1].name, file2.name);
           done();
@@ -640,7 +643,10 @@ describe('Bucket', () => {
 
       storageTransport.makeRequest = sandbox.stub().callsFake(reqOpts => {
         const body = JSON.parse(reqOpts.body);
-        assert.strictEqual(reqOpts.url, '/compose');
+        assert.strictEqual(
+          reqOpts.url,
+          '/storage/v1/b/test-bucket/o/destination.foo/compose',
+        );
         assert.deepStrictEqual(body, {
           destination: {},
           sourceObjects: [{name: sources[0].name}, {name: sources[1].name}],
@@ -827,7 +833,10 @@ describe('Bucket', () => {
         .stub()
         .callsFake(reqOpts => {
           assert.strictEqual(reqOpts.method, 'POST');
-          assert.strictEqual(reqOpts.url, `/b/${BUCKET_NAME}/o/watch`);
+          assert.strictEqual(
+            reqOpts.url,
+            `/storage/v1/b/${BUCKET_NAME}/o/watch`,
+          );
 
           const expectedJson = Object.assign({}, config, {
             id: ID,
@@ -955,7 +964,7 @@ describe('Bucket', () => {
           assert.strictEqual(reqOpts.method, 'POST');
           assert.strictEqual(
             reqOpts.url,
-            `/b/${BUCKET_NAME}/notificationConfigs`,
+            `/storage/v1/b/${BUCKET_NAME}/notificationConfigs`,
           );
           assert.deepStrictEqual(JSON.parse(reqOpts.body), expectedJson);
           assert.notStrictEqual(reqOpts.body, options);
@@ -1644,7 +1653,7 @@ describe('Bucket', () => {
       bucket.storageTransport.makeRequest = sandbox
         .stub()
         .callsFake(reqOpts => {
-          assert.strictEqual(reqOpts.url, `/b/${BUCKET_NAME}/o`);
+          assert.strictEqual(reqOpts.url, `/storage/v1/b/${BUCKET_NAME}/o`);
           assert.deepStrictEqual(reqOpts.queryParameters, {});
         });
 
@@ -1917,7 +1926,7 @@ describe('Bucket', () => {
         .callsFake(reqOpts => {
           assert.strictEqual(
             reqOpts.url,
-            `/b/${BUCKET_NAME}/notificationConfigs`,
+            `/storage/v1/b/${BUCKET_NAME}/notificationConfigs`,
           );
           assert.strictEqual(reqOpts.queryParameters, options);
           done();
@@ -2072,7 +2081,7 @@ describe('Bucket', () => {
         .callsFake((reqOpts, callback) => {
           assert.deepStrictEqual(reqOpts, {
             method: 'POST',
-            url: `/b/${BUCKET_NAME}/lockRetentionPolicy`,
+            url: `/storage/v1/b/${BUCKET_NAME}/lockRetentionPolicy`,
             queryParameters: {
               ifMetagenerationMatch: metageneration,
             },
@@ -2293,7 +2302,7 @@ describe('Bucket', () => {
         .callsFake(reqOpts => {
           assert.deepStrictEqual(reqOpts, {
             method: 'POST',
-            url: `/b/${BUCKET_NAME}/restore`,
+            url: `/storage/v1/b/${BUCKET_NAME}/restore`,
             queryParameters: {generation: '123456789'},
           });
           return [];
diff --git a/handwritten/storage/test/channel.ts b/handwritten/storage/test/channel.ts
index 0e9f8034957..90f2813cfbf 100644
--- a/handwritten/storage/test/channel.ts
+++ b/handwritten/storage/test/channel.ts
@@ -62,7 +62,7 @@ describe('Channel', () => {
         .stub()
         .callsFake(reqOpts => {
           assert.strictEqual(reqOpts.method, 'POST');
-          assert.strictEqual(reqOpts.url, '/channels/stop');
+          assert.strictEqual(reqOpts.url, '/storage/v1/channels/stop');
           assert.deepStrictEqual(JSON.parse(reqOpts.body), channel.metadata);
 
           return Promise.resolve();
diff --git a/handwritten/storage/test/file.ts b/handwritten/storage/test/file.ts
index ca58296702b..f6e664c138d 100644
--- a/handwritten/storage/test/file.ts
+++ b/handwritten/storage/test/file.ts
@@ -156,7 +156,10 @@ describe('File', () => {
           .stub()
           .callsFake(reqOpts => {
             assert.strictEqual(reqOpts.method, 'DELETE');
-            assert.strictEqual(reqOpts.url, '/b/bucket-name/o/file-name.png');
+            assert.strictEqual(
+              reqOpts.url,
+              '/storage/v1/b/bucket-name/o/file-name.png',
+            );
             assert.deepStrictEqual(
               reqOpts.queryParameters.generation,
               options.generation,
@@ -214,7 +217,10 @@ describe('File', () => {
           .stub()
           .callsFake((reqOpts, callback) => {
             assert.strictEqual(reqOpts.method, 'GET');
-            assert.strictEqual(reqOpts.url, '/b/bucket-name/o/file-name.png');
+            assert.strictEqual(
+              reqOpts.url,
+              '/storage/v1/b/bucket-name/o/file-name.png',
+            );
             assert.deepStrictEqual(
               reqOpts.queryParameters.generation,
               options.generation,
@@ -272,7 +278,10 @@ describe('File', () => {
           .stub()
           .callsFake((reqOpts, callback) => {
             assert.strictEqual(reqOpts.method, 'GET');
-            assert.strictEqual(reqOpts.url, '/b/bucket-name/o/file-name.png');
+            assert.strictEqual(
+              reqOpts.url,
+              '/storage/v1/b/bucket-name/o/file-name.png',
+            );
             assert.deepStrictEqual(
               reqOpts.queryParameters.generation,
               options.generation,
@@ -330,7 +339,10 @@ describe('File', () => {
           .stub()
           .callsFake((reqOpts, callback) => {
             assert.strictEqual(reqOpts.method, 'GET');
-            assert.strictEqual(reqOpts.url, '/b/bucket-name/o/file-name.png');
+            assert.strictEqual(
+              reqOpts.url,
+              '/storage/v1/b/bucket-name/o/file-name.png',
+            );
             assert.deepStrictEqual(
               reqOpts.queryParameters.generation,
               options.generation,
@@ -382,7 +394,10 @@ describe('File', () => {
           .callsFake((reqOpts, callback) => {
             const body = JSON.parse(reqOpts.body);
             assert.strictEqual(reqOpts.method, 'PATCH');
-            assert.strictEqual(reqOpts.url, '/b/bucket-name/o/file-name.png');
+            assert.strictEqual(
+              reqOpts.url,
+              '/storage/v1/b/bucket-name/o/file-name.png',
+            );
             assert.deepStrictEqual(body.temporaryHold, options.temporaryHold);
             callback(null);
             return Promise.resolve();
@@ -448,7 +463,7 @@ describe('File', () => {
     it('should URI encode file names', done => {
       const newFile = new File(BUCKET, 'nested/file.jpg');
 
-      const expectedPath = `/b/${BUCKET.name}/o/${encodeURIComponent(directoryFile.name)}/rewriteTo/b/${
+      const expectedPath = `/storage/v1/b/${BUCKET.name}/o/${encodeURIComponent(directoryFile.name)}/rewriteTo/b/${
         file.bucket.name
       }/o/${encodeURIComponent(newFile.name)}`;
 
@@ -553,6 +568,7 @@ describe('File', () => {
         assert.deepStrictEqual(
           Object.fromEntries((reqOpts.headers as Headers).entries()),
           {
+            'content-type': 'application/json',
             'x-goog-copy-source-encryption-algorithm': 'AES256',
             'x-goog-copy-source-encryption-key': file.encryptionKeyBase64,
             'x-goog-copy-source-encryption-key-sha256': file.encryptionKeyHash,
@@ -566,19 +582,42 @@ describe('File', () => {
 
     it('should set encryption key on the new File instance', done => {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      let file: any;
-      // eslint-disable-next-line prefer-const, @typescript-eslint/no-explicit-any
-      file = new (File as any)(BUCKET, FILE_NAME);
+      const file = new (File as any)(BUCKET, FILE_NAME);
+      Object.assign(file, {
+        encryptionKey: 'source-key',
+        encryptionKeyBase64: 'base64',
+        encryptionKeyHash: 'hash',
+      });
 
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const newFile = new (File as any)(BUCKET, 'new-file');
-      newFile.encryptionKey = 'encryptionKey';
-
-      file.setEncryptionKey = sandbox.stub().callsFake(encryptionKey => {
-        assert.strictEqual(encryptionKey, newFile.encryptionKey);
-        done();
+      Object.assign(newFile, {
+        encryptionKey: 'dest-key',
+        encryptionKeyBase64: 'base64-dest',
+        encryptionKeyHash: 'hash-dest',
       });
 
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      storageTransport.makeRequest = async (reqOpts: any, callback: any) => {
+        const actualHeaders = Object.fromEntries(reqOpts.headers.entries());
+
+        try {
+          assert.deepStrictEqual(actualHeaders, {
+            'content-type': 'application/json',
+            'x-goog-copy-source-encryption-algorithm': 'AES256',
+            'x-goog-copy-source-encryption-key': 'base64',
+            'x-goog-copy-source-encryption-key-sha256': 'hash',
+            'x-goog-encryption-algorithm': 'AES256',
+            'x-goog-encryption-key': 'base64-dest',
+            'x-goog-encryption-key-sha256': 'hash-dest',
+          });
+          callback?.(null, {done: true}, {});
+          done();
+        } catch (e) {
+          done(e);
+        }
+      };
+
       file.copy(newFile, assert.ifError);
     });
 
@@ -685,7 +724,7 @@ describe('File', () => {
       it('should allow a string', done => {
         const newFileName = 'new-file-name.png';
         const newFile = new File(BUCKET, newFileName);
-        const expectedPath = `/b/${BUCKET.name}/o/${encodeURIComponent(file.name)}/rewriteTo/b/${file.bucket.name}/o/${newFile.name}`;
+        const expectedPath = `/storage/v1/b/${BUCKET.name}/o/${encodeURIComponent(file.name)}/rewriteTo/b/${file.bucket.name}/o/${newFile.name}`;
         assertPathEquals(file, expectedPath, done);
         file.copy(newFileName, done);
       });
@@ -694,7 +733,7 @@ describe('File', () => {
         const newFileName = '/new-file-name.png';
         const newFile = new File(BUCKET, newFileName);
         // File uri encodes file name when calling this.request during copy
-        const expectedPath = `/b/${BUCKET.name}/o/${encodeURIComponent(file.name)}/rewriteTo/b/${
+        const expectedPath = `/storage/v1/b/${BUCKET.name}/o/${encodeURIComponent(file.name)}/rewriteTo/b/${
           file.bucket.name
         }/o/${encodeURIComponent(newFile.name)}`;
         assertPathEquals(file, expectedPath, done);
@@ -703,20 +742,20 @@ describe('File', () => {
 
       it('should allow a "gs://..." string', done => {
         const newFileName = 'gs://other-bucket/new-file-name.png';
-        const expectedPath = `/b/${BUCKET.name}/o/${file.name}/rewriteTo/b/other-bucket/o/new-file-name.png`;
+        const expectedPath = `/storage/v1/b/${BUCKET.name}/o/${file.name}/rewriteTo/b/other-bucket/o/new-file-name.png`;
         assertPathEquals(file, expectedPath, done);
         file.copy(newFileName, done);
       });
 
       it('should allow a Bucket', done => {
-        const expectedPath = `/b/${BUCKET.name}/o/${file.name}/rewriteTo/b/${BUCKET.name}/o/${file.name}`;
+        const expectedPath = `/storage/v1/b/${BUCKET.name}/o/${file.name}/rewriteTo/b/${BUCKET.name}/o/${file.name}`;
         assertPathEquals(file, expectedPath, done);
         file.copy(BUCKET, done);
       });
 
       it('should allow a File', done => {
         const newFile = new File(BUCKET, 'new-file');
-        const expectedPath = `/b/${BUCKET.name}/o/${file.name}/rewriteTo/b/${BUCKET.name}/o/${newFile.name}`;
+        const expectedPath = `/storage/v1/b/${BUCKET.name}/o/${file.name}/rewriteTo/b/${BUCKET.name}/o/${newFile.name}`;
         assertPathEquals(file, expectedPath, done);
         file.copy(newFile, done);
       });
@@ -963,11 +1002,12 @@ describe('File', () => {
       it('should create an authenticated request', () => {
         file.storageTransport.makeRequest = sandbox.stub().callsFake(opts => {
           assert.deepStrictEqual(opts, {
-            url: '/b/bucket-name/o/file-name.png',
+            url: '/storage/v1/b/bucket-name/o/file-name.png',
             headers: {
               'Accept-Encoding': 'gzip',
               'Cache-Control': 'no-store',
             },
+            decompress: true,
             responseType: 'stream',
             queryParameters: {
               alt: 'media',
@@ -3649,81 +3689,99 @@ describe('File', () => {
   });
 
   describe('isPublic', () => {
-    it('should execute callback with `true` in response', () => {
+    it('should execute callback with `true` in response', done => {
+      file.storageTransport.makeRequest = sandbox
+        .stub()
+        .callsFake((reqOpts, callback) => {
+          callback(null, {}, {});
+          return Promise.resolve();
+        });
+
       file.isPublic((err, resp) => {
         assert.ifError(err);
         assert.strictEqual(resp, true);
+        done();
       });
     });
 
-    it('should execute callback with `false` in response', () => {
+    it('should execute callback with `false` in response on 403', done => {
       file.storageTransport.makeRequest = sandbox
         .stub()
-        .callsFake((reqOpts, config, callback) => {
+        .callsFake((reqOpts, callback) => {
           const error = new GaxiosError(
             'Permission Denied.',
             {} as GaxiosOptionsPrepared,
           );
-          error.status = 403;
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          error.response = {status: 403} as any;
           callback(error);
+          return Promise.resolve();
         });
       file.isPublic((err, resp) => {
         assert.ifError(err);
         assert.strictEqual(resp, false);
+        done();
       });
     });
 
-    it('should propagate non-403 errors to user', () => {
+    it('should propagate non-403 errors to user', done => {
       const error = new GaxiosError('400 Error.', {} as GaxiosOptionsPrepared);
-      error.status = 400;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      error.response = {status: 400} as any;
       file.storageTransport.makeRequest = sandbox
         .stub()
-        .callsFake((reqOpts, config, callback) => {
+        .callsFake((reqOpts, callback) => {
           callback(error);
+          return Promise.resolve();
         });
       file.isPublic(err => {
         assert.strictEqual(err, error);
+        done();
       });
     });
 
     it('should correctly send a GET request', () => {
       file.storageTransport.makeRequest = sandbox
         .stub()
-        .callsFake((reqOpts, config, callback) => {
+        .callsFake((reqOpts, callback) => {
           assert.strictEqual(reqOpts.method, 'GET');
           callback(null);
+          return Promise.resolve();
         });
       file.isPublic(err => {
         assert.ifError(err);
       });
     });
 
-    it('should correctly format URL in the request', () => {
+    it('should correctly format URL in the request', done => {
       file = new File(BUCKET, 'my#file$.png');
-      const expectedURL = `https://storage.googleapis.com/${
-        BUCKET.name
-      }/${encodeURIComponent(file.name)}`;
+      const expectedPath = `/${BUCKET.name}/${encodeURIComponent(file.name)}`;
 
       file.storageTransport.makeRequest = sandbox
         .stub()
-        .callsFake((reqOpts, config, callback) => {
-          assert.strictEqual(reqOpts.uri, expectedURL);
+        .callsFake((reqOpts, callback) => {
+          assert.strictEqual(reqOpts.method, 'GET');
+          assert.strictEqual(reqOpts.url, expectedPath);
           callback(null);
+          return Promise.resolve();
         });
       file.isPublic(err => {
         assert.ifError(err);
+        done();
       });
     });
 
-    it('should not set any headers when there are no interceptors', () => {
+    it('should not set any headers when there are no interceptors', done => {
       file.storageTransport.makeRequest = sandbox
         .stub()
-        .callsFake((reqOpts, config, callback) => {
-          assert.deepStrictEqual(reqOpts.headers, {});
+        .callsFake((reqOpts, callback) => {
+          assert.deepStrictEqual(reqOpts.headers, undefined);
           callback(null);
+          return Promise.resolve();
         });
       file.isPublic(err => {
         assert.ifError(err);
+        done();
       });
     });
   });
@@ -3755,7 +3813,7 @@ describe('File', () => {
     it('should URI encode file names', async () => {
       const newFile = new File(BUCKET, 'nested/file.jpg');
 
-      const expectedPath = `/b/${BUCKET.id}/o/${directoryFile.id}/moveTo/o/${encodeURIComponent(newFile.name)}`;
+      const expectedPath = `/storage/v1/b/${BUCKET.id}/o/${directoryFile.id}/moveTo/o/${encodeURIComponent(newFile.name)}`;
 
       directoryFile.storageTransport.makeRequest = sandbox
         .stub()
@@ -3858,7 +3916,7 @@ describe('File', () => {
       it('should allow a string', async done => {
         const newFileName = 'new-file-name.png';
         const newFile = new File(BUCKET, newFileName);
-        const expectedPath = `/b/${BUCKET.id}/o/${file.id}/moveTo/o/${newFile.name}`;
+        const expectedPath = `/storage/v1/b/${BUCKET.id}/o/${file.id}/moveTo/o/${newFile.name}`;
         assertPathEquals(file, expectedPath, done);
         await file.moveFileAtomic(newFileName);
       });
@@ -3866,21 +3924,21 @@ describe('File', () => {
       it('should allow a string with leading slash.', async done => {
         const newFileName = '/new-file-name.png';
         const newFile = new File(BUCKET, newFileName);
-        const expectedPath = `/b/${BUCKET.id}/o/${file.id}/moveTo/o/${encodeURIComponent(newFile.name)}`;
+        const expectedPath = `/storage/v1/b/${BUCKET.id}/o/${file.id}/moveTo/o/${encodeURIComponent(newFile.name)}`;
         assertPathEquals(file, expectedPath, done);
         await file.moveFileAtomic(newFileName);
       });
 
       it('should allow a "gs://..." string', async done => {
         const newFileName = 'gs://other-bucket/new-file-name.png';
-        const expectedPath = `/b/${BUCKET.id}/o/${file.id}/moveTo/o/new-file-name.png`;
+        const expectedPath = `/storage/v1/b/${BUCKET.id}/o/${file.id}/moveTo/o/new-file-name.png`;
         assertPathEquals(file, expectedPath, done);
         await file.moveFileAtomic(newFileName);
       });
 
       it('should allow a File', async done => {
         const newFile = new File(BUCKET, 'new-file');
-        const expectedPath = `/b/${BUCKET.id}/o/${file.id}/moveTo/o/${newFile.name}`;
+        const expectedPath = `/storage/v1/b/${BUCKET.id}/o/${file.id}/moveTo/o/${newFile.name}`;
         assertPathEquals(file, expectedPath, done);
         await file.moveFileAtomic(newFile);
       });
@@ -4153,7 +4211,7 @@ describe('File', () => {
         .callsFake((reqOpts, callback_) => {
           assert.deepStrictEqual(reqOpts, {
             method: 'POST',
-            url: `/b/${file.bucket.name}/o/${encodeURIComponent(file.name)}/restore`,
+            url: `/storage/v1/b/${file.bucket.name}/o/${encodeURIComponent(file.name)}/restore`,
             queryParameters: {generation: 123},
           });
           assert.strictEqual(callback_, undefined);
diff --git a/handwritten/storage/test/headers.ts b/handwritten/storage/test/headers.ts
index a3632ea8543..a9826f93370 100644
--- a/handwritten/storage/test/headers.ts
+++ b/handwritten/storage/test/headers.ts
@@ -76,9 +76,18 @@ describe('headers', () => {
   it('populates x-goog-api-client header (node)', async () => {
     const bucket = storage.bucket('foo-bucket');
     authClient.request = opts => {
+      let apiClientHeader: string | null = '';
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if (typeof (opts.headers as any).get === 'function') {
+        apiClientHeader = (opts.headers as Headers).get('x-goog-api-client');
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        apiClientHeader = (opts.headers as any)['x-goog-api-client'];
+      }
       assert.ok(
         /^gl-node\/(?<nodeVersion>[^W]+) gccl\/(?<gccl>[^W]+) gccl-invocation-id\/(?<gcclInvocationId>[^W]+)$/.test(
-          (opts.headers as Headers).get('x-goog-api-client')!,
+          apiClientHeader!,
         ),
       );
       return Promise.resolve(gaxiosResponse);
@@ -94,9 +103,18 @@ describe('headers', () => {
   it('populates x-goog-api-client header (deno)', async () => {
     const bucket = storage.bucket('foo-bucket');
     authClient.request = opts => {
+      let apiClientHeader: string | null = '';
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if (typeof (opts.headers as any).get === 'function') {
+        apiClientHeader = (opts.headers as Headers).get('x-goog-api-client');
+      } else {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        apiClientHeader = (opts.headers as any)['x-goog-api-client'];
+      }
       assert.ok(
         /^gl-deno\/0.00.0 gccl\/(?<gccl>[^W]+) gccl-invocation-id\/(?<gcclInvocationId>[^W]+)$/.test(
-          (opts.headers as Headers).get('x-goog-api-client')!,
+          apiClientHeader!,
         ),
       );
       return Promise.resolve(gaxiosResponse);
diff --git a/handwritten/storage/test/iam.ts b/handwritten/storage/test/iam.ts
index ab2c6d9d0cc..89d480785dc 100644
--- a/handwritten/storage/test/iam.ts
+++ b/handwritten/storage/test/iam.ts
@@ -51,7 +51,8 @@ describe('storage/iam', () => {
         .stub()
         .callsFake((reqOpts, callback) => {
           assert.deepStrictEqual(reqOpts, {
-            url: '/iam',
+            method: 'GET',
+            url: `/storage/v1/b/${BUCKET_INSTANCE.name}/iam`,
             queryParameters: {},
           });
           callback(null);
@@ -107,9 +108,12 @@ describe('storage/iam', () => {
           reqOpts.body = JSON.parse(reqOpts.body);
           assert.deepStrictEqual(reqOpts, {
             method: 'PUT',
-            url: '/iam',
+            url: `/storage/v1/b/${BUCKET_INSTANCE.name}/iam`,
             maxRetries: 0,
-            body: Object.assign(policy, {resourceId: `buckets/${id}`}),
+            headers: {
+              'Content-Type': 'application/json',
+            },
+            body: Object.assign(policy),
             queryParameters: {},
           });
           callback(null);
@@ -147,7 +151,8 @@ describe('storage/iam', () => {
         .stub()
         .callsFake(reqOpts => {
           assert.deepStrictEqual(reqOpts, {
-            url: '/iam/testPermissions',
+            method: 'GET',
+            url: `/storage/v1/b/${BUCKET_INSTANCE.name}/iam/testPermissions`,
             queryParameters: {
               permissions: [permissions],
             },
diff --git a/handwritten/storage/test/index.ts b/handwritten/storage/test/index.ts
index d15b9e710f6..ff7c68acedd 100644
--- a/handwritten/storage/test/index.ts
+++ b/handwritten/storage/test/index.ts
@@ -625,7 +625,7 @@ describe('Storage', () => {
         .callsFake((reqOpts, callback) => {
           const body = JSON.parse(reqOpts.body);
           assert.strictEqual(reqOpts.method, 'POST');
-          assert.strictEqual(reqOpts.url, '/b');
+          assert.strictEqual(reqOpts.url, '/storage/v1/b');
           assert.strictEqual(
             reqOpts.queryParameters!.project,
             storage.projectId,
@@ -946,7 +946,7 @@ describe('Storage', () => {
       storage.storageTransport.makeRequest = sandbox
         .stub()
         .callsFake(reqOpts => {
-          assert.strictEqual(reqOpts.url, '/b');
+          assert.strictEqual(reqOpts.url, '/storage/v1/b');
           assert.deepStrictEqual(reqOpts.queryParameters, {
             project: storage.projectId,
           });
@@ -1184,7 +1184,7 @@ describe('Storage', () => {
         .callsFake(reqOpts => {
           assert.strictEqual(
             reqOpts.url,
-            `/projects/${storage.projectId}/serviceAccount`,
+            `/storage/v1/projects/${storage.projectId}/serviceAccount`,
           );
           assert.deepStrictEqual(reqOpts.queryParameters, {});
           done();
@@ -1202,7 +1202,7 @@ describe('Storage', () => {
       storage.storageTransport.makeRequest = sandbox
         .stub()
         .callsFake(reqOpts => {
-          assert.strictEqual(reqOpts.queryParameters, options);
+          assert.deepStrictEqual(reqOpts.queryParameters, options);
           done();
         });
 
diff --git a/handwritten/storage/test/storage-transport.ts b/handwritten/storage/test/storage-transport.ts
index 4b71c8fa9d6..a4c936a190b 100644
--- a/handwritten/storage/test/storage-transport.ts
+++ b/handwritten/storage/test/storage-transport.ts
@@ -75,10 +75,10 @@ describe('Storage Transport', () => {
       calledWith.url.href,
       `${baseUrl}/bucket/object?alt=json&userProject=user-project`,
     );
-    assert.strictEqual(calledWith.headers.get('content-encoding'), 'gzip');
-    assert.ok(
-      calledWith.headers.get('User-Agent').includes('gcloud-node-storage/'),
-    );
+    assert.strictEqual(calledWith.headers['content-encoding'], 'gzip');
+    const headers = calledWith.headers;
+    const userAgent = headers['User-Agent'] || headers['user-agent'];
+    assert.ok(userAgent.includes('gcloud-node-storage/'));
     assert.deepStrictEqual(_response, response.data);
   });
 
@@ -113,9 +113,7 @@ describe('Storage Transport', () => {
       .args[0];
 
     assert.ok(
-      calledWith.headers
-        .get('x-goog-api-client')
-        .includes('gccl-gcs-cmd/test-key'),
+      calledWith.headers['x-goog-api-client'].includes('gccl-gcs-cmd/test-key'),
     );
   });