wrangler 0.0.0-e2b7352 → 0.0.0-e305903a

package/src/__tests__/helpers/mock-cfetch.ts

@@ -1,24 +1,42 @@
+import { Readable } from "node:stream";
 import { URL, URLSearchParams } from "node:url";
 import { pathToRegexp } from "path-to-regexp";
+import { Response } from "undici";
 import { getCloudflareApiBaseUrl } from "../../cfetch";
 import type { FetchResult, FetchError } from "../../cfetch";
-import type { RequestInit } from "undici";
+import type { fetchInternal, fetchR2Objects } from "../../cfetch/internal";
+import type { RequestInit, BodyInit, HeadersInit } from "undici";
+
+/**
+ * When the custom mocks fallthrough in tests because they aren't set, instead of throwing an error,
+ * we use real fetch to make the request which will use Mock Service Workers.
+ */
+const {
+	fetchInternal: realFetchInternal,
+}: { fetchInternal: typeof fetchInternal } = jest.requireActual(
+	"../../cfetch/internal"
+);
+const {
+	fetchR2Objects: realFetchR2Objects,
+}: { fetchR2Objects: typeof fetchR2Objects } = jest.requireActual(
+	"../../cfetch/internal"
+);
 
 /**
  * The signature of the function that will handle a mock request.
  */
 export type MockHandler<ResponseType> = (
-  uri: RegExpExecArray,
-  init: RequestInit,
-  queryParams: URLSearchParams
+	uri: RegExpExecArray,
+	init: RequestInit,
+	queryParams: URLSearchParams
 ) => ResponseType | Promise<ResponseType>;
 
 type RemoveMockFn = () => void;
 
 interface MockFetch<ResponseType> {
-  regexp: RegExp;
-  method: string | undefined;
-  handler: MockHandler<ResponseType>;
+	regexp: RegExp;
+	method: string | undefined;
+	handler: MockHandler<ResponseType>;
 }
 const mocks: MockFetch<unknown>[] = [];
 
