refactor(test): reorganize integration tests by functionality

Split the large integration.test.ts file into 7 feature-specific test files:
- integration.basic.test.ts: basic operations and variables
- integration.boolean.test.ts: boolean logic
- integration.math.test.ts: Math functions
- integration.objects.test.ts: object access and methods
- integration.functions.test.ts: custom functions
- integration.optimization.test.ts: optimization options
- integration.complex.test.ts: complex scenarios

Author: codehz

src/integration.basic.test.ts

@@ -0,0 +1,100 @@
+import { expect, test } from "bun:test";
+import { z } from "zod";
+import { compile, evaluate, expr, variable } from "./index";
+
+test("集成测试：完整的表达式流程", () => {
+  // 定义变量
+  const x = variable(z.number());
+  const y = variable(z.number());
+
+  // 构建表达式
+  const sum = expr({ x, y })("x + y");
+  const product = expr({ x, y })("x * y");
+  const result = expr({ sum, product })("sum + product");
+
+  // 编译（默认内联优化）
+  const data = compile(result, { x, y });
+  expect(data[0]).toEqual(["x", "y"]);
+  expect(data.length).toBe(2); // 变量名 + 内联后的单个表达式
+
+  // 执行
+  const value = evaluate<number>(data, { x: 2, y: 3 });
+  expect(value).toBe(11); // 2+3 + 2*3 = 5 + 6 = 11
+});
+
+test("集成测试：基础变量和表达式", () => {
+  const a = variable(z.number());
+  const b = variable(z.number());
+
+  const simple = expr({ a, b })("a + b");
+  const compiled = compile(simple, { a, b });
+
+  const result = evaluate<number>(compiled, { a: 10, b: 20 });
+  expect(result).toBe(30);
+});
+
+test("集成测试：多层嵌套表达式", () => {
+  const a = variable(z.number());
+  const b = variable(z.number());
+  const c = variable(z.number());
+
+  const layer1 = expr({ a, b })("a + b");
+  const layer2 = expr({ layer1, c })("layer1 * c");
+  const layer3 = expr({ layer2 })("layer2 + 1");
+
+  const compiled = compile(layer3, { a, b, c });
+
+  // 验证编译结果的结构
+  expect(compiled[0]).toEqual(["a", "b", "c"]);
+
+  // 执行
+  const result = evaluate<number>(compiled, { a: 2, b: 3, c: 4 });
+  // (2+3) * 4 + 1 = 5 * 4 + 1 = 20 + 1 = 21
+  expect(result).toBe(21);
+});
+
+test("集成测试：连续算术运算", () => {
+  const x = variable(z.number());
+
+  const expr1 = expr({ x })("x + 1");
+  const expr2 = expr({ expr1 })("expr1 * 2");
+  const expr3 = expr({ expr2 })("expr3 - 3");
+
+  // 此处应该捕获错误：expr3 在上下文中不存在
+  expect(() => {
+    compile(expr3, { x });
+  }).toThrow();
+});
+
+test("集成测试：正确的链式计算", () => {
+  const x = variable(z.number());
+
+  const expr1 = expr({ x })("x + 1");
+  const expr2 = expr({ expr1 })("expr1 * 2");
+  const expr3 = expr({ expr2 })("expr2 - 3");
+
+  const compiled = compile(expr3, { x });
+  const result = evaluate<number>(compiled, { x: 5 });
+  // ((5+1)*2) - 3 = (6*2) - 3 = 12 - 3 = 9
+  expect(result).toBe(9);
+});
+
+test("集成测试：简单字符串表达式", () => {
+  const a = variable(z.string());
+  const b = variable(z.string());
+
+  const combined = expr({ a, b })("a + b");
+  const compiled = compile(combined, { a, b });
+  const result = evaluate<string>(compiled, { a: "Hello", b: "World" });
+  expect(result).toBe("HelloWorld");
+});
+
+test("集成测试：数字类型保持一致", () => {
+  const p = variable(z.number());
+  const q = variable(z.number());
+
+  const calc = expr({ p, q })("p + q * 2");
+  const compiled = compile(calc, { p, q });
+  const result = evaluate<number>(compiled, { p: 10, q: 5 });
+  expect(result).toBe(20); // 10 + 5*2 = 10 + 10 = 20
+});

src/integration.boolean.test.ts

