test(signature-v4-multi-region): beforeAll update

Author: siddsriv

packages/signature-v4-multi-region/src/eventbridge-sigv4a-put-api.e2e.spec.ts

@@ -17,13 +17,11 @@ import { CreateHealthCheckCommand, Route53Client } from "@aws-sdk/client-route-5
 import { defaultProvider } from "@aws-sdk/credential-provider-node";
 import { SignatureV4MultiRegion } from "@aws-sdk/signature-v4-multi-region";
 import { HttpRequest } from "@smithy/protocol-http";
-import { beforeAll, describe, expect, it, vi } from "vitest";
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
 
 const LONG_TIMEOUT = 5 * 60 * 1000;
-const POLLING_DELAY = 5000;
-const MAX_POLLING_ATTEMPTS = 40;
 
-// long-lived resources
+// Long-lived resources
 const RESOURCE_PREFIX = "jsv3-e2e-global";
 
 const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -55,6 +53,7 @@ describe("EventBridge Client with SignatureV4a", () => {
   let primaryEventBusArn: string | undefined;
   let secondaryEventBusArn: string | undefined;
   let healthCheckId: string | undefined;
+  let endpointArn: string | undefined;
 
   beforeAll(async () => {
     vi.setConfig({ hookTimeout: LONG_TIMEOUT });
@@ -78,64 +77,60 @@ describe("EventBridge Client with SignatureV4a", () => {
       signer,
     });
 
-    try {
-      eventBusName = `${RESOURCE_PREFIX}-bus`;
-      endpointName = `${RESOURCE_PREFIX}-endpoint`;
+    eventBusName = `${RESOURCE_PREFIX}-bus`;
+    endpointName = `${RESOURCE_PREFIX}-endpoint`;
 
-      const managementClient = new EventBridgeClient({ region: primaryRegion });
-      try {
-        await managementClient.send(new DescribeEndpointCommand({ Name: endpointName }));
-      } catch (error: any) {
-        if (error.name === "ResourceNotFoundException") {
-          // Create resources if they don't exist
-          const primaryBus = await primaryEbClient.send(new CreateEventBusCommand({ Name: eventBusName }));
-          primaryEventBusArn = primaryBus.EventBusArn;
-
-          const secondaryBus = await secondaryEbClient.send(new CreateEventBusCommand({ Name: eventBusName }));
-          secondaryEventBusArn = secondaryBus.EventBusArn;
-
-          const healthCheck = await route53Client.send(
-            new CreateHealthCheckCommand({
-              CallerReference: `${RESOURCE_PREFIX}-${Date.now()}`,
-              HealthCheckConfig: {
-                Type: "HTTP",
-                FullyQualifiedDomainName: "example.com",
-                Port: 80,
-                ResourcePath: "/",
-                RequestInterval: 30,
-                FailureThreshold: 3,
-              },
-            })
-          );
-          healthCheckId = healthCheck.HealthCheck?.Id;
-          await wait(10000);
-
-          const createEndpointResponse = await managementClient.send(
-            new CreateEndpointCommand({
-              Name: endpointName,
-              RoutingConfig: {
-                FailoverConfig: {
-                  Primary: { HealthCheck: `arn:aws:route53:::healthcheck/${healthCheckId}` },
-                  Secondary: { Route: secondaryRegion },
-                },
+    const managementClient = new EventBridgeClient({ region: primaryRegion });
+    try {
+      const existingEndpoint = await managementClient.send(new DescribeEndpointCommand({ Name: endpointName }));
+      endpointArn = existingEndpoint.Arn;
+    } catch (error: any) {
+      if (error.name === "ResourceNotFoundException") {
+        const primaryBus = await primaryEbClient.send(new CreateEventBusCommand({ Name: eventBusName }));
+        primaryEventBusArn = primaryBus.EventBusArn;
+
+        const secondaryBus = await secondaryEbClient.send(new CreateEventBusCommand({ Name: eventBusName }));
+        secondaryEventBusArn = secondaryBus.EventBusArn;
+
+        const healthCheck = await route53Client.send(
+          new CreateHealthCheckCommand({
+            CallerReference: `${RESOURCE_PREFIX}-${Date.now()}`,
+            HealthCheckConfig: {
+              Type: "HTTP",
+              FullyQualifiedDomainName: "example.com",
+              Port: 80,
+              ResourcePath: "/",
+              RequestInterval: 30,
+              FailureThreshold: 3,
+            },
+          })
+        );
+        healthCheckId = healthCheck.HealthCheck?.Id;
+        await wait(10000);
+
+        const createEndpointResponse = await managementClient.send(
+          new CreateEndpointCommand({
+            Name: endpointName,
+            RoutingConfig: {
+              FailoverConfig: {
+                Primary: { HealthCheck: `arn:aws:route53:::healthcheck/${healthCheckId}` },
+                Secondary: { Route: secondaryRegion },
               },
-              ReplicationConfig: { State: ReplicationState.DISABLED },
-              EventBuses: [{ EventBusArn: primaryEventBusArn }, { EventBusArn: secondaryEventBusArn }],
-            })
-          );
-        } else {
-          throw error;
-        }
-      } finally {
-        managementClient.destroy();
+            },
+            ReplicationConfig: { State: ReplicationState.DISABLED },
+            EventBuses: [{ EventBusArn: primaryEventBusArn }, { EventBusArn: secondaryEventBusArn }],
+          })
+        );
+        endpointArn = createEndpointResponse.Arn;
+      } else {
+        throw error;
       }
-    } catch (error) {
-      console.error("Error during setup:", error);
-      throw error;
+    } finally {
+      managementClient.destroy();
     }
   }, LONG_TIMEOUT);
 
-  beforeAll(async () => {
+  afterAll(async () => {
     primaryEbClient?.destroy();
     secondaryEbClient?.destroy();
     route53Client?.destroy();
@@ -184,39 +179,15 @@ describe("EventBridge Client with SignatureV4a", () => {
   it(
     "should send an event to an EventBridge Global Endpoint using SignatureV4a",
     async () => {
-      let attempts = 0;
-      let currentState: EndpointState | string | undefined;
-      let endpointUrl: string | undefined;
       const managementClient = new EventBridgeClient({ region: primaryRegion });
-
-      while (attempts < MAX_POLLING_ATTEMPTS) {
-        attempts++;
-        try {
-          const describeResponse = await managementClient.send(new DescribeEndpointCommand({ Name: endpointName }));
-          currentState = describeResponse.State;
-          if (currentState === EndpointState.ACTIVE) {
-            endpointUrl = describeResponse.EndpointUrl;
-            break;
-          }
-          if (currentState === EndpointState.CREATE_FAILED || currentState === EndpointState.UPDATE_FAILED) {
-            throw new Error(`Endpoint entered failed state: ${currentState}`);
-          }
-        } catch (error) {
-          console.warn(`DescribeEndpoint failed (attempt ${attempts}):`, error);
-        }
-        await wait(POLLING_DELAY);
-      }
+      const describeResponse = await managementClient.send(new DescribeEndpointCommand({ Name: endpointName }));
       managementClient.destroy();
 
-      if (currentState !== EndpointState.ACTIVE) {
-        throw new Error(`Endpoint ${endpointName} did not become ACTIVE after ${attempts} attempts.`);
-      }
-      expect(endpointUrl).toBeDefined();
+      expect(describeResponse.State).toBe(EndpointState.ACTIVE);
+      expect(describeResponse.EndpointUrl).toBeDefined();
 
-      const endpointSubdomain = getSubdomainFromUrl(endpointUrl);
-      if (!endpointSubdomain) {
-        throw new Error(`Failed to extract subdomain from Endpoint URL: ${endpointUrl}`);
-      }
+      const endpointSubdomain = getSubdomainFromUrl(describeResponse.EndpointUrl);
+      expect(endpointSubdomain).toBeDefined();
 
       const putEventsInput: PutEventsCommandInput = {
         Entries: [
@@ -236,6 +207,9 @@ describe("EventBridge Client with SignatureV4a", () => {
       expect(putEventsResponse.FailedEntryCount).toBe(0);
       expect(putEventsResponse.Entries).toHaveLength(1);
       expect(putEventsResponse.Entries?.[0]?.EventId).toBeDefined();
+      // Note: Verifying the event *arrived* in the target bus (primary or secondary)
+      // would require additional setup and is omitted
+      // here to focus on the PutEvents call itself succeeding with SigV4a.
     },
     LONG_TIMEOUT
   );