Add discard functionality for conditional tests

example/contracts/slice.tests.clar

@@ -4,33 +4,42 @@
 (define-constant ERR_ASSERTION_FAILED_3 (err 3))
 
 (define-public (test-slice-list-int (seq (list 127 int)) (skip int) (n int))
-  (if
-    ;; Early return if the input is invalid.
-    (or
-      (not (and (<= 0 n) (<= n 127)))
-      (not (and (<= 0 skip) (<= skip 127))))
-    (ok true)
-    (let (
-        (result (contract-call? .slice slice seq skip n))
-      )
+  (let (
+      (result (contract-call? .slice slice seq skip n))
+    )
+    (if
+      ;; Case 1: If skip > length of seq, result should be an empty list.
+      (> (to-uint skip) (len seq))
+      (asserts! (is-eq result (list )) ERR_ASSERTION_FAILED_1)
       (if
-        ;; Case 1: If skip > length of seq, result should be an empty list.
-        (> (to-uint skip) (len seq))
-        (asserts! (is-eq result (list )) ERR_ASSERTION_FAILED_1)
-        (if
-          ;; Case 2: If n > length of seq - skip, result length should be
-          ;; length of seq - skip.
-          (>
-            (to-uint n)
+        ;; Case 2: If n > length of seq - skip, result length should be
+        ;; length of seq - skip.
+        (>
+          (to-uint n)
+          (- (len seq) (to-uint skip)))
+        (asserts!
+          (is-eq
+            (len result)
             (- (len seq) (to-uint skip)))
-          (asserts!
-            (is-eq
-              (len result)
-              (- (len seq) (to-uint skip)))
-            ERR_ASSERTION_FAILED_2)
-          ;; Case 3: If n <= length of seq - skip, result length should be n.
-          (asserts! (is-eq (len result) (to-uint n)) ERR_ASSERTION_FAILED_3)))
-      (ok true))))
+          ERR_ASSERTION_FAILED_2)
+        ;; Case 3: If n <= length of seq - skip, result length should be n.
+        (asserts! (is-eq (len result) (to-uint n)) ERR_ASSERTION_FAILED_3)))
+    (ok true)))
+
+;; Some tests, like 'test-slice-list-int', are valid only for specific inputs.
+;; Rendezvous generates a wide range of inputs, which may include values that
+;; are unsuitable for these tests.
+;; To skip the test when inputs are invalid, define a 'discard' function:
+;; - It must be read-only.
+;; - Its name should match the property test function's, prefixed with "can-".
+;; - Its parameters should mirror those of the property test.
+;; - It must return a boolean indicating if the inputs are invalid.
+(define-read-only (can-test-slice-list-int (seq (list 127 int))
+                                           (skip int)
+                                           (n int))
+  (and
+    (and (<= 0 n) (<= n 127))
+    (and (<= 0 skip) (<= skip 127))))
 
 (define-public (test-slice-list-uint (seq (list 127 uint)) (skip int) (n int))
   (if

heatstroke.tests.ts

@@ -102,7 +102,7 @@ describe("Custom reporter logging", () => {
 
           // Assert
           const expectedMessages = [
-            `Error: Property failed after ${r.numRuns} tests.`,
+            `\nError: Property failed after ${r.numRuns} tests.`,
             `Seed : ${r.seed}`,
             `\nCounterexample:`,
             `- Contract : ${getContractNameFromRendezvousId(
@@ -231,7 +231,7 @@ describe("Custom reporter logging", () => {
 
           // Assert
           const expectedMessages = [
-            `Error: Property failed after ${r.numRuns} tests.`,
+            `\nError: Property failed after ${r.numRuns} tests.`,
             `Seed : ${r.seed}`,
             `Path : ${r.path}`,
             `\nCounterexample:`,
@@ -441,7 +441,7 @@ describe("Custom reporter logging", () => {
 
           // Assert
           const expectedMessages = [
-            `Error: Property failed after ${r.numRuns} tests.`,
+            `\nError: Property failed after ${r.numRuns} tests.`,
             `Seed : ${r.seed}`,
             `\nCounterexample:`,
             `- Test Contract : ${testContractId.split(".")[1]}`,
@@ -543,7 +543,7 @@ describe("Custom reporter logging", () => {
 
           // Assert
           const expectedMessages = [
-            `Error: Property failed after ${r.numRuns} tests.`,
+            `\nError: Property failed after ${r.numRuns} tests.`,
             `Seed : ${r.seed}`,
             `Path : ${r.path}`,
             `\nCounterexample:`,

heatstroke.ts

@@ -39,7 +39,7 @@ export function reporter(
 
     radio.emit(
       "logFailure",
-      `Error: Property failed after ${runDetails.numRuns} tests.`
+      `\nError: Property failed after ${runDetails.numRuns} tests.`
     );
     radio.emit("logFailure", `Seed : ${runDetails.seed}`);
     if (runDetails.path) {
@@ -141,7 +141,7 @@ export function reporter(
       green(
         `\nOK, ${
           type === "invariant" ? "invariants" : "properties"
-        } passed after ${runDetails.numRuns} runs.`
+        } passed after ${runDetails.numRuns} runs.\n`
       )
     );
   }

property.ts

@@ -16,6 +16,7 @@ import {
   getFunctionsListForContract,
   getSimnetDeployerContractsInterfaces,
 } from "./shared";
+import { dim, green, red, underline, yellow } from "ansicolor";
 
 export const checkProperties = (
   simnet: Simnet,
@@ -59,6 +60,93 @@ export const checkProperties = (
     `\nStarting property testing type for the ${sutContractName} contract...`
   );
 
+  // Search for discard functions, for each test function. This map will
+  // be used to pair the test functions with their corresponding discard
+  // functions.
+  const testContractsDiscardFunctions = new Map(
+    Array.from(testContractsAllFunctions, ([contractId, functions]) => [
+      contractId,
+      functions.filter(
+        (f) => f.access === "read_only" && f.name.startsWith("can-")
+      ),
+    ])
+  );
+
+  // Pair each test function with its corresponding discard function. When a
+  // test function is selected, Rendezvous will first call its discard
+  // function, if available, to validate that the generated test arguments are
+  // meaningful. This way, we are reducing the risk of false positives in test
+  // results.
+  const testContractsPairedFunctions = new Map(
+    Array.from(testContractsTestFunctions, ([contractId, functions]) => [
+      contractId,
+      new Map(
+        functions.map((f) => {
+          const discardFunction = testContractsDiscardFunctions
+            .get(contractId)
+            ?.find((pf) => pf.name === `can-${f.name}`);
+
+          return [f.name, discardFunction?.name];
+        })
+      ),
+    ])
+  );
+
+  let discardFunctionError = false;
+
+  // If discard functions are available, verify they follow the remaining
+  // rules:
+  // - Their parameters must match those of the test function.
+  // - Their return type must be boolean.
+  testContractsPairedFunctions.forEach((pairedMap, contractId) => {
+    pairedMap.forEach((discardFunctionName, testFunctionName) => {
+      if (discardFunctionName) {
+        const testFunction = testContractsTestFunctions
+          .get(contractId)
+          ?.find((f) => f.name === testFunctionName);
+        const discardFunction = testContractsDiscardFunctions
+          .get(contractId)
+          ?.find((f) => f.name === discardFunctionName);
+
+        if (testFunction && discardFunction) {
+          const paramsMatch =
+            JSON.stringify(testFunction.args) ===
+            JSON.stringify(discardFunction.args);
+          const returnTypeIsBoolean = discardFunction.outputs.type === "bool";
+
+          if (!paramsMatch) {
+            radio.emit(
+              "logFailure",
+              red(
+                `\n[FAIL] Parameter mismatch for discard function "${discardFunctionName}" in contract "${deriveTestContractName(
+                  sutContractIds[0]
+                )}".`
+              )
+            );
+            discardFunctionError = true;
+            return;
+          }
+          if (!returnTypeIsBoolean) {
+            radio.emit(
+              "logFailure",
+              red(
+                `\n[FAIL] Return type must be boolean for discard function "${discardFunctionName}" in contract "${deriveTestContractName(
+                  sutContractIds[0]
+                )}".`
+              )
+            );
+            discardFunctionError = true;
+            return;
+          }
+        }
+      }
+    });
+  });
+
+  if (discardFunctionError) {
+    return;
+  }
+
   const radioReporter = (runDetails: any) => {
     reporter(runDetails, radio, "test");
   };
@@ -129,37 +217,76 @@ export const checkProperties = (
           .join(" ");
 
         const [testCallerWallet, testCallerAddress] = r.testCaller;
-        const { result: testFunctionCallResult } = simnet.callPublicFn(
-          r.testContractId,
-          r.selectedTestFunction.name,
-          selectedTestFunctionArgs,
-          testCallerAddress
-        );
 
-        const testFunctionCallResultJson = cvToJSON(testFunctionCallResult);
+        const discardFunctionName = testContractsPairedFunctions
+          .get(r.testContractId)!
+          .get(r.selectedTestFunction.name);
 
-        if (
-          testFunctionCallResultJson.success &&
-          testFunctionCallResultJson.value.value === true
-        ) {
-          radio.emit(
-            "logMessage",
-            ` ✔  ${testCallerWallet} ${r.testContractId.split(".")[1]} ${
-              r.selectedTestFunction.name
-            } ${printedTestFunctionArgs}`
+        let discarded = false;
+
+        // If a discard function is defined, call it first to determine if the
+        // test function can be executed.
+        if (discardFunctionName !== undefined) {
+          const { result: discardFunctionCallResult } = simnet.callReadOnlyFn(
+            r.testContractId,
+            discardFunctionName,
+            selectedTestFunctionArgs,
+            testCallerAddress
           );
-        } else {
+
+          const jsonDiscardFunctionCallResult = cvToJSON(
+            discardFunctionCallResult
+          );
+
+          discarded = jsonDiscardFunctionCallResult.value === false;
+        }
+
+        if (discarded) {
           radio.emit(
             "logMessage",
-            ` ✗  ${testCallerWallet} ${r.testContractId.split(".")[1]} ${
-              r.selectedTestFunction.name
-            } ${printedTestFunctionArgs}`
+            ` ${yellow("[WARN]")}  ${dim(testCallerWallet)} ${
+              r.testContractId.split(".")[1]
+            } ${underline(r.selectedTestFunction.name)} ${dim(
+              printedTestFunctionArgs
+            )}`
           );
-          throw new Error(
-            `Test failed for ${r.testContractId.split(".")[1]} contract: "${
-              r.selectedTestFunction.name
-            }" returned ${testFunctionCallResultJson.value.value}`
+        } else {
+          const { result: testFunctionCallResult } = simnet.callPublicFn(
+            r.testContractId,
+            r.selectedTestFunction.name,
+            selectedTestFunctionArgs,
+            testCallerAddress
           );
+
+          const testFunctionCallResultJson = cvToJSON(testFunctionCallResult);
+
+          if (
+            testFunctionCallResultJson.success &&
+            testFunctionCallResultJson.value.value === true
+          ) {
+            radio.emit(
+              "logMessage",
+              ` ${green("[PASS]")}  ${dim(testCallerWallet)} ${
+                r.testContractId.split(".")[1]
+              } ${underline(
+                r.selectedTestFunction.name
+              )} ${printedTestFunctionArgs}`
+            );
+          } else {
+            radio.emit(
+              "logMessage",
+              ` ${red("[FAIL]")}  ${dim(testCallerWallet)} ${
+                r.testContractId.split(".")[1]
+              } ${underline(
+                r.selectedTestFunction.name
+              )} ${printedTestFunctionArgs}`
+            );
+            throw new Error(
+              `Test failed for ${r.testContractId.split(".")[1]} contract: "${
+                r.selectedTestFunction.name
+              }" returned ${testFunctionCallResultJson.value.value}`
+            );
+          }
         }
       }
     ),