movehat 0.1.3 → 0.1.4

package/src/templates/tests/Counter.test.ts

@@ -1,72 +1,113 @@
 // @ts-nocheck - This is a template file, dependencies are installed in user projects
-import { describe, it, before } from "mocha";
+import { describe, it, before, after } from "mocha";
 import { expect } from "chai";
-import { getMovehat, type MovehatRuntime } from "movehat";
+import { setupTestFixture, teardownTestFixture, type TestFixture } from "movehat/helpers";
 
 describe("Counter Contract", () => {
-  let mh: MovehatRuntime;
-  let contractAddress: string;
+  let fixture: TestFixture<'counter'>;
 
   before(async function () {
-    this.timeout(30000);
+    this.timeout(60000); // Allow time for local node startup + deployment
 
-    // Initialize Movehat Runtime Environment
-    // Uses testnet by default - no local setup required
-    mh = await getMovehat();
+    // Setup local testing environment with auto-deployment
+    // This will:
+    // 1. Start a local Movement blockchain node
+    // 2. Generate and fund test accounts from local faucet
+    // 3. Auto-deploy the counter module
+    // 4. Return everything ready to use
+    //
+    // By default uses 'local-node' mode (full blockchain)
+    // For faster tests on existing state, pass { mode: 'fork' }
+    //
+    // Note: Use 'as const' for type inference
+    fixture = await setupTestFixture(['counter'] as const, ['alice', 'bob']);
 
-    contractAddress = mh.account.accountAddress.toString();
-
-    console.log(`\nTesting on ${mh.network.name}`);
-    console.log(`Account: ${contractAddress}\n`);
+    console.log(`\n✅ Testing on local blockchain`);
+    console.log(`   Deployer: ${fixture.accounts.deployer.accountAddress.toString()}`);
+    console.log(`   Alice: ${fixture.accounts.alice.accountAddress.toString()}`);
+    console.log(`   Bob: ${fixture.accounts.bob.accountAddress.toString()}\n`);
   });
 
   describe("Counter functionality", () => {
-    it("should initialize counter using simulation", async function () {
-      this.timeout(30000);
-
-      // Build transaction
-      const transaction = await mh.aptos.transaction.build.simple({
-        sender: mh.account.accountAddress,
-        data: {
-          function: `${contractAddress}::counter::init`,
-          functionArguments: []
-        }
-      });
-
-      // Simulate transaction (no gas cost, instant)
-      const [simulation] = await mh.aptos.transaction.simulate.simple({
-        signerPublicKey: mh.account.publicKey,
-        transaction
-      });
-
-      // Verify simulation succeeded
-      expect(simulation.success).to.be.true;
-      console.log(`Counter init simulated successfully`);
-      console.log(`Gas used: ${simulation.gas_used}`);
+    it("should initialize with value 0", async () => {
+      const counter = fixture.contracts.counter; // Type-safe, no `!` needed
+      const deployer = fixture.accounts.deployer;
+
+      // Read counter value (returns string from view function)
+      const value = await counter.view<string>("get", [
+        deployer.accountAddress.toString()
+      ]);
+
+      console.log(`   Counter value: ${value}`);
+
+      // Assert the counter is 0 (note: values from view are strings)
+      expect(parseInt(value)).to.equal(0);
+    });
+
+    it("should increment counter", async () => {
+      const counter = fixture.contracts.counter;
+      const deployer = fixture.accounts.deployer;
+
+      // Increment the counter
+      const tx = await counter.call(deployer, "increment", []);
+      console.log(`   Transaction: ${tx.hash}`);
+
+      // Read new value
+      const value = await counter.view<string>("get", [
+        deployer.accountAddress.toString()
+      ]);
+
+      console.log(`   New counter value: ${value}`);
+
+      // Should be 1 now
+      expect(parseInt(value)).to.equal(1);
+    });
+
+    it("alice can also increment counter", async () => {
+      const counter = fixture.contracts.counter;
+      const alice = fixture.accounts.alice;
+
+      // Alice increments her own counter
+      const tx = await counter.call(alice, "increment", []);
+      console.log(`   Alice's transaction: ${tx.hash}`);
+
+      // Read counter value for Alice (each user has their own counter)
+      const aliceValue = await counter.view<string>("get", [
+        alice.accountAddress.toString()
+      ]);
+
+      console.log(`   Alice's counter value: ${aliceValue}`);
+      expect(parseInt(aliceValue)).to.equal(1);
+
+      // Deployer's counter should still be 1 (unchanged)
+      const deployerValue = await counter.view<string>("get", [
+        fixture.accounts.deployer.accountAddress.toString()
+      ]);
+
+      console.log(`   Deployer's counter value: ${deployerValue}`);
+      expect(parseInt(deployerValue)).to.equal(1);
     });
 
-    it("should increment counter using simulation", async function () {
-      this.timeout(30000);
-
-      // Build increment transaction
-      const transaction = await mh.aptos.transaction.build.simple({
-        sender: mh.account.accountAddress,
-        data: {
-          function: `${contractAddress}::counter::increment`,
-          functionArguments: []
-        }
-      });
-
-      // Simulate transaction
-      const [simulation] = await mh.aptos.transaction.simulate.simple({
-        signerPublicKey: mh.account.publicKey,
-        transaction
-      });
-
-      // Verify simulation succeeded
-      expect(simulation.success).to.be.true;
-      console.log(`Counter increment simulated successfully`);
-      console.log(`Gas used: ${simulation.gas_used}`);
+    it("bob can also increment the counter", async () => {
+      const counter = fixture.contracts.counter;
+      const bob = fixture.accounts.bob;
+
+      // Bob increments his own counter
+      const tx = await counter.call(bob, "increment", []);
+      console.log(`   Bob's transaction: ${tx.hash}`);
+
+      // Read counter value for Bob (each user has their own counter)
+      const bobValue = await counter.view<string>("get", [
+        bob.accountAddress.toString()
+      ]);
+
+      console.log(`   Bob's counter value: ${bobValue}`);
+      expect(parseInt(bobValue)).to.equal(1);
     });
   });
-});
+
+  after(async () => {
+    // Cleanup: Stop local node and clear account pool
+    await teardownTestFixture();
+  });
+});

package/src/types/config.ts

@@ -33,4 +33,36 @@ export interface MovehatConfig {
     account: string;              // Account address (derived from privateKey)
     namedAddresses: Record<string, string>; // Merged named addresses
     networkConfig: NetworkConfig; // Full network configuration
+}
+
+/**
+ * Testing mode for local environment
+ */
+export type LocalTestingMode = 'local-node' | 'fork';
+
+/**
+ * Options for setting up local testing environment
+ */
+export interface LocalTestOptions {
+    mode?: LocalTestingMode;            // Testing mode: 'local-node' (full blockchain) or 'fork' (read-only snapshot) (default: 'local-node')
+
+    // Local Node options (when mode='local-node')
+    nodeTestDir?: string;               // Directory for node data (default: .movehat/local-node)
+    nodeForceRestart?: boolean;         // Clean node state and start fresh (default: true)
+    nodeFaucetPort?: number;            // Faucet port for local node (default: 8081)
+    nodeApiPort?: number;               // API/RPC port for local node (default: 8080)
+    nodeReadyPort?: number;             // Ready server port (default: 8070)
+    nodeSilent?: boolean;               // Suppress node output (default: false)
+
+    // Fork options (when mode='fork')
+    forkNetwork?: 'testnet' | string;   // Network to fork from (default: 'testnet')
+    forkName?: string;                  // Name for the fork (default: 'test-local')
+    forkPort?: number;                  // Fork server port (default: 8080)
+    forkResetState?: boolean;           // Clear fork state before tests (default: true)
+
+    // Common options (both modes)
+    autoFund?: boolean;                 // Auto-fund accounts (default: true)
+    defaultBalance?: number;            // Default balance in octas (default: 100_000_000 = 100 APT)
+    autoDeploy?: readonly string[];     // Modules to auto-deploy (accepts readonly arrays)
+    accountLabels?: readonly string[];  // Labels for pre-generated accounts (default: ['deployer', 'alice', 'bob'])
 }