gitforest 0.1.0

package/test/unit/utils/errors.test.ts

@@ -0,0 +1,295 @@
+import { describe, test, expect } from "bun:test";
+import { errorToString } from "../../../src/utils/errors";
+
+describe("errorToString", () => {
+  test("handles Error objects", () => {
+    const error = new Error("Something went wrong");
+    const result = errorToString(error);
+    expect(result).toBe("Something went wrong");
+  });
+
+  test("handles Error objects with empty message", () => {
+    const error = new Error("");
+    const result = errorToString(error);
+    expect(result).toBe("");
+  });
+
+  test("handles string errors", () => {
+    const result = errorToString("String error message");
+    expect(result).toBe("String error message");
+  });
+
+  test("handles empty string", () => {
+    const result = errorToString("");
+    expect(result).toBe("");
+  });
+
+  test("handles null", () => {
+    const result = errorToString(null);
+    expect(result).toBe("null");
+  });
+
+  test("handles undefined", () => {
+    const result = errorToString(undefined);
+    expect(result).toBe("undefined");
+  });
+
+  test("handles numbers", () => {
+    const result = errorToString(404);
+    expect(result).toBe("404");
+  });
+
+  test("handles zero", () => {
+    const result = errorToString(0);
+    expect(result).toBe("0");
+  });
+
+  test("handles negative numbers", () => {
+    const result = errorToString(-42);
+    expect(result).toBe("-42");
+  });
+
+  test("handles objects with toString", () => {
+    const obj = {
+      toString: () => "Custom error message",
+    };
+    const result = errorToString(obj);
+    expect(result).toBe("Custom error message");
+  });
+
+  test("handles plain objects", () => {
+    const obj = { key: "value" };
+    const result = errorToString(obj);
+    expect(result).toBe("[object Object]");
+  });
+
+  test("handles arrays", () => {
+    const arr = [1, 2, 3];
+    const result = errorToString(arr);
+    expect(result).toBe("1,2,3");
+  });
+
+  test("handles boolean true", () => {
+    const result = errorToString(true);
+    expect(result).toBe("true");
+  });
+
+  test("handles boolean false", () => {
+    const result = errorToString(false);
+    expect(result).toBe("false");
+  });
+
+  test("handles Symbol", () => {
+    const sym = Symbol("test");
+    const result = errorToString(sym);
+    expect(result).toBe("Symbol(test)");
+  });
+
+  test("handles custom Error subclasses", () => {
+    class CustomError extends Error {
+      constructor(message: string) {
+        super(message);
+        this.name = "CustomError";
+      }
+    }
+    
+    const error = new CustomError("Custom error occurred");
+    const result = errorToString(error);
+    expect(result).toBe("Custom error occurred");
+  });
+
+  test("handles Error with complex message", () => {
+    const error = new Error("Error: Connection failed (timeout: 5000ms)");
+    const result = errorToString(error);
+    expect(result).toBe("Error: Connection failed (timeout: 5000ms)");
+  });
+
+  test("handles nested objects", () => {
+    const nested = {
+      error: {
+        message: "Nested error",
+        code: 500,
+      },
+    };
+    const result = errorToString(nested);
+    expect(result).toBe("[object Object]");
+  });
+
+  test("handles function", () => {
+    const fn = () => "error";
+    const result = errorToString(fn);
+    expect(result).toBe(fn.toString());
+  });
+
+  // Additional tests for comprehensive coverage
+  test("handles Error with cause (nested errors)", () => {
+    const cause = new Error("Root cause");
+    const error = new Error("Main error", { cause });
+    const result = errorToString(error);
+    expect(result).toBe("Main error");
+  });
+
+  test("handles TypeError", () => {
+    const error = new TypeError("Type mismatch");
+    const result = errorToString(error);
+    expect(result).toBe("Type mismatch");
+  });
+
+  test("handles RangeError", () => {
+    const error = new RangeError("Out of range");
+    const result = errorToString(error);
+    expect(result).toBe("Out of range");
+  });
+
+  test("handles ReferenceError", () => {
+    const error = new ReferenceError("Undefined variable");
+    const result = errorToString(error);
+    expect(result).toBe("Undefined variable");
+  });
+
+  test("handles Error with stack trace", () => {
+    const error = new Error("Stack trace test");
+    error.stack = "Error: Stack trace test\n    at Test.<anonymous> (test.js:10:20)";
+    const result = errorToString(error);
+    expect(result).toBe("Stack trace test");
+  });
+
+  test("handles Error with code property", () => {
+    const error = new Error("Code test") as Error & { code?: string };
+    error.code = "ENOENT";
+    const result = errorToString(error);
+    expect(result).toBe("Code test");
+  });
+
+  test("handles very long error messages", () => {
+    const longMessage = "a".repeat(10000);
+    const error = new Error(longMessage);
+    const result = errorToString(error);
+    expect(result).toBe(longMessage);
+  });
+
+  test("handles object with circular references", () => {
+    const obj: any = { a: 1 };
+    obj.self = obj;
+    const result = errorToString(obj);
+    expect(result).toBe("[object Object]");
+  });
+
+  test("handles array with mixed types", () => {
+    const arr = [1, "two", null, undefined, { three: 3 }];
+    const result = errorToString(arr);
+    expect(result).toBe("1,two,,,[object Object]");
+  });
+
+  test("handles object with null prototype", () => {
+    const obj = Object.create(null);
+    obj.message = "No prototype";
+    // Objects with null prototype can't be converted to string by String()
+    // We expect this to throw, which is the correct behavior
+    expect(() => errorToString(obj)).toThrow();
+  });
+
+  test("handles Date object", () => {
+    const date = new Date("2024-01-01");
+    const result = errorToString(date);
+    expect(result).toBe(date.toString());
+  });
+
+  test("handles RegExp object", () => {
+    const regex = /test/gi;
+    const result = errorToString(regex);
+    expect(result).toBe("/test/gi");
+  });
+
+  test("handles Map object", () => {
+    const map = new Map([["key", "value"]]);
+    const result = errorToString(map);
+    expect(result).toBe("[object Map]");
+  });
+
+  test("handles Set object", () => {
+    const set = new Set([1, 2, 3]);
+    const result = errorToString(set);
+    expect(result).toBe("[object Set]");
+  });
+
+  test("handles BigInt", () => {
+    const bigInt = BigInt(123456789012345678901234567890n);
+    const result = errorToString(bigInt);
+    expect(result).toBe("123456789012345678901234567890");
+  });
+
+  test("handles Error with name property", () => {
+    const error = new Error("Named error");
+    error.name = "CustomName";
+    const result = errorToString(error);
+    expect(result).toBe("Named error");
+  });
+
+  test("handles multi-line error messages", () => {
+    const error = new Error("Line 1\nLine 2\nLine 3");
+    const result = errorToString(error);
+    expect(result).toBe("Line 1\nLine 2\nLine 3");
+  });
+
+  test("handles string with special characters", () => {
+    const specialString = "Error: \t\n\r\"'\\";
+    const result = errorToString(specialString);
+    expect(result).toBe(specialString);
+  });
+
+  test("handles Error subclass with custom properties", () => {
+    class CustomError extends Error {
+      code: number;
+      details: object;
+      
+      constructor(message: string, code: number, details: object) {
+        super(message);
+        this.name = "CustomError";
+        this.code = code;
+        this.details = details;
+      }
+    }
+    
+    const error = new CustomError("Custom message", 42, { foo: "bar" });
+    const result = errorToString(error);
+    expect(result).toBe("Custom message");
+  });
+
+  test("handles Unicode characters in error messages", () => {
+    const error = new Error("🚨 Error: 中文 ошибка خطأ");
+    const result = errorToString(error);
+    expect(result).toBe("🚨 Error: 中文 ошибка خطأ");
+  });
+
+  test("handles empty array", () => {
+    const result = errorToString([]);
+    expect(result).toBe("");
+  });
+
+  test("handles nested arrays", () => {
+    const result = errorToString([1, [2, [3, 4]]]);
+    expect(result).toBe("1,2,3,4");
+  });
+
+  test("handles object with toString that throws", () => {
+    const obj = {
+      toString: () => {
+        throw new Error("toString failed");
+      },
+    };
+    expect(() => errorToString(obj)).toThrow("toString failed");
+  });
+
+  test("handles frozen object", () => {
+    const obj = Object.freeze({ prop: "value" });
+    const result = errorToString(obj);
+    expect(result).toBe("[object Object]");
+  });
+
+  test("handles sealed object", () => {
+    const obj = Object.seal({ prop: "value" });
+    const result = errorToString(obj);
+    expect(result).toBe("[object Object]");
+  });
+});

