Add tests for MetadataHandler

Author: AlePouroullis

.fernignore

@@ -19,6 +19,7 @@ src/utils
 
 # Modified due to issues with OTEL
 tests/unit/fetcher/stream-wrappers/webpack.test.ts
+tests/unit/internal/
 tests/integration/
 
 # CI Action

src/evals/run.ts

@@ -637,7 +637,6 @@ async function resolveFile<I extends Record<string, unknown> & { message?: any[]
                 "File does not exist on Humanloop. Please provide a `file.path` and a version to create a new version.",
             );
         }
-        Logger.log(`UPSERTING FILE ${JSON.stringify(fileConfig, null, 2)}`);
         return [await upsertFile(client, fileConfig), callable];
     }
 

src/sync/MetadataHandler.ts

@@ -1,5 +1,5 @@
-import fs from "fs";
-import path from "path";
+import * as fs from "fs";
+import * as path from "path";
 
 /**
  * Interface for operation data
@@ -33,7 +33,7 @@ interface LogOperationParams {
     successfulFiles?: string[];
     failedFiles?: string[];
     error?: string;
-    startTime: number;
+    duration_ms: number;
 }
 
 /**
@@ -107,7 +107,6 @@ export default class MetadataHandler {
      */
     public logOperation(params: LogOperationParams): void {
         const currentTime = new Date().toISOString();
-        const duration = Date.now() - params.startTime;
 
         const operationData: OperationData = {
             timestamp: currentTime,
@@ -117,7 +116,7 @@ export default class MetadataHandler {
             successful_files: params.successfulFiles || [],
             failed_files: params.failedFiles || [],
             error: params.error,
-            duration_ms: duration,
+            duration_ms: params.duration_ms,
         };
 
         const metadata = this.readMetadata();

src/sync/SyncClient.ts

@@ -316,18 +316,19 @@ export default class SyncClient {
                 path: normalizedPath || "",
                 environment,
                 successfulFiles,
-                startTime,
+                duration_ms: duration,
             });
 
             return successfulFiles;
         } catch (error) {
+            const duration = Date.now() - startTime;
             // Log the failed operation
             this.metadata.logOperation({
                 operationType: "pull",
                 path: normalizedPath || "",
                 environment,
                 error: String(error),
-                startTime,
+                duration_ms: duration,
             });
             throw error;
         }

tests/unit/internal/sync/MetadataHandler.test.ts

