@futdevpro/fsm-dynamo 1.15.8 → 1.15.10

package/src/_models/data-models/metadata.data-model.spec.ts

@@ -0,0 +1,184 @@
+import { DyFM_Metadata } from './metadata.data-model';
+
+describe('| DyFM_Metadata', (): void => {
+  it('| should create an instance without initial data', (): void => {
+    const instance = new DyFM_Metadata();
+    expect(instance).toBeTruthy();
+    expect(instance.__created).toBeInstanceOf(Date);
+    expect(instance.__lastModified).toBeInstanceOf(Date);
+    expect(instance.__v).toBe(0);
+  });
+
+  it('| should create an instance with initial data', (): void => {
+    const initialData: DyFM_Metadata = {
+      _id: 'test-id',
+      __created: new Date('2023-01-01'),
+      __createdBy: 'user1',
+      __lastModified: new Date('2023-01-02'),
+      __lastModifiedBy: 'user2',
+      __v: 1
+    };
+    const instance = new DyFM_Metadata(initialData);
+
+    expect(instance._id).toBe('test-id');
+    expect(instance.__created).toEqual(new Date('2023-01-01'));
+    expect(instance.__createdBy).toBe('user1');
+    expect(instance.__lastModified).toEqual(new Date('2023-01-02'));
+    expect(instance.__lastModifiedBy).toBe('user2');
+    expect(instance.__v).toBe(1);
+  });
+
+  it('| should set default values when not provided', (): void => {
+    const instance = new DyFM_Metadata({});
+
+    expect(instance.__created).toBeInstanceOf(Date);
+    expect(instance.__lastModified).toBeInstanceOf(Date);
+    expect(instance.__v).toBe(0);
+  });
+
+  it('| should handle init parameter with id and issuer', (): void => {
+    const instance = new DyFM_Metadata(undefined, {
+      id: 'init-id',
+      issuer: 'init-user'
+    });
+
+    expect(instance._id).toBe('init-id');
+    expect(instance.__createdBy).toBe('init-user');
+    expect(instance.__lastModifiedBy).toBe('init-user');
+  });
+
+  it('| should not override existing _id with init id', (): void => {
+    const instance = new DyFM_Metadata(
+      { _id: 'existing-id' },
+      { id: 'init-id', issuer: 'user' }
+    );
+
+    expect(instance._id).toBe('existing-id');
+  });
+
+  it('| should not override existing __createdBy with init issuer', (): void => {
+    const instance = new DyFM_Metadata(
+      { __createdBy: 'existing-user' },
+      { issuer: 'init-user' }
+    );
+
+    expect(instance.__createdBy).toBe('existing-user');
+  });
+
+  it('| should handle archived data', (): void => {
+    const archivedDate = new Date('2023-01-01');
+    const instance = new DyFM_Metadata({
+      _archived: archivedDate,
+      _originalId: 'original-id'
+    });
+
+    expect(instance._archived).toEqual(archivedDate);
+    expect(instance._originalId).toBe('original-id');
+  });
+
+  it('| should handle deleted data', (): void => {
+    const deletedDate = new Date('2023-01-01');
+    const instance = new DyFM_Metadata({
+      _deleted: deletedDate,
+      _deletedBy: 'deleter'
+    } as any);
+    instance._deleted = deletedDate;
+    instance._deletedBy = 'deleter';
+
+    expect(instance._deleted).toEqual(deletedDate);
+    expect(instance._deletedBy).toBe('deleter');
+  });
+
+  it('| should set _id to undefined when _id is falsy but not undefined', (): void => {
+    // Test case for line 40-42: if (!set._id && set._id !== undefined)
+    // This happens when _id is null, empty string, 0, false, etc.
+    const instance1 = new DyFM_Metadata({ _id: null as any });
+    expect(instance1._id).toBeUndefined();
+
+    const instance2 = new DyFM_Metadata({ _id: '' as any });
+    expect(instance2._id).toBeUndefined();
+
+    const instance3 = new DyFM_Metadata({ _id: 0 as any });
+    expect(instance3._id).toBeUndefined();
+  });
+
+  describe('| updateMetadata', (): void => {
+    it('| should update metadata correctly', (): void => {
+      const data = new DyFM_Metadata();
+      const updated = DyFM_Metadata.updateMetadata!(data, 'updater', 'new-id');
+
+      expect(updated._id).toBe('new-id');
+      expect(updated.__createdBy).toBe('updater');
+      expect(updated.__lastModifiedBy).toBe('updater');
+      expect(updated.__lastModified).toBeInstanceOf(Date);
+      expect(updated.__v).toBe(1);
+    });
+
+    it('| should increment version on update', (): void => {
+      const data = new DyFM_Metadata({ __v: 5 });
+      const updated = DyFM_Metadata.updateMetadata!(data, 'updater');
+
+      expect(updated.__v).toBe(6);
+    });
+
+    it('| should set version to 1 if not present', (): void => {
+      const data = new DyFM_Metadata({ __v: undefined });
+      const updated = DyFM_Metadata.updateMetadata!(data, 'updater');
+
+      expect(updated.__v).toBe(1);
+    });
+
+    it('| should not override existing _id if id not provided', (): void => {
+      const data = new DyFM_Metadata({ _id: 'existing-id' });
+      const updated = DyFM_Metadata.updateMetadata!(data, 'updater');
+
+      expect(updated._id).toBe('existing-id');
+    });
+
+    it('| should set _id if not present and id provided', (): void => {
+      const data = new DyFM_Metadata({ _id: undefined });
+      const updated = DyFM_Metadata.updateMetadata!(data, 'updater', 'new-id');
+
+      expect(updated._id).toBe('new-id');
+    });
+
+    it('| should throw error when updating deleted data', (): void => {
+      const data = new DyFM_Metadata({ _deleted: new Date() } as any);
+      data._deleted = new Date();
+
+      expect(() => {
+        DyFM_Metadata.updateMetadata!(data, 'updater');
+      }).toThrowError('Cannot update metadata of deleted data');
+    });
+
+    it('| should return data as-is if data is null', (): void => {
+      const result = DyFM_Metadata.updateMetadata!(null as any, 'updater');
+
+      expect(result).toBeNull();
+    });
+
+    it('| should set __created if not present', (): void => {
+      const data = new DyFM_Metadata({ __created: undefined });
+      const updated = DyFM_Metadata.updateMetadata!(data, 'updater');
+
+      expect(updated.__created).toBeInstanceOf(Date);
+    });
+
+    it('| should set __createdBy if not present', (): void => {
+      const data = new DyFM_Metadata({ __createdBy: undefined });
+      const updated = DyFM_Metadata.updateMetadata!(data, 'updater');
+
+      expect(updated.__createdBy).toBe('updater');
+    });
+
+    it('| should set __created if not present (branch coverage)', (): void => {
+      // Test case for line 114-116: if (!data.__created)
+      const data = new DyFM_Metadata();
+      data.__created = undefined as any;
+      const updated = DyFM_Metadata.updateMetadata!(data, 'updater');
+
+      expect(updated.__created).toBeInstanceOf(Date);
+    });
+  });
+});
+

