test(signature-v4-multi-region): use long-lived resources for sigv4a events test (#7039)

siddsriv · web-flow · commit 2bd6ec20dbcf · 2025-04-29T16:33:29.000-04:00
* test(signature-v4-multi-region): use long-lived resources for sigv4a events test

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

* test(signature-v4-multi-region): timeouts
diff --git a/packages/signature-v4-multi-region/src/eventbridge-sigv4a-put-api.e2e.spec.ts b/packages/signature-v4-multi-region/src/eventbridge-sigv4a-put-api.e2e.spec.ts
@@ -5,8 +5,6 @@ import { Sha256 } from "@aws-crypto/sha256-js";
 import {
   CreateEndpointCommand,
   CreateEventBusCommand,
-  DeleteEndpointCommand,
-  DeleteEventBusCommand,
   DescribeEndpointCommand,
   EndpointState,
   EventBridgeClient,
@@ -15,27 +13,24 @@ import {
   PutEventsCommandOutput,
   ReplicationState,
 } from "@aws-sdk/client-eventbridge";
-import { CreateHealthCheckCommand, DeleteHealthCheckCommand, Route53Client } from "@aws-sdk/client-route-53";
-import { GetCallerIdentityCommand, STSClient } from "@aws-sdk/client-sts";
+import { CreateHealthCheckCommand, Route53Client } from "@aws-sdk/client-route-53";
 import { defaultProvider } from "@aws-sdk/credential-provider-node";
 import { SignatureV4MultiRegion } from "@aws-sdk/signature-v4-multi-region";
 import { HttpRequest } from "@smithy/protocol-http";
 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
+const RESOURCE_PREFIX = "jsv3-e2e-global";
 
 const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
 const getSubdomainFromUrl = (url: string | undefined): string | undefined => {
   if (!url) return undefined;
   try {
     const parsedUrl = new URL(url);
-    // Hostname will be like abcde.xyz.endpoint.events.amazonaws.com
     const hostnameParts = parsedUrl.hostname.split(".");
-    // We can expect at least 5 parts: subdomain[0].subdomain[1].endpoint.events.amazonaws.com
-    // Check if the 3rd part from the end is 'events'
     if (hostnameParts.length >= 5 && hostnameParts[hostnameParts.length - 3] === "events") {
       return `${hostnameParts[0]}.${hostnameParts[1]}`;
     }
@@ -46,71 +41,26 @@ const getSubdomainFromUrl = (url: string | undefined): string | undefined => {
 };
 
 describe("EventBridge Client with SignatureV4a", () => {
-  let stsClient: STSClient;
   let primaryEbClient: EventBridgeClient;
   let secondaryEbClient: EventBridgeClient;
   let route53Client: Route53Client;
   let signer: SignatureV4MultiRegion;
   let globalEbClient: EventBridgeClient;
-
-  let accountId: string;
-  let timestamp: number;
   let primaryRegion: string;
   let secondaryRegion: string;
   let eventBusName: string;
+  let endpointName: string;
   let primaryEventBusArn: string | undefined;
   let secondaryEventBusArn: string | undefined;
   let healthCheckId: string | undefined;
-  let endpointName: string;
   let endpointArn: string | undefined;
 
-  const cleanupResources = async () => {
-    try {
-      if (endpointArn) {
-        const managementClient = new EventBridgeClient({ region: primaryRegion });
-        await managementClient.send(new DeleteEndpointCommand({ Name: endpointName }));
-        managementClient.destroy();
-        endpointArn = undefined; // Mark as deleted
-      }
-    } catch (error) {
-      console.error(`Error deleting endpoint ${endpointName}:`, error);
-    }
-
-    try {
-      if (healthCheckId) {
-        await route53Client.send(new DeleteHealthCheckCommand({ HealthCheckId: healthCheckId }));
-        healthCheckId = undefined;
-      }
-    } catch (error) {
-      console.error(`Error deleting health check ${healthCheckId}:`, error);
-    }
-
-    try {
-      if (primaryEventBusArn) {
-        await primaryEbClient.send(new DeleteEventBusCommand({ Name: eventBusName }));
-        primaryEventBusArn = undefined;
-      }
-    } catch (error) {
-      console.error(`Error deleting event bus ${eventBusName} from ${primaryRegion}:`, error);
-    }
-
-    try {
-      if (secondaryEventBusArn) {
-        await secondaryEbClient.send(new DeleteEventBusCommand({ Name: eventBusName }));
-        secondaryEventBusArn = undefined;
-      }
-    } catch (error) {
-      console.error(`Error deleting event bus ${eventBusName} from ${secondaryRegion}:`, error);
-    }
-  };
-
   beforeAll(async () => {
     vi.setConfig({ hookTimeout: LONG_TIMEOUT });
 
     primaryRegion = "us-west-2";
     secondaryRegion = "us-east-1";
 
-    stsClient = new STSClient({ region: primaryRegion });
     primaryEbClient = new EventBridgeClient({ region: primaryRegion });
     secondaryEbClient = new EventBridgeClient({ region: secondaryRegion });
     route53Client = new Route53Client({ region: "us-west-2" });
@@ -127,82 +77,60 @@ describe("EventBridge Client with SignatureV4a", () => {
       signer,
     });
 
-    // Account ID & Timestamp for Unique Names
+    eventBusName = `${RESOURCE_PREFIX}-bus`;
+    endpointName = `${RESOURCE_PREFIX}-endpoint`;
+
+    const managementClient = new EventBridgeClient({ region: primaryRegion });
     try {
-      const identity = await stsClient.send(new GetCallerIdentityCommand({}));
-      accountId = identity.Account!;
-      timestamp = Date.now();
-
-      eventBusName = `test-global-bus-${accountId}-${timestamp}`;
-      endpointName = `test-global-endpoint-${accountId}-${timestamp}`;
-
-      const primaryBus = await primaryEbClient.send(new CreateEventBusCommand({ Name: eventBusName }));
-      primaryEventBusArn = primaryBus.EventBusArn;
-      expect(primaryEventBusArn).toBeDefined();
-
-      const secondaryBus = await secondaryEbClient.send(new CreateEventBusCommand({ Name: eventBusName }));
-      secondaryEventBusArn = secondaryBus.EventBusArn;
-      expect(secondaryEventBusArn).toBeDefined();
-
-      // Create Route 53 Health Check: a basic one against a dummy target.
-      const healthCheckCallerReference = `eb-putevents-test-${timestamp}`;
-      const healthCheck = await route53Client.send(
-        new CreateHealthCheckCommand({
-          CallerReference: healthCheckCallerReference,
-          HealthCheckConfig: {
-            Type: "HTTP",
-            FullyQualifiedDomainName: "example.com",
-            Port: 80,
-            ResourcePath: "/",
-            RequestInterval: 30,
-            FailureThreshold: 3,
-          },
-        })
-      );
-      healthCheckId = healthCheck.HealthCheck?.Id;
-      expect(healthCheckId).toBeDefined();
-      await wait(10000);
-
-      let managementClient: EventBridgeClient | undefined;
-      try {
-        managementClient = new EventBridgeClient({ region: primaryRegion });
-        const createInput = {
-          Name: endpointName,
-          RoutingConfig: {
-            FailoverConfig: {
-              Primary: { HealthCheck: `arn:aws:route53:::healthcheck/${healthCheckId}` },
-              Secondary: { Route: secondaryRegion },
+      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,
             },
-          },
-          ReplicationConfig: { State: ReplicationState.DISABLED },
-          EventBuses: [{ EventBusArn: primaryEventBusArn }, { EventBusArn: secondaryEventBusArn }],
-        };
-        const createResponse = await managementClient.send(new CreateEndpointCommand(createInput));
-
-        expect(createResponse.$metadata.httpStatusCode).toBe(200);
-        expect(createResponse.Name).toBe(endpointName);
-        expect(createResponse.Arn).toBeDefined();
-
-        endpointArn = createResponse.Arn!;
-      } catch (error) {
-        console.error("Error during prerequisite resource creation:", error);
-        await cleanupResources();
+          })
+        );
+        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 }],
+          })
+        );
+        endpointArn = createEndpointResponse.Arn;
+      } else {
         throw error;
-      } finally {
-        managementClient?.destroy();
       }
-    } catch (error) {
-      console.error("Error during prerequisite resource creation:", error);
-      await cleanupResources();
-      throw error;
+    } finally {
+      managementClient.destroy();
     }
   }, LONG_TIMEOUT);
 
   afterAll(async () => {
-    vi.setConfig({ hookTimeout: LONG_TIMEOUT });
-    await cleanupResources();
-    // Clean up SDK clients
-    stsClient?.destroy();
     primaryEbClient?.destroy();
     secondaryEbClient?.destroy();
     route53Client?.destroy();
@@ -251,42 +179,15 @@ describe("EventBridge Client with SignatureV4a", () => {
   it(
     "should send an event to an EventBridge Global Endpoint using SignatureV4a",
     async () => {
-      expect(endpointArn).toBeDefined();
-
-      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);
-          // Continue polling unless it's a definitive failure state
-        }
-        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: [
@@ -306,7 +207,6 @@ 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.