@@ -0,0 +1,36 @@
+import { expect, test } from "bun:test";
+import { z } from "zod";
+import { compile, evaluate, expr, variable } from "./index";
+
+test("集成测试：布尔表达式", () => {
+  const age = variable(z.number());
+
+  const isAdult = expr({ age })("age >= 18");
+  const compiled = compile(isAdult, { age });
+
+  const result1 = evaluate<boolean>(compiled, { age: 25 });
+  expect(result1).toBe(true);
+
+  const result2 = evaluate<boolean>(compiled, { age: 15 });
+  expect(result2).toBe(false);
+});
+
+test("集成测试：多变量布尔逻辑", () => {
+  const x = variable(z.number());
+  const y = variable(z.number());
+
+  const isGreater = expr({ x, y })("x > y");
+  const isEqual = expr({ x, y })("x === y");
+  const combined = expr({ isGreater, isEqual })("isGreater || isEqual");
+
+  const compiled = compile(combined, { x, y });
+
+  const result1 = evaluate<boolean>(compiled, { x: 10, y: 5 });
+  expect(result1).toBe(true); // 10 > 5
+
+  const result2 = evaluate<boolean>(compiled, { x: 5, y: 5 });
+  expect(result2).toBe(true); // 5 === 5
+
+  const result3 = evaluate<boolean>(compiled, { x: 3, y: 7 });
+  expect(result3).toBe(false); // !(3 > 7) && !(3 === 7)
+});

src/integration.complex.test.ts

@@ -0,0 +1,120 @@
+import { expect, test } from "bun:test";
+import { z } from "zod";
+import { compile, evaluate, expr, variable } from "./index";
+
+test("集成测试：复杂的数学运算", () => {
+  const x = variable(z.number());
+  const y = variable(z.number());
+
+  const expr1 = expr({ x, y })("x * y");
+  const expr2 = expr({ x, y })("x + y");
+  const expr3 = expr({ expr1, expr2 })("expr1 - expr2");
+
+  const compiled = compile(expr3, { x, y });
+  const result = evaluate<number>(compiled, { x: 5, y: 3 });
+  // 5*3 - (5+3) = 15 - 8 = 7
+  expect(result).toBe(7);
+});
+
+test("集成测试：多个独立表达式链", () => {
+  const a = variable(z.number());
+  const b = variable(z.number());
+  const c = variable(z.number());
+
+  // 链 1: a 和 b
+  const sum = expr({ a, b })("a + b");
+
+  // 链 2: 从链1和 c
+  const multiple = expr({ sum, c })("sum * c");
+
+  // 链 3: 从链2
+  const final = expr({ multiple })("multiple + 10");
+
+  const compiled = compile(final, { a, b, c });
+  const result = evaluate<number>(compiled, { a: 1, b: 2, c: 3 });
+  // ((1+2)*3) + 10 = (3*3) + 10 = 9 + 10 = 19
+  expect(result).toBe(19);
+});
+
+test("集成测试：对象属性与函数组合", () => {
+  // 测试表达式 double(obj.value)，组合对象属性和函数调用
+  const double = variable(z.function({ input: [z.number()], output: z.number() }));
+  const obj = variable(
+    z.object({
+      value: z.number(),
+    })
+  );
+
+  const combinedExpr = expr({ double, obj })("double(obj.value)");
+  const combinedCompiled = compile(combinedExpr, { double, obj });
+
+  const result = evaluate<number>(combinedCompiled, {
+    double: (n: number) => n * 2,
+    obj: { value: 15 },
+  });
+  expect(result).toBe(30);
+});
+
+test("集成测试：嵌套的方法调用与运算", () => {
+  // 测试表达式 obj.user.age * 2 或类似的组合
+  const obj = variable(
+    z.object({
+      user: z.object({
+        name: z.string(),
+        age: z.number(),
+      }),
+    })
+  );
+
+  const ageCalcExpr = expr({ obj })("obj.user.age * 2");
+  const ageCalcCompiled = compile(ageCalcExpr, { obj });
+
+  const result = evaluate<number>(ageCalcCompiled, {
+    obj: { user: { name: "Charlie", age: 25 } },
+  });
+  expect(result).toBe(50);
+
+  // 更复杂的计算
+  const complexExpr = expr({ obj })("obj.user.age * 2 + 10");
+  const complexCompiled = compile(complexExpr, { obj });
+
+  const complexResult = evaluate<number>(complexCompiled, {
+    obj: { user: { name: "Diana", age: 30 } },
+  });
+  expect(complexResult).toBe(70); // 30 * 2 + 10 = 70
+});
+
+test("集成测试：在复杂表达式中使用多个导入", () => {
+  // 使用多个对象和函数的组合表达式
+  const multiply = variable(z.function({ input: [z.number(), z.number()], output: z.number() }));
+  const add = variable(z.function({ input: [z.number(), z.number()], output: z.number() }));
+
+  const data = variable(
+    z.object({
+      x: z.number(),
+      y: z.number(),
+    })
+  );
+
+  // 复合表达式：multiply(data.x, data.y) + add(data.x, data.y)
+  const complexExpr = expr({ multiply, add, data })("multiply(data.x, data.y) + add(data.x, data.y)");
+  const complexCompiled = compile(complexExpr, { multiply, add, data });
+
+  const result = evaluate<number>(complexCompiled, {
+    multiply: (a: number, b: number) => a * b,
+    add: (a: number, b: number) => a + b,
+    data: { x: 3, y: 4 },
+  });
+  expect(result).toBe(19); // (3*4) + (3+4) = 12 + 7 = 19
+
+  // 另一个组合：multiply(add(data.x, data.y), data.x)
+  const nestedExpr = expr({ multiply, add, data })("multiply(add(data.x, data.y), data.x)");
+  const nestedCompiled = compile(nestedExpr, { multiply, add, data });
+
+  const nestedResult = evaluate<number>(nestedCompiled, {
+    multiply: (a: number, b: number) => a * b,
+    add: (a: number, b: number) => a + b,
+    data: { x: 5, y: 2 },
+  });
+  expect(nestedResult).toBe(35); // (5+2) * 5 = 7 * 5 = 35
+});

