@futdevpro/fsm-dynamo 1.16.38 → 1.16.40

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

@@ -1,473 +1,473 @@
-import { DyFM_DataHandler } from './data-handler.control-model';
-import { DyFM_Metadata } from '../../../_models/data-models/metadata.data-model';
-import { DyFM_DataHandler_Settings } from './data-handler-settings.control-model';
-import { DyFM_Log } from '../../../_collections/utils/log.util';
-
-class TestMetadata extends DyFM_Metadata {
-  name?: string;
-}
-
-class TestDataHandler extends DyFM_DataHandler<TestMetadata> {
-  override get data(): TestMetadata {
-    return this.data_BS.value;
-  }
-}
-
-xdescribe('| DyFM_DataHandler', (): void => {
-  let handler: TestDataHandler;
-  let settings: DyFM_DataHandler_Settings<TestMetadata>;
-
-  beforeEach(() => {
-    settings = {
-      name: 'TestHandler',
-      get: async (loadBy?: string): Promise<TestMetadata> => {
-        return { _id: loadBy || 'default', name: 'test' } as TestMetadata;
-      },
-      set: async (data: TestMetadata): Promise<TestMetadata> => data,
-      defaultValue: { _id: 'default', name: 'default' } as TestMetadata,
-    };
-
-    handler = new TestDataHandler(settings);
-  });
-
-  it('| should create an instance with settings', (): void => {
-    expect(handler).toBeTruthy();
-    expect(handler.name).toBe('TestHandler');
-  });
-
-  it('| should have data$ observable', (): void => {
-    expect(handler.data$).toBeTruthy();
-  });
-
-  it('| should have loaded$ observable', (): void => {
-    expect(handler.loaded$).toBeTruthy();
-  });
-
-  it('| should have loadInProgress$ observable', (): void => {
-    expect(handler.loadInProgress$).toBeTruthy();
-  });
-
-  it('| should get default value initially', (): void => {
-    expect(handler.data).toEqual({ _id: 'default', name: 'default' });
-  });
-
-  it('| should update data', async (): Promise<void> => {
-    const newData = { _id: 'new', name: 'new' } as TestMetadata;
-    await handler.updateData(newData);
-
-    expect(handler.data).toEqual(newData);
-  });
-
-  it('| updateData default NEM triggereli a dependent-reload-t (backward-safe)', async (): Promise<void> => {
-    const dependentHandler = new TestDataHandler({
-      name: 'DependentHandler-noreload',
-      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
-      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
-    });
-    handler.addDependentDataHandlers([dependentHandler]);
-    const reloadSpy: jasmine.Spy = spyOn(dependentHandler, 'reloadData');
-
-    await handler.updateData({ _id: 'new', name: 'new' } as TestMetadata);
-
-    expect(reloadSpy).not.toHaveBeenCalled();
-  });
-
-  it('| updateData reloadDependents:true meghajtja a dependent-reload-láncot (BFR-MASTERPROMPTER-013)', async (): Promise<void> => {
-    const dependentHandler = new TestDataHandler({
-      name: 'DependentHandler-reload',
-      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
-      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
-    });
-    handler.addDependentDataHandlers([dependentHandler]);
-    const reloadSpy: jasmine.Spy = spyOn(dependentHandler, 'reloadData');
-
-    await handler.updateData({ _id: 'new-parent', name: 'new' } as TestMetadata, false, true);
-
-    expect(reloadSpy).toHaveBeenCalledWith('new-parent');
-  });
-
-  it('| should clear data', (): void => {
-    handler.clear();
-
-    expect(handler.data).toBeUndefined();
-    expect(handler.lastLoadedBy).toBeUndefined();
-  });
-
-  it('| should wait for load', async (): Promise<void> => {
-    const waitPromise = handler.waitForLoad();
-    
-    expect(waitPromise).toBeInstanceOf(Promise);
-  });
-
-  it('| should handle postProcess that returns null', async (): Promise<void> => {
-    // Test case for lines 429-434: postProcess returns null or undefined
-    const warnSpy = spyOn(DyFM_Log, 'warn');
-    settings.getPostProcess = async (data: TestMetadata) => null as any;
-    handler = new TestDataHandler(settings);
-    
-    await handler.reloadData('test');
-    
-    expect(warnSpy).toHaveBeenCalled();
-  });
-
-  it('| should handle postProcess that returns undefined', async (): Promise<void> => {
-    // Test case for lines 429-434: postProcess returns null or undefined
-    const warnSpy = spyOn(DyFM_Log, 'warn');
-    settings.getPostProcess = async (data: TestMetadata) => undefined as any;
-    handler = new TestDataHandler(settings);
-    
-    await handler.reloadData('test');
-    
-    expect(warnSpy).toHaveBeenCalled();
-  });
-
-  it('| should resolve waits on load', async (): Promise<void> => {
-    // Test case for line 444: resolveWaitsOnLoad
-    const waitPromise = handler.waitForLoad();
-    await handler.reloadData('test');
-    
-    await expectAsync(waitPromise).toBeResolved();
-  });
-
-  it('| should warn when name is not set', (): void => {
-    // Test case for lines 144-152: constructor without name
-    const warnSpy = spyOn(DyFM_Log, 'warn');
-    const settingsWithoutName = { ...settings };
-    delete settingsWithoutName.name;
-    
-    const handlerWithoutName = new TestDataHandler(settingsWithoutName);
-    
-    expect(handlerWithoutName.name).toContain('Unnamed DataHandler');
-    expect(warnSpy).toHaveBeenCalled();
-  });
-
-  it('| should handle constructor with debugLog', (): void => {
-    // Test case for line 155: debugLog
-    settings.debugLog = true;
-    const handlerWithDebug = new TestDataHandler(settings);
-    
-    expect(handlerWithDebug).toBeTruthy();
-  });
-
-  it('| should handle constructor with defaultLoadBy', (): void => {
-    // Test case for lines 177-179: defaultLoadBy
-    settings.defaultLoadBy = 'defaultId';
-    const handlerWithDefaultLoadBy = new TestDataHandler(settings);
-    
-    expect(handlerWithDefaultLoadBy.defaultLoadBy).toBe('defaultId');
-  });
-
-  it('| should handle constructor with skipDependencyConnections', (): void => {
-    // Test case for lines 181-189: skipDependencyConnections
-    const dependentHandler = new TestDataHandler({
-      name: 'DependentHandler',
-      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
-      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
-    });
-    
-    settings.dependentDataHandlers = [dependentHandler];
-    const handlerWithSkip = new TestDataHandler(settings, true);
-    
-    expect(handlerWithSkip).toBeTruthy();
-  });
-
-  it('| should add dependency data handler', (): void => {
-    // Test case for lines 196-221: addDependencyDataHandler
-    const dependentHandler = new TestDataHandler({
-      name: 'DependentHandler',
-      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
-      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
-    });
-    
-    handler.addDependencyDataHandler(dependentHandler);
-    
-    expect(handler).toBeTruthy();
-  });
-
-  it('| should handle addDependencyDataHandler with null', (): void => {
-    // Test case for lines 198-203: addDependencyDataHandler with null
-    const errorSpy = spyOn(console, 'error');
-    
-    handler.addDependencyDataHandler(null as any);
-    
-    expect(errorSpy).toHaveBeenCalled();
-  });
-
-  it('| should handle addDependencyDataHandler with invalid instance', (): void => {
-    // Test case for lines 205-210: addDependencyDataHandler with invalid instance
-    const errorSpy = spyOn(console, 'error');
-    
-    handler.addDependencyDataHandler({} as any);
-    
-    expect(errorSpy).toHaveBeenCalled();
-  });
-
-  xit('| should add dependent data handlers', (): void => {
-    // Test case for lines 223-290: addDependentDataHandlers
-    const dependentHandler = new TestDataHandler({
-      name: 'DependentHandler',
-      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
-      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
-    });
-    
-    handler.addDependentDataHandlers([dependentHandler]);
-    
-    expect(handler).toBeTruthy();
-  });
-
-  xit('| should throw error when adding null dependent handler', (): void => {
-    // Test case for lines 228-233: addDependentDataHandlers with null
-    expect(() => {
-      handler.addDependentDataHandlers([null as any]);
-    }).toThrow();
-  });
-
-  xit('| should throw error when adding invalid dependent handler', (): void => {
-    // Test case for lines 235-240: addDependentDataHandlers with invalid instance
-    expect(() => {
-      handler.addDependentDataHandlers([{} as any]);
-    }).toThrow();
-  });
-
-  xit('| should throw error when dependent handler has same name', (): void => {
-    // Test case for lines 242-247: addDependentDataHandlers with same name
-    const dependentHandler = new TestDataHandler({
-      name: 'TestHandler',
-      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
-      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
-    });
-    
-    expect(() => {
-      handler.addDependentDataHandlers([dependentHandler]);
-    }).toThrow();
-  });
-
-  xit('| should throw error when dependent handler not set up', (): void => {
-    // Test case for lines 249-256: addDependentDataHandlers with handler not set up
-    const dependentHandler = new TestDataHandler({
-      name: 'DependentHandler',
-      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
-      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
-    });
-    // Remove data_BS to simulate not set up
-    (dependentHandler as any).data_BS = undefined;
-    
-    expect(() => {
-      handler.addDependentDataHandlers([dependentHandler]);
-    }).toThrow();
-  });
-
-  xit('| should handle addDependentDataHandlers with debugLog', (): void => {
-    // Test case for lines 262-272: addDependentDataHandlers with debugLog
-    const consoleSpy = spyOn(console, 'log');
-    settings.debugLog = true;
-    handler = new TestDataHandler(settings);
-    
-    const dependentHandler = new TestDataHandler({
-      name: 'DependentHandler',
-      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
-      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
-    });
-    
-    handler.addDependentDataHandlers([dependentHandler]);
-    
-    // Trigger reload to test debug log
-    handler.reloadData('test').catch(() => {});
-    
-    expect(handler).toBeTruthy();
-  });
-
-  xit('| should handle addDependentDataHandlers with existing data', (): void => {
-    // Test case for lines 286-288: addDependentDataHandlers with existing data
-    handler.reloadData('test').catch(() => {});
-    
-    const dependentHandler = new TestDataHandler({
-      name: 'DependentHandler',
-      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
-      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
-    });
-    
-    const reloadSpy = spyOn(dependentHandler, 'reloadData');
-    handler.addDependentDataHandlers([dependentHandler], false);
-    
-    expect(reloadSpy).toHaveBeenCalled();
-  });
-
-  xit('| should handle reloadData with no loadBy and noId', async (): Promise<void> => {
-    // Test case for lines 299-315: reloadData without loadBy
-    settings.noId = true;
-    handler = new TestDataHandler(settings);
-    
-    const result = await handler.reloadData();
-    
-    expect(result).toBeDefined();
-  });
-
-  xit('| should throw error when reloadData missing ID', async (): Promise<void> => {
-    // Test case for lines 307-315: reloadData missing ID
-    settings.noId = false;
-    handler = new TestDataHandler(settings);
-    handler.clear();
-    
-    await expectAsync(handler.reloadData()).toBeRejected();
-  });
-
-  xit('| should return existing data when already loading same ID', async (): Promise<void> => {
-    // Test case for lines 317-327: reloadData already loading
-    const loadPromise = handler.reloadData('test');
-    const result = await handler.reloadData('test');
-    
-    await loadPromise;
-    
-    expect(result).toBeDefined();
-  });
-
-  xit('| should handle reloadData with debugLog', async (): Promise<void> => {
-    // Test case for lines 329-334: reloadData with debugLog
-    const consoleSpy = spyOn(console, 'log');
-    settings.debugLog = true;
-    handler = new TestDataHandler(settings);
-    
-    await handler.reloadData('test');
-    
-    expect(consoleSpy).toHaveBeenCalled();
-  });
-
-  it('| should handle reloadData error with handled flag', async (): Promise<void> => {
-    // Test case for lines 350-361: reloadData error with handled flag
-    const errorSpy = spyOn(console, 'error');
-    const handledError = {
-      error: {
-        handled: false,
-        flag: ['DYNAMO'],
-      },
-    };
-    settings.get = async () => {
-      throw handledError;
-    };
-    handler = new TestDataHandler(settings);
-    
-    try {
-      await handler.reloadData('test');
-    } catch (e) {
-      expect(handledError.error.handled).toBe(true);
-    }
-  });
-
-  it('| should getData when data exists', async (): Promise<void> => {
-    // Test case for lines 367-378: getData
-    await handler.reloadData('test');
-    
-    const result = await handler.getData();
-    
-    expect(result).toBeDefined();
-  });
-
-  it('| should getData when data does not exist and loading', async (): Promise<void> => {
-    // Test case for lines 368-374: getData when loading
-    handler.clear();
-    const loadPromise = handler.reloadData('test');
-    const result = await handler.getData();
-    
-    await loadPromise;
-    
-    expect(result).toBeDefined();
-  });
-
-  it('| should getData when data does not exist and not loading', async (): Promise<void> => {
-    // Test case for lines 372-374: getData when not loading
-    handler.clear();
-    // Set noId to true to allow reloadData without an ID
-    handler.noId = true;
-    
-    const result = await handler.getData();
-    
-    expect(result).toBeDefined();
-  });
-
-  it('| should updateData with set', async (): Promise<void> => {
-    // Test case for lines 391-397: updateData with set
-    const newData = { _id: 'new', name: 'new' } as TestMetadata;
-    await handler.updateData(newData);
-    
-    expect(handler.data).toEqual(newData);
-  });
-
-  it('| should updateData without set', async (): Promise<void> => {
-    // Test case for lines 391-397: updateData without set
-    settings.set = undefined;
-    handler = new TestDataHandler(settings);
-    
-    const newData = { _id: 'new', name: 'new' } as TestMetadata;
-    await handler.updateData(newData);
-    
-    expect(handler.data).toEqual(newData);
-  });
-
-  it('| should updateData with dontSendUpdate', async (): Promise<void> => {
-    // Test case for lines 391-397: updateData with dontSendUpdate
-    const setSpy = spyOn(settings, 'set');
-    const newData = { _id: 'new', name: 'new' } as TestMetadata;
-    await handler.updateData(newData, true);
-    
-    expect(setSpy).not.toHaveBeenCalled();
-  });
-
-  it('| should clear with dependents', (): void => {
-    // Test case for lines 399-407: clear with dependents
-    const dependentHandler = new TestDataHandler({
-      name: 'DependentHandler',
-      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
-      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
-    });
-    
-    // Add dependent handler - addDependentDataHandlers adds to the parameter array
-    // but clear uses this.dependentDataHandlers, so we need to add directly
-    (handler as any).dependentDataHandlers.push(dependentHandler);
-    
-    const clearSpy = spyOn(dependentHandler, 'clear');
-    
-    handler.clear();
-    
-    expect(clearSpy).toHaveBeenCalled();
-  });
-
-  it('| should clear without dependents', (): void => {
-    // Test case for lines 399-407: clear without dependents
-    handler.clear(true);
-    
-    expect(handler.data).toBeUndefined();
-  });
-
-  it('| should processLoadResult with debugLog', async (): Promise<void> => {
-    // Test case for lines 409-440: processLoadResult
-    const consoleSpy = spyOn(console, 'log');
-    settings.debugLog = true;
-    handler = new TestDataHandler(settings);
-    
-    await handler.reloadData('test');
-    
-    expect(consoleSpy).toHaveBeenCalled();
-  });
-
-  it('| should processLoadResult with multiple postProcesses', async (): Promise<void> => {
-    // Test case for lines 418-435: processLoadResult with multiple postProcesses
-    let callCount = 0;
-    settings.getPostProcess = async (data: TestMetadata) => {
-      callCount++;
-      return { ...data, name: `processed${callCount}` };
-    };
-    handler = new TestDataHandler(settings);
-    
-    // Add another post-process
-    (handler as any).getPostProcesses.push(async (data: TestMetadata) => {
-      callCount++;
-      return { ...data, name: `processed${callCount}` };
-    });
-    
-    await handler.reloadData('test');
-    
-    expect(callCount).toBeGreaterThan(0);
-  });
-});
-
+import { DyFM_DataHandler } from './data-handler.control-model';
+import { DyFM_Metadata } from '../../../_models/data-models/metadata.data-model';
+import { DyFM_DataHandler_Settings } from './data-handler-settings.control-model';
+import { DyFM_Log } from '../../../_collections/utils/log.util';
+
+class TestMetadata extends DyFM_Metadata {
+  name?: string;
+}
+
+class TestDataHandler extends DyFM_DataHandler<TestMetadata> {
+  override get data(): TestMetadata {
+    return this.data_BS.value;
+  }
+}
+
+xdescribe('| DyFM_DataHandler', (): void => {
+  let handler: TestDataHandler;
+  let settings: DyFM_DataHandler_Settings<TestMetadata>;
+
+  beforeEach(() => {
+    settings = {
+      name: 'TestHandler',
+      get: async (loadBy?: string): Promise<TestMetadata> => {
+        return { _id: loadBy || 'default', name: 'test' } as TestMetadata;
+      },
+      set: async (data: TestMetadata): Promise<TestMetadata> => data,
+      defaultValue: { _id: 'default', name: 'default' } as TestMetadata,
+    };
+
+    handler = new TestDataHandler(settings);
+  });
+
+  it('| should create an instance with settings', (): void => {
+    expect(handler).toBeTruthy();
+    expect(handler.name).toBe('TestHandler');
+  });
+
+  it('| should have data$ observable', (): void => {
+    expect(handler.data$).toBeTruthy();
+  });
+
+  it('| should have loaded$ observable', (): void => {
+    expect(handler.loaded$).toBeTruthy();
+  });
+
+  it('| should have loadInProgress$ observable', (): void => {
+    expect(handler.loadInProgress$).toBeTruthy();
+  });
+
+  it('| should get default value initially', (): void => {
+    expect(handler.data).toEqual({ _id: 'default', name: 'default' });
+  });
+
+  it('| should update data', async (): Promise<void> => {
+    const newData = { _id: 'new', name: 'new' } as TestMetadata;
+    await handler.updateData(newData);
+
+    expect(handler.data).toEqual(newData);
+  });
+
+  it('| updateData default NEM triggereli a dependent-reload-t (backward-safe)', async (): Promise<void> => {
+    const dependentHandler = new TestDataHandler({
+      name: 'DependentHandler-noreload',
+      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
+      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
+    });
+    handler.addDependentDataHandlers([dependentHandler]);
+    const reloadSpy: jasmine.Spy = spyOn(dependentHandler, 'reloadData');
+
+    await handler.updateData({ _id: 'new', name: 'new' } as TestMetadata);
+
+    expect(reloadSpy).not.toHaveBeenCalled();
+  });
+
+  it('| updateData reloadDependents:true meghajtja a dependent-reload-láncot (BFR-MASTERPROMPTER-013)', async (): Promise<void> => {
+    const dependentHandler = new TestDataHandler({
+      name: 'DependentHandler-reload',
+      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
+      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
+    });
+    handler.addDependentDataHandlers([dependentHandler]);
+    const reloadSpy: jasmine.Spy = spyOn(dependentHandler, 'reloadData');
+
+    await handler.updateData({ _id: 'new-parent', name: 'new' } as TestMetadata, false, true);
+
+    expect(reloadSpy).toHaveBeenCalledWith('new-parent');
+  });
+
+  it('| should clear data', (): void => {
+    handler.clear();
+
+    expect(handler.data).toBeUndefined();
+    expect(handler.lastLoadedBy).toBeUndefined();
+  });
+
+  it('| should wait for load', async (): Promise<void> => {
+    const waitPromise = handler.waitForLoad();
+    
+    expect(waitPromise).toBeInstanceOf(Promise);
+  });
+
+  it('| should handle postProcess that returns null', async (): Promise<void> => {
+    // Test case for lines 429-434: postProcess returns null or undefined
+    const warnSpy = spyOn(DyFM_Log, 'warn');
+    settings.getPostProcess = async (data: TestMetadata) => null as any;
+    handler = new TestDataHandler(settings);
+    
+    await handler.reloadData('test');
+    
+    expect(warnSpy).toHaveBeenCalled();
+  });
+
+  it('| should handle postProcess that returns undefined', async (): Promise<void> => {
+    // Test case for lines 429-434: postProcess returns null or undefined
+    const warnSpy = spyOn(DyFM_Log, 'warn');
+    settings.getPostProcess = async (data: TestMetadata) => undefined as any;
+    handler = new TestDataHandler(settings);
+    
+    await handler.reloadData('test');
+    
+    expect(warnSpy).toHaveBeenCalled();
+  });
+
+  it('| should resolve waits on load', async (): Promise<void> => {
+    // Test case for line 444: resolveWaitsOnLoad
+    const waitPromise = handler.waitForLoad();
+    await handler.reloadData('test');
+    
+    await expectAsync(waitPromise).toBeResolved();
+  });
+
+  it('| should warn when name is not set', (): void => {
+    // Test case for lines 144-152: constructor without name
+    const warnSpy = spyOn(DyFM_Log, 'warn');
+    const settingsWithoutName = { ...settings };
+    delete settingsWithoutName.name;
+    
+    const handlerWithoutName = new TestDataHandler(settingsWithoutName);
+    
+    expect(handlerWithoutName.name).toContain('Unnamed DataHandler');
+    expect(warnSpy).toHaveBeenCalled();
+  });
+
+  it('| should handle constructor with debugLog', (): void => {
+    // Test case for line 155: debugLog
+    settings.debugLog = true;
+    const handlerWithDebug = new TestDataHandler(settings);
+    
+    expect(handlerWithDebug).toBeTruthy();
+  });
+
+  it('| should handle constructor with defaultLoadBy', (): void => {
+    // Test case for lines 177-179: defaultLoadBy
+    settings.defaultLoadBy = 'defaultId';
+    const handlerWithDefaultLoadBy = new TestDataHandler(settings);
+    
+    expect(handlerWithDefaultLoadBy.defaultLoadBy).toBe('defaultId');
+  });
+
+  it('| should handle constructor with skipDependencyConnections', (): void => {
+    // Test case for lines 181-189: skipDependencyConnections
+    const dependentHandler = new TestDataHandler({
+      name: 'DependentHandler',
+      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
+      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
+    });
+    
+    settings.dependentDataHandlers = [dependentHandler];
+    const handlerWithSkip = new TestDataHandler(settings, true);
+    
+    expect(handlerWithSkip).toBeTruthy();
+  });
+
+  it('| should add dependency data handler', (): void => {
+    // Test case for lines 196-221: addDependencyDataHandler
+    const dependentHandler = new TestDataHandler({
+      name: 'DependentHandler',
+      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
+      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
+    });
+    
+    handler.addDependencyDataHandler(dependentHandler);
+    
+    expect(handler).toBeTruthy();
+  });
+
+  it('| should handle addDependencyDataHandler with null', (): void => {
+    // Test case for lines 198-203: addDependencyDataHandler with null
+    const errorSpy = spyOn(console, 'error');
+    
+    handler.addDependencyDataHandler(null as any);
+    
+    expect(errorSpy).toHaveBeenCalled();
+  });
+
+  it('| should handle addDependencyDataHandler with invalid instance', (): void => {
+    // Test case for lines 205-210: addDependencyDataHandler with invalid instance
+    const errorSpy = spyOn(console, 'error');
+    
+    handler.addDependencyDataHandler({} as any);
+    
+    expect(errorSpy).toHaveBeenCalled();
+  });
+
+  xit('| should add dependent data handlers', (): void => {
+    // Test case for lines 223-290: addDependentDataHandlers
+    const dependentHandler = new TestDataHandler({
+      name: 'DependentHandler',
+      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
+      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
+    });
+    
+    handler.addDependentDataHandlers([dependentHandler]);
+    
+    expect(handler).toBeTruthy();
+  });
+
+  xit('| should throw error when adding null dependent handler', (): void => {
+    // Test case for lines 228-233: addDependentDataHandlers with null
+    expect(() => {
+      handler.addDependentDataHandlers([null as any]);
+    }).toThrow();
+  });
+
+  xit('| should throw error when adding invalid dependent handler', (): void => {
+    // Test case for lines 235-240: addDependentDataHandlers with invalid instance
+    expect(() => {
+      handler.addDependentDataHandlers([{} as any]);
+    }).toThrow();
+  });
+
+  xit('| should throw error when dependent handler has same name', (): void => {
+    // Test case for lines 242-247: addDependentDataHandlers with same name
+    const dependentHandler = new TestDataHandler({
+      name: 'TestHandler',
+      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
+      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
+    });
+    
+    expect(() => {
+      handler.addDependentDataHandlers([dependentHandler]);
+    }).toThrow();
+  });
+
+  xit('| should throw error when dependent handler not set up', (): void => {
+    // Test case for lines 249-256: addDependentDataHandlers with handler not set up
+    const dependentHandler = new TestDataHandler({
+      name: 'DependentHandler',
+      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
+      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
+    });
+    // Remove data_BS to simulate not set up
+    (dependentHandler as any).data_BS = undefined;
+    
+    expect(() => {
+      handler.addDependentDataHandlers([dependentHandler]);
+    }).toThrow();
+  });
+
+  xit('| should handle addDependentDataHandlers with debugLog', (): void => {
+    // Test case for lines 262-272: addDependentDataHandlers with debugLog
+    const consoleSpy = spyOn(console, 'log');
+    settings.debugLog = true;
+    handler = new TestDataHandler(settings);
+    
+    const dependentHandler = new TestDataHandler({
+      name: 'DependentHandler',
+      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
+      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
+    });
+    
+    handler.addDependentDataHandlers([dependentHandler]);
+    
+    // Trigger reload to test debug log
+    handler.reloadData('test').catch(() => {});
+    
+    expect(handler).toBeTruthy();
+  });
+
+  xit('| should handle addDependentDataHandlers with existing data', (): void => {
+    // Test case for lines 286-288: addDependentDataHandlers with existing data
+    handler.reloadData('test').catch(() => {});
+    
+    const dependentHandler = new TestDataHandler({
+      name: 'DependentHandler',
+      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
+      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
+    });
+    
+    const reloadSpy = spyOn(dependentHandler, 'reloadData');
+    handler.addDependentDataHandlers([dependentHandler], false);
+    
+    expect(reloadSpy).toHaveBeenCalled();
+  });
+
+  xit('| should handle reloadData with no loadBy and noId', async (): Promise<void> => {
+    // Test case for lines 299-315: reloadData without loadBy
+    settings.noId = true;
+    handler = new TestDataHandler(settings);
+    
+    const result = await handler.reloadData();
+    
+    expect(result).toBeDefined();
+  });
+
+  xit('| should throw error when reloadData missing ID', async (): Promise<void> => {
+    // Test case for lines 307-315: reloadData missing ID
+    settings.noId = false;
+    handler = new TestDataHandler(settings);
+    handler.clear();
+    
+    await expectAsync(handler.reloadData()).toBeRejected();
+  });
+
+  xit('| should return existing data when already loading same ID', async (): Promise<void> => {
+    // Test case for lines 317-327: reloadData already loading
+    const loadPromise = handler.reloadData('test');
+    const result = await handler.reloadData('test');
+    
+    await loadPromise;
+    
+    expect(result).toBeDefined();
+  });
+
+  xit('| should handle reloadData with debugLog', async (): Promise<void> => {
+    // Test case for lines 329-334: reloadData with debugLog
+    const consoleSpy = spyOn(console, 'log');
+    settings.debugLog = true;
+    handler = new TestDataHandler(settings);
+    
+    await handler.reloadData('test');
+    
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  it('| should handle reloadData error with handled flag', async (): Promise<void> => {
+    // Test case for lines 350-361: reloadData error with handled flag
+    const errorSpy = spyOn(console, 'error');
+    const handledError = {
+      error: {
+        handled: false,
+        flag: ['DYNAMO'],
+      },
+    };
+    settings.get = async () => {
+      throw handledError;
+    };
+    handler = new TestDataHandler(settings);
+    
+    try {
+      await handler.reloadData('test');
+    } catch (e) {
+      expect(handledError.error.handled).toBe(true);
+    }
+  });
+
+  it('| should getData when data exists', async (): Promise<void> => {
+    // Test case for lines 367-378: getData
+    await handler.reloadData('test');
+    
+    const result = await handler.getData();
+    
+    expect(result).toBeDefined();
+  });
+
+  it('| should getData when data does not exist and loading', async (): Promise<void> => {
+    // Test case for lines 368-374: getData when loading
+    handler.clear();
+    const loadPromise = handler.reloadData('test');
+    const result = await handler.getData();
+    
+    await loadPromise;
+    
+    expect(result).toBeDefined();
+  });
+
+  it('| should getData when data does not exist and not loading', async (): Promise<void> => {
+    // Test case for lines 372-374: getData when not loading
+    handler.clear();
+    // Set noId to true to allow reloadData without an ID
+    handler.noId = true;
+    
+    const result = await handler.getData();
+    
+    expect(result).toBeDefined();
+  });
+
+  it('| should updateData with set', async (): Promise<void> => {
+    // Test case for lines 391-397: updateData with set
+    const newData = { _id: 'new', name: 'new' } as TestMetadata;
+    await handler.updateData(newData);
+    
+    expect(handler.data).toEqual(newData);
+  });
+
+  it('| should updateData without set', async (): Promise<void> => {
+    // Test case for lines 391-397: updateData without set
+    settings.set = undefined;
+    handler = new TestDataHandler(settings);
+    
+    const newData = { _id: 'new', name: 'new' } as TestMetadata;
+    await handler.updateData(newData);
+    
+    expect(handler.data).toEqual(newData);
+  });
+
+  it('| should updateData with dontSendUpdate', async (): Promise<void> => {
+    // Test case for lines 391-397: updateData with dontSendUpdate
+    const setSpy = spyOn(settings, 'set');
+    const newData = { _id: 'new', name: 'new' } as TestMetadata;
+    await handler.updateData(newData, true);
+    
+    expect(setSpy).not.toHaveBeenCalled();
+  });
+
+  it('| should clear with dependents', (): void => {
+    // Test case for lines 399-407: clear with dependents
+    const dependentHandler = new TestDataHandler({
+      name: 'DependentHandler',
+      get: async () => ({ _id: 'dep', name: 'dep' } as TestMetadata),
+      defaultValue: { _id: 'dep', name: 'dep' } as TestMetadata,
+    });
+    
+    // Add dependent handler - addDependentDataHandlers adds to the parameter array
+    // but clear uses this.dependentDataHandlers, so we need to add directly
+    (handler as any).dependentDataHandlers.push(dependentHandler);
+    
+    const clearSpy = spyOn(dependentHandler, 'clear');
+    
+    handler.clear();
+    
+    expect(clearSpy).toHaveBeenCalled();
+  });
+
+  it('| should clear without dependents', (): void => {
+    // Test case for lines 399-407: clear without dependents
+    handler.clear(true);
+    
+    expect(handler.data).toBeUndefined();
+  });
+
+  it('| should processLoadResult with debugLog', async (): Promise<void> => {
+    // Test case for lines 409-440: processLoadResult
+    const consoleSpy = spyOn(console, 'log');
+    settings.debugLog = true;
+    handler = new TestDataHandler(settings);
+    
+    await handler.reloadData('test');
+    
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  it('| should processLoadResult with multiple postProcesses', async (): Promise<void> => {
+    // Test case for lines 418-435: processLoadResult with multiple postProcesses
+    let callCount = 0;
+    settings.getPostProcess = async (data: TestMetadata) => {
+      callCount++;
+      return { ...data, name: `processed${callCount}` };
+    };
+    handler = new TestDataHandler(settings);
+    
+    // Add another post-process
+    (handler as any).getPostProcesses.push(async (data: TestMetadata) => {
+      callCount++;
+      return { ...data, name: `processed${callCount}` };
+    });
+    
+    await handler.reloadData('test');
+    
+    expect(callCount).toBeGreaterThan(0);
+  });
+});
+