Add unit tests in Clarity

contrib/core-contract-tests/.gitignore

@@ -4,4 +4,6 @@ npm-debug.log*
 coverage
 *.info
 costs-reports.json
-node_modules
+node_modules
+*.log.txt
+history.txt

contrib/core-contract-tests/Clarinet.toml

@@ -8,3 +8,11 @@ costs_version = 1
 [contracts.bns]
 path = "../../stackslib/src/chainstate/stacks/boot/bns.clar"
 depends_on = []
+
+[contracts.bns_test]
+path = "contracts/bns-tests/bns_test.clar"
+depends_on = []
+
+[contracts.bns_flow_test]
+path = "contracts/bns-tests/bns_flow_test.clar"
+depends_on = []

contrib/core-contract-tests/contracts/bns-tests/bns_flow_test.clar

@@ -0,0 +1,19 @@
+(define-constant ERR_NAMESPACE_NOT_FOUND 1005)
+
+;; @name: test delegation to wallet_2, stacking and revoking
+(define-public (test-name-registration)
+    (begin
+        ;; @caller wallet_1
+        (unwrap! (contract-call? .bns name-preorder 0x0123456789abcdef01230123456789abcdef0123 u1000000) (err "name-preorder by wallet 1 should succeed"))
+        ;; @caller wallet_2
+        (unwrap! (contract-call? .bns name-preorder 0x30123456789abcdef01230123456789abcdef012 u1000000) (err "name-preorder by wallet 2 should succeed"))
+
+        ;; @mine-blocks-before 100
+        ;; @caller wallet_1
+        (try! (register))
+        (ok true)))
+
+(define-public (register)
+    (let ((result (contract-call? .bns name-register 0x123456 0x123456 0x123456 0x)))
+            (asserts! (is-eq result (err ERR_NAMESPACE_NOT_FOUND)) (err "name-register should fail"))
+            (ok true)))

contrib/core-contract-tests/contracts/bns-tests/bns_test.clar

@@ -0,0 +1,10 @@
+;; @name: test preorder and publish with invalid names
+;; @caller: wallet_1
+(define-constant ERR_NAMESPACE_NOT_FOUND 1005)
+
+(define-public (test-name-registration)
+    (begin
+        (unwrap! (contract-call? .bns name-preorder 0x0123456789abcdef01230123456789abcdef0123 u1000000) (err "preorder should succeeed"))
+        (let ((result (contract-call? .bns name-register  0x123456 0x123456 0x123456 0x)))
+            (asserts! (is-eq result (err ERR_NAMESPACE_NOT_FOUND)) (err "registration should fail"))
+            (ok true))))

contrib/core-contract-tests/package.json

@@ -12,6 +12,7 @@
     "@hirosystems/clarinet-sdk": "^1.1.0",
     "@stacks/transactions": "^6.9.0",
     "chokidar-cli": "^3.0.0",
+    "path": "^0.12.7",
     "typescript": "^5.2.2",
     "vite": "^4.4.9",
     "vitest": "^0.34.4",

contrib/core-contract-tests/tests/clar/clar-flow.test.ts

