movehat 0.1.9 → 0.2.0

package/src/__tests__/fixtures/sigint-deploy-harness.ts

@@ -0,0 +1,95 @@
+/**
+ * Stand-alone child-process harness for the SIGINT-cleanup test in
+ * `deployContract.test.ts`. Run via tsx by the parent test; never picked
+ * up by vitest's test glob (default matches `*.{test,spec}.?(c|m)[jt]s`).
+ *
+ * Behavior:
+ *   1. Build a fake ChildProcessAdapter whose `publish` step awaits a
+ *      long delay (3 seconds) — gives the parent test plenty of time to
+ *      send SIGINT mid-flight.
+ *   2. Drive `Publisher.deploy()` against the fake adapter using a
+ *      synthetic MovehatConfig + Account read from env vars.
+ *   3. Write the chosen `movehat-deploy-<uuid>` profile name to stdout
+ *      as JSON (`{"profile": "..."}`) before the slow publish so the
+ *      parent test knows which key to look for after SIGINT.
+ *   4. If the deploy completes naturally (test failure case), exit 0.
+ *   5. When SIGINT arrives, Publisher's signal handler runs synchronous
+ *      cleanup and `setImmediate(() => process.exit(130))`.
+ *
+ * The parent test does NOT import this file — it spawns it via
+ * `child_process.spawn(node, [tsx, harness, ...])` so the harness runs
+ * in its own process with its own signal-handler installation.
+ */
+
+import { Account, Ed25519PrivateKey } from "@aptos-labs/ts-sdk";
+import { Publisher } from "../../core/Publisher.js";
+import type {
+  ChildProcessAdapter,
+  RunInput,
+  RunResult,
+} from "../../utils/childProcessAdapter.js";
+import type { MovehatConfig } from "../../types/config.js";
+
+// Deterministic test key — must satisfy the Movement TypeScript SDK's Ed25519 parser.
+// Same key the testnet auto-config uses in `core/config.ts:147-155`.
+const TEST_PRIVATE_KEY =
+  "0x0000000000000000000000000000000000000000000000000000000000000001";
+
+async function main() {
+  const account = Account.fromPrivateKey({
+    privateKey: new Ed25519PrivateKey(TEST_PRIVATE_KEY),
+  });
+
+  const config: MovehatConfig = {
+    network: "testnet",
+    rpc: "https://testnet.invalid/v1",
+    privateKey: TEST_PRIVATE_KEY,
+    allAccounts: [TEST_PRIVATE_KEY],
+    profile: "default",
+    moveDir: "./move",
+    account: account.accountAddress.toString(),
+    namedAddresses: {},
+    networkConfig: {
+      url: "https://testnet.invalid/v1",
+      chainId: "testnet",
+    },
+  };
+
+  const slowPublishAdapter: ChildProcessAdapter = {
+    async run(input: RunInput): Promise<RunResult> {
+      if (input.args[1] === "build") {
+        return { exitCode: 0, stdout: "built", stderr: "" };
+      }
+      if (input.args[1] === "publish") {
+        // Surface the unique profile name to the parent BEFORE blocking.
+        const profileIdx = input.args.indexOf("--profile");
+        const profile = profileIdx >= 0 ? input.args[profileIdx + 1] : "";
+        process.stdout.write(JSON.stringify({ profile }) + "\n");
+        // Hold long enough for the parent to deliver SIGINT.
+        await new Promise((r) => setTimeout(r, 3000));
+        return {
+          exitCode: 0,
+          stdout: "Transaction hash: 0x" + "f".repeat(64),
+          stderr: "",
+        };
+      }
+      throw new Error(`unexpected subcommand: ${input.args[1]}`);
+    },
+    spawn() {
+      throw new Error("spawn not used");
+    },
+  };
+
+  const publisher = new Publisher({ adapter: slowPublishAdapter });
+  await publisher.deploy({
+    moduleName: "sigint_harness",
+    config,
+    account,
+    packageDir: process.cwd(),
+  });
+}
+
+main().catch((err) => {
+  process.stderr.write(`harness error: ${(err as Error).message}\n`);
+  process.exit(2);
+});

