From 5907d3bc8806945b830453d57bc5d1978c00c8fb Mon Sep 17 00:00:00 2001
From: Thiyagu K <thiyaguk@google.com>
Date: Wed, 3 Sep 2025 07:40:50 +0000
Subject: [PATCH 01/11] feat(storagecontrol): Add samples for Storage Anywhere
 Cache

---
 storage-control/createAnywhereCache.js  | 106 ++++++++++++++++++++++++
 storage-control/disableAnywhereCache.js |  60 ++++++++++++++
 storage-control/getAnywhereCache.js     |  60 ++++++++++++++
 storage-control/listAnywhereCaches.js   |  56 +++++++++++++
 storage-control/package.json            |   4 +-
 storage-control/pauseAnywhereCache.js   |  60 ++++++++++++++
 storage-control/resumeAnywhereCache.js  |  60 ++++++++++++++
 storage-control/updateAnywhereCache.js  |  71 ++++++++++++++++
 8 files changed, 475 insertions(+), 2 deletions(-)
 create mode 100644 storage-control/createAnywhereCache.js
 create mode 100644 storage-control/disableAnywhereCache.js
 create mode 100644 storage-control/getAnywhereCache.js
 create mode 100644 storage-control/listAnywhereCaches.js
 create mode 100644 storage-control/pauseAnywhereCache.js
 create mode 100644 storage-control/resumeAnywhereCache.js
 create mode 100644 storage-control/updateAnywhereCache.js