package/src/_modules/ai/_modules/anthropic/_models/aai-call-settings.control-model.spec.ts

@@ -0,0 +1,28 @@
+import { DyFM_AAI_CallSettings } from './aai-call-settings.control-model';
+import { DyFM_AAI_Model } from '../_enums/aai-model.enum';
+
+describe('| DyFM_AAI_CallSettings', (): void => {
+  it('| should create an instance with default model', (): void => {
+    const settings = new DyFM_AAI_CallSettings();
+
+    expect(settings).toBeTruthy();
+    expect(settings.useModel).toBe(DyFM_AAI_Model.claude_3_5_sonnet_latest);
+  });
+
+  it('| should create an instance with custom model', (): void => {
+    const settings = new DyFM_AAI_CallSettings({
+      useModel: DyFM_AAI_Model.claude_3_5_sonnet_latest,
+    });
+
+    expect(settings.useModel).toBe(DyFM_AAI_Model.claude_3_5_sonnet_latest);
+  });
+
+  it('| should create an instance with string model', (): void => {
+    const settings = new DyFM_AAI_CallSettings({
+      useModel: 'custom-model',
+    });
+
+    expect(settings.useModel).toBe('custom-model');
+  });
+});
+

package/src/_modules/ai/_modules/anthropic/_models/aai-settings.control-model.spec.ts

