@futdevpro/fsm-dynamo 1.15.8 → 1.15.9

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

@@ -0,0 +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');
+  });
+});
+

package/src/_modules/messaging/_models/msg-conversation.data-model.spec.ts

@@ -0,0 +1,69 @@
+import { DyFM_Msg_Conversation } from './msg-conversation.data-model';
+import { DyFM_Msg_ConversationType } from '../_enums/msg-conversation-type.enum';
+import { DyFM_Msg_Participant } from './msg-participant.interface';
+import { DyFM_Msg_ParticipantRole } from '../_enums/msg-participant-role.enum';
+
+describe('| DyFM_Msg_Conversation', (): void => {
+  it('| should create an instance without initial data', (): void => {
+    const conversation = new DyFM_Msg_Conversation();
+
+    expect(conversation).toBeTruthy();
+    expect(conversation.__created).toBeInstanceOf(Date);
+    expect(conversation.__lastModified).toBeInstanceOf(Date);
+  });
+
+  it('| should create an instance with initial data', (): void => {
+    const participants: DyFM_Msg_Participant[] = [
+      { userId: 'user1', role: DyFM_Msg_ParticipantRole.owner, joinedAt: new Date() },
+      { userId: 'user2', role: DyFM_Msg_ParticipantRole.member, joinedAt: new Date() },
+    ];
+
+    const initialData: DyFM_Msg_Conversation = {
+      title: 'Test Conversation',
+      type: DyFM_Msg_ConversationType.direct,
+      participants: participants,
+      lastMessageId: 'msg1',
+      lastMessageAt: new Date('2023-01-01'),
+      lastMessagePreview: 'Hello world',
+      isArchived: false,
+      isMuted: false,
+      isPinned: true,
+      platformSource: 'test',
+      platformChannelId: 'channel1',
+      platformChannelName: 'Test Channel',
+      aiProvider: 'openai',
+      aiModel: 'gpt-4',
+      systemPrompt: 'You are a helpful assistant',
+      messageCount: 10,
+      unreadCount: 2,
+    };
+
+    const conversation = new DyFM_Msg_Conversation(initialData);
+
+    expect(conversation.title).toBe('Test Conversation');
+    expect(conversation.type).toBe(DyFM_Msg_ConversationType.direct);
+    expect(conversation.participants).toEqual(participants);
+    expect(conversation.lastMessageId).toBe('msg1');
+    expect(conversation.lastMessageAt).toEqual(new Date('2023-01-01'));
+    expect(conversation.lastMessagePreview).toBe('Hello world');
+    expect(conversation.isArchived).toBe(false);
+    expect(conversation.isMuted).toBe(false);
+    expect(conversation.isPinned).toBe(true);
+    expect(conversation.platformSource).toBe('test');
+    expect(conversation.platformChannelId).toBe('channel1');
+    expect(conversation.platformChannelName).toBe('Test Channel');
+    expect(conversation.aiProvider).toBe('openai');
+    expect(conversation.aiModel).toBe('gpt-4');
+    expect(conversation.systemPrompt).toBe('You are a helpful assistant');
+    expect(conversation.messageCount).toBe(10);
+    expect(conversation.unreadCount).toBe(2);
+  });
+
+  it('| should have dataParams defined', (): void => {
+    const { DyFM_msgConversation_dataParams } = require('./msg-conversation.data-model');
+
+    expect(DyFM_msgConversation_dataParams).toBeTruthy();
+    expect(DyFM_msgConversation_dataParams.dataName).toBe('msg_conversation');
+  });
+});
+

package/src/_modules/messaging/_models/msg-message.data-model.spec.ts

