Fix unit test issues in streaming cache tests

- Fix credential fallback test: mock CredentialCache so cached credentials
  are available, making the test actually validate the stream-body guard
  (previously, the test passed trivially because _tryGetCredentialsAsync
  would throw before making a second request)
- Fix 504 statusText from 'BadGateway' to 'Gateway Timeout'
- Replace fragile S3 upload snapshot that captured Readable internals
  (breaks on Node.js upgrades) with targeted assertions on URL, verb,
  headers, and body identity
- Replace fail() + try/catch with expect().rejects.toThrow()
- Move Readable import to top of S3 test file instead of per-test
  dynamic import

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: iclanton

rush-plugins/rush-amazon-s3-build-cache-plugin/src/test/AmazonS3Client.test.ts

@@ -5,6 +5,8 @@ jest.mock('@rushstack/rush-sdk/lib/utilities/WebClient', () => {
   return jest.requireActual('@microsoft/rush-lib/lib/utilities/WebClient');
 });
 
+import { Readable } from 'node:stream';
+
 import { ConsoleTerminalProvider, Terminal } from '@rushstack/terminal';
 import { WebClient } from '@rushstack/rush-sdk/lib/utilities/WebClient';
 
@@ -664,21 +666,18 @@ describe(AmazonS3Client.name, () => {
         status: number,
         statusText?: string
       ): Promise<{ result: NodeJS.ReadableStream | undefined; spy: jest.SpyInstance }> {
-        const { Readable } = await import('node:stream');
         const mockStream = new Readable({ read() {} });
 
-        const spy: jest.SpyInstance = jest
-          .spyOn(WebClient.prototype, 'fetchStreamAsync')
-          .mockReturnValue(
-            Promise.resolve({
-              stream: mockStream,
-              headers: {},
-              status,
-              statusText,
-              ok: status >= 200 && status < 300,
-              redirected: false
-            })
-          );
+        const spy: jest.SpyInstance = jest.spyOn(WebClient.prototype, 'fetchStreamAsync').mockReturnValue(
+          Promise.resolve({
+            stream: mockStream,
+            headers: {},
+            status,
+            statusText,
+            ok: status >= 200 && status < 300,
+            redirected: false
+          })
+        );
 
         const s3Client: AmazonS3Client = new AmazonS3Client(credentials, options, webClient, terminal);
         const result = await s3Client.getObjectStreamAsync(objectName);
@@ -722,7 +721,6 @@ describe(AmazonS3Client.name, () => {
 
     describe('Uploading an object stream', () => {
       it('Throws an error if credentials are not provided', async () => {
-        const { Readable } = await import('node:stream');
         const s3Client: AmazonS3Client = new AmazonS3Client(
           undefined,
           { s3Endpoint: 'http://foo.bar.baz', ...DUMMY_OPTIONS_WITHOUT_ENDPOINT },
@@ -731,31 +729,25 @@ describe(AmazonS3Client.name, () => {
         );
 
         const mockStream = new Readable({ read() {} });
-        try {
-          await s3Client.uploadObjectStreamAsync('temp', mockStream);
-          fail('Expected an exception to be thrown');
-        } catch (e) {
-          expect(e).toMatchSnapshot();
-        }
+        await expect(s3Client.uploadObjectStreamAsync('temp', mockStream)).rejects.toThrow(
+          'Credentials are required to upload objects to S3.'
+        );
       });
 
       it('Uploads a stream successfully', async () => {
-        const { Readable } = await import('node:stream');
         const mockStream = new Readable({ read() {} });
         const responseStream = new Readable({ read() {} });
 
-        const spy: jest.SpyInstance = jest
-          .spyOn(WebClient.prototype, 'fetchStreamAsync')
-          .mockReturnValue(
-            Promise.resolve({
-              stream: responseStream,
-              headers: {},
-              status: 200,
-              statusText: 'OK',
-              ok: true,
-              redirected: false
-            })
-          );
+        const spy: jest.SpyInstance = jest.spyOn(WebClient.prototype, 'fetchStreamAsync').mockReturnValue(
+          Promise.resolve({
+            stream: responseStream,
+            headers: {},
+            status: 200,
+            statusText: 'OK',
+            ok: true,
+            redirected: false
+          })
+        );
 
         const s3Client: AmazonS3Client = new AmazonS3Client(
           {
@@ -771,27 +763,33 @@ describe(AmazonS3Client.name, () => {
         await s3Client.uploadObjectStreamAsync('abc123', mockStream);
 
         expect(spy).toHaveBeenCalledTimes(1);
-        expect(spy.mock.calls[0]).toMatchSnapshot();
+        // Assert on URL and request options without snapshotting Readable internals,
+        // which are fragile across Node.js versions
+        const [url, options] = spy.mock.calls[0];
+        expect(url).toBe('http://localhost:9000/abc123');
+        expect(options.verb).toBe('PUT');
+        expect(options.body).toBe(mockStream);
+        expect(options.headers['x-amz-content-sha256']).toBe('UNSIGNED-PAYLOAD');
+        expect(options.headers['x-amz-date']).toBe('20200418T123242Z');
+        // eslint-disable-next-line dot-notation
+        expect(options.headers['Authorization']).toContain('AWS4-HMAC-SHA256');
         spy.mockRestore();
       });
 
       it('Does not retry on failure (stream consumed)', async () => {
-        const { Readable } = await import('node:stream');
         const mockStream = new Readable({ read() {} });
         const responseStream = new Readable({ read() {} });
 
-        const spy: jest.SpyInstance = jest
-          .spyOn(WebClient.prototype, 'fetchStreamAsync')
-          .mockReturnValue(
-            Promise.resolve({
-              stream: responseStream,
-              headers: {},
-              status: 500,
-              statusText: 'InternalServerError',
-              ok: false,
-              redirected: false
-            })
-          );
+        const spy: jest.SpyInstance = jest.spyOn(WebClient.prototype, 'fetchStreamAsync').mockReturnValue(
+          Promise.resolve({
+            stream: responseStream,
+            headers: {},
+            status: 500,
+            statusText: 'InternalServerError',
+            ok: false,
+            redirected: false
+          })
+        );
 
         const s3Client: AmazonS3Client = new AmazonS3Client(
           {
@@ -804,12 +802,7 @@ describe(AmazonS3Client.name, () => {
           terminal
         );
 
-        try {
-          await s3Client.uploadObjectStreamAsync('abc123', mockStream);
-          fail('Expected an exception to be thrown');
-        } catch (e) {
-          expect((e as Error).message).toContain('500');
-        }
+        await expect(s3Client.uploadObjectStreamAsync('abc123', mockStream)).rejects.toThrow('500');
 
         // Only 1 call - no retry for streams
         expect(spy).toHaveBeenCalledTimes(1);

rush-plugins/rush-amazon-s3-build-cache-plugin/src/test/__snapshots__/AmazonS3Client.test.ts.snap

@@ -563,40 +563,3 @@ Array [
 ]
 `;
 
-exports[`AmazonS3Client Streaming requests Uploading an object stream Throws an error if credentials are not provided 1`] = `[Error: Credentials are required to upload objects to S3.]`;
-
-exports[`AmazonS3Client Streaming requests Uploading an object stream Uploads a stream successfully 1`] = `
-Array [
-  "http://localhost:9000/abc123",
-  Object {
-    "body": Readable {
-      "_events": Object {
-        "close": undefined,
-        "data": undefined,
-        "end": undefined,
-        "error": undefined,
-        "readable": undefined,
-      },
-      "_maxListeners": undefined,
-      "_read": [Function],
-      "_readableState": ReadableState {
-        "awaitDrainWriters": null,
-        "buffer": Array [],
-        "bufferIndex": 0,
-        "highWaterMark": 65536,
-        "length": 0,
-        "pipes": Array [],
-        Symbol(kState): 1052940,
-      },
-      Symbol(shapeMode): true,
-      Symbol(kCapture): false,
-    },
-    "headers": Object {
-      "Authorization": "AWS4-HMAC-SHA256 Credential=accessKeyId/20200418/us-east-1/s3/aws4_request,SignedHeaders=host;x-amz-content-sha256;x-amz-date,Signature=bfc5ee97ccfdb44b7f351c0b550a1ac9c2cdb661606dbba8a74c11be6b5b2b72",
-      "x-amz-content-sha256": "UNSIGNED-PAYLOAD",
-      "x-amz-date": "20200418T123242Z",
-    },
-    "verb": "PUT",
-  },
-]
-`;

rush-plugins/rush-http-build-cache-plugin/src/test/HttpBuildCacheProvider.test.ts

@@ -8,6 +8,7 @@ jest.mock('@rushstack/rush-sdk/lib/utilities/WebClient', () => {
 import { Readable } from 'node:stream';
 
 import { type RushSession, EnvironmentConfiguration } from '@rushstack/rush-sdk';
+import { type ICredentialCacheEntry, CredentialCache } from '@rushstack/credential-cache';
 import { StringBufferTerminalProvider, Terminal } from '@rushstack/terminal';
 import { WebClient } from '@rushstack/rush-sdk/lib/utilities/WebClient';
 
@@ -113,7 +114,7 @@ Array [
       });
       mocked(fetchFn).mockResolvedValueOnce({
         status: 504,
-        statusText: 'BadGateway',
+        statusText: 'Gateway Timeout',
         ok: false
       });
 
@@ -149,7 +150,7 @@ Array [
   "[  debug] [http-build-cache] request: GET https://buildcache.example.acme.com/some-key unknown bytes[n]",
   "[  debug] [http-build-cache] request: GET https://buildcache.example.acme.com/some-key unknown bytes[n]",
   "[  debug] [http-build-cache] request: GET https://buildcache.example.acme.com/some-key unknown bytes[n]",
-  "[warning] Could not get cache entry: HTTP 504: BadGateway[n]",
+  "[warning] Could not get cache entry: HTTP 504: Gateway Timeout[n]",
 ]
 `);
     });
@@ -183,11 +184,7 @@ Array [
       const session: RushSession = {} as RushSession;
       const provider = new HttpBuildCacheProvider(EXAMPLE_OPTIONS, session); // write not allowed
 
-      const result = await provider.trySetCacheEntryBufferAsync(
-        terminal,
-        'some-key',
-        Buffer.from('data')
-      );
+      const result = await provider.trySetCacheEntryBufferAsync(terminal, 'some-key', Buffer.from('data'));
 
       expect(result).toBe(false);
       expect(fetchFn).not.toHaveBeenCalled();
@@ -235,11 +232,7 @@ Array [
         ok: false
       });
 
-      const result = await provider.trySetCacheEntryBufferAsync(
-        terminal,
-        'some-key',
-        Buffer.from('data')
-      );
+      const result = await provider.trySetCacheEntryBufferAsync(terminal, 'some-key', Buffer.from('data'));
 
       expect(result).toBe(false);
       expect(fetchFn).toHaveBeenCalledTimes(3);
@@ -316,7 +309,7 @@ Array [
       });
       mocked(streamFetchFn).mockResolvedValueOnce({
         status: 504,
-        statusText: 'BadGateway',
+        statusText: 'Gateway Timeout',
         ok: false,
         stream: createMockStream()
       });
@@ -393,7 +386,19 @@ Array [
     });
 
     it('skips credential fallback for stream bodies on 4xx', async () => {
+      // No credential in env for the first attempt
       jest.spyOn(EnvironmentConfiguration, 'buildCacheCredential', 'get').mockReturnValue(undefined);
+      // But credentials ARE available in the credential cache — without the stream-body
+      // guard, the credential fallback would resolve these and make a second HTTP request
+      // with the already-consumed stream body.
+      jest
+        .spyOn(CredentialCache, 'usingAsync')
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        .mockImplementation(async (_options, fn) => {
+          await (fn as (cache: CredentialCache) => Promise<void>)({
+            tryGetCacheEntry: (): ICredentialCacheEntry => ({ credential: 'cached-token' })
+          } as unknown as CredentialCache);
+        });
 
       const session: RushSession = {} as RushSession;
       const provider = new HttpBuildCacheProvider(WRITE_ALLOWED_OPTIONS, session);
@@ -412,7 +417,7 @@ Array [
       const result = await provider.trySetCacheEntryStreamAsync(terminal, 'some-key', entryStream);
 
       expect(result).toBe(false);
-      // Should only be called once (no credential fallback retry)
+      // Should only be called once (no credential fallback retry with consumed stream)
       expect(streamFetchFn).toHaveBeenCalledTimes(1);
     });
   });