@@ -0,0 +1,22 @@
+import { DyFM_AAI_Settings } from './aai-settings.control-model';
+import { DyFM_AI_Provider } from '../../../_enums/ai-provider.enum';
+
+describe('| DyFM_AAI_Settings', (): void => {
+  it('| should create an instance with default values', (): void => {
+    const settings = new DyFM_AAI_Settings();
+
+    expect(settings).toBeTruthy();
+    expect(settings.provider).toBe(DyFM_AI_Provider.Anthropic);
+    expect(settings.defaultSettings).toBeTruthy();
+    expect(settings.config).toBeTruthy();
+  });
+
+  it('| should create an instance with custom values', (): void => {
+    const settings = new DyFM_AAI_Settings({
+      provider: DyFM_AI_Provider.Anthropic,
+    });
+
+    expect(settings.provider).toBe(DyFM_AI_Provider.Anthropic);
+  });
+});
+

package/src/_modules/ai/_modules/google-ai/_models/gai-call-settings.control-model.spec.ts

@@ -0,0 +1,28 @@
+import { DyFM_GAI_CallSettings } from './gai-call-settings.control-model';
+import { DyFM_GAI_Model } from '../_enums/gai-model.enum';
+
+describe('| DyFM_GAI_CallSettings', (): void => {
+  it('| should create an instance with default model', (): void => {
+    const settings = new DyFM_GAI_CallSettings();
+
+    expect(settings).toBeTruthy();
+    expect(settings.useModel).toBe(DyFM_GAI_Model.gemini_1_5_pro_latest);
+  });
+
+  it('| should create an instance with custom model', (): void => {
+    const settings = new DyFM_GAI_CallSettings({
+      useModel: DyFM_GAI_Model.gemini_1_5_pro_latest,
+    });
+
+    expect(settings.useModel).toBe(DyFM_GAI_Model.gemini_1_5_pro_latest);
+  });
+
+  it('| should create an instance with string model', (): void => {
+    const settings = new DyFM_GAI_CallSettings({
+      useModel: 'custom-model',
+    });
+
+    expect(settings.useModel).toBe('custom-model');
+  });
+});
+

package/src/_modules/ai/_modules/google-ai/_models/gai-settings.control-model.spec.ts

@@ -0,0 +1,22 @@
+import { DyFM_GAI_Settings } from './gai-settings.control-model';
+import { DyFM_AI_Provider } from '../../../_enums/ai-provider.enum';
+
+describe('| DyFM_GAI_Settings', (): void => {
+  it('| should create an instance with default values', (): void => {
+    const settings = new DyFM_GAI_Settings();
+
+    expect(settings).toBeTruthy();
+    expect(settings.provider).toBe(DyFM_AI_Provider.Google);
+    expect(settings.defaultSettings).toBeTruthy();
+    expect(settings.config).toBeTruthy();
+  });
+
+  it('| should create an instance with custom values', (): void => {
+    const settings = new DyFM_GAI_Settings({
+      provider: DyFM_AI_Provider.Google,
+    });
+
+    expect(settings.provider).toBe(DyFM_AI_Provider.Google);
+  });
+});
+

package/src/_modules/ai/_modules/local-ai/_models/lai-call-settings.control-model.spec.ts

