chore: fixed discovery tests failing

Author: aryanjassal

src/discovery/Discovery.ts

@@ -180,17 +180,13 @@ class Discovery {
           undefined,
           gestaltsUtils.decodeGestaltId(parent ?? undefined),
           true,
-          undefined,
-          ctx,
         );
         return;
       }
       // Aborting a duplicate task is not an error
       if (e === abortSingletonTaskReason) return;
       // Destroying tasks is not an error
       if (e === discoveryDestroyedTaskReason) return;
-      // Abortion due to cancellation is not an error
-      if (e === ctx.signal.reason) return;
       this.dispatchEvent(
         new discoveryEvents.EventDiscoveryVertexFailed({
           detail: {
@@ -352,10 +348,6 @@ class Discovery {
       ['node', nodeId],
       undefined,
       lastProcessedCutoffTime,
-      undefined,
-      undefined,
-      undefined,
-      ctx,
     );
   }
 
@@ -381,10 +373,6 @@ class Discovery {
       ['identity', [providerId, identityId]],
       undefined,
       lastProcessedCutoffTime,
-      undefined,
-      undefined,
-      undefined,
-      ctx,
     );
   }
 
@@ -438,10 +426,8 @@ class Discovery {
     const [type, id] = vertexId;
     switch (type) {
       case 'node':
-        // Return await this.processNode(id, lastProcessedCutoffTime, ctx);
         return await this.processNode(id, lastProcessedCutoffTime, ctx);
       case 'identity':
-        // Return await this.processIdentity(id, lastProcessedCutoffTime, ctx);
         return await this.processIdentity(id, lastProcessedCutoffTime, ctx);
       default:
         never(`type must be either "node" or "identity" got "${type}"`);
@@ -489,7 +475,6 @@ class Discovery {
     }
     // Iterate over each of the claims in the chain (already verified).
     for (const signedClaim of Object.values(vertexChainData)) {
-      ctx.signal.throwIfAborted();
       switch (signedClaim.payload.typ) {
         case 'ClaimLinkNode':
           await this.processClaimLinkNode(
@@ -581,9 +566,6 @@ class Discovery {
         undefined,
         lastProcessedCutoffTime,
         ['node', nodeId],
-        undefined,
-        undefined,
-        ctx,
       );
     }
   }
@@ -687,9 +669,6 @@ class Discovery {
         undefined,
         lastProcessedCutoffTime,
         ['node', nodeId],
-        undefined,
-        undefined,
-        ctx,
       );
     }
   }
@@ -766,9 +745,6 @@ class Discovery {
           undefined,
           lastProcessedCutoffTime,
           ['identity', providerIdentityId],
-          undefined,
-          undefined,
-          ctx,
         );
       }
     }
@@ -828,13 +804,12 @@ class Discovery {
    */
   protected async scheduleDiscoveryForVertex(
     vertex: GestaltId,
-    delay: number | undefined,
-    lastProcessedCutoffTime: number | undefined,
-    parent: GestaltId | undefined,
+    delay?: number,
+    lastProcessedCutoffTime?: number,
+    parent?: GestaltId,
     ignoreActive: boolean = false,
-    tran: DBTransaction | undefined,
-    ctx: ContextTimed,
-  ) {
+    tran?: DBTransaction,
+  ): Promise<void> {
     if (tran == null) {
       return this.db.withTransactionF((tran) =>
         this.scheduleDiscoveryForVertex(
@@ -844,7 +819,6 @@ class Discovery {
           parent,
           ignoreActive,
           tran,
-          ctx,
         ),
       );
     }
@@ -864,9 +838,7 @@ class Discovery {
       true,
       [this.constructor.name, this.discoverVertexHandlerId, gestaltIdEncoded],
       tran,
-      ctx,
     )) {
-      ctx.signal.throwIfAborted();
       // Ignore active tasks
       if (ignoreActive && task.status === 'active') continue;
       if (taskExisting == null) {

src/tasks/TaskManager.ts

@@ -397,33 +397,23 @@ class TaskManager {
     };
   }
 
-  public getTasks(
-    order?: 'asc' | 'desc',
-    lazy?: boolean,
-    path?: TaskPath,
-    tran?: DBTransaction,
-    ctx?: Partial<ContextTimedInput>,
-  ): AsyncGenerator<Task>;
   @ready(new tasksErrors.ErrorTaskManagerNotRunning())
-  @timed()
   public async *getTasks(
     order: 'asc' | 'desc' = 'asc',
     lazy: boolean = false,
-    path: TaskPath | undefined,
-    tran: DBTransaction | undefined,
-    @context ctx: ContextTimed,
+    path?: TaskPath,
+    tran?: DBTransaction,
   ): AsyncGenerator<Task> {
     if (tran == null) {
       return yield* this.db.withTransactionG((tran) =>
-        this.getTasks(order, lazy, path, tran, ctx),
+        this.getTasks(order, lazy, path, tran),
       );
     }
     if (path == null) {
       for await (const [[taskIdBuffer]] of tran.iterator(
         [...this.tasksTaskDbPath],
         { values: false, reverse: order !== 'asc' },
       )) {
-        ctx.signal.throwIfAborted();
         const taskId = IdInternal.fromBuffer<TaskId>(taskIdBuffer as Buffer);
         const task = (await this.getTask(taskId, lazy, tran))!;
         yield task;

tests/discovery/Discovery.test.ts

@@ -293,10 +293,17 @@ describe('Discovery', () => {
     await discovery.stop();
     await discovery.destroy();
     await expect(
-      discovery.queueDiscoveryByIdentity('' as ProviderId, '' as IdentityId),
+      async () =>
+        await discovery.queueDiscoveryByIdentity(
+          '' as ProviderId,
+          '' as IdentityId,
+        ),
     ).rejects.toThrow(discoveryErrors.ErrorDiscoveryNotRunning);
     await expect(
-      discovery.queueDiscoveryByNode(testNodesUtils.generateRandomNodeId()),
+      async () =>
+        await discovery.queueDiscoveryByNode(
+          testNodesUtils.generateRandomNodeId(),
+        ),
     ).rejects.toThrow(discoveryErrors.ErrorDiscoveryNotRunning);
   });
   test('discovery by node', async () => {

tests/vaults/VaultInternal.test.ts

@@ -117,13 +117,13 @@ describe('VaultInternal', () => {
 
   test('VaultInternal readiness', async () => {
     await vault.stop();
-    await expect(async () => {
-      await vault.log();
-    }).rejects.toThrow(vaultsErrors.ErrorVaultNotRunning);
+    await expect(async () => await vault.log()).rejects.toThrow(
+      vaultsErrors.ErrorVaultNotRunning,
+    );
     await vault.destroy();
-    await expect(async () => {
-      await vault.start();
-    }).rejects.toThrow(vaultsErrors.ErrorVaultDestroyed);
+    await expect(async () => await vault.start()).rejects.toThrow(
+      vaultsErrors.ErrorVaultDestroyed,
+    );
   });
   test('is type correct', async () => {
     expect(vault).toBeInstanceOf(VaultInternal);