@ronkovic/aad 0.3.0 → 0.3.2

package/src/shared/__tests__/memory-monitor.test.ts

@@ -0,0 +1,120 @@
+import { describe, test, expect, mock, afterEach } from "bun:test";
+import { createMemoryMonitor } from "../memory-monitor";
+import type { MemoryStatus } from "../memory-check";
+
+function createMockLogger() {
+  return {
+    warn: mock(() => {}),
+    info: mock(() => {}),
+    error: mock(() => {}),
+    debug: mock(() => {}),
+    child: mock(() => createMockLogger()),
+  } as any;
+}
+
+function makeStatus(freeGB: number): MemoryStatus {
+  return {
+    totalGB: 16,
+    usedGB: 16 - freeGB,
+    freeGB,
+    usedPercent: Math.round(((16 - freeGB) / 16) * 100),
+    isLowMemory: freeGB < 2,
+  };
+}
+
+describe("memory-monitor", () => {
+  let monitors: ReturnType<typeof createMemoryMonitor>[] = [];
+
+  afterEach(() => {
+    monitors.forEach((m) => m.stop());
+    monitors = [];
+  });
+
+  test("calls callback when memory is critical", async () => {
+    const callback = mock(() => {});
+    const getStatus = mock(async () => makeStatus(0.5));
+
+    const monitor = createMemoryMonitor({
+      logger: createMockLogger(),
+      checkIntervalMs: 10,
+      criticalFreeGB: 0.8,
+      _getMemoryStatus: getStatus,
+    });
+    monitors.push(monitor);
+
+    monitor.onCritical(callback);
+    monitor.start();
+
+    await new Promise((r) => setTimeout(r, 50));
+    monitor.stop();
+
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+
+  test("does not fire callback when memory is fine", async () => {
+    const callback = mock(() => {});
+    const getStatus = mock(async () => makeStatus(4.0));
+
+    const monitor = createMemoryMonitor({
+      logger: createMockLogger(),
+      checkIntervalMs: 10,
+      criticalFreeGB: 0.8,
+      _getMemoryStatus: getStatus,
+    });
+    monitors.push(monitor);
+
+    monitor.onCritical(callback);
+    monitor.start();
+
+    await new Promise((r) => setTimeout(r, 50));
+    monitor.stop();
+
+    expect(callback).not.toHaveBeenCalled();
+  });
+
+  test("stop clears the interval", async () => {
+    let callCount = 0;
+    const getStatus = mock(async () => {
+      callCount++;
+      return makeStatus(4.0);
+    });
+
+    const monitor = createMemoryMonitor({
+      logger: createMockLogger(),
+      checkIntervalMs: 10,
+      _getMemoryStatus: getStatus,
+    });
+    monitors.push(monitor);
+
+    monitor.start();
+    await new Promise((r) => setTimeout(r, 50));
+    monitor.stop();
+
+    const countAfterStop = callCount;
+    await new Promise((r) => setTimeout(r, 50));
+
+    // No new calls after stop
+    expect(callCount).toBe(countAfterStop);
+  });
+
+  test("fires callback only once", async () => {
+    const callback = mock(() => {});
+    const getStatus = mock(async () => makeStatus(0.3));
+
+    const monitor = createMemoryMonitor({
+      logger: createMockLogger(),
+      checkIntervalMs: 10,
+      criticalFreeGB: 0.8,
+      _getMemoryStatus: getStatus,
+    });
+    monitors.push(monitor);
+
+    monitor.onCritical(callback);
+    monitor.start();
+
+    await new Promise((r) => setTimeout(r, 80));
+    monitor.stop();
+
+    expect(callback).toHaveBeenCalledTimes(1);
+  });
+});

package/src/shared/__tests__/shutdown-handler.test.ts

@@ -0,0 +1,138 @@
+import { describe, test, expect, beforeEach, mock } from "bun:test";
+import {
+  installShutdownHandler,
+  isShuttingDown,
+  _resetShutdownState,
+} from "../shutdown-handler";
+import type { TaskStore, RunStore } from "../../modules/persistence/stores.port";
+import type { Task, RunState } from "../types";
+import { createRunId, createTaskId } from "../types";
+
+function createMockLogger() {
+  return {
+    warn: mock(() => {}),
+    info: mock(() => {}),
+    error: mock(() => {}),
+    debug: mock(() => {}),
+    child: mock(() => createMockLogger()),
+  } as any;
+}
+
+function createMockStores(tasks: Task[], runState: RunState | null) {
+  const savedTasks: Task[] = [];
+  let savedRun: RunState | null = null;
+
+  const taskStore: TaskStore = {
+    get: mock(async (id) => tasks.find((t) => t.taskId === id) ?? null),
+    getAll: mock(async () => tasks),
+    getByStatus: mock(async (status) => tasks.filter((t) => t.status === status)),
+    save: mock(async (task) => {
+      savedTasks.push(task);
+      // Update in-place for subsequent getAll calls
+      const idx = tasks.findIndex((t) => t.taskId === task.taskId);
+      if (idx >= 0) tasks[idx] = task;
+    }),
+    delete: mock(async () => {}),
+  };
+
+  const runStore: RunStore = {
+    get: mock(async () => runState),
+    getLatest: mock(async () => runState),
+    save: mock(async (state) => { savedRun = state; }),
+  };
+
+  return { taskStore, runStore, savedTasks, getSavedRun: () => savedRun };
+}
+
+const runId = createRunId("test-run-1");
+
+function makeTask(id: string, status: "pending" | "running" | "completed" | "failed"): Task {
+  return {
+    taskId: createTaskId(id),
+    title: id,
+    description: "",
+    filesToModify: [],
+    dependsOn: [],
+    priority: 1,
+    status,
+    retryCount: 0,
+  };
+}
+
+describe("shutdown-handler", () => {
+  beforeEach(() => {
+    _resetShutdownState();
+  });
+
+  test("isShuttingDown returns false initially", () => {
+    expect(isShuttingDown()).toBe(false);
+  });
+
+  test("saves state on signal and sets shuttingDown", async () => {
+    const tasks = [
+      makeTask("t1", "completed"),
+      makeTask("t2", "running"),
+      makeTask("t3", "pending"),
+    ];
+    const runState: RunState = {
+      runId,
+      parentBranch: "main",
+      totalTasks: 3,
+      pending: 1,
+      running: 1,
+      completed: 1,
+      failed: 0,
+      startTime: new Date().toISOString(),
+    };
+
+    const exitFn = mock(() => {});
+    const stores = createMockStores(tasks, runState);
+    const logger = createMockLogger();
+
+    installShutdownHandler({
+      runId,
+      stores: { runStore: stores.runStore, taskStore: stores.taskStore },
+      logger,
+      exitFn,
+    });
+
+    // Simulate SIGINT
+    process.emit("SIGINT");
+
+    // Wait for async handler
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(isShuttingDown()).toBe(true);
+    expect(exitFn).toHaveBeenCalledWith(1);
+    // Running task should be saved as pending
+    expect(stores.taskStore.save).toHaveBeenCalled();
+    expect(stores.runStore.save).toHaveBeenCalled();
+
+    const savedRun = stores.getSavedRun();
+    expect(savedRun).not.toBeNull();
+    expect(savedRun!.running).toBe(0);
+  });
+
+  test("debounces duplicate signals", async () => {
+    const tasks: Task[] = [];
+    const exitFn = mock(() => {});
+    const stores = createMockStores(tasks, null);
+    const logger = createMockLogger();
+
+    installShutdownHandler({
+      runId,
+      stores: { runStore: stores.runStore, taskStore: stores.taskStore },
+      logger,
+      exitFn,
+    });
+
+    process.emit("SIGINT");
+    process.emit("SIGINT");
+    process.emit("SIGINT");
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    // exitFn called only once due to debounce
+    expect(exitFn).toHaveBeenCalledTimes(1);
+  });
+});

package/src/shared/__tests__/utils.test.ts

@@ -0,0 +1,294 @@
+import { describe, test, expect } from "bun:test";
+import { capitalize, toLowerCase, trim, reverse, toUpperCase } from "../utils";
+
+describe("capitalize", () => {
+  test.each([
+    ["hello", "Hello"],
+    ["world", "World"],
+    ["a", "A"],
+    ["test", "Test"],
+    ["capitalize", "Capitalize"],
+  ])("capitalizes '%s' to '%s'", (input, expected) => {
+    expect(capitalize(input)).toBe(expected);
+  });
+
+  test.each([
+    ["Hello", "Hello"],
+    ["WORLD", "WORLD"],
+    ["Already", "Already"],
+  ])("does not change '%s' when already capitalized", (input, expected) => {
+    expect(capitalize(input)).toBe(expected);
+  });
+
+  test("handles empty string", () => {
+    expect(capitalize("")).toBe("");
+  });
+
+  test.each([
+    ["123test", "123test"],
+    ["!hello", "!hello"],
+    [" space", " space"],
+  ])("handles string starting with non-letter: '%s'", (input, expected) => {
+    expect(capitalize(input)).toBe(expected);
+  });
+
+  test.each([
+    ["hello world", "Hello world"],
+    ["test string", "Test string"],
+  ])("only capitalizes first character: '%s' to '%s'", (input, expected) => {
+    expect(capitalize(input)).toBe(expected);
+  });
+});
+
+describe("toLowerCase", () => {
+  test.each([
+    ["HELLO", "hello"],
+    ["WORLD", "world"],
+    ["TEST", "test"],
+    ["UPPERCASE", "uppercase"],
+  ])("converts '%s' to '%s'", (input, expected) => {
+    expect(toLowerCase(input)).toBe(expected);
+  });
+
+  test("handles empty string", () => {
+    expect(toLowerCase("")).toBe("");
+  });
+
+  test.each([
+    ["hello", "hello"],
+    ["world", "world"],
+    ["lowercase", "lowercase"],
+  ])("does not change '%s' when already lowercase", (input, expected) => {
+    expect(toLowerCase(input)).toBe(expected);
+  });
+
+  test.each([
+    ["Hello World", "hello world"],
+    ["TeSt StRiNg", "test string"],
+    ["MiXeD CaSe", "mixed case"],
+  ])("converts mixed case '%s' to '%s'", (input, expected) => {
+    expect(toLowerCase(input)).toBe(expected);
+  });
+});
+
+describe("trim", () => {
+  test.each([
+    ["  hello  ", "hello"],
+    [" world ", "world"],
+    ["  test", "test"],
+    ["test  ", "test"],
+    ["   spaces   ", "spaces"],
+  ])("removes leading and trailing whitespace from '%s'", (input, expected) => {
+    expect(trim(input)).toBe(expected);
+  });
+
+  test.each([
+    ["\thello\t", "hello"],
+    ["\nworld\n", "world"],
+    [" \t\ntest\n\t ", "test"],
+  ])("removes various whitespace characters from '%s'", (input, expected) => {
+    expect(trim(input)).toBe(expected);
+  });
+
+  test.each([
+    ["hello world", "hello world"],
+    ["test  string", "test  string"],
+    ["multiple   spaces", "multiple   spaces"],
+  ])("preserves internal whitespace in '%s'", (input, expected) => {
+    expect(trim(input)).toBe(expected);
+  });
+
+  test("handles empty string", () => {
+    expect(trim("")).toBe("");
+  });
+
+  test.each([
+    ["nowhitespace", "nowhitespace"],
+    ["alreadytrimmed", "alreadytrimmed"],
+  ])("does not change '%s' when already trimmed", (input, expected) => {
+    expect(trim(input)).toBe(expected);
+  });
+});
+
+describe("reverse", () => {
+  test.each([
+    ["hello", "olleh"],
+    ["world", "dlrow"],
+    ["test", "tset"],
+    ["typescript", "tpircsepyt"],
+    ["reverse", "esrever"],
+  ])("reverses normal string '%s' to '%s'", (input, expected) => {
+    expect(reverse(input)).toBe(expected);
+  });
+
+  test("handles empty string", () => {
+    expect(reverse("")).toBe("");
+  });
+
+  test.each([
+    ["a", "a"],
+    ["b", "b"],
+    ["z", "z"],
+  ])("handles single character string '%s'", (input, expected) => {
+    expect(reverse(input)).toBe(expected);
+  });
+
+  test.each([
+    ["123", "321"],
+    ["456789", "987654"],
+    ["test123", "321tset"],
+    ["123test", "tset321"],
+    ["a1b2c3", "3c2b1a"],
+  ])("reverses string with numbers '%s' to '%s'", (input, expected) => {
+    expect(reverse(input)).toBe(expected);
+  });
+
+  test.each([
+    ["hello world", "dlrow olleh"],
+    ["test string", "gnirts tset"],
+    ["multiple   spaces", "secaps   elpitlum"],
+    [" leading", "gnidael "],
+    ["trailing ", " gniliart"],
+  ])("reverses string with spaces '%s' to '%s'", (input, expected) => {
+    expect(reverse(input)).toBe(expected);
+  });
+
+  test.each([
+    ["!hello", "olleh!"],
+    ["world?", "?dlrow"],
+    ["test@email.com", "moc.liame@tset"],
+    ["special#$%chars", "srahc%$#laiceps"],
+  ])("reverses string with special characters '%s' to '%s'", (input, expected) => {
+    expect(reverse(input)).toBe(expected);
+  });
+
+  test.each([
+    ["Hello", "olleH"],
+    ["WORLD", "DLROW"],
+    ["MiXeD", "DeXiM"],
+    ["CamelCase", "esaClemaC"],
+  ])("reverses string with mixed case '%s' to '%s'", (input, expected) => {
+    expect(reverse(input)).toBe(expected);
+  });
+
+  test.each([
+    ["こんにちは", "はちにんこ"],
+    ["你好", "好你"],
+    ["안녕", "녕안"],
+  ])("reverses string with multibyte characters '%s' to '%s'", (input, expected) => {
+    expect(reverse(input)).toBe(expected);
+  });
+
+  test.each([
+    ["\thello\t", "\tolleh\t"],
+    ["\nworld\n", "\ndlrow\n"],
+    ["test\r\n", "\n\rtset"],
+  ])("reverses string with whitespace characters '%s'", (input, expected) => {
+    expect(reverse(input)).toBe(expected);
+  });
+
+  test.each([
+    ["aba", "aba"],
+    ["racecar", "racecar"],
+    ["noon", "noon"],
+  ])("reverses palindrome '%s' to '%s'", (input, expected) => {
+    expect(reverse(input)).toBe(expected);
+  });
+});
+
+describe("toUpperCase", () => {
+  // Test case 1: Lowercase-only strings
+  test.each([
+    ["hello", "HELLO"],
+    ["world", "WORLD"],
+    ["test", "TEST"],
+    ["lowercase", "LOWERCASE"],
+    ["typescript", "TYPESCRIPT"],
+    ["function", "FUNCTION"],
+  ])("converts lowercase-only string '%s' to '%s'", (input, expected) => {
+    expect(toUpperCase(input)).toBe(expected);
+  });
+
+  // Test case 2: Strings with mixed uppercase and lowercase
+  test.each([
+    ["Hello World", "HELLO WORLD"],
+    ["TeSt StRiNg", "TEST STRING"],
+    ["MiXeD CaSe", "MIXED CASE"],
+    ["CamelCase", "CAMELCASE"],
+    ["snake_Case", "SNAKE_CASE"],
+  ])("converts mixed case string '%s' to '%s'", (input, expected) => {
+    expect(toUpperCase(input)).toBe(expected);
+  });
+
+  // Test case 3: Strings containing numbers
+  test.each([
+    ["123", "123"],
+    ["456789", "456789"],
+    ["test123", "TEST123"],
+    ["123test", "123TEST"],
+    ["a1b2c3", "A1B2C3"],
+    ["hello123world", "HELLO123WORLD"],
+  ])("converts string with numbers '%s' to '%s'", (input, expected) => {
+    expect(toUpperCase(input)).toBe(expected);
+  });
+
+  // Test case 4: Strings containing symbols
+  test.each([
+    ["!@#$%", "!@#$%"],
+    ["hello!", "HELLO!"],
+    ["test@email.com", "TEST@EMAIL.COM"],
+    ["special#$%chars", "SPECIAL#$%CHARS"],
+    ["under_score", "UNDER_SCORE"],
+    ["dash-case", "DASH-CASE"],
+  ])("converts string with symbols '%s' to '%s'", (input, expected) => {
+    expect(toUpperCase(input)).toBe(expected);
+  });
+
+  // Test case 5: Empty strings
+  test("handles empty string", () => {
+    expect(toUpperCase("")).toBe("");
+  });
+
+  // Test case 6: Already uppercase strings
+  test.each([
+    ["HELLO", "HELLO"],
+    ["WORLD", "WORLD"],
+    ["UPPERCASE", "UPPERCASE"],
+    ["ALREADY", "ALREADY"],
+    ["TEST", "TEST"],
+  ])("does not change '%s' when already uppercase", (input, expected) => {
+    expect(toUpperCase(input)).toBe(expected);
+  });
+
+  // Test case 7: Single character strings
+  test.each([
+    ["a", "A"],
+    ["z", "Z"],
+    ["m", "M"],
+    ["A", "A"],
+    ["Z", "Z"],
+  ])("converts single character '%s' to '%s'", (input, expected) => {
+    expect(toUpperCase(input)).toBe(expected);
+  });
+
+  // Test case 8: Strings with whitespace
+  test.each([
+    [" hello ", " HELLO "],
+    ["hello world", "HELLO WORLD"],
+    ["  multiple   spaces  ", "  MULTIPLE   SPACES  "],
+    ["\thello\t", "\tHELLO\t"],
+    ["\nworld\n", "\nWORLD\n"],
+  ])("converts string with whitespace '%s' to '%s'", (input, expected) => {
+    expect(toUpperCase(input)).toBe(expected);
+  });
+
+  // Test case 9: Complex mixed content
+  test.each([
+    ["Test123!@#", "TEST123!@#"],
+    ["hello_world_123", "HELLO_WORLD_123"],
+    ["email@test.com", "EMAIL@TEST.COM"],
+    ["complex MiXeD 123 !@#", "COMPLEX MIXED 123 !@#"],
+  ])("converts complex string '%s' to '%s'", (input, expected) => {
+    expect(toUpperCase(input)).toBe(expected);
+  });
+});

package/src/shared/errors.ts

@@ -120,6 +120,13 @@ export class TestRunnerError extends AadError {
   }
 }
 
+export class MemoryError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("MEMORY_ERROR", message, context);
+    this.name = "MemoryError";
+  }
+}
+
 export class MergeConflictError extends AadError {
   constructor(message: string, context: Record<string, unknown> = {}) {
     super("MERGE_CONFLICT_ERROR", message, context);