feat: benchmark details refinement

ensawards.org/data/acceptance-tests/index.test.ts

@@ -0,0 +1,22 @@
+import { ACCEPTANCE_TESTS } from "data/acceptance-tests";
+import { isValidSlug } from "data/shared/slugs";
+import { describe, expect, it } from "vitest";
+
+import { areStringsUnique } from "@/utils";
+
+describe("Acceptance test data", () => {
+  it("Should have valid and unique slugs", () => {
+    const slugArray: string[] = [];
+
+    ACCEPTANCE_TESTS.forEach((acceptanceTest) => {
+      expect(
+        isValidSlug(acceptanceTest.acceptanceTestSlug),
+        `Slug={${acceptanceTest.acceptanceTestSlug}} is not valid`,
+      ).toEqual(true);
+
+      slugArray.push(acceptanceTest.acceptanceTestSlug);
+    });
+
+    expect(areStringsUnique(slugArray), `Slugs for Acceptance Tests are not unique`).toEqual(true);
+  });
+});

ensawards.org/data/acceptance-tests/index.ts

@@ -0,0 +1,5 @@
+import { ENS_BEST_PRACTICES } from "data/ens-best-practices";
+
+export const ACCEPTANCE_TESTS = [
+  ...ENS_BEST_PRACTICES.flatMap((bestPractice) => bestPractice.technicalDetails.acceptanceTests),
+];

ensawards.org/data/acceptance-tests/types.ts

@@ -0,0 +1,98 @@
+import { type BenchmarkResult, BenchmarkResults } from "data/benchmarks/types";
+import type { Contribution } from "data/contributors/types";
+import type { JSX } from "react";
+
+/** A unique identifier for an acceptance test.
+ *
+ * @invariant Must be unique across all acceptance tests.
+ * @invariant Must match {@link ENSAWARDS_SLUG_PATTERN}.
+ */
+export type AcceptanceTestSlug = string;
+
+/**
+ * Represents an acceptance test that an app can be evaluated against.
+ */
+export interface AcceptanceTest {
+  /**
+   * Unique identifier for the acceptance test.
+   */
+  acceptanceTestSlug: AcceptanceTestSlug;
+
+  /**
+   * Description of the acceptance test,
+   * which should provide clear and detailed information
+   * about the criteria and requirements that
+   * an {@link App} must meet to pass the test.
+   * This may include specific functionalities to be tested,
+   * user interactions to be evaluated,
+   * and any relevant technical details or considerations.
+   *
+   * @note The description should not include examples of passed or failed benchmarks,
+   * there are dedicated fields for that
+   * (see {@link AcceptanceTest.examplePass},
+   * {@link AcceptanceTest.examplePartialPass},
+   * or {@link AcceptanceTest.exampleFail}).
+   */
+  description: JSX.Element;
+
+  /**
+   * Examples of benchmark results that illustrate
+   * what a passing, partially passing, or failing result
+   * looks like for this acceptance test.
+   */
+  examplePass: AcceptanceTestBenchmarkPass;
+  examplePartialPass?: AcceptanceTestBenchmarkPartialPass;
+  exampleFail?: AcceptanceTestBenchmarkFail;
+}
+
+/**
+ * Represents the benchmark of an {@link AcceptanceTest} on an {@link App} against a {@link BestPractice}.
+ */
+export interface AcceptanceTestBenchmarkAbstract<BenchmarkResultT extends BenchmarkResult> {
+  /** The result of the benchmark */
+  result: BenchmarkResultT;
+
+  /** A record of all contributors involved
+   * in the addition or maintenance of the benchmark's data.
+   *
+   * @invariant Multiple {@link Contribution} from the same contributor
+   * on the same app benchmark are not allowed.
+   * When a contributor makes updates to their existing contribution,
+   * they should update the `lastUpdated` timestamp of their existing `Contribution`.
+   */
+  contributions: [Contribution, ...Contribution[]];
+
+  /**
+   * Notes about how the benchmark result was determined,
+   * which may include details about the testing process,
+   * any challenges encountered, and explanations,
+   * as well as a visual proof, for the final result.
+   */
+  notes: JSX.Element;
+}
+
+/**
+ * Represents a benchmark of an {@link AcceptanceTest} on an {@link App} against a {@link BestPractice},
+ * that has fully passed the acceptance test.
+ */
+export interface AcceptanceTestBenchmarkPass
+  extends AcceptanceTestBenchmarkAbstract<typeof BenchmarkResults.Pass> {}
+
+/**
+ * Represents a benchmark of an {@link AcceptanceTest} on an {@link App} against a {@link BestPractice},
+ * that has partially passed the acceptance test.
+ */
+export interface AcceptanceTestBenchmarkPartialPass
+  extends AcceptanceTestBenchmarkAbstract<typeof BenchmarkResults.PartialPass> {}
+
+/**
+ * Represents a benchmark of an {@link AcceptanceTest} on an {@link App} against a {@link BestPractice},
+ * that hasn't passed the acceptance test.
+ */
+export interface AcceptanceTestBenchmarkFail
+  extends AcceptanceTestBenchmarkAbstract<typeof BenchmarkResults.Fail> {}
+
+export type AcceptanceTestBenchmark =
+  | AcceptanceTestBenchmarkPass
+  | AcceptanceTestBenchmarkPartialPass
+  | AcceptanceTestBenchmarkFail;

