run formatter

Author: smilkuri

packages/credential-provider-imds/src/fromInstanceMetadata.e2e.spec.ts

@@ -1,15 +1,15 @@
 import { CredentialsProviderError } from "@smithy/property-provider";
-import { afterEach, beforeEach, describe, expect, test as it} from "vitest";
+import { afterEach, beforeEach, describe, expect, test as it } from "vitest";
 
-import { fromInstanceMetadata,getMetadataToken } from "./fromInstanceMetadata"; 
+import { fromInstanceMetadata, getMetadataToken } from "./fromInstanceMetadata";
 
 describe("fromInstanceMetadata (Live EC2 E2E Tests)", () => {
   const originalEnv = { ...process.env };
   let imdsAvailable = false;
 
   beforeEach(async () => {
     process.env = { ...originalEnv };
-    
+
     // Check IMDS availability
     try {
       const testProvider = fromInstanceMetadata({ timeout: 1000, maxRetries: 0 });
@@ -25,17 +25,16 @@ describe("fromInstanceMetadata (Live EC2 E2E Tests)", () => {
   });
 
   it("should fetch metadata token successfully", async () => {
-  
     if (!imdsAvailable) {
       return;
     }
     const options = {
-      path: "/latest/api/token",  
+      path: "/latest/api/token",
       method: "PUT",
-      timeout: 1000,   
+      timeout: 1000,
       headers: {
-      "x-aws-ec2-metadata-token-ttl-seconds": "21600",
-      },           
+        "x-aws-ec2-metadata-token-ttl-seconds": "21600",
+      },
     };
     const token = await getMetadataToken(options);
     expect(token).toBeDefined();
@@ -44,32 +43,30 @@ describe("fromInstanceMetadata (Live EC2 E2E Tests)", () => {
   });
 
   it("retrieves credentials with account ID on allowlisted instances only)", async () => {
+    if (!imdsAvailable) return;
 
-  if (!imdsAvailable)
-    return;
-    
     const provider = fromInstanceMetadata({ timeout: 1000, maxRetries: 2 });
     const credentials = await provider();
 
-  expect(credentials).toHaveProperty("accessKeyId");
-  expect(credentials).toHaveProperty("secretAccessKey");
-  expect(typeof credentials.accessKeyId).toBe("string");
-  expect(typeof credentials.secretAccessKey).toBe("string");
+    expect(credentials).toHaveProperty("accessKeyId");
+    expect(credentials).toHaveProperty("secretAccessKey");
+    expect(typeof credentials.accessKeyId).toBe("string");
+    expect(typeof credentials.secretAccessKey).toBe("string");
 
-  if (!credentials.accountId) {
-    console.log("Skipping account ID test not an allowlisted instance");
-    return;
-  }
+    if (!credentials.accountId) {
+      console.log("Skipping account ID test not an allowlisted instance");
+      return;
+    }
 
-  expect(credentials.accountId).toBeDefined();
-  expect(typeof credentials.accountId).toBe("string");
+    expect(credentials.accountId).toBeDefined();
+    expect(typeof credentials.accountId).toBe("string");
 
-  console.log("IMDSv2 Credentials with Account ID:", {
-    accessKeyId: credentials.accessKeyId,
-    sessionToken: credentials.sessionToken?.slice(0, 10) + "...",
-    accountId: credentials.accountId,
+    console.log("IMDSv2 Credentials with Account ID:", {
+      accessKeyId: credentials.accessKeyId,
+      sessionToken: credentials.sessionToken?.slice(0, 10) + "...",
+      accountId: credentials.accountId,
+    });
   });
-});
 
   it("IMDS access disabled via AWS_EC2_METADATA_DISABLED", async () => {
     process.env.AWS_EC2_METADATA_DISABLED = "true";
@@ -88,13 +85,11 @@ describe("fromInstanceMetadata (Live EC2 E2E Tests)", () => {
   });
 
   it("Uses configured profile name from env", async () => {
+    if (!imdsAvailable) return;
 
-    if (!imdsAvailable)
-      return;
-    
     process.env.AWS_EC2_INSTANCE_PROFILE_NAME = "foo-profile";
     const provider = fromInstanceMetadata({ timeout: 1000 });
-    
+
     try {
       const credentials = await provider();
       expect(credentials).toHaveProperty("accessKeyId");
@@ -106,9 +101,7 @@ describe("fromInstanceMetadata (Live EC2 E2E Tests)", () => {
   });
 
   it("Multiple calls return stable results", async () => {
-    
-    if (!imdsAvailable)
-      return;
+    if (!imdsAvailable) return;
 
     const provider = fromInstanceMetadata({ timeout: 1000 });
     const creds1 = await provider();
@@ -121,12 +114,10 @@ describe("fromInstanceMetadata (Live EC2 E2E Tests)", () => {
     console.log("Stable credentials returned across calls.");
   });
 
- it("should timeout as expected when a request exceeds the specified duration", async () => {
-    if (!imdsAvailable)
-      return;
+  it("should timeout as expected when a request exceeds the specified duration", async () => {
+    if (!imdsAvailable) return;
     const provider = fromInstanceMetadata({ timeout: 1 });
 
     await expect(provider()).rejects.toThrow(/timeout|timed out|TimeoutError/i);
   });
-
 });

packages/credential-provider-imds/src/fromInstanceMetadata.spec.ts

@@ -3,7 +3,12 @@ import { CredentialsProviderError } from "@smithy/property-provider";
 import { afterEach, beforeEach, describe, expect, test as it, vi } from "vitest";
 
 import { InstanceMetadataV1FallbackError } from "./error/InstanceMetadataV1FallbackError";
-import { fromInstanceMetadata,getConfiguredProfileName, getImdsProfile, throwIfImdsTurnedOff } from "./fromInstanceMetadata";
+import {
+  fromInstanceMetadata,
+  getConfiguredProfileName,
+  getImdsProfile,
+  throwIfImdsTurnedOff,
+} from "./fromInstanceMetadata";
 import { httpRequest } from "./remoteProvider/httpRequest";
 import { fromImdsCredentials, isImdsCredentials } from "./remoteProvider/ImdsCredentials";
 import { providerConfigFromInit } from "./remoteProvider/RemoteProviderInit";
@@ -66,7 +71,7 @@ describe("fromInstanceMetadata", () => {
     vi.mocked(staticStabilityProvider).mockImplementation((input) => input);
     vi.mocked(getInstanceMetadataEndpoint).mockResolvedValue({ hostname } as any);
     vi.mocked(loadConfig).mockReturnValue(() => Promise.resolve(false));
-    vi.spyOn({throwIfImdsTurnedOff}, "throwIfImdsTurnedOff").mockResolvedValue(undefined);
+    vi.spyOn({ throwIfImdsTurnedOff }, "throwIfImdsTurnedOff").mockResolvedValue(undefined);
     (isImdsCredentials as unknown as any).mockReturnValue(true);
     vi.mocked(providerConfigFromInit).mockReturnValue({
       timeout: mockTimeout,
@@ -79,16 +84,16 @@ describe("fromInstanceMetadata", () => {
   });
 
   it("returns no credentials when AWS_EC2_METADATA_DISABLED=true", async () => {
-  vi.mocked(loadConfig).mockImplementation(({ environmentVariableSelector, configFileSelector }) => {
-    if (environmentVariableSelector && environmentVariableSelector({ AWS_EC2_METADATA_DISABLED: "true" })) {
-      return () => Promise.resolve(true);
-    }
-    if (configFileSelector && configFileSelector({ imds_disabled: "true" })) {
-      return () => Promise.resolve(true);
-    }
-    return () => Promise.resolve(false);
-  });
-    vi.spyOn({throwIfImdsTurnedOff},"throwIfImdsTurnedOff").mockRejectedValueOnce(
+    vi.mocked(loadConfig).mockImplementation(({ environmentVariableSelector, configFileSelector }) => {
+      if (environmentVariableSelector && environmentVariableSelector({ AWS_EC2_METADATA_DISABLED: "true" })) {
+        return () => Promise.resolve(true);
+      }
+      if (configFileSelector && configFileSelector({ imds_disabled: "true" })) {
+        return () => Promise.resolve(true);
+      }
+      return () => Promise.resolve(false);
+    });
+    vi.spyOn({ throwIfImdsTurnedOff }, "throwIfImdsTurnedOff").mockRejectedValueOnce(
       new CredentialsProviderError("IMDS credential fetching is disabled")
     );
     const provider = fromInstanceMetadata({});
@@ -172,7 +177,7 @@ describe("fromInstanceMetadata", () => {
 
     vi.mocked(retry).mockImplementation((fn: any) => fn());
     vi.mocked(fromImdsCredentials).mockReturnValue(mockCreds);
-     vi.spyOn({throwIfImdsTurnedOff}, "throwIfImdsTurnedOff").mockResolvedValue();
+    vi.spyOn({ throwIfImdsTurnedOff }, "throwIfImdsTurnedOff").mockResolvedValue();
 
     await expect(fromInstanceMetadata()()).resolves.toEqual(mockCreds);
     expect(httpRequest).toHaveBeenNthCalledWith(3, {
@@ -298,9 +303,9 @@ describe("fromInstanceMetadata", () => {
 
     it("uses ec2InstanceProfileName from init if provided", async () => {
       const profileName = "profile-from-init";
-      const options = { hostname } ;
+      const options = { hostname };
 
-      vi.spyOn({getConfiguredProfileName}, "getConfiguredProfileName").mockResolvedValueOnce(profileName);
+      vi.spyOn({ getConfiguredProfileName }, "getConfiguredProfileName").mockResolvedValueOnce(profileName);
 
       const credentials = await getImdsProfile(options, mockMaxRetries, {
         ec2InstanceProfileName: profileName,

packages/credential-provider-imds/src/fromInstanceMetadata.ts

@@ -169,24 +169,24 @@ export const getImdsProfile = async (
     if (resolvedProfile) {
       return resolvedProfile;
     }
-      // Try extended API first
-      try {
-        const response = await httpRequest({ ...options, path: IMDS_EXTENDED_PATH });
+    // Try extended API first
+    try {
+      const response = await httpRequest({ ...options, path: IMDS_EXTENDED_PATH });
+      resolvedProfile = response.toString().trim();
+      if (apiVersion === "unknown") {
+        apiVersion = "extended";
+      }
+      return resolvedProfile;
+    } catch (error) {
+      if (error?.statusCode === 404 && apiVersion === "unknown") {
+        apiVersion = "legacy";
+        const response = await httpRequest({ ...options, path: IMDS_LEGACY_PATH });
         resolvedProfile = response.toString().trim();
-        if (apiVersion === "unknown") {
-          apiVersion = "extended";
-        }
         return resolvedProfile;
-      } catch (error) {
-        if (error?.statusCode === 404 && apiVersion === "unknown") {
-          apiVersion = "legacy";
-          const response = await httpRequest({ ...options, path: IMDS_LEGACY_PATH });
-          resolvedProfile = response.toString().trim();
-          return resolvedProfile;
-        } else {
-          throw error;
-        }
+      } else {
+        throw error;
       }
+    }
   }, maxRetries);
 };