@@ -0,0 +1,28 @@
+import { DyFM_LAI_CallSettings } from './lai-call-settings.control-model';
+import { DyFM_LAI_Model } from '../_enums/lai-model.enum';
+
+describe('| DyFM_LAI_CallSettings', (): void => {
+  it('| should create an instance with default model', (): void => {
+    const settings = new DyFM_LAI_CallSettings();
+
+    expect(settings).toBeTruthy();
+    expect(settings.useModel).toBe(DyFM_LAI_Model.generic_llm);
+  });
+
+  it('| should create an instance with custom model', (): void => {
+    const settings = new DyFM_LAI_CallSettings({
+      useModel: DyFM_LAI_Model.generic_llm,
+    });
+
+    expect(settings.useModel).toBe(DyFM_LAI_Model.generic_llm);
+  });
+
+  it('| should create an instance with string model', (): void => {
+    const settings = new DyFM_LAI_CallSettings({
+      useModel: 'custom-model',
+    });
+
+    expect(settings.useModel).toBe('custom-model');
+  });
+});
+

package/src/_modules/ai/_modules/local-ai/_models/lai-settings.control-model.spec.ts

@@ -0,0 +1,22 @@
+import { DyFM_LAI_Settings } from './lai-settings.control-model';
+import { DyFM_AI_Provider } from '../../../_enums/ai-provider.enum';
+
+describe('| DyFM_LAI_Settings', (): void => {
+  it('| should create an instance with default values', (): void => {
+    const settings = new DyFM_LAI_Settings();
+
+    expect(settings).toBeTruthy();
+    expect(settings.provider).toBe(DyFM_AI_Provider.LocalAI);
+    expect(settings.defaultSettings).toBeTruthy();
+    expect(settings.config).toBeTruthy();
+  });
+
+  it('| should create an instance with custom values', (): void => {
+    const settings = new DyFM_LAI_Settings({
+      provider: DyFM_AI_Provider.LocalAI,
+    });
+
+    expect(settings.provider).toBe(DyFM_AI_Provider.LocalAI);
+  });
+});
+

package/src/_modules/ai/_modules/open-ai/_models/oai-call-settings.control-model.spec.ts

@@ -0,0 +1,28 @@
+import { DyFM_OAI_CallSettings } from './oai-call-settings.control-model';
+import { DyFM_OAI_Model } from '../_enums/oai-model.enum';
+
+describe('| DyFM_OAI_CallSettings', (): void => {
+  it('| should create an instance with default model', (): void => {
+    const settings = new DyFM_OAI_CallSettings();
+
+    expect(settings).toBeTruthy();
+    expect(settings.useModel).toBe(DyFM_OAI_Model.gpt4o);
+  });
+
+  it('| should create an instance with custom model', (): void => {
+    const settings = new DyFM_OAI_CallSettings({
+      useModel: DyFM_OAI_Model.gpt4o,
+    });
+
+    expect(settings.useModel).toBe(DyFM_OAI_Model.gpt4o);
+  });
+
+  it('| should create an instance with string model', (): void => {
+    const settings = new DyFM_OAI_CallSettings({
+      useModel: 'custom-model',
+    });
+
+    expect(settings.useModel).toBe('custom-model');
+  });
+});
+

package/src/_modules/ai/_modules/open-ai/_models/oai-settings.control-model.spec.ts

@@ -0,0 +1,22 @@
+import { DyFM_OAI_Settings } from './oai-settings.control-model';
+import { DyFM_AI_Provider } from '../../../_enums/ai-provider.enum';
+
+describe('| DyFM_OAI_Settings', (): void => {
+  it('| should create an instance with default values', (): void => {
+    const settings = new DyFM_OAI_Settings();
+
+    expect(settings).toBeTruthy();
+    expect(settings.provider).toBe(DyFM_AI_Provider.OpenAI);
+    expect(settings.defaultSettings).toBeTruthy();
+    expect(settings.config).toBeTruthy();
+  });
+
+  it('| should create an instance with custom values', (): void => {
+    const settings = new DyFM_OAI_Settings({
+      provider: DyFM_AI_Provider.OpenAI,
+    });
+
+    expect(settings.provider).toBe(DyFM_AI_Provider.OpenAI);
+  });
+});
+

