pi-harness-runtime 1.1.439 → 1.1.441

package/packages/test-data-generator/test/generator.test.ts

@@ -1,265 +0,0 @@
-/**
- * Test Data Generator - Tests
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	createTestDataGenerator,
-	createFaker,
-	SDK_VERSION,
-} from "../src/index.js";
-
-describe("TestDataGenerator", () => {
-	describe("SDK_VERSION", () => {
-		it("should export SDK_VERSION", () => {
-			expect(SDK_VERSION).toBeDefined();
-			expect(typeof SDK_VERSION).toBe("string");
-		});
-	});
-
-	describe("createFaker", () => {
-		it("should create faker instance with seed", () => {
-			const faker = createFaker(12345);
-			expect(faker).toBeDefined();
-		});
-
-		it("should generate consistent data with same seed", () => {
-			const faker1 = createFaker(99999);
-			const faker2 = createFaker(99999);
-
-			const name1 = faker1.fullName();
-			const name2 = faker2.fullName();
-
-			expect(name1).toBe(name2);
-		});
-	});
-
-	describe("createTestDataGenerator", () => {
-		it("should create a test data generator instance", () => {
-			const generator = createTestDataGenerator();
-			expect(generator).toBeDefined();
-		});
-
-		it("should create with custom config", () => {
-			const generator = createTestDataGenerator({
-				seed: 12345,
-				verbose: true,
-			});
-			expect(generator).toBeDefined();
-		});
-	});
-
-	describe("data generation", () => {
-		const generator = createTestDataGenerator({
-			seed: 12345,
-		});
-
-		it("should generate data from schema", async () => {
-			const result = await generator.generate({
-				schema: {
-					name: "TestUser",
-					fields: [
-						{ name: "email", type: "email" },
-						{ name: "name", type: "fullName" },
-					],
-				},
-				count: 1,
-			});
-
-			expect(result.success).toBe(true);
-			expect(result.records.length).toBe(1);
-			expect(result.records[0].data.email).toContain("@");
-		});
-
-		it("should generate multiple records", async () => {
-			const result = await generator.generate({
-				schema: {
-					name: "Users",
-					fields: [{ name: "name", type: "firstName" }],
-				},
-				count: 5,
-			});
-
-			expect(result.count).toBe(5);
-			expect(result.records.length).toBe(5);
-		});
-
-		it("should generate different data each run", async () => {
-			const gen1 = createTestDataGenerator({ seed: Date.now() });
-			const gen2 = createTestDataGenerator({ seed: Date.now() + 1 });
-
-			const result1 = await gen1.generate({
-				schema: {
-					name: "Random",
-					fields: [
-						{ name: "value", type: "number", options: { min: 1, max: 1000 } },
-					],
-				},
-				count: 1,
-			});
-
-			const result2 = await gen2.generate({
-				schema: {
-					name: "Random",
-					fields: [
-						{ name: "value", type: "number", options: { min: 1, max: 1000 } },
-					],
-				},
-				count: 1,
-			});
-
-			// Different seeds should produce different results
-			expect(typeof result1.records[0].data.value).toBe("number");
-			expect(typeof result2.records[0].data.value).toBe("number");
-		});
-
-		it("should validate required fields", async () => {
-			const result = await generator.generate({
-				schema: {
-					name: "Required",
-					fields: [{ name: "name", type: "string", required: true }],
-				},
-				count: 1,
-			});
-
-			expect(result.success).toBe(true);
-		});
-
-		it("should use default values", async () => {
-			const result = await generator.generate({
-				schema: {
-					name: "WithDefaults",
-					fields: [
-						{
-							name: "status",
-							type: "enum",
-							options: { values: ["active"] },
-							default: "active",
-						},
-					],
-				},
-				count: 1,
-			});
-
-			expect(result.records[0].data.status).toBe("active");
-		});
-
-		it("should record generation time", async () => {
-			const result = await generator.generate({
-				schema: {
-					name: "Timing",
-					fields: [{ name: "value", type: "number" }],
-				},
-				count: 1,
-			});
-
-			expect(result.generationTimeMs).toBeGreaterThanOrEqual(0);
-		});
-	});
-
-	describe("field types", () => {
-		const generator = createTestDataGenerator({ seed: 12345 });
-
-		it("should generate string fields", async () => {
-			const result = await generator.generate({
-				schema: {
-					name: "Strings",
-					fields: [
-						{
-							name: "text",
-							type: "string",
-							options: { minLength: 5, maxLength: 10 },
-						},
-					],
-				},
-				count: 1,
-			});
-
-			const text = result.records[0].data.text as string;
-			expect(text.length).toBeGreaterThanOrEqual(5);
-			expect(text.length).toBeLessThanOrEqual(10);
-		});
-
-		it("should generate number fields", async () => {
-			const result = await generator.generate({
-				schema: {
-					name: "Numbers",
-					fields: [
-						{ name: "age", type: "number", options: { min: 18, max: 99 } },
-					],
-				},
-				count: 1,
-			});
-
-			const age = result.records[0].data.age as number;
-			expect(age).toBeGreaterThanOrEqual(18);
-			expect(age).toBeLessThanOrEqual(99);
-		});
-
-		it("should generate boolean fields", async () => {
-			const result = await generator.generate({
-				schema: {
-					name: "Booleans",
-					fields: [{ name: "active", type: "boolean" }],
-				},
-				count: 1,
-			});
-
-			const active = result.records[0].data.active;
-			expect(typeof active).toBe("boolean");
-		});
-
-		it("should generate enum fields", async () => {
-			const result = await generator.generate({
-				schema: {
-					name: "Enums",
-					fields: [
-						{
-							name: "status",
-							type: "enum",
-							options: { values: ["pending", "active", "done"] },
-						},
-					],
-				},
-				count: 10,
-			});
-
-			const statuses = result.records.map((r) => r.data.status);
-			statuses.forEach((status) => {
-				expect(["pending", "active", "done"]).toContain(status);
-			});
-		});
-	});
-
-	describe("schema registration", () => {
-		const generator = createTestDataGenerator();
-
-		it("should register schemas", () => {
-			generator.registerSchema({
-				name: "RegisteredUser",
-				fields: [{ name: "email", type: "email" }],
-			});
-
-			const schema = generator.getSchema("RegisteredUser");
-			expect(schema).toBeDefined();
-			expect(schema?.name).toBe("RegisteredUser");
-		});
-
-		it("should generate using registered schema", async () => {
-			generator.registerSchema({
-				name: "Product",
-				fields: [
-					{ name: "name", type: "company" },
-					{ name: "price", type: "number", options: { min: 1, max: 100 } },
-				],
-			});
-
-			const result = await generator.generate({
-				schemaId: "Product",
-				count: 1,
-			});
-
-			expect(result.success).toBe(true);
-		});
-	});
-});

package/packages/test-generator/test/generator.test.ts

@@ -1,156 +0,0 @@
-/**
- * Test Generator Tests (RFC-0013)
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	detectAssertions,
-	generateUnitTests,
-	generateE2ETests,
-	generateMockFixtures,
-} from "../src/index.js";
-import type { SourceFile, TestScenario } from "../src/index.js";
-
-const src = (content: string): SourceFile => ({
-	path: "src/math.ts",
-	content,
-	language: "typescript",
-});
-
-describe("detectAssertions", () => {
-	it("detects .toBe", () => {
-		const s = src("expect(result).toBe(42);");
-		const assertions = detectAssertions(s);
-		expect(assertions.length).toBeGreaterThan(0);
-		expect(assertions[0].type).toBe("equality");
-	});
-
-	it("detects .toEqual", () => {
-		const s = src("expect(result).toEqual({ ok: true });");
-		const assertions = detectAssertions(s);
-		expect(assertions.some((a) => a.type === "equality")).toBe(true);
-	});
-
-	it("detects .toThrow", () => {
-		const s = src("expect(() => run()).toThrow();");
-		const assertions = detectAssertions(s);
-		expect(assertions.some((a) => a.type === "exception")).toBe(true);
-	});
-
-	it("detects truthiness", () => {
-		const s = src("expect(value).toBeTruthy();");
-		const assertions = detectAssertions(s);
-		expect(assertions.some((a) => a.type === "truthiness")).toBe(true);
-	});
-
-	it("returns empty for clean code", () => {
-		const s = src("const x = 1; const y = 2;");
-		expect(detectAssertions(s).length).toBe(0);
-	});
-
-	it("includes line number", () => {
-		const s = src("const x = 1;\nexpect(x).toBe(1);");
-		const assertions = detectAssertions(s);
-		expect(assertions[0].line).toBe(2);
-	});
-});
-
-describe("generateUnitTests", () => {
-	it("generates test content", () => {
-		const s = src(
-			"export function add(a: number, b: number): number { return a + b; }",
-		);
-		const test = generateUnitTests(s);
-		expect(test.content).toContain("describe(");
-		expect(test.content).toContain("it(");
-		expect(test.fileName).toContain(".test.ts");
-	});
-
-	it("uses bun test imports by default", () => {
-		const s = src("function fn() {}");
-		const test = generateUnitTests(s);
-		expect(test.content).toContain('from "bun:test"');
-	});
-
-	it("uses vitest for vitest framework", () => {
-		const s = src("function fn() {}");
-		const test = generateUnitTests(s, "vitest");
-		expect(test.content).toContain("vitest");
-	});
-
-	it("uses playwright for playwright framework", () => {
-		const s = src("function fn() {}");
-		const test = generateUnitTests(s, "playwright");
-		expect(test.content).toContain("playwright");
-		expect(test.testCount).toBeGreaterThan(0);
-	});
-
-	it("extracts function name", () => {
-		const s = src("export const multiply = (a: number, b: number) => a * b;");
-		const test = generateUnitTests(s);
-		expect(test.content).toContain("multiply");
-	});
-
-	it("handles anonymous function", () => {
-		const s = src("const fn = function() {};");
-		const test = generateUnitTests(s);
-		expect(test.content).toContain("describe(");
-	});
-});
-
-describe("generateE2ETests", () => {
-	it("generates playwright test from scenario", () => {
-		const scenario: TestScenario = {
-			name: "Login Flow",
-			description: "User logs in",
-			steps: [
-				"navigate:https://example.com/login",
-				"click:#username",
-				"assert:.error",
-			],
-			expectedResult: "User sees login form",
-			mockFixtures: [],
-		};
-		const tests = generateE2ETests([scenario]);
-		expect(tests).toHaveLength(1);
-		expect(tests[0].content).toContain("Login Flow");
-		expect(tests[0].framework).toBe("playwright");
-	});
-
-	it("generates correct step content", () => {
-		const scenario: TestScenario = {
-			name: "Navigate",
-			description: "",
-			steps: ["navigate:https://example.com"],
-			expectedResult: "",
-			mockFixtures: [],
-		};
-		const tests = generateE2ETests([scenario]);
-		expect(tests[0].content).toContain('page.goto("https://example.com")');
-	});
-});
-
-describe("generateMockFixtures", () => {
-	it("extracts typed variables", () => {
-		const s = src("const name: string = 'Alice'; const count: number = 42;");
-		const fixtures = generateMockFixtures(s);
-		expect(fixtures.some((f) => f.name === "name" && f.type === "string")).toBe(
-			true,
-		);
-		expect(
-			fixtures.some((f) => f.name === "count" && f.type === "number"),
-		).toBe(true);
-	});
-
-	it("maps types to values", () => {
-		const s = src("const flag: boolean = true;");
-		const fixtures = generateMockFixtures(s);
-		expect(fixtures[0].value).toBe("true");
-	});
-
-	it("defaults unknown types to null", () => {
-		const s = src("const custom: CustomType = x;");
-		const fixtures = generateMockFixtures(s);
-		expect(fixtures[0].value).toBe("null");
-	});
-});

package/packages/token-estimation/test/token-estimation.test.ts

@@ -1,207 +0,0 @@
-/**
- * Token Estimation Tests
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	roughTokenCount,
-	roughMessageTokens,
-	roughMessagesTokens,
-	roughSystemPromptTokens,
-	roughToolDefinitionTokens,
-	estimateRequestTokens,
-} from "../src/index";
-
-describe("roughTokenCount", () => {
-	it("returns 0 for empty string", () => expect(roughTokenCount("")).toBe(0));
-
-	it("returns 0 for null-like input", () =>
-		expect(roughTokenCount("   ")).toBeGreaterThanOrEqual(0));
-
-	it("returns positive for non-empty text", () =>
-		expect(roughTokenCount("hello world")).toBeGreaterThan(0));
-
-	it("handles unicode text", () =>
-		expect(roughTokenCount("สวัสดี")).toBeGreaterThan(0));
-
-	it("handles long text proportionally", () => {
-		const short = roughTokenCount("hi");
-		const long = roughTokenCount("hi ".repeat(100));
-		expect(long).toBeGreaterThan(short * 10);
-	});
-});
-
-describe("roughMessageTokens", () => {
-	it("adds role overhead", () => {
-		const tokens = roughMessageTokens({ role: "user", content: null });
-		expect(tokens).toBeGreaterThanOrEqual(4);
-	});
-
-	it("counts string content", () => {
-		const tokens = roughMessageTokens({
-			role: "user",
-			content: "hello world",
-		});
-		expect(tokens).toBeGreaterThanOrEqual(4 + roughTokenCount("hello world"));
-	});
-
-	it("counts text blocks in content array", () => {
-		const tokens = roughMessageTokens({
-			role: "assistant",
-			content: [{ type: "text", text: "the answer is 42" }],
-		});
-		expect(tokens).toBeGreaterThanOrEqual(
-			4 + roughTokenCount("the answer is 42"),
-		);
-	});
-
-	it("estimates tool_use blocks", () => {
-		const tokens = roughMessageTokens({
-			role: "assistant",
-			content: [
-				{
-					type: "tool_use",
-					name: "get_weather",
-					input: { city: "Bangkok" },
-				},
-			],
-		});
-		expect(tokens).toBeGreaterThan(4 + roughTokenCount("get_weather"));
-	});
-
-	it("adds overhead for tool_result blocks", () => {
-		const tokens = roughMessageTokens({
-			role: "user",
-			content: [{ type: "tool_result" }],
-		});
-		expect(tokens).toBeGreaterThanOrEqual(4 + 50);
-	});
-
-	it("estimates image blocks as 2000 tokens", () => {
-		const tokens = roughMessageTokens({
-			role: "user",
-			content: [{ type: "image" }],
-		});
-		expect(tokens).toBeGreaterThanOrEqual(4 + 2000);
-	});
-
-	it("counts tool_calls outside content", () => {
-		const tokens = roughMessageTokens({
-			role: "assistant",
-			content: null,
-			tool_calls: [{ id: "call-1", name: "search", input: { q: "test" } }],
-		});
-		expect(tokens).toBeGreaterThan(4 + roughTokenCount("search"));
-	});
-
-	it("returns 0 for null message", () =>
-		expect(roughMessageTokens(null as any)).toBe(0));
-
-	it("counts thinking blocks", () => {
-		const tokens = roughMessageTokens({
-			role: "assistant",
-			content: null,
-			thinking: "I should use the search tool here",
-		});
-		expect(tokens).toBeGreaterThanOrEqual(
-			4 + roughTokenCount("I should use the search tool here"),
-		);
-	});
-});
-
-describe("roughMessagesTokens", () => {
-	it("sums tokens from multiple messages", () => {
-		const messages = [
-			{ role: "user", content: "hello" },
-			{ role: "assistant", content: "hi there" },
-		];
-		const total = roughMessagesTokens(messages);
-		const individual =
-			roughMessageTokens({ role: "user", content: "hello" }) +
-			roughMessageTokens({ role: "assistant", content: "hi there" });
-		expect(total).toBe(individual);
-	});
-
-	it("returns 0 for empty array", () =>
-		expect(roughMessagesTokens([])).toBe(0));
-});
-
-describe("roughSystemPromptTokens", () => {
-	it("includes overhead plus content", () => {
-		const tokens = roughSystemPromptTokens("You are a helpful assistant");
-		expect(tokens).toBeGreaterThanOrEqual(
-			15 + roughTokenCount("You are a helpful assistant"),
-		);
-	});
-
-	it("handles empty system prompt", () =>
-		expect(roughSystemPromptTokens("")).toBe(15));
-});
-
-describe("roughToolDefinitionTokens", () => {
-	it("counts name, description, and input_schema", () => {
-		const tokens = roughToolDefinitionTokens({
-			name: "get_weather",
-			description: "Get current weather",
-			input_schema: {
-				type: "object",
-				properties: { city: { type: "string" } },
-			},
-		});
-		expect(tokens).toBeGreaterThanOrEqual(
-			roughTokenCount("get_weather") +
-				roughTokenCount("Get current weather") +
-				roughTokenCount(
-					'{"type":"object","properties":{"city":{"type":"string"}}}',
-				),
-		);
-	});
-
-	it("handles minimal tool with only name", () => {
-		const tokens = roughToolDefinitionTokens({ name: "ping" });
-		expect(tokens).toBeGreaterThan(0);
-	});
-});
-
-describe("estimateRequestTokens", () => {
-	it("sums system + messages + tools", () => {
-		const estimate = estimateRequestTokens(
-			"You are a helpful assistant",
-			[{ role: "user", content: "hello" }],
-			[{ name: "search", description: "Search the web" }],
-			100_000,
-		);
-		expect(estimate.total).toBeGreaterThan(estimate.systemPrompt);
-		expect(estimate.total).toBeGreaterThan(estimate.messages);
-		expect(estimate.total).toBeGreaterThan(estimate.tools);
-		expect(estimate.total).toBe(
-			estimate.systemPrompt + estimate.messages + estimate.tools,
-		);
-	});
-
-	it("computes availableForContext correctly", () => {
-		const estimate = estimateRequestTokens(
-			"system",
-			[{ role: "user", content: "msg" }],
-			[],
-			100_000,
-		);
-		expect(estimate.availableForContext).toBe(100_000 - estimate.total);
-	});
-
-	it("returns 0 available when over limit", () => {
-		const estimate = estimateRequestTokens(
-			"x".repeat(200_000),
-			[],
-			[],
-			100_000,
-		);
-		expect(estimate.availableForContext).toBeLessThan(100_000);
-	});
-
-	it("handles empty inputs", () => {
-		const estimate = estimateRequestTokens("", [], [], 100_000);
-		expect(estimate.total).toBe(15); // system overhead only
-		expect(estimate.availableForContext).toBe(100_000 - 15);
-	});
-});