outcome-cli 1.0.0

package/src/utils/logger.test.ts

@@ -0,0 +1,361 @@
+/**
+ * Logger Tests
+ *
+ * Tests for the structured logging utility including:
+ * - Log entry creation and storage
+ * - Log retrieval and filtering
+ * - CLI formatting
+ * - Property tests for log completeness
+ *
+ * @module utils/logger.test
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import * as fc from 'fast-check';
+import {
+  log,
+  getLogs,
+  getAgentLogs,
+  clearLogs,
+  clearAllLogs,
+  getTotalLogCount,
+  formatLogsForCli,
+  logSuccess,
+  logFailure,
+  logPending,
+  type LogEntry,
+  type LogEntryInput,
+  type LogResult,
+} from './logger.js';
+
+describe('Logger', () => {
+  // Clear logs before each test to ensure isolation
+  beforeEach(() => {
+    clearAllLogs();
+  });
+
+  describe('log', () => {
+    it('should create a log entry with timestamp', () => {
+      const entry = log({
+        agentId: 'test-agent',
+        outcomeId: 'test-outcome',
+        promptVersion: 'v1.0.0',
+        tokensSpent: 100,
+        result: 'SUCCESS',
+      });
+
+      expect(entry.agentId).toBe('test-agent');
+      expect(entry.outcomeId).toBe('test-outcome');
+      expect(entry.promptVersion).toBe('v1.0.0');
+      expect(entry.tokensSpent).toBe(100);
+      expect(entry.result).toBe('SUCCESS');
+      expect(entry.timestamp).toBeDefined();
+      expect(new Date(entry.timestamp).getTime()).not.toBeNaN();
+    });
+
+    it('should store the log entry for retrieval', () => {
+      log({
+        agentId: 'agent-1',
+        outcomeId: 'outcome-1',
+        promptVersion: 'v1.0.0',
+        tokensSpent: 50,
+        result: 'PENDING',
+      });
+
+      const logs = getLogs('outcome-1');
+      expect(logs).toHaveLength(1);
+      expect(logs[0].agentId).toBe('agent-1');
+    });
+
+    it('should include failureReason when result is FAILURE', () => {
+      const entry = log({
+        agentId: 'agent-1',
+        outcomeId: 'outcome-1',
+        promptVersion: 'v1.0.0',
+        tokensSpent: 100,
+        result: 'FAILURE',
+        failureReason: 'Company too small',
+      });
+
+      expect(entry.result).toBe('FAILURE');
+      expect(entry.failureReason).toBe('Company too small');
+    });
+
+    it('should include metadata when provided', () => {
+      const entry = log({
+        agentId: 'agent-1',
+        outcomeId: 'outcome-1',
+        promptVersion: 'v1.0.0',
+        tokensSpent: 100,
+        result: 'SUCCESS',
+        metadata: { attemptNumber: 3, leadId: 'lead-123' },
+      });
+
+      expect(entry.metadata).toEqual({ attemptNumber: 3, leadId: 'lead-123' });
+    });
+  });
+
+  describe('getLogs', () => {
+    it('should return empty array for outcome with no logs', () => {
+      const logs = getLogs('nonexistent-outcome');
+      expect(logs).toEqual([]);
+    });
+
+    it('should return all logs for an outcome in order', () => {
+      log({ agentId: 'a1', outcomeId: 'o1', promptVersion: 'v1', tokensSpent: 10, result: 'PENDING' });
+      log({ agentId: 'a2', outcomeId: 'o1', promptVersion: 'v1', tokensSpent: 20, result: 'SUCCESS' });
+      log({ agentId: 'a1', outcomeId: 'o1', promptVersion: 'v1', tokensSpent: 30, result: 'FAILURE', failureReason: 'test' });
+
+      const logs = getLogs('o1');
+      expect(logs).toHaveLength(3);
+      expect(logs[0].agentId).toBe('a1');
+      expect(logs[1].agentId).toBe('a2');
+      expect(logs[2].agentId).toBe('a1');
+    });
+
+    it('should isolate logs by outcome', () => {
+      log({ agentId: 'a1', outcomeId: 'outcome-A', promptVersion: 'v1', tokensSpent: 10, result: 'SUCCESS' });
+      log({ agentId: 'a1', outcomeId: 'outcome-B', promptVersion: 'v1', tokensSpent: 20, result: 'SUCCESS' });
+
+      expect(getLogs('outcome-A')).toHaveLength(1);
+      expect(getLogs('outcome-B')).toHaveLength(1);
+    });
+  });
+
+  describe('getAgentLogs', () => {
+    it('should filter logs by agent ID', () => {
+      log({ agentId: 'agent-1', outcomeId: 'o1', promptVersion: 'v1', tokensSpent: 10, result: 'PENDING' });
+      log({ agentId: 'agent-2', outcomeId: 'o1', promptVersion: 'v1', tokensSpent: 20, result: 'SUCCESS' });
+      log({ agentId: 'agent-1', outcomeId: 'o1', promptVersion: 'v1', tokensSpent: 30, result: 'SUCCESS' });
+
+      const agent1Logs = getAgentLogs('o1', 'agent-1');
+      expect(agent1Logs).toHaveLength(2);
+      expect(agent1Logs.every(l => l.agentId === 'agent-1')).toBe(true);
+
+      const agent2Logs = getAgentLogs('o1', 'agent-2');
+      expect(agent2Logs).toHaveLength(1);
+    });
+  });
+
+  describe('clearLogs', () => {
+    it('should clear logs for specific outcome only', () => {
+      log({ agentId: 'a1', outcomeId: 'o1', promptVersion: 'v1', tokensSpent: 10, result: 'SUCCESS' });
+      log({ agentId: 'a1', outcomeId: 'o2', promptVersion: 'v1', tokensSpent: 20, result: 'SUCCESS' });
+
+      clearLogs('o1');
+
+      expect(getLogs('o1')).toHaveLength(0);
+      expect(getLogs('o2')).toHaveLength(1);
+    });
+  });
+
+  describe('clearAllLogs', () => {
+    it('should clear all logs', () => {
+      log({ agentId: 'a1', outcomeId: 'o1', promptVersion: 'v1', tokensSpent: 10, result: 'SUCCESS' });
+      log({ agentId: 'a1', outcomeId: 'o2', promptVersion: 'v1', tokensSpent: 20, result: 'SUCCESS' });
+
+      clearAllLogs();
+
+      expect(getLogs('o1')).toHaveLength(0);
+      expect(getLogs('o2')).toHaveLength(0);
+      expect(getTotalLogCount()).toBe(0);
+    });
+  });
+
+  describe('getTotalLogCount', () => {
+    it('should return total count across all outcomes', () => {
+      log({ agentId: 'a1', outcomeId: 'o1', promptVersion: 'v1', tokensSpent: 10, result: 'SUCCESS' });
+      log({ agentId: 'a1', outcomeId: 'o1', promptVersion: 'v1', tokensSpent: 20, result: 'SUCCESS' });
+      log({ agentId: 'a1', outcomeId: 'o2', promptVersion: 'v1', tokensSpent: 30, result: 'SUCCESS' });
+
+      expect(getTotalLogCount()).toBe(3);
+    });
+  });
+
+  describe('formatLogsForCli', () => {
+    it('should return message for empty logs', () => {
+      const output = formatLogsForCli('empty-outcome');
+      expect(output).toContain('No logs found');
+    });
+
+    it('should format logs with header and entries', () => {
+      log({ agentId: 'a1', outcomeId: 'o1', promptVersion: 'v1', tokensSpent: 100, result: 'SUCCESS' });
+      log({ agentId: 'a2', outcomeId: 'o1', promptVersion: 'v1', tokensSpent: 200, result: 'FAILURE', failureReason: 'Test failure' });
+
+      const output = formatLogsForCli('o1');
+      expect(output).toContain('o1');
+      expect(output).toContain('2 entries');
+      expect(output).toContain('a1');
+      expect(output).toContain('a2');
+      expect(output).toContain('SUCCESS');
+      expect(output).toContain('FAILURE');
+      expect(output).toContain('Test failure');
+    });
+  });
+
+  describe('convenience functions', () => {
+    it('logSuccess should create SUCCESS entry', () => {
+      const entry = logSuccess('agent-1', 'outcome-1', 'v1.0.0', 500);
+      expect(entry.result).toBe('SUCCESS');
+      expect(entry.failureReason).toBeUndefined();
+    });
+
+    it('logFailure should create FAILURE entry with reason', () => {
+      const entry = logFailure('agent-1', 'outcome-1', 'v1.0.0', 300, 'Test failure');
+      expect(entry.result).toBe('FAILURE');
+      expect(entry.failureReason).toBe('Test failure');
+    });
+
+    it('logPending should create PENDING entry', () => {
+      const entry = logPending('agent-1', 'outcome-1', 'v1.0.0', 100);
+      expect(entry.result).toBe('PENDING');
+    });
+  });
+});
+
+describe('Logger Property Tests', () => {
+  beforeEach(() => {
+    clearAllLogs();
+  });
+
+  /**
+   * **Feature: earnd-bounty-engine, Property 12: Log Entry Completeness**
+   * For any agent attempt, the log entry SHALL contain agentId, outcomeId,
+   * promptVersion, tokensSpent, result, and failureReason (if result is FAILURE).
+   * **Validates: Requirements 6.1**
+   */
+  it('Property 12: Log Entry Completeness', () => {
+    fc.assert(
+      fc.property(
+        fc.record({
+          agentId: fc.string({ minLength: 1 }),
+          outcomeId: fc.string({ minLength: 1 }),
+          promptVersion: fc.string({ minLength: 1 }),
+          tokensSpent: fc.nat(),
+          result: fc.constantFrom('SUCCESS', 'FAILURE', 'PENDING') as fc.Arbitrary<LogResult>,
+          failureReason: fc.option(fc.string({ minLength: 1 }), { nil: undefined }),
+        }),
+        (input) => {
+          clearAllLogs();
+
+          const entry = log({
+            agentId: input.agentId,
+            outcomeId: input.outcomeId,
+            promptVersion: input.promptVersion,
+            tokensSpent: input.tokensSpent,
+            result: input.result,
+            failureReason: input.failureReason,
+          });
+
+          // Verify all required fields are present
+          expect(entry.agentId).toBe(input.agentId);
+          expect(entry.outcomeId).toBe(input.outcomeId);
+          expect(entry.promptVersion).toBe(input.promptVersion);
+          expect(entry.tokensSpent).toBe(input.tokensSpent);
+          expect(entry.result).toBe(input.result);
+          expect(entry.timestamp).toBeDefined();
+          expect(typeof entry.timestamp).toBe('string');
+
+          // Verify timestamp is valid ISO string
+          const parsedTime = new Date(entry.timestamp).getTime();
+          expect(Number.isNaN(parsedTime)).toBe(false);
+
+          // If failure, reason should be included
+          if (input.result === 'FAILURE' && input.failureReason) {
+            expect(entry.failureReason).toBe(input.failureReason);
+          }
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * **Feature: earnd-bounty-engine, Property 13: Log Persistence**
+   * For any completed agent run with N attempts, querying logs SHALL return
+   * exactly N log entries for that agent.
+   * **Validates: Requirements 6.3**
+   */
+  it('Property 13: Log Persistence', () => {
+    fc.assert(
+      fc.property(
+        fc.nat({ max: 20 }), // Number of attempts (0-20)
+        fc.string({ minLength: 1 }), // agentId
+        fc.string({ minLength: 1 }), // outcomeId
+        (attemptCount, agentId, outcomeId) => {
+          clearAllLogs();
+
+          // Log N attempts
+          for (let i = 0; i < attemptCount; i++) {
+            log({
+              agentId,
+              outcomeId,
+              promptVersion: `v1.${i}`,
+              tokensSpent: 100 + i * 10,
+              result: i === attemptCount - 1 ? 'SUCCESS' : 'PENDING',
+            });
+          }
+
+          // Verify exactly N entries exist
+          const logs = getAgentLogs(outcomeId, agentId);
+          expect(logs.length).toBe(attemptCount);
+
+          // Verify all entries belong to the correct agent
+          for (const log of logs) {
+            expect(log.agentId).toBe(agentId);
+            expect(log.outcomeId).toBe(outcomeId);
+          }
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+
+  /**
+   * Property: Log isolation between outcomes
+   * Logs for different outcomes SHALL be isolated from each other.
+   */
+  it('Property: Log isolation between outcomes', () => {
+    fc.assert(
+      fc.property(
+        fc.string({ minLength: 1 }), // outcomeId1
+        fc.string({ minLength: 1 }), // outcomeId2
+        fc.nat({ max: 10 }), // count1
+        fc.nat({ max: 10 }), // count2
+        (outcomeId1, outcomeId2, count1, count2) => {
+          // Skip if outcomes are the same
+          if (outcomeId1 === outcomeId2) return;
+
+          clearAllLogs();
+
+          // Log to first outcome
+          for (let i = 0; i < count1; i++) {
+            log({
+              agentId: `agent-${i}`,
+              outcomeId: outcomeId1,
+              promptVersion: 'v1',
+              tokensSpent: 100,
+              result: 'SUCCESS',
+            });
+          }
+
+          // Log to second outcome
+          for (let i = 0; i < count2; i++) {
+            log({
+              agentId: `agent-${i}`,
+              outcomeId: outcomeId2,
+              promptVersion: 'v1',
+              tokensSpent: 100,
+              result: 'SUCCESS',
+            });
+          }
+
+          // Verify isolation
+          expect(getLogs(outcomeId1).length).toBe(count1);
+          expect(getLogs(outcomeId2).length).toBe(count2);
+        }
+      ),
+      { numRuns: 100 }
+    );
+  });
+});