@futdevpro/nts-dynamo 1.15.136 → 1.15.139

package/src/_modules/bot/_modules/slack-bot/_services/slb-messaging-provider.control-service.spec.ts

@@ -1,344 +1,344 @@
-
-import { DyNTS_SlB_MessagingProvider_ControlService } from './slb-messaging-provider.control-service';
-import { Slack_MessagingProviderConfig } from '../../../_services/bot-messaging-provider.service-base';
-import { DyFM_Msg_Provider_Type } from '@futdevpro/fsm-dynamo/messaging';
-
-describe('| DyNTS_SlB_MessagingProvider_ControlService', () => {
-  let provider: DyNTS_SlB_MessagingProvider_ControlService;
-  let config: Slack_MessagingProviderConfig;
-
-  beforeEach(() => {
-    config = {
-      token: 'test-token',
-      workspace: 'test-workspace',
-      reportChannelName: 'reports',
-    };
-
-    provider = new DyNTS_SlB_MessagingProvider_ControlService(config);
-  });
-
-  describe('| constructor', () => {
-    it('| should initialize with config', () => {
-      expect(provider.config).toEqual(config);
-      expect(provider.name).toBe('slack');
-      expect(provider.type).toBe(DyFM_Msg_Provider_Type.slack);
-    });
-  });
-
-  describe('| properties', () => {
-    it('| should return botId', () => {
-      expect(provider.botId).toBe('slack-bot-stub');
-    });
-
-    it('| should return botDisplayName', () => {
-      expect(provider.botDisplayName).toBe('Slack Bot (Stub)');
-    });
-  });
-
-  describe('| setup', () => {
-    it('| should throw error (not yet implemented)', async () => {
-      try {
-        await provider.setup('test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-  });
-
-  describe('| start', () => {
-    it('| should throw error (not yet implemented)', async () => {
-      try {
-        await provider.start('test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-  });
-
-  describe('| channel operations', () => {
-    it('| getChannelByName should throw error', async () => {
-      try {
-        await provider.getChannelByName('test-channel');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| getChannelById should throw error', async () => {
-      try {
-        await provider.getChannelById('channel-123');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| sendMessageToChannelByName should throw error', async () => {
-      try {
-        await provider.sendMessageToChannelByName('test-channel', 'Test message', 'test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| getMessagesFromChannelByChannelName should throw error', async () => {
-      try {
-        await provider.getMessagesFromChannelByChannelName('test-channel', 10);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| getLastMessageInChannel should throw error', async () => {
-      try {
-        await provider.getLastMessageInChannel('test-channel');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| clearChannel should throw error', async () => {
-      try {
-        await provider.clearChannel(null as any);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-  });
-
-  describe('| message operations', () => {
-    it('| sendMessageToChannel should throw error', async () => {
-      try {
-        await provider.sendMessageToChannel(null as any, 'Test message');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| replyToMessage should throw error', async () => {
-      try {
-        await provider.replyToMessage(null as any, 'Reply');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| sendTyping should throw error', async () => {
-      try {
-        await provider.sendTyping(null as any);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| sendTypingForMessage should throw error', async () => {
-      try {
-        await provider.sendTypingForMessage(null as any);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| fetchMessages should throw error', async () => {
-      try {
-        await provider.fetchMessages(null as any, 10);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| fetchMessagesById should throw error', async () => {
-      try {
-        await provider.fetchMessagesById('id-123', 10);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| fetchMessagesForMessage should throw error', async () => {
-      try {
-        await provider.fetchMessagesForMessage(null as any, 10);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| fetchAllMessagesWithPaging should throw error', async () => {
-      try {
-        await provider.fetchAllMessagesWithPaging(null as any, 100);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| deleteMessage should throw error', async () => {
-      try {
-        await provider.deleteMessage(null as any);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-  });
-
-  describe('| user operations', () => {
-    it('| getUserByName should throw error', async () => {
-      try {
-        await provider.getUserByName('test-user');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| getUserMention should return mention string', () => {
-      const mention = provider.getUserMention('user-123');
-      expect(mention).toBe('<@user-123>');
-    });
-
-    it('| getUserMention should handle different user IDs', () => {
-      expect(provider.getUserMention('U123456')).toBe('<@U123456>');
-      expect(provider.getUserMention('user-abc')).toBe('<@user-abc>');
-    });
-
-    it('| readMembersInChannel should throw error', async () => {
-      try {
-        await provider.readMembersInChannel('test-channel');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| readMemberNamesInChannel should throw error', async () => {
-      try {
-        await provider.readMemberNamesInChannel('test-channel');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-  });
-
-  describe('| advanced message queries', () => {
-    it('| getLastMessageSentBy should throw error', async () => {
-      try {
-        await provider.getLastMessageSentBy('test-channel', 'test-user');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| getLastMentionOf should throw error', async () => {
-      try {
-        await provider.getLastMentionOf('test-channel', 'test-user');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| readLastMessageDatesByMembers should throw error', async () => {
-      try {
-        await provider.readLastMessageDatesByMembers('test-channel', ['user1', 'user2']);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| readLastMessageWithMemberNamePingInIt should throw error', async () => {
-      try {
-        await provider.readLastMessageWithMemberNamePingInIt('test-channel', []);
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-  });
-
-  describe('| event binding', () => {
-    it('| create_onMessageEventListener should throw error', async () => {
-      try {
-        await provider.create_onMessageEventListener(async () => {});
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| create_onErrorEventListener should throw error', () => {
-      try {
-        provider.create_onErrorEventListener(() => {});
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-  });
-
-  describe('| report operations', () => {
-    it('| sendReport should throw error', async () => {
-      try {
-        await provider.sendReport('Test report');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-
-    it('| sendReportIn should throw error', async () => {
-      try {
-        await provider.sendReportIn('Test report');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toBe('Slack provider not yet implemented');
-      }
-    });
-  });
-});
-
+
+import { DyNTS_SlB_MessagingProvider_ControlService } from './slb-messaging-provider.control-service';
+import { Slack_MessagingProviderConfig } from '../../../_services/bot-messaging-provider.service-base';
+import { DyFM_Msg_Provider_Type } from '@futdevpro/fsm-dynamo/messaging';
+
+describe('| DyNTS_SlB_MessagingProvider_ControlService', () => {
+  let provider: DyNTS_SlB_MessagingProvider_ControlService;
+  let config: Slack_MessagingProviderConfig;
+
+  beforeEach(() => {
+    config = {
+      token: 'test-token',
+      workspace: 'test-workspace',
+      reportChannelName: 'reports',
+    };
+
+    provider = new DyNTS_SlB_MessagingProvider_ControlService(config);
+  });
+
+  describe('| constructor', () => {
+    it('| should initialize with config', () => {
+      expect(provider.config).toEqual(config);
+      expect(provider.name).toBe('slack');
+      expect(provider.type).toBe(DyFM_Msg_Provider_Type.slack);
+    });
+  });
+
+  describe('| properties', () => {
+    it('| should return botId', () => {
+      expect(provider.botId).toBe('slack-bot-stub');
+    });
+
+    it('| should return botDisplayName', () => {
+      expect(provider.botDisplayName).toBe('Slack Bot (Stub)');
+    });
+  });
+
+  describe('| setup', () => {
+    it('| should throw error (not yet implemented)', async () => {
+      try {
+        await provider.setup('test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+  });
+
+  describe('| start', () => {
+    it('| should throw error (not yet implemented)', async () => {
+      try {
+        await provider.start('test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+  });
+
+  describe('| channel operations', () => {
+    it('| getChannelByName should throw error', async () => {
+      try {
+        await provider.getChannelByName('test-channel');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| getChannelById should throw error', async () => {
+      try {
+        await provider.getChannelById('channel-123');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| sendMessageToChannelByName should throw error', async () => {
+      try {
+        await provider.sendMessageToChannelByName('test-channel', 'Test message', 'test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| getMessagesFromChannelByChannelName should throw error', async () => {
+      try {
+        await provider.getMessagesFromChannelByChannelName('test-channel', 10);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| getLastMessageInChannel should throw error', async () => {
+      try {
+        await provider.getLastMessageInChannel('test-channel');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| clearChannel should throw error', async () => {
+      try {
+        await provider.clearChannel(null as any);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+  });
+
+  describe('| message operations', () => {
+    it('| sendMessageToChannel should throw error', async () => {
+      try {
+        await provider.sendMessageToChannel(null as any, 'Test message');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| replyToMessage should throw error', async () => {
+      try {
+        await provider.replyToMessage(null as any, 'Reply');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| sendTyping should throw error', async () => {
+      try {
+        await provider.sendTyping(null as any);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| sendTypingForMessage should throw error', async () => {
+      try {
+        await provider.sendTypingForMessage(null as any);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| fetchMessages should throw error', async () => {
+      try {
+        await provider.fetchMessages(null as any, 10);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| fetchMessagesById should throw error', async () => {
+      try {
+        await provider.fetchMessagesById('id-123', 10);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| fetchMessagesForMessage should throw error', async () => {
+      try {
+        await provider.fetchMessagesForMessage(null as any, 10);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| fetchAllMessagesWithPaging should throw error', async () => {
+      try {
+        await provider.fetchAllMessagesWithPaging(null as any, 100);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| deleteMessage should throw error', async () => {
+      try {
+        await provider.deleteMessage(null as any);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+  });
+
+  describe('| user operations', () => {
+    it('| getUserByName should throw error', async () => {
+      try {
+        await provider.getUserByName('test-user');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| getUserMention should return mention string', () => {
+      const mention = provider.getUserMention('user-123');
+      expect(mention).toBe('<@user-123>');
+    });
+
+    it('| getUserMention should handle different user IDs', () => {
+      expect(provider.getUserMention('U123456')).toBe('<@U123456>');
+      expect(provider.getUserMention('user-abc')).toBe('<@user-abc>');
+    });
+
+    it('| readMembersInChannel should throw error', async () => {
+      try {
+        await provider.readMembersInChannel('test-channel');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| readMemberNamesInChannel should throw error', async () => {
+      try {
+        await provider.readMemberNamesInChannel('test-channel');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+  });
+
+  describe('| advanced message queries', () => {
+    it('| getLastMessageSentBy should throw error', async () => {
+      try {
+        await provider.getLastMessageSentBy('test-channel', 'test-user');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| getLastMentionOf should throw error', async () => {
+      try {
+        await provider.getLastMentionOf('test-channel', 'test-user');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| readLastMessageDatesByMembers should throw error', async () => {
+      try {
+        await provider.readLastMessageDatesByMembers('test-channel', ['user1', 'user2']);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| readLastMessageWithMemberNamePingInIt should throw error', async () => {
+      try {
+        await provider.readLastMessageWithMemberNamePingInIt('test-channel', []);
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+  });
+
+  describe('| event binding', () => {
+    it('| create_onMessageEventListener should throw error', async () => {
+      try {
+        await provider.create_onMessageEventListener(async () => {});
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| create_onErrorEventListener should throw error', () => {
+      try {
+        provider.create_onErrorEventListener(() => {});
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+  });
+
+  describe('| report operations', () => {
+    it('| sendReport should throw error', async () => {
+      try {
+        await provider.sendReport('Test report');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+
+    it('| sendReportIn should throw error', async () => {
+      try {
+        await provider.sendReportIn('Test report');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toBe('Slack provider not yet implemented');
+      }
+    });
+  });
+});
+