@@ -30,23 +48,24 @@ const mocks: MockFetch<unknown>[] = [];
  * Once found the handler will be used to generate a mock response.
  */
 export async function mockFetchInternal(
-  resource: string,
-  init: RequestInit = {},
-  queryParams: URLSearchParams = new URLSearchParams()
+	resource: string,
+	init: RequestInit = {},
+	queryParams: URLSearchParams | undefined
 ) {
-  for (const { regexp, method, handler } of mocks) {
-    const resourcePath = new URL(resource, getCloudflareApiBaseUrl()).pathname;
-    const uri = regexp.exec(resourcePath);
-    // Do the resource path and (if specified) the HTTP method match?
-    if (uri !== null && (!method || method === (init.method ?? "GET"))) {
-      // The `resource` regular expression will extract the labelled groups from the URL.
-      // These are passed through to the `handler` call, to allow it to do additional checks or behaviour.
-      return await handler(uri, init, queryParams); // TODO: should we have some kind of fallthrough system? we'll see.
-    }
-  }
-  throw new Error(
-    `no mocks found for ${init.method ?? "any HTTP"} request to ${resource}`
-  );
+	for (const { regexp, method, handler } of mocks) {
+		const resourcePath = new URL(resource, getCloudflareApiBaseUrl()).pathname;
+		const uri = regexp.exec(resourcePath);
+		// Do the resource path and (if specified) the HTTP method match?
+		if (uri !== null && (!method || method === (init.method ?? "GET"))) {
+			// The `resource` regular expression will extract the labelled groups from the URL.
+			// These are passed through to the `handler` call, to allow it to do additional checks or behaviour.
+			return await handler(uri, init, queryParams ?? new URLSearchParams()); // TODO: should we have some kind of fallthrough system? we'll see.
+		}
+	}
+
+	// let it fall through to mock-service-worker
+	// (do a real, unmocked fetch)
+	return await realFetchInternal(resource, init, queryParams);
 }
 
 /**
@@ -57,8 +76,8 @@ export async function mockFetchInternal(
  * @param handler The function that will generate the mock response for this request.
  */
 export function setMockRawResponse<ResponseType>(
-  resource: string,
-  handler: MockHandler<ResponseType>
+	resource: string,
+	handler: MockHandler<ResponseType>
 ): RemoveMockFn;
 /**
  * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
@@ -69,32 +88,32 @@ export function setMockRawResponse<ResponseType>(
  * @param handler The function that will generate the mock response for this request.
  */
 export function setMockRawResponse<ResponseType>(
-  resource: string,
-  method: string,
-  handler: MockHandler<ResponseType>
+	resource: string,
+	method: string,
+	handler: MockHandler<ResponseType>
 ): RemoveMockFn;
 /**
  * Specify an expected resource path that is to be handled, resulting in a raw JSON response.
  */
 export function setMockRawResponse<ResponseType>(
-  resource: string,
-  ...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
+	resource: string,
+	...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
 ): RemoveMockFn {
-  const handler = args.pop() as MockHandler<ResponseType>;
-  const method = args.pop() as string;
-  const mock = {
-    resource,
-    method,
-    handler,
-    regexp: pathToRegexp(resource),
-  };
-  mocks.push(mock);
-  return () => {
-    const mockIndex = mocks.indexOf(mock);
-    if (mockIndex !== -1) {
-      mocks.splice(mockIndex, 1);
-    }
-  };
+	const handler = args.pop() as MockHandler<ResponseType>;
+	const method = args.pop() as string;
+	const mock = {
+		resource,
+		method,
+		handler,
+		regexp: pathToRegexp(resource),
+	};
+	mocks.push(mock);
+	return () => {
+		const mockIndex = mocks.indexOf(mock);
+		if (mockIndex !== -1) {
+			mocks.splice(mockIndex, 1);
+		}
+	};
 }
 
 /**
@@ -107,8 +126,8 @@ export function setMockRawResponse<ResponseType>(
  * @param handler The function that will generate the mock response for this request.
  */
 export function setMockResponse<ResponseType>(
-  resource: string,
-  handler: MockHandler<ResponseType>
+	resource: string,
+	handler: MockHandler<ResponseType>
 ): RemoveMockFn;
 /**
  * Specify an expected resource path that is to be handled, resulting in a FetchRequest..
@@ -119,48 +138,48 @@ export function setMockResponse<ResponseType>(
  * @param handler The function that will generate the mock response for this request.
  */
 export function setMockResponse<ResponseType>(
-  resource: string,
-  method: string,
-  handler: MockHandler<ResponseType>
+	resource: string,
+	method: string,
+	handler: MockHandler<ResponseType>
 ): RemoveMockFn;
 /**
  * Specify an expected resource path that is to be handled, resulting in a FetchRequest.
  */
 export function setMockResponse<ResponseType>(
-  resource: string,
-  ...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
+	resource: string,
+	...args: [string, MockHandler<ResponseType>] | [MockHandler<ResponseType>]
 ): RemoveMockFn {
-  const handler = args.pop() as MockHandler<ResponseType>;
-  const method = args.pop() as string;
-  return setMockRawResponse(resource, method, (...handlerArgs) =>
-    createFetchResult(handler(...handlerArgs))
-  );
+	const handler = args.pop() as MockHandler<ResponseType>;
+	const method = args.pop() as string;
+	return setMockRawResponse(resource, method, (...handlerArgs) =>
+		createFetchResult(handler(...handlerArgs))
+	);
 }
 
 /**
  * A helper to make it easier to create `FetchResult` objects in tests.
  */
 export async function createFetchResult<ResponseType>(
-  result: ResponseType | Promise<ResponseType>,
-  success = true,
-  errors: FetchError[] = [],
-  messages: string[] = [],
-  result_info?: unknown
+	result: ResponseType | Promise<ResponseType>,
+	success = true,
+	errors: FetchError[] = [],
+	messages: string[] = [],
+	result_info?: unknown
 ): Promise<FetchResult<ResponseType>> {
-  return result_info
-    ? {
-        result: await result,
-        success,
-        errors,
-        messages,
-        result_info,
-      }
-    : {
-        result: await result,
-        success,
-        errors,
-        messages,
-      };
+	return result_info
+		? {
+				result: await result,
+				success,
+				errors,
+				messages,
+				result_info,
+		  }
+		: {
+				result: await result,
+				success,
+				errors,
+				messages,
+		  };
 }
 
 /**
@@ -169,7 +188,7 @@ export async function createFetchResult<ResponseType>(
  * This should be called in an `afterEach()` block to ensure that mock handlers do not leak between tests.
  */
 export function unsetAllMocks() {
-  mocks.length = 0;
+	mocks.length = 0;
 }
 
 /**
@@ -179,29 +198,119 @@ export function unsetAllMocks() {
  * special-case mocking it here.
  */
 
