hardhat 3.14.0 → 3.16.0

package/src/internal/builtin-plugins/solidity-test/inline-config/validation.ts

@@ -1,144 +0,0 @@
-import type { RawInlineOverride } from "./types.js";
-
-import {
-  HardhatError,
-  assertHardhatInvariant,
-} from "@nomicfoundation/hardhat-errors";
-
-import { KEY_TYPES } from "./constants.js";
-import { getFunctionFqn } from "./helpers.js";
-
-/**
- * Validates a list of raw inline overrides, checking for:
- * - Valid keys
- * - No duplicate keys for the same function
- * - Values of the expected type (numbers must be non-negative integers,
- *   booleans must be "true" or "false", strings must be a non-empty
- *   double-quoted literal)
- *
- * Throws a HardhatError if any validation fails.
- */
-export function validateInlineOverrides(overrides: RawInlineOverride[]): void {
-  const seen = new Set<string>();
-
-  for (const {
-    inputSourceName,
-    contractName,
-    functionName,
-    functionSelector,
-    rawKey,
-    rawValue,
-    key,
-  } of overrides) {
-    const functionFqn = getFunctionFqn(
-      inputSourceName,
-      contractName,
-      functionName,
-    );
-
-    // Validate key
-    if (!Object.hasOwn(KEY_TYPES, key)) {
-      throw new HardhatError(
-        HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_KEY,
-        {
-          key: rawKey,
-          validKeys: Object.keys(KEY_TYPES).join(", "),
-          functionFqn,
-        },
-      );
-    }
-
-    // Validate key matches test type
-    const dotIndex = key.indexOf(".");
-    if (dotIndex !== -1) {
-      const keyCategory = key.slice(0, dotIndex);
-      const isFuzzTest = functionName.startsWith("test");
-      const isInvariantTest = functionName.startsWith("invariant");
-
-      if (
-        (isFuzzTest && keyCategory === "invariant") ||
-        (isInvariantTest && keyCategory === "fuzz")
-      ) {
-        const testType = isFuzzTest ? "fuzz" : "invariant";
-        const validPrefix = isFuzzTest ? "fuzz." : "invariant.";
-        const validKeys = Object.keys(KEY_TYPES)
-          .filter((k) => k.startsWith(validPrefix) || !k.includes("."))
-          .join(", ");
-
-        throw new HardhatError(
-          HardhatError.ERRORS.CORE.SOLIDITY_TESTS
-            .INLINE_CONFIG_INVALID_KEY_FOR_TEST_TYPE,
-          {
-            key: rawKey,
-            functionFqn,
-            testType,
-            validKeys,
-          },
-        );
-      }
-    }
-
-    // Check for duplicates (include selector to allow same key on overloaded functions)
-    const functionId =
-      functionSelector !== undefined
-        ? `${functionFqn}#${functionSelector}`
-        : functionFqn;
-    const dedupeKey = `${functionId}-${key}`;
-    if (seen.has(dedupeKey)) {
-      throw new HardhatError(
-        HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_DUPLICATE_KEY,
-        { key: rawKey, functionFqn },
-      );
-    }
-    seen.add(dedupeKey);
-
-    // Validate value type
-    const expectedType = KEY_TYPES[key];
-    if (expectedType === "number") {
-      if (
-        !/^(0|[1-9]\d*)$/.test(rawValue) ||
-        !Number.isSafeInteger(Number(rawValue))
-      ) {
-        throw new HardhatError(
-          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_VALUE,
-          {
-            value: rawValue,
-            key: rawKey,
-            expectedType: "non-negative integer",
-            functionFqn,
-          },
-        );
-      }
-    } else if (expectedType === "boolean") {
-      const lowerValue = rawValue.toLowerCase();
-      if (lowerValue !== "true" && lowerValue !== "false") {
-        throw new HardhatError(
-          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_VALUE,
-          {
-            value: rawValue,
-            key: rawKey,
-            expectedType: "boolean",
-            functionFqn,
-          },
-        );
-      }
-    } else if (expectedType === "string") {
-      if (!/^"[^"\n]+"$/.test(rawValue)) {
-        throw new HardhatError(
-          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.INLINE_CONFIG_INVALID_VALUE,
-          {
-            value: rawValue,
-            key: rawKey,
-            expectedType: "non-empty double-quoted string",
-            functionFqn,
-          },
-        );
-      }
-    } else {
-      assertHardhatInvariant(
-        false,
-        `Unhandled inline config value type for key ${key}`,
-      );
-    }
-  }
-}