@forwardimpact/libmock 0.1.7 → 0.1.10

package/LICENSE

@@ -1,201 +1,21 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to the Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2026 Dick Olsson
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+MIT License
+
+Copyright (c) 2019 Zachary Rice
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/libmock",
-  "version": "0.1.7",
+  "version": "0.1.10",
   "description": "Shared mocks and test fixtures so every library and service tests the same way.",
   "keywords": [
     "test",
@@ -22,7 +22,8 @@
     ".": "./src/index.js",
     "./mock": "./src/mock/index.js",
     "./fixture": "./src/fixture/index.js",
-    "./runtime": "./src/runtime.js"
+    "./runtime": "./src/runtime.js",
+    "./expect": "./src/expect/index.js"
   },
   "files": [
     "src/**/*.js",
@@ -31,6 +32,9 @@
   "scripts": {
     "test": "bun test test/*.test.js"
   },
+  "dependencies": {
+    "@grpc/grpc-js": "^1.14.4"
+  },
   "peerDependencies": {
     "@forwardimpact/libtype": "*"
   },

package/src/expect/index.js

@@ -0,0 +1,476 @@
+/**
+ * Dependency-free, runner-independent `expect()` shim. Replaces `expect` from
+ * `bun:test` so the test suite can run under `node --test` (which ships no
+ * `expect`) as well as `bun test`. Mirrors how `spy()` replaced `mock.fn`.
+ *
+ * Covers exactly the matcher surface the converged test files use: `toBe`,
+ * `toEqual`, `toMatchObject`, `toBeNull`, `toBeUndefined`, `toBeDefined`,
+ * `toBeTruthy`, `toBeGreaterThan`, `toBeGreaterThanOrEqual`,
+ * `toBeLessThanOrEqual`, `toHaveLength`, `toContain`, `toMatch`, `toThrow`,
+ * plus the `.not`, `.resolves`, and `.rejects` chain modifiers.
+ *
+ * Imports only from the Node standard library.
+ */
+
+import { AssertionError } from "node:assert";
+import { isDeepStrictEqual } from "node:util";
+
+/**
+ * Render a value for assertion messages without throwing on circular refs.
+ * @param {unknown} value - Value to stringify.
+ * @returns {string} Human-readable rendering.
+ */
+function show(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "bigint") {
+    return `${value}n`;
+  }
+  if (value instanceof Map) {
+    return `Map(${value.size})`;
+  }
+  if (value instanceof Set) {
+    return `Set(${value.size})`;
+  }
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+
+/**
+ * Throw or, when negated, swallow — the single choke point that makes `.not`
+ * invert every matcher. `pass` is the un-negated truth of the assertion.
+ * @param {boolean} pass - Whether the positive assertion holds.
+ * @param {boolean} negated - Whether `.not` is active.
+ * @param {string} message - Message for the failing (positive) direction.
+ * @param {string} [negatedMessage] - Message for the failing negated direction.
+ */
+function settle(pass, negated, message, negatedMessage) {
+  if (negated) {
+    if (pass) {
+      throw new AssertionError({
+        message: negatedMessage ?? `not: ${message}`,
+      });
+    }
+    return;
+  }
+  if (!pass) {
+    throw new AssertionError({ message });
+  }
+}
+
+const ASYMMETRIC = Symbol.for("libmock.expect.asymmetric");
+
+/**
+ * Whether `value` is an asymmetric matcher produced by `expect.any` / friends.
+ * @param {unknown} value - Candidate.
+ * @returns {boolean} True when `value` carries the asymmetric marker.
+ */
+function isAsymmetric(value) {
+  return (
+    value != null && typeof value === "object" && value[ASYMMETRIC] === true
+  );
+}
+
+/**
+ * Structural equality that understands asymmetric matchers (`expect.any`).
+ * Falls back to `node:util.isDeepStrictEqual` when neither side carries one.
+ * @param {unknown} actual - Observed value.
+ * @param {unknown} expected - Expected value, possibly an asymmetric matcher.
+ * @returns {boolean} Whether they match.
+ */
+function equals(actual, expected) {
+  if (isAsymmetric(expected)) {
+    return expected.asymmetricMatch(actual);
+  }
+  if (expected === null || typeof expected !== "object") {
+    return Object.is(actual, expected) || isDeepStrictEqual(actual, expected);
+  }
+  if (actual === null || typeof actual !== "object") {
+    return false;
+  }
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual) || actual.length !== expected.length) {
+      return false;
+    }
+    return expected.every((e, i) => equals(actual[i], e));
+  }
+  // No asymmetric matcher anywhere → exact deep equality is correct and cheap.
+  if (!containsAsymmetric(expected)) {
+    return isDeepStrictEqual(actual, expected);
+  }
+  const keys = Object.keys(expected);
+  if (keys.length !== Object.keys(actual).length) {
+    return false;
+  }
+  return keys.every((k) => equals(actual[k], expected[k]));
+}
+
+/**
+ * Whether an expected value tree contains any asymmetric matcher.
+ * @param {unknown} value - Tree to scan.
+ * @returns {boolean} True if an asymmetric matcher is present.
+ */
+function containsAsymmetric(value) {
+  if (isAsymmetric(value)) {
+    return true;
+  }
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return value.some(containsAsymmetric);
+  }
+  return Object.values(value).some(containsAsymmetric);
+}
+
+/**
+ * Deep subset match: every own enumerable key of `subset` matches the same key
+ * in `actual` (recursively for plain objects, asymmetric-aware).
+ * @param {unknown} actual - Candidate object.
+ * @param {unknown} subset - Expected subset.
+ * @returns {boolean} Whether `actual` contains `subset`.
+ */
+function matchesObject(actual, subset) {
+  if (isAsymmetric(subset)) {
+    return subset.asymmetricMatch(actual);
+  }
+  if (subset === null || typeof subset !== "object") {
+    return equals(actual, subset);
+  }
+  if (actual === null || typeof actual !== "object") {
+    return false;
+  }
+  for (const key of Object.keys(subset)) {
+    const sv = subset[key];
+    const av = actual[key];
+    if (
+      sv !== null &&
+      typeof sv === "object" &&
+      !Array.isArray(sv) &&
+      !isAsymmetric(sv)
+    ) {
+      if (!matchesObject(av, sv)) {
+        return false;
+      }
+    } else if (!equals(av, sv)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Run a possibly-throwing function and apply the `toThrow` predicate.
+ * @param {() => unknown} fn - The thunk under test.
+ * @param {unknown} matcher - undefined, a string (substring), or a RegExp.
+ * @param {boolean} negated - Whether `.not` is active.
+ */
+function assertThrow(fn, matcher, negated) {
+  if (typeof fn !== "function") {
+    throw new AssertionError({
+      message: `toThrow expects a function, got ${show(fn)}`,
+    });
+  }
+  let thrown;
+  let didThrow = false;
+  try {
+    fn();
+  } catch (err) {
+    didThrow = true;
+    thrown = err;
+  }
+  if (!didThrow) {
+    settle(false, negated, "expected function to throw, but it did not");
+    return;
+  }
+  const message = thrown instanceof Error ? thrown.message : String(thrown);
+  let pass = true;
+  if (typeof matcher === "string") {
+    pass = message.includes(matcher);
+  } else if (matcher instanceof RegExp) {
+    pass = matcher.test(message);
+  }
+  settle(
+    pass,
+    negated,
+    `expected thrown message ${show(message)} to match ${show(matcher)}`,
+    `expected thrown message ${show(message)} not to match ${show(matcher)}`,
+  );
+}
+
+/**
+ * Build the synchronous matcher object for an already-resolved actual value.
+ * @param {unknown} actual - The value under test.
+ * @param {boolean} negated - Whether `.not` is active.
+ * @returns {object} Matcher object.
+ */
+function matchers(actual, negated) {
+  return {
+    get not() {
+      return matchers(actual, !negated);
+    },
+    toBe(expected) {
+      settle(
+        Object.is(actual, expected),
+        negated,
+        `expected ${show(actual)} to be ${show(expected)}`,
+        `expected ${show(actual)} not to be ${show(expected)}`,
+      );
+    },
+    toEqual(expected) {
+      settle(
+        equals(actual, expected),
+        negated,
+        `expected ${show(actual)} to deep-equal ${show(expected)}`,
+        `expected ${show(actual)} not to deep-equal ${show(expected)}`,
+      );
+    },
+    toMatchObject(expected) {
+      settle(
+        matchesObject(actual, expected),
+        negated,
+        `expected ${show(actual)} to match object ${show(expected)}`,
+        `expected ${show(actual)} not to match object ${show(expected)}`,
+      );
+    },
+    toBeNull() {
+      settle(
+        actual === null,
+        negated,
+        `expected ${show(actual)} to be null`,
+        `expected ${show(actual)} not to be null`,
+      );
+    },
+    toBeUndefined() {
+      settle(
+        actual === undefined,
+        negated,
+        `expected ${show(actual)} to be undefined`,
+        `expected ${show(actual)} not to be undefined`,
+      );
+    },
+    toBeDefined() {
+      settle(
+        actual !== undefined,
+        negated,
+        `expected ${show(actual)} to be defined`,
+        `expected ${show(actual)} not to be defined`,
+      );
+    },
+    toBeTruthy() {
+      settle(
+        Boolean(actual),
+        negated,
+        `expected ${show(actual)} to be truthy`,
+        `expected ${show(actual)} not to be truthy`,
+      );
+    },
+    toBeGreaterThan(expected) {
+      settle(
+        actual > expected,
+        negated,
+        `expected ${show(actual)} to be greater than ${show(expected)}`,
+        `expected ${show(actual)} not to be greater than ${show(expected)}`,
+      );
+    },
+    toBeGreaterThanOrEqual(expected) {
+      settle(
+        actual >= expected,
+        negated,
+        `expected ${show(actual)} to be >= ${show(expected)}`,
+        `expected ${show(actual)} not to be >= ${show(expected)}`,
+      );
+    },
+    toBeLessThanOrEqual(expected) {
+      settle(
+        actual <= expected,
+        negated,
+        `expected ${show(actual)} to be <= ${show(expected)}`,
+        `expected ${show(actual)} not to be <= ${show(expected)}`,
+      );
+    },
+    toHaveLength(expected) {
+      const len = actual == null ? undefined : actual.length;
+      settle(
+        len === expected,
+        negated,
+        `expected length ${show(len)} to be ${show(expected)}`,
+        `expected length ${show(len)} not to be ${show(expected)}`,
+      );
+    },
+    toContain(expected) {
+      let pass = false;
+      if (typeof actual === "string") {
+        pass = actual.includes(expected);
+      } else if (Array.isArray(actual)) {
+        pass = actual.includes(expected);
+      } else if (actual instanceof Set) {
+        pass = actual.has(expected);
+      } else if (
+        actual != null &&
+        typeof actual[Symbol.iterator] === "function"
+      ) {
+        pass = [...actual].includes(expected);
+      }
+      settle(
+        pass,
+        negated,
+        `expected ${show(actual)} to contain ${show(expected)}`,
+        `expected ${show(actual)} not to contain ${show(expected)}`,
+      );
+    },
+    toMatch(expected) {
+      const str = String(actual);
+      const pass =
+        expected instanceof RegExp
+          ? expected.test(str)
+          : str.includes(String(expected));
+      settle(
+        pass,
+        negated,
+        `expected ${show(str)} to match ${show(expected)}`,
+        `expected ${show(str)} not to match ${show(expected)}`,
+      );
+    },
+    toThrow(expected) {
+      assertThrow(actual, expected, negated);
+    },
+  };
+}
+
+/**
+ * Build the async matcher object for a promise-producing actual. Each matcher
+ * awaits the promise and applies the underlying matcher to the settled value.
+ * @param {unknown} actual - A promise (or thenable) under test.
+ * @param {boolean} negated - Whether `.not` is active.
+ * @param {"resolves" | "rejects"} mode - Which settlement to assert on.
+ * @returns {object} Matcher object whose methods return promises.
+ */
+function asyncMatchers(actual, negated, mode) {
+  const wrap = (apply) => async () => {
+    let value;
+    let rejected = false;
+    let rejection;
+    try {
+      value = await actual;
+    } catch (err) {
+      rejected = true;
+      rejection = err;
+    }
+    if (mode === "rejects") {
+      if (!rejected) {
+        throw new AssertionError({
+          message: "expected promise to reject, but it resolved",
+        });
+      }
+      return apply(rejection);
+    }
+    if (rejected) {
+      throw new AssertionError({
+        message: `expected promise to resolve, but it rejected with ${show(rejection)}`,
+      });
+    }
+    return apply(value);
+  };
+
+  const make =
+    (name) =>
+    (...args) => {
+      if (name === "toThrow") {
+        // `rejects.toThrow(x)` asserts the rejection's message; the settled value
+        // here is the rejection itself, so wrap it back into a throwing thunk.
+        return wrap((settled) => {
+          const thunk = () => {
+            throw settled;
+          };
+          assertThrow(thunk, args[0], negated);
+        })();
+      }
+      return wrap((settled) => matchers(settled, negated)[name](...args))();
+    };
+
+  return {
+    get not() {
+      return asyncMatchers(actual, !negated, mode);
+    },
+    toBe: make("toBe"),
+    toEqual: make("toEqual"),
+    toMatchObject: make("toMatchObject"),
+    toBeNull: make("toBeNull"),
+    toBeUndefined: make("toBeUndefined"),
+    toBeDefined: make("toBeDefined"),
+    toBeTruthy: make("toBeTruthy"),
+    toBeGreaterThan: make("toBeGreaterThan"),
+    toBeGreaterThanOrEqual: make("toBeGreaterThanOrEqual"),
+    toBeLessThanOrEqual: make("toBeLessThanOrEqual"),
+    toHaveLength: make("toHaveLength"),
+    toContain: make("toContain"),
+    toMatch: make("toMatch"),
+    toThrow: make("toThrow"),
+  };
+}
+
+/**
+ * Jest-style `expect`. Returns a matcher object with `.not`, `.resolves`, and
+ * `.rejects` chain modifiers plus the supported matchers.
+ * @param {unknown} actual - The value under test.
+ * @returns {object} Matcher object.
+ */
+export function expect(actual) {
+  const base = matchers(actual, false);
+  Object.defineProperties(base, {
+    resolves: {
+      get() {
+        return asyncMatchers(actual, false, "resolves");
+      },
+    },
+    rejects: {
+      get() {
+        return asyncMatchers(actual, false, "rejects");
+      },
+    },
+  });
+  return base;
+}
+
+/**
+ * Asymmetric matcher: matches any value constructed by / typed as `ctor`,
+ * for use inside `toEqual` / `toMatchObject`. Mirrors Jest/bun `expect.any`.
+ * @param {Function} ctor - A constructor or primitive wrapper (String, Number…).
+ * @returns {object} An asymmetric matcher.
+ */
+const PRIMITIVE_TYPEOF = new Map([
+  [String, "string"],
+  [Number, "number"],
+  [Boolean, "boolean"],
+  [BigInt, "bigint"],
+  [Object, "object"],
+  [Function, "function"],
+]);
+
+expect.any = (ctor) => ({
+  [ASYMMETRIC]: true,
+  asymmetricMatch(value) {
+    if (value == null) {
+      return false;
+    }
+    const primitive = PRIMITIVE_TYPEOF.get(ctor);
+    if (primitive) {
+      return typeof value === primitive || value instanceof ctor;
+    }
+    return value instanceof ctor;
+  },
+});
+
+/**
+ * Asymmetric matcher: matches any non-null, non-undefined value.
+ * @returns {object} An asymmetric matcher.
+ */
+expect.anything = () => ({
+  [ASYMMETRIC]: true,
+  asymmetricMatch: (value) => value != null,
+});

package/src/mock/git-client.js

@@ -8,16 +8,86 @@ const GIT_METHODS = [
   "rebase",
   "rebaseAbort",
   "mergeOursStrategy",
+  "resetSoft",
+  "checkoutPaths",
+  "mergeAbort",
+  "unmergedPaths",
+  "isMidMerge",
+  "introducedByFile",
   "commitAll",
   "commitPaths",
   "push",
+  "logByAuthor",
+  "diffRange",
+  "showFile",
   "revListCount",
   "configGet",
   "configSet",
   "aheadCount",
   "remoteGetUrl",
+  "headBranch",
+  "refExists",
+  "mergeBaseExists",
+  "remoteBranchExists",
+  "fetchDeepen",
+  "pushPorcelain",
+  "remoteRefTip",
+  "isAncestor",
+  "statusPorcelain",
+  "revParse",
+  "diffNameStatus",
+  "stashDropBySha",
 ];
 
+// A response descriptor models one git failure: an `Error` thrown as-is, or
+// `{ throw: <message>, stderr?: <text> }` thrown as an Error carrying that
+// stderr — mirroring how GitClient's `#runRaw` surfaces a failure (the real
+// GitError exposes `.stderr`), so a caller inspecting stderr (e.g. to tell a
+// push rejection from an auth failure) sees a faithful shape.
+function isResponseDescriptor(value) {
+  return (
+    value instanceof Error ||
+    (value && typeof value === "object" && "throw" in value)
+  );
+}
+
+// A configured response that is an array of response descriptors is a per-call
+// sequence: consumed one entry per invocation, reusing the last entry once
+// exhausted, so a test can express "push rejected on call 1, succeeds on call
+// 2". An array that is plain data (e.g. a `logByAuthor` commit list) is returned
+// whole — the descriptor check keeps data returns and failure sequences apart.
+function makeResponder(configured) {
+  const isSequence =
+    Array.isArray(configured) && configured.some(isResponseDescriptor);
+  if (!isSequence) return () => configured;
+  let i = 0;
+  return () => configured[Math.min(i++, configured.length - 1)];
+}
+
+function resolveResponse(responder) {
+  const value = responder();
+  if (value instanceof Error) throw value;
+  if (value && typeof value === "object" && "throw" in value) {
+    const err = new Error(value.throw);
+    err.stderr = value.stderr ?? value.throw;
+    throw err;
+  }
+  return value;
+}
+
+// Per-method default returns when no `responses[method]` is configured.
+// Methods absent here default to a no-op success `{ stdout, stderr, exitCode }`.
+const GIT_DEFAULTS = {
+  revListCount: 0,
+  aheadCount: 0,
+  logByAuthor: [],
+  diffRange: "",
+  showFile: null,
+  status: "",
+  configGet: "",
+  remoteGetUrl: "",
+};
+
 /**
  * Creates a mock `GitClient` collaborator. Every method on the real
  * `GitClient` surface is a spy returning a no-op success by default, or the
@@ -32,18 +102,14 @@ export function createMockGitClient({ responses = {} } = {}) {
   const calls = [];
   const client = { calls };
 
+  const responders = {};
   for (const method of GIT_METHODS) {
+    if (method in responses)
+      responders[method] = makeResponder(responses[method]);
     client[method] = spy(async (...args) => {
       calls.push({ method, args });
-      if (method in responses) return responses[method];
-      if (method === "revListCount" || method === "aheadCount") return 0;
-      if (
-        method === "status" ||
-        method === "configGet" ||
-        method === "remoteGetUrl"
-      ) {
-        return "";
-      }
+      if (method in responders) return resolveResponse(responders[method]);
+      if (method in GIT_DEFAULTS) return GIT_DEFAULTS[method];
       return { stdout: "", stderr: "", exitCode: 0 };
     });
   }