Return fixed time from new Date()/Date.now(), closes #225

...unless `--actual-time`/`actualTime: true` option set.

Author: mrbbot

packages/cache/src/cache.ts

@@ -165,7 +165,8 @@ export class Cache implements CacheInterface {
     res: BaseResponse | Response
   ): Promise<undefined> {
     if (this.#blockGlobalAsyncIO) assertInRequest();
-    getRequestContext()?.incrementExternalSubrequests();
+    const ctx = getRequestContext();
+    ctx?.incrementExternalSubrequests();
     req = normaliseRequest(req);
 
     if (res instanceof Response && res.webSocket) {
@@ -201,14 +202,16 @@ export class Cache implements CacheInterface {
       metadata,
     });
     await waitForOpenInputGate();
+    ctx?.advanceCurrentTime();
   }
 
   async match(
     req: RequestInfo,
     options?: CacheMatchOptions
   ): Promise<Response | undefined> {
     if (this.#blockGlobalAsyncIO) assertInRequest();
-    getRequestContext()?.incrementExternalSubrequests();
+    const ctx = getRequestContext();
+    ctx?.incrementExternalSubrequests();
     req = normaliseRequest(req);
     // Cloudflare only caches GET requests
     if (req.method !== "GET" && !options?.ignoreMethod) return;
@@ -218,6 +221,7 @@ export class Cache implements CacheInterface {
     const storage = await this.#storage;
     const cached = await storage.get<CachedMeta>(key);
     await waitForOpenInputGate();
+    ctx?.advanceCurrentTime();
     if (!cached) return;
 
     // Check we're not trying to load cached data created in Miniflare 1.
@@ -250,7 +254,8 @@ export class Cache implements CacheInterface {
     options?: CacheMatchOptions
   ): Promise<boolean> {
     if (this.#blockGlobalAsyncIO) assertInRequest();
-    getRequestContext()?.incrementExternalSubrequests();
+    const ctx = getRequestContext();
+    ctx?.incrementExternalSubrequests();
     req = normaliseRequest(req);
     // Cloudflare only caches GET requests
     if (req.method !== "GET" && !options?.ignoreMethod) return false;
@@ -261,6 +266,7 @@ export class Cache implements CacheInterface {
     await waitForOpenOutputGate();
     const result = storage.delete(key);
     await waitForOpenInputGate();
+    ctx?.advanceCurrentTime();
     return result;
   }
 }

packages/cache/test/cache.spec.ts

@@ -9,6 +9,7 @@ import {
   Storage,
 } from "@miniflare/shared";
 import {
+  advancesTime,
   getObjectProperties,
   utf8Decode,
   utf8Encode,
@@ -439,3 +440,11 @@ test("Cache: operations throw outside request handler", async (t) => {
   await ctx.runWith(() => cache.match("http://localhost:8787/"));
   await ctx.runWith(() => cache.delete("http://localhost:8787/"));
 });
+test("Cache: operations advance current time", async (t) => {
+  const { cache } = t.context;
+  await advancesTime(t, () =>
+    cache.put("http://localhost:8787/", testResponse())
+  );
+  await advancesTime(t, () => cache.match("http://localhost:8787/"));
+  await advancesTime(t, () => cache.delete("http://localhost:8787/"));
+});

packages/cli-parser/test/help.spec.ts

@@ -57,6 +57,8 @@ Core Options:
      --global-timers         Allow setting timers outside handlers     [boolean]
      --global-random         Allow secure random generation outside    [boolean]
                              handlers
+     --actual-time           Always return correct time from Date      [boolean]
+                             methods
 
 Test Options:
  -b, --boolean-option        Boolean option                            [boolean]

packages/core/src/plugins/core.ts

@@ -52,6 +52,7 @@ import {
   btoa,
   createCompatFetch,
   createCrypto,
+  createDate,
   createTimer,
   withStringFormDataFiles,
 } from "../standards";
@@ -105,6 +106,7 @@ export interface CoreOptions {
   globalAsyncIO?: boolean;
   globalTimers?: boolean;
   globalRandom?: boolean;
+  actualTime?: boolean;
 }
 
 function mapMountEntries(
@@ -350,6 +352,13 @@ export class CorePlugin extends Plugin<CoreOptions> implements CoreOptions {
   })
   globalRandom?: boolean;
 
+  @Option({
+    type: OptionType.BOOLEAN,
+    description: "Always return correct time from Date methods",
+    fromWrangler: ({ miniflare }) => miniflare?.actual_time,
+  })
+  actualTime?: boolean;
+
   readonly processedModuleRules: ProcessedModuleRule[] = [];
 
   readonly upstreamURL?: URL;
@@ -465,6 +474,8 @@ export class CorePlugin extends Plugin<CoreOptions> implements CoreOptions {
       // Approximate with serialize/deserialize if not there.
       structuredClone: globalThis.structuredClone ?? structuredCloneBuffer,
 
+      Date: createDate(this.actualTime),
+
       ...compatGlobals,
 
       // The types below would be included automatically, but it's not possible
@@ -477,7 +488,6 @@ export class CorePlugin extends Plugin<CoreOptions> implements CoreOptions {
       BigInt64Array,
       BigUint64Array,
       DataView,
-      Date,
       Float32Array,
       Float64Array,
       Int8Array,

packages/core/src/standards/date.ts

@@ -0,0 +1,26 @@
+import { getRequestContext } from "@miniflare/shared";
+
+function requestContextNow() {
+  // If there's no request context, just fallback to actual time
+  return getRequestContext()?.currentTime ?? Date.now();
+}
+
+export function createDate(actualTime = false): typeof Date {
+  // If we always want the actual time, return Date as-is
+  if (actualTime) return Date;
+  // Otherwise, proxy it to use the request context's time
+  return new Proxy(Date, {
+    construct(target, args, newTarget) {
+      return Reflect.construct(
+        target,
+        // If `args` is empty, this is `new Date()`
+        args.length === 0 ? [requestContextNow()] : args,
+        newTarget
+      );
+    },
+    get(target, propertyKey, receiver) {
+      if (propertyKey === "now") return requestContextNow;
+      return Reflect.get(target, propertyKey, receiver);
+    },
+  });
+}

packages/core/src/standards/http.ts

@@ -832,6 +832,7 @@ export async function fetch(
   res.headers[fetchSymbols.kGuard] = "immutable";
 
   await waitForOpenInputGate();
+  ctx?.advanceCurrentTime();
   return withInputGating(res);
 }
 

packages/core/src/standards/index.ts

@@ -1,5 +1,6 @@
 export * from "./cf";
 export * from "./crypto";
+export * from "./date";
 export * from "./domexception";
 export * from "./encoding";
 export * from "./event";

packages/core/test/plugins/core.spec.ts

@@ -1,11 +1,13 @@
 import assert from "assert";
 import fs from "fs/promises";
+
 import path from "path";
 import { CorePlugin, Request, Response, Scheduler } from "@miniflare/core";
 import {
   Compatibility,
   NoOpLog,
   PluginContext,
+  RequestContext,
   STRING_SCRIPT_PATH,
 } from "@miniflare/shared";
 import {
@@ -43,6 +45,8 @@ test("CorePlugin: parses options from argv", (t) => {
     "fetch_refuses_unknown_protocols",
     "--compat-flag",
     "durable_object_fetch_allows_relative_url",
+    "--usage-model",
+    "unbound",
     "--upstream",
     "https://github.com/mrbbot",
     "--watch",
@@ -63,6 +67,7 @@ test("CorePlugin: parses options from argv", (t) => {
     "--global-async-io",
     "--global-timers",
     "--global-random",
+    "--actual-time",
   ]);
   t.deepEqual(options, {
     scriptPath: "script.js",
@@ -79,6 +84,7 @@ test("CorePlugin: parses options from argv", (t) => {
       "fetch_refuses_unknown_protocols",
       "durable_object_fetch_allows_relative_url",
     ],
+    usageModel: "unbound",
     upstream: "https://github.com/mrbbot",
     watch: true,
     debug: true,
@@ -105,6 +111,7 @@ test("CorePlugin: parses options from argv", (t) => {
     globalAsyncIO: true,
     globalTimers: true,
     globalRandom: true,
+    actualTime: true,
   });
   options = parsePluginArgv(CorePlugin, [
     "-c",
@@ -158,6 +165,7 @@ test("CorePlugin: parses options from wrangler config", async (t) => {
         global_async_io: true,
         global_timers: true,
         global_random: true,
+        actual_time: true,
       },
     },
     configDir
@@ -212,6 +220,7 @@ test("CorePlugin: parses options from wrangler config", async (t) => {
     globalAsyncIO: true,
     globalTimers: true,
     globalRandom: true,
+    actualTime: true,
   });
   // Check build upload dir defaults to dist
   options = parsePluginWranglerConfig(
@@ -246,6 +255,7 @@ test("CorePlugin: logs options", (t) => {
     globalAsyncIO: true,
     globalTimers: true,
     globalRandom: true,
+    actualTime: true,
   });
   t.deepEqual(logs, [
     // script is OptionType.NONE so omitted
@@ -267,6 +277,7 @@ test("CorePlugin: logs options", (t) => {
     "Allow Global Async I/O: true",
     "Allow Global Timers: true",
     "Allow Global Secure Random: true",
+    "Actual Time: true",
   ]);
   // Check logs default wrangler config/package paths
   logs = logPluginOptions(CorePlugin, {
@@ -511,6 +522,23 @@ test("CorePlugin: setup: includes navigator only if compatibility flag enabled",
   globals = (await plugin.setup()).globals;
   t.is(globals?.navigator.userAgent, "Cloudflare-Workers");
 });
+test("CorePlugin: setup: uses actual time if option enabled", async (t) => {
+  let plugin = new CorePlugin(ctx);
+  let DateImpl: typeof Date = (await plugin.setup()).globals?.Date;
+  await new RequestContext().runWith(async () => {
+    const previous = DateImpl.now();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    t.is(DateImpl.now(), previous);
+  });
+
+  plugin = new CorePlugin(ctx, { actualTime: true });
+  DateImpl = (await plugin.setup()).globals?.Date;
+  await new RequestContext().runWith(async () => {
+    const previous = DateImpl.now();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    t.not(DateImpl.now(), previous);
+  });
+});
 
 test("CorePlugin: setup: structuredClone: creates deep-copy of value", async (t) => {
   const plugin = new CorePlugin(ctx);

packages/core/test/standards/date.spec.ts

@@ -0,0 +1,56 @@
+import { setTimeout } from "timers/promises";
+import { createDate } from "@miniflare/core";
+import { RequestContext } from "@miniflare/shared";
+import test from "ava";
+
+test("Date: uses regular Date if actual time requested", (t) => {
+  const DateImpl = createDate(true);
+  t.is(DateImpl, Date);
+});
+
+test("Date: new Date() returns fixed time if no parameters provided", async (t) => {
+  // Check inside request context
+  const DateImpl = createDate();
+  const ctx = new RequestContext();
+  await ctx.runWith(async () => {
+    const previous = new DateImpl().getTime();
+    await setTimeout(100);
+    t.is(new DateImpl().getTime(), previous);
+    ctx.advanceCurrentTime();
+    t.not(new DateImpl().getTime(), previous);
+  });
+
+  // Check outside request context (should return actual time here)
+  const previous = new DateImpl().getTime();
+  await setTimeout(100);
+  t.not(new DateImpl().getTime(), previous);
+});
+test("Date: new Date() accepts regular constructor parameters", (t) => {
+  const DateImpl = createDate();
+  const date = new DateImpl(1000);
+  t.is(date.getTime(), 1000);
+});
+test("Date: new Date() passes instanceof checks", (t) => {
+  const DateImpl = createDate();
+  t.not(DateImpl, Date);
+  t.true(new DateImpl() instanceof Date);
+  t.true(new Date() instanceof DateImpl);
+});
+
+test("Date: Date.now() returns fixed time", async (t) => {
+  // Check inside request context
+  const DateImpl = createDate();
+  const ctx = new RequestContext();
+  await ctx.runWith(async () => {
+    const previous = DateImpl.now();
+    await setTimeout(100);
+    t.is(DateImpl.now(), previous);
+    ctx.advanceCurrentTime();
+    t.not(DateImpl.now(), previous);
+  });
+
+  // Check outside request context (should return actual time here)
+  const previous = DateImpl.now();
+  await setTimeout(100);
+  t.not(DateImpl.now(), previous);
+});

packages/core/test/standards/http.spec.ts

@@ -29,6 +29,7 @@ import {
 } from "@miniflare/shared";
 import {
   TestLog,
+  advancesTime,
   triggerPromise,
   useServer,
   utf8Decode,
@@ -937,6 +938,10 @@ test("fetch: increments subrequest count for each redirect", async (t) => {
   await ctx.runWith(() => fetch(url));
   t.is(ctx.externalSubrequests, 4);
 });
+test("fetch: advances current time", async (t) => {
+  const upstream = (await useServer(t, (req, res) => res.end("upstream"))).http;
+  await advancesTime(t, () => fetch(upstream));
+});
 test("fetch: waits for output gate to open before fetching", async (t) => {
   let fetched = false;
   const upstream = (