Updated tests to conform to the new testing guidelines.

Author: gasperzgonec

src/types/extraction.test.ts

@@ -1,13 +1,16 @@
 import { EventContext, EventType, InitialSyncScope } from './extraction';
 import { createEvent } from '../tests/test-helpers';
 
-describe('EventContext', () => {
+// Test the EventContext interface and related extraction types
+describe('ExtractionTypes', () => {
   const baseEvent = createEvent({ eventType: EventType.ExtractionDataStart });
 
   it('should create event context without optional fields', () => {
     const event = { ...baseEvent };
+    
     // If this compiles, the test passes
     expect(event).toBeDefined();
+    expect(event.payload.event_context).toBeDefined();
   });
 
   it('should create event context with all optional fields', () => {
@@ -20,8 +23,10 @@ describe('EventContext', () => {
         reset_extract_from: true
     } as EventContext;
 
-    // Test with all optionals present
     expect(event).toBeDefined();
+    expect(event.payload.event_context.extract_from).toBe('2024-01-01T00:00:00Z');
+    expect(event.payload.event_context.initial_sync_scope).toBe(InitialSyncScope.TIME_SCOPED);
+    expect(event.payload.event_context.reset_extract_from).toBe(true);
   });
 
   it('should create event context with partial optional fields', () => {
@@ -33,5 +38,75 @@ describe('EventContext', () => {
     } as EventContext;
 
     expect(event).toBeDefined();
+    expect(event.payload.event_context.extract_from).toBe('2024-01-01T00:00:00Z');
+  });
+
+  it('should handle different InitialSyncScope values', () => {
+    const event = { ...baseEvent };
+
+    event.payload.event_context = {
+        ...baseEvent.payload.event_context,
+        initial_sync_scope: InitialSyncScope.FULL_HISTORY
+    } as EventContext;
+
+    expect(event.payload.event_context.initial_sync_scope).toBe(InitialSyncScope.FULL_HISTORY);
+  });
+
+  describe('[Edges]', () => {
+    it('should handle null event context gracefully', () => {
+      const event = { ...baseEvent };
+
+      event.payload.event_context = null as any;
+
+      expect(event.payload.event_context).toBeNull();
+    });
+
+    it('should handle undefined optional fields', () => {
+      const event = { ...baseEvent };
+
+      event.payload.event_context = {
+        ...baseEvent.payload.event_context,
+        extract_from: undefined,
+        initial_sync_scope: undefined,
+        reset_extract_from: undefined
+      } as EventContext;
+
+      expect(event.payload.event_context.extract_from).toBeUndefined();
+      expect(event.payload.event_context.initial_sync_scope).toBeUndefined();
+      expect(event.payload.event_context.reset_extract_from).toBeUndefined();
+    });
+
+    it('should handle invalid date format in extract_from', () => {
+      const event = { ...baseEvent };
+
+      event.payload.event_context = {
+        ...baseEvent.payload.event_context,
+        extract_from: 'invalid-date-format'
+      } as EventContext;
+
+      expect(event.payload.event_context.extract_from).toBe('invalid-date-format');
+      // Note: Type validation would typically happen at runtime, not compile time
+    });
+
+    it('should handle explicit boolean values for reset_extract_from', () => {
+      const eventWithTrue = createEvent({
+        eventType: EventType.ExtractionDataStart,
+        eventContextOverrides: {
+          reset_extract_from: true
+        }
+      });
+
+      const eventWithFalse = createEvent({
+        eventType: EventType.ExtractionDataStart,
+        eventContextOverrides: {
+          reset_extract_from: false
+        }
+      });
+
+      expect(eventWithTrue.payload.event_context.reset_extract_from).toBe(true);
+      expect(eventWithFalse.payload.event_context.reset_extract_from).toBe(false);
+      expect(typeof eventWithTrue.payload.event_context.reset_extract_from).toBe('boolean');
+      expect(typeof eventWithFalse.payload.event_context.reset_extract_from).toBe('boolean');
+    });
   });
 });

src/workers/create-worker.test.ts

@@ -5,8 +5,9 @@ import { EventType } from '../types/extraction';
 import { createWorker } from './create-worker';
 
 describe(createWorker.name, () => {
-  it('should create a Worker instance when valid worker script path is provided', async () => {
+  it('should create a Worker instance when valid parameters are provided', async () => {
     const workerPath = __dirname + '../tests/dummy-worker.ts';
+    
     const worker = isMainThread
       ? await createWorker<object>({
           event: createEvent({
@@ -24,4 +25,82 @@ describe(createWorker.name, () => {
       await worker.terminate();
     }
   });
+
+  it('should throw error when not in main thread', async () => {
+    const originalIsMainThread = isMainThread;
+    (isMainThread as any) = false;
+    const workerPath = __dirname + '../tests/dummy-worker.ts';
+
+    await expect(
+      createWorker<object>({
+        event: createEvent({
+          eventType: EventType.ExtractionExternalSyncUnitsStart,
+        }),
+        initialState: {},
+        workerPath,
+      })
+    ).rejects.toThrow('Worker threads can not start more worker threads.');
+
+    // Restore original value
+    (isMainThread as any) = originalIsMainThread;
+  });
+
+  describe('[Edges]', () => {
+    it('should handle worker creation with minimal valid data', async () => {
+      const workerPath = __dirname + '../tests/dummy-worker.ts';
+
+      if (isMainThread) {
+        const worker = await createWorker<object>({
+          event: createEvent({
+            eventType: EventType.ExtractionExternalSyncUnitsStart,
+          }),
+          initialState: {},
+          workerPath,
+        });
+
+        expect(worker).toBeInstanceOf(Worker);
+        await worker.terminate();
+      }
+    });
+
+    it('should handle worker creation with complex initial state', async () => {
+      const workerPath = __dirname + '../tests/dummy-worker.ts';
+      const complexState = {
+        nested: {
+          data: [1, 2, 3],
+          config: { enabled: true }
+        }
+      };
+
+      if (isMainThread) {
+        const worker = await createWorker<typeof complexState>({
+          event: createEvent({
+            eventType: EventType.ExtractionDataStart,
+          }),
+          initialState: complexState,
+          workerPath,
+        });
+
+        expect(worker).toBeInstanceOf(Worker);
+        await worker.terminate();
+      }
+    });
+
+    it('should handle different event types', async () => {
+      const workerPath = __dirname + '../tests/dummy-worker.ts';
+
+      if (isMainThread) {
+        const worker = await createWorker<object>({
+          event: createEvent({
+            eventType: EventType.ExtractionMetadataStart,
+          }),
+          initialState: {},
+          workerPath,
+        });
+
+        expect(worker).toBeInstanceOf(Worker);
+        await worker.terminate();
+      }
+    });
+  });
 });

src/workers/worker-adapter.test.ts

@@ -501,7 +501,7 @@ describe(WorkerAdapter.name, () => {
       jest.restoreAllMocks();
     });
 
-    test('should emit only one event when multiple events of same type are sent', async () => {
+    it('should emit only one event when multiple events of same type are sent', async () => {
       adapter['adapterState'].postState = jest.fn().mockResolvedValue(undefined);
       adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
 
@@ -517,7 +517,7 @@ describe(WorkerAdapter.name, () => {
       expect(counter.counter).toBe(1);
     });
 
-    test('should emit event when different event type is sent after previous events', async () => {
+    it('should emit event when different event type is sent after previous events', async () => {
       adapter['adapterState'].postState = jest.fn().mockResolvedValue(undefined);
       adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
 
@@ -537,7 +537,7 @@ describe(WorkerAdapter.name, () => {
       expect(counter.counter).toBe(1);
     });
 
-    test('should correctly emit one event even if postState errors', async () => {
+    it('should correctly emit one event even if postState errors', async () => {
       adapter['adapterState'].postState = jest.fn().mockRejectedValue(new Error('postState error'));
       adapter.uploadAllRepos = jest.fn().mockResolvedValue(undefined);
 
@@ -548,7 +548,7 @@ describe(WorkerAdapter.name, () => {
       expect(counter.counter).toBe(1);
     });
 
-    test('should correctly emit one event even if uploadAllRepos errors', async () => {
+    it('should correctly emit one event even if uploadAllRepos errors', async () => {
       adapter['adapterState'].postState = jest.fn().mockResolvedValue(undefined);
       adapter.uploadAllRepos = jest.fn().mockRejectedValue(new Error('uploadAllRepos error'));