ci: fixing contract test breaking due to async hooks

Author: joker23

packages/sdk/server-node/contract-tests/src/sdkClientEntity.ts

@@ -88,9 +88,7 @@ export function makeSdkConfig(options: ServerSDKConfigParams, tag: string): LDOp
   }
 
   if (options.hooks) {
-    cf.hooks = options.hooks.hooks.map(
-      (hook) => new TestHook(hook.name, hook.callbackUri, hook.data, hook.errors),
-    );
+    cf.hooks = TestHook.forClient(options.hooks.hooks);
   }
 
   if (options.wrapper) {

packages/tooling/contract-test-utils/src/client-side/TestHook.ts

@@ -8,8 +8,15 @@ import {
 } from '@launchdarkly/js-client-sdk-common';
 
 import { BaseTestHook } from '../shared/BaseTestHook.js';
+import { HookPostQueue } from '../shared/HookPostQueue.js';
+import { SDKConfigHookInstance } from '../types/ConfigParams.js';
 
 export default class TestHook extends BaseTestHook implements Hook {
+  static forClient(configs: ReadonlyArray<SDKConfigHookInstance>): TestHook[] {
+    const queue = new HookPostQueue();
+    return configs.map((c) => new TestHook(c.name, c.callbackUri, c.data, c.errors, queue));
+  }
+
   protected async safePost(body: unknown): Promise<void> {
     try {
       await fetch(this.endpoint, {
@@ -52,7 +59,7 @@ export default class TestHook extends BaseTestHook implements Hook {
     if (this.hookErrors?.afterTrack) {
       throw new Error(this.hookErrors.afterTrack);
     }
-    this.safePost({
+    this.enqueuePost({
       trackSeriesContext: hookContext,
       stage: 'afterTrack',
     });

packages/tooling/contract-test-utils/src/server-side/TestHook.ts

@@ -1,8 +1,15 @@
 import { integrations, LDEvaluationDetail } from '@launchdarkly/js-server-sdk-common';
 
 import { BaseTestHook } from '../shared/BaseTestHook.js';
+import { HookPostQueue } from '../shared/HookPostQueue.js';
+import { SDKConfigHookInstance } from '../types/ConfigParams.js';
 
 export default class TestHook extends BaseTestHook implements integrations.Hook {
+  static forClient(configs: ReadonlyArray<SDKConfigHookInstance>): TestHook[] {
+    const queue = new HookPostQueue();
+    return configs.map((c) => new TestHook(c.name, c.callbackUri, c.data, c.errors, queue));
+  }
+
   protected async safePost(body: unknown): Promise<void> {
     try {
       await fetch(this.endpoint, {

packages/tooling/contract-test-utils/src/shared/BaseTestHook.ts

@@ -1,20 +1,34 @@
 import { HookData, HookErrors } from '../types/CommandParams.js';
 
+import { HookPostQueue } from './HookPostQueue.js';
+
 export abstract class BaseTestHook {
   protected readonly hookName: string;
   protected readonly endpoint: string;
   protected readonly hookData?: HookData;
   protected readonly hookErrors?: HookErrors;
+  private readonly _postQueue: HookPostQueue;
 
-  constructor(name: string, endpoint: string, data?: HookData, errors?: HookErrors) {
+  constructor(
+    name: string,
+    endpoint: string,
+    data?: HookData,
+    errors?: HookErrors,
+    postQueue?: HookPostQueue,
+  ) {
     this.hookName = name;
     this.endpoint = endpoint;
     this.hookData = data;
     this.hookErrors = errors;
+    this._postQueue = postQueue ?? new HookPostQueue();
   }
 
   protected abstract safePost(body: unknown): Promise<void>;
 
+  protected enqueuePost(body: unknown): void {
+    this._postQueue.enqueue(() => this.safePost(body));
+  }
+
   getMetadata() {
     return { name: this.hookName };
   }
@@ -26,7 +40,7 @@ export abstract class BaseTestHook {
     if (this.hookErrors?.beforeEvaluation) {
       throw new Error(this.hookErrors.beforeEvaluation);
     }
-    this.safePost({
+    this.enqueuePost({
       evaluationSeriesContext: hookContext,
       evaluationSeriesData: data,
       stage: 'beforeEvaluation',
@@ -42,7 +56,7 @@ export abstract class BaseTestHook {
     if (this.hookErrors?.afterEvaluation) {
       throw new Error(this.hookErrors.afterEvaluation);
     }
-    this.safePost({
+    this.enqueuePost({
       evaluationSeriesContext: hookContext,
       evaluationSeriesData: data,
       stage: 'afterEvaluation',

packages/tooling/contract-test-utils/src/shared/HookPostQueue.ts

@@ -0,0 +1,9 @@
+// The test harness records hook callbacks in network-arrival order, so
+// parallel fetches break ordering assertions. Chain them instead.
+export class HookPostQueue {
+  private _chain: Promise<void> = Promise.resolve();
+
+  enqueue(fn: () => Promise<void>): void {
+    this._chain = this._chain.then(fn).catch(() => {});
+  }
+}