@fogpipe/forma-core 0.8.1 → 0.9.0

package/src/__tests__/feel.test.ts

@@ -0,0 +1,833 @@
+/**
+ * Tests for FEEL expression evaluation
+ *
+ * Focuses on null handling behavior and warning scenarios.
+ * FEEL uses three-valued logic where comparisons with null/undefined return null,
+ * not false. This is critical to understand for form visibility expressions.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  evaluate,
+  evaluateBoolean,
+  evaluateNumber,
+  evaluateString,
+  evaluateBooleanBatch,
+  isValidExpression,
+  validateExpression,
+} from "../feel/index.js";
+import type { EvaluationContext } from "../types.js";
+
+// =============================================================================
+// Test Helpers
+// =============================================================================
+
+/**
+ * Create a minimal evaluation context for testing
+ */
+function createContext(
+  overrides: Partial<EvaluationContext> = {}
+): EvaluationContext {
+  return {
+    data: {},
+    ...overrides,
+  };
+}
+
+// =============================================================================
+// evaluate() Tests
+// =============================================================================
+
+describe("evaluate", () => {
+  describe("basic expressions", () => {
+    it("evaluates simple arithmetic", () => {
+      const result = evaluate("2 + 3", createContext());
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBe(5);
+      }
+    });
+
+    it("evaluates field references from data", () => {
+      const result = evaluate(
+        "age >= 18",
+        createContext({ data: { age: 21 } })
+      );
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBe(true);
+      }
+    });
+
+    it("evaluates computed field references", () => {
+      const result = evaluate(
+        "computed.total > 100",
+        createContext({ data: {}, computed: { total: 150 } })
+      );
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBe(true);
+      }
+    });
+
+    it("evaluates item field references in array context", () => {
+      const result = evaluate(
+        "item.quantity > 5",
+        createContext({ data: {}, item: { quantity: 10 } })
+      );
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBe(true);
+      }
+    });
+
+    it("evaluates value reference for validation", () => {
+      const result = evaluate("value >= 0", createContext({ data: {}, value: 5 }));
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBe(true);
+      }
+    });
+  });
+
+  describe("null/undefined handling", () => {
+    /**
+     * IMPORTANT: Feelin's behavior differs from strict FEEL three-valued logic.
+     *
+     * In feelin:
+     * - Equality checks (=, !=) with undefined return false, not null
+     * - Numeric comparisons (>, <, >=, <=) with undefined return null
+     * - Logical operators (and, or) propagate null correctly
+     * - Function calls on undefined (string length, count, etc.) return null
+     */
+
+    it("equality check on undefined field returns false (feelin behavior)", () => {
+      // In feelin, undefined = true returns false, not null
+      // This differs from strict FEEL three-valued logic
+      const result = evaluate(
+        "undefinedField = true",
+        createContext({ data: {} })
+      );
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBe(false);
+      }
+    });
+
+    it("!= null check on undefined field returns false (feelin behavior)", () => {
+      // In feelin, undefined != null returns false
+      const result = evaluate(
+        "undefinedField != null",
+        createContext({ data: {} })
+      );
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBe(false);
+      }
+    });
+
+    it("returns null for numeric comparison with undefined field", () => {
+      // Numeric comparisons DO return null when field is undefined
+      const result = evaluate(
+        "undefinedField > 5",
+        createContext({ data: {} })
+      );
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBeNull();
+      }
+    });
+
+    it("returns null for string length of undefined field", () => {
+      const result = evaluate(
+        "string length(undefinedField)",
+        createContext({ data: {} })
+      );
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBeNull();
+      }
+    });
+
+    it("returns null for string length comparison with undefined field", () => {
+      const result = evaluate(
+        "string length(undefinedField) > 0",
+        createContext({ data: {} })
+      );
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBeNull();
+      }
+    });
+
+    it("returns null for count of undefined field", () => {
+      const result = evaluate(
+        "count(undefinedField) > 0",
+        createContext({ data: {} })
+      );
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBeNull();
+      }
+    });
+
+    it("propagates null through logical AND with null operand", () => {
+      // null and true = null
+      const result = evaluate(
+        "null and true",
+        createContext({ data: {} })
+      );
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBeNull();
+      }
+    });
+
+    it("returns null when computed field is null in AND expression with defined operand", () => {
+      // When computed.eligible is null and the other operand is defined,
+      // null propagates through AND
+      const result = evaluate(
+        "computed.eligible and x = true",
+        createContext({ data: { x: true }, computed: { eligible: null } })
+      );
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBeNull();
+      }
+    });
+
+    it("returns false when computed field is null but other operand evaluates to false", () => {
+      // When the other operand is undefined, x = true returns false
+      // false and null = false (short-circuit)
+      const result = evaluate(
+        "computed.eligible and x = true",
+        createContext({ data: {}, computed: { eligible: null } })
+      );
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.value).toBe(false);
+      }
+    });
+  });
+
+  describe("error handling", () => {
+    it("returns error for invalid expression syntax", () => {
+      // Note: feelin may not always throw on syntax errors at evaluation
+      // It depends on the expression and context
+      const result = evaluate("@#$%", createContext());
+      // If it doesn't throw, we just check the result structure
+      expect(result).toHaveProperty("success");
+    });
+  });
+});
+
+// =============================================================================
+// evaluateBoolean() Tests - Null Warning Scenarios
+// =============================================================================
+
+describe("evaluateBoolean", () => {
+  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleWarnSpy.mockRestore();
+  });
+
+  describe("normal boolean evaluation", () => {
+    it("returns true for true expression", () => {
+      const result = evaluateBoolean(
+        "age >= 18",
+        createContext({ data: { age: 21 } })
+      );
+      expect(result).toBe(true);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("returns false for false expression", () => {
+      const result = evaluateBoolean(
+        "age >= 18",
+        createContext({ data: { age: 15 } })
+      );
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("returns true for explicitly true boolean field", () => {
+      const result = evaluateBoolean(
+        "hasConsent = true",
+        createContext({ data: { hasConsent: true } })
+      );
+      expect(result).toBe(true);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("returns false for explicitly false boolean field", () => {
+      const result = evaluateBoolean(
+        "hasConsent = true",
+        createContext({ data: { hasConsent: false } })
+      );
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("null result warning scenarios", () => {
+    /**
+     * These tests verify that evaluateBoolean logs warnings when expressions
+     * return null. In feelin, null results occur from:
+     * - Numeric comparisons with undefined fields (>, <, >=, <=)
+     * - String/array functions on undefined (string length, count, sum)
+     * - Logical AND/OR with null operands
+     *
+     * Note: Equality checks (=, !=) on undefined return false, NOT null in feelin.
+     */
+
+    it("does NOT warn for equality check on undefined (feelin returns false)", () => {
+      // feelin returns false for undefined = true, so no warning
+      const result = evaluateBoolean(
+        "undefinedField = true",
+        createContext({ data: {} })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("logs warning for numeric comparison with undefined field", () => {
+      // undefinedField > 5 returns null, triggering warning
+      const result = evaluateBoolean(
+        "undefinedField > 5",
+        createContext({ data: {} })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("returned null")
+      );
+    });
+
+    it("logs warning for string length comparison on undefined field", () => {
+      const result = evaluateBoolean(
+        "string length(undefinedField) > 0",
+        createContext({ data: {} })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("returned null")
+      );
+    });
+
+    it("logs warning for count comparison on undefined field", () => {
+      const result = evaluateBoolean(
+        "count(undefinedField) > 0",
+        createContext({ data: {} })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("returned null")
+      );
+    });
+
+    it("logs warning when computed field is null in AND expression with defined operand", () => {
+      // computed.eligible is null, AND propagates null when other operand is defined
+      const result = evaluateBoolean(
+        "computed.eligible and x = true",
+        createContext({ data: { x: true }, computed: { eligible: null } })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("returned null")
+      );
+    });
+
+    it("no warning when computed is null but other operand evaluates false first", () => {
+      // When x is undefined, x = true returns false
+      // feelin may short-circuit: false and null = false (no null in result)
+      const result = evaluateBoolean(
+        "computed.eligible and x = true",
+        createContext({ data: {}, computed: { eligible: null } })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("logs warning for explicit null and true expression", () => {
+      const result = evaluateBoolean(
+        "null and true",
+        createContext({ data: {} })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it("warning message includes expression that caused it", () => {
+      evaluateBoolean(
+        "undefinedField > 5",
+        createContext({ data: {} })
+      );
+
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("undefinedField > 5")
+      );
+    });
+
+    it("warning message includes null-safe pattern guidance", () => {
+      evaluateBoolean(
+        "undefinedField > 5",
+        createContext({ data: {} })
+      );
+
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("null-safe patterns")
+      );
+    });
+  });
+
+  describe("non-boolean result handling", () => {
+    it("logs warning and returns false for numeric result", () => {
+      const result = evaluateBoolean(
+        "2 + 3",
+        createContext({ data: {} })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("did not return boolean")
+      );
+    });
+
+    it("logs warning and returns false for string result", () => {
+      const result = evaluateBoolean(
+        '"hello"',
+        createContext({ data: {} })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("did not return boolean")
+      );
+    });
+  });
+
+  describe("error handling", () => {
+    it("logs warning and returns false on evaluation error", () => {
+      // Force an error by using invalid function
+      const result = evaluateBoolean(
+        "nonExistentFunction(x)",
+        createContext({ data: {} })
+      );
+
+      expect(result).toBe(false);
+      // May log either error or null warning depending on feelin behavior
+      expect(consoleWarnSpy).toHaveBeenCalled();
+    });
+  });
+});
+
+// =============================================================================
+// evaluateNumber() Tests
+// =============================================================================
+
+describe("evaluateNumber", () => {
+  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleWarnSpy.mockRestore();
+  });
+
+  it("returns number for valid arithmetic", () => {
+    const result = evaluateNumber("quantity * price", createContext({
+      data: { quantity: 5, price: 10 }
+    }));
+    expect(result).toBe(50);
+  });
+
+  it("returns null for non-numeric result", () => {
+    const result = evaluateNumber('"hello"', createContext());
+    expect(result).toBeNull();
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("did not return number")
+    );
+  });
+
+  it("returns null on evaluation error", () => {
+    const result = evaluateNumber("invalidExpression((", createContext());
+    expect(result).toBeNull();
+    expect(consoleWarnSpy).toHaveBeenCalled();
+  });
+});
+
+// =============================================================================
+// evaluateString() Tests
+// =============================================================================
+
+describe("evaluateString", () => {
+  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleWarnSpy.mockRestore();
+  });
+
+  it("returns string for valid string expression", () => {
+    const result = evaluateString(
+      'if age >= 18 then "adult" else "minor"',
+      createContext({ data: { age: 21 } })
+    );
+    expect(result).toBe("adult");
+  });
+
+  it("returns null for non-string result", () => {
+    const result = evaluateString("2 + 3", createContext());
+    expect(result).toBeNull();
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("did not return string")
+    );
+  });
+});
+
+// =============================================================================
+// evaluateBooleanBatch() Tests
+// =============================================================================
+
+describe("evaluateBooleanBatch", () => {
+  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleWarnSpy.mockRestore();
+  });
+
+  it("evaluates multiple expressions at once", () => {
+    const results = evaluateBooleanBatch(
+      {
+        canVote: "age >= 18",
+        canDrive: "age >= 16",
+        canDrink: "age >= 21",
+      },
+      createContext({ data: { age: 20 } })
+    );
+
+    expect(results.canVote).toBe(true);
+    expect(results.canDrive).toBe(true);
+    expect(results.canDrink).toBe(false);
+  });
+
+  it("handles equality checks on undefined without warnings (feelin behavior)", () => {
+    // Equality checks return false in feelin, not null, so no warnings
+    const results = evaluateBooleanBatch(
+      {
+        visible: "undefinedField = true",
+        enabled: "anotherUndefined = false",
+      },
+      createContext({ data: {} })
+    );
+
+    expect(results.visible).toBe(false);
+    expect(results.enabled).toBe(false);
+    expect(consoleWarnSpy).not.toHaveBeenCalled();
+  });
+
+  it("handles null results in batch with warnings", () => {
+    // Numeric comparisons return null, triggering warnings
+    const results = evaluateBooleanBatch(
+      {
+        hasEnoughItems: "count(items) > 5",
+        hasLongName: "string length(name) > 10",
+      },
+      createContext({ data: {} })
+    );
+
+    expect(results.hasEnoughItems).toBe(false);
+    expect(results.hasLongName).toBe(false);
+    expect(consoleWarnSpy).toHaveBeenCalledTimes(2);
+  });
+});
+
+// =============================================================================
+// isValidExpression() Tests
+// =============================================================================
+
+describe("isValidExpression", () => {
+  it("returns true for valid simple expression", () => {
+    expect(isValidExpression("age >= 18")).toBe(true);
+  });
+
+  it("returns true for valid complex expression", () => {
+    expect(isValidExpression("x > 5 and y < 10 or z = true")).toBe(true);
+  });
+
+  it("returns true for valid function call", () => {
+    expect(isValidExpression("count(items) > 0")).toBe(true);
+  });
+
+  it("returns false for clearly invalid syntax", () => {
+    // Some syntax errors may only be caught at runtime
+    // Check for common invalid patterns
+    const result = isValidExpression("@#$%^&*");
+    // Result depends on feelin's behavior
+    expect(typeof result).toBe("boolean");
+  });
+});
+
+// =============================================================================
+// validateExpression() Tests
+// =============================================================================
+
+describe("validateExpression", () => {
+  it("returns null for valid expression", () => {
+    expect(validateExpression("age >= 18")).toBeNull();
+  });
+
+  it("returns null for runtime errors (not parsing errors)", () => {
+    // Missing variable is a runtime error, not a parse error
+    // Should return null since it's syntactically valid
+    const result = validateExpression("missingVariable > 5");
+    expect(result).toBeNull();
+  });
+
+  it("returns error for syntax errors", () => {
+    // Force a parse error
+    const result = validateExpression("if then else");
+    // May or may not catch depending on feelin's behavior
+    expect(typeof result === "string" || result === null).toBe(true);
+  });
+});
+
+// =============================================================================
+// Real-World Scenario Tests
+// =============================================================================
+
+describe("real-world scenarios", () => {
+  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleWarnSpy.mockRestore();
+  });
+
+  describe("clinical trial eligibility pattern", () => {
+    it("correctly evaluates when all inclusion criteria are met", () => {
+      const result = evaluateBoolean(
+        "inclusionAge = true and inclusionDiagnosis = true and inclusionHbA1c = true",
+        createContext({
+          data: {
+            inclusionAge: true,
+            inclusionDiagnosis: true,
+            inclusionHbA1c: true,
+          },
+        })
+      );
+
+      expect(result).toBe(true);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("correctly evaluates when any inclusion criteria is false", () => {
+      const result = evaluateBoolean(
+        "inclusionAge = true and inclusionDiagnosis = true and inclusionHbA1c = true",
+        createContext({
+          data: {
+            inclusionAge: true,
+            inclusionDiagnosis: false,
+            inclusionHbA1c: true,
+          },
+        })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("returns false without warning when field is undefined (feelin equality behavior)", () => {
+      // In feelin, undefined = true returns false, not null
+      // This means no warning is triggered, but result is still false
+      const result = evaluateBoolean(
+        "inclusionAge = true and inclusionDiagnosis = true and inclusionHbA1c = true",
+        createContext({
+          data: {
+            inclusionAge: true,
+            // inclusionDiagnosis not yet answered
+            inclusionHbA1c: true,
+          },
+        })
+      );
+
+      expect(result).toBe(false);
+      // No warning because feelin returns false for undefined = true
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("null-safe pattern detects unanswered fields (feelin behavior)", () => {
+      // In feelin, equality check on undefined returns false
+      // So (undefined = true or undefined = false) = (false or false) = false
+      const allAnswered = evaluateBoolean(
+        "(inclusionAge = true or inclusionAge = false) and (inclusionDiagnosis = true or inclusionDiagnosis = false)",
+        createContext({
+          data: {
+            inclusionAge: true,
+            // inclusionDiagnosis not yet answered
+          },
+        })
+      );
+
+      expect(allAnswered).toBe(false);
+      // No warning because equality checks don't return null in feelin
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("!= true on undefined returns true in feelin", () => {
+      // In feelin, undefined != true returns true
+      // This is useful for checking "not true" conditions
+      const result = evaluateBoolean(
+        "signingOnBehalf != true",
+        createContext({
+          data: {
+            // signingOnBehalf not yet answered
+          },
+        })
+      );
+
+      // feelin returns true for undefined != true
+      expect(result).toBe(true);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("page visibility with computed dependencies", () => {
+    it("correctly shows page when computed eligibility is true", () => {
+      const result = evaluateBoolean(
+        "computed.eligible = true",
+        createContext({
+          data: {},
+          computed: { eligible: true },
+        })
+      );
+
+      expect(result).toBe(true);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("correctly hides page when computed eligibility is false", () => {
+      const result = evaluateBoolean(
+        "computed.eligible = true",
+        createContext({
+          data: {},
+          computed: { eligible: false },
+        })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("returns false without warning when computed is null (feelin equality behavior)", () => {
+      // In feelin, null = true returns false, not null
+      const result = evaluateBoolean(
+        "computed.eligible = true",
+        createContext({
+          data: {},
+          computed: { eligible: null },
+        })
+      );
+
+      expect(result).toBe(false);
+      // No warning because equality check returns false, not null
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("warns when computed field is used in AND with defined operand (null propagates)", () => {
+      // Using computed field directly in AND expression propagates null
+      // when the other operand is defined and evaluates to true
+      const result = evaluateBoolean(
+        "computed.eligible and otherCondition = true",
+        createContext({
+          data: { otherCondition: true },
+          computed: { eligible: null },
+        })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("returned null")
+      );
+    });
+
+    it("no warning when computed null and other operand undefined (short-circuit to false)", () => {
+      // When other operand is undefined, feelin returns false immediately
+      const result = evaluateBoolean(
+        "computed.eligible and otherCondition = true",
+        createContext({
+          data: {},
+          computed: { eligible: null },
+        })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("string validation scenarios", () => {
+    it("warns when validating string length of undefined field", () => {
+      // This is a common pattern that triggers warnings
+      const result = evaluateBoolean(
+        "string length(signature) > 0",
+        createContext({ data: {} })
+      );
+
+      expect(result).toBe(false);
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it("no warning when field has value", () => {
+      const result = evaluateBoolean(
+        "string length(signature) > 0",
+        createContext({ data: { signature: "John Doe" } })
+      );
+
+      expect(result).toBe(true);
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+
+    it("no warning when null check precedes string length", () => {
+      // Proper null-safe pattern: check != null first
+      const result = evaluateBoolean(
+        "signature != null and string length(signature) > 0",
+        createContext({ data: {} })
+      );
+
+      expect(result).toBe(false);
+      // The != null check short-circuits, so string length is not evaluated
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
+    });
+  });
+});