movehat 0.2.4 → 0.2.5

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

@@ -1,148 +0,0 @@
-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 —
- * verifies 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 = () => {};
-    // F3: api.ts now installs a setTimeout on the request and may call
-    // destroy() on overflow / timeout. Stub both so this happy-path
-    // capture mock still satisfies the new contract.
-    (fakeReq as unknown as { setTimeout: (ms: number, cb?: () => void) => void }).setTimeout = () => {};
-    (fakeReq as unknown as { destroy: () => void }).destroy = () => {};
-
-    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__/fork/api.timeout.test.ts

@@ -1,150 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { ClientRequest, IncomingMessage } from "node:http";
-import { EventEmitter } from "node:events";
-
-/**
- * F3 — MovementApiClient must bound responses by time AND bytes.
- *
- * Without these guards a malicious / hung upstream can:
- *   - leak the request promise forever (never emits 'end'), or
- *   - exhaust heap by pushing unbounded `data` chunks.
- *
- * Strategy mirrors src/__tests__/fork/api.test.ts: vi.mock node:http
- * and node:https, intercept `client.get(url, options, cb)`, and feed
- * a controllable `IncomingMessage` to the callback. The fake
- * `ClientRequest` exposes `setTimeout`, `destroy`, and emits 'error' /
- * 'timeout' so we can drive the failure modes from the test.
- */
-
-interface FakeReq extends EventEmitter {
-  end(): void;
-  destroy(err?: Error): void;
-  setTimeout(ms: number, cb?: () => void): void;
-  destroyed: boolean;
-}
-
-const httpsGet = vi.fn();
-const httpGet = vi.fn();
-
-vi.mock("https", () => ({ default: { get: httpsGet }, get: httpsGet }));
-vi.mock("http", () => ({ default: { get: httpGet }, get: httpGet }));
-
-function makeFakeReq(): FakeReq {
-  const req = new EventEmitter() as FakeReq;
-  req.destroyed = false;
-  let timeoutHandle: NodeJS.Timeout | undefined;
-  req.end = () => {};
-  req.destroy = (err?: Error) => {
-    req.destroyed = true;
-    if (timeoutHandle) clearTimeout(timeoutHandle);
-    setImmediate(() => req.emit("error", err ?? new Error("destroyed")));
-  };
-  req.setTimeout = (ms: number, cb?: () => void) => {
-    timeoutHandle = setTimeout(() => {
-      req.emit("timeout");
-      if (cb) cb();
-    }, ms);
-    // Don't keep the event loop alive — Node sets this itself but the
-    // mock has no native socket to inherit from.
-    timeoutHandle.unref?.();
-  };
-  return req;
-}
-
-function makeUnresolvableResponse(): IncomingMessage {
-  const res = new EventEmitter() as unknown as IncomingMessage;
-  (res as unknown as { statusCode: number }).statusCode = 200;
-  return res;
-}
-
-function makeStreamingResponse(
-  bytesPerChunk: number,
-  chunks: number
-): IncomingMessage {
-  const res = new EventEmitter() as unknown as IncomingMessage;
-  (res as unknown as { statusCode: number }).statusCode = 200;
-  setImmediate(() => {
-    let i = 0;
-    const pump = () => {
-      if (i >= chunks) {
-        (res as unknown as EventEmitter).emit("end");
-        return;
-      }
-      (res as unknown as EventEmitter).emit(
-        "data",
-        Buffer.alloc(bytesPerChunk, 0x61)
-      );
-      i++;
-      setImmediate(pump);
-    };
-    pump();
-  });
-  return res;
-}
-
-describe("F3 — MovementApiClient timeouts and byte cap", () => {
-  beforeEach(() => {
-    httpsGet.mockReset();
-    httpGet.mockReset();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("rejects with a timeout error when the upstream never responds", async () => {
-    const fakeReq = makeFakeReq();
-    httpGet.mockImplementation(
-      (
-        _url: string,
-        options: unknown,
-        cb?: (res: IncomingMessage) => void
-      ) => {
-        const callback =
-          typeof options === "function"
-            ? (options as (r: IncomingMessage) => void)
-            : cb;
-        if (callback) callback(makeUnresolvableResponse());
-        return fakeReq as unknown as ClientRequest;
-      }
-    );
-
-    const { MovementApiClient } = await import("../../fork/api.js");
-    const client = new MovementApiClient("http://hung.example/v1", undefined, {
-      timeoutMs: 25,
-      maxBytes: 1024 * 1024,
-    });
-
-    await expect(client.getLedgerInfo()).rejects.toThrow(/timed out|timeout/i);
-    expect(fakeReq.destroyed).toBe(true);
-  });
-
-  it("rejects and destroys the request when the response exceeds maxBytes", async () => {
-    const fakeReq = makeFakeReq();
-    httpGet.mockImplementation(
-      (
-        _url: string,
-        options: unknown,
-        cb?: (res: IncomingMessage) => void
-      ) => {
-        const callback =
-          typeof options === "function"
-            ? (options as (r: IncomingMessage) => void)
-            : cb;
-        if (callback) callback(makeStreamingResponse(2048, 100));
-        return fakeReq as unknown as ClientRequest;
-      }
-    );
-
-    const { MovementApiClient } = await import("../../fork/api.js");
-    const client = new MovementApiClient("http://big.example/v1", undefined, {
-      timeoutMs: 5000,
-      maxBytes: 4096,
-    });
-
-    await expect(client.getLedgerInfo()).rejects.toThrow(
-      /maxBytes|too large|exceeded/i
-    );
-    expect(fakeReq.destroyed).toBe(true);
-  });
-});

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

@@ -1,57 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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 the Harness:
- * once 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 integration suite.
- */
-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();
-  });
-
-  // Dedicated suites exist for each of the four methods
-  // (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

@@ -1,131 +0,0 @@
-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;
-}