@@ -0,0 +1,79 @@
+import { DyFM_Msg_Message } from './msg-message.data-model';
+import { DyFM_Msg_Type } from '../_enums/msg-type.enum';
+import { DyFM_Msg_Status } from '../_enums/msg-status.enum';
+
+describe('| DyFM_Msg_Message', (): void => {
+  it('| should create an instance without initial data', (): void => {
+    const message = new DyFM_Msg_Message();
+
+    expect(message).toBeTruthy();
+    expect(message.__created).toBeInstanceOf(Date);
+    expect(message.__lastModified).toBeInstanceOf(Date);
+  });
+
+  it('| should create an instance with initial data', (): void => {
+    const initialData: DyFM_Msg_Message = {
+      conversationId: 'conv1',
+      content: 'Hello world',
+      type: DyFM_Msg_Type.text,
+      status: DyFM_Msg_Status.sent,
+      senderId: 'user1',
+      senderName: 'John Doe',
+      senderDisplayName: 'John',
+      recipientIds: ['user2'],
+      parentMessageId: 'parent1',
+      threadId: 'thread1',
+      attachments: [],
+      mentions: [],
+      reactions: [],
+      aiProvider: 'openai',
+      aiModel: 'gpt-4',
+      isAIGenerated: false,
+      systemPrompt: 'You are helpful',
+      agentProcessSteps: [],
+      platformSource: 'test',
+      platformMessageId: 'platform1',
+      platformChannelId: 'channel1',
+      sentAt: new Date('2023-01-01'),
+      deliveredAt: new Date('2023-01-01'),
+      readAt: new Date('2023-01-01'),
+      editedAt: new Date('2023-01-01'),
+    };
+
+    const message = new DyFM_Msg_Message(initialData);
+
+    expect(message.conversationId).toBe('conv1');
+    expect(message.content).toBe('Hello world');
+    expect(message.type).toBe(DyFM_Msg_Type.text);
+    expect(message.status).toBe(DyFM_Msg_Status.sent);
+    expect(message.senderId).toBe('user1');
+    expect(message.senderName).toBe('John Doe');
+    expect(message.senderDisplayName).toBe('John');
+    expect(message.recipientIds).toEqual(['user2']);
+    expect(message.parentMessageId).toBe('parent1');
+    expect(message.threadId).toBe('thread1');
+    expect(message.attachments).toEqual([]);
+    expect(message.mentions).toEqual([]);
+    expect(message.reactions).toEqual([]);
+    expect(message.aiProvider).toBe('openai');
+    expect(message.aiModel).toBe('gpt-4');
+    expect(message.isAIGenerated).toBe(false);
+    expect(message.systemPrompt).toBe('You are helpful');
+    expect(message.agentProcessSteps).toEqual([]);
+    expect(message.platformSource).toBe('test');
+    expect(message.platformMessageId).toBe('platform1');
+    expect(message.platformChannelId).toBe('channel1');
+    expect(message.sentAt).toEqual(new Date('2023-01-01'));
+    expect(message.deliveredAt).toEqual(new Date('2023-01-01'));
+    expect(message.readAt).toEqual(new Date('2023-01-01'));
+    expect(message.editedAt).toEqual(new Date('2023-01-01'));
+  });
+
+  it('| should have dataParams defined', (): void => {
+    const { DyFM_msgMessage_dataParams } = require('./msg-message.data-model');
+
+    expect(DyFM_msgMessage_dataParams).toBeTruthy();
+    expect(DyFM_msgMessage_dataParams.dataName).toBe('msg_message');
+  });
+});
+

package/src/_modules/pipe/_collections/utils/pip-json-pipe.util.spec.ts

@@ -0,0 +1,62 @@
+import { DyFM_json_pipeTransform } from './pip-json-pipe.util';
+
+describe('| DyFM_json_pipeTransform', (): void => {
+  it('| should stringify an object with default depth', (): void => {
+    const obj = { a: 1, b: 2, c: 3 };
+    const result = DyFM_json_pipeTransform(obj);
+
+    expect(result).toBe(JSON.stringify(obj, null, 2));
+  });
+
+  it('| should stringify an object with custom depth', (): void => {
+    const obj = { a: 1, b: 2, c: 3 };
+    const result = DyFM_json_pipeTransform(obj, 4);
+
+    expect(result).toBe(JSON.stringify(obj, null, 4));
+  });
+
+  it('| should handle arrays', (): void => {
+    const arr = [1, 2, 3];
+    const result = DyFM_json_pipeTransform(arr);
+
+    expect(result).toBe(JSON.stringify(arr, null, 2));
+  });
+
+  it('| should handle nested objects', (): void => {
+    const obj = { a: { b: { c: 1 } } };
+    const result = DyFM_json_pipeTransform(obj);
+
+    expect(result).toBe(JSON.stringify(obj, null, 2));
+  });
+
+  it('| should handle null', (): void => {
+    const result = DyFM_json_pipeTransform(null);
+
+    expect(result).toBe(JSON.stringify(null, null, 2));
+  });
+
+  it('| should handle undefined', (): void => {
+    const result = DyFM_json_pipeTransform(undefined);
+
+    expect(result).toBe(JSON.stringify(undefined, null, 2));
+  });
+
+  it('| should handle strings', (): void => {
+    const result = DyFM_json_pipeTransform('test');
+
+    expect(result).toBe(JSON.stringify('test', null, 2));
+  });
+
+  it('| should handle numbers', (): void => {
+    const result = DyFM_json_pipeTransform(123);
+
+    expect(result).toBe(JSON.stringify(123, null, 2));
+  });
+
+  it('| should handle boolean values', (): void => {
+    const result = DyFM_json_pipeTransform(true);
+
+    expect(result).toBe(JSON.stringify(true, null, 2));
+  });
+});
+

package/src/_modules/pipe/_collections/utils/pip-multi-pipe-pipe.util.spec.ts

@@ -38,17 +38,24 @@ describe('| DyFM_multiPipe_pipeTransform', () => {
     expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe('transformed with arg1');
   }); */
 
-  xit('should return the original value if Angular pipe is not defined', () => {
+  it('| should return the original value if Angular pipe is not defined', () => {
     const value = 'test';
     const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_AngularMultiPipeAvailable.currency]: [] }];
-    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
+    const originalPipe = DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency];
+    DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency] = null;
+    const result = DyFM_multiPipe_pipeTransform(value, pipes);
+    DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency] = originalPipe;
+    expect(result).toBe(value);
   });
 
   it('| should transform value using a defined Angular pipe', () => {
     const value = 'test';
     const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_AngularMultiPipeAvailable.currency]: ['arg1'] }];
+    const originalPipe = DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency];
     DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency] = (val: string, arg: string) => `angular transformed with ${arg}`;
-    expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe('angular transformed with arg1');
+    const result = DyFM_multiPipe_pipeTransform(value, pipes);
+    DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency] = originalPipe;
+    expect(result).toBe('angular transformed with arg1');
   });
 
   /* it('| should handle errors gracefully and return the original value', () => {