src/__tests__/jsonexpr/operators/semver_lt.test.js (2)

34-39: Consider asserting that versionCompare is called for null inputs.

The test verifies that null is returned for null inputs, but doesn't assert on the versionCompare call. Based on the operator implementation, versionCompare(null, null) should still be called (and return null). Adding this assertion would strengthen the test.

🧪 Proposed enhancement

 		it("should return null for null inputs", () => {
 			expect(operator.evaluate(evaluator, [null, null])).toBe(null);
+			expect(evaluator.versionCompare).toHaveBeenCalledWith(null, null);
 
 			evaluator.evaluate.mockClear();
 			evaluator.versionCompare.mockClear();
 		});

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/__tests__/jsonexpr/operators/semver_lt.test.js` around lines 34 - 39, Add
an assertion in the "should return null for null inputs" test to verify that
evaluator.versionCompare was invoked with the null inputs when
operator.evaluate(evaluator, [null, null]) is called; specifically assert
evaluator.versionCompare was called once (or called with (null, null)) after the
evaluate call and before clearing mocks (use the existing mock on
evaluator.versionCompare and evaluator.evaluate to perform the check).

---

7-9: Consider using beforeEach for mock clearing.

The shared evaluator with manual mockClear() at the end of each test is fragile—if a test fails before clearing, subsequent tests may be affected. Using Jest's beforeEach hook would be more robust and reduce repetition.

♻️ Proposed refactor

 	describe("evaluate", () => {
 		const evaluator = mockEvaluator();
 
+		beforeEach(() => {
+			evaluator.evaluate.mockClear();
+			evaluator.versionCompare.mockClear();
+		});
+
 		it("should return true when left version is less", () => {
 			expect(operator.evaluate(evaluator, ["1.0.0", "2.0.0"])).toBe(true);
 			expect(evaluator.versionCompare).toHaveBeenCalledWith("1.0.0", "2.0.0");
-
-			evaluator.evaluate.mockClear();
-			evaluator.versionCompare.mockClear();
 		});
 		// ... similarly for other tests

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/__tests__/jsonexpr/operators/semver_lt.test.js` around lines 7 - 9, The
tests create a shared evaluator via const evaluator = mockEvaluator() and call
evaluator.mockClear() manually at each test end; replace this pattern with a
Jest beforeEach that either reassigns evaluator = mockEvaluator() or calls
evaluator.mockClear() before each test so mocks are reset even if a test fails —
update references to the evaluator created by mockEvaluator() in the
describe("evaluate", ...) block and remove per-test manual mockClear() calls to
avoid fragile cleanup.

src/__tests__/jsonexpr/operators/semver_gt.test.js (2)

34-39: Add versionCompare call assertion for null inputs.

Similar to the suggestion for semver_lt.test.js, consider asserting that versionCompare is called with (null, null) to fully document the expected behaviour.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/__tests__/jsonexpr/operators/semver_gt.test.js` around lines 34 - 39, The
test for null inputs should also assert that evaluator.versionCompare was
invoked with (null, null); update the "should return null for null inputs" case
to add expect(evaluator.versionCompare).toHaveBeenCalledWith(null, null) (placed
after the operator.evaluate assertion and before mockClear calls) so the test
documents that operator.evaluate triggered versionCompare with those arguments.

---

7-9: Same refactoring opportunity as semver_lt.test.js.

Consider using beforeEach for mock clearing to improve test isolation and reduce repetition. The same pattern applies to other semver operator test files.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/__tests__/jsonexpr/operators/semver_gt.test.js` around lines 7 - 9, Tests
in describe("evaluate") repeat mock setup and lack per-test isolation; change
the const evaluator = mockEvaluator() pattern to initialize/reset the mock in a
beforeEach block: declare evaluator in the describe scope (use let evaluator)
and call evaluator = mockEvaluator() (or jest.clearAllMocks() plus re-init)
inside beforeEach so every test gets a fresh mock; apply the same change to
semver_gt.test.js and other semver operator test files following the
semver_lt.test.js refactor.

src/__tests__/jsonexpr/operators/evaluator.js (1)

21-27: Inconsistent indentation in versionCompare mock body.

The body of versionCompare (lines 22-26) lacks the leading tab indentation used elsewhere in this object (e.g., compare on lines 29+). This breaks the consistent formatting style and may trigger linter warnings.

🔧 Proposed fix

 	versionCompare: jest.fn((lhs, rhs) => {
-	const lhsStr = typeof lhs === "string" ? lhs : null;
-	const rhsStr = typeof rhs === "string" ? rhs : null;
-	if (lhsStr === null || rhsStr === null) return null;
-	return lhsStr === rhsStr ? 0 : lhsStr > rhsStr ? 1 : -1;
-}),
+		const lhsStr = typeof lhs === "string" ? lhs : null;
+		const rhsStr = typeof rhs === "string" ? rhs : null;
+		if (lhsStr === null || rhsStr === null) return null;
+		return lhsStr === rhsStr ? 0 : lhsStr > rhsStr ? 1 : -1;
+	}),
 
