@futdevpro/fsm-dynamo 1.15.17 → 1.15.20

package/src/_modules/data-handler/_models/list-collector-data-handler.control-model.spec.ts

@@ -1,374 +1,374 @@
-import { DyFM_ListCollectorDataHandler } from './list-collector-data-handler.control-model';
-import { DyFM_Metadata } from '../../../_models/data-models/metadata.data-model';
-import { DyFM_ListCollectorDataHandler_Settings } from './data-handler-settings.control-model';
-import { DyFM_Error } from '../../../_models/control-models/error.control-model';
-
-class TestCollector extends DyFM_Metadata {
-  items?: TestItem[];
-}
-
-class TestItem extends DyFM_Metadata {
-  name?: string;
-}
-
-describe('| DyFM_ListCollectorDataHandler', (): void => {
-  let handler: DyFM_ListCollectorDataHandler<TestCollector, TestItem>;
-  let settings: DyFM_ListCollectorDataHandler_Settings<TestCollector, TestItem>;
-
-  beforeEach(() => {
-    settings = {
-      name: 'TestCollectorHandler',
-      listKey: 'items',
-      get: async (loadBy?: string): Promise<TestCollector> => {
-        return {
-          _id: loadBy || 'default',
-          items: [
-            { _id: '1', name: 'item1' } as TestItem,
-            { _id: '2', name: 'item2' } as TestItem,
-          ],
-        } as TestCollector;
-      },
-      setItem: async (item: TestItem, collectorId?: string): Promise<TestItem> => item,
-      deleteItem: async (id: string, collectorId?: string): Promise<void> => {},
-      defaultValue: { _id: 'default', items: [] } as TestCollector,
-    };
-
-    handler = new DyFM_ListCollectorDataHandler<TestCollector, TestItem>(settings);
-  });
-
-  it('| should create an instance with settings', (): void => {
-    expect(handler).toBeTruthy();
-    expect(handler.name).toBe('TestCollectorHandler');
-  });
-
-  it('| should have dataList$ observable', (): void => {
-    expect(handler.dataList$).toBeTruthy();
-  });
-
-  it('| should have activeItem$ observable', (): void => {
-    expect(handler.activeItem$).toBeTruthy();
-  });
-
-  it('| should get empty dataList initially', (): void => {
-    expect(handler.dataList).toEqual([]);
-  });
-
-  it('| should set active item', (): void => {
-    const item = { _id: '1', name: 'item1' } as TestItem;
-    handler.setActiveItem(item);
-
-    handler.activeItem$.subscribe(activeItem => {
-      expect(activeItem).toEqual(item);
-    });
-  });
-
-  it('| should clear data and active item', (): void => {
-    handler.clear();
-
-    expect(handler.dataList).toEqual([]);
-    handler.activeItem$.subscribe(activeItem => {
-      expect(activeItem).toBeNull();
-    });
-  });
-
-  it('| should throw error when adding item without data', async (): Promise<void> => {
-    handler.clear();
-    const newItem = { _id: '3', name: 'item3' } as TestItem;
-
-    await expectAsync(handler.addItem(newItem)).toBeRejectedWith(jasmine.any(DyFM_Error));
-  });
-
-  it('| should throw error when removing item without data', async (): Promise<void> => {
-    // Test case for lines 204-212: removeItem throws error when list not found
-    handler.clear();
-    
-    await expectAsync(handler.removeItem('1')).toBeRejectedWith(jasmine.any(DyFM_Error));
-  });
-
-  it('| should remove item with deleteItem', async (): Promise<void> => {
-    // Test case for lines 213-226: removeItem with deleteItem
-    // Use updateData to bypass the problematic post-process that expects an array
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    const deleteItemSpy = spyOn(handler as any, 'deleteItem').and.returnValue(Promise.resolve());
-    
-    await handler.removeItem('1');
-    
-    expect(deleteItemSpy).toHaveBeenCalledWith('1', undefined);
-    expect(handler.dataList.find(i => i._id === '1')).toBeUndefined();
-  });
-
-  it('| should remove item without deleteItem', async (): Promise<void> => {
-    // Test case for lines 213-226: removeItem without deleteItem
-    settings.deleteItem = undefined;
-    handler = new DyFM_ListCollectorDataHandler<TestCollector, TestItem>(settings);
-    // Use updateData to bypass the problematic post-process that expects an array
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    
-    await handler.removeItem('1');
-    
-    expect(handler.dataList.find(i => i._id === '1')).toBeUndefined();
-  });
-
-  it('| should clear active item when removing active item', async (): Promise<void> => {
-    // Test case for lines 223-225: clear active item when removing
-    // Use updateData to bypass the problematic post-process that expects an array
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    handler.setActiveItem(handler.dataList[0]);
-    
-    await handler.removeItem(handler.dataList[0]._id);
-    
-    handler.activeItem$.subscribe(activeItem => {
-      expect(activeItem).toBeNull();
-    });
-  });
-
-  it('| should throw error when updating item without data', async (): Promise<void> => {
-    // Test case for lines 238-246: updateItem throws error when list not found
-    handler.clear();
-    const item = { _id: '1', name: 'item1' } as TestItem;
-    
-    await expectAsync(handler.updateItem(item)).toBeRejectedWith(jasmine.any(DyFM_Error));
-  });
-
-  it('| should update item with setItem', async (): Promise<void> => {
-    // Test case for lines 247-269: updateItem with setItem
-    // Use updateData to bypass the problematic post-process that expects an array
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    const setItemSpy = spyOn(handler as any, 'setItem').and.returnValue(Promise.resolve(handler.dataList[0]));
-    
-    const updatedItem = { _id: '1', name: 'updated' } as TestItem;
-    await handler.updateItem(updatedItem);
-    
-    expect(setItemSpy).toHaveBeenCalledWith(updatedItem, undefined);
-    expect(handler.dataList.find(i => i._id === '1')?.name).toBe('updated');
-  });
-
-  it('| should update item without setItem', async (): Promise<void> => {
-    // Test case for lines 247-269: updateItem without setItem
-    settings.setItem = undefined;
-    handler = new DyFM_ListCollectorDataHandler<TestCollector, TestItem>(settings);
-    // Use updateData to bypass the problematic post-process that expects an array
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    
-    const updatedItem = { _id: '1', name: 'updated' } as TestItem;
-    await handler.updateItem(updatedItem);
-    
-    expect(handler.dataList.find(i => i._id === '1')?.name).toBe('updated');
-  });
-
-  it('| should throw error when updating non-existent item', async (): Promise<void> => {
-    // Test case for lines 260-268: updateItem throws error when item not found
-    // Use updateData to bypass the problematic post-process that expects an array
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    const nonExistentItem = { _id: '999', name: 'not found' } as TestItem;
-    
-    await expectAsync(handler.updateItem(nonExistentItem)).toBeRejected();
-  });
-
-  it('| should addItem with setItem and dontSendUpdate false', async (): Promise<void> => {
-    // Test case for lines 173-193: addItem with setItem
-    await handler.updateData({
-      _id: 'test',
-      items: [],
-    } as TestCollector);
-    const setItemSpy = spyOn(handler as any, 'setItem').and.returnValue(Promise.resolve({ _id: '3', name: 'item3' }));
-    
-    const newItem = { _id: '3', name: 'item3' } as TestItem;
-    await handler.addItem(newItem, undefined, false);
-    
-    expect(setItemSpy).toHaveBeenCalled();
-    expect(handler.activeItem_BS.value).toEqual(newItem);
-  });
-
-  it('| should addItem with setItem and dontSendUpdate true', async (): Promise<void> => {
-    // Test case for lines 173-193: addItem with dontSendUpdate
-    // When dontSendUpdate is true, setItem should NOT be called (line 185: if (this.setItem && !dontSendUpdate))
-    await handler.updateData({
-      _id: 'test',
-      items: [],
-    } as TestCollector);
-    const setItemSpy = spyOn(handler as any, 'setItem').and.returnValue(Promise.resolve({ _id: '3', name: 'item3' }));
-    
-    const newItem = { _id: '3', name: 'item3' } as TestItem;
-    await handler.addItem(newItem, undefined, true);
-    
-    expect(setItemSpy).not.toHaveBeenCalled();
-    expect(handler.activeItem_BS.value).toEqual(newItem);
-  });
-
-  it('| should addItem without setItem', async (): Promise<void> => {
-    // Test case for lines 173-193: addItem without setItem
-    settings.setItem = undefined;
-    handler = new DyFM_ListCollectorDataHandler<TestCollector, TestItem>(settings);
-    await handler.updateData({
-      _id: 'test',
-      items: [],
-    } as TestCollector);
-    
-    const newItem = { _id: '3', name: 'item3' } as TestItem;
-    await handler.addItem(newItem);
-    
-    expect(handler.dataList.find(i => i._id === '3')).toBeDefined();
-  });
-
-  it('| should addItem with collectorId', async (): Promise<void> => {
-    // Test case for lines 173-193: addItem with collectorId
-    await handler.updateData({
-      _id: 'test',
-      items: [],
-    } as TestCollector);
-    const setItemSpy = spyOn(handler as any, 'setItem').and.returnValue(Promise.resolve({ _id: '3', name: 'item3' }));
-    
-    const newItem = { _id: '3', name: 'item3' } as TestItem;
-    await handler.addItem(newItem, 'collectorId');
-    
-    expect(setItemSpy).toHaveBeenCalledWith(newItem, 'collectorId');
-  });
-
-  it('| should addItem when listKey does not exist', async (): Promise<void> => {
-    // Test case for line 183: addItem when listKey does not exist
-    await handler.updateData({
-      _id: 'test',
-    } as TestCollector);
-    
-    const newItem = { _id: '3', name: 'item3' } as TestItem;
-    await handler.addItem(newItem);
-    
-    expect(handler.dataList.find(i => i._id === '3')).toBeDefined();
-  });
-
-  it('| should removeItem when item not found', async (): Promise<void> => {
-    // Test case for lines 203-226: removeItem when index === -1
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    
-    await handler.removeItem('999');
-    
-    // Should not throw, just do nothing
-    expect(handler.dataList.length).toBe(2);
-  });
-
-  it('| should removeItem with collectorId parameter', async (): Promise<void> => {
-    // Test case for lines 203-226: removeItem with collectorId
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    const deleteItemSpy = spyOn(handler as any, 'deleteItem').and.returnValue(Promise.resolve());
-    
-    await handler.removeItem('1', 'collectorId');
-    
-    expect(deleteItemSpy).toHaveBeenCalledWith('1', 'collectorId');
-  });
-
-  it('| should removeItem with dontSendUpdate', async (): Promise<void> => {
-    // Test case for lines 203-226: removeItem with dontSendUpdate
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    settings.deleteItem = undefined;
-    handler = new DyFM_ListCollectorDataHandler<TestCollector, TestItem>(settings);
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    
-    await handler.removeItem('1', undefined, true);
-    
-    expect(handler.dataList.find(i => i._id === '1')).toBeUndefined();
-  });
-
-  it('| should updateItem with collectorId parameter', async (): Promise<void> => {
-    // Test case for lines 237-269: updateItem with collectorId
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    const setItemSpy = spyOn(handler as any, 'setItem').and.returnValue(Promise.resolve(handler.dataList[0]));
-    
-    const updatedItem = { _id: '1', name: 'updated' } as TestItem;
-    await handler.updateItem(updatedItem, 'collectorId');
-    
-    expect(setItemSpy).toHaveBeenCalledWith(updatedItem, 'collectorId');
-  });
-
-  it('| should updateItem with dontSendUpdate', async (): Promise<void> => {
-    // Test case for lines 237-269: updateItem with dontSendUpdate
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    settings.setItem = undefined;
-    handler = new DyFM_ListCollectorDataHandler<TestCollector, TestItem>(settings);
-    await handler.updateData({
-      _id: 'test',
-      items: [
-        { _id: '1', name: 'item1' } as TestItem,
-        { _id: '2', name: 'item2' } as TestItem,
-      ],
-    } as TestCollector);
-    
-    const updatedItem = { _id: '1', name: 'updated' } as TestItem;
-    await handler.updateItem(updatedItem, undefined, true);
-    
-    expect(handler.dataList.find(i => i._id === '1')?.name).toBe('updated');
-  });
-});
-
+import { DyFM_ListCollectorDataHandler } from './list-collector-data-handler.control-model';
+import { DyFM_Metadata } from '../../../_models/data-models/metadata.data-model';
+import { DyFM_ListCollectorDataHandler_Settings } from './data-handler-settings.control-model';
+import { DyFM_Error } from '../../../_models/control-models/error.control-model';
+
+class TestCollector extends DyFM_Metadata {
+  items?: TestItem[];
+}
+
+class TestItem extends DyFM_Metadata {
+  name?: string;
+}
+
+describe('| DyFM_ListCollectorDataHandler', (): void => {
+  let handler: DyFM_ListCollectorDataHandler<TestCollector, TestItem>;
+  let settings: DyFM_ListCollectorDataHandler_Settings<TestCollector, TestItem>;
+
+  beforeEach(() => {
+    settings = {
+      name: 'TestCollectorHandler',
+      listKey: 'items',
+      get: async (loadBy?: string): Promise<TestCollector> => {
+        return {
+          _id: loadBy || 'default',
+          items: [
+            { _id: '1', name: 'item1' } as TestItem,
+            { _id: '2', name: 'item2' } as TestItem,
+          ],
+        } as TestCollector;
+      },
+      setItem: async (item: TestItem, collectorId?: string): Promise<TestItem> => item,
+      deleteItem: async (id: string, collectorId?: string): Promise<void> => {},
+      defaultValue: { _id: 'default', items: [] } as TestCollector,
+    };
+
+    handler = new DyFM_ListCollectorDataHandler<TestCollector, TestItem>(settings);
+  });
+
+  it('| should create an instance with settings', (): void => {
+    expect(handler).toBeTruthy();
+    expect(handler.name).toBe('TestCollectorHandler');
+  });
+
+  it('| should have dataList$ observable', (): void => {
+    expect(handler.dataList$).toBeTruthy();
+  });
+
+  it('| should have activeItem$ observable', (): void => {
+    expect(handler.activeItem$).toBeTruthy();
+  });
+
+  it('| should get empty dataList initially', (): void => {
+    expect(handler.dataList).toEqual([]);
+  });
+
+  it('| should set active item', (): void => {
+    const item = { _id: '1', name: 'item1' } as TestItem;
+    handler.setActiveItem(item);
+
+    handler.activeItem$.subscribe(activeItem => {
+      expect(activeItem).toEqual(item);
+    });
+  });
+
+  it('| should clear data and active item', (): void => {
+    handler.clear();
+
+    expect(handler.dataList).toEqual([]);
+    handler.activeItem$.subscribe(activeItem => {
+      expect(activeItem).toBeNull();
+    });
+  });
+
+  it('| should throw error when adding item without data', async (): Promise<void> => {
+    handler.clear();
+    const newItem = { _id: '3', name: 'item3' } as TestItem;
+
+    await expectAsync(handler.addItem(newItem)).toBeRejectedWith(jasmine.any(DyFM_Error));
+  });
+
+  it('| should throw error when removing item without data', async (): Promise<void> => {
+    // Test case for lines 204-212: removeItem throws error when list not found
+    handler.clear();
+    
+    await expectAsync(handler.removeItem('1')).toBeRejectedWith(jasmine.any(DyFM_Error));
+  });
+
+  it('| should remove item with deleteItem', async (): Promise<void> => {
+    // Test case for lines 213-226: removeItem with deleteItem
+    // Use updateData to bypass the problematic post-process that expects an array
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    const deleteItemSpy = spyOn(handler as any, 'deleteItem').and.returnValue(Promise.resolve());
+    
+    await handler.removeItem('1');
+    
+    expect(deleteItemSpy).toHaveBeenCalledWith('1', undefined);
+    expect(handler.dataList.find(i => i._id === '1')).toBeUndefined();
+  });
+
+  it('| should remove item without deleteItem', async (): Promise<void> => {
+    // Test case for lines 213-226: removeItem without deleteItem
+    settings.deleteItem = undefined;
+    handler = new DyFM_ListCollectorDataHandler<TestCollector, TestItem>(settings);
+    // Use updateData to bypass the problematic post-process that expects an array
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    
+    await handler.removeItem('1');
+    
+    expect(handler.dataList.find(i => i._id === '1')).toBeUndefined();
+  });
+
+  it('| should clear active item when removing active item', async (): Promise<void> => {
+    // Test case for lines 223-225: clear active item when removing
+    // Use updateData to bypass the problematic post-process that expects an array
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    handler.setActiveItem(handler.dataList[0]);
+    
+    await handler.removeItem(handler.dataList[0]._id);
+    
+    handler.activeItem$.subscribe(activeItem => {
+      expect(activeItem).toBeNull();
+    });
+  });
+
+  it('| should throw error when updating item without data', async (): Promise<void> => {
+    // Test case for lines 238-246: updateItem throws error when list not found
+    handler.clear();
+    const item = { _id: '1', name: 'item1' } as TestItem;
+    
+    await expectAsync(handler.updateItem(item)).toBeRejectedWith(jasmine.any(DyFM_Error));
+  });
+
+  it('| should update item with setItem', async (): Promise<void> => {
+    // Test case for lines 247-269: updateItem with setItem
+    // Use updateData to bypass the problematic post-process that expects an array
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    const setItemSpy = spyOn(handler as any, 'setItem').and.returnValue(Promise.resolve(handler.dataList[0]));
+    
+    const updatedItem = { _id: '1', name: 'updated' } as TestItem;
+    await handler.updateItem(updatedItem);
+    
+    expect(setItemSpy).toHaveBeenCalledWith(updatedItem, undefined);
+    expect(handler.dataList.find(i => i._id === '1')?.name).toBe('updated');
+  });
+
+  it('| should update item without setItem', async (): Promise<void> => {
+    // Test case for lines 247-269: updateItem without setItem
+    settings.setItem = undefined;
+    handler = new DyFM_ListCollectorDataHandler<TestCollector, TestItem>(settings);
+    // Use updateData to bypass the problematic post-process that expects an array
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    
+    const updatedItem = { _id: '1', name: 'updated' } as TestItem;
+    await handler.updateItem(updatedItem);
+    
+    expect(handler.dataList.find(i => i._id === '1')?.name).toBe('updated');
+  });
+
+  it('| should throw error when updating non-existent item', async (): Promise<void> => {
+    // Test case for lines 260-268: updateItem throws error when item not found
+    // Use updateData to bypass the problematic post-process that expects an array
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    const nonExistentItem = { _id: '999', name: 'not found' } as TestItem;
+    
+    await expectAsync(handler.updateItem(nonExistentItem)).toBeRejected();
+  });
+
+  it('| should addItem with setItem and dontSendUpdate false', async (): Promise<void> => {
+    // Test case for lines 173-193: addItem with setItem
+    await handler.updateData({
+      _id: 'test',
+      items: [],
+    } as TestCollector);
+    const setItemSpy = spyOn(handler as any, 'setItem').and.returnValue(Promise.resolve({ _id: '3', name: 'item3' }));
+    
+    const newItem = { _id: '3', name: 'item3' } as TestItem;
+    await handler.addItem(newItem, undefined, false);
+    
+    expect(setItemSpy).toHaveBeenCalled();
+    expect(handler.activeItem_BS.value).toEqual(newItem);
+  });
+
+  it('| should addItem with setItem and dontSendUpdate true', async (): Promise<void> => {
+    // Test case for lines 173-193: addItem with dontSendUpdate
+    // When dontSendUpdate is true, setItem should NOT be called (line 185: if (this.setItem && !dontSendUpdate))
+    await handler.updateData({
+      _id: 'test',
+      items: [],
+    } as TestCollector);
+    const setItemSpy = spyOn(handler as any, 'setItem').and.returnValue(Promise.resolve({ _id: '3', name: 'item3' }));
+    
+    const newItem = { _id: '3', name: 'item3' } as TestItem;
+    await handler.addItem(newItem, undefined, true);
+    
+    expect(setItemSpy).not.toHaveBeenCalled();
+    expect(handler.activeItem_BS.value).toEqual(newItem);
+  });
+
+  it('| should addItem without setItem', async (): Promise<void> => {
+    // Test case for lines 173-193: addItem without setItem
+    settings.setItem = undefined;
+    handler = new DyFM_ListCollectorDataHandler<TestCollector, TestItem>(settings);
+    await handler.updateData({
+      _id: 'test',
+      items: [],
+    } as TestCollector);
+    
+    const newItem = { _id: '3', name: 'item3' } as TestItem;
+    await handler.addItem(newItem);
+    
+    expect(handler.dataList.find(i => i._id === '3')).toBeDefined();
+  });
+
+  it('| should addItem with collectorId', async (): Promise<void> => {
+    // Test case for lines 173-193: addItem with collectorId
+    await handler.updateData({
+      _id: 'test',
+      items: [],
+    } as TestCollector);
+    const setItemSpy = spyOn(handler as any, 'setItem').and.returnValue(Promise.resolve({ _id: '3', name: 'item3' }));
+    
+    const newItem = { _id: '3', name: 'item3' } as TestItem;
+    await handler.addItem(newItem, 'collectorId');
+    
+    expect(setItemSpy).toHaveBeenCalledWith(newItem, 'collectorId');
+  });
+
+  it('| should addItem when listKey does not exist', async (): Promise<void> => {
+    // Test case for line 183: addItem when listKey does not exist
+    await handler.updateData({
+      _id: 'test',
+    } as TestCollector);
+    
+    const newItem = { _id: '3', name: 'item3' } as TestItem;
+    await handler.addItem(newItem);
+    
+    expect(handler.dataList.find(i => i._id === '3')).toBeDefined();
+  });
+
+  it('| should removeItem when item not found', async (): Promise<void> => {
+    // Test case for lines 203-226: removeItem when index === -1
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    
+    await handler.removeItem('999');
+    
+    // Should not throw, just do nothing
+    expect(handler.dataList.length).toBe(2);
+  });
+
+  it('| should removeItem with collectorId parameter', async (): Promise<void> => {
+    // Test case for lines 203-226: removeItem with collectorId
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    const deleteItemSpy = spyOn(handler as any, 'deleteItem').and.returnValue(Promise.resolve());
+    
+    await handler.removeItem('1', 'collectorId');
+    
+    expect(deleteItemSpy).toHaveBeenCalledWith('1', 'collectorId');
+  });
+
+  it('| should removeItem with dontSendUpdate', async (): Promise<void> => {
+    // Test case for lines 203-226: removeItem with dontSendUpdate
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    settings.deleteItem = undefined;
+    handler = new DyFM_ListCollectorDataHandler<TestCollector, TestItem>(settings);
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    
+    await handler.removeItem('1', undefined, true);
+    
+    expect(handler.dataList.find(i => i._id === '1')).toBeUndefined();
+  });
+
+  it('| should updateItem with collectorId parameter', async (): Promise<void> => {
+    // Test case for lines 237-269: updateItem with collectorId
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    const setItemSpy = spyOn(handler as any, 'setItem').and.returnValue(Promise.resolve(handler.dataList[0]));
+    
+    const updatedItem = { _id: '1', name: 'updated' } as TestItem;
+    await handler.updateItem(updatedItem, 'collectorId');
+    
+    expect(setItemSpy).toHaveBeenCalledWith(updatedItem, 'collectorId');
+  });
+
+  it('| should updateItem with dontSendUpdate', async (): Promise<void> => {
+    // Test case for lines 237-269: updateItem with dontSendUpdate
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    settings.setItem = undefined;
+    handler = new DyFM_ListCollectorDataHandler<TestCollector, TestItem>(settings);
+    await handler.updateData({
+      _id: 'test',
+      items: [
+        { _id: '1', name: 'item1' } as TestItem,
+        { _id: '2', name: 'item2' } as TestItem,
+      ],
+    } as TestCollector);
+    
+    const updatedItem = { _id: '1', name: 'updated' } as TestItem;
+    await handler.updateItem(updatedItem, undefined, true);
+    
+    expect(handler.dataList.find(i => i._id === '1')?.name).toBe('updated');
+  });
+});
+