@@ -0,0 +1,267 @@
+import * as fs from "fs";
+import * as path from "path";
+
+import MetadataHandler from "../../../../src/sync/MetadataHandler";
+
+// Mock fs module
+jest.mock("fs");
+
+describe("MetadataHandler", () => {
+    let metadataHandler: MetadataHandler;
+    const testBaseDir = "/test/dir";
+    const mockMetadataFile = path.join(testBaseDir, ".sync_metadata.json");
+
+    beforeEach(() => {
+        // Clear all mocks before each test
+        jest.clearAllMocks();
+
+        // Mock fs.existsSync to return false initially (file doesn't exist)
+        (fs.existsSync as jest.Mock).mockReturnValue(false);
+
+        // Mock fs.mkdirSync to do nothing
+        (fs.mkdirSync as jest.Mock).mockImplementation(() => {});
+
+        // Mock fs.writeFileSync to do nothing
+        (fs.writeFileSync as jest.Mock).mockImplementation(() => {});
+
+        // Mock fs.readFileSync to return initial state
+        (fs.readFileSync as jest.Mock).mockReturnValue(
+            JSON.stringify({ last_operation: null, history: [] }),
+        );
+    });
+
+    describe("initialization", () => {
+        it("should create metadata file if it does not exist", () => {
+            metadataHandler = new MetadataHandler(testBaseDir);
+            expect(fs.existsSync).toHaveBeenCalledWith(mockMetadataFile);
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                mockMetadataFile,
+                JSON.stringify({ last_operation: null, history: [] }, null, 2),
+            );
+        });
+
+        it("should not create metadata file if it already exists", () => {
+            // Reset mocks
+            jest.clearAllMocks();
+
+            // Mock that file exists
+            (fs.existsSync as jest.Mock).mockReturnValue(true);
+
+            // Mock readFileSync to return existing data
+            (fs.readFileSync as jest.Mock).mockReturnValue(
+                JSON.stringify({ last_operation: null, history: [] }),
+            );
+
+            metadataHandler = new MetadataHandler(testBaseDir);
+
+            expect(fs.writeFileSync).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("logOperation", () => {
+        it("should log operation with all fields", () => {
+            metadataHandler = new MetadataHandler(testBaseDir);
+            const params = {
+                operationType: "pull",
+                path: "test/path",
+                environment: "dev",
+                successfulFiles: ["test/path/file1.prompt", "test/path/file2.prompt"],
+                failedFiles: ["test/path/file3.prompt"],
+                error: "Test error",
+                duration_ms: 1000,
+            };
+
+            metadataHandler.logOperation(params);
+
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                mockMetadataFile,
+                expect.stringContaining('"operation_type": "pull"'),
+            );
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                mockMetadataFile,
+                expect.stringContaining('"path": "test/path"'),
+            );
+            expect(fs.writeFileSync).toHaveBeenCalledWith(
+                mockMetadataFile,
+                expect.stringContaining('"environment": "dev"'),
+            );
+        });
+
+        it("should maintain history within max size", () => {
+            // First, initialize the MetadataHandler
+            metadataHandler = new MetadataHandler(testBaseDir);
+
+            // Clear the writeFileSync mock to reset the call history after initialization
+            (fs.writeFileSync as jest.Mock).mockClear();
+
+            // Create a history array with 5 items
+            const existingHistory = Array(5)
+                .fill(null)
+                .map(() => ({
+                    timestamp: new Date().toISOString(),
+                    operation_type: "pull",
+                    path: "/test/path",
+                    successful_files: [],
+                    failed_files: [],
+                    duration_ms: 1000,
+                }));
+
+            // NOW set up the stateful mock AFTER initialization
+            // This prevents the ensureMetadataFile from overwriting our test data
+            (fs.readFileSync as jest.Mock).mockReturnValue(
+                JSON.stringify({
+                    last_operation: existingHistory[0],
+                    history: existingHistory,
+                }),
+            );
+
+            const params = {
+                operationType: "pull",
+                path: "/new/path",
+                duration_ms: 750,
+            };
+
+            metadataHandler.logOperation(params);
+
+            // Get the last call to writeFileSync
+            const lastCallArgs = (fs.writeFileSync as jest.Mock).mock.calls[0];
+            const writtenData = JSON.parse(lastCallArgs[1]);
+
+            // The history should still have 5 items (max size) after adding a new one
+            expect(writtenData.history.length).toBe(5);
+
+            // The new operation should be at the start of the array
+            expect(writtenData.history[0].operation_type).toBe("pull");
+            expect(writtenData.history[0].path).toBe("/new/path");
+            expect(writtenData.history[0].duration_ms).toBe(750);
+        });
+
+        it("should handle empty history array", () => {
+            metadataHandler = new MetadataHandler(testBaseDir);
+
+            const params = {
+                operationType: "pull",
+                path: "test/path",
+                duration_ms: 500,
+            };
+
+            metadataHandler.logOperation(params);
+
+            const lastCallArgs = (fs.writeFileSync as jest.Mock).mock.calls.slice(
+                -1,
+            )[0];
+            const writtenData = JSON.parse(lastCallArgs[1]);
+
+            expect(writtenData.history.length).toBe(1);
+            expect(writtenData.history[0].operation_type).toBe("pull");
+            expect(writtenData.history[0].path).toBe("test/path");
+        });
+
+        it("should handle missing optional fields", () => {
+            metadataHandler = new MetadataHandler(testBaseDir);
+
+            const params = {
+                operationType: "pull",
+                path: "test/path",
+                duration_ms: 500,
+            };
+
+            metadataHandler.logOperation(params);
+
+            const lastCallArgs = (fs.writeFileSync as jest.Mock).mock.calls.slice(
+                -1,
+            )[0];
+            const writtenData = JSON.parse(lastCallArgs[1]);
+
+            expect(writtenData.history[0].successful_files).toEqual([]);
+            expect(writtenData.history[0].failed_files).toEqual([]);
+            expect(writtenData.history[0].environment).toBeUndefined();
+            expect(writtenData.history[0].error).toBeUndefined();
+        });
+    });
+
+    describe("getLastOperation", () => {
+        it("should return the last operation", () => {
+            const operation = {
+                timestamp: new Date().toISOString(),
+                operation_type: "pull",
+                path: "test/path",
+                successful_files: [],
+                failed_files: [],
+                duration_ms: 1000,
+            };
+
+            // Mock readFileSync to return a state with a last operation
+            (fs.readFileSync as jest.Mock).mockReturnValue(
+                JSON.stringify({
+                    last_operation: operation,
+                    history: [operation],
+                }),
+            );
+
+            metadataHandler = new MetadataHandler(testBaseDir);
+            const result = metadataHandler.getLastOperation();
+
+            expect(result).toEqual(operation);
+        });
+
+        it("should return null if no operations exist", () => {
+            // Mock readFileSync to return empty state
+            (fs.readFileSync as jest.Mock).mockReturnValue(
+                JSON.stringify({
+                    last_operation: null,
+                    history: [],
+                }),
+            );
+
+            metadataHandler = new MetadataHandler(testBaseDir);
+            const result = metadataHandler.getLastOperation();
+
+            expect(result).toBeNull();
+        });
+    });
+
+    describe("getHistory", () => {
+        it("should return the operation history", () => {
+            const operations = Array(3)
+                .fill(null)
+                .map((_, i) => ({
+                    timestamp: new Date().toISOString(),
+                    operation_type: "pull",
+                    path: `test/path${i}`,
+                    successful_files: [],
+                    failed_files: [],
+                    duration_ms: 1000 + i,
+                }));
+
+            // Mock readFileSync to return a state with history
+            (fs.readFileSync as jest.Mock).mockReturnValue(
+                JSON.stringify({
+                    last_operation: operations[0],
+                    history: operations,
+                }),
+            );
+
+            metadataHandler = new MetadataHandler(testBaseDir);
+            const result = metadataHandler.getHistory();
+
+            expect(result).toEqual(operations);
+            expect(result.length).toBe(3);
+        });
+
+        it("should return empty array if no history exists", () => {
+            // Mock readFileSync to return empty state
+            (fs.readFileSync as jest.Mock).mockReturnValue(
+                JSON.stringify({
+                    last_operation: null,
+                    history: [],
+                }),
+            );
+
+            metadataHandler = new MetadataHandler(testBaseDir);
+            const result = metadataHandler.getHistory();
+
+            expect(result).toEqual([]);
+        });
+    });
+});