package/test/unit/utils/markdown.test.ts

@@ -0,0 +1,163 @@
+import { test, expect } from "bun:test";
+import { parseMarkdown, truncateMarkdown } from "../../../src/utils/markdown";
+
+test("parseMarkdown - headings", () => {
+  const markdown = `# H1 Title
+## H2 Title
+### H3 Title`;
+  
+  const result = parseMarkdown(markdown);
+  
+  expect(result).toHaveLength(3);
+  expect(result[0]).toEqual({
+    type: 'heading',
+    level: 1,
+    content: 'H1 Title'
+  });
+  expect(result[1]).toEqual({
+    type: 'heading',
+    level: 2,
+    content: 'H2 Title'
+  });
+  expect(result[2]).toEqual({
+    type: 'heading',
+    level: 3,
+    content: 'H3 Title'
+  });
+});
+
+test("parseMarkdown - paragraph with inline formatting", () => {
+  const markdown = `This is **bold** and *italic* text with \`inline code\``;
+  
+  const result = parseMarkdown(markdown);
+  
+  expect(result).toHaveLength(1);
+  const firstResult = result[0];
+  if (!firstResult) throw new Error('Expected result[0] to be defined');
+  expect(firstResult.type).toBe('paragraph');
+  expect(firstResult.children).toBeDefined();
+  
+  const children = firstResult.children || [];
+  expect(children.length).toBe(6);
+  expect(children[0]).toEqual({ type: 'text', content: 'This is ' });
+  expect(children[1]).toEqual({ type: 'bold', content: 'bold' });
+  expect(children[2]).toEqual({ type: 'text', content: ' and ' });
+  expect(children[3]).toEqual({ type: 'italic', content: 'italic' });
+  expect(children[4]).toEqual({ type: 'text', content: ' text with ' });
+  expect(children[5]).toEqual({ type: 'code', content: 'inline code' });
+});
+
+test("parseMarkdown - code block", () => {
+  const markdown = `\`\`\`typescript
+const x = 1;
+const y = 2;
+\`\`\``;
+  
+  const result = parseMarkdown(markdown);
+  
+  expect(result).toHaveLength(1);
+  expect(result[0]).toEqual({
+    type: 'codeblock',
+    content: 'const x = 1;\nconst y = 2;',
+    language: 'typescript'
+  });
+});
+
+test("parseMarkdown - list items", () => {
+  const markdown = `- Item 1
+- Item 2
+- Item 3`;
+  
+  const result = parseMarkdown(markdown);
+  
+  expect(result).toHaveLength(1);
+  const firstResult = result[0];
+  if (!firstResult) throw new Error('Expected result[0] to be defined');
+  expect(firstResult.type).toBe('list');
+  expect(firstResult.children).toBeDefined();
+  
+  const items = firstResult.children || [];
+  expect(items.length).toBe(3);
+  expect(items[0]).toEqual({ type: 'listitem', content: 'Item 1' });
+  expect(items[1]).toEqual({ type: 'listitem', content: 'Item 2' });
+  expect(items[2]).toEqual({ type: 'listitem', content: 'Item 3' });
+});
+
+test("parseMarkdown - blockquote", () => {
+  const markdown = `> This is a blockquote`;
+  
+  const result = parseMarkdown(markdown);
+  
+  expect(result).toHaveLength(1);
+  expect(result[0]).toEqual({
+    type: 'blockquote',
+    content: 'This is a blockquote'
+  });
+});
+
+test("parseMarkdown - horizontal rule", () => {
+  const markdown = `---`;
+  
+  const result = parseMarkdown(markdown);
+  
+  expect(result).toHaveLength(1);
+  expect(result[0]).toEqual({ type: 'hr' });
+});
+
+test("parseMarkdown - link", () => {
+  const markdown = `Check out [GitHub](https://github.com)`;
+  
+  const result = parseMarkdown(markdown);
+  
+  expect(result).toHaveLength(1);
+  const firstResult = result[0];
+  if (!firstResult) throw new Error('Expected result[0] to be defined');
+  expect(firstResult.type).toBe('paragraph');
+  
+  const children = firstResult.children || [];
+  expect(children[0]).toEqual({ type: 'text', content: 'Check out ' });
+  expect(children[1]).toEqual({ 
+    type: 'link', 
+    content: 'GitHub',
+    url: 'https://github.com'
+  });
+});
+
+test("truncateMarkdown - limits output lines", () => {
+  const markdown = `# Title
+
+This is paragraph 1.
+
+This is paragraph 2.
+
+This is paragraph 3.`;
+  
+  const nodes = parseMarkdown(markdown);
+  const truncated = truncateMarkdown(nodes, 3);
+  
+  expect(truncated).toHaveLength(3);
+});
+
+test("parseMarkdown - mixed content", () => {
+  const markdown = `# Welcome
+
+This is a **demo** of the *markdown* parser.
+
+- Feature 1
+- Feature 2
+
+\`\`\`javascript
+console.log("Hello");
+\`\`\`
+
+> This is a quote`;
+  
+  const result = parseMarkdown(markdown);
+  
+  expect(result).toHaveLength(5);
+  expect(result[0]?.type).toBe('heading');
+  expect(result[1]?.type).toBe('paragraph');
+  expect(result[2]?.type).toBe('list');
+  expect(result[3]?.type).toBe('codeblock');
+  expect(result[4]?.type).toBe('blockquote');
+});