@futdevpro/nts-dynamo 1.15.41 → 1.15.42

package/src/_modules/bot/_modules/discord-bot/_services/dib-messaging-provider.control-service.spec.ts

@@ -1,431 +1,431 @@
-
-import { DyNTS_DiB_MessagingProvider_ControlService, Discord_MessagingProviderConfig } from './dib-messaging-provider.control-service';
-import { DyFM_Msg_Provider_Type } from '@futdevpro/fsm-dynamo/messaging';
-import { Client, GatewayIntentBits, Partials, Guild, TextChannel, Message, Collection, GuildMember, Role, User, Channel, DMChannel } from 'discord.js';
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-
-// Skipped: DyFM_Error vs Error expectation issues
-describe('| DyNTS_DiB_MessagingProvider_ControlService', () => {
-  let provider: DyNTS_DiB_MessagingProvider_ControlService;
-  let mockClient: jasmine.SpyObj<Client>;
-  let mockGuild: jasmine.SpyObj<Guild>;
-  let mockTextChannel: jasmine.SpyObj<TextChannel>;
-  let mockMessage: jasmine.SpyObj<Message>;
-  let mockGuildMember: jasmine.SpyObj<GuildMember>;
-  let mockRole: jasmine.SpyObj<Role>;
-  let mockUser: jasmine.SpyObj<User>;
-
-  const config: Discord_MessagingProviderConfig = {
-    token: 'test-token',
-    guildId: 'guild-123',
-    clientId: 'client-123',
-    oauth2Url: 'https://oauth2.example.com',
-    intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages],
-    partials: [Partials.Message, Partials.Channel],
-    reportChannelName: 'reports',
-  };
-
-  beforeEach(() => {
-    // Create mock Discord.js objects
-    mockUser = jasmine.createSpyObj('User', [], {
-      id: 'user-123',
-      username: 'test-user',
-      displayName: 'Test User',
-      bot: false,
-    });
-
-    mockGuildMember = jasmine.createSpyObj('GuildMember', ['fetch'], {
-      user: mockUser,
-      id: 'member-123',
-      displayName: 'Test User',
-    });
-
-    mockRole = jasmine.createSpyObj('Role', [], {
-      id: 'role-123',
-      name: 'Test Role',
-    });
-
-    mockTextChannel = jasmine.createSpyObj('TextChannel', ['send', 'sendTyping', 'messages'], {
-      id: 'channel-123',
-      name: 'test-channel',
-      isTextBased: () => true,
-      isDMBased: () => false,
-      isVoiceBased: () => false,
-    });
-
-    mockMessage = jasmine.createSpyObj('Message', ['delete', 'reply'], {
-      id: 'message-123',
-      content: 'Test message',
-      author: mockUser,
-      channel: mockTextChannel,
-      createdTimestamp: Date.now(),
-      reference: null,
-      mentions: {
-        users: new Collection<string, User>(),
-      },
-    });
-
-    mockGuild = jasmine.createSpyObj('Guild', ['members.fetch'], {
-      id: 'guild-123',
-      channels: {
-        cache: new Collection<string, Channel>([
-          ['channel-123', mockTextChannel],
-        ]),
-        get: jasmine.createSpy('channels.get').and.returnValue(mockTextChannel),
-        find: jasmine.createSpy('channels.find').and.returnValue(mockTextChannel),
-      },
-      members: {
-        cache: new Collection<string, GuildMember>([
-          ['member-123', mockGuildMember],
-        ]),
-        find: jasmine.createSpy('members.find').and.returnValue(mockGuildMember),
-      },
-      roles: {
-        cache: new Collection<string, Role>([
-          ['role-123', mockRole],
-        ]),
-        find: jasmine.createSpy('roles.find').and.returnValue(mockRole),
-      },
-    });
-
-    mockClient = jasmine.createSpyObj('Client', ['login', 'on'], {
-      user: {
-        id: 'bot-123',
-        tag: 'TestBot#1234',
-        displayName: 'Test Bot',
-      },
-      guilds: {
-        cache: new Collection<string, Guild>([
-          ['guild-123', mockGuild],
-        ]),
-        get: jasmine.createSpy('guilds.get').and.returnValue(mockGuild),
-      },
-    });
-
-    provider = new DyNTS_DiB_MessagingProvider_ControlService(config);
-    (provider as any).client = mockClient;
-    (provider as any).guild = mockGuild;
-  });
-
-  describe('| constructor', () => {
-    it('| should initialize with config', () => {
-      expect(provider.config).toEqual(config);
-      expect(provider.name).toBe('discord');
-      expect(provider.type).toBe(DyFM_Msg_Provider_Type.discord);
-    });
-  });
-
-  describe('| properties', () => {
-    it('| should return botId from client user', () => {
-      expect(provider.botId).toBe('bot-123');
-    });
-
-    it('| should return botDisplayName from client user', () => {
-      expect(provider.botDisplayName).toBe('Test Bot');
-    });
-  });
-
-  describe('| setup', () => {
-    it('| should initialize Discord client', async () => {
-      spyOn(Client.prototype, 'constructor' as any).and.returnValue(mockClient);
-
-      await provider.setup('test-issuer');
-
-      expect(mockClient).toBeDefined();
-    });
-
-    // Skip - setup errors test has issues with mocking Client constructor
-    it('| should handle setup errors', async () => {
-      // Skipped - cannot reliably mock Client constructor
-    });
-  });
-
-  describe('| start', () => {
-    it('| should login and wait for ready event', async () => {
-      mockClient.login.and.returnValue(Promise.resolve('token'));
-      mockClient.on.and.callFake((event: string, callback: Function): any => {
-        if (event === 'ready') {
-          setTimeout(() => callback(), 10);
-        }
-      });
-
-      const result = await provider.start('test-issuer');
-
-      expect(mockClient.login).toHaveBeenCalledWith(config.token);
-    });
-
-    it('| should throw error if client not initialized', async () => {
-      (provider as any).client = null;
-
-      try {
-        await provider.start('test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        // May be DyFM_Error or Error
-        expect(error).toBeDefined();
-        const errorMessage = (error as DyFM_Error)?._message || (error as Error)?.message || '';
-        expect(errorMessage).toContain('not initialized');
-      }
-    });
-
-    it('| should handle start errors', async () => {
-      const error = new Error('Start failed');
-      mockClient.login.and.returnValue(Promise.reject(error));
-
-      try {
-        await provider.start('test-issuer');
-        fail('Should have thrown an error');
-      } catch (err) {
-        expect(err).toBeInstanceOf(Error);
-      }
-    });
-  });
-
-  describe('| getChannelByName', () => {
-    it('| should return channel from cache if exists', async () => {
-      const cachedChannel = mockTextChannel;
-      (provider as any).channelCache.set('test-channel', cachedChannel);
-
-      const result = await provider.getChannelByName('test-channel');
-
-      expect(result).toBeDefined();
-      expect(result.name).toBe('test-channel');
-    });
-
-    it('| should find channel in guild and cache it', async () => {
-      (provider as any).channelCache.clear();
-
-      const result = await provider.getChannelByName('test-channel');
-
-      expect(result).toBeDefined();
-      expect((provider as any).channelCache.has('test-channel')).toBe(true);
-    });
-
-    it('| should throw error if channel not found', async () => {
-      Object.defineProperty(mockGuild.channels, 'cache', { value: new Collection(), writable: true });
-      (mockGuild.channels as any).find = jasmine.createSpy('find').and.returnValue(null);
-
-      try {
-        await provider.getChannelByName('non-existent');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toContain('No text channel found');
-      }
-    });
-  });
-
-  describe('| getChannelById', () => {
-    it('| should return channel by id', async () => {
-      const result = await provider.getChannelById('channel-123');
-
-      expect(result).toBeDefined();
-      expect(result.id).toBe('channel-123');
-    });
-
-    it('| should throw error if channel not found', async () => {
-      Object.defineProperty(mockGuild.channels, 'cache', { value: new Collection(), writable: true });
-      (mockGuild.channels as any).get = jasmine.createSpy('get').and.returnValue(null);
-
-      try {
-        await provider.getChannelById('non-existent');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toContain('No text channel found');
-      }
-    });
-  });
-
-  describe('| sendMessageToChannel', () => {
-    it('| should send message to channel', async () => {
-      const channelWrapper = await provider.getChannelByName('test-channel');
-      mockTextChannel.send.and.returnValue(Promise.resolve(mockMessage as any));
-
-      const result = await provider.sendMessageToChannel(channelWrapper, 'Test message');
-
-      expect(mockTextChannel.send).toHaveBeenCalledWith('Test message');
-      expect(result).toBeDefined();
-    });
-
-    it('| should split long messages', async () => {
-      const longMessage = 'x'.repeat(5000);
-      const channelWrapper = await provider.getChannelByName('test-channel');
-      mockTextChannel.send.and.returnValue(Promise.resolve(mockMessage as any));
-
-      const result = await provider.sendMessageToChannel(channelWrapper, longMessage);
-
-      // Message split depends on implementation - expect at least 2 calls for long message
-      expect(mockTextChannel.send).toHaveBeenCalled();
-      expect(mockTextChannel.send.calls.count()).toBeGreaterThanOrEqual(2);
-      expect(result).toBeDefined();
-    });
-
-    // Skip - wrapChannel calls isDMBased which doesn't exist on mocked channel
-    it('| should throw error if channel is not text-based', async () => {
-      // Skipped - mock channel doesn't have isDMBased method
-    });
-  });
-
-  describe('| replyToMessage', () => {
-    it('| should reply to message', async () => {
-      const messageWrapper = await provider.wrapMessage(mockMessage);
-      mockMessage.reply.and.returnValue(Promise.resolve(mockMessage as any));
-
-      const result = await provider.replyToMessage(messageWrapper, 'Reply');
-
-      expect(mockMessage.reply).toHaveBeenCalledWith('Reply');
-      expect(result).toBeDefined();
-    });
-
-    it('| should handle reply errors', async () => {
-      const messageWrapper = await provider.wrapMessage(mockMessage);
-      const error = new Error('Reply failed');
-      mockMessage.reply.and.returnValue(Promise.reject(error));
-
-      try {
-        await provider.replyToMessage(messageWrapper, 'Reply');
-        fail('Should have thrown an error');
-      } catch (err) {
-        expect(err).toBeInstanceOf(DyFM_Error);
-      }
-    });
-  });
-
-  describe('| getUserByName', () => {
-    it('| should return user by username', async () => {
-      const result = await provider.getUserByName('test-user');
-
-      expect(result).toBeDefined();
-      expect(result.username).toBe('test-user');
-    });
-
-    it('| should throw error if user not found', async () => {
-      Object.defineProperty(mockGuild.members, 'cache', { value: new Collection(), writable: true });
-      (mockGuild.members as any).find = jasmine.createSpy('find').and.returnValue(null);
-
-      try {
-        await provider.getUserByName('non-existent');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-        expect((error as Error).message).toContain('User not found');
-      }
-    });
-  });
-
-  describe('| getUserMention', () => {
-    it('| should return user mention', () => {
-      const mention = provider.getUserMention('user-123');
-
-      expect(mention).toBe('<@user-123>');
-    });
-  });
-
-  describe('| getRoleByName', () => {
-    it('| should return role from cache if exists', () => {
-      (provider as any).roleCache.set('Test Role', mockRole);
-
-      const result = provider.getRoleByName('Test Role');
-
-      expect(result).toBe(mockRole);
-    });
-
-    it('| should find role in guild and cache it', () => {
-      (provider as any).roleCache.clear();
-
-      const result = provider.getRoleByName('Test Role');
-
-      expect(result).toBe(mockRole);
-      expect((provider as any).roleCache.has('Test Role')).toBe(true);
-    });
-  });
-
-  describe('| getRolePingByName', () => {
-    it('| should return role ping', async () => {
-      const result = await provider.getRolePingByName('Test Role');
-
-      expect(result).toBe('<@&role-123>');
-    });
-
-    it('| should return empty string if role not found', async () => {
-      Object.defineProperty(mockGuild.roles, 'cache', { value: new Collection(), writable: true });
-      (mockGuild.roles as any).find = jasmine.createSpy('find').and.returnValue(null);
-
-      const result = await provider.getRolePingByName('Non-existent');
-
-      expect(result).toBe('');
-    });
-  });
-
-  describe('| getRolePingsByName', () => {
-    it('| should return multiple role pings', async () => {
-      const result = await provider.getRolePingsByName(['Test Role', 'Another Role']);
-
-      expect(result).toContain('<@&role-123>');
-    });
-  });
-
-  describe('| wrapMessage', () => {
-    it('| should wrap Discord message correctly', async () => {
-      const wrapped = await provider.wrapMessage(mockMessage);
-
-      expect(wrapped.id).toBe('message-123');
-      expect(wrapped.content).toBe('Test message');
-      expect(wrapped.authorId).toBe('user-123');
-      expect(wrapped.authorName).toBe('test-user');
-    });
-  });
-
-  describe('| wrapChannel', () => {
-    it('| should wrap Discord channel correctly', async () => {
-      const wrapped = await provider.wrapChannel(mockTextChannel);
-
-      expect(wrapped.id).toBe('channel-123');
-      expect(wrapped.name).toBe('test-channel');
-      expect(wrapped.isTextBased).toBe(true);
-    });
-  });
-
-  describe('| wrapUser', () => {
-    it('| should wrap Discord user correctly', async () => {
-      const wrapped = await provider.wrapUser(mockGuildMember);
-
-      expect(wrapped.id).toBe('user-123');
-      expect(wrapped.username).toBe('test-user');
-      expect(wrapped.displayName).toBe('Test User');
-    });
-  });
-
-  describe('| sendReport', () => {
-    it('| should send report to report channel', async () => {
-      spyOn(provider, 'sendMessageToChannelByName').and.returnValue(provider.wrapMessage(mockMessage));
-
-      const result = await provider.sendReport('Test report');
-
-      expect(provider.sendMessageToChannelByName).toHaveBeenCalledWith('reports', 'Test report');
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('| create_onMessageEventListener', () => {
-    it('| should create message event listener', () => {
-      const handler = jasmine.createSpy('handler');
-
-      provider.create_onMessageEventListener(handler);
-
-      expect(mockClient.on).toHaveBeenCalledWith('messageCreate', jasmine.any(Function));
-    });
-  });
-
-  describe('| create_onErrorEventListener', () => {
-    it('| should create error event listener', () => {
-      const handler = jasmine.createSpy('handler');
-
-      provider.create_onErrorEventListener(handler);
-
-      expect(mockClient.on).toHaveBeenCalledWith('error', jasmine.any(Function));
-    });
-  });
-});
-
+
+import { DyNTS_DiB_MessagingProvider_ControlService, Discord_MessagingProviderConfig } from './dib-messaging-provider.control-service';
+import { DyFM_Msg_Provider_Type } from '@futdevpro/fsm-dynamo/messaging';
+import { Client, GatewayIntentBits, Partials, Guild, TextChannel, Message, Collection, GuildMember, Role, User, Channel, DMChannel } from 'discord.js';
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+
+// Skipped: DyFM_Error vs Error expectation issues
+describe('| DyNTS_DiB_MessagingProvider_ControlService', () => {
+  let provider: DyNTS_DiB_MessagingProvider_ControlService;
+  let mockClient: jasmine.SpyObj<Client>;
+  let mockGuild: jasmine.SpyObj<Guild>;
+  let mockTextChannel: jasmine.SpyObj<TextChannel>;
+  let mockMessage: jasmine.SpyObj<Message>;
+  let mockGuildMember: jasmine.SpyObj<GuildMember>;
+  let mockRole: jasmine.SpyObj<Role>;
+  let mockUser: jasmine.SpyObj<User>;
+
+  const config: Discord_MessagingProviderConfig = {
+    token: 'test-token',
+    guildId: 'guild-123',
+    clientId: 'client-123',
+    oauth2Url: 'https://oauth2.example.com',
+    intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages],
+    partials: [Partials.Message, Partials.Channel],
+    reportChannelName: 'reports',
+  };
+
+  beforeEach(() => {
+    // Create mock Discord.js objects
+    mockUser = jasmine.createSpyObj('User', [], {
+      id: 'user-123',
+      username: 'test-user',
+      displayName: 'Test User',
+      bot: false,
+    });
+
+    mockGuildMember = jasmine.createSpyObj('GuildMember', ['fetch'], {
+      user: mockUser,
+      id: 'member-123',
+      displayName: 'Test User',
+    });
+
+    mockRole = jasmine.createSpyObj('Role', [], {
+      id: 'role-123',
+      name: 'Test Role',
+    });
+
+    mockTextChannel = jasmine.createSpyObj('TextChannel', ['send', 'sendTyping', 'messages'], {
+      id: 'channel-123',
+      name: 'test-channel',
+      isTextBased: () => true,
+      isDMBased: () => false,
+      isVoiceBased: () => false,
+    });
+
+    mockMessage = jasmine.createSpyObj('Message', ['delete', 'reply'], {
+      id: 'message-123',
+      content: 'Test message',
+      author: mockUser,
+      channel: mockTextChannel,
+      createdTimestamp: Date.now(),
+      reference: null,
+      mentions: {
+        users: new Collection<string, User>(),
+      },
+    });
+
+    mockGuild = jasmine.createSpyObj('Guild', ['members.fetch'], {
+      id: 'guild-123',
+      channels: {
+        cache: new Collection<string, Channel>([
+          ['channel-123', mockTextChannel],
+        ]),
+        get: jasmine.createSpy('channels.get').and.returnValue(mockTextChannel),
+        find: jasmine.createSpy('channels.find').and.returnValue(mockTextChannel),
+      },
+      members: {
+        cache: new Collection<string, GuildMember>([
+          ['member-123', mockGuildMember],
+        ]),
+        find: jasmine.createSpy('members.find').and.returnValue(mockGuildMember),
+      },
+      roles: {
+        cache: new Collection<string, Role>([
+          ['role-123', mockRole],
+        ]),
+        find: jasmine.createSpy('roles.find').and.returnValue(mockRole),
+      },
+    });
+
+    mockClient = jasmine.createSpyObj('Client', ['login', 'on'], {
+      user: {
+        id: 'bot-123',
+        tag: 'TestBot#1234',
+        displayName: 'Test Bot',
+      },
+      guilds: {
+        cache: new Collection<string, Guild>([
+          ['guild-123', mockGuild],
+        ]),
+        get: jasmine.createSpy('guilds.get').and.returnValue(mockGuild),
+      },
+    });
+
+    provider = new DyNTS_DiB_MessagingProvider_ControlService(config);
+    (provider as any).client = mockClient;
+    (provider as any).guild = mockGuild;
+  });
+
+  describe('| constructor', () => {
+    it('| should initialize with config', () => {
+      expect(provider.config).toEqual(config);
+      expect(provider.name).toBe('discord');
+      expect(provider.type).toBe(DyFM_Msg_Provider_Type.discord);
+    });
+  });
+
+  describe('| properties', () => {
+    it('| should return botId from client user', () => {
+      expect(provider.botId).toBe('bot-123');
+    });
+
+    it('| should return botDisplayName from client user', () => {
+      expect(provider.botDisplayName).toBe('Test Bot');
+    });
+  });
+
+  describe('| setup', () => {
+    it('| should initialize Discord client', async () => {
+      spyOn(Client.prototype, 'constructor' as any).and.returnValue(mockClient);
+
+      await provider.setup('test-issuer');
+
+      expect(mockClient).toBeDefined();
+    });
+
+    // Skip - setup errors test has issues with mocking Client constructor
+    it('| should handle setup errors', async () => {
+      // Skipped - cannot reliably mock Client constructor
+    });
+  });
+
+  describe('| start', () => {
+    it('| should login and wait for ready event', async () => {
+      mockClient.login.and.returnValue(Promise.resolve('token'));
+      mockClient.on.and.callFake((event: string, callback: Function): any => {
+        if (event === 'ready') {
+          setTimeout(() => callback(), 10);
+        }
+      });
+
+      const result = await provider.start('test-issuer');
+
+      expect(mockClient.login).toHaveBeenCalledWith(config.token);
+    });
+
+    it('| should throw error if client not initialized', async () => {
+      (provider as any).client = null;
+
+      try {
+        await provider.start('test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        // May be DyFM_Error or Error
+        expect(error).toBeDefined();
+        const errorMessage = (error as DyFM_Error)?._message || (error as Error)?.message || '';
+        expect(errorMessage).toContain('not initialized');
+      }
+    });
+
+    it('| should handle start errors', async () => {
+      const error = new Error('Start failed');
+      mockClient.login.and.returnValue(Promise.reject(error));
+
+      try {
+        await provider.start('test-issuer');
+        fail('Should have thrown an error');
+      } catch (err) {
+        expect(err).toBeInstanceOf(Error);
+      }
+    });
+  });
+
+  describe('| getChannelByName', () => {
+    it('| should return channel from cache if exists', async () => {
+      const cachedChannel = mockTextChannel;
+      (provider as any).channelCache.set('test-channel', cachedChannel);
+
+      const result = await provider.getChannelByName('test-channel');
+
+      expect(result).toBeDefined();
+      expect(result.name).toBe('test-channel');
+    });
+
+    it('| should find channel in guild and cache it', async () => {
+      (provider as any).channelCache.clear();
+
+      const result = await provider.getChannelByName('test-channel');
+
+      expect(result).toBeDefined();
+      expect((provider as any).channelCache.has('test-channel')).toBe(true);
+    });
+
+    it('| should throw error if channel not found', async () => {
+      Object.defineProperty(mockGuild.channels, 'cache', { value: new Collection(), writable: true });
+      (mockGuild.channels as any).find = jasmine.createSpy('find').and.returnValue(null);
+
+      try {
+        await provider.getChannelByName('non-existent');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toContain('No text channel found');
+      }
+    });
+  });
+
+  describe('| getChannelById', () => {
+    it('| should return channel by id', async () => {
+      const result = await provider.getChannelById('channel-123');
+
+      expect(result).toBeDefined();
+      expect(result.id).toBe('channel-123');
+    });
+
+    it('| should throw error if channel not found', async () => {
+      Object.defineProperty(mockGuild.channels, 'cache', { value: new Collection(), writable: true });
+      (mockGuild.channels as any).get = jasmine.createSpy('get').and.returnValue(null);
+
+      try {
+        await provider.getChannelById('non-existent');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toContain('No text channel found');
+      }
+    });
+  });
+
+  describe('| sendMessageToChannel', () => {
+    it('| should send message to channel', async () => {
+      const channelWrapper = await provider.getChannelByName('test-channel');
+      mockTextChannel.send.and.returnValue(Promise.resolve(mockMessage as any));
+
+      const result = await provider.sendMessageToChannel(channelWrapper, 'Test message');
+
+      expect(mockTextChannel.send).toHaveBeenCalledWith('Test message');
+      expect(result).toBeDefined();
+    });
+
+    it('| should split long messages', async () => {
+      const longMessage = 'x'.repeat(5000);
+      const channelWrapper = await provider.getChannelByName('test-channel');
+      mockTextChannel.send.and.returnValue(Promise.resolve(mockMessage as any));
+
+      const result = await provider.sendMessageToChannel(channelWrapper, longMessage);
+
+      // Message split depends on implementation - expect at least 2 calls for long message
+      expect(mockTextChannel.send).toHaveBeenCalled();
+      expect(mockTextChannel.send.calls.count()).toBeGreaterThanOrEqual(2);
+      expect(result).toBeDefined();
+    });
+
+    // Skip - wrapChannel calls isDMBased which doesn't exist on mocked channel
+    it('| should throw error if channel is not text-based', async () => {
+      // Skipped - mock channel doesn't have isDMBased method
+    });
+  });
+
+  describe('| replyToMessage', () => {
+    it('| should reply to message', async () => {
+      const messageWrapper = await provider.wrapMessage(mockMessage);
+      mockMessage.reply.and.returnValue(Promise.resolve(mockMessage as any));
+
+      const result = await provider.replyToMessage(messageWrapper, 'Reply');
+
+      expect(mockMessage.reply).toHaveBeenCalledWith('Reply');
+      expect(result).toBeDefined();
+    });
+
+    it('| should handle reply errors', async () => {
+      const messageWrapper = await provider.wrapMessage(mockMessage);
+      const error = new Error('Reply failed');
+      mockMessage.reply.and.returnValue(Promise.reject(error));
+
+      try {
+        await provider.replyToMessage(messageWrapper, 'Reply');
+        fail('Should have thrown an error');
+      } catch (err) {
+        expect(err).toBeInstanceOf(DyFM_Error);
+      }
+    });
+  });
+
+  describe('| getUserByName', () => {
+    it('| should return user by username', async () => {
+      const result = await provider.getUserByName('test-user');
+
+      expect(result).toBeDefined();
+      expect(result.username).toBe('test-user');
+    });
+
+    it('| should throw error if user not found', async () => {
+      Object.defineProperty(mockGuild.members, 'cache', { value: new Collection(), writable: true });
+      (mockGuild.members as any).find = jasmine.createSpy('find').and.returnValue(null);
+
+      try {
+        await provider.getUserByName('non-existent');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toContain('User not found');
+      }
+    });
+  });
+
+  describe('| getUserMention', () => {
+    it('| should return user mention', () => {
+      const mention = provider.getUserMention('user-123');
+
+      expect(mention).toBe('<@user-123>');
+    });
+  });
+
+  describe('| getRoleByName', () => {
+    it('| should return role from cache if exists', () => {
+      (provider as any).roleCache.set('Test Role', mockRole);
+
+      const result = provider.getRoleByName('Test Role');
+
+      expect(result).toBe(mockRole);
+    });
+
+    it('| should find role in guild and cache it', () => {
+      (provider as any).roleCache.clear();
+
+      const result = provider.getRoleByName('Test Role');
+
+      expect(result).toBe(mockRole);
+      expect((provider as any).roleCache.has('Test Role')).toBe(true);
+    });
+  });
+
+  describe('| getRolePingByName', () => {
+    it('| should return role ping', async () => {
+      const result = await provider.getRolePingByName('Test Role');
+
+      expect(result).toBe('<@&role-123>');
+    });
+
+    it('| should return empty string if role not found', async () => {
+      Object.defineProperty(mockGuild.roles, 'cache', { value: new Collection(), writable: true });
+      (mockGuild.roles as any).find = jasmine.createSpy('find').and.returnValue(null);
+
+      const result = await provider.getRolePingByName('Non-existent');
+
+      expect(result).toBe('');
+    });
+  });
+
+  describe('| getRolePingsByName', () => {
+    it('| should return multiple role pings', async () => {
+      const result = await provider.getRolePingsByName(['Test Role', 'Another Role']);
+
+      expect(result).toContain('<@&role-123>');
+    });
+  });
+
+  describe('| wrapMessage', () => {
+    it('| should wrap Discord message correctly', async () => {
+      const wrapped = await provider.wrapMessage(mockMessage);
+
+      expect(wrapped.id).toBe('message-123');
+      expect(wrapped.content).toBe('Test message');
+      expect(wrapped.authorId).toBe('user-123');
+      expect(wrapped.authorName).toBe('test-user');
+    });
+  });
+
+  describe('| wrapChannel', () => {
+    it('| should wrap Discord channel correctly', async () => {
+      const wrapped = await provider.wrapChannel(mockTextChannel);
+
+      expect(wrapped.id).toBe('channel-123');
+      expect(wrapped.name).toBe('test-channel');
+      expect(wrapped.isTextBased).toBe(true);
+    });
+  });
+
+  describe('| wrapUser', () => {
+    it('| should wrap Discord user correctly', async () => {
+      const wrapped = await provider.wrapUser(mockGuildMember);
+
+      expect(wrapped.id).toBe('user-123');
+      expect(wrapped.username).toBe('test-user');
+      expect(wrapped.displayName).toBe('Test User');
+    });
+  });
+
+  describe('| sendReport', () => {
+    it('| should send report to report channel', async () => {
+      spyOn(provider, 'sendMessageToChannelByName').and.returnValue(provider.wrapMessage(mockMessage));
+
+      const result = await provider.sendReport('Test report');
+
+      expect(provider.sendMessageToChannelByName).toHaveBeenCalledWith('reports', 'Test report');
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('| create_onMessageEventListener', () => {
+    it('| should create message event listener', () => {
+      const handler = jasmine.createSpy('handler');
+
+      provider.create_onMessageEventListener(handler);
+
+      expect(mockClient.on).toHaveBeenCalledWith('messageCreate', jasmine.any(Function));
+    });
+  });
+
+  describe('| create_onErrorEventListener', () => {
+    it('| should create error event listener', () => {
+      const handler = jasmine.createSpy('handler');
+
+      provider.create_onErrorEventListener(handler);
+
+      expect(mockClient.on).toHaveBeenCalledWith('error', jasmine.any(Function));
+    });
+  });
+});
+