fix: compute_hyperdisk_create_from_pool

compute/disks/createComputeHyperdiskFromPool.js

@@ -35,9 +35,9 @@ async function main() {
   // The zone where your VM and new disk are located.
   const zone = 'europe-central2-b';
   // The name of the new disk
-  const diskName = 'disk-name-from-pool';
+  const diskName = 'disk-from-pool-name';
   // The name of the storage pool
-  const storagePoolName = 'storage-pool-name-hyperdisk';
+  const storagePoolName = 'storage-pool-name';
   // Link to the storagePool you want to use. Use format:
   // https://www.googleapis.com/compute/v1/projects/{projectId}/zones/{zone}/storagePools/{storagePoolName}
   const storagePool = `https://www.googleapis.com/compute/v1/projects/${projectId}/zones/${zone}/storagePools/${storagePoolName}`;

compute/disks/createComputeHyperdiskPool.js

@@ -33,7 +33,7 @@ async function main() {
   // Project ID or project number of the Google Cloud project you want to use.
   const projectId = await storagePoolClient.getProjectId();
   // Name of the zone in which you want to create the storagePool.
-  const zone = 'us-central1-a';
+  const zone = 'europe-central2-b';
   // Name of the storagePool you want to create.
   const storagePoolName = 'storage-pool-name';
   // The type of disk you want to create. This value uses the following format:

compute/test/createComputeHyperdiskFromPool.test.js

@@ -20,96 +20,82 @@ const path = require('path');
 const {assert} = require('chai');
 const {after, before, describe, it} = require('mocha');
 const cp = require('child_process');
-const {DisksClient, StoragePoolsClient} = require('@google-cloud/compute').v1;
+const {DisksClient, StoragePoolsClient, ZoneOperationsClient} =
+  require('@google-cloud/compute').v1;
 
 const execSync = cmd => cp.execSync(cmd, {encoding: 'utf-8'});
 const cwd = path.join(__dirname, '..');
 
+async function cleanupResources(projectId, zone, diskName, storagePoolName) {
+  const disksClient = new DisksClient();
+  const storagePoolsClient = new StoragePoolsClient();
+  const zoneOperationsClient = new ZoneOperationsClient();
+  // Delete disk attached to storagePool
+  const [diskResponse] = await disksClient.delete({
+    project: projectId,
+    disk: diskName,
+    zone,
+  });
+
+  let diskOperation = diskResponse.latestResponse;
+
+  // Wait for the delete disk operation to complete.
+  while (diskOperation.status !== 'DONE') {
+    [diskOperation] = await zoneOperationsClient.wait({
+      operation: diskOperation.name,
+      project: projectId,
+      zone: diskOperation.zone.split('/').pop(),
+    });
+  }
+
+  const [poolResponse] = await storagePoolsClient.delete({
+    project: projectId,
+    storagePool: storagePoolName,
+    zone,
+  });
+  let poolOperation = poolResponse.latestResponse;
+
+  // Wait for the delete pool operation to complete.
+  while (poolOperation.status !== 'DONE') {
+    [poolOperation] = await zoneOperationsClient.wait({
+      operation: poolOperation.name,
+      project: projectId,
+      zone: poolOperation.zone.split('/').pop(),
+    });
+  }
+}
+
 describe('Create compute hyperdisk from pool', async () => {
-  const diskName = 'disk-name-from-pool';
+  const diskName = 'disk-from-pool-name';
   const zone = 'europe-central2-b';
-  const storagePoolName = 'storage-pool-name-hyperdisk';
+  const storagePoolName = 'storage-pool-name';
   const disksClient = new DisksClient();
-  const storagePoolsClient = new StoragePoolsClient();
   let projectId;
 
   before(async () => {
     projectId = await disksClient.getProjectId();
 
     // Ensure resources are deleted before attempting to recreate them
     try {
-      await disksClient.delete({
-        project: projectId,
-        disk: diskName,
-        zone,
-      });
-    } catch (err) {
-      // Should be ok to ignore (resource doesn't exist)
-      console.error(err);
-    }
-
-    try {
-      await storagePoolsClient.delete({
-        project: projectId,
-        storagePool: storagePoolName,
-        zone,
-      });
+      await cleanupResources(projectId, zone, diskName, storagePoolName);
     } catch (err) {
-      // Should be ok to ignore (resource doesn't exist)
+      // Should be ok to ignore (resources do not exist)
       console.error(err);
     }
-
-    await storagePoolsClient.insert({
-      project: projectId,
-      storagePoolResource: {
-        name: storagePoolName,
-        poolProvisionedCapacityGb: 10240,
-        poolProvisionedIops: 10000,
-        poolProvisionedThroughput: 1024,
-        storagePoolType: `projects/${projectId}/zones/${zone}/storagePoolTypes/hyperdisk-balanced`,
-        capacityProvisioningType: 'advanced',
-        zone,
-      },
-      zone,
-    });
   });
 
   after(async () => {
-    // Trying to delete the disk too quickly seems to fail
-    const deleteDisk = async () => {
-      setTimeout(async () => {
-        await disksClient.delete({
-          project: projectId,
-          disk: diskName,
-          zone,
-        });
-      }, 120 * 1000); // wait two minutes
-    };
-
-    try {
-      await deleteDisk();
-    } catch {
-      // Try one more time after repeating the delay
-      await deleteDisk();
-    }
+    await cleanupResources(projectId, zone, diskName, storagePoolName);
+  });
 
-    // Need enough time after removing the disk before removing the pool
-    const deletePool = async () => {
-      setTimeout(async () => {
-        await storagePoolsClient.delete({
-          project: projectId,
-          storagePool: storagePoolName,
-          zone,
-        });
-      }, 120 * 1000); // wait two minutes
-    };
+  it('should create a new storage pool', () => {
+    const response = JSON.parse(
+      execSync('node ./disks/createComputeHyperdiskPool.js', {
+        cwd,
+      })
+    );
 
-    try {
-      await deletePool();
-    } catch {
-      // Try one more time after repeating the delay
-      await deletePool();
-    }
+    assert.equal(response.name, storagePoolName);
   });
 
   it('should create a new hyperdisk from pool', () => {