tinyspy 3.0.2: restoreAll

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify tinyspy.restoreAll in pkg:npm/tinyspy@3.0.2
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/tinyspy@3.0.2
Demonstrate these symbols/APIs:
  - tinyspy.restoreAll

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:724f858cecd360b0450ce7bff0b2f16883fe86880a7b86634901203789a3ac45","contract":["restoreAll restores spied object methods to their original implementation","restoreAll restores getter properties spied on objects to their original getters","restoreAll restores setter properties spied on objects to their original setters","restoreAll clears all active spies from the global spies set","restoreAll is idempotent and safe to invoke when no spies are active","restoreAll restores multiple spied methods across different objects","restoreAll restores methods defined on a class prototype","restoreAll safely ignores spies that were already manually restored","restoreAll does not alter or reset standalone spies created with spy"],"goal":"verify tinyspy.restoreAll in pkg:npm/tinyspy@3.0.2","kind":"HOW","packages":["pkg:npm/tinyspy@3.0.2"],"schemaVersion":1,"symbols":["tinyspy.restoreAll"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"esm","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/tinyspy@3.0.2"],"schemaVersion":1,"subject":"pkg:npm/tinyspy@3.0.2","symbols":["tinyspy.restoreAll"],"verifierAdapter":"node-typescript@1"}

{
  "name": "sample-tinyspy-restore-all",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-tinyspy-restore-all",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "tinyspy": "3.0.2"
      }
    },
    "node_modules/tinyspy": {
      "version": "3.0.2",
      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz",
      "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==",
      "license": "MIT",
      "engines": {
        "node": ">=14.0.0"
      }
    }
  }
}

{
  "name": "sample-tinyspy-restore-all",
  "version": "1.0.0",
  "type": "module",
  "private": true,
  "description": "Clean-room verification for tinyspy.restoreAll in tinyspy@3.0.2",
  "main": "test/contract.mjs",
  "scripts": {
    "test": "node test/contract.mjs"
  },
  "dependencies": {
    "tinyspy": "3.0.2"
  },
  "license": "MIT-0"
}

{
  "schemaVersion": 1,
  "goal": "verify tinyspy.restoreAll in pkg:npm/tinyspy@3.0.2",
  "kind": "HOW",
  "packages": [
    "pkg:npm/tinyspy@3.0.2"
  ],
  "symbols": [
    "tinyspy.restoreAll"
  ]
}

import assert from "node:assert";
import { spyOn, restoreAll, spies, spy } from "tinyspy";

