groundswell 0.0.1 → 0.0.2

package/src/__tests__/integration/observer-logging.test.ts

@@ -0,0 +1,643 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Workflow } from '../../core/workflow';
+import type { WorkflowObserver, WorkflowEvent, LogEntry } from '../../types';
+
+describe('Observer Error Logging Integration Tests', () => {
+  describe('WorkflowLogger observer onLog error', () => {
+    it('should log observer onLog errors to workflow.node.logs', async () => {
+      const onLogError = new Error('Observer onLog failed');
+
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {
+          throw onLogError;
+        },
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.logger.info('Test message');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+      await workflow.run();
+
+      // Should have 2 logs: the original "Test message" and the observer error
+      expect(workflow.node.logs.length).toBe(2);
+
+      // First log is the original message
+      expect(workflow.node.logs[0].message).toBe('Test message');
+      expect(workflow.node.logs[0].level).toBe('info');
+
+      // Second log is the observer error
+      expect(workflow.node.logs[1].message).toBe('Observer onLog error');
+      expect(workflow.node.logs[1].level).toBe('error');
+      expect(workflow.node.logs[1].data).toEqual({ error: onLogError });
+    });
+
+    it('should avoid infinite recursion when observer onLog throws', async () => {
+      let callCount = 0;
+      const maxCalls = 10; // Safety limit to prevent actual infinite loop
+
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {
+          callCount++;
+          if (callCount < maxCalls) {
+            throw new Error('Recursive error');
+          }
+        },
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.logger.info('Test message');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+      await workflow.run();
+
+      // Should only call onLog once (original) + one error log, then stop
+      // The error log should NOT trigger another observer notification
+      expect(callCount).toBe(1);
+
+      // Should have 2 logs: original + error
+      expect(workflow.node.logs.length).toBe(2);
+    });
+  });
+
+  describe('Workflow observer onEvent error', () => {
+    it('should log observer onEvent errors via this.logger.error', () => {
+      const onEventError = new Error('Observer onEvent failed');
+
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {},
+        onEvent: () => {
+          throw onEventError;
+        },
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.emitEvent({ type: 'testEvent' } as any);
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+
+      workflow.run();
+
+      // Should have error log entry
+      const errorLog = workflow.node.logs.find((log) => log.message === 'Observer onEvent error');
+      expect(errorLog).toBeDefined();
+      expect(errorLog?.level).toBe('error');
+      expect(errorLog?.data).toEqual({
+        error: onEventError,
+        eventType: 'testEvent',
+      });
+    });
+
+    it('should include event type in error data', () => {
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {},
+        onEvent: () => {
+          throw new Error('Event error');
+        },
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.emitEvent({ type: 'treeUpdated', root: this.node });
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+
+      workflow.run();
+
+      const errorLog = workflow.node.logs.find((log) => log.message === 'Observer onEvent error');
+      expect(errorLog?.data).toHaveProperty('eventType', 'treeUpdated');
+    });
+  });
+
+  describe('Workflow observer onStateUpdated error', () => {
+    it('should log observer onStateUpdated errors via this.logger.error', async () => {
+      const onStateUpdatedError = new Error('Observer onStateUpdated failed');
+
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {},
+        onEvent: () => {},
+        onStateUpdated: () => {
+          throw onStateUpdatedError;
+        },
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.snapshotState();
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+      await workflow.run();
+
+      // Should have error log entry
+      const errorLog = workflow.node.logs.find(
+        (log) => log.message === 'Observer onStateUpdated error'
+      );
+      expect(errorLog).toBeDefined();
+      expect(errorLog?.level).toBe('error');
+      expect(errorLog?.data).toEqual({
+        error: onStateUpdatedError,
+        nodeId: workflow.node.id,
+      });
+    });
+
+    it('should include node ID in error data', async () => {
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {},
+        onEvent: () => {},
+        onStateUpdated: () => {
+          throw new Error('State update error');
+        },
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.snapshotState();
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+      await workflow.run();
+
+      const errorLog = workflow.node.logs.find(
+        (log) => log.message === 'Observer onStateUpdated error'
+      );
+      expect(errorLog?.data).toHaveProperty('nodeId', workflow.node.id);
+    });
+  });
+
+  describe('Validation errors still use console.error', () => {
+    it('should use console.error for child already has parent validation', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const parent = new Workflow('ParentWorkflow');
+      const child1 = new Workflow('Child1', parent);
+      const child2 = new Workflow('Child2');
+
+      // Try to attach child1 to child2 (should fail - already has parent)
+      expect(() => {
+        child2.attachChild(child1);
+      }).toThrow();
+
+      // Should have called console.error for validation
+      expect(consoleErrorSpy).toHaveBeenCalled();
+      const errorMessage = consoleErrorSpy.mock.calls[0][0] as string;
+      expect(errorMessage).toContain('already has a parent');
+
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should use console.error for circular reference detection', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const grandparent = new Workflow('Grandparent');
+      const parent = new Workflow('Parent', grandparent);
+      const child = new Workflow('Child', parent);
+
+      // Try to attach grandparent as child of child (circular reference)
+      expect(() => {
+        child.attachChild(grandparent);
+      }).toThrow();
+
+      // Should have called console.error for validation
+      expect(consoleErrorSpy).toHaveBeenCalled();
+      const errorMessage = consoleErrorSpy.mock.calls[0][0] as string;
+      expect(errorMessage).toContain('circular reference');
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('Error isolation', () => {
+    it('should not crash workflow when observer onLog throws', async () => {
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {
+          throw new Error('Observer onLog error');
+        },
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.logger.info('Message 1');
+          this.logger.info('Message 2');
+          this.logger.info('Message 3');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+
+      // Should complete without throwing
+      await expect(workflow.run()).resolves.toBeUndefined();
+
+      // All messages should be logged
+      expect(workflow.node.logs.length).toBe(6); // 3 messages + 3 error logs
+    });
+
+    it('should not crash workflow when observer onEvent throws', () => {
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {},
+        onEvent: () => {
+          throw new Error('Observer onEvent error');
+        },
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.emitEvent({ type: 'event1' } as any);
+          this.emitEvent({ type: 'event2' } as any);
+          this.emitEvent({ type: 'event3' } as any);
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+
+      // Should complete without throwing
+      expect(() => {
+        workflow.run();
+      }).not.toThrow();
+
+      // All events should be emitted
+      expect(workflow.node.events.length).toBe(3);
+    });
+
+    it('should not crash workflow when observer onStateUpdated throws', async () => {
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {},
+        onEvent: () => {},
+        onStateUpdated: () => {
+          throw new Error('Observer onStateUpdated error');
+        },
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.snapshotState();
+          this.snapshotState();
+          this.snapshotState();
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+
+      // Should complete without throwing
+      await expect(workflow.run()).resolves.toBeUndefined();
+    });
+  });
+
+  describe('Observer onTreeChanged error', () => {
+    it('should log observer onTreeChanged errors (caught as onEvent error)', () => {
+      const onTreeChangedError = new Error('Observer onTreeChanged failed');
+
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {},
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {
+          throw onTreeChangedError;
+        },
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          // Trigger treeUpdated event which calls onTreeChanged
+          this.emitEvent({ type: 'treeUpdated', root: this.node });
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+
+      workflow.run();
+
+      // Should have error log entry (logged as "Observer onEvent error" since onTreeChanged is in onEvent try-catch)
+      const errorLog = workflow.node.logs.find((log) => log.message === 'Observer onEvent error');
+      expect(errorLog).toBeDefined();
+      expect(errorLog?.level).toBe('error');
+      expect(errorLog?.data).toEqual({
+        error: onTreeChangedError,
+        eventType: 'treeUpdated',
+      });
+    });
+
+    it('should log observer onTreeChanged errors for childAttached events', () => {
+      const onTreeChangedError = new Error('Tree changed on attach');
+
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {},
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {
+          throw onTreeChangedError;
+        },
+      };
+
+      const parent = new Workflow('ParentWorkflow');
+      const child = new Workflow('ChildWorkflow');
+
+      parent.addObserver(throwingObserver);
+
+      // Trigger childAttached event which calls onTreeChanged
+      parent.attachChild(child);
+
+      // Should have error log entry (logged as "Observer onEvent error")
+      const errorLog = parent.node.logs.find((log) => log.message === 'Observer onEvent error');
+      expect(errorLog).toBeDefined();
+      expect(errorLog?.data).toEqual({
+        error: onTreeChangedError,
+        eventType: 'childAttached',
+      });
+    });
+
+    it('should log observer onTreeChanged errors for childDetached events', () => {
+      const onTreeChangedError = new Error('Tree changed on detach');
+
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {},
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {
+          throw onTreeChangedError;
+        },
+      };
+
+      const parent = new Workflow('ParentWorkflow');
+      const child = new Workflow('ChildWorkflow', parent);
+
+      parent.addObserver(throwingObserver);
+
+      // Clear logs from setup
+      parent.node.logs = [];
+
+      // Trigger childDetached event which calls onTreeChanged
+      parent.detachChild(child);
+
+      // Should have error log entry (logged as "Observer onEvent error")
+      const errorLog = parent.node.logs.find((log) => log.message === 'Observer onEvent error');
+      expect(errorLog).toBeDefined();
+      expect(errorLog?.data).toEqual({
+        error: onTreeChangedError,
+        eventType: 'childDetached',
+      });
+    });
+  });
+
+  describe('Console.error negative verification', () => {
+    it('should NOT call console.error for observer onLog errors', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {
+          throw new Error('Observer onLog error');
+        },
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.logger.info('Test message');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+      await workflow.run();
+
+      // Verify console.error was NOT called for observer error
+      expect(consoleErrorSpy).not.toHaveBeenCalled();
+
+      // Verify error was logged to workflow.node.logs instead
+      const errorLog = workflow.node.logs.find((log) => log.message === 'Observer onLog error');
+      expect(errorLog).toBeDefined();
+
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should NOT call console.error for observer onEvent errors', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {},
+        onEvent: () => {
+          throw new Error('Observer onEvent error');
+        },
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.emitEvent({ type: 'testEvent' } as any);
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+      workflow.run();
+
+      // Verify console.error was NOT called for observer error
+      expect(consoleErrorSpy).not.toHaveBeenCalled();
+
+      // Verify error was logged to workflow.node.logs instead
+      const errorLog = workflow.node.logs.find((log) => log.message === 'Observer onEvent error');
+      expect(errorLog).toBeDefined();
+
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should NOT call console.error for observer onStateUpdated errors', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {},
+        onEvent: () => {},
+        onStateUpdated: () => {
+          throw new Error('Observer onStateUpdated error');
+        },
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.snapshotState();
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+      await workflow.run();
+
+      // Verify console.error was NOT called for observer error
+      expect(consoleErrorSpy).not.toHaveBeenCalled();
+
+      // Verify error was logged to workflow.node.logs instead
+      const errorLog = workflow.node.logs.find(
+        (log) => log.message === 'Observer onStateUpdated error'
+      );
+      expect(errorLog).toBeDefined();
+
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should NOT call console.error for observer onTreeChanged errors', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {},
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {
+          throw new Error('Observer onTreeChanged error');
+        },
+      };
+
+      const parent = new Workflow('ParentWorkflow');
+      const child = new Workflow('ChildWorkflow');
+
+      parent.addObserver(throwingObserver);
+
+      // Trigger childAttached which calls onTreeChanged
+      parent.attachChild(child);
+
+      // Verify console.error was NOT called for observer error
+      expect(consoleErrorSpy).not.toHaveBeenCalled();
+
+      // Verify error was logged to workflow.node.logs instead (as onEvent error)
+      const errorLog = parent.node.logs.find((log) => log.message === 'Observer onEvent error');
+      expect(errorLog).toBeDefined();
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('Multiple observers', () => {
+    it('should continue notifying other observers after one throws', async () => {
+      let observer2Called = false;
+      let observer3Called = false;
+
+      const throwingObserver: WorkflowObserver = {
+        onLog: () => {
+          throw new Error('Observer 1 failed');
+        },
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      const workingObserver2: WorkflowObserver = {
+        onLog: () => {
+          observer2Called = true;
+        },
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      const workingObserver3: WorkflowObserver = {
+        onLog: () => {
+          observer3Called = true;
+        },
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.logger.info('Test message');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver);
+      workflow.addObserver(workingObserver2);
+      workflow.addObserver(workingObserver3);
+
+      await workflow.run();
+
+      // Both working observers should have been called
+      expect(observer2Called).toBe(true);
+      expect(observer3Called).toBe(true);
+
+      // Should have error log for throwing observer
+      const errorLog = workflow.node.logs.find((log) => log.message === 'Observer onLog error');
+      expect(errorLog).toBeDefined();
+    });
+
+    it('should log errors for multiple throwing observers', async () => {
+      const throwingObserver1: WorkflowObserver = {
+        onLog: () => {
+          throw new Error('Observer 1 error');
+        },
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      const throwingObserver2: WorkflowObserver = {
+        onLog: () => {
+          throw new Error('Observer 2 error');
+        },
+        onEvent: () => {},
+        onStateUpdated: () => {},
+        onTreeChanged: () => {},
+      };
+
+      class TestWorkflow extends Workflow {
+        async run() {
+          this.logger.info('Test message');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      workflow.addObserver(throwingObserver1);
+      workflow.addObserver(throwingObserver2);
+
+      await workflow.run();
+
+      // Should have error logs for both throwing observers
+      const errorLogs = workflow.node.logs.filter((log) => log.message === 'Observer onLog error');
+      expect(errorLogs.length).toBe(2);
+    });
+  });
+});

package/src/__tests__/integration/tree-mirroring.test.ts

@@ -111,4 +111,41 @@ describe('Tree Mirroring Integration', () => {
       }
     }
   });
+
+  it('should propagate treeUpdated events to root observers', () => {
+    // ARRANGE: Create parent-child workflow tree
+    const parent = new TDDOrchestrator('Parent');
+    const child = new TDDOrchestrator('Child', parent);
+
+    // ARRANGE: Set up observer with collection arrays
+    const events: WorkflowEvent[] = [];
+    const treeChangedCalls: any[] = [];
+
+    // ARRANGE: Create inline observer
+    const observer: WorkflowObserver = {
+      onLog: () => {}, // Empty - not testing logs
+      onEvent: (event) => events.push(event), // Capture events
+      onStateUpdated: () => {}, // Empty - not testing state updates
+      onTreeChanged: (root) => treeChangedCalls.push(root), // Capture tree changes
+    };
+
+    // ARRANGE: Attach observer to ROOT (parent, not child)
+    parent.addObserver(observer);
+
+    // ACT: Trigger status change on CHILD workflow
+    child.setStatus('completed');
+
+    // ASSERT: Verify treeUpdated event was received via onEvent
+    const treeUpdatedEvent = events.find((e) => e.type === 'treeUpdated');
+    expect(treeUpdatedEvent).toBeDefined();
+
+    // ASSERT: Type guard for discriminated union + verify root node
+    if (treeUpdatedEvent && treeUpdatedEvent.type === 'treeUpdated') {
+      expect(treeUpdatedEvent.root).toBe(parent.getNode());
+    }
+
+    // ASSERT: Verify onTreeChanged callback was invoked
+    expect(treeChangedCalls).toHaveLength(1);
+    expect(treeChangedCalls[0]).toBe(parent.getNode());
+  });
 });