@nudojs/cli 0.2.1 → 0.3.0

package/src/__tests__/narrowing.test.ts

@@ -1,82 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { T, typeValueEquals, typeValueToString, createEnvironment } from "@nudojs/core";
-import { parse } from "@nudojs/parser";
-import { narrow } from "../narrowing.ts";
-import type { ExpressionStatement } from "@babel/types";
-
-function getTestExpr(source: string) {
-  const ast = parse(source);
-  const stmt = ast.program.body[0] as ExpressionStatement;
-  return stmt.expression;
-}
-
-describe("narrow: typeof", () => {
-  it("narrows typeof x === 'number' on union", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.number, T.string));
-    const expr = getTestExpr('typeof x === "number"');
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.number)).toBe(true);
-    expect(typeValueEquals(falseEnv.lookup("x"), T.string)).toBe(true);
-  });
-
-  it("narrows typeof x === 'string' on union", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.number, T.string, T.boolean));
-    const expr = getTestExpr('typeof x === "string"');
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.string)).toBe(true);
-    const falseType = falseEnv.lookup("x");
-    expect(typeValueToString(falseType)).toBe("number | boolean");
-  });
-
-  it("narrows typeof x !== 'number' (inverted)", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.number, T.string));
-    const expr = getTestExpr('typeof x !== "number"');
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.string)).toBe(true);
-    expect(typeValueEquals(falseEnv.lookup("x"), T.number)).toBe(true);
-  });
-});
-
-describe("narrow: strict equality", () => {
-  it("narrows x === null", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.null, T.number));
-    const expr = getTestExpr("x === null");
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.null)).toBe(true);
-    expect(typeValueEquals(falseEnv.lookup("x"), T.number)).toBe(true);
-  });
-
-  it("narrows x === 1", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.literal(1), T.literal(2), T.literal(3)));
-    const expr = getTestExpr("x === 1");
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.literal(1))).toBe(true);
-    const falseType = falseEnv.lookup("x");
-    expect(typeValueToString(falseType)).toBe("2 | 3");
-  });
-
-  it("narrows x !== 1 (inverted)", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.literal(1), T.literal(2)));
-    const expr = getTestExpr("x !== 1");
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.literal(2))).toBe(true);
-    expect(typeValueEquals(falseEnv.lookup("x"), T.literal(1))).toBe(true);
-  });
-});
-
-describe("narrow: negation", () => {
-  it("narrows !(typeof x === 'number')", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.number, T.string));
-    const expr = getTestExpr('!(typeof x === "number")');
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.string)).toBe(true);
-    expect(typeValueEquals(falseEnv.lookup("x"), T.number)).toBe(true);
-  });
-});

package/src/__tests__/nudo-mock-syntax.test.ts

