Support secondsGranularity in R2Conditional and add tests

Author: mrbbot

packages/tre/src/plugins/r2/index.ts

@@ -46,3 +46,4 @@ export const R2_PLUGIN: Plugin<
 export * from "./r2Object";
 export * from "./gateway";
 export * from "./schemas";
+export { _testR2Conditional } from "./validator";

packages/tre/src/plugins/r2/validator.ts

@@ -17,51 +17,45 @@ const UNPAIRED_SURROGATE_PAIR_REGEX =
   /^(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])$/;
 const MAX_VALUE_SIZE = 5 * 1_000 * 1_000 * 1_000 - 5 * 1_000 * 1_000;
 
-// false -> the condition testing "failed"
-function testR2Conditional(
-  conditional?: R2Conditional,
-  metadata?: R2ObjectMetadata
+function identity(ms: number) {
+  return ms;
+}
+function truncateToSeconds(ms: number) {
+  return Math.floor(ms / 1000) * 1000;
+}
+
+// Returns `true` iff the condition passed
+/** @internal */
+export function _testR2Conditional(
+  cond: R2Conditional,
+  metadata?: Pick<R2ObjectMetadata, "etag" | "uploaded">
 ): boolean {
-  const { etagMatches, etagDoesNotMatch, uploadedBefore, uploadedAfter } =
-    conditional ?? {};
+  // Adapted from internal R2 gateway implementation.
+  // See also https://datatracker.ietf.org/doc/html/rfc7232#section-6.
 
-  // If the object doesn't exist
   if (metadata === undefined) {
-    // the etagDoesNotMatch and uploadedBefore automatically pass
-    // etagMatches and uploadedAfter automatically fail if they exist
-    return etagMatches === undefined && uploadedAfter === undefined;
-  }
-
-  const { etag, uploaded } = metadata;
-
-  // ifMatch check
-  const ifMatch = etagMatches ? etagMatches === etag : null;
-  if (ifMatch === false) return false;
-
-  // ifNoMatch check
-  const ifNoneMatch = etagDoesNotMatch ? etagDoesNotMatch !== etag : null;
-
-  if (ifNoneMatch === false) return false;
-
-  // ifUnmodifiedSince check
-  if (
-    ifMatch !== true && // if "ifMatch" is true, we ignore date checking
-    uploadedBefore !== undefined &&
-    uploaded > uploadedBefore.getTime()
-  ) {
-    return false;
-  }
-
-  // ifModifiedSince check
-  if (
-    ifNoneMatch !== true && // if "ifNoneMatch" is true, we ignore date checking
-    uploadedAfter !== undefined &&
-    uploaded < uploadedAfter.getTime()
-  ) {
-    return false;
+    const ifMatch = cond.etagMatches === undefined;
+    const ifModifiedSince = cond.uploadedAfter === undefined;
+    return ifMatch && ifModifiedSince;
   }
 
-  return true;
+  const { etag, uploaded: lastModifiedRaw } = metadata;
+  const ifMatch = cond.etagMatches === undefined || cond.etagMatches === etag;
+  const ifNoneMatch =
+    cond.etagDoesNotMatch === undefined || cond.etagDoesNotMatch !== etag;
+
+  const maybeTruncate = cond.secondsGranularity ? truncateToSeconds : identity;
+  const lastModified = maybeTruncate(lastModifiedRaw);
+  const ifModifiedSince =
+    cond.uploadedAfter === undefined ||
+    maybeTruncate(cond.uploadedAfter.getTime()) < lastModified ||
+    (cond.etagDoesNotMatch !== undefined && ifNoneMatch);
+  const ifUnmodifiedSince =
+    cond.uploadedBefore === undefined ||
+    lastModified < maybeTruncate(cond.uploadedBefore.getTime()) ||
+    (cond.etagMatches !== undefined && ifMatch);
+
+  return ifMatch && ifNoneMatch && ifModifiedSince && ifUnmodifiedSince;
 }
 
 export const R2_HASH_ALGORITHMS = [
@@ -95,7 +89,7 @@ export class Validator {
   }
 
   condition(meta?: R2Object, onlyIf?: R2Conditional): Validator {
-    if (onlyIf !== undefined && !testR2Conditional(onlyIf, meta)) {
+    if (onlyIf !== undefined && !_testR2Conditional(onlyIf, meta)) {
       let error = new PreconditionFailed();
       if (meta !== undefined) error = error.attach(meta);
       throw error;

packages/tre/test/plugins/r2/validator.spec.ts

@@ -0,0 +1,114 @@
+import { R2Conditional } from "@cloudflare/workers-types/experimental";
+import { R2ObjectMetadata, _testR2Conditional } from "@miniflare/tre";
+import test from "ava";
+
+test("testR2Conditional: matches various conditions", (t) => {
+  // Adapted from internal R2 gateway tests
+  const etag = "test";
+  const badEtag = "not-test";
+
+  const uploadedDate = new Date("2023-02-24T00:09:00.500Z");
+  const pastDate = new Date(uploadedDate.getTime() - 30_000);
+  const futureDate = new Date(uploadedDate.getTime() + 30_000);
+
+  const metadata: Pick<R2ObjectMetadata, "etag" | "uploaded"> = {
+    etag,
+    uploaded: uploadedDate.getTime(),
+  };
+
+  const using = (cond: R2Conditional) => _testR2Conditional(cond, metadata);
+  const usingMissing = (cond: R2Conditional) => _testR2Conditional(cond);
+
+  // Check single conditions
+  t.true(using({ etagMatches: etag }));
+  t.false(using({ etagMatches: badEtag }));
+
+  t.true(using({ etagDoesNotMatch: badEtag }));
+  t.false(using({ etagDoesNotMatch: etag }));
+
+  t.false(using({ uploadedBefore: pastDate }));
+  t.true(using({ uploadedBefore: futureDate }));
+
+  t.true(using({ uploadedAfter: pastDate }));
+  t.false(using({ uploadedBefore: pastDate }));
+
+  // Check multiple conditions that evaluate to false
+  t.false(using({ etagMatches: etag, etagDoesNotMatch: etag }));
+  t.false(using({ etagMatches: etag, uploadedAfter: futureDate }));
+  t.false(
+    using({
+      // `etagMatches` pass makes `uploadedBefore` pass, but `uploadedAfter` fails
+      etagMatches: etag,
+      uploadedAfter: futureDate,
+      uploadedBefore: pastDate,
+    })
+  );
+  t.false(using({ etagDoesNotMatch: badEtag, uploadedBefore: pastDate }));
+  t.false(
+    using({
+      // `etagDoesNotMatch` pass makes `uploadedAfter` pass, but `uploadedBefore` fails
+      etagDoesNotMatch: badEtag,
+      uploadedAfter: futureDate,
+      uploadedBefore: pastDate,
+    })
+  );
+  t.false(
+    using({
+      etagMatches: badEtag,
+      etagDoesNotMatch: badEtag,
+      uploadedAfter: pastDate,
+      uploadedBefore: futureDate,
+    })
+  );
+
+  // Check multiple conditions that evaluate to true
+  t.true(using({ etagMatches: etag, etagDoesNotMatch: badEtag }));
+  // `etagMatches` pass makes `uploadedBefore` pass
+  t.true(using({ etagMatches: etag, uploadedBefore: pastDate }));
+  // `etagDoesNotMatch` pass makes `uploadedAfter` pass
+  t.true(using({ etagDoesNotMatch: badEtag, uploadedAfter: futureDate }));
+  t.true(
+    using({
+      // `etagMatches` pass makes `uploadedBefore` pass
+      etagMatches: etag,
+      uploadedBefore: pastDate,
+      // `etagDoesNotMatch` pass makes `uploadedAfter` pass
+      etagDoesNotMatch: badEtag,
+      uploadedAfter: futureDate,
+    })
+  );
+  t.true(
+    using({
+      uploadedBefore: futureDate,
+      // `etagDoesNotMatch` pass makes `uploadedAfter` pass
+      etagDoesNotMatch: badEtag,
+      uploadedAfter: futureDate,
+    })
+  );
+  t.true(
+    using({
+      uploadedAfter: pastDate,
+      // `etagMatches` pass makes `uploadedBefore` pass
+      etagMatches: etag,
+      uploadedBefore: pastDate,
+    })
+  );
+
+  // Check missing metadata fails with either `etagMatches` and `uploadedAfter`
+  t.false(usingMissing({ etagMatches: etag }));
+  t.false(usingMissing({ uploadedAfter: pastDate }));
+  t.false(usingMissing({ etagMatches: etag, uploadedAfter: pastDate }));
+  t.true(usingMissing({ etagDoesNotMatch: etag }));
+  t.true(usingMissing({ uploadedBefore: pastDate }));
+  t.true(usingMissing({ etagDoesNotMatch: etag, uploadedBefore: pastDate }));
+  t.false(usingMissing({ etagMatches: etag, uploadedBefore: pastDate }));
+  t.false(usingMissing({ etagDoesNotMatch: etag, uploadedAfter: pastDate }));
+
+  // Check with second granularity
+  const justPastDate = new Date(uploadedDate.getTime() - 250);
+  const justFutureDate = new Date(uploadedDate.getTime() + 250);
+  t.true(using({ uploadedAfter: justPastDate }));
+  t.false(using({ uploadedAfter: justPastDate, secondsGranularity: true }));
+  t.true(using({ uploadedBefore: justFutureDate }));
+  t.false(using({ uploadedBefore: justFutureDate, secondsGranularity: true }));
+});