-const kvGetMocks = new Map<string, string>();
+const kvGetMocks = new Map<string, string | Buffer>();
+const r2GetMocks = new Map<string, string | undefined>();
+const dashScriptMocks = new Map<string, string | undefined>();
 
+/**
+ * @mocked typeof fetchKVGetValue
+ */
 export function mockFetchKVGetValue(
-  accountId: string,
-  namespaceId: string,
-  key: string
+	accountId: string,
+	namespaceId: string,
+	key: string
 ) {
-  const mapKey = `${accountId}/${namespaceId}/${key}`;
-  if (kvGetMocks.has(mapKey)) {
-    return kvGetMocks.get(mapKey);
-  }
-  throw new Error(`no mock value found for \`kv:key get\` - ${mapKey}`);
+	const mapKey = `${accountId}/${namespaceId}/${key}`;
+	if (kvGetMocks.has(mapKey)) {
+		const value = kvGetMocks.get(mapKey);
+		if (value !== undefined) return Promise.resolve(value);
+	}
+	throw new Error(`no mock value found for \`kv:key get\` - ${mapKey}`);
 }
 
 export function setMockFetchKVGetValue(
-  accountId: string,
-  namespaceId: string,
-  key: string,
-  value: string
+	accountId: string,
+	namespaceId: string,
+	key: string,
+	value: string | Buffer
 ) {
-  kvGetMocks.set(`${accountId}/${namespaceId}/${key}`, value);
+	kvGetMocks.set(`${accountId}/${namespaceId}/${key}`, value);
+}
+
+/**
+ * @mocked typeof fetchR2Objects
+ */
+export async function mockFetchR2Objects(
+	resource: string,
+	bodyInit: {
+		body: BodyInit | Readable;
+		headers: HeadersInit | undefined;
+		method: "PUT" | "GET" | "DELETE";
+	}
+): Promise<Response> {
+	if (r2GetMocks.has(resource)) {
+		/**
+		 * Here we destroy & removeListeners to "drain" the stream, for testing purposes
+		 * mimicking the fetch request taking in the stream and draining it.
+		 */
+		if (bodyInit.body instanceof Readable) {
+			bodyInit.body.destroy();
+			bodyInit.body.removeAllListeners();
+		}
+
+		const value = r2GetMocks.get(resource);
+
+		return new Response(value);
+	}
+
+	// No mocks found for ${init.method ?? "any HTTP"} request to ${resource}
+	// let it fall through to Mock Service Worker with a real fetch.
+	return await realFetchR2Objects(resource, bodyInit);
 }
 
