some bug fixes & testiung mostly related to timeouts

Author: toptobes

src/api/devops-api-http-client.ts

@@ -18,7 +18,7 @@ import { AxiosError, AxiosResponse } from 'axios';
 import { HTTPClientOptions } from '@/src/api/types';
 import { HTTP1AuthHeaderFactories, HTTP1Strategy } from '@/src/api/http1';
 import { DevopsApiResponseError, DevopsApiTimeout, DevopsUnexpectedStateError } from '@/src/devops/errors';
-import { AdminBlockingOptions } from '@/src/devops/types';
+import { AdminBlockingOptions, PollBlockingOptions } from '@/src/devops/types';
 import {
   MkTimeoutError,
   MultiCallTimeoutManager,
@@ -80,15 +80,14 @@ export class DevopsApiHttpClient extends HttpClient {
       ? info.id(resp)
       : info.id;
 
-    await this._awaitStatus(id, 'ACTIVE', ['MAINTENANCE'], info.options, info.defaultPollInterval, timeoutManager);
+    if (info?.options?.blocking !== false) {
+      await this._awaitStatus(id, info.target, info.legalStates, info.options, info.defaultPollInterval, timeoutManager);
+    }
+
     return resp;
   }
 
-  private async _awaitStatus(id: string, target: string, legalStates: string[], options: AdminBlockingOptions | undefined, defaultPollInterval: number, timeoutManager: TimeoutManager): Promise<void> {
-    if (options?.blocking === false) {
-      return;
-    }
-
+  private async _awaitStatus(id: string, target: string, legalStates: string[], options: PollBlockingOptions | undefined, defaultPollInterval: number, timeoutManager: TimeoutManager): Promise<void> {
     for (;;) {
       const resp = await this.request({
         method: HTTP_METHODS.Get,
@@ -113,7 +112,7 @@ export class DevopsApiHttpClient extends HttpClient {
 }
 
 const mkTimeoutManager = (constructor: new (maxMs: number, mkTimeoutError: MkTimeoutError) => TimeoutManager, maxMs: number | undefined) => {
-  const timeout = maxMs ?? DEFAULT_TIMEOUT;
+  const timeout = maxMs ?? 0;
   return new constructor(timeout, mkTimeoutErrorMaker(timeout));
 }
 

src/api/http-client.ts

@@ -88,7 +88,7 @@ export class HttpClient {
   }
 
   protected async _request(info: HTTPRequestInfo): Promise<GuaranteedAPIResponse> {
-    return await this.requestStrategy.request({
+    const fullInfo = {
       url: info.url,
       data: info.data,
       method: info.method,
@@ -97,7 +97,12 @@ export class HttpClient {
       userAgent: this.userAgent,
       timeoutManager: info.timeoutManager,
       reviver: info.reviver,
-    });
+    };
+
+    if (info.timeoutManager.msRemaining <= 0) {
+      throw info.timeoutManager.mkTimeoutError(fullInfo);
+    }
+    return await this.requestStrategy.request(fullInfo);
   }
 }
 

src/api/http1.ts

@@ -68,7 +68,9 @@ export class HTTP1Strategy implements HTTPRequestStrategy {
         data: info.data,
         params: info.params,
         method: info.method,
-        timeout: info.timeoutManager.msRemaining,
+        timeout: (isFinite(info.timeoutManager.msRemaining))
+          ? info.timeoutManager.msRemaining
+          : 0,
         headers: {
           ...this._authHeaderFactory(info.token),
           'User-Agent': info.userAgent,

src/api/http2.ts

@@ -38,7 +38,9 @@ export class HTTP2Strategy implements HTTPRequestStrategy {
         this.#session = this._reviveSession();
       }
 
-      const timer = setTimeout(() => reject(info.timeoutManager.mkTimeoutError(info)), info.timeoutManager.msRemaining);
+      const timer = (isFinite(info.timeoutManager.msRemaining))
+        ? setTimeout(() => reject(info.timeoutManager.mkTimeoutError(info)), info.timeoutManager.msRemaining)
+        : undefined;
 
       const path = info.url.replace(this.origin, '');
       const params = info.params ? `?${new URLSearchParams(info.params).toString()}` : '';

src/api/timeout-managers.ts

@@ -30,15 +30,19 @@ export interface TimeoutManager {
 }
 
 export class SingleCallTimeoutManager implements TimeoutManager {
-  constructor(readonly msRemaining: number, readonly mkTimeoutError: MkTimeoutError) {}
+  public readonly msRemaining: number;
+
+  constructor(maxMs: number, readonly mkTimeoutError: MkTimeoutError) {
+    this.msRemaining = maxMs || Infinity;
+  }
 }
 
 export class MultiCallTimeoutManager implements TimeoutManager {
   private _deadline!: number;
   private _started: boolean;
 
   constructor(maxMs: number, readonly mkTimeoutError: MkTimeoutError) {
-    this._deadline = maxMs;
+    this._deadline = maxMs || Infinity;
     this._started = false;
   }
 

src/devops/astra-db-admin.ts

@@ -242,12 +242,12 @@ export class AstraDbAdmin extends DbAdmin {
    */
   public async drop(options?: AdminBlockingOptions): Promise<void> {
     await this._httpClient.requestLongRunning({
-      method: HTTP_METHODS.Delete,
-      path: `/databases/${this._db.id}`,
+      method: HTTP_METHODS.Post,
+      path: `/databases/${this._db.id}/terminate`,
     }, {
       id: this._db.id,
-      target: 'DELETED',
-      legalStates: ['TERMINATED'],
+      target: 'TERMINATED',
+      legalStates: ['TERMINATING'],
       defaultPollInterval: 10000,
       options,
     });

tests/integration/data-api/collection/insert-many.test.ts

@@ -9,7 +9,7 @@
 // limitations under the License.
 // noinspection DuplicatedCode
 
-import { Collection, DataAPIError, InsertManyError, ObjectId, UUID } from '@/src/data-api';
+import { Collection, DataAPIError, DataAPITimeout, InsertManyError, ObjectId, UUID } from '@/src/data-api';
 import { assertTestsEnabled, initCollectionWithFailingClient, initTestObjects } from '@/tests/fixtures';
 import assert from 'assert';
 
@@ -204,6 +204,25 @@ describe('integration.data-api.collection.insert-many', () => {
     }
   });
 
+  it('times out properly', async () => {
+    try {
+      const docs = Array.from({ length: 1000 }, (_, i) => ({ _id: i }));
+      await collection.insertMany(docs, { ordered: true, maxTimeMS: 500, chunkSize: 10 });
+      assert.fail('Expected an error');
+    } catch (e) {
+      assert.ok(e instanceof DataAPITimeout);
+      assert.strictEqual(e.timeout, 500);
+      const found = await collection.find({}).toArray();
+      assert.ok(found.length > 0);
+      assert.ok(found.length < 1000);
+    }
+  });
+
+  it('does not time out if maxTimeMS is high', async () => {
+    const docs = Array.from({ length: 100 }, (_, i) => ({ _id: i }));
+    await collection.insertMany(docs, { ordered: true, maxTimeMS: 500000, chunkSize: 10 });
+  });
+
   it('[dev] should insertMany with vectorize', async function () {
     assertTestsEnabled(this, 'DEV');
     const res = await collection.insertMany([

tests/integration/data-api/collection/update-many.test.ts

@@ -9,7 +9,7 @@
 // limitations under the License.
 // noinspection DuplicatedCode
 
-import { BulkWriteError, Collection, DataAPIError, UpdateManyError } from '@/src/data-api';
+import { Collection, DataAPIError, UpdateManyError } from '@/src/data-api';
 import { initCollectionWithFailingClient, initTestObjects, sampleUsersList } from '@/tests/fixtures';
 import assert from 'assert';
 

tests/integration/devops/lifecycle.test.ts

@@ -17,6 +17,8 @@ import { assertTestsEnabled, initTestObjects } from '@/tests/fixtures';
 import { DataApiClient } from '@/src/client';
 import assert from 'assert';
 import { DevopsApiResponseError } from '@/src/devops';
+import { SingleCallTimeoutManager } from '@/src/api/timeout-managers';
+import { DEFAULT_TIMEOUT } from '@/src/api';
 
 describe('integration.devops.lifecycle', async () => {
   let client: DataApiClient;
@@ -89,7 +91,7 @@ describe('integration.devops.lifecycle', async () => {
       }
 
       {
-        await asyncDbAdmin['_httpClient'].awaitStatus(asyncDb, 'ACTIVE', ['INITIALIZING', 'PENDING'], {}, 10000);
+        await asyncDbAdmin['_httpClient']['_awaitStatus'](asyncDb.id, 'ACTIVE', ['INITIALIZING', 'PENDING'], {}, 10000, new SingleCallTimeoutManager(DEFAULT_TIMEOUT, () => new Error('Timeout')));
       }
 
       for (const [dbAdmin, db, dbType] of [[syncDbAdmin, syncDb, 'sync'], [asyncDbAdmin, asyncDb, 'async']] as const) {
@@ -132,7 +134,7 @@ describe('integration.devops.lifecycle', async () => {
 
       {
         await syncDbAdmin.createNamespace('other_namespace');
-        await asyncDbAdmin['_httpClient'].awaitStatus(asyncDb, 'ACTIVE', ['MAINTENANCE'], {}, 1000);
+        await asyncDbAdmin['_httpClient']['_awaitStatus'](asyncDb.id, 'ACTIVE', ['MAINTENANCE'], {}, 1000, new SingleCallTimeoutManager(DEFAULT_TIMEOUT, () => new Error('Timeout')));
       }
 
       for (const [dbAdmin, db, dbType] of [[syncDbAdmin, syncDb, 'sync'], [asyncDbAdmin, asyncDb, 'async']] as const) {
@@ -151,7 +153,7 @@ describe('integration.devops.lifecycle', async () => {
 
       {
         await syncDbAdmin.dropNamespace('other_namespace', { blocking: true });
-        await asyncDbAdmin['_httpClient'].awaitStatus(asyncDb, 'ACTIVE', ['MAINTENANCE'], {}, 1000);
+        await asyncDbAdmin['_httpClient']['_awaitStatus'](asyncDb.id, 'ACTIVE', ['MAINTENANCE'], {}, 1000, new SingleCallTimeoutManager(DEFAULT_TIMEOUT, () => new Error('Timeout')));
       }
 
       for (const [dbAdmin, db, dbType] of [[syncDbAdmin, syncDb, 'sync'], [asyncDbAdmin, asyncDb, 'async']] as const) {
@@ -172,7 +174,7 @@ describe('integration.devops.lifecycle', async () => {
 
       {
         await admin.dropDatabase(syncDb);
-        await asyncDbAdmin['_httpClient'].awaitStatus(asyncDbAdmin, 'TERMINATED', ['TERMINATING'], {}, 10000);
+        await asyncDbAdmin['_httpClient']['_awaitStatus'](asyncDb.id, 'TERMINATED', ['TERMINATING'], {}, 10000, new SingleCallTimeoutManager(DEFAULT_TIMEOUT, () => new Error('Timeout')));
       }
 
       for (const [dbAdmin, dbType] of [[syncDbAdmin, 'sync'], [asyncDbAdmin, 'async']] as const) {