@@ -1,245 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parse, extractDirectives, type CaseDirective, type MockDirective, parseTypeValueExpr } from "@nudojs/parser";
-import { typeValueToString, createEnvironment, T, mockHelperToTypeValue } from "@nudojs/core";
-import { evaluateFunctionFull } from "../evaluator.js";
-
-function runNudoTest(source: string): { name: string; caseName: string; result: string }[] {
-  const ast = parse(source);
-  const directives = extractDirectives(ast);
-  const env = createEnvironment();
-  const results: { name: string; caseName: string; result: string }[] = [];
-
-  for (const fn of directives) {
-    for (const d of fn.directives) {
-      if (d.kind === "mock") {
-        if (d.arrowFn) {
-          const fnType = T.fn(d.arrowFn.params, d.arrowFn.body, env);
-          (fnType as any)._paramPatterns = d.arrowFn.paramPatterns;
-          env.bind(d.name, fnType);
-        } else if (d.nudoMock) {
-          const typeVal = mockHelperToTypeValue(d.nudoMock, env);
-          env.bind(d.name, typeVal);
-        } else if (d.sinonExpr) {
-          // Handle sinon expressions
-          const body = { type: "BlockStatement", body: [] } as any;
-          const fn = T.fn(["...args"], body, env);
-          if (d.sinonExpr.returnValue) {
-            (fn as any)._directReturn = d.sinonExpr.returnValue;
-          } else if (d.sinonExpr.resolvedValue) {
-            (fn as any)._directReturn = T.promise(d.sinonExpr.resolvedValue);
-          } else if (d.sinonExpr.rejectedValue) {
-            (fn as any)._directReturn = T.never;
-          } else {
-            (fn as any)._directReturn = T.unknown;
-          }
-          env.bind(d.name, fn);
-        } else if (d.expression) {
-          env.bind(d.name, parseTypeValueExpr(d.expression));
-        }
-      }
-    }
-
-    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
-    for (const dir of caseDirectives) {
-      const result = evaluateFunctionFull(fn.node, dir.args, env);
-      results.push({
-        name: fn.name,
-        caseName: dir.name,
-        result: typeValueToString(result.value),
-      });
-    }
-  }
-  return results;
-}
-
-describe("Nudo Mock Helper Syntax", () => {
-  it("stub() should bind as a function returning unknown", () => {
-    const results = runNudoTest(`
-// @nudo:mock handler = stub()
-// @nudo:case "test" (42)
-function testFn(x) {
-  return handler(x);
-}
-`);
-    expect(results[0].result).toBe("unknown");
-  });
-
-  it("stub().returns({ status: 200 }) should return the specified value", () => {
-    const results = runNudoTest(`
-// @nudo:mock fetch = stub().returns({ status: 200, data: { ok: true } })
-// @nudo:case "api" ("/users")
-function fetchUsers(url) {
-  return fetch(url);
-}
-`);
-    expect(results[0].result).toContain("status: 200");
-    expect(results[0].result).toContain("ok: true");
-  });
-
-  it("stub().resolves('hello') should return Promise<\"hello\">", () => {
-    const results = runNudoTest(`
-// @nudo:mock fetchData = stub().resolves("hello")
-// @nudo:case "async" ()
-function getData() {
-  return fetchData();
-}
-`);
-    expect(results[0].result).toBe('Promise<"hello">');
-  });
-
-  it("spy() should bind as a function returning unknown", () => {
-    const results = runNudoTest(`
-// @nudo:mock listener = spy()
-// @nudo:case "event" ({ type: "click" })
-function handleEvent(event) {
-  return listener(event);
-}
-`);
-    expect(results[0].result).toBe("unknown");
-  });
-
-  it("mock() should bind as a function returning unknown", () => {
-    const results = runNudoTest(`
-// @nudo:mock service = mock()
-// @nudo:case "call" ()
-function useService() {
-  return service();
-}
-`);
-    expect(results[0].result).toBe("unknown");
-  });
-
-  it("stub().returns with complex object", () => {
-    const results = runNudoTest(`
-// @nudo:mock httpClient = stub().returns({ status: 200, data: { users: [{ id: 1, name: "Alice" }] } })
-// @nudo:case "users" ()
-function getUsers() {
-  const response = httpClient();
-  return response.data.users;
-}
-`);
-    expect(results[0].result).toContain("id: 1");
-    expect(results[0].result).toContain("name: \"Alice\"");
-  });
-
-  it("mixed nudo mocks and arrow function mocks", () => {
-    const results = runNudoTest(`
-// @nudo:mock validate = (x) => x !== null
-// @nudo:mock transform = stub().returns({ processed: true })
-// @nudo:case "mix" (42)
-function process(x) {
-  if (!validate(x)) return null;
-  return transform(x);
-}
-`);
-    expect(results[0].result).toContain("processed: true");
-  });
-});
-
-describe("Chain call syntax", () => {
-  it("stub().returns(v).onFirstCall() should parse and use returns value", () => {
-    const results = runNudoTest(`
-// @nudo:mock handler = stub().returns(42).onFirstCall()
-// @nudo:case "test" ()
-function fn() {
-  return handler();
-}
-`);
-    expect(results[0].result).toBe("42");
-  });
-
-  it("stub().callsFake(expr) should parse", () => {
-    const results = runNudoTest(`
-// @nudo:mock transform = stub().callsFake((x) => x)
-// @nudo:case "test" (21)
-function fn(x) {
-  return transform(x);
-}
-`);
-    expect(results[0].result).toBeDefined();
-  });
-
-  it("spy().returns(v) should parse", () => {
-    const results = runNudoTest(`
-// @nudo:mock listener = spy().returns({ handled: true })
-// @nudo:case "test" ()
-function fn() {
-  return listener();
-}
-`);
-    expect(results[0].result).toContain("handled: true");
-  });
-
-  it("stub().withArgs(a, b).returns(v) should parse", () => {
-    const results = runNudoTest(`
-// @nudo:mock fetch = stub().withArgs("GET", "/api").returns({ status: 200 })
-// @nudo:case "test" ()
-function fn() {
-  return fetch("GET", "/api");
-}
-`);
-    expect(results[0].result).toContain("status: 200");
-  });
-});
-
-describe("callsFake execution semantics (unified stub/sinon paths)", () => {
-  it("stub().callsFake lifts the fake onto arrowFn (same binding as plain arrow mocks)", () => {
-    const ast = parse(`
-// @nudo:mock transform = stub().callsFake((x) => ({ v: x }))
-function applyTransform(x) {
-  return transform(x);
-}
-`);
-    const directives = extractDirectives(ast);
-    const mockDir = directives[0].directives.find((d): d is MockDirective => d.kind === "mock")!;
-    // 与 @nudo:mock f = (x) => ... 相同的 arrowFn 形态：T.fn + _paramPatterns + 全局 env
-    expect(mockDir.arrowFn).toBeDefined();
-    expect(mockDir.arrowFn!.params).toEqual(["x"]);
-  });
-
-  it("stub().callsFake((x) => ({ v: x })) direct call with 21 yields { v: 21 }", () => {
-    const results = runNudoTest(`
-// @nudo:mock transform = stub().callsFake((x) => ({ v: x }))
-// @nudo:case "direct" (21)
-function applyTransform(x) {
-  return transform(x);
-}
-`);
-    expect(results[0].result).toBe("{ v: 21 }");
-  });
-
-  it("sinon.stub().callsFake((x) => ({ v: x })) direct call with 21 yields { v: 21 }", () => {
-    const results = runNudoTest(`
-// @nudo:mock transform = sinon.stub().callsFake((x) => ({ v: x }))
-// @nudo:case "direct" (21)
-function applyTransform(x) {
-  return transform(x);
-}
-`);
-    expect(results[0].result).toBe("{ v: 21 }");
-  });
-
-  it("callsFake propagates precisely through arr.map(transform) HOF", () => {
-    const results = runNudoTest(`
-// @nudo:mock transform = stub().callsFake((x) => ({ v: x }))
-// @nudo:case "hof" ([1, 2, 3])
-function mapAll(arr) {
-  return arr.map(transform);
-}
-`);
-    expect(results[0].result).toBe("[{ v: 1 }, { v: 2 }, { v: 3 }]");
-  });
-
-  it("withArgs(...).returns(...) mixed chain: matched args win, unmatched use default stub behavior", () => {
-    const results = runNudoTest(`
-// @nudo:mock handler = stub().withArgs(21).returns("hit")
-// @nudo:case "match" (21)
-// @nudo:case "miss" (22)
-function call(x) {
-  return handler(x);
-}
-`);
-    expect(results[0].result).toBe('"hit"');
-    expect(results[1].result).toBe("unknown");
-  });
-});