ensawards.org/data/acceptance-tests/utils.test.ts

@@ -0,0 +1,95 @@
+import { generalizeAcceptanceTestBenchmarks } from "data/acceptance-tests/utils";
+import { type AcceptanceTestBenchmarks, BenchmarkResults } from "data/benchmarks/types";
+import { createMockAcceptanceTestBenchmark } from "data/shared/test-utils";
+import { describe, expect, it } from "vitest";
+
+describe("Acceptance test utils", () => {
+  describe("generalizeAcceptanceTestBenchmarks", () => {
+    it(
+      "Returns `BenchmarkResults.Pass` if in all defined benchmarks there is at least one `BenchmarkResults.Pass`" +
+        " and all others are `BenchmarkResults.Pass` or `BenchmarkResults.PartialPass`",
+      () => {
+        const expectedResult = BenchmarkResults.Pass;
+
+        const inputBenchmarks = {
+          "mock-acceptance-test-1": createMockAcceptanceTestBenchmark(BenchmarkResults.Pass),
+          "mock-acceptance-test-2": createMockAcceptanceTestBenchmark(BenchmarkResults.PartialPass),
+          "mock-acceptance-test-3": undefined,
+          // pending benchmarks should be ignored in this case of the generalization
+        } as const satisfies AcceptanceTestBenchmarks;
+
+        expect(
+          generalizeAcceptanceTestBenchmarks(inputBenchmarks),
+          "generalizeAcceptanceTestBenchmarks should return `BenchmarkResults.Pass`",
+        ).toEqual(expectedResult);
+      },
+    );
+
+    it("Returns `BenchmarkResults.Fail` if all defined benchmarks are `BenchmarkResults.Fail`", () => {
+      const expectedResult = BenchmarkResults.Fail;
+
+      const inputBenchmarks = {
+        "mock-acceptance-test-1": createMockAcceptanceTestBenchmark(BenchmarkResults.Fail),
+        "mock-acceptance-test-2": createMockAcceptanceTestBenchmark(BenchmarkResults.Fail),
+        "mock-acceptance-test-3": undefined,
+        // pending benchmarks should be ignored in this case of the generalization
+      } as const satisfies AcceptanceTestBenchmarks;
+
+      expect(
+        generalizeAcceptanceTestBenchmarks(inputBenchmarks),
+        "generalizeAcceptanceTestBenchmarks should return `BenchmarkResults.Fail`",
+      ).toEqual(expectedResult);
+    });
+
+    it(
+      "Returns `BenchmarkResults.PartialPass` if at least one defined benchmark is `BenchmarkResults.Fail`" +
+        " and at least one defined benchmark is `BenchmarkResults.Pass`",
+      () => {
+        const expectedResult = BenchmarkResults.PartialPass;
+
+        const inputBenchmarks = {
+          "mock-acceptance-test-1": createMockAcceptanceTestBenchmark(BenchmarkResults.Fail),
+          "mock-acceptance-test-2": createMockAcceptanceTestBenchmark(BenchmarkResults.Pass),
+          "mock-acceptance-test-3": createMockAcceptanceTestBenchmark(BenchmarkResults.PartialPass),
+          "mock-acceptance-test-4": undefined,
+          // pending benchmarks should be ignored in this case of the generalization
+        } as const satisfies AcceptanceTestBenchmarks;
+
+        expect(
+          generalizeAcceptanceTestBenchmarks(inputBenchmarks),
+          "generalizeAcceptanceTestBenchmarks should return `BenchmarkResults.PartialPass`",
+        ).toEqual(expectedResult);
+      },
+    );
+
+    it("Returns `BenchmarkResults.PartialPass` if all defined benchmarks are `BenchmarkResults.PartialPass`", () => {
+      const expectedResult = BenchmarkResults.PartialPass;
+
+      const inputBenchmarks = {
+        "mock-acceptance-test-1": createMockAcceptanceTestBenchmark(BenchmarkResults.PartialPass),
+        "mock-acceptance-test-2": createMockAcceptanceTestBenchmark(BenchmarkResults.PartialPass),
+        "mock-acceptance-test-3": undefined,
+        // pending benchmarks should be ignored in this case of the generalization
+      } as const satisfies AcceptanceTestBenchmarks;
+
+      expect(
+        generalizeAcceptanceTestBenchmarks(inputBenchmarks),
+        "generalizeAcceptanceTestBenchmarks should return `BenchmarkResults.PartialPass`",
+      ).toEqual(expectedResult);
+    });
+
+    it("Returns `undefined` if all benchmarks are `undefined` (pending)", () => {
+      const expectedResult = undefined;
+
+      const inputBenchmarks = {
+        "mock-acceptance-test-1": undefined,
+        "mock-acceptance-test-2": undefined,
+      } as const satisfies AcceptanceTestBenchmarks;
+
+      expect(
+        generalizeAcceptanceTestBenchmarks(inputBenchmarks),
+        "generalizeAcceptanceTestBenchmarks should return `undefined` for all pending benchmarks",
+      ).toEqual(expectedResult);
+    });
+  });
+});