src/integration.functions.test.ts

@@ -0,0 +1,66 @@
+import { expect, test } from "bun:test";
+import { z } from "zod";
+import { compile, evaluate, expr, variable } from "./index";
+
+test("集成测试：基础函数调用", () => {
+  // 定义单参数函数 double(x: number) => x * 2
+  const double = variable(z.function({ input: [z.number()], output: z.number() }));
+  const x = variable(z.number());
+
+  const doubleCallExpr = expr({ double, x })("double(x)");
+  const doubleCompiled = compile(doubleCallExpr, { double, x });
+
+  const result = evaluate<number>(doubleCompiled, {
+    double: (n: number) => n * 2,
+    x: 5,
+  });
+  expect(result).toBe(10);
+});
+
+test("集成测试：多参数函数", () => {
+  // 定义多参数函数 add(a: number, b: number) => a + b
+  const add = variable(z.function({ input: [z.number(), z.number()], output: z.number() }));
+  const a = variable(z.number());
+  const b = variable(z.number());
+
+  const addExpr = expr({ add, a, b })("add(a, b)");
+  const addCompiled = compile(addExpr, { add, a, b });
+
+  const result = evaluate<number>(addCompiled, {
+    add: (x: number, y: number) => x + y,
+    a: 7,
+    b: 3,
+  });
+  expect(result).toBe(10);
+
+  // 测试另外的值
+  const result2 = evaluate<number>(addCompiled, {
+    add: (x: number, y: number) => x + y,
+    a: 100,
+    b: 50,
+  });
+  expect(result2).toBe(150);
+});
+
+test("集成测试：函数返回对象", () => {
+  // 定义返回对象的函数 getUser() => ({ name: string, age: number })
+  const getUser = variable(z.function({ input: [], output: z.object({ name: z.string(), age: z.number() }) }));
+
+  // 调用函数并访问返回对象的属性
+  const userNameExpr = expr({ getUser })("getUser().name");
+  const userNameCompiled = compile(userNameExpr, { getUser });
+
+  const result = evaluate<string>(userNameCompiled, {
+    getUser: () => ({ name: "Bob", age: 28 }),
+  });
+  expect(result).toBe("Bob");
+
+  // 访问返回对象的 age 属性
+  const userAgeExpr = expr({ getUser })("getUser().age");
+  const userAgeCompiled = compile(userAgeExpr, { getUser });
+
+  const ageResult = evaluate<number>(userAgeCompiled, {
+    getUser: () => ({ name: "Bob", age: 28 }),
+  });
+  expect(ageResult).toBe(28);
+});