-export function unsetMockFetchKVGetValues() {
-  kvGetMocks.clear();
+/**
+ * Mock setter for usage within test blocks, companion helper to `mockFetchR2Objects`
+ */
+export function setMockFetchR2Objects({
+	accountId,
+	bucketName,
+	objectName,
+	mockResponse,
+}: {
+	accountId: string;
+	bucketName: string;
+	objectName: string;
+	mockResponse?: string;
+}) {
+	r2GetMocks.set(
+		`/accounts/${accountId}/r2/buckets/${bucketName}/objects/${objectName}`,
+		mockResponse
+	);
+}
+
+export function unsetSpecialMockFns() {
+	kvGetMocks.clear();
+	r2GetMocks.clear();
+	dashScriptMocks.clear();
+}
+
+/**
+ * @mocked typeof fetchDashScript
+ * multipart/form-data is the response for modules and raw text for the Script endpoint.
+ */
+export async function mockFetchDashScript(resource: string): Promise<string> {
+	if (dashScriptMocks.has(resource)) {
+		return dashScriptMocks.get(resource) ?? "";
+	}
+	throw new Error(`no mock found for \`init from-dash\` - ${resource}`);
+}
+
+/**
+ * Mock setter for usage within test blocks, companion helper to `mockFetchDashScript`
+ */
+export function setMockFetchDashScript({
+	accountId,
+	fromDashScriptName,
+	environment,
+	mockResponse,
+}: {
+	accountId: string;
+	fromDashScriptName: string;
+	environment: string;
+	mockResponse?: string;
+}) {
+	dashScriptMocks.set(
+		`/accounts/${accountId}/workers/services/${fromDashScriptName}/environments/${environment}/content`,
+		mockResponse
+	);
 }

package/src/__tests__/helpers/mock-console.ts

@@ -1,50 +1,71 @@
 import * as util from "node:util";
+import { logger } from "../../logger";
 
 /**
  * We use this module to mock console methods, and optionally
  * assert on the values they're called with in our tests.
  */
 
-let logSpy: jest.SpyInstance,
-  errorSpy: jest.SpyInstance,
-  warnSpy: jest.SpyInstance;
+let debugSpy: jest.SpyInstance,
+	logSpy: jest.SpyInstance,
+	errorSpy: jest.SpyInstance,
+	warnSpy: jest.SpyInstance;
 
 const std = {
-  get out() {
-    return normalizeOutput(logSpy);
-  },
-  get err() {
-    return normalizeOutput(errorSpy);
-  },
-  get warn() {
-    return normalizeOutput(warnSpy);
-  },
+	get debug() {
+		return normalizeOutput(debugSpy);
+	},
+	get out() {
+		return normalizeOutput(logSpy);
+	},
+	get err() {
+		return normalizeOutput(errorSpy);
+	},
+	get warn() {
+		return normalizeOutput(warnSpy);
+	},
 };
 
 function normalizeOutput(spy: jest.SpyInstance): string {
-  return stripTrailingWhitespace(
-    normalizeSlashes(stripTimings(captureCalls(spy)))
-  );
+	return normalizeErrorMarkers(
+		replaceByte(
+			stripTrailingWhitespace(
+				normalizeSlashes(normalizeTempDirs(stripTimings(captureCalls(spy))))
+			)
+		)
+	);
 }
 
 function captureCalls(spy: jest.SpyInstance): string {
-  return spy.mock.calls
-    .map((args: unknown[]) => util.format("%s", ...args))
-    .join("\n");
+	return spy.mock.calls
+		.map((args: unknown[]) => util.format("%s", ...args))
+		.join("\n");
 }
 
 export function mockConsoleMethods() {
-  beforeEach(() => {
-    logSpy = jest.spyOn(console, "log").mockImplementation();
-    errorSpy = jest.spyOn(console, "error").mockImplementation();
-    warnSpy = jest.spyOn(console, "warn").mockImplementation();
-  });
-  afterEach(() => {
-    logSpy.mockRestore();
-    errorSpy.mockRestore();
-    warnSpy.mockRestore();
-  });
-  return std;
+	beforeEach(() => {
+		logger.columns = 100;
+		debugSpy = jest.spyOn(console, "debug").mockImplementation();
+		logSpy = jest.spyOn(console, "log").mockImplementation();
+		errorSpy = jest.spyOn(console, "error").mockImplementation();
+		warnSpy = jest.spyOn(console, "warn").mockImplementation();
+	});
+	afterEach(() => {
+		debugSpy.mockRestore();
+		logSpy.mockRestore();
+		errorSpy.mockRestore();
+		warnSpy.mockRestore();
+	});
+	return std;
+}
+
+/**
+ * Normalize error `X` markers.
+ *
+ * Windows gets a different character.
+ */
+function normalizeErrorMarkers(str: string): string {
+	return str.replaceAll("✘", "X");
 }
 
 /**
@@ -53,7 +74,7 @@ export function mockConsoleMethods() {
  * Use this in snapshot tests to be resilient to file-system differences.
  */
 export function normalizeSlashes(str: string): string {
-  return str.replace(/\\/g, "/");
+	return str.replace(/\\/g, "/");
 }
 
 /**
@@ -62,9 +83,24 @@ export function normalizeSlashes(str: string): string {
  * Use this in snapshot tests to be resilient to slight changes in timing of processing.
  */
 export function stripTimings(stdout: string): string {
-  return stdout.replace(/\(\d+\.\d+ sec\)/g, "(TIMINGS)");
+	return stdout.replace(/\(\d+\.\d+ sec\)/g, "(TIMINGS)");
 }
 
 export function stripTrailingWhitespace(str: string): string {
-  return str.replace(/[^\S\n]+\n/g, "\n");
+	return str.replace(/[^\S\n]+\n/g, "\n");
+}
+
+/**
+ * Removing leading kilobit (tenth of a byte) from test output due to
+ * variation causing every few tests the value to change by ± .01
+ */
+function replaceByte(stdout: string): string {
+	return stdout.replaceAll(/\d+\.\d+ KiB/g, "xx KiB");
+}
+
+/**
+ * Temp directories are created with random names, so we replace all comments temp dirs in them
+ */
+export function normalizeTempDirs(stdout: string): string {
+	return stdout.replaceAll(/\/\/.+\/tmp.+/g, "//tmpdir");
 }