ensawards.org/data/acceptance-tests/utils.ts

@@ -0,0 +1,90 @@
+import { ACCEPTANCE_TESTS } from "data/acceptance-tests";
+import type {
+  AcceptanceTest,
+  AcceptanceTestBenchmark,
+  AcceptanceTestSlug,
+} from "data/acceptance-tests/types";
+import type { AppSlug } from "data/apps/types";
+import {
+  type AcceptanceTestBenchmarks,
+  type BenchmarkResult,
+  BenchmarkResults,
+} from "data/benchmarks/types";
+import { getAppBenchmarks } from "data/benchmarks/utils.ts";
+
+/** Returns an {@link AcceptanceTest} by {@link AcceptanceTestSlug}. */
+export const getAcceptanceTestBySlug = (slug: AcceptanceTestSlug): AcceptanceTest | undefined => {
+  return ACCEPTANCE_TESTS.find((acceptanceTest) => acceptanceTest.acceptanceTestSlug === slug);
+};
+
+/** Returns all {@link AcceptanceTestBenchmark}s of an `App` by {@link AppSlug}. */
+export const getAcceptanceTestBenchmarksByApp = (
+  appSlug: AppSlug,
+): (AcceptanceTestBenchmark | undefined)[] => {
+  const appBenchmarks = getAppBenchmarks(appSlug);
+
+  return Object.values(appBenchmarks).flatMap((acceptanceTestBenchmarks) =>
+    Object.values(acceptanceTestBenchmarks),
+  );
+};
+
+/**
+ * Generalizes multiple `AcceptanceTestBenchmark`s into a single `BenchmarkResult`
+ * based on the following rules:
+ * - Returns {@link BenchmarkResults.Pass} if:
+ *     - in all defined benchmarks there is at least one
+ *       {@link BenchmarkResults.Pass}
+ *     - and all others are {@link BenchmarkResults.Pass} or {@link BenchmarkResults.PartialPass}
+ *
+ * - Returns {@link BenchmarkResults.Fail} if all defined benchmarks
+ * are {@link BenchmarkResults.Fail},
+ *
+ * - Returns {@link BenchmarkResults.PartialPass} if:
+ *     - at least one defined benchmark is {@link BenchmarkResults.Fail}
+ *       and at least one defined benchmark is
+ *       {@link BenchmarkResults.Pass} or {@link BenchmarkResults.PartialPass},
+ *     - or all defined benchmarks are {@link BenchmarkResults.PartialPass},
+ *
+ * -  Returns `undefined` if all benchmarks are `undefined` (pending).
+ */
+export const generalizeAcceptanceTestBenchmarks = (
+  acceptanceTestBenchmarks: AcceptanceTestBenchmarks,
+): BenchmarkResult | undefined => {
+  const benchmarkResults = Object.values(acceptanceTestBenchmarks).map(
+    (benchmark) => benchmark?.result,
+  );
+
+  const definedBenchmarkResults = benchmarkResults.filter((result) => result !== undefined);
+
+  if (definedBenchmarkResults.length === 0) {
+    return undefined;
+  }
+
+  const allDefinedBenchmarksPassPartially = definedBenchmarkResults.every(
+    (result) => result === BenchmarkResults.PartialPass,
+  );
+
+  if (allDefinedBenchmarksPassPartially) {
+    return BenchmarkResults.PartialPass;
+  }
+
+  // For now, we'll explicitly treat pass and partial pass equally
+  // (For cases where not all benchmarks are partial pass)
+  const allDefinedBenchmarksPass = definedBenchmarkResults.every(
+    (result) => result === BenchmarkResults.Pass || result === BenchmarkResults.PartialPass,
+  );
+
+  if (allDefinedBenchmarksPass) {
+    return BenchmarkResults.Pass;
+  }
+
+  const allDefinedBenchmarksFail = definedBenchmarkResults.every(
+    (result) => result === BenchmarkResults.Fail,
+  );
+
+  if (allDefinedBenchmarksFail) {
+    return BenchmarkResults.Fail;
+  }
+
+  return BenchmarkResults.PartialPass;
+};

