@ai-setting/roy-agent-core 1.0.0

package/src/env/session/session-message-converter.test.ts

@@ -0,0 +1,763 @@
+/**
+ * @fileoverview Session Message Converter Tests
+ * 
+ * Tests for SessionMessage <-> AI SDK ModelMessage conversion functions.
+ * Following TDD: These tests define the expected behavior.
+ */
+
+import { describe, test, expect, beforeEach } from "bun:test";
+import type { 
+  SessionMessage, 
+  TextPart, 
+  ToolCallPart, 
+  ToolResultPart, 
+  ReasoningPart,
+  FilePart,
+  CheckpointPart,
+  SessionPart 
+} from "./types";
+
+// ============================================================================
+// Test Utilities
+// ============================================================================
+
+function createSessionMessage(overrides: Partial<SessionMessage> = {}): SessionMessage {
+  return {
+    id: `msg_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+    sessionID: "session_test",
+    role: "user",
+    content: "",
+    timestamp: Date.now(),
+    ...overrides,
+  };
+}
+
+// ============================================================================
+// RED Phase: Write tests that define expected behavior
+// ============================================================================
+
+describe("Session Part Types", () => {
+  describe("TextPart", () => {
+    test("should have correct structure", () => {
+      const textPart: TextPart = {
+        type: "text",
+        content: "Hello, world!",
+        synthetic: false,
+        ignored: false,
+      };
+      
+      expect(textPart.type).toBe("text");
+      expect(textPart.content).toBe("Hello, world!");
+      expect(textPart.synthetic).toBe(false);
+      expect(textPart.ignored).toBe(false);
+    });
+    
+    test("should support optional fields", () => {
+      const textPart: TextPart = {
+        type: "text",
+        content: "Simple text",
+      };
+      
+      expect(textPart.type).toBe("text");
+      expect(textPart.content).toBe("Simple text");
+      expect(textPart.synthetic).toBeUndefined();
+      expect(textPart.ignored).toBeUndefined();
+    });
+  });
+  
+  describe("ToolCallPart", () => {
+    test("should have correct structure", () => {
+      const toolCallPart: ToolCallPart = {
+        type: "tool-call",
+        toolCallId: "call_abc123",
+        toolName: "grep",
+        arguments: { pattern: "TODO", path: "/src" },
+        state: "pending",
+      };
+      
+      expect(toolCallPart.type).toBe("tool-call");
+      expect(toolCallPart.toolCallId).toBe("call_abc123");
+      expect(toolCallPart.toolName).toBe("grep");
+      expect(toolCallPart.arguments).toEqual({ pattern: "TODO", path: "/src" });
+      expect(toolCallPart.state).toBe("pending");
+    });
+    
+    test("should support string arguments", () => {
+      const toolCallPart: ToolCallPart = {
+        type: "tool-call",
+        toolCallId: "call_xyz",
+        toolName: "bash",
+        arguments: '{"command": "ls -la"}',
+        state: "pending",
+      };
+      
+      expect(typeof toolCallPart.arguments).toBe("string");
+    });
+    
+    test("should support running state", () => {
+      const toolCallPart: ToolCallPart = {
+        type: "tool-call",
+        toolCallId: "call_running",
+        toolName: "search",
+        arguments: {},
+        state: "running",
+      };
+      
+      expect(toolCallPart.state).toBe("running");
+    });
+  });
+  
+  describe("ToolResultPart", () => {
+    test("should have correct structure", () => {
+      const toolResultPart: ToolResultPart = {
+        type: "tool-result",
+        toolCallId: "call_abc123",
+        toolName: "grep",
+        output: "Found 3 matches",
+        state: "completed",
+      };
+      
+      expect(toolResultPart.type).toBe("tool-result");
+      expect(toolResultPart.toolCallId).toBe("call_abc123");
+      expect(toolResultPart.toolName).toBe("grep");
+      expect(toolResultPart.output).toBe("Found 3 matches");
+      expect(toolResultPart.state).toBe("completed");
+    });
+    
+    test("should support error state", () => {
+      const toolResultPart: ToolResultPart = {
+        type: "tool-result",
+        toolCallId: "call_error",
+        toolName: "bash",
+        output: "",
+        error: "Command failed: exit code 1",
+        state: "error",
+      };
+      
+      expect(toolResultPart.error).toBe("Command failed: exit code 1");
+      expect(toolResultPart.state).toBe("error");
+    });
+  });
+  
+  describe("ReasoningPart", () => {
+    test("should have correct structure", () => {
+      const reasoningPart: ReasoningPart = {
+        type: "reasoning",
+        content: "Let me think about this problem...",
+        reasoningType: "core",
+        state: "completed",
+      };
+      
+      expect(reasoningPart.type).toBe("reasoning");
+      expect(reasoningPart.content).toBe("Let me think about this problem...");
+      expect(reasoningPart.reasoningType).toBe("core");
+      expect(reasoningPart.state).toBe("completed");
+    });
+    
+    test("should support optional metadata", () => {
+      const reasoningPart: ReasoningPart = {
+        type: "reasoning",
+        content: "Thinking...",
+        reasoningType: "effort",
+        state: "thinking",
+        isCollapsed: true,
+        metadata: {
+          tokenCount: 150,
+          time: { start: Date.now(), end: Date.now() + 1000 },
+        },
+      };
+      
+      expect(reasoningPart.isCollapsed).toBe(true);
+      expect(reasoningPart.metadata?.tokenCount).toBe(150);
+    });
+  });
+  
+  describe("FilePart", () => {
+    test("should have correct structure", () => {
+      const filePart: FilePart = {
+        type: "file",
+        mime: "image/png",
+        url: "file:///path/to/image.png",
+        filename: "screenshot.png",
+      };
+      
+      expect(filePart.type).toBe("file");
+      expect(filePart.mime).toBe("image/png");
+      expect(filePart.url).toBe("file:///path/to/image.png");
+      expect(filePart.filename).toBe("screenshot.png");
+    });
+  });
+  
+  describe("CheckpointPart", () => {
+    test("should have correct structure", () => {
+      const checkpointPart: CheckpointPart = {
+        type: "checkpoint",
+        checkpointId: "chk_abc123",
+        summary: "Session compacted",
+        processKeyPoints: ["Analyzed requirements", "Created test files"],
+        currentState: "Implementing feature X",
+        nextSteps: ["Write implementation", "Test edge cases"],
+      };
+      
+      expect(checkpointPart.type).toBe("checkpoint");
+      expect(checkpointPart.checkpointId).toBe("chk_abc123");
+      expect(checkpointPart.summary).toBe("Session compacted");
+      expect(checkpointPart.processKeyPoints).toHaveLength(2);
+      expect(checkpointPart.nextSteps).toHaveLength(2);
+    });
+  });
+  
+  describe("SessionPart Union Type", () => {
+    test("should allow all part types in union", () => {
+      const parts: SessionPart[] = [
+        { type: "text", content: "Hello" },
+        { type: "tool-call", toolCallId: "c1", toolName: "t1", arguments: {}, state: "pending" },
+        { type: "tool-result", toolCallId: "c1", toolName: "t1", output: "ok", state: "completed" },
+        { type: "reasoning", content: "thinking" },
+        { type: "file", mime: "text/plain", url: "file://test.txt" },
+        { type: "checkpoint", checkpointId: "chk1", summary: "test" },
+      ];
+      
+      expect(parts).toHaveLength(6);
+    });
+  });
+});
+
+// ============================================================================
+// SessionMessage Structure Tests
+// ============================================================================
+
+describe("SessionMessage Structure", () => {
+  test("should support parts array", () => {
+    const message = createSessionMessage({
+      role: "assistant",
+      parts: [
+        { type: "text", content: "Hello!" },
+        { type: "reasoning", content: "Let me think...", reasoningType: "core" },
+      ],
+    });
+    
+    expect(message.parts).toBeDefined();
+    expect(message.parts).toHaveLength(2);
+    expect(message.parts![0].type).toBe("text");
+    expect(message.parts![1].type).toBe("reasoning");
+  });
+  
+  test("should support metadata", () => {
+    const message = createSessionMessage({
+      role: "assistant",
+      metadata: {
+        model: "gpt-4",
+        isCheckpoint: true,
+        checkpointId: "chk_123",
+      },
+    });
+    
+    expect(message.metadata).toBeDefined();
+    expect(message.metadata?.model).toBe("gpt-4");
+    expect(message.metadata?.isCheckpoint).toBe(true);
+  });
+  
+  test("should support backward compatibility with content field", () => {
+    const message = createSessionMessage({
+      role: "user",
+      content: "Simple text message",
+    });
+    
+    expect(message.content).toBe("Simple text message");
+    expect(message.parts).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// Import tests (will be implemented in GREEN phase)
+// ============================================================================
+
+describe("toModelMessage", () => {
+  test("should convert user message to ModelMessage", async () => {
+    const { toModelMessage } = await import("./session-message-converter");
+    
+    const sessionMsg = createSessionMessage({
+      role: "user",
+      content: "Hello, AI!",
+    });
+    
+    const modelMsg = toModelMessage(sessionMsg);
+    
+    expect(modelMsg.role).toBe("user");
+    expect(modelMsg.content).toBe("Hello, AI!");
+  });
+  
+  test("should convert assistant text message to ModelMessage", async () => {
+    const { toModelMessage } = await import("./session-message-converter");
+    
+    const sessionMsg = createSessionMessage({
+      role: "assistant",
+      content: "Hello, human!",
+      parts: [{ type: "text", content: "Hello, human!" }],
+    });
+    
+    const modelMsg = toModelMessage(sessionMsg);
+    
+    expect(modelMsg.role).toBe("assistant");
+    expect(modelMsg.content).toHaveLength(1);
+    expect(modelMsg.content[0]).toEqual({ type: "text", text: "Hello, human!" });
+  });
+  
+  test("should convert reasoning part to ModelMessage", async () => {
+    const { toModelMessage } = await import("./session-message-converter");
+    
+    const sessionMsg = createSessionMessage({
+      role: "assistant",
+      parts: [
+        { type: "reasoning", content: "Let me analyze this...", reasoningType: "core" },
+        { type: "text", content: "Here's my answer." },
+      ],
+    });
+    
+    const modelMsg = toModelMessage(sessionMsg);
+    
+    expect(modelMsg.role).toBe("assistant");
+    expect(modelMsg.content).toHaveLength(2);
+    expect(modelMsg.content[0]).toMatchObject({ 
+      type: "reasoning", 
+      text: "Let me analyze this..." 
+    });
+  });
+  
+  test("should convert tool-call part to ModelMessage", async () => {
+    const { toModelMessage } = await import("./session-message-converter");
+    
+    const sessionMsg = createSessionMessage({
+      role: "assistant",
+      parts: [
+        { type: "text", content: "Searching..." },
+        { 
+          type: "tool-call", 
+          toolCallId: "call_123", 
+          toolName: "grep", 
+          arguments: { pattern: "TODO" },
+          state: "pending",
+        },
+      ],
+    });
+    
+    const modelMsg = toModelMessage(sessionMsg);
+    
+    expect(modelMsg.content).toHaveLength(2);
+    const toolCall = modelMsg.content.find(c => c.type === "tool-call");
+    expect(toolCall).toMatchObject({
+      type: "tool-call",
+      toolCallId: "call_123",
+      toolName: "grep",
+      input: { pattern: "TODO" },
+    });
+  });
+  
+  test("should convert tool message to ModelMessage", async () => {
+    const { toModelMessage } = await import("./session-message-converter");
+    
+    const sessionMsg = createSessionMessage({
+      role: "tool",
+      content: "Found 5 matches",
+      parts: [
+        {
+          type: "tool-result",
+          toolCallId: "call_123",
+          toolName: "grep",
+          output: "Found 5 matches",
+          state: "completed",
+        },
+      ],
+    });
+    
+    const modelMsg = toModelMessage(sessionMsg);
+    
+    expect(modelMsg.role).toBe("tool");
+    expect(modelMsg.content).toHaveLength(1);
+    expect(modelMsg.content[0]).toMatchObject({
+      type: "tool-result",
+      toolCallId: "call_123",
+      toolName: "grep",
+      output: "Found 5 matches",
+    });
+  });
+  
+  test("should convert file part in assistant message", async () => {
+    const { toModelMessage } = await import("./session-message-converter");
+    
+    const sessionMsg = createSessionMessage({
+      role: "assistant",
+      parts: [
+        { type: "text", content: "Here's the file" },
+        { type: "file", mime: "image/png", url: "file:///tmp/image.png", filename: "screenshot.png" },
+      ],
+    });
+    
+    const modelMsg = toModelMessage(sessionMsg);
+    
+    expect(modelMsg.role).toBe("assistant");
+    expect(Array.isArray(modelMsg.content)).toBe(true);
+    const content = modelMsg.content as any[];
+    const filePart = content.find(c => c.type === "file");
+    expect(filePart).toBeDefined();
+    expect(filePart.url).toBe("file:///tmp/image.png");
+    expect(filePart.mimeType).toBe("image/png");
+  });
+  
+  test("should skip checkpoint parts in assistant message", async () => {
+    const { toModelMessage } = await import("./session-message-converter");
+    
+    const sessionMsg = createSessionMessage({
+      role: "assistant",
+      parts: [
+        { type: "text", content: "Response after checkpoint" },
+        { type: "checkpoint", checkpointId: "chk_123", summary: "Checkpoint summary" },
+      ],
+    });
+    
+    const modelMsg = toModelMessage(sessionMsg);
+    
+    expect(modelMsg.role).toBe("assistant");
+    expect(Array.isArray(modelMsg.content)).toBe(true);
+    const content = modelMsg.content as any[];
+    // Checkpoint should be skipped
+    expect(content).toHaveLength(1);
+    expect(content[0].type).toBe("text");
+  });
+});
+
+describe("fromModelMessage", () => {
+  test("should convert text ModelMessage to SessionMessage", async () => {
+    const { fromModelMessage } = await import("./session-message-converter");
+    
+    const modelMsg = {
+      role: "user" as const,
+      content: "Hello!",
+    };
+    
+    const sessionMsg = fromModelMessage(modelMsg);
+    
+    expect(sessionMsg.role).toBe("user");
+    expect(sessionMsg.content).toBe("Hello!");
+    expect(sessionMsg.parts).toEqual([{ type: "text", content: "Hello!" }]);
+  });
+  
+  test("should convert assistant ModelMessage with multiple parts", async () => {
+    const { fromModelMessage } = await import("./session-message-converter");
+    
+    const modelMsg = {
+      role: "assistant" as const,
+      content: [
+        { type: "reasoning", text: "Thinking..." },
+        { type: "text", text: "Here's my response." },
+        { type: "tool-call", toolCallId: "c1", toolName: "bash", input: { cmd: "ls" } },
+      ],
+    };
+    
+    const sessionMsg = fromModelMessage(modelMsg);
+    
+    expect(sessionMsg.role).toBe("assistant");
+    expect(sessionMsg.parts).toHaveLength(3);
+    expect(sessionMsg.parts![0]).toMatchObject({ type: "reasoning", content: "Thinking..." });
+    expect(sessionMsg.parts![1]).toMatchObject({ type: "text", content: "Here's my response." });
+    expect(sessionMsg.parts![2]).toMatchObject({ 
+      type: "tool-call", 
+      toolCallId: "c1", 
+      toolName: "bash",
+      arguments: { cmd: "ls" },
+    });
+  });
+  
+  test("should convert tool-result ModelMessage to SessionMessage", async () => {
+    const { fromModelMessage } = await import("./session-message-converter");
+    
+    const modelMsg = {
+      role: "tool" as const,
+      content: [
+        {
+          type: "tool-result" as const,
+          toolCallId: "call_abc",
+          toolName: "grep",
+          output: "Match 1\nMatch 2",
+        },
+      ],
+    };
+    
+    const sessionMsg = fromModelMessage(modelMsg);
+    
+    expect(sessionMsg.role).toBe("tool");
+    expect(sessionMsg.parts![0]).toMatchObject({
+      type: "tool-result",
+      toolCallId: "call_abc",
+      toolName: "grep",
+      output: "Match 1\nMatch 2",
+      state: "completed",
+    });
+    // tool messages should have metadata.type = "tool_result"
+    expect(sessionMsg.metadata).toEqual({ type: "tool_result" });
+  });
+  
+  test("should set metadata.type to tool_call for assistant messages with tool-call parts", async () => {
+    const { fromModelMessage } = await import("./session-message-converter");
+    
+    const modelMsg = {
+      role: "assistant" as const,
+      content: [
+        { type: "text", text: "I'll search for that." },
+        { type: "tool-call", toolCallId: "c1", toolName: "search", input: { query: "test" } },
+      ],
+    };
+    
+    const sessionMsg = fromModelMessage(modelMsg);
+    
+    expect(sessionMsg.role).toBe("assistant");
+    expect(sessionMsg.metadata).toEqual({ type: "tool_call" });
+  });
+  
+  test("should not set metadata.type for assistant messages without tool-call parts", async () => {
+    const { fromModelMessage } = await import("./session-message-converter");
+    
+    const modelMsg = {
+      role: "assistant" as const,
+      content: "Just a regular text response.",
+    };
+    
+    const sessionMsg = fromModelMessage(modelMsg);
+    
+    expect(sessionMsg.role).toBe("assistant");
+    expect(sessionMsg.metadata).toBeUndefined();
+  });
+  
+  test("should set metadata.type to tool_result for tool messages", async () => {
+    const { fromModelMessage } = await import("./session-message-converter");
+    
+    const modelMsg = {
+      role: "tool" as const,
+      content: [
+        { type: "tool-result", toolCallId: "c1", toolName: "search", output: "result" },
+      ],
+    };
+    
+    const sessionMsg = fromModelMessage(modelMsg);
+    
+    expect(sessionMsg.metadata).toEqual({ type: "tool_result" });
+  });
+});
+
+describe("sessionToHistory", () => {
+  test("should convert session messages to ModelMessage array", async () => {
+    const { sessionToHistory } = await import("./session-message-converter");
+    
+    const messages: SessionMessage[] = [
+      createSessionMessage({ role: "user", content: "Hello!" }),
+      createSessionMessage({ 
+        role: "assistant", 
+        parts: [{ type: "text", content: "Hi there!" }] 
+      }),
+    ];
+    
+    const history = sessionToHistory(messages);
+    
+    expect(history).toHaveLength(2);
+    expect(history[0].role).toBe("user");
+    expect(history[1].role).toBe("assistant");
+  });
+  
+  test("should filter out archived messages", async () => {
+    const { sessionToHistory } = await import("./session-message-converter");
+    
+    const messages: SessionMessage[] = [
+      createSessionMessage({ role: "user", content: "Message 1" }),
+      createSessionMessage({ role: "user", content: "Message 2", isArchived: true }),
+      createSessionMessage({ role: "user", content: "Message 3" }),
+    ];
+    
+    const history = sessionToHistory(messages);
+    
+    expect(history).toHaveLength(2);
+    expect(history[0].content).toBe("Message 1");
+    expect(history[1].content).toBe("Message 3");
+  });
+});
+
+describe("extractProviderOptions", () => {
+  test("should extract reasoning options from reasoning parts", async () => {
+    const { extractProviderOptions } = await import("./session-message-converter");
+    
+    const message = createSessionMessage({
+      role: "assistant",
+      parts: [
+        { type: "reasoning", content: "Thinking...", reasoningType: "core" },
+      ],
+    });
+    
+    const options = extractProviderOptions(message);
+    
+    expect(options).toHaveProperty("openai");
+    expect(options.openai).toHaveProperty("thinking");
+  });
+});
+
+describe("migrateMessage", () => {
+  test("should migrate old format message to new format", async () => {
+    const { migrateMessage } = await import("./session-message-converter");
+    
+    // Old format: content is plain text, no parts
+    const oldMsg = {
+      id: "msg_old",
+      sessionID: "session_test",
+      role: "user" as const,
+      content: "Hello, old world!",
+      timestamp: Date.now(),
+    };
+    
+    const migrated = migrateMessage(oldMsg);
+    
+    expect(migrated.content).toBe("Hello, old world!");
+    expect(migrated.parts).toBeDefined();
+    expect(migrated.parts).toHaveLength(1);
+    expect(migrated.parts![0]).toEqual({ type: "text", content: "Hello, old world!" });
+  });
+  
+  test("should keep new format message as is", async () => {
+    const { migrateMessage } = await import("./session-message-converter");
+    
+    // New format: already has proper parts
+    const newMsg = {
+      id: "msg_new",
+      sessionID: "session_test",
+      role: "assistant" as const,
+      content: "Hello!",
+      timestamp: Date.now(),
+      parts: [
+        { type: "text", content: "Hello!" },
+        { type: "reasoning", content: "Thinking...", reasoningType: "core" as const },
+      ],
+    };
+    
+    const migrated = migrateMessage(newMsg);
+    
+    expect(migrated.parts).toHaveLength(2);
+    expect(migrated.parts![0].type).toBe("text");
+    expect(migrated.parts![1].type).toBe("reasoning");
+  });
+  
+  test("should migrate message with empty parts array", async () => {
+    const { migrateMessage } = await import("./session-message-converter");
+    
+    // Old format with empty parts (malformed)
+    const oldMsg = {
+      id: "msg_empty_parts",
+      sessionID: "session_test",
+      role: "user" as const,
+      content: "Content without parts field",
+      timestamp: Date.now(),
+      parts: [],
+    };
+    
+    const migrated = migrateMessage(oldMsg);
+    
+    expect(migrated.content).toBe("Content without parts field");
+    expect(migrated.parts).toHaveLength(1);
+    expect(migrated.parts![0]).toEqual({ type: "text", content: "Content without parts field" });
+  });
+});
+
+describe("Storage Integration", () => {
+  test("SQLite storage should handle new part format", async () => {
+    const { SQLiteSessionStore } = await import("./storage/sqlite");
+    const { toModelMessage } = await import("./session-message-converter");
+    
+    const store = new SQLiteSessionStore(":memory:");
+    
+    // Create session
+    const session = await store.create({ title: "Test Storage" });
+    
+    // Add message with new format parts
+    await store.addMessage(session.id, {
+      role: "user",
+      content: "Test message",
+      parts: [
+        { type: "text", content: "Test message" },
+      ],
+    });
+    
+    // Add assistant message with reasoning
+    await store.addMessage(session.id, {
+      role: "assistant",
+      content: "I'll help you!",
+      parts: [
+        { type: "reasoning", content: "Analyzing the request...", reasoningType: "core" },
+        { type: "text", content: "I'll help you!" },
+      ],
+    });
+    
+    // Retrieve and verify
+    const messages = await store.getMessages(session.id);
+    
+    expect(messages).toHaveLength(2);
+    expect(messages[0].role).toBe("user");
+    expect(messages[0].parts).toHaveLength(1);
+    
+    expect(messages[1].role).toBe("assistant");
+    expect(messages[1].parts).toHaveLength(2);
+    expect(messages[1].parts![0].type).toBe("reasoning");
+    expect(messages[1].parts![1].type).toBe("text");
+    
+    // Convert to ModelMessage
+    const modelMsg = toModelMessage(messages[1]);
+    expect(modelMsg.role).toBe("assistant");
+    expect(modelMsg.content).toHaveLength(2);
+    
+    await store.close();
+  });
+  
+  test("Memory storage should handle new part format", async () => {
+    const { MemorySessionStore } = await import("./storage/memory");
+    const { sessionToHistory } = await import("./session-message-converter");
+    
+    const store = new MemorySessionStore();
+    
+    // Create session
+    const session = await store.create({ title: "Test Memory" });
+    
+    // Add user message
+    await store.addMessage(session.id, {
+      role: "user",
+      content: "Find TODO comments",
+    });
+    
+    // Add assistant message with tool call
+    await store.addMessage(session.id, {
+      role: "assistant",
+      content: "Let me search...",
+      parts: [
+        { type: "text", content: "Let me search..." },
+        { type: "tool-call", toolCallId: "call_1", toolName: "grep", arguments: { pattern: "TODO" }, state: "pending" as const },
+      ],
+    });
+    
+    await store.addMessage(session.id, {
+      role: "tool",
+      content: "Found 3 matches",
+      parts: [
+        { type: "tool-result", toolCallId: "call_1", toolName: "grep", output: "Found 3 matches", state: "completed" as const },
+      ],
+    });
+    
+    // Retrieve and convert to history
+    const messages = await store.getMessages(session.id);
+    const history = sessionToHistory(messages);
+    
+    expect(messages).toHaveLength(3);
+    expect(history).toHaveLength(3);
+    expect(history[1].role).toBe("assistant");
+    expect(history[1].content).toHaveLength(2);
+    
+    const toolCall = history[1].content.find((c: any) => c.type === "tool-call");
+    expect(toolCall).toBeDefined();
+    expect(toolCall.toolCallId).toBe("call_1");
+    expect(toolCall.toolName).toBe("grep");
+  });
+});