package/src/_modules/ci-tools/_models/cit-ci-result-info.data-models.spec.ts

@@ -0,0 +1,58 @@
+import { DyFM_CIT_CIResultInfo } from './cit-ci-result-info.data-models';
+import { DyFM_CIT_CIResultCode } from '../_enums/cit-ci-result-code.enum';
+import { DyFM_CIT_CIStepResultCode } from '../_enums/cit-ci-step-result-code.enum';
+import { DyFM_CIT_CIStepResult } from './cit-ci-step-result.interface';
+
+describe('| DyFM_CIT_CIResultInfo', (): void => {
+  it('| should create an instance without initial data', (): void => {
+    const resultInfo = new DyFM_CIT_CIResultInfo();
+
+    expect(resultInfo).toBeTruthy();
+    expect(resultInfo.__created).toBeInstanceOf(Date);
+    expect(resultInfo.__lastModified).toBeInstanceOf(Date);
+    expect(resultInfo.stepResults).toEqual([]);
+  });
+
+  it('| should create an instance with initial data', (): void => {
+    const stepResults: DyFM_CIT_CIStepResult[] = [
+      { stepName: 'build', resultCode: DyFM_CIT_CIStepResultCode.success, duration: 100 },
+      { stepName: 'test', resultCode: DyFM_CIT_CIStepResultCode.success, duration: 200 },
+    ];
+
+    const initialData: DyFM_CIT_CIResultInfo = {
+      project: 'myProject',
+      system: 'mySystem',
+      version: '1.0.0',
+      environment: 'development',
+      branch: 'main',
+      result: DyFM_CIT_CIResultCode.success,
+      stepResults: stepResults,
+      linkToAction: 'https://example.com',
+      duration: '10 seconds',
+      error: 'Error message',
+      errorDetails: { error: 'Error object' },
+    };
+
+    const resultInfo = new DyFM_CIT_CIResultInfo(initialData);
+
+    expect(resultInfo.project).toBe('myProject');
+    expect(resultInfo.system).toBe('mySystem');
+    expect(resultInfo.version).toBe('1.0.0');
+    expect(resultInfo.environment).toBe('development');
+    expect(resultInfo.branch).toBe('main');
+    expect(resultInfo.result).toBe(DyFM_CIT_CIResultCode.success);
+    expect(resultInfo.stepResults).toEqual(stepResults);
+    expect(resultInfo.linkToAction).toBe('https://example.com');
+    expect(resultInfo.duration).toBe('10 seconds');
+    expect(resultInfo.error).toBe('Error message');
+    expect(resultInfo.errorDetails).toEqual({ error: 'Error object' });
+  });
+
+  it('| should have dataParams defined', (): void => {
+    const { DyFM_CIT_ciResultInfo_dataParams } = require('./cit-ci-result-info.data-models');
+
+    expect(DyFM_CIT_ciResultInfo_dataParams).toBeTruthy();
+    expect(DyFM_CIT_ciResultInfo_dataParams.dataName).toBe('ci_result_info');
+  });
+});
+

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