@@ -0,0 +1,138 @@
+import { ParsedTransactionResult, tx } from "@hirosystems/clarinet-sdk";
+import { describe, it } from "vitest";
+import {
+  CallInfo,
+  FunctionAnnotations,
+  FunctionBody,
+  extractTestAnnotationsAndCalls,
+} from "./utils/clarity-parser";
+import { expectOk, isValidTestFunction } from "./utils/test-helpers";
+import path from "path";
+import * as fs from "fs";
+
+function isTestContract(contractName: string) {
+  return contractName.substring(contractName.length - 10) === "_flow_test";
+}
+
+const accounts = simnet.getAccounts();
+clearLogFile();
+
+simnet.getContractsInterfaces().forEach((contract, contractFQN) => {
+  if (!isTestContract(contractFQN)) {
+    return;
+  }
+
+  describe(contractFQN, () => {
+    const hasDefaultPrepareFunction =
+      contract.functions.findIndex((f) => f.name === "prepare") >= 0;
+
+    contract.functions.forEach((functionCall) => {
+      if (!isValidTestFunction(functionCall)) {
+        return;
+      }
+
+      const functionName = functionCall.name;
+      const source = simnet.getContractSource(contractFQN)!;
+      const [annotations, functionBodies] =
+        extractTestAnnotationsAndCalls(source);
+      const functionAnnotations: FunctionAnnotations =
+        annotations[functionName] || {};
+      const testname = `${functionCall.name}${
+        functionAnnotations.name ? `: ${functionAnnotations.name}` : ""
+      }`;
+      it(testname, () => {
+        writeToLogFile(`\n\n${testname}\n\n`);
+        if (hasDefaultPrepareFunction && !functionAnnotations.prepare)
+          functionAnnotations.prepare = "prepare";
+        if (functionAnnotations["no-prepare"])
+          delete functionAnnotations.prepare;
+
+        const functionBody = functionBodies[functionName] || [];
+
+        mineBlocksFromFunctionBody(contractFQN, functionName, functionBody);
+      });
+    });
+  });
+});
+function mineBlocksFromFunctionBody(
+  contractFQN: string,
+  testFunctionName: string,
+  calls: FunctionBody
+) {
+  let blockStarted = false;
+  let txs: any[] = [];
+  let block: ParsedTransactionResult[] = [];
+
+  for (const { callAnnotations, callInfo } of calls) {
+    // mine empty blocks
+    const mineBlocksBefore =
+      parseInt(callAnnotations["mine-blocks-before"] as string) || 0;
+    const caller = accounts.get(
+      (callAnnotations["caller"] as string) || "deployer"
+    )!;
+
+    if (mineBlocksBefore >= 1) {
+      if (blockStarted) {
+        writeToLogFile(txs);
+        block = simnet.mineBlock(txs);
+        for (let index = 0; index < txs.length; index++) {
+          expectOk(block, contractFQN, testFunctionName, index);
+        }
+        txs = [];
+        blockStarted = false;
+      }
+      if (mineBlocksBefore > 1) {
+        simnet.mineEmptyBlocks(mineBlocksBefore - 1);
+        writeToLogFile(mineBlocksBefore - 1);
+      }
+    }
+    // start a new block if necessary
+    if (!blockStarted) {
+      blockStarted = true;
+    }
+    // add tx to current block
+    txs.push(generateCallWithArguments(callInfo, contractFQN, caller));
+  }
+  // close final block
+  if (blockStarted) {
+    writeToLogFile(txs);
+    block = simnet.mineBlock(txs);
+    for (let index = 0; index < txs.length; index++) {
+      expectOk(block, contractFQN, testFunctionName, index);
+    }
+    txs = [];
+    blockStarted = false;
+  }
+}
+
+function generateCallWithArguments(
+  callInfo: CallInfo,
+  contractPrincipal: string,
+  callerAddress: string
+) {
+  const contractName = callInfo.contractName || contractPrincipal;
+  const functionName = callInfo.functionName;
+
+  return tx.callPublicFn(
+    contractName,
+    functionName,
+    callInfo.args.map((arg) => arg.value),
+    callerAddress
+  );
+}
+
+function writeToLogFile(data: ParsedTransactionResult[] | number | string) {
+  const filePath = path.join(__dirname, "clar-flow-test.log.txt");
+  if (typeof data === "number") {
+    fs.appendFileSync(filePath, `${data} empty blocks\n`);
+  } else if (typeof data === "string") {
+    fs.appendFileSync(filePath, `${data}\n`);
+  } else {
+    fs.appendFileSync(filePath, `block:\n${JSON.stringify(data, null, 2)}\n`);
+  }
+}
+
+function  clearLogFile() {
+  const filePath = path.join(__dirname, "clar-flow-test.log.txt");
+  fs.writeFileSync(filePath, "");
+}