-	compare: jest.fn((lhs, rhs) => {
+		compare: jest.fn((lhs, rhs) => {

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/__tests__/jsonexpr/operators/evaluator.js` around lines 21 - 27, The mock
implementation for versionCompare has inconsistent indentation compared to other
operator mocks; update the body of the jest.fn for versionCompare so its inner
lines (the const declarations, null checks and return) use the same leading tab
indentation as the surrounding entries (e.g., match the indentation style used
by compare) to satisfy the linter and maintain consistent formatting for the
versionCompare jest.fn mock.

src/__tests__/jsonexpr/operators/semver_lte.test.js (2)

7-39: Consider using beforeEach/afterEach for mock clearing.

The manual mockClear() calls at the end of each test are repetitive. Using Jest's afterEach hook would be cleaner and ensure mocks are always cleared, even if a test fails mid-execution.

♻️ Suggested refactor

 	describe("evaluate", () => {
 		const evaluator = mockEvaluator();

+		afterEach(() => {
+			evaluator.evaluate.mockClear();
+			evaluator.versionCompare.mockClear();
+		});
+
 		it("should return true when left version is less", () => {
 			expect(operator.evaluate(evaluator, ["1.0.0", "2.0.0"])).toBe(true);
 			expect(evaluator.versionCompare).toHaveBeenCalledWith("1.0.0", "2.0.0");
-
-			evaluator.evaluate.mockClear();
-			evaluator.versionCompare.mockClear();
 		});
 		// ... apply same pattern to other tests

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/__tests__/jsonexpr/operators/semver_lte.test.js` around lines 7 - 39,
Replace the repetitive manual evaluator.evaluate.mockClear() and
evaluator.versionCompare.mockClear() calls in each it block with a single
afterEach hook that clears those mocks; locate the test suite around
describe("evaluate", ...) and add an afterEach(() => {
evaluator.evaluate.mockClear(); evaluator.versionCompare.mockClear(); }) (or use
jest.clearAllMocks() if preferred) and remove the per-test mockClear() lines so
mocks are always cleared even on test failures.

---

34-39: Consider verifying versionCompare call behaviour for null inputs.

The other semver operator tests (e.g., semver_eq.test.js) verify whether versionCompare was or wasn't called when inputs are null. This test lacks that assertion, making it inconsistent with the test suite.

♻️ Suggested improvement

 		it("should return null for null inputs", () => {
 			expect(operator.evaluate(evaluator, [null, null])).toBe(null);
+			expect(evaluator.versionCompare).not.toHaveBeenCalled();

 			evaluator.evaluate.mockClear();
 			evaluator.versionCompare.mockClear();
 		});

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/__tests__/jsonexpr/operators/semver_lte.test.js` around lines 34 - 39,
The test semver_lte.test.js's "should return null for null inputs" currently
checks the return value but doesn't assert whether evaluator.versionCompare was
invoked; update the test for operator.evaluate(evaluator, [null, null]) to also
assert that evaluator.versionCompare was not called (e.g.,
expect(evaluator.versionCompare).not.toHaveBeenCalled()), and keep the existing
mockClear() calls for evaluator.evaluate and evaluator.versionCompare to match
the other semver operator tests.

src/__tests__/jsonexpr/operators/evaluator.js (1)

21-26: Avoid lexicographic fallback in the SemVer mock.

On Line [25], lhsStr > rhsStr is lexicographic, so values like "1.10.0" and "1.2.0" are ordered incorrectly for semver. In this shared helper, that can hide semver-ordering issues in operator tests. Prefer a neutral default for non-equality and let each test explicitly stub ordering.

Proposed change

 		versionCompare: jest.fn((lhs, rhs) => {
 			const lhsStr = typeof lhs === "string" ? lhs : null;
 			const rhsStr = typeof rhs === "string" ? rhs : null;
 			if (lhsStr === null || rhsStr === null) return null;
-			return lhsStr === rhsStr ? 0 : lhsStr > rhsStr ? 1 : -1;
+			return lhsStr === rhsStr ? 0 : null;
 		}),

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/__tests__/jsonexpr/operators/evaluator.js` around lines 21 - 26, The mock
for versionCompare currently falls back to lexicographic comparison (lhsStr >
rhsStr), which misorders semver like "1.10.0" vs "1.2.0"; update the jest.fn
mock for versionCompare so it only returns 0 when lhs and rhs are equal strings
and returns null for non-equal string inputs (i.e., remove the lexicographic
comparison branch), so tests must explicitly stub ordering when needed; locate
the versionCompare mock in the evaluator tests and change its implementation
accordingly.