package/src/__tests__/fork/api.test.ts

@@ -0,0 +1,143 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ClientRequest, IncomingMessage } from "node:http";
+import { EventEmitter } from "node:events";
+
+/**
+ * Tests for `MovementApiClient` Authorization header injection (M2.4
+ * follow-up — wires the apiKey threading from `Harness.createFork`).
+ *
+ * Strategy: `vi.mock` `node:https` and `node:http` so the test
+ * captures the request options passed to `client.get(url, options, cb)`
+ * without making real network requests. Two assertions:
+ *
+ *   1. When the client is constructed with an apiKey, every `get`
+ *      call carries `Authorization: Bearer <apiKey>` in
+ *      `options.headers`.
+ *   2. When constructed without an apiKey, no Authorization header
+ *      is added (back-compat for unauthenticated public endpoints).
+ */
+
+const httpsGet = vi.fn();
+const httpGet = vi.fn();
+
+vi.mock("https", () => ({
+  default: { get: httpsGet },
+  get: httpsGet,
+}));
+vi.mock("http", () => ({
+  default: { get: httpGet },
+  get: httpGet,
+}));
+
+/**
+ * Build a fake `IncomingMessage`-like emitter that immediately emits
+ * a valid JSON body and ends. The MovementApiClient.get callback
+ * consumes the response via `data` / `end` events.
+ */
+function makeFakeResponse(body: string, statusCode = 200): IncomingMessage {
+  const res = new EventEmitter() as unknown as IncomingMessage;
+  (res as unknown as { statusCode: number }).statusCode = statusCode;
+  // Use setImmediate so the listener attaches before the events fire.
+  setImmediate(() => {
+    (res as unknown as EventEmitter).emit("data", body);
+    (res as unknown as EventEmitter).emit("end");
+  });
+  return res;
+}
+
+/**
+ * Capture the options arg from `client.get(url, options, callback)`
+ * and immediately resolve with a fake successful ledger-info response.
+ * Returns the captured options for assertion.
+ */
+function setupGetCapture(): {
+  captured: { url?: string; options?: { headers?: Record<string, string> } };
+} {
+  const captured: {
+    url?: string;
+    options?: { headers?: Record<string, string> };
+  } = {};
+
+  const handler = (
+    url: string,
+    options:
+      | { headers?: Record<string, string> }
+      | ((res: IncomingMessage) => void),
+    cb?: (res: IncomingMessage) => void
+  ): ClientRequest => {
+    captured.url = url;
+    // Distinguish (url, callback) vs (url, options, callback) overloads.
+    let callback: ((res: IncomingMessage) => void) | undefined;
+    if (typeof options === "function") {
+      callback = options;
+    } else {
+      captured.options = options;
+      callback = cb;
+    }
+
+    const fakeReq = new EventEmitter() as unknown as ClientRequest;
+    (fakeReq as unknown as { end: () => void }).end = () => {};
+
+    if (callback) {
+      const body = JSON.stringify({
+        chain_id: 250,
+        ledger_version: "1",
+        ledger_timestamp: "0",
+        epoch: "0",
+        block_height: "0",
+      });
+      callback(makeFakeResponse(body));
+    }
+    return fakeReq;
+  };
+
+  httpsGet.mockImplementation(handler);
+  httpGet.mockImplementation(handler);
+
+  return { captured };
+}
+
+describe("MovementApiClient — Authorization header (apiKey wiring)", () => {
+  beforeEach(() => {
+    httpsGet.mockReset();
+    httpGet.mockReset();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("injects 'Authorization: Bearer <apiKey>' when constructed with an apiKey", async () => {
+    const { captured } = setupGetCapture();
+
+    const { MovementApiClient } = await import("../../fork/api.js");
+    const client = new MovementApiClient(
+      "https://testnet.example.com/v1",
+      "secret-key-123"
+    );
+
+    await client.getLedgerInfo();
+
+    expect(captured.url).toBe("https://testnet.example.com/v1/");
+    expect(captured.options).toBeDefined();
+    expect(captured.options?.headers).toEqual({
+      Authorization: "Bearer secret-key-123",
+    });
+    expect(httpsGet).toHaveBeenCalledTimes(1);
+  });
+
+  it("omits the Authorization header when constructed without an apiKey (back-compat)", async () => {
+    const { captured } = setupGetCapture();
+
+    const { MovementApiClient } = await import("../../fork/api.js");
+    const client = new MovementApiClient("https://testnet.example.com/v1");
+
+    await client.getLedgerInfo();
+
+    expect(captured.url).toBe("https://testnet.example.com/v1/");
+    if (captured.options !== undefined) {
+      expect(captured.options.headers).toBeUndefined();
+    }
+    expect(httpsGet).toHaveBeenCalledTimes(1);
+  });
+});

package/src/__tests__/harness/Harness.createLive.test.ts

@@ -0,0 +1,57 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { Harness } from "../../harness/index.js";
+import { setupHarnessTestFixture, type HarnessTestFixture } from "./_fixture.js";
+
+describe("Harness.createLive", () => {
+  let fixture: HarnessTestFixture;
+
+  beforeEach(() => {
+    fixture = setupHarnessTestFixture({
+      extraNetworks: {
+        custom: {
+          url: "https://custom.example.com/v1",
+          chainId: "custom",
+          accounts: ["0x" + "a".repeat(64)],
+        },
+      },
+    });
+  });
+
+  afterEach(() => {
+    fixture.teardown();
+  });
+
+  it("returns a Harness bound to the requested network with mode='live'", async () => {
+    const harness = await Harness.createLive("testnet");
+    try {
+      expect(harness.mode).toBe("live");
+      expect(harness.runtime).toBeDefined();
+      expect(harness.runtime.network.name).toBe("testnet");
+      expect(harness.runtime.network.rpc).toContain("testnet.movementnetwork.xyz");
+      // createLive does not own a local node or fork server.
+      expect(harness.localNode).toBeUndefined();
+      expect(harness.forkServer).toBeUndefined();
+      expect(harness.forkManager).toBeUndefined();
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("can switch networks via the first argument", async () => {
+    const harness = await Harness.createLive("custom");
+    try {
+      expect(harness.runtime.network.name).toBe("custom");
+      expect(harness.runtime.network.rpc).toContain("custom.example.com");
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("cleanup() is a no-op for createLive (no owned services) but still poisons", async () => {
+    const harness = await Harness.createLive("testnet");
+    expect(harness.poisoned).toBe(false);
+    await harness.cleanup();
+    expect(harness.poisoned).toBe(true);
+  });
+});

package/src/__tests__/harness/Harness.proxy.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { Harness, HarnessDisposedError } from "../../harness/index.js";
+import { setupHarnessTestFixture, type HarnessTestFixture } from "./_fixture.js";
+
+/**
+ * Proxy poisoning is the load-bearing safety guarantee of M2: once a
+ * Harness has been cleaned up, any further deploy / view / script /
+ * upgrade call must throw `HarnessDisposedError` synchronously on
+ * property access — not after the awaited method body. These tests
+ * lock that contract.
+ *
+ * Uses `Harness.createLive(network)` because it does not spawn a real
+ * Movement node — `initRuntime` only constructs the SDK client (no RPC
+ * round-trip) from the fixture config. `createLocal` / `createFork`
+ * runtime tests live in the M4 integration suite where spinning a real
+ * node is acceptable.
+ */
+describe("Harness — proxy poisoning", () => {
+  let fixture: HarnessTestFixture;
+
+  beforeEach(() => {
+    fixture = setupHarnessTestFixture();
+  });
+
+  afterEach(() => {
+    fixture.teardown();
+  });
+
+  it("cleanup() flips poisoned to true", async () => {
+    const harness = await Harness.createLive("testnet");
+    expect(harness.poisoned).toBe(false);
+    await harness.cleanup();
+    expect(harness.poisoned).toBe(true);
+  });
+
+  it("cleanup() is idempotent", async () => {
+    const harness = await Harness.createLive("testnet");
+    await harness.cleanup();
+    // Second call must not throw and must leave the harness poisoned.
+    await expect(harness.cleanup()).resolves.toBeUndefined();
+    expect(harness.poisoned).toBe(true);
+  });
+
+  it("post-cleanup, deployCodeObject throws HarnessDisposedError synchronously on property access", async () => {
+    const harness = await Harness.createLive("testnet");
+    await harness.cleanup();
+
+    // Property access itself throws — the call site never gets a Promise back.
+    // The args ({moduleName: "x"}) typecheck but never execute (the get trap
+    // fires before the method body runs).
+    expect(() => harness.deployCodeObject({ moduleName: "x" })).toThrow(
+      HarnessDisposedError
+    );
+  });
+
+  it("post-cleanup, upgradeCodeObject / runViewFunction / runMoveScript all throw HarnessDisposedError synchronously", async () => {
+    const harness = await Harness.createLive("testnet");
+    await harness.cleanup();
+
+    expect(() =>
+      harness.upgradeCodeObject({ moduleName: "x", objectAddress: "0x1" })
+    ).toThrow(HarnessDisposedError);
+    expect(() =>
+      harness.runViewFunction({ function: "0x1::m::f" })
+    ).toThrow(HarnessDisposedError);
+    expect(() =>
+      harness.runMoveScript({ scriptPath: "irrelevant.move" })
+    ).toThrow(HarnessDisposedError);
+  });
+
+  it("HarnessDisposedError carries the offending method name", async () => {
+    const harness = await Harness.createLive("testnet");
+    await harness.cleanup();
+
+    let captured: unknown;
+    try {
+      harness.deployCodeObject({ moduleName: "x" });
+    } catch (err) {
+      captured = err;
+    }
+    expect(captured).toBeInstanceOf(HarnessDisposedError);
+    expect((captured as HarnessDisposedError).methodName).toBe("deployCodeObject");
+  });
+
+  it("post-cleanup, metadata accessors (mode, poisoned, runtime) still work", async () => {
+    const harness = await Harness.createLive("testnet");
+    await harness.cleanup();
+
+    // None of these should throw — only the 4 poisoned methods do.
+    expect(harness.mode).toBe("live");
+    expect(harness.poisoned).toBe(true);
+    expect(harness.runtime).toBeDefined();
+  });
+
+  // The M2.3-era "stubs reject" assertion was retired when M2.3 shipped
+  // real bodies for runViewFunction and runMoveScript. All four methods
+  // now have dedicated test suites (codeObject.deploy/upgrade.test.ts,
+  // view.test.ts, script.test.ts).
+
+  it("await harness.someAsyncMethod() pattern: post-cleanup throw happens before await", async () => {
+    const harness = await Harness.createLive("testnet");
+    await harness.cleanup();
+
+    // The error is synchronous (property access), but the typical caller
+    // shape uses await. Confirm that pattern surfaces the error too.
+    let captured: unknown;
+    try {
+      await harness.deployCodeObject({ moduleName: "x" });
+    } catch (err) {
+      captured = err;
+    }
+    expect(captured).toBeInstanceOf(HarnessDisposedError);
+  });
+});

package/src/__tests__/harness/_fixture.ts

@@ -0,0 +1,131 @@
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { _resetConfigCache } from "../../core/config.js";
+
+/**
+ * Shared test fixture for Harness tests.
+ *
+ * Six test files in `__tests__/harness/` all needed the same setup
+ * boilerplate (~30 LoC each) before this helper landed: tmpdir for
+ * cwd, write a `movehat.config.js`, write a minimal Move package
+ * (`move/Move.toml` + `move/sources/dummy.move`), chdir, reset the
+ * mtime-based config cache, manage HOME for tests that exercise
+ * `~/.aptos/config.yaml` profile management. Extracted as a single
+ * helper to eliminate the drift surface across siblings.
+ *
+ * The defaults match the most common test shape: a single `testnet`
+ * network and no HOME management. Tests that need more (a `custom`
+ * network for switching, an isolated HOME for profile tests) opt in
+ * via the options.
+ *
+ * @internal — not exported from `src/index.ts`. Test-only.
+ */
+
+/**
+ * Additional networks to merge into the fixture's `movehat.config.js`.
+ * Keyed by network name. Each network needs `url` + `chainId` at
+ * minimum; pass `accounts` when the test exercises a code path that
+ * requires explicit account configuration (e.g. mainnet-like security
+ * checks in `resolveNetworkConfig`).
+ */
+export interface ExtraNetwork {
+  url: string;
+  chainId: string;
+  accounts?: string[];
+}
+
+export interface HarnessTestFixtureOptions {
+  /** Additional networks merged on top of the default `testnet` entry. */
+  extraNetworks?: Record<string, ExtraNetwork>;
+
+  /**
+   * When `true`, manage a separate `process.env.HOME` directory for
+   * the test. Used by tests that exercise `~/.aptos/config.yaml`
+   * profile writes (codeObject.* and script.* test suites).
+   */
+  withTmpHome?: boolean;
+}
+
+export interface HarnessTestFixture {
+  /** Fresh per-test cwd. The test is chdir'd here. */
+  tmpCwd: string;
+  /** Fresh per-test HOME, only set when `withTmpHome: true`. */
+  tmpHome?: string;
+  /** Restore cwd + HOME, remove the tmp dirs, and reset config cache. */
+  teardown: () => void;
+}
+
+/**
+ * Build a fresh per-test fixture. Call from `beforeEach`, capture the
+ * returned object, and call `fixture.teardown()` in `afterEach`.
+ */
+export function setupHarnessTestFixture(
+  options: HarnessTestFixtureOptions = {}
+): HarnessTestFixture {
+  const tmpCwd = mkdtempSync(join(tmpdir(), "movehat-harness-test-"));
+  const tmpHome = options.withTmpHome
+    ? mkdtempSync(join(tmpdir(), "movehat-harness-home-"))
+    : undefined;
+
+  // Build the network map. Default `testnet` + caller's extras.
+  const networks: Record<string, ExtraNetwork> = {
+    testnet: {
+      url: "https://testnet.movementnetwork.xyz/v1",
+      chainId: "testnet",
+    },
+    ...(options.extraNetworks ?? {}),
+  };
+
+  writeFileSync(
+    join(tmpCwd, "movehat.config.js"),
+    `export default {
+  defaultNetwork: "testnet",
+  networks: ${JSON.stringify(networks, null, 2)}
+};
+`
+  );
+
+  // Minimal Move package — `extractNamedAddresses` reads from
+  // `<moveDir>/sources/*.move`; an empty file yields an empty Set.
+  const moveDir = join(tmpCwd, "move");
+  mkdirSync(join(moveDir, "sources"), { recursive: true });
+  writeFileSync(
+    join(moveDir, "Move.toml"),
+    `[package]
+name = "dummy"
+version = "0.0.1"
+
+[addresses]
+`
+  );
+  writeFileSync(join(moveDir, "sources", "dummy.move"), "// intentionally empty\n");
+
+  const origCwd = process.cwd();
+  const origHome = process.env.HOME;
+  process.chdir(tmpCwd);
+  if (tmpHome !== undefined) process.env.HOME = tmpHome;
+  _resetConfigCache();
+
+  const teardown = () => {
+    try {
+      process.chdir(origCwd);
+    } finally {
+      if (options.withTmpHome) {
+        if (origHome === undefined) delete process.env.HOME;
+        else process.env.HOME = origHome;
+        if (tmpHome !== undefined && existsSync(tmpHome)) {
+          rmSync(tmpHome, { recursive: true, force: true });
+        }
+      }
+      if (existsSync(tmpCwd)) {
+        rmSync(tmpCwd, { recursive: true, force: true });
+      }
+      _resetConfigCache();
+    }
+  };
+
+  const fixture: HarnessTestFixture = { tmpCwd, teardown };
+  if (tmpHome !== undefined) fixture.tmpHome = tmpHome;
+  return fixture;
+}