async function runContract() {
  // 1. restoreAll restores spied object methods to their original implementation
  const service = {
    calculate(x) {
      return x * 2;
    }
  };
  const calcSpy = spyOn(service, "calculate", (x) => x + 100);
  assert.strictEqual(service.calculate(5), 105, "spied method should execute spy implementation");
  assert.strictEqual(calcSpy.callCount, 1, "calcSpy callCount should be 1");
  restoreAll();
  assert.strictEqual(service.calculate(5), 10, "service.calculate should revert to original implementation");
  assert.strictEqual(calcSpy.callCount, 1, "calcSpy should not receive subsequent calls after restoreAll");

  // 2. restoreAll restores getter properties spied on objects to their original getters
  const config = {
    _val: "real-config",
    get setting() {
      return this._val;
    }
  };
  const getterSpy = spyOn(config, { getter: "setting" }, () => "mocked-config");
  assert.strictEqual(config.setting, "mocked-config", "spied getter should return mocked value");
  assert.strictEqual(getterSpy.callCount, 1, "getterSpy callCount should be 1");
  restoreAll();
  assert.strictEqual(config.setting, "real-config", "config.setting should return original getter value");
  assert.strictEqual(getterSpy.callCount, 1, "getterSpy should not receive subsequent calls after restoreAll");

  // 3. restoreAll restores setter properties spied on objects to their original setters
  const store = {
    _saved: "",
    set item(v) {
      this._saved = v;
    }
  };
  const setterSpy = spyOn(store, { setter: "item" });
  store.item = "first";
  assert.strictEqual(setterSpy.callCount, 1, "setterSpy callCount should be 1");
  assert.strictEqual(store._saved, "first", "original setter behavior preserved during spy");
  restoreAll();
  store.item = "second";
  assert.strictEqual(setterSpy.callCount, 1, "setterSpy should not be called after restoreAll");
  assert.strictEqual(store._saved, "second", "original setter should update value after restoreAll");

  // 4. restoreAll clears all active spies from the global spies set
  const dummy1 = { run() { return 1; } };
  const dummy2 = { run() { return 2; } };
  spyOn(dummy1, "run");
  spyOn(dummy2, "run");
  assert.strictEqual(spies.size, 2, "spies set should contain 2 entries before restoreAll");
  restoreAll();
  assert.strictEqual(spies.size, 0, "spies set should be empty after restoreAll");

  // 5. restoreAll is idempotent and safe to invoke when no spies are active
  assert.strictEqual(spies.size, 0, "spies set should initially be 0");
  assert.doesNotThrow(() => restoreAll(), "calling restoreAll with no spies should not throw");
  assert.doesNotThrow(() => restoreAll(), "consecutive restoreAll calls should not throw");
  assert.strictEqual(spies.size, 0, "spies set should remain empty");

  // 6. restoreAll restores multiple spied methods across different objects
  const objA = { greet: (name) => `hi ${name}` };
  const objB = { farewell: (name) => `bye ${name}` };
  const spyA = spyOn(objA, "greet", () => "mockA");
  const spyB = spyOn(objB, "farewell", () => "mockB");
  assert.strictEqual(objA.greet("alice"), "mockA");
  assert.strictEqual(objB.farewell("alice"), "mockB");
  restoreAll();
  assert.strictEqual(objA.greet("alice"), "hi alice", "objA.greet should be restored");
  assert.strictEqual(objB.farewell("alice"), "bye alice", "objB.farewell should be restored");

  // 7. restoreAll restores methods defined on a class prototype
  class WorkerService {
    doTask(task) {
      return `completed:${task}`;
    }
  }
  const worker = new WorkerService();
  const protoSpy = spyOn(worker, "doTask", () => "mock-task");
  assert.strictEqual(worker.doTask("job1"), "mock-task", "instance method spy should intercept calls");
  assert.strictEqual(protoSpy.callCount, 1);
  restoreAll();
  assert.strictEqual(worker.doTask("job1"), "completed:job1", "prototype method should be restored");
  assert.strictEqual(protoSpy.callCount, 1, "protoSpy should not be called after restoreAll");

  // 8. restoreAll safely ignores spies that were already manually restored
  const target = { execute: () => "original" };
  const execSpy = spyOn(target, "execute", () => "mock");
  assert.strictEqual(target.execute(), "mock");
  execSpy.restore();
  assert.strictEqual(target.execute(), "original", "manually restored function should return original");
  assert.strictEqual(spies.size, 1, "manually restored spy remains in global set until restoreAll");
  assert.doesNotThrow(() => restoreAll(), "restoreAll should handle already restored spy without error");
  assert.strictEqual(spies.size, 0, "spies set should be cleared");
  assert.strictEqual(target.execute(), "original", "function remains restored");

  // 9. restoreAll does not alter or reset standalone spies created with spy
  const standalone = spy((n) => n * 3);
  assert.strictEqual(standalone(4), 12);
  assert.strictEqual(standalone.callCount, 1);
  restoreAll();
  assert.strictEqual(standalone.callCount, 1, "standalone spy callCount unchanged by restoreAll");
  assert.strictEqual(standalone(5), 15);
  assert.strictEqual(standalone.callCount, 2, "standalone spy functions normally after restoreAll");

  console.log("Contract verified successfully.");
}

runContract().catch((err) => {
  console.error("Contract failed:", err);
  process.exit(1);
});