ensawards.org/data/apps/ambire-wallet/benchmarks/index.tsx

@@ -0,0 +1,47 @@
+// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md for additional advice
+// on adding and modifying app benchmarks
+
+import type { AcceptanceTestBenchmark } from "data/acceptance-tests/types";
+import AmbireWallet from "data/apps/ambire-wallet";
+import { defineAppBenchmarks } from "data/benchmarks/registry";
+import { BenchmarkResults } from "data/benchmarks/types";
+import contributors from "data/contributors";
+import { acceptanceTestDetailsContainerStyles } from "data/ens-best-practices/styles";
+import type { BestPracticeBenchmarks } from "data/ens-best-practices/types.ts";
+
+import { parseTimestamp } from "@ensnode/ensnode-sdk";
+
+const benchmarks = {
+  "display-named-smart-contracts-mainnet": {
+    "mainnet-interactions-display-named-smart-contracts": {
+      result: BenchmarkResults.PartialPass,
+      contributions: [
+        { from: contributors.caldonia, lastUpdated: parseTimestamp("2026-04-23T19:50:24Z") },
+      ],
+      notes: (
+        // TODO: Enhance the notes
+        <div className={acceptanceTestDetailsContainerStyles}>
+          <p className="w-full">Benchmark placeholder notes</p>
+        </div>
+      ),
+    } as const satisfies AcceptanceTestBenchmark,
+  },
+  "display-named-smart-contracts-l2-chains": {
+    "l2-chain-interactions-display-named-smart-contracts": {
+      result: BenchmarkResults.PartialPass,
+      contributions: [
+        { from: contributors.caldonia, lastUpdated: parseTimestamp("2026-04-23T19:50:24Z") },
+      ],
+      notes: (
+        // TODO: Enhance the notes
+        <div className={acceptanceTestDetailsContainerStyles}>
+          <p className="w-full">Benchmark placeholder notes</p>
+        </div>
+      ),
+    } as const satisfies AcceptanceTestBenchmark,
+  },
+} as const satisfies BestPracticeBenchmarks;
+
+defineAppBenchmarks(AmbireWallet, benchmarks);
+
+export default benchmarks;