diff --git a/storage-control/createAnywhereCache.js b/storage-control/createAnywhereCache.js
new file mode 100644
index 0000000000..cd3c691f7b
--- /dev/null
+++ b/storage-control/createAnywhereCache.js
@@ -0,0 +1,106 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+
+function main(bucketName, cacheName, zoneName) {
+  // [START storage_control_create_anywhere_cache]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+
+  // The name of your GCS bucket
+  // const bucketName = 'bucketName';
+
+  // The name of the cache to be created
+  // const cacheName = 'cacheName';
+
+  // The zone that the cache instance will run in.
+  // const zoneName = 'zoneName';
+
+  // Imports the Control library
+  const {StorageControlClient} = require('@google-cloud/storage-control').v2;
+
+  // Instantiates a client
+  const controlClient = new StorageControlClient();
+
+  async function callCreateAnywhereCache() {
+    const bucketPath = controlClient.bucketPath('_', bucketName);
+
+    // Create the request
+    const request = {
+      parent: bucketPath,
+      anywhereCache: {
+        name: cacheName,
+        zone: zoneName,
+      },
+    };
+
+    // Run the request, which returns an Operation object
+    const [operation] = await controlClient.createAnywhereCache(request);
+    console.log(`Waiting for operation ${operation.name} to complete...`);
+
+    // Wait for the operation to complete and get the final resource
+    const anywhereCache = await checkCreateAnywhereCacheProgress(
+      operation.name
+    );
+    console.log(`Created anywhere cache: ${anywhereCache.result.name}.`);
+  }
+
+  // A custom function to check the operation's progress.
+  async function checkCreateAnywhereCacheProgress(operationName) {
+    let operation = {done: false};
+    console.log('Starting manual polling for operation...');
+
+    // Poll the operation until it's done.
+    while (!operation.done) {
+      await new Promise(resolve => setTimeout(resolve, 180000)); // Wait for 3 minutes before the next check.
+      const request = {
+        name: operationName,
+      };
+      try {
+        const [latestOperation] = await controlClient.getOperation(request);
+        operation = latestOperation;
+      } catch (err) {
+        // Handle potential errors during polling.
+        console.error('Error while polling:', err.message);
+        break; // Exit the loop on error.
+      }
+    }
+
+    // Return the final result of the operation.
+    if (operation.response) {
+      // Decode the operation response into a usable Operation object
+      const decodeOperation = new controlClient._gaxModule.Operation(
+        operation,
+        controlClient.descriptors.longrunning.createAnywhereCache,
+        controlClient._gaxModule.createDefaultBackoffSettings()
+      );
+      // Return the decoded operation
+      return decodeOperation;
+    } else {
+      // If there's no response, it indicates an issue, so throw an error
+      throw new Error('Operation completed without a response.');
+    }
+  }
+
+  callCreateAnywhereCache();
+  // [END storage_control_create_anywhere_cache]
+}
+
+process.on('unhandledRejection', err => {
+  console.error(err.message);
+  process.exitCode = 1;
+});
+main(...process.argv.slice(2));
diff --git a/storage-control/disableAnywhereCache.js b/storage-control/disableAnywhereCache.js
new file mode 100644
index 0000000000..3259812f33
--- /dev/null
+++ b/storage-control/disableAnywhereCache.js
@@ -0,0 +1,60 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+
+function main(bucketName, cacheName) {
+  // [START storage_control_disable_anywhere_cache]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+
+  // The name of your GCS bucket
+  // const bucketName = 'bucketName';
+
+  // The name of the cache to be disabled
+  // const cacheName = 'cacheName';
+
+  // Imports the Control library
+  const {StorageControlClient} = require('@google-cloud/storage-control').v2;
+
+  // Instantiates a client
+  const controlClient = new StorageControlClient();
+
+  async function callDisableAnywhereCache() {
+    const anywhereCachePath = controlClient.anywhereCachePath(
+      '_',
+      bucketName,
+      cacheName
+    );
+
+    // Create the request
+    const request = {
+      name: anywhereCachePath,
+    };
+
+    // Run request
+    const [response] = await controlClient.disableAnywhereCache(request);
+    console.log(`Disabled anywhere cache: ${response.name}.`);
+  }
+
+  callDisableAnywhereCache();
+  // [END storage_control_disable_anywhere_cache]
+}
+
+process.on('unhandledRejection', err => {
+  console.error(err.message);
+  process.exitCode = 1;
+});
+main(...process.argv.slice(2));
diff --git a/storage-control/getAnywhereCache.js b/storage-control/getAnywhereCache.js
new file mode 100644
index 0000000000..fb30ae304e
--- /dev/null
+++ b/storage-control/getAnywhereCache.js
@@ -0,0 +1,60 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+
+function main(bucketName, cacheName) {
+  // [START storage_control_get_anywhere_cache]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+
+  // The name of your GCS bucket
+  // const bucketName = 'bucketName';
+
+  // The name of the cache to get
+  // const cacheName = 'cacheName';
+
+  // Imports the Control library
+  const {StorageControlClient} = require('@google-cloud/storage-control').v2;
+
+  // Instantiates a client
+  const controlClient = new StorageControlClient();
+
+  async function callGetAnywhereCache() {
+    const anywhereCachePath = controlClient.anywhereCachePath(
+      '_',
+      bucketName,
+      cacheName
+    );
+
+    // Create the request
+    const request = {
+      name: anywhereCachePath,
+    };
+
+    // Run request
+    const [response] = await controlClient.getAnywhereCache(request);
+    console.log(`Got anywhere cache: ${response.name}.`);
+  }
+
+  callGetAnywhereCache();
+  // [END storage_control_get_anywhere_cache]
+}
+
+process.on('unhandledRejection', err => {
+  console.error(err.message);
+  process.exitCode = 1;
+});
+main(...process.argv.slice(2));
diff --git a/storage-control/listAnywhereCaches.js b/storage-control/listAnywhereCaches.js
new file mode 100644
index 0000000000..40c4456885
--- /dev/null
+++ b/storage-control/listAnywhereCaches.js
@@ -0,0 +1,56 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+'use strict';
+
+function main(bucketName) {
+  // [START storage_control_list_anywhere_caches]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+
+  // The name of your GCS bucket
+  // const bucketName = 'bucketName';
+
+  // Imports the Control library
+  const {StorageControlClient} = require('@google-cloud/storage-control').v2;
+
+  // Instantiates a client
+  const controlClient = new StorageControlClient();
+
+  async function callListAnywhereCaches() {
+    const bucketPath = controlClient.bucketPath('_', bucketName);
+
+    // Create the request
+    const request = {
+      parent: bucketPath,
+    };
+
+    // Run request
+    const [response] = await controlClient.listAnywhereCaches(request);
+    for (const anywhereCache of response) {
+      console.log(anywhereCache.name);
+    }
+  }
+
+  callListAnywhereCaches();
+  // [END storage_control_list_anywhere_caches]
+}
+
+process.on('unhandledRejection', err => {
+  console.error(err.message);
+  process.exitCode = 1;
+});
+main(...process.argv.slice(2));
diff --git a/storage-control/package.json b/storage-control/package.json
index 0f6d932845..98f61559c5 100644
--- a/storage-control/package.json
+++ b/storage-control/package.json
@@ -12,8 +12,8 @@
   "author": "Google Inc.",
   "license": "Apache-2.0",
   "devDependencies": {
-    "@google-cloud/storage": "^7.12.0",
-    "@google-cloud/storage-control": "^0.2.0",
+    "@google-cloud/storage": "^7.17.0",
+    "@google-cloud/storage-control": "^0.5.0",
     "c8": "^10.0.0",
     "chai": "^4.5.0",
     "mocha": "^10.7.0",
diff --git a/storage-control/pauseAnywhereCache.js b/storage-control/pauseAnywhereCache.js
new file mode 100644
index 0000000000..8663c9553d
--- /dev/null
+++ b/storage-control/pauseAnywhereCache.js
@@ -0,0 +1,60 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+
+function main(bucketName, cacheName) {
+  // [START storage_control_pause_anywhere_cache]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+
+  // The name of your GCS bucket
+  // const bucketName = 'bucketName';
+
+  // The name of the cache to be paused
+  // const cacheName = 'cacheName';
+
+  // Imports the Control library
+  const {StorageControlClient} = require('@google-cloud/storage-control').v2;
+
+  // Instantiates a client
+  const controlClient = new StorageControlClient();
+
+  async function callPauseAnywhereCache() {
+    const anywhereCachePath = controlClient.anywhereCachePath(
+      '_',
+      bucketName,
+      cacheName
+    );
+
+    // Create the request
+    const request = {
+      name: anywhereCachePath,
+    };
+
+    // Run request
+    const [response] = await controlClient.pauseAnywhereCache(request);
+    console.log(`Paused anywhere cache: ${response.name}.`);
+  }
+
+  callPauseAnywhereCache();
+  // [END storage_control_pause_anywhere_cache]
+}
+
+process.on('unhandledRejection', err => {
+  console.error(err.message);
+  process.exitCode = 1;
+});
+main(...process.argv.slice(2));
diff --git a/storage-control/resumeAnywhereCache.js b/storage-control/resumeAnywhereCache.js
new file mode 100644
index 0000000000..8418e3129f
--- /dev/null
+++ b/storage-control/resumeAnywhereCache.js
@@ -0,0 +1,60 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+
+function main(bucketName, cacheName) {
+  // [START storage_control_resume_anywhere_cache]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+
+  // The name of your GCS bucket
+  // const bucketName = 'bucketName';
+
+  // The name of the cache to be resumed
+  // const cacheName = 'cacheName';
+
+  // Imports the Control library
+  const {StorageControlClient} = require('@google-cloud/storage-control').v2;
+
+  // Instantiates a client
+  const controlClient = new StorageControlClient();
+
+  async function callResumeAnywhereCache() {
+    const anywhereCachePath = controlClient.anywhereCachePath(
+      '_',
+      bucketName,
+      cacheName
+    );
+
+    // Create the request
+    const request = {
+      name: anywhereCachePath,
+    };
+
+    // Run request
+    const [response] = await controlClient.resumeAnywhereCache(request);
+    console.log(`Resumed anywhere cache: ${response.name}.`);
+  }
+
+  callResumeAnywhereCache();
+  // [END storage_control_resume_anywhere_cache]
+}
+
+process.on('unhandledRejection', err => {
+  console.error(err.message);
+  process.exitCode = 1;
+});
+main(...process.argv.slice(2));
diff --git a/storage-control/updateAnywhereCache.js b/storage-control/updateAnywhereCache.js
new file mode 100644
index 0000000000..67fcd0c7b6
--- /dev/null
+++ b/storage-control/updateAnywhereCache.js
@@ -0,0 +1,71 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+'use strict';
+
+function main(bucketName, cacheName, admissionPolicy) {
+  // [START storage_control_update_anywhere_cache]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+
+  // The name of your GCS bucket
+  // const bucketName = 'bucketName';
+
+  // The name of the cache to be update
+  // const cacheName = 'cacheName';
+
+  // The admission policy of the cache to be updated
+  // const admissionPolicy = 'admit-on-first-miss';
+
+  // Imports the Control library
+  const {StorageControlClient} = require('@google-cloud/storage-control').v2;
+
+  // Instantiates a client
+  const controlClient = new StorageControlClient();
+
+  async function callUpdateAnywhereCache() {
+    const anywhereCachePath = controlClient.anywhereCachePath(
+      '_',
+      bucketName,
+      cacheName
+    );
+
+    // Create the request
+    const request = {
+      anywhereCache: {
+        name: anywhereCachePath,
+        admissionPolicy: admissionPolicy,
+      },
+      updateMask: {
+        paths: ['admission_policy'],
+      },
+    };
+
+    // Run request
+    const [operation] = await controlClient.updateAnywhereCache(request);
+    const [response] = await operation.promise();
+
+    console.log(`Updated anywhere cache: ${response.name}.`);
+  }
+
+  callUpdateAnywhereCache();
+  // [END storage_control_update_anywhere_cache]
+}
+
+process.on('unhandledRejection', err => {
+  console.error(err.message);
+  process.exitCode = 1;
+});
+main(...process.argv.slice(2));

From dc0e5cb25fe47bbd5ebad46cc0b7d48efaebd68b Mon Sep 17 00:00:00 2001
From: Thiyagu K <thiyaguk@google.com>
Date: Wed, 3 Sep 2025 07:44:46 +0000
Subject: [PATCH 02/11] add testcase

---
 .../system-test/anywhereCache.test.js         | 134 ++++++++++++++++++
 1 file changed, 134 insertions(+)
 create mode 100644 storage-control/system-test/anywhereCache.test.js

diff --git a/storage-control/system-test/anywhereCache.test.js b/storage-control/system-test/anywhereCache.test.js
new file mode 100644
index 0000000000..04c9a5bbb7
--- /dev/null
+++ b/storage-control/system-test/anywhereCache.test.js
@@ -0,0 +1,134 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+const {Storage, Bucket} = require('@google-cloud/storage');
+const {StorageControlClient} = require('@google-cloud/storage-control').v2;
+const cp = require('child_process');
+const {assert} = require('chai');
+const {describe, it, before, after} = require('mocha');
+const uuid = require('uuid');
+
+const execSync = cmd => cp.execSync(cmd, {encoding: 'utf-8'});
+const bucketPrefix = `storage-control-samples-${uuid.v4()}`;
+const bucketName = `${bucketPrefix}-a`;
+// const bucketName = 'php-gcscontrol-sample-awc-17510023031559095173';
+const controlClient = new StorageControlClient();
+const storage = new Storage({projectId: 'storage-sdk-vendor'});
+const bucket = new Bucket(storage, bucketName);
+const location = 'us-west1';
+const cacheName = 'us-west1-c';
+let anywhereCachePath;
+
+describe('Anywhere Cache', () => {
+  before(async () => {
+    await storage.createBucket(bucketName, {
+      iamConfiguration: {
+        uniformBucketLevelAccess: {
+          enabled: true,
+        },
+      },
+      hierarchicalNamespace: {enabled: true},
+      location: location,
+    });
+
+    anywhereCachePath = controlClient.anywhereCachePath(
+      '_',
+      bucketName,
+      cacheName
+    );
+  });
+
+  after(async function () {
+    this.timeout(3600000);
+    let caches = false;
+    // The `while` loop will continue to run as long as the `caches` flag is `false`.
+    while (!caches) {
+      await new Promise(resolve => setTimeout(resolve, 30000));
+      const bucketPath = controlClient.bucketPath('_', bucketName);
+
+      try {
+        // Call the `listAnywhereCaches` method to check for any active caches.
+        // The response is an array of caches.
+        const [response] = await controlClient.listAnywhereCaches({
+          parent: bucketPath,
+        });
+        // Check if the response array is empty. If so, it means there are no more caches, and we can exit the loop.
+        if (response.length === 0) {
+          // Set `caches` to `true` to break out of the `while` loop.
+          caches = true;
+        }
+      } catch (err) {
+        console.error('Error while polling:', err.message);
+        break;
+      }
+    }
+    // After the loop has finished (i.e., no more caches are found), we proceed with deleting the bucket.
+    await bucket.delete();
+  });
+
+  it('should create an anywhere cache', async function () {
+    this.timeout(3600000);
+    const output = execSync(
+      `node createAnywhereCache.js ${bucketName} ${location} ${cacheName}`
+    );
+    assert.match(output, /Created anywhere cache:/);
+    assert.match(output, new RegExp(anywhereCachePath));
+  });
+
+  it('should get an anywhere cache', async () => {
+    const output = execSync(
+      `node getAnywhereCache.js ${bucketName} ${cacheName}`
+    );
+    assert.match(output, /Got anywhere cache:/);
+    assert.match(output, new RegExp(anywhereCachePath));
+  });
+
+  it('should list anywhere caches', async () => {
+    const output = execSync(`node listAnywhereCaches.js ${bucketName}`);
+    assert.match(output, new RegExp(anywhereCachePath));
+  });
+
+  it('should update an anywhere cache', async () => {
+    const admissionPolicy = 'admit-on-second-miss';
+    const output = execSync(
+      `node updateAnywhereCache.js ${bucketName} ${cacheName} ${admissionPolicy}`
+    );
+    assert.match(output, /Updated anywhere cache:/);
+    assert.match(output, new RegExp(anywhereCachePath));
+  });
+
+  it('should pause an anywhere cache', async () => {
+    const output = execSync(
+      `node pauseAnywhereCache.js ${bucketName} ${cacheName}`
+    );
+    assert.match(output, /Paused anywhere cache:/);
+    assert.match(output, new RegExp(anywhereCachePath));
+  });
+
+  it('should resume an anywhere cache', async () => {
+    const output = execSync(
+      `node resumeAnywhereCache.js ${bucketName} ${cacheName}`
+    );
+    assert.match(output, /Resumed anywhere cache:/);
+    assert.match(output, new RegExp(anywhereCachePath));
+  });
+
+  it('should disable an anywhere cache', async () => {
+    const output = execSync(
+      `node disableAnywhereCache.js ${bucketName} ${cacheName}`
+    );
+    assert.match(output, /Disabled anywhere cache:/);
+    assert.match(output, new RegExp(anywhereCachePath));
+  });
+});

From 3ebcc065c6c14068d88ae46906788d01ab148eed Mon Sep 17 00:00:00 2001
From: Thiyagu K <thiyaguk@google.com>
Date: Wed, 3 Sep 2025 07:51:18 +0000
Subject: [PATCH 03/11] lint fix

---
 storage-control/system-test/anywhereCache.test.js | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/storage-control/system-test/anywhereCache.test.js b/storage-control/system-test/anywhereCache.test.js
index 04c9a5bbb7..a99eeb5f0c 100644
--- a/storage-control/system-test/anywhereCache.test.js
+++ b/storage-control/system-test/anywhereCache.test.js
@@ -22,7 +22,6 @@ const uuid = require('uuid');
 const execSync = cmd => cp.execSync(cmd, {encoding: 'utf-8'});
 const bucketPrefix = `storage-control-samples-${uuid.v4()}`;
 const bucketName = `${bucketPrefix}-a`;
-// const bucketName = 'php-gcscontrol-sample-awc-17510023031559095173';
 const controlClient = new StorageControlClient();
 const storage = new Storage({projectId: 'storage-sdk-vendor'});
 const bucket = new Bucket(storage, bucketName);
@@ -50,6 +49,9 @@ describe('Anywhere Cache', () => {
   });
 
   after(async function () {
+    // Sets the timeout for the test to 3600000 milliseconds (1 hour).
+    // This is necessary for long-running operations, such as waiting for a
+    // cache to be disabled, to prevent the test from failing due to a timeout.
     this.timeout(3600000);
     let caches = false;
     // The `while` loop will continue to run as long as the `caches` flag is `false`.
@@ -78,6 +80,9 @@ describe('Anywhere Cache', () => {
   });
 
   it('should create an anywhere cache', async function () {
+    // Sets the timeout for the test to 3600000 milliseconds (1 hour).
+    // This is necessary for long-running operations, such as waiting for a
+    // cache to be created, to prevent the test from failing due to a timeout.
     this.timeout(3600000);
     const output = execSync(
       `node createAnywhereCache.js ${bucketName} ${location} ${cacheName}`

From 2ec5ce4120517ccdceb12eb4928dce66ce4d229d Mon Sep 17 00:00:00 2001
From: Thiyagu K <thiyaguk@google.com>
Date: Wed, 3 Sep 2025 13:57:14 +0000
Subject: [PATCH 04/11] fix: test case

---
 storage-control/system-test/anywhereCache.test.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/storage-control/system-test/anywhereCache.test.js b/storage-control/system-test/anywhereCache.test.js
index a99eeb5f0c..49070f101e 100644
--- a/storage-control/system-test/anywhereCache.test.js
+++ b/storage-control/system-test/anywhereCache.test.js
@@ -25,7 +25,7 @@ const bucketName = `${bucketPrefix}-a`;
 const controlClient = new StorageControlClient();
 const storage = new Storage({projectId: 'storage-sdk-vendor'});
 const bucket = new Bucket(storage, bucketName);
-const location = 'us-west1';
+const zoneName = 'us-west1';
 const cacheName = 'us-west1-c';
 let anywhereCachePath;
 
@@ -38,7 +38,7 @@ describe('Anywhere Cache', () => {
         },
       },
       hierarchicalNamespace: {enabled: true},
-      location: location,
+      location: zoneName,
     });
 
     anywhereCachePath = controlClient.anywhereCachePath(
@@ -85,7 +85,7 @@ describe('Anywhere Cache', () => {
     // cache to be created, to prevent the test from failing due to a timeout.
     this.timeout(3600000);
     const output = execSync(
-      `node createAnywhereCache.js ${bucketName} ${location} ${cacheName}`
+      `node createAnywhereCache.js ${bucketName} ${cacheName} ${zoneName}`
     );
     assert.match(output, /Created anywhere cache:/);
     assert.match(output, new RegExp(anywhereCachePath));

From 95d39c62b0d284a15f1ff47ab0c40d7ecdc600fb Mon Sep 17 00:00:00 2001
From: Thiyagu K <thiyaguk@google.com>
Date: Thu, 4 Sep 2025 06:31:10 +0000
Subject: [PATCH 05/11] fix: remove cacheName

---
 storage-control/createAnywhereCache.js            | 6 +-----
 storage-control/system-test/anywhereCache.test.js | 6 +++---
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/storage-control/createAnywhereCache.js b/storage-control/createAnywhereCache.js
index cd3c691f7b..54a0c3e633 100644
--- a/storage-control/createAnywhereCache.js
+++ b/storage-control/createAnywhereCache.js
@@ -14,7 +14,7 @@
 
 'use strict';
 
-function main(bucketName, cacheName, zoneName) {
+function main(bucketName, zoneName) {
   // [START storage_control_create_anywhere_cache]
   /**
    * TODO(developer): Uncomment these variables before running the sample.
@@ -23,9 +23,6 @@ function main(bucketName, cacheName, zoneName) {
   // The name of your GCS bucket
   // const bucketName = 'bucketName';
 
-  // The name of the cache to be created
-  // const cacheName = 'cacheName';
-
   // The zone that the cache instance will run in.
   // const zoneName = 'zoneName';
 
@@ -42,7 +39,6 @@ function main(bucketName, cacheName, zoneName) {
     const request = {
       parent: bucketPath,
       anywhereCache: {
-        name: cacheName,
         zone: zoneName,
       },
     };
diff --git a/storage-control/system-test/anywhereCache.test.js b/storage-control/system-test/anywhereCache.test.js
index 49070f101e..fc9c2ab03d 100644
--- a/storage-control/system-test/anywhereCache.test.js
+++ b/storage-control/system-test/anywhereCache.test.js
@@ -25,7 +25,7 @@ const bucketName = `${bucketPrefix}-a`;
 const controlClient = new StorageControlClient();
 const storage = new Storage({projectId: 'storage-sdk-vendor'});
 const bucket = new Bucket(storage, bucketName);
-const zoneName = 'us-west1';
+const zoneName = 'us-west1-c';
 const cacheName = 'us-west1-c';
 let anywhereCachePath;
 
@@ -38,7 +38,7 @@ describe('Anywhere Cache', () => {
         },
       },
       hierarchicalNamespace: {enabled: true},
-      location: zoneName,
+      location: 'us-west1',
     });
 
     anywhereCachePath = controlClient.anywhereCachePath(
@@ -85,7 +85,7 @@ describe('Anywhere Cache', () => {
     // cache to be created, to prevent the test from failing due to a timeout.
     this.timeout(3600000);
     const output = execSync(
-      `node createAnywhereCache.js ${bucketName} ${cacheName} ${zoneName}`
+      `node createAnywhereCache.js ${bucketName} ${zoneName}`
     );
     assert.match(output, /Created anywhere cache:/);
     assert.match(output, new RegExp(anywhereCachePath));

From 9d7c97bf4554abde0b4501d3261f0e982b80fbeb Mon Sep 17 00:00:00 2001
From: Thiyagu K <thiyaguk@google.com>
Date: Thu, 4 Sep 2025 08:17:49 +0000
Subject: [PATCH 06/11] skip test case

---
 storage-control/system-test/anywhereCache.test.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/storage-control/system-test/anywhereCache.test.js b/storage-control/system-test/anywhereCache.test.js
index fc9c2ab03d..cf964ec7d2 100644
--- a/storage-control/system-test/anywhereCache.test.js
+++ b/storage-control/system-test/anywhereCache.test.js
@@ -29,7 +29,9 @@ const zoneName = 'us-west1-c';
 const cacheName = 'us-west1-c';
 let anywhereCachePath;
 
-describe('Anywhere Cache', () => {
+// Skipped to prevent CI timeouts caused by long-running operations.
+// Un-skip for deliberate, manual runs.
+describe.skip('Anywhere Cache', () => {
   before(async () => {
     await storage.createBucket(bucketName, {
       iamConfiguration: {

From 43c4fe7f6674e2498fa4887cfe0b23415d09fe04 Mon Sep 17 00:00:00 2001
From: Thiyagu K <thiyaguk@google.com>
Date: Fri, 5 Sep 2025 14:29:55 +0000
Subject: [PATCH 07/11] test case remove projectId

---
 storage-control/system-test/anywhereCache.test.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/storage-control/system-test/anywhereCache.test.js b/storage-control/system-test/anywhereCache.test.js
index cf964ec7d2..ea38f5db22 100644
--- a/storage-control/system-test/anywhereCache.test.js
+++ b/storage-control/system-test/anywhereCache.test.js
@@ -23,7 +23,7 @@ const execSync = cmd => cp.execSync(cmd, {encoding: 'utf-8'});
 const bucketPrefix = `storage-control-samples-${uuid.v4()}`;
 const bucketName = `${bucketPrefix}-a`;
 const controlClient = new StorageControlClient();
-const storage = new Storage({projectId: 'storage-sdk-vendor'});
+const storage = new Storage();
 const bucket = new Bucket(storage, bucketName);
 const zoneName = 'us-west1-c';
 const cacheName = 'us-west1-c';

From bb23814d930472d2119420cd36b6c4c9078cfa07 Mon Sep 17 00:00:00 2001
From: Thiyagu K <thiyaguk@google.com>
Date: Tue, 9 Sep 2025 08:20:56 +0000
Subject: [PATCH 08/11] addressing review comments

---
 storage-control/createAnywhereCache.js  | 7 +++++++
 storage-control/disableAnywhereCache.js | 7 +++++++
 storage-control/getAnywhereCache.js     | 7 +++++++
 storage-control/listAnywhereCaches.js   | 7 +++++++
 storage-control/pauseAnywhereCache.js   | 7 +++++++
 storage-control/resumeAnywhereCache.js  | 7 +++++++
 storage-control/updateAnywhereCache.js  | 9 ++++++++-
 7 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/storage-control/createAnywhereCache.js b/storage-control/createAnywhereCache.js
index 54a0c3e633..aee8ab6235 100644
--- a/storage-control/createAnywhereCache.js
+++ b/storage-control/createAnywhereCache.js
@@ -14,6 +14,13 @@
 
 'use strict';
 
+/**
+ * This application demonstrates how to perform basic operations on an Anywhere Cache
+ * instance with the Google Cloud Storage API.
+ *
+ * For more information, see the documentation at https://cloud.google.com/storage/docs/anywhere-cache.
+ */
+
 function main(bucketName, zoneName) {
   // [START storage_control_create_anywhere_cache]
   /**
diff --git a/storage-control/disableAnywhereCache.js b/storage-control/disableAnywhereCache.js
index 3259812f33..b298c887ad 100644
--- a/storage-control/disableAnywhereCache.js
+++ b/storage-control/disableAnywhereCache.js
@@ -14,6 +14,13 @@
 
 'use strict';
 
+/**
+ * This application demonstrates how to perform basic operations on an Anywhere Cache
+ * instance with the Google Cloud Storage API.
+ *
+ * For more information, see the documentation at https://cloud.google.com/storage/docs/anywhere-cache.
+ */
+
 function main(bucketName, cacheName) {
   // [START storage_control_disable_anywhere_cache]
   /**
diff --git a/storage-control/getAnywhereCache.js b/storage-control/getAnywhereCache.js
index fb30ae304e..814227b665 100644
--- a/storage-control/getAnywhereCache.js
+++ b/storage-control/getAnywhereCache.js
@@ -14,6 +14,13 @@
 
 'use strict';
 
+/**
+ * This application demonstrates how to perform basic operations on an Anywhere Cache
+ * instance with the Google Cloud Storage API.
+ *
+ * For more information, see the documentation at https://cloud.google.com/storage/docs/anywhere-cache.
+ */
+
 function main(bucketName, cacheName) {
   // [START storage_control_get_anywhere_cache]
   /**
diff --git a/storage-control/listAnywhereCaches.js b/storage-control/listAnywhereCaches.js
index 40c4456885..6dcd3d29ed 100644
--- a/storage-control/listAnywhereCaches.js
+++ b/storage-control/listAnywhereCaches.js
@@ -15,6 +15,13 @@
 
 'use strict';
 
+/**
+ * This application demonstrates how to perform basic operations on an Anywhere Cache
+ * instance with the Google Cloud Storage API.
+ *
+ * For more information, see the documentation at https://cloud.google.com/storage/docs/anywhere-cache.
+ */
+
 function main(bucketName) {
   // [START storage_control_list_anywhere_caches]
   /**
diff --git a/storage-control/pauseAnywhereCache.js b/storage-control/pauseAnywhereCache.js
index 8663c9553d..492f6efab4 100644
--- a/storage-control/pauseAnywhereCache.js
+++ b/storage-control/pauseAnywhereCache.js
@@ -14,6 +14,13 @@
 
 'use strict';
 
+/**
+ * This application demonstrates how to perform basic operations on an Anywhere Cache
+ * instance with the Google Cloud Storage API.
+ *
+ * For more information, see the documentation at https://cloud.google.com/storage/docs/anywhere-cache.
+ */
+
 function main(bucketName, cacheName) {
   // [START storage_control_pause_anywhere_cache]
   /**
diff --git a/storage-control/resumeAnywhereCache.js b/storage-control/resumeAnywhereCache.js
index 8418e3129f..0362e40bc8 100644
--- a/storage-control/resumeAnywhereCache.js
+++ b/storage-control/resumeAnywhereCache.js
@@ -14,6 +14,13 @@
 
 'use strict';
 
+/**
+ * This application demonstrates how to perform basic operations on an Anywhere Cache
+ * instance with the Google Cloud Storage API.
+ *
+ * For more information, see the documentation at https://cloud.google.com/storage/docs/anywhere-cache.
+ */
+
 function main(bucketName, cacheName) {
   // [START storage_control_resume_anywhere_cache]
   /**
diff --git a/storage-control/updateAnywhereCache.js b/storage-control/updateAnywhereCache.js
index 67fcd0c7b6..bb2e29c15c 100644
--- a/storage-control/updateAnywhereCache.js
+++ b/storage-control/updateAnywhereCache.js
@@ -14,6 +14,13 @@
 
 'use strict';
 
+/**
+ * This application demonstrates how to perform basic operations on an Anywhere Cache
+ * instance with the Google Cloud Storage API.
+ *
+ * For more information, see the documentation at https://cloud.google.com/storage/docs/anywhere-cache.
+ */
+
 function main(bucketName, cacheName, admissionPolicy) {
   // [START storage_control_update_anywhere_cache]
   /**
@@ -27,7 +34,7 @@ function main(bucketName, cacheName, admissionPolicy) {
   // const cacheName = 'cacheName';
 
   // The admission policy of the cache to be updated
-  // const admissionPolicy = 'admit-on-first-miss';
+  // const admissionPolicy = 'admit-on-second-miss';
 
   // Imports the Control library
   const {StorageControlClient} = require('@google-cloud/storage-control').v2;

From fd57da1af555e71c79ca967381c0251cebc0f3ea Mon Sep 17 00:00:00 2001
From: Thiyagu K <thiyaguk@google.com>
Date: Wed, 8 Oct 2025 06:17:48 +0000
Subject: [PATCH 09/11] index on anywhere-cache-samples: e83ba77b addressing
 review comments

---
 storage-control/createAnywhereCache.js  | 19 ++++++++++++-------
 storage-control/disableAnywhereCache.js | 18 +++++++++++-------
 storage-control/getAnywhereCache.js     | 25 ++++++++++++++++++-------
 storage-control/listAnywhereCaches.js   | 10 ++++++----
 storage-control/updateAnywhereCache.js  | 18 ++++++++----------
 5 files changed, 55 insertions(+), 35 deletions(-)

diff --git a/storage-control/createAnywhereCache.js b/storage-control/createAnywhereCache.js
index aee8ab6235..836c581769 100644
--- a/storage-control/createAnywhereCache.js
+++ b/storage-control/createAnywhereCache.js
@@ -23,16 +23,19 @@
 
 function main(bucketName, zoneName) {
   // [START storage_control_create_anywhere_cache]
+
   /**
-   * TODO(developer): Uncomment these variables before running the sample.
+   * Creates an Anywhere Cache instance for a Cloud Storage bucket.
+   * Anywhere Cache is a feature that provides an SSD-backed zonal read cache.
+   * This can significantly improve read performance for frequently accessed data
+   * by caching it in the same zone as your compute resources.
+   *
+   * @param {string} bucketName The name of the bucket to create the cache for.
+   * Example: 'your-gcp-bucket-name'
+   * @param {string} zoneName The zone where the cache will be created.
+   * Example: 'us-central1-a'
    */
 
-  // The name of your GCS bucket
-  // const bucketName = 'bucketName';
-
-  // The zone that the cache instance will run in.
-  // const zoneName = 'zoneName';
-
   // Imports the Control library
   const {StorageControlClient} = require('@google-cloud/storage-control').v2;
 
@@ -47,6 +50,8 @@ function main(bucketName, zoneName) {
       parent: bucketPath,
       anywhereCache: {
         zone: zoneName,
+        ttl: '70000s',
+        admissionPolicy: 'admit-on-first-miss',
       },
     };
 
diff --git a/storage-control/disableAnywhereCache.js b/storage-control/disableAnywhereCache.js
index b298c887ad..3b1f7aa021 100644
--- a/storage-control/disableAnywhereCache.js
+++ b/storage-control/disableAnywhereCache.js
@@ -24,15 +24,19 @@
 function main(bucketName, cacheName) {
   // [START storage_control_disable_anywhere_cache]
   /**
-   * TODO(developer): Uncomment these variables before running the sample.
+   * Disables an Anywhere Cache instance.
+   *
+   * Disabling a cache is the first step to permanently removing it. Once disabled,
+   * the cache stops ingesting new data. After a grace period, the cache and its
+   * contents are deleted. This is useful for decommissioning caches that are no
+   * longer needed.
+   *
+   * @param {string} bucketName The name of the bucket where the cache resides.
+   * Example: 'your-gcp-bucket-name'
+   * @param {string} cacheName The unique identifier of the cache instance to disable.
+   * Example: 'cacheName'
    */
 
-  // The name of your GCS bucket
-  // const bucketName = 'bucketName';
-
-  // The name of the cache to be disabled
-  // const cacheName = 'cacheName';
-
   // Imports the Control library
   const {StorageControlClient} = require('@google-cloud/storage-control').v2;
 
diff --git a/storage-control/getAnywhereCache.js b/storage-control/getAnywhereCache.js
index 814227b665..61d058c567 100644
--- a/storage-control/getAnywhereCache.js
+++ b/storage-control/getAnywhereCache.js
@@ -24,15 +24,17 @@
 function main(bucketName, cacheName) {
   // [START storage_control_get_anywhere_cache]
   /**
-   * TODO(developer): Uncomment these variables before running the sample.
+   * Retrieves details of a specific Anywhere Cache instance.
+   *
+   * This function is useful for checking the current state, configuration (like TTL),
+   * and other metadata of an existing cache.
+   *
+   * @param {string} bucketName The name of the bucket where the cache resides.
+   * Example: 'your-gcp-bucket-name'
+   * @param {string} cacheName The unique identifier of the cache instance.
+   * Example: 'my-anywhere-cache-id'
    */
 
-  // The name of your GCS bucket
-  // const bucketName = 'bucketName';
-
-  // The name of the cache to get
-  // const cacheName = 'cacheName';
-
   // Imports the Control library
   const {StorageControlClient} = require('@google-cloud/storage-control').v2;
 
@@ -54,6 +56,15 @@ function main(bucketName, cacheName) {
     // Run request
     const [response] = await controlClient.getAnywhereCache(request);
     console.log(`Got anywhere cache: ${response.name}.`);
+    console.log(`Anywhere Cache details for '${cacheName}':`);
+    console.log(`  ID: ${response.id}`);
+    console.log(`  Zone: ${response.zone}`);
+    console.log(`  State: ${response.state}`);
+    console.log(`  TTL: ${response.ttl.seconds}s`);
+    console.log(`  Admission Policy: ${response.admissionPolicy}`);
+    console.log(
+      `  Create Time: ${new Date(response.createTime.seconds * 1000).toISOString()}`
+    );
   }
 
   callGetAnywhereCache();
diff --git a/storage-control/listAnywhereCaches.js b/storage-control/listAnywhereCaches.js
index 6dcd3d29ed..360b2ee565 100644
--- a/storage-control/listAnywhereCaches.js
+++ b/storage-control/listAnywhereCaches.js
@@ -25,12 +25,14 @@
 function main(bucketName) {
   // [START storage_control_list_anywhere_caches]
   /**
-   * TODO(developer): Uncomment these variables before running the sample.
+   * Lists all Anywhere Cache instances for a Cloud Storage bucket.
+   * This function helps you discover all active and pending caches associated with
+   * a specific bucket, which is useful for auditing and management.
+   *
+   * @param {string} bucketName The name of the bucket to list caches for.
+   * Example: 'your-gcp-bucket-name'
    */
 
-  // The name of your GCS bucket
-  // const bucketName = 'bucketName';
-
   // Imports the Control library
   const {StorageControlClient} = require('@google-cloud/storage-control').v2;
 
diff --git a/storage-control/updateAnywhereCache.js b/storage-control/updateAnywhereCache.js
index bb2e29c15c..02c55494a5 100644
--- a/storage-control/updateAnywhereCache.js
+++ b/storage-control/updateAnywhereCache.js
@@ -24,18 +24,16 @@
 function main(bucketName, cacheName, admissionPolicy) {
   // [START storage_control_update_anywhere_cache]
   /**
-   * TODO(developer): Uncomment these variables before running the sample.
+   * Updates the Admission Policy of an Anywhere Cache instance.
+   *
+   * @param {string} bucketName The name of the bucket where the cache resides.
+   * Example: 'your-gcp-bucket-name'
+   * @param {string} cacheName The unique identifier of the cache instance to update.
+   * Example: 'my-anywhere-cache-id'
+   * @param {string} admissionPolicy Determines when data is ingested into the cache
+   * Example: 'admit-on-second-miss'
    */
 
-  // The name of your GCS bucket
-  // const bucketName = 'bucketName';
-
-  // The name of the cache to be update
-  // const cacheName = 'cacheName';
-
-  // The admission policy of the cache to be updated
-  // const admissionPolicy = 'admit-on-second-miss';
-
   // Imports the Control library
   const {StorageControlClient} = require('@google-cloud/storage-control').v2;
 

From 572f7f163e7b2b056a11fef7169a94297e689d52 Mon Sep 17 00:00:00 2001
From: Thiyagu K <thiyaguk@google.com>
Date: Wed, 8 Oct 2025 09:22:17 +0000
Subject: [PATCH 10/11] feat(storage-control): Improve Anywhere Cache API
 samples

Improve Anywhere Cache API samples (Documentation & Error Handling)

* Wraps all asynchronous Anywhere Cache API samples (Create, Get, List,
Disable, Pause, Resume) in `try...catch` blocks for production
readiness.
* Adds specific gRPC error code checks (NOT_FOUND, FAILED_PRECONDITION)
to provide better diagnostic feedback to users.
* Clarifies documentation regarding the optional nature and default
values of `ttl` and `admissionPolicy` for cache creation.
---
 storage-control/createAnywhereCache.js  | 28 +++++++++------
 storage-control/disableAnywhereCache.js | 33 ++++++++++++++++++
 storage-control/getAnywhereCache.js     | 37 +++++++++++++-------
 storage-control/listAnywhereCaches.js   | 25 +++++++++++---
 storage-control/pauseAnywhereCache.js   | 45 +++++++++++++++++++------
 storage-control/resumeAnywhereCache.js  | 44 ++++++++++++++++++------
 storage-control/updateAnywhereCache.js  | 32 +++++++++++++++---
 7 files changed, 194 insertions(+), 50 deletions(-)

diff --git a/storage-control/createAnywhereCache.js b/storage-control/createAnywhereCache.js
index 836c581769..1b43d6e4d5 100644
--- a/storage-control/createAnywhereCache.js
+++ b/storage-control/createAnywhereCache.js
@@ -50,20 +50,28 @@ function main(bucketName, zoneName) {
       parent: bucketPath,
       anywhereCache: {
         zone: zoneName,
-        ttl: '70000s',
-        admissionPolicy: 'admit-on-first-miss',
+        ttl: {
+          seconds: '10000s',
+        }, // Optional. Default: '86400s'(1 day)
+        admissionPolicy: 'admit-on-first-miss', // Optional. Default: 'admit-on-first-miss'
       },
     };
 
-    // Run the request, which returns an Operation object
-    const [operation] = await controlClient.createAnywhereCache(request);
-    console.log(`Waiting for operation ${operation.name} to complete...`);
+    try {
+      // Run the request, which returns an Operation object
+      const [operation] = await controlClient.createAnywhereCache(request);
+      console.log(`Waiting for operation ${operation.name} to complete...`);
 
-    // Wait for the operation to complete and get the final resource
-    const anywhereCache = await checkCreateAnywhereCacheProgress(
-      operation.name
-    );
-    console.log(`Created anywhere cache: ${anywhereCache.result.name}.`);
+      // Wait for the operation to complete and get the final resource
+      const anywhereCache = await checkCreateAnywhereCacheProgress(
+        operation.name
+      );
+      console.log(`Created anywhere cache: ${anywhereCache.result.name}.`);
+    } catch (error) {
+      // Handle any error that occurred during the creation or polling process.
+      console.error('Failed to create Anywhere Cache:', error.message);
+      throw error;
+    }
   }
 
   // A custom function to check the operation's progress.
diff --git a/storage-control/disableAnywhereCache.js b/storage-control/disableAnywhereCache.js
index 3b1f7aa021..e9ce829a55 100644
--- a/storage-control/disableAnywhereCache.js
+++ b/storage-control/disableAnywhereCache.js
@@ -44,6 +44,10 @@ function main(bucketName, cacheName) {
   const controlClient = new StorageControlClient();
 
   async function callDisableAnywhereCache() {
+    // You have a one-hour grace period after disabling a cache to resume it and prevent its deletion.
+    // If you don't resume the cache within that hour, it will be deleted, its data will be evicted,
+    // and the cache will be permanently removed from the bucket.
+
     const anywhereCachePath = controlClient.anywhereCachePath(
       '_',
       bucketName,
@@ -55,6 +59,35 @@ function main(bucketName, cacheName) {
       name: anywhereCachePath,
     };
 
+    try {
+      // Run request. This initiates the disablement process.
+      const [response] = await controlClient.disableAnywhereCache(request);
+
+      console.log(
+        `Successfully initiated disablement for Anywhere Cache '${cacheName}'.`
+      );
+      console.log(`  Current State: ${response.state}`);
+      console.log(`  Resource Name: ${response.name}`);
+    } catch (error) {
+      // Catch and handle potential API errors.
+      console.error(
+        `Error disabling Anywhere Cache '${cacheName}': ${error.message}`
+      );
+
+      if (error.code === 5) {
+        // NOT_FOUND (gRPC code 5) error can occur if the bucket or cache does not exist.
+        console.error(
+          `Please ensure the cache '${cacheName}' exists in bucket '${bucketName}'.`
+        );
+      } else if (error.code === 9) {
+        // FAILED_PRECONDITION (gRPC code 9) can occur if the cache is already being disabled
+        // or is not in a RUNNING state that allows the disable operation.
+        console.error(
+          `Cache '${cacheName}' may not be in a state that allows disabling (e.g., must be RUNNING).`
+        );
+      }
+      throw error;
+    }
     // Run request
     const [response] = await controlClient.disableAnywhereCache(request);
     console.log(`Disabled anywhere cache: ${response.name}.`);
diff --git a/storage-control/getAnywhereCache.js b/storage-control/getAnywhereCache.js
index 61d058c567..2633ede7e4 100644
--- a/storage-control/getAnywhereCache.js
+++ b/storage-control/getAnywhereCache.js
@@ -53,18 +53,31 @@ function main(bucketName, cacheName) {
       name: anywhereCachePath,
     };
 
-    // Run request
-    const [response] = await controlClient.getAnywhereCache(request);
-    console.log(`Got anywhere cache: ${response.name}.`);
-    console.log(`Anywhere Cache details for '${cacheName}':`);
-    console.log(`  ID: ${response.id}`);
-    console.log(`  Zone: ${response.zone}`);
-    console.log(`  State: ${response.state}`);
-    console.log(`  TTL: ${response.ttl.seconds}s`);
-    console.log(`  Admission Policy: ${response.admissionPolicy}`);
-    console.log(
-      `  Create Time: ${new Date(response.createTime.seconds * 1000).toISOString()}`
-    );
+    try {
+      // Run request
+      const [response] = await controlClient.getAnywhereCache(request);
+      console.log(`Anywhere Cache details for '${cacheName}':`);
+      console.log(`  Name: ${response.name}`);
+      console.log(`  Zone: ${response.zone}`);
+      console.log(`  State: ${response.state}`);
+      console.log(`  TTL: ${response.ttl.seconds}s`);
+      console.log(`  Admission Policy: ${response.admissionPolicy}`);
+      console.log(
+        `  Create Time: ${new Date(response.createTime.seconds * 1000).toISOString()}`
+      );
+    } catch (error) {
+      // Handle errors (e.g., cache not found, permission denied).
+      console.error(
+        `Error retrieving Anywhere Cache '${cacheName}': ${error.message}`
+      );
+
+      if (error.code === 5) {
+        console.error(
+          `Ensure the cache '${cacheName}' exists in bucket '${bucketName}'.`
+        );
+      }
+      throw error;
+    }
   }
 
   callGetAnywhereCache();
diff --git a/storage-control/listAnywhereCaches.js b/storage-control/listAnywhereCaches.js
index 360b2ee565..9bf5175981 100644
--- a/storage-control/listAnywhereCaches.js
+++ b/storage-control/listAnywhereCaches.js
@@ -47,10 +47,27 @@ function main(bucketName) {
       parent: bucketPath,
     };
 
-    // Run request
-    const [response] = await controlClient.listAnywhereCaches(request);
-    for (const anywhereCache of response) {
-      console.log(anywhereCache.name);
+    try {
+      // Run request. The response is an array where the first element is the list of caches.
+      const [response] = await controlClient.listAnywhereCaches(request);
+
+      if (response && response.length > 0) {
+        console.log(
+          `Found ${response.length} Anywhere Caches for bucket: ${bucketName}`
+        );
+        for (const anywhereCache of response) {
+          console.log(anywhereCache.name);
+        }
+      } else {
+        // Case: Successful but empty list (No Anywhere Caches found)
+        console.log(`No Anywhere Caches found for bucket: ${bucketName}.`);
+      }
+    } catch (error) {
+      console.error(
+        `Error listing Anywhere Caches for bucket ${bucketName}:`,
+        error.message
+      );
+      throw error;
     }
   }
 
diff --git a/storage-control/pauseAnywhereCache.js b/storage-control/pauseAnywhereCache.js
index 492f6efab4..dcb974b0fe 100644
--- a/storage-control/pauseAnywhereCache.js
+++ b/storage-control/pauseAnywhereCache.js
@@ -24,15 +24,18 @@
 function main(bucketName, cacheName) {
   // [START storage_control_pause_anywhere_cache]
   /**
-   * TODO(developer): Uncomment these variables before running the sample.
+   * Pauses an Anywhere Cache instance.
+   *
+   * This synchronous function stops the ingestion of new data for a cache that's in a RUNNING state.
+   * While PAUSED, you can still read existing data (which resets the TTL), but no new data is ingested.
+   * The cache can be returned to the RUNNING state by calling the resume function.
+   *
+   * @param {string} bucketName The name of the bucket where the cache resides.
+   * Example: 'your-gcp-bucket-name'
+   * @param {string} cacheName The unique identifier of the cache instance.
+   * Example: 'my-anywhere-cache-id'
    */
 
-  // The name of your GCS bucket
-  // const bucketName = 'bucketName';
-
-  // The name of the cache to be paused
-  // const cacheName = 'cacheName';
-
   // Imports the Control library
   const {StorageControlClient} = require('@google-cloud/storage-control').v2;
 
@@ -51,9 +54,31 @@ function main(bucketName, cacheName) {
       name: anywhereCachePath,
     };
 
-    // Run request
-    const [response] = await controlClient.pauseAnywhereCache(request);
-    console.log(`Paused anywhere cache: ${response.name}.`);
+    try {
+      // Run request
+      const [response] = await controlClient.pauseAnywhereCache(request);
+
+      console.log(`Successfully paused anywhere cache: ${response.name}.`);
+      console.log(`  Current State: ${response.state}`);
+    } catch (error) {
+      // Catch and handle potential API errors.
+      console.error(
+        `Error pausing Anywhere Cache '${cacheName}': ${error.message}`
+      );
+
+      if (error.code === 5) {
+        // NOT_FOUND (gRPC code 5)
+        console.error(
+          `Please ensure the cache '${cacheName}' exists in bucket '${bucketName}'.`
+        );
+      } else if (error.code === 9) {
+        // FAILED_PRECONDITION (gRPC code 9)
+        console.error(
+          `Cache '${cacheName}' may not be in a state that allows pausing (e.g., must be RUNNING).`
+        );
+      }
+      throw error;
+    }
   }
 
   callPauseAnywhereCache();
diff --git a/storage-control/resumeAnywhereCache.js b/storage-control/resumeAnywhereCache.js
index 0362e40bc8..1cea5035d3 100644
--- a/storage-control/resumeAnywhereCache.js
+++ b/storage-control/resumeAnywhereCache.js
@@ -24,15 +24,17 @@
 function main(bucketName, cacheName) {
   // [START storage_control_resume_anywhere_cache]
   /**
-   * TODO(developer): Uncomment these variables before running the sample.
+   * Resumes a disabled Anywhere Cache instance.
+   *
+   * This action reverts a cache from a PAUSED state or a DISABLED state back to RUNNING,
+   * provided it is done within the 1-hour grace period before the cache is permanently deleted.
+   *
+   * @param {string} bucketName The name of the bucket where the cache resides.
+   * Example: 'your-gcp-bucket-name'
+   * @param {string} cacheName The unique identifier of the cache instance.
+   * Example: 'my-anywhere-cache-id'
    */
 
-  // The name of your GCS bucket
-  // const bucketName = 'bucketName';
-
-  // The name of the cache to be resumed
-  // const cacheName = 'cacheName';
-
   // Imports the Control library
   const {StorageControlClient} = require('@google-cloud/storage-control').v2;
 
@@ -51,9 +53,31 @@ function main(bucketName, cacheName) {
       name: anywhereCachePath,
     };
 
-    // Run request
-    const [response] = await controlClient.resumeAnywhereCache(request);
-    console.log(`Resumed anywhere cache: ${response.name}.`);
+    try {
+      // Run request
+      const [response] = await controlClient.resumeAnywhereCache(request);
+
+      console.log(`Successfully resumed anywhere cache: ${response.name}.`);
+      console.log(`  Current State: ${response.state}`);
+    } catch (error) {
+      // Catch and handle potential API errors.
+      console.error(
+        `Error resuming Anywhere Cache '${cacheName}': ${error.message}`
+      );
+
+      if (error.code === 5) {
+        // NOT_FOUND (gRPC code 5)
+        console.error(
+          `Please ensure the cache '${cacheName}' exists in bucket '${bucketName}'.`
+        );
+      } else if (error.code === 9) {
+        // FAILED_PRECONDITION (gRPC code 9)
+        console.error(
+          `Cache '${cacheName}' may not be in a state that allows resuming (e.g., already RUNNING or past the 1-hour deletion grace period).`
+        );
+      }
+      throw error;
+    }
   }
 
   callResumeAnywhereCache();
diff --git a/storage-control/updateAnywhereCache.js b/storage-control/updateAnywhereCache.js
index 02c55494a5..1d006e4119 100644
--- a/storage-control/updateAnywhereCache.js
+++ b/storage-control/updateAnywhereCache.js
@@ -58,11 +58,35 @@ function main(bucketName, cacheName, admissionPolicy) {
       },
     };
 
-    // Run request
-    const [operation] = await controlClient.updateAnywhereCache(request);
-    const [response] = await operation.promise();
+    try {
+      // Run request
+      const [operation] = await controlClient.updateAnywhereCache(request);
+      console.log(
+        `Waiting for update operation ${operation.name} to complete...`
+      );
 
-    console.log(`Updated anywhere cache: ${response.name}.`);
+      const [response] = await operation.promise();
+
+      console.log(`Updated anywhere cache: ${response.name}.`);
+    } catch (error) {
+      // Handle errors during the initial request or during the LRO polling.
+      console.error(
+        `Error updating Anywhere Cache '${cacheName}': ${error.message}`
+      );
+
+      if (error.code === 5) {
+        // NOT_FOUND (gRPC code 5)
+        console.error(
+          `Ensure the cache '${cacheName}' exists in bucket '${bucketName}'.`
+        );
+      } else if (error.code === 3) {
+        // INVALID_ARGUMENT (gRPC code 3)
+        console.error(
+          `Ensure '${admissionPolicy}' is a valid Admission Policy.`
+        );
+      }
+      throw error;
+    }
   }
 
   callUpdateAnywhereCache();

From 002f574438979cfd54833b96c61250db6915821d Mon Sep 17 00:00:00 2001
From: Thiyagu K <thiyaguk@google.com>
Date: Wed, 8 Oct 2025 12:52:38 +0000
Subject: [PATCH 11/11] test(storagecontrol): Enhance Anywhere Cache test
 assertions and coverage

Updates tests for all Anywhere Cache management methods (Create, Get,
List, Resume, Disable, Pause) to align with enhanced sample script
output.

**(Tests were skipped due to reliance on Long-Running Operations (LROs)
in the sample code.)**

This includes:
* **Enhanced Assertions:** Asserting against all newly added detail
fields (e.g., Name, State, TTL) to verify full API response parsing in
Get and List samples.
* **Negative Scenario Coverage:** Adding explicit **negative scenario
tests** for state-dependent operations (Disable, Pause, Resume) to
assert graceful failure on expected errors like `FAILED_PRECONDITION`.
---
 storage-control/disableAnywhereCache.js       |  2 +-
 .../system-test/anywhereCache.test.js         | 39 +++++++++++++++----
 2 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/storage-control/disableAnywhereCache.js b/storage-control/disableAnywhereCache.js
index e9ce829a55..f4487d725f 100644
--- a/storage-control/disableAnywhereCache.js
+++ b/storage-control/disableAnywhereCache.js
@@ -64,7 +64,7 @@ function main(bucketName, cacheName) {
       const [response] = await controlClient.disableAnywhereCache(request);
 
       console.log(
-        `Successfully initiated disablement for Anywhere Cache '${cacheName}'.`
+        `Successfully initiated disablement for Anywhere Cache: '${cacheName}'.`
       );
       console.log(`  Current State: ${response.state}`);
       console.log(`  Resource Name: ${response.name}`);
diff --git a/storage-control/system-test/anywhereCache.test.js b/storage-control/system-test/anywhereCache.test.js
index ea38f5db22..59a6bbadb6 100644
--- a/storage-control/system-test/anywhereCache.test.js
+++ b/storage-control/system-test/anywhereCache.test.js
@@ -97,8 +97,15 @@ describe.skip('Anywhere Cache', () => {
     const output = execSync(
       `node getAnywhereCache.js ${bucketName} ${cacheName}`
     );
-    assert.match(output, /Got anywhere cache:/);
+    const detailsHeader = `Anywhere Cache details for '${cacheName}':`;
+    assert.match(output, new RegExp(detailsHeader));
+    assert.match(output, /Name:/);
     assert.match(output, new RegExp(anywhereCachePath));
+    assert.match(output, /Zone:/);
+    assert.match(output, /State:/);
+    assert.match(output, /TTL:/);
+    assert.match(output, /Admission Policy:/);
+    assert.match(output, /Create Time:/);
   });
 
   it('should list anywhere caches', async () => {
@@ -119,23 +126,39 @@ describe.skip('Anywhere Cache', () => {
     const output = execSync(
       `node pauseAnywhereCache.js ${bucketName} ${cacheName}`
     );
-    assert.match(output, /Paused anywhere cache:/);
+    assert.match(output, /Successfully paused anywhere cache:/);
     assert.match(output, new RegExp(anywhereCachePath));
+    assert.match(output, /Current State:/);
   });
 
   it('should resume an anywhere cache', async () => {
     const output = execSync(
       `node resumeAnywhereCache.js ${bucketName} ${cacheName}`
     );
-    assert.match(output, /Resumed anywhere cache:/);
+    assert.match(output, /Successfully resumed anywhere cache:/);
     assert.match(output, new RegExp(anywhereCachePath));
+    assert.match(output, /Current State:/);
   });
 
   it('should disable an anywhere cache', async () => {
-    const output = execSync(
-      `node disableAnywhereCache.js ${bucketName} ${cacheName}`
-    );
-    assert.match(output, /Disabled anywhere cache:/);
-    assert.match(output, new RegExp(anywhereCachePath));
+    try {
+      const output = execSync(
+        `node disableAnywhereCache.js ${bucketName} ${cacheName}`
+      );
+      assert.match(
+        output,
+        /Successfully initiated disablement for Anywhere Cache:/
+      );
+      assert.match(output, new RegExp(anywhereCachePath));
+      assert.match(output, /Current State:/);
+      assert.match(output, /Resource Name:/);
+    } catch (error) {
+      const errorMessage = error.stderr.toString();
+
+      assert.match(
+        errorMessage,
+        /9 FAILED_PRECONDITION: The requested DISABLE operation can't be applied on cache in DISABLED state./
+      );
+    }
   });
 });