@@ -0,0 +1,110 @@
+import { DyFM_DataHandler_Settings, DyFM_DataListHandler_Settings, DyFM_DataSearchHandler_Settings, DyFM_ListCollectorDataHandler_Settings } from './data-handler-settings.control-model';
+import { DyFM_Metadata } from '../../../_models/data-models/metadata.data-model';
+import { DyFM_SearchQuery } from '../../../_models/interfaces/search-query.interface';
+
+class TestMetadata extends DyFM_Metadata {
+  name?: string;
+}
+
+describe('| DyFM_DataHandler_Settings', (): void => {
+  it('| should create an instance with minimal settings', (): void => {
+    const settings = new DyFM_DataHandler_Settings<TestMetadata>();
+    Object.assign(settings, {
+      name: 'TestHandler',
+    });
+
+    expect(settings.name).toBe('TestHandler');
+  });
+
+  it('| should create an instance with all settings', (): void => {
+    const getFn = async (): Promise<TestMetadata> => ({ _id: 'test' } as TestMetadata);
+    const setFn = async (data: TestMetadata): Promise<TestMetadata> => data;
+    const postProcess = async (data: any): Promise<any> => data;
+
+    const settings = new DyFM_DataHandler_Settings<TestMetadata>();
+    Object.assign(settings, {
+      name: 'TestHandler',
+      get: getFn,
+      set: setFn,
+      getPostProcess: postProcess,
+      defaultValue: { _id: 'default' } as TestMetadata,
+      defaultLoadBy: 'defaultId',
+      noId: false,
+      debugLog: true,
+    });
+
+    expect(settings.name).toBe('TestHandler');
+    expect(settings.get).toBe(getFn);
+    expect(settings.set).toBe(setFn);
+    expect(settings.getPostProcess).toBe(postProcess);
+    expect(settings.defaultValue).toEqual({ _id: 'default' });
+    expect(settings.defaultLoadBy).toBe('defaultId');
+    expect(settings.noId).toBe(false);
+    expect(settings.debugLog).toBe(true);
+  });
+});
+
+describe('| DyFM_DataListHandler_Settings', (): void => {
+  it('| should create an instance with list handler settings', (): void => {
+    const setItemFn = async (item: TestMetadata): Promise<TestMetadata> => item;
+    const deleteItemFn = async (id: string): Promise<void> => {};
+
+    const settings = new DyFM_DataListHandler_Settings<TestMetadata>();
+    Object.assign(settings, {
+      name: 'TestListHandler',
+      setItem: setItemFn,
+      deleteItem: deleteItemFn,
+    });
+
+    expect(settings.name).toBe('TestListHandler');
+    expect(settings.setItem).toBe(setItemFn);
+    expect(settings.deleteItem).toBe(deleteItemFn);
+  });
+});
+
+describe('| DyFM_DataSearchHandler_Settings', (): void => {
+  it('| should create an instance with search handler settings', (): void => {
+    const defaultQuery: DyFM_SearchQuery<TestMetadata> = {
+      page: 0,
+      pageSize: 10,
+    };
+
+    const settings = new DyFM_DataSearchHandler_Settings<TestMetadata>();
+    Object.assign(settings, {
+      name: 'TestSearchHandler',
+      defaultQuery: defaultQuery,
+      defaultPageSize: 20,
+      cacheSize: 10,
+      queryUpdateDebounceTime: 500,
+      searchOnInit: true,
+    });
+
+    expect(settings.name).toBe('TestSearchHandler');
+    expect(settings.defaultQuery).toEqual(defaultQuery);
+    expect(settings.defaultPageSize).toBe(20);
+    expect(settings.cacheSize).toBe(10);
+    expect(settings.queryUpdateDebounceTime).toBe(500);
+    expect(settings.searchOnInit).toBe(true);
+  });
+});
+
+describe('| DyFM_ListCollectorDataHandler_Settings', (): void => {
+  it('| should create an instance with list collector settings', (): void => {
+    const setItemFn = async (item: TestMetadata, collectorId?: string): Promise<TestMetadata> => item;
+    const deleteItemFn = async (id: string, collectorId?: string): Promise<void> => {};
+
+    const settings = new DyFM_ListCollectorDataHandler_Settings<TestMetadata, TestMetadata>();
+    Object.assign(settings, {
+      name: 'TestCollectorHandler',
+      listKey: 'items',
+      setItem: setItemFn,
+      deleteItem: deleteItemFn,
+    });
+
+    expect(settings.name).toBe('TestCollectorHandler');
+    expect(settings.listKey).toBe('items');
+    expect(settings.setItem).toBe(setItemFn);
+    expect(settings.deleteItem).toBe(deleteItemFn);
+  });
+});
+