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 those tests.
+;; To skip the test when inputs are invalid, define a 'discard' function:
+;; - Must be read-only.
+;; - Name should match the property test function's, prefixed with "can-".
+;; - Parameters should mirror those of the property test.
+;; - Returns true only if inputs are valid, allowing the test to run.
+(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) {
@@ -138,11 +138,9 @@ export function reporter(
   } else {
     radio.emit(
       "logMessage",
-      green(
         `\nOK, ${
           type === "invariant" ? "invariants" : "properties"
-        } passed after ${runDetails.numRuns} runs.`
-      )
+        } passed after ${runDetails.numRuns} runs.\n`
     );
   }
 }

property.tests.ts

@@ -5,11 +5,19 @@ import {
   deriveTestContractName,
   filterTestContractsInterfaces,
   getTestsContractSource,
+  isParamsMatch,
+  isReturnTypeBoolean,
 } from "./property";
 import { getSimnetDeployerContractsInterfaces } from "./shared";
 import { resolve } from "path";
 import fs from "fs";
 import fc from "fast-check";
+import {
+  ContractInterfaceFunction,
+  ContractInterfaceFunctionAccess,
+  ContractInterfaceFunctionArg,
+  ContractInterfaceFunctionOutput,
+} from "@hirosystems/clarinet-sdk/dist/esm/contractInterface";
 
 describe("File stream operations", () => {
   it("retrieves the test contract source", async () => {
@@ -165,3 +173,200 @@ describe("Simnet contracts operations", () => {
     expect(actualTestContractsList).toEqual(expectedTestContractsList);
   });
 });
+
+describe("Test discarding related operations", () => {
+  it("boolean output checker returns true when the function's output is boolean", () => {
+    fc.assert(
+      fc.property(
+        fc.record({
+          fnName: fc.string(),
+          access: fc.constant("read_only"),
+          args: fc.array(
+            fc.record({
+              name: fc.string(),
+              type: fc.constantFrom("int128", "uint128", "bool", "principal"),
+            })
+          ),
+          outputs: fc.record({ type: fc.constant("bool") }),
+        }),
+        (r: {
+          fnName: string;
+          access: string;
+          args: { name: string; type: string }[];
+          outputs: { type: string };
+        }) => {
+          const discardFunctionInterface: ContractInterfaceFunction = {
+            name: r.fnName,
+            access: r.access as ContractInterfaceFunctionAccess,
+            args: r.args as ContractInterfaceFunctionArg[],
+            outputs: r.outputs as ContractInterfaceFunctionOutput,
+          };
+          const actual = isReturnTypeBoolean(discardFunctionInterface);
+          expect(actual).toBe(true);
+        }
+      )
+    );
+  });
+
+  it("boolean output checker returns false when the function's output is non-boolean", () => {
+    fc.assert(
+      fc.property(
+        fc.record({
+          fnName: fc.string(),
+          access: fc.constant("read_only"),
+          args: fc.array(
+            fc.record({
+              name: fc.string(),
+              type: fc.constantFrom("int128", "uint128", "bool", "principal"),
+            })
+          ),
+          outputs: fc.record({
+            type: fc.constantFrom("int128", "uint128", "principal"),
+          }),
+        }),
+        (r: {
+          fnName: string;
+          access: string;
+          args: { name: string; type: string }[];
+          outputs: { type: string };
+        }) => {
+          const discardFunctionInterface: ContractInterfaceFunction = {
+            name: r.fnName,
+            access: r.access as ContractInterfaceFunctionAccess,
+            args: r.args as ContractInterfaceFunctionArg[],
+            outputs: r.outputs as ContractInterfaceFunctionOutput,
+          };
+          const actual = isReturnTypeBoolean(discardFunctionInterface);
+          expect(actual).toBe(false);
+        }
+      )
+    );
+  });
+
+  it("param matcher returns true when two functions have the same parameters", () => {
+    fc.assert(
+      fc.property(
+        fc.record({
+          fnName: fc.string(),
+          access: fc.constant("read_only"),
+          args: fc.array(
+            fc.record({
+              name: fc.string(),
+              type: fc.constantFrom("int128", "uint128", "bool", "principal"),
+            })
+          ),
+          outputs: fc.record({ type: fc.constant("bool") }),
+        }),
+        (r: {
+          fnName: string;
+          access: string;
+          args: { name: string; type: string }[];
+          outputs: { type: string };
+        }) => {
+          const testFunctionInterface: ContractInterfaceFunction = {
+            name: r.fnName,
+            access: r.access as ContractInterfaceFunctionAccess,
+            args: r.args as ContractInterfaceFunctionArg[],
+            outputs: r.outputs as ContractInterfaceFunctionOutput,
+          };
+          const discardFunctionInterface: ContractInterfaceFunction = {
+            name: r.fnName,
+            access: r.access as ContractInterfaceFunctionAccess,
+            args: r.args as ContractInterfaceFunctionArg[],
+            outputs: r.outputs as ContractInterfaceFunctionOutput,
+          };
+          const actual = isParamsMatch(
+            testFunctionInterface,
+            discardFunctionInterface
+          );
+          expect(actual).toBe(true);
+        }
+      )
+    );
+  });
+
+  it("param matcher returns false when two functions have different parameters", () => {
+    fc.assert(
+      fc.property(
+        fc
+          .record({
+            testFn: fc.record({
+              fnName: fc.string(),
+              access: fc.constant("read_only"),
+              args: fc.array(
+                fc.record({
+                  name: fc.string(),
+                  type: fc.constantFrom(
+                    "int128",
+                    "uint128",
+                    "bool",
+                    "principal"
+                  ),
+                })
+              ),
+              outputs: fc.record({ type: fc.constant("bool") }),
+            }),
+            discardFn: fc.record({
+              fnName: fc.string(),
+              access: fc.constant("read_only"),
+              args: fc.array(
+                fc.record({
+                  name: fc.string(),
+                  type: fc.constantFrom(
+                    "int128",
+                    "uint128",
+                    "bool",
+                    "principal"
+                  ),
+                })
+              ),
+              outputs: fc.record({ type: fc.constant("bool") }),
+            }),
+          })
+          .filter(
+            (r) =>
+              JSON.stringify(
+                [...r.testFn.args].sort((a, b) => a.name.localeCompare(b.name))
+              ) !==
+              JSON.stringify(
+                [...r.discardFn.args].sort((a, b) =>
+                  a.name.localeCompare(b.name)
+                )
+              )
+          ),
+        (r: {
+          testFn: {
+            fnName: string;
+            access: string;
+            args: { name: string; type: string }[];
+            outputs: { type: string };
+          };
+          discardFn: {
+            fnName: string;
+            access: string;
+            args: { name: string; type: string }[];
+            outputs: { type: string };
+          };
+        }) => {
+          const testFunctionInterface: ContractInterfaceFunction = {
+            name: r.testFn.fnName,
+            access: r.testFn.access as ContractInterfaceFunctionAccess,
+            args: r.testFn.args as ContractInterfaceFunctionArg[],
+            outputs: r.testFn.outputs as ContractInterfaceFunctionOutput,
+          };
+          const discardFunctionInterface: ContractInterfaceFunction = {
+            name: r.discardFn.fnName,
+            access: r.discardFn.access as ContractInterfaceFunctionAccess,
+            args: r.discardFn.args as ContractInterfaceFunctionArg[],
+            outputs: r.discardFn.outputs as ContractInterfaceFunctionOutput,
+          };
+          const actual = isParamsMatch(
+            testFunctionInterface,
+            discardFunctionInterface
+          );
+          expect(actual).toBe(false);
+        }
+      )
+    );
+  });
+});