chore: round of test approval

Author: ice-chillios

packages/core/tests/util/deepMerge.test.ts

@@ -45,28 +45,11 @@ describe("deepMerge", () => {
     expect(deepMerge(target, source)).toEqual({ a: { b: { c: 10, d: 2, f: 4 }, e: 3, g: 5 } });
   });
 
-  /**
-   * SECURITY: prototype pollution via constructor key.
-   *
-   * The current implementation uses spread (`{ ...target }`) and `Object.keys()`,
-   * which treats `constructor` as a regular own property on the result object
-   * rather than walking up the prototype chain. This means `Object.prototype`
-   * is NOT polluted by this particular vector.
-   *
-   * However, the implementation does NOT explicitly reject dangerous keys
-   * (`__proto__`, `constructor`, `prototype`). If the merge strategy changes
-   * (e.g., to mutate in place), pollution could be re-introduced. Consider
-   * adding an explicit key blocklist for defense in depth.
-   */
-  test("SECURITY: prototype pollution via constructor key does not pollute Object.prototype", () => {
+  test("prototype pollution via constructor key does not pollute Object.prototype", () => {
     const malicious = JSON.parse('{"constructor":{"prototype":{"polluted":true}}}');
-
     const result = deepMerge({}, malicious);
 
-    // Object.prototype must NOT be polluted
     expect(({} as Record<string, unknown>).polluted).toBeUndefined();
-
-    // The constructor key should exist as a plain property on the result
     expect(result).toHaveProperty("constructor");
   });
 

packages/core/tests/util/mri-utils.test.ts

@@ -6,33 +6,29 @@ import { buildMriOptions, convertNumbers, mapPositionals, validatePositionals }
 describe("buildMriOptions", () => {
   test("boolean args go to boolean array", () => {
     const defs: Record<string, ArgDefinition> = { debug: { type: "boolean" }, verbose: { type: "boolean" } };
-    const opts = buildMriOptions(defs);
-    expect(opts.boolean).toEqual(["debug", "verbose"]);
-    expect(opts.string).toEqual([]);
+
+    expect(buildMriOptions(defs)).toMatchObject({ boolean: ["debug", "verbose"], string: [] });
   });
 
   test("string and number args go to string array", () => {
     const defs: Record<string, ArgDefinition> = { count: { type: "number" }, name: { type: "string" } };
-    const opts = buildMriOptions(defs);
-    expect(opts.string).toEqual(["count", "name"]);
-    expect(opts.boolean).toEqual([]);
+
+    expect(buildMriOptions(defs)).toMatchObject({ boolean: [], string: ["count", "name"] });
   });
 
   test("aliases registered correctly", () => {
     const defs: Record<string, ArgDefinition> = {
       output: { alias: "o", type: "string" },
       verbose: { alias: "v", type: "boolean" },
     };
-    const opts = buildMriOptions(defs);
-    expect(opts.alias.v).toBe("verbose");
-    expect(opts.alias.o).toBe("output");
+
+    expect(buildMriOptions(defs).alias).toMatchObject({ o: "output", v: "verbose" });
   });
 
   test("camelCase auto-generates kebab-case alias", () => {
     const defs: Record<string, ArgDefinition> = { dryRun: { type: "boolean" }, outputDir: { type: "string" } };
-    const opts = buildMriOptions(defs);
-    expect(opts.alias["dry-run"]).toBe("dryRun");
-    expect(opts.alias["output-dir"]).toBe("outputDir");
+
+    expect(buildMriOptions(defs).alias).toMatchObject({ "dry-run": "dryRun", "output-dir": "outputDir" });
   });
 
   test("defaults populated", () => {
@@ -60,9 +56,8 @@ describe("convertNumbers", () => {
 
   test("skips boolean and string types", () => {
     const defs: Record<string, ArgDefinition> = { name: { type: "string" }, verbose: { type: "boolean" } };
-    const result = convertNumbers({ name: "hello", verbose: true }, defs);
-    expect(result.verbose).toBe(true);
-    expect(result.name).toBe("hello");
+
+    expect(convertNumbers({ name: "hello", verbose: true }, defs)).toMatchObject({ name: "hello", verbose: true });
   });
 
   test("skips undefined values", () => {
@@ -81,30 +76,27 @@ describe("mapPositionals", () => {
 
   test("maps multiple positionals by index", () => {
     const defs: Record<string, PositionalDefinition> = { dest: { required: true }, source: { required: true } };
-    const result = mapPositionals(["a.txt", "b.txt"], defs);
-    expect(result.dest).toBe("a.txt");
-    expect(result.source).toBe("b.txt");
+
+    expect(mapPositionals(["a.txt", "b.txt"], defs)).toMatchObject({ dest: "a.txt", source: "b.txt" });
   });
 
   test("variadic positional captures rest as array", () => {
     const defs: Record<string, PositionalDefinition> = { first: { required: true }, rest: { variadic: true } };
-    const result = mapPositionals(["a", "b", "c", "d"], defs);
-    expect(result.first).toBe("a");
-    expect(result.rest).toEqual(["b", "c", "d"]);
+
+    expect(mapPositionals(["a", "b", "c", "d"], defs)).toMatchObject({ first: "a", rest: ["b", "c", "d"] });
   });
 
   test("missing positional returns undefined", () => {
     const defs: Record<string, PositionalDefinition> = { extra: {}, name: { required: true } };
-    const result = mapPositionals(["foo"], defs);
-    expect(result.extra).toBe("foo");
-    expect(result.name).toBeUndefined();
+
+    expect(mapPositionals(["foo"], defs)).toMatchObject({ extra: "foo", name: undefined });
   });
 
   test("extra positionals silently dropped", () => {
     const defs: Record<string, PositionalDefinition> = { name: { required: true } };
     const result = mapPositionals(["foo", "bar", "baz"], defs);
-    expect(result.name).toBe("foo");
-    expect(Object.keys(result)).toEqual(["name"]);
+
+    expect(result).toEqual({ name: "foo" });
   });
 });
 

packages/sisyphus/src/domain/Commit.ts

@@ -130,7 +130,9 @@ export class Commit {
     const commits: Commit[] = [];
 
     for (let i = 0; i < segments.length; i += 2) {
-      const fields = segments[i]?.split(FIELD_SEPARATOR);
+      const segment = segments[i];
+      if (!segment) continue;
+      const fields = segment.split(FIELD_SEPARATOR);
       if (fields.length < 3) continue;
 
       const [hash, subject, author] = fields;

packages/sisyphus/tests/domain/BumpType.test.ts

@@ -73,7 +73,6 @@ describe("BUMP_ORDER", () => {
       BumpType.Dependency,
       BumpType.Snapshot,
     ]);
-    expect(BUMP_ORDER).toHaveLength(5);
   });
 });
 
@@ -88,11 +87,9 @@ describe("BUMP_PRIORITY", () => {
 });
 
 describe("BUMP_EMOJI", () => {
-  test("all types have an emoji", () => {
+  test("all types have a non-empty emoji string", () => {
     for (const type of Object.values(BumpType)) {
-      expect(BUMP_EMOJI[type]).toBeDefined();
-      expect(typeof BUMP_EMOJI[type]).toBe("string");
-      expect(BUMP_EMOJI[type].length).toBeGreaterThan(0);
+      expect(BUMP_EMOJI[type]).toMatch(/.+/);
     }
   });
 });

packages/sisyphus/tests/domain/Commit.test.ts

@@ -1,169 +1,137 @@
 import { describe, expect, test } from "bun:test";
+import { OTHER_COMMIT_TYPE } from "../../src/constants";
 import type { CommitInfo } from "../../src/domain/Commit";
-import { Commit, OTHER_COMMIT_TYPE } from "../../src/domain/Commit";
+import { Commit } from "../../src/domain/Commit";
 
 const HASH = "abc1234567890def";
+const AUTHOR = "test-author";
 
 describe("Commit.parse", () => {
   test("parses standard feat commit", () => {
-    const commit = Commit.parse(HASH, "feat: add feature");
-
-    expect(commit.type).toBe("feat");
-    expect(commit.message).toBe("add feature");
-    expect(commit.breaking).toBe(false);
-    expect(commit.scope).toBeUndefined();
-    expect(commit.subject).toBe("feat: add feature");
-    expect(commit.hash).toBe(HASH);
-    expect(commit.files).toEqual([]);
+    const commit = Commit.parse(HASH, "feat: add feature", AUTHOR);
+
+    expect(commit).toMatchObject({
+      breaking: false,
+      files: [],
+      hash: HASH,
+      message: "add feature",
+      scope: undefined,
+      subject: "feat: add feature",
+      type: "feat",
+    });
   });
 
   test("parses standard fix commit", () => {
-    const commit = Commit.parse(HASH, "fix: resolve bug");
+    const commit = Commit.parse(HASH, "fix: resolve bug", AUTHOR);
 
-    expect(commit.type).toBe("fix");
-    expect(commit.message).toBe("resolve bug");
-    expect(commit.breaking).toBe(false);
+    expect(commit).toMatchObject({ breaking: false, message: "resolve bug", type: "fix" });
   });
 
   test("parses commit with scope", () => {
-    const commit = Commit.parse(HASH, "feat(api): add endpoint");
+    const commit = Commit.parse(HASH, "feat(api): add endpoint", AUTHOR);
 
-    expect(commit.type).toBe("feat");
-    expect(commit.scope).toBe("api");
-    expect(commit.message).toBe("add endpoint");
-    expect(commit.breaking).toBe(false);
+    expect(commit).toMatchObject({ breaking: false, message: "add endpoint", scope: "api", type: "feat" });
   });
 
   test("parses breaking change with !", () => {
-    const commit = Commit.parse(HASH, "feat!: breaking change");
+    const commit = Commit.parse(HASH, "feat!: breaking change", AUTHOR);
 
-    expect(commit.type).toBe("feat");
-    expect(commit.breaking).toBe(true);
-    expect(commit.message).toBe("breaking change");
+    expect(commit).toMatchObject({ breaking: true, message: "breaking change", type: "feat" });
   });
 
   test("parses breaking change with scope and !", () => {
-    const commit = Commit.parse(HASH, "feat(api)!: break it");
+    const commit = Commit.parse(HASH, "feat(api)!: break it", AUTHOR);
 
-    expect(commit.type).toBe("feat");
-    expect(commit.scope).toBe("api");
-    expect(commit.breaking).toBe(true);
-    expect(commit.message).toBe("break it");
+    expect(commit).toMatchObject({ breaking: true, message: "break it", scope: "api", type: "feat" });
   });
 
   describe("all known commit types", () => {
     const knownTypes = ["build", "chore", "ci", "docs", "feat", "fix", "perf", "refactor", "style", "test"];
 
     for (const type of knownTypes) {
       test(`recognizes "${type}" as conventional type`, () => {
-        const commit = Commit.parse(HASH, `${type}: some message`);
+        const commit = Commit.parse(HASH, `${type}: some message`, AUTHOR);
 
-        expect(commit.type).toBe(type);
-        expect(commit.message).toBe("some message");
-        expect(commit.isConventional).toBe(true);
+        expect(commit).toMatchObject({ isConventional: true, message: "some message", type });
       });
     }
   });
 
   test("unknown type falls back to OTHER_COMMIT_TYPE", () => {
-    const commit = Commit.parse(HASH, "unknown: something");
+    const commit = Commit.parse(HASH, "unknown: something", AUTHOR);
 
-    expect(commit.type).toBe(OTHER_COMMIT_TYPE);
-    expect(commit.type).toBe("other");
-    expect(commit.message).toBe("unknown: something");
+    expect(commit).toMatchObject({ message: "unknown: something", type: OTHER_COMMIT_TYPE });
   });
 
   test("non-conventional commit falls back to OTHER_COMMIT_TYPE", () => {
-    const commit = Commit.parse(HASH, "just a message");
+    const commit = Commit.parse(HASH, "just a message", AUTHOR);
 
-    expect(commit.type).toBe(OTHER_COMMIT_TYPE);
-    expect(commit.message).toBe("just a message");
-    expect(commit.subject).toBe("just a message");
+    expect(commit).toMatchObject({ message: "just a message", subject: "just a message", type: OTHER_COMMIT_TYPE });
   });
 
   test("commit with colon but no known type falls back to OTHER_COMMIT_TYPE", () => {
-    const commit = Commit.parse(HASH, "WIP: work in progress");
+    const commit = Commit.parse(HASH, "WIP: work in progress", AUTHOR);
 
-    expect(commit.type).toBe(OTHER_COMMIT_TYPE);
-    expect(commit.message).toBe("WIP: work in progress");
+    expect(commit).toMatchObject({ message: "WIP: work in progress", type: OTHER_COMMIT_TYPE });
   });
 
   test("empty subject edge case", () => {
-    const commit = Commit.parse(HASH, "");
+    const commit = Commit.parse(HASH, "", AUTHOR);
 
-    expect(commit.type).toBe(OTHER_COMMIT_TYPE);
-    expect(commit.message).toBe("");
-    expect(commit.subject).toBe("");
-    expect(commit.breaking).toBe(false);
+    expect(commit).toMatchObject({ breaking: false, message: "", subject: "", type: OTHER_COMMIT_TYPE });
   });
 });
 
 describe("Commit getters", () => {
   test("shortHash returns first 7 characters", () => {
-    const commit = Commit.parse(HASH, "feat: something");
-
-    expect(commit.shortHash).toBe("abc1234");
-    expect(commit.shortHash).toHaveLength(7);
+    expect(Commit.parse(HASH, "feat: something", AUTHOR).shortHash).toBe("abc1234");
   });
 
   test("shortHash works with exactly 7 char hash", () => {
-    const commit = Commit.parse("abc1234", "feat: something");
-
-    expect(commit.shortHash).toBe("abc1234");
+    expect(Commit.parse("abc1234", "feat: something", AUTHOR).shortHash).toBe("abc1234");
   });
 
   test("isConventional returns true for known types", () => {
-    const commit = Commit.parse(HASH, "feat: something");
-
-    expect(commit.isConventional).toBe(true);
+    expect(Commit.parse(HASH, "feat: something", AUTHOR).isConventional).toBe(true);
   });
 
   test("isConventional returns false for other type", () => {
-    const commit = Commit.parse(HASH, "random message");
-
-    expect(commit.isConventional).toBe(false);
+    expect(Commit.parse(HASH, "random message", AUTHOR).isConventional).toBe(false);
   });
 });
 
 describe("Commit.withFiles", () => {
-  test("returns new Commit with files set", () => {
-    const original = Commit.parse(HASH, "feat: something");
+  test("returns new Commit with files set, original unchanged", () => {
+    const original = Commit.parse(HASH, "feat: something", AUTHOR);
     const files = ["src/index.ts", "src/utils.ts"];
     const withFiles = original.withFiles(files);
 
-    expect(withFiles.files).toEqual(files);
-    expect(withFiles.type).toBe("feat");
-    expect(withFiles.message).toBe("something");
-    expect(withFiles.hash).toBe(HASH);
-    // Original is unchanged
+    expect(withFiles).toMatchObject({ files, hash: HASH, message: "something", type: "feat" });
     expect(original.files).toEqual([]);
   });
 });
 
 describe("Commit.withBody", () => {
-  test("returns new Commit with body set", () => {
-    const original = Commit.parse(HASH, "feat: something");
+  test("returns new Commit with body set, original unchanged", () => {
+    const original = Commit.parse(HASH, "feat: something", AUTHOR);
     const withBody = original.withBody("detailed description");
 
-    expect(withBody.body).toBe("detailed description");
-    expect(withBody.type).toBe("feat");
-    expect(withBody.message).toBe("something");
-    // Original is unchanged
+    expect(withBody).toMatchObject({ body: "detailed description", message: "something", type: "feat" });
     expect(original.body).toBeUndefined();
   });
 
-  test("returns new Commit with undefined body", () => {
-    const original = Commit.parse(HASH, "feat: something").withBody("some body");
-    const withoutBody = original.withBody(undefined);
+  test("withBody(undefined) clears the body", () => {
+    const original = Commit.parse(HASH, "feat: something", AUTHOR).withBody("some body");
 
-    expect(withoutBody.body).toBeUndefined();
+    expect(original.withBody(undefined).body).toBeUndefined();
   });
 });
 
 describe("Commit.toInfo", () => {
   test("returns CommitInfo with correct fields", () => {
-    const commit = Commit.parse(HASH, "feat(api): add endpoint").withBody("some body").withFiles(["src/api.ts"]);
-
+    const commit = Commit.parse(HASH, "feat(api): add endpoint", AUTHOR)
+      .withBody("some body")
+      .withFiles(["src/api.ts"]);
     const info: CommitInfo = commit.toInfo(["@org/api"]);
 
     expect(info).toEqual({
@@ -178,15 +146,16 @@ describe("Commit.toInfo", () => {
   });
 
   test("returns CommitInfo for non-conventional commit", () => {
-    const commit = Commit.parse(HASH, "just a message");
-
-    const info = commit.toInfo([]);
+    const info = Commit.parse(HASH, "just a message", AUTHOR).toInfo([]);
 
-    expect(info.type).toBe("other");
-    expect(info.message).toBe("just a message");
-    expect(info.hash).toBe("abc1234");
-    expect(info.packages).toEqual([]);
-    expect(info.scope).toBeUndefined();
-    expect(info.body).toBeUndefined();
+    expect(info).toEqual({
+      body: undefined,
+      hash: "abc1234",
+      message: "just a message",
+      packages: [],
+      scope: undefined,
+      subject: "just a message",
+      type: "other",
+    });
   });
 });