@temporalio/testing 1.0.0-rc.0 → 1.0.1

package/src/test-service-client.ts

@@ -0,0 +1,47 @@
+import * as grpc from '@grpc/grpc-js';
+import { Connection as BaseConnection, ConnectionOptions } from '@temporalio/client';
+import { ConnectionCtorOptions as BaseConnectionCtorOptions } from '@temporalio/client/lib/connection';
+import { temporal } from '../generated-protos';
+
+export type TestService = temporal.api.testservice.v1.TestService;
+export const { TestService } = temporal.api.testservice.v1;
+
+interface ConnectionCtorOptions extends BaseConnectionCtorOptions {
+  testService: TestService;
+}
+
+/**
+ * A Connection class that can be used to interact with both the test server's TestService and WorkflowService
+ */
+export class Connection extends BaseConnection {
+  public static readonly TestServiceClient = grpc.makeGenericClientConstructor({}, 'TestService', {});
+  public readonly testService: TestService;
+
+  protected static createCtorOptions(options?: ConnectionOptions): ConnectionCtorOptions {
+    const ctorOptions = BaseConnection.createCtorOptions(options);
+    const rpcImpl = this.generateRPCImplementation({
+      serviceName: 'temporal.api.testservice.v1.TestService',
+      client: ctorOptions.client,
+      callContextStorage: ctorOptions.callContextStorage,
+      interceptors: ctorOptions.options.interceptors,
+    });
+    const testService = TestService.create(rpcImpl, false, false);
+    return { ...ctorOptions, testService };
+  }
+
+  static lazy(options?: ConnectionOptions): Connection {
+    const ctorOptions = this.createCtorOptions(options);
+    return new this(ctorOptions);
+  }
+
+  static async connect(options?: ConnectionOptions): Promise<Connection> {
+    const ret = this.lazy(options);
+    await ret.ensureConnected();
+    return ret;
+  }
+
+  protected constructor(options: ConnectionCtorOptions) {
+    super(options);
+    this.testService = options.testService;
+  }
+}

package/src/utils.ts

@@ -0,0 +1,52 @@
+import { Connection } from '@temporalio/client';
+import { msToTs } from '@temporalio/internal-workflow-common';
+
+export async function waitOnNamespace(
+  connection: Connection,
+  namespace: string,
+  maxAttempts = 100,
+  retryIntervalSecs = 1
+): Promise<void> {
+  const runId = '12345678-dead-beef-1234-1234567890ab';
+  for (let attempt = 1; attempt <= maxAttempts; ++attempt) {
+    try {
+      await connection.workflowService.getWorkflowExecutionHistory({
+        namespace,
+        execution: { workflowId: 'fake', runId },
+      });
+    } catch (err: any) {
+      if (err.details.includes('workflow history not found') || err.details.includes(runId)) {
+        break;
+      }
+      if (attempt === maxAttempts) {
+        throw err;
+      }
+      await new Promise((resolve) => setTimeout(resolve, retryIntervalSecs * 1000));
+    }
+  }
+}
+
+export async function createNamespace(
+  connection: Connection,
+  namespace: string,
+  maxAttempts = 100,
+  retryIntervalSecs = 1
+): Promise<void> {
+  for (let attempt = 1; attempt <= maxAttempts; ++attempt) {
+    try {
+      await connection.workflowService.registerNamespace({
+        namespace,
+        workflowExecutionRetentionPeriod: msToTs('1 day'),
+      });
+      break;
+    } catch (err: any) {
+      if (err.details === 'Namespace already exists.') {
+        break;
+      }
+      if (attempt === maxAttempts) {
+        throw err;
+      }
+      await new Promise((resolve) => setTimeout(resolve, retryIntervalSecs * 1000));
+    }
+  }
+}