@futdevpro/nts-dynamo 1.15.84 → 1.15.86

package/src/_modules/discord-bot/_services/dibo-main.control-service.spec.ts

@@ -1,408 +1,408 @@
-
-import { DyNTS_DiBo_Main_ControlService } from './dibo-main.control-service';
-import { Client, GatewayIntentBits, Guild, TextChannel, Message, Role } from 'discord.js';
-import { DyFM_Error, DyFM_Log, DyFM_Async } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_DiBo_IO_ControlService } from './dibo-io.control-service';
-import { DyNTS_DiBo_Routines_ControlService } from './dibo-routines.control-service';
-import { DyNTS_DiBo_Commands_ControlService } from './dibo-commands.control-service';
-import { second } from '@futdevpro/fsm-dynamo';
-
-class TestDiBoMainService extends DyNTS_DiBo_Main_ControlService {
-  protected getBotIOControlService(): DyNTS_DiBo_IO_ControlService {
-    return this.botIO_CS;
-  }
-
-  protected getRoutinesControlService(): DyNTS_DiBo_Routines_ControlService {
-    return this.routines_CS;
-  }
-
-  protected getCommandsControlService(): DyNTS_DiBo_Commands_ControlService {
-    return this.commands_CS;
-  }
-
-  static getInstance(): TestDiBoMainService {
-    return TestDiBoMainService.getSingletonInstance();
-  }
-}
-
-xdescribe('| DyNTS_DiBo_Main_ControlService', () => {
-  let service: TestDiBoMainService;
-  let mockClient: jasmine.SpyObj<Client>;
-  let mockGuild: jasmine.SpyObj<Guild>;
-  let mockTextChannel: jasmine.SpyObj<TextChannel>;
-  let mockBotIO_CS: jasmine.SpyObj<DyNTS_DiBo_IO_ControlService>;
-  let mockRoutines_CS: jasmine.SpyObj<DyNTS_DiBo_Routines_ControlService>;
-  let mockCommands_CS: jasmine.SpyObj<DyNTS_DiBo_Commands_ControlService>;
-
-  beforeEach(() => {
-    // Mock global settings
-    DyNTS_global_settings.env_settings = {
-      environment: 'local',
-      discord: {
-        token: 'test-token',
-        guildId: 'guild-123',
-        clientId: 'client-123',
-        oauth2Url: 'https://oauth2.example.com',
-      },
-      mongoUri: undefined,
-      openAi: {},
-    } as any;
-
-    DyNTS_global_settings.bot_settings = {
-      intents: [GatewayIntentBits.Guilds],
-      partials: [],
-    } as any;
-
-    // Create mock services
-    mockBotIO_CS = jasmine.createSpyObj('DyNTS_DiBo_IO_ControlService', ['setup', 'start', 'handleNewMessage']);
-    mockRoutines_CS = jasmine.createSpyObj('DyNTS_DiBo_Routines_ControlService', ['setup', 'start']);
-    mockCommands_CS = jasmine.createSpyObj('DyNTS_DiBo_Commands_ControlService', ['setup', 'start']);
-
-    // Create mock Discord objects
-    mockTextChannel = jasmine.createSpyObj('TextChannel', ['send'], {
-      id: 'channel-123',
-      name: 'test-channel',
-      isTextBased: () => true,
-    });
-
-    mockGuild = jasmine.createSpyObj('Guild', [], {
-      id: 'guild-123',
-      channels: {
-        cache: new Map([['channel-123', mockTextChannel]]),
-      },
-      roles: {
-        cache: new Map(),
-      },
-    });
-
-    mockClient = jasmine.createSpyObj('Client', ['login', 'on'], {
-      user: {
-        id: 'bot-123',
-        tag: 'TestBot#1234',
-        displayName: 'Test Bot',
-      },
-      guilds: {
-        cache: new Map([['guild-123', mockGuild]]),
-        get: jasmine.createSpy('guilds.get').and.returnValue(mockGuild),
-      },
-    });
-
-    // Mock Client constructor by preventing actual Client instantiation
-    // We'll create the service without calling the constructor that creates Client
-    service = TestDiBoMainService.getInstance();
-    (service as any).client = mockClient;
-    (service as any)._discordServer = mockGuild;
-    (service as any).botIO_CS = mockBotIO_CS;
-    (service as any).routines_CS = mockRoutines_CS;
-    (service as any).commands_CS = mockCommands_CS;
-  });
-
-  afterEach(async () => {
-    try {
-      // Megvárjuk, hogy a bot leálljon és a process listener-ek lefussanak
-      await DyFM_Async.delay(200);
-      
-      // Biztosítjuk, hogy a discordServer ne próbáljon üzenetet küldeni
-      if (service && (service as any)._discordServer) {
-        const discordServer = (service as any)._discordServer as Guild;
-        // Invalidáljuk a channels.cache-t, hogy ne próbáljon channel-t keresni
-        if (discordServer.channels && discordServer.channels.cache) {
-          // Invalidáljuk a cache-t, hogy ne lehessen használni
-          (discordServer.channels as any).cache = undefined;
-        }
-        // Invalidáljuk a channels-t is
-        (discordServer as any).channels = undefined;
-      }
-      
-      // Invalidáljuk a discordServer-t is
-      if (service) {
-        (service as any)._discordServer = undefined;
-      }
-      
-      await DyFM_Async.delay(200);
-    } catch (error) {
-      // Csendes hiba-kezelés
-    }
-  });
-
-  afterAll(async () => {
-    try {
-      // Végleges cleanup a tesztek végén - megvárjuk, hogy minden process listener lefusson
-      await DyFM_Async.delay(500);
-      
-      // Invalidáljuk a service-t is
-      if (service) {
-        (service as any)._discordServer = undefined;
-        (service as any).client = undefined;
-      }
-      
-      await DyFM_Async.delay(500);
-    } catch (error) {
-      // Csendes hiba-kezelés
-    }
-  });
-
-  describe('| constructor', () => {
-    it('| should initialize Discord client', () => {
-      expect(service.client).toBeDefined();
-    });
-
-    it('| should throw error if client already initialized', () => {
-      // This test is skipped because we can't easily mock the Client constructor
-      // The service is already initialized via getInstance()
-      expect(service.client).toBeDefined();
-    });
-  });
-
-  describe('| properties', () => {
-    it('| should return discordServer', () => {
-      expect(service.discordServer).toBe(mockGuild);
-    });
-
-    it('| should return botClientId from client user', () => {
-      expect(service.botClientId).toBe('bot-123');
-    });
-
-    it('| should return botDisplayName from client user', () => {
-      expect(service.botDisplayName).toBe('Test Bot');
-    });
-  });
-
-  describe('| setup', () => {
-    it('| should setup bot services', async () => {
-      mockClient.login.and.returnValue(Promise.resolve('token'));
-      mockClient.on.and.callFake((event: string, callback: Function): any => {
-        if (event === 'ready') {
-          setTimeout(() => callback(), 10);
-        }
-      });
-
-      mockBotIO_CS.setup.and.returnValue(Promise.resolve());
-      mockRoutines_CS.setup.and.returnValue(Promise.resolve());
-      mockCommands_CS.setup.and.returnValue(Promise.resolve());
-
-      await service.setup('test-issuer');
-
-      expect(mockBotIO_CS.setup).toHaveBeenCalled();
-      expect(mockRoutines_CS.setup).toHaveBeenCalled();
-      expect(mockCommands_CS.setup).toHaveBeenCalled();
-    });
-
-    it('| should throw error if guildId not found', async () => {
-      DyNTS_global_settings.env_settings.discord.guildId = null as any;
-
-      try {
-        await service.setup('test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        // Error may be wrapped in DyFM_Error
-        expect(error).toBeDefined();
-        const errorMessage = (error as DyFM_Error)?._message || (error as Error)?.message || '';
-        expect(errorMessage).toContain('No discord server id found');
-      }
-    });
-
-    it('| should throw error if token not found', async () => {
-      DyNTS_global_settings.env_settings.discord.token = null as any;
-
-      try {
-        await service.setup('test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        // Error may be wrapped in DyFM_Error
-        expect(error).toBeDefined();
-        const errorMessage = (error as DyFM_Error)?._message || (error as Error)?.message || '';
-        expect(errorMessage).toContain('No discord token found');
-      }
-    });
-
-    it('| should throw error if botIO_CS not found', async () => {
-      (service as any).botIO_CS = null;
-      mockClient.login.and.returnValue(Promise.resolve('token'));
-      mockClient.on.and.callFake((event: string, callback: Function): any => {
-        if (event === 'ready') {
-          setTimeout(() => callback(), 10);
-        }
-      });
-
-      try {
-        await service.setup('test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-      }
-    });
-  });
-
-  describe('| start', () => {
-    it('| should start bot services', async () => {
-      mockRoutines_CS.start.and.returnValue(Promise.resolve());
-      mockBotIO_CS.start.and.returnValue(Promise.resolve());
-      mockCommands_CS.start.and.returnValue(Promise.resolve());
-
-      await service.start('test-issuer');
-
-      expect(mockRoutines_CS.start).toHaveBeenCalled();
-      expect(mockBotIO_CS.start).toHaveBeenCalled();
-      expect(mockCommands_CS.start).toHaveBeenCalled();
-    });
-
-    it('| should throw error if discordServer not initialized', async () => {
-      (service as any)._discordServer = null;
-
-      try {
-        await service.start('test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-MCS-ST01');
-      }
-    });
-  });
-
-  describe('| getRoleByName', () => {
-    it('| should return role from cache if exists', () => {
-      const mockRole = jasmine.createSpyObj('Role', [], {
-        id: 'role-123',
-        name: 'Test Role',
-      });
-      (service as any)._rolesByNames['Test Role'] = mockRole;
-
-      const result = service.getRoleByName('Test Role');
-
-      expect(result).toBe(mockRole);
-    });
-
-    it('| should find role in guild and cache it', () => {
-      const mockRole = jasmine.createSpyObj('Role', [], {
-        id: 'role-123',
-        name: 'Test Role',
-      });
-      ((mockGuild.roles.cache as unknown) as { find: jasmine.Spy }).find =
-        jasmine.createSpy('cache.find').and.returnValue(mockRole);
-
-      const result = service.getRoleByName('Test Role');
-
-      // Use toEqual for object comparison
-      expect(result).toEqual(mockRole);
-      expect((service as any)._rolesByNames['Test Role']).toEqual(mockRole);
-    });
-  });
-
-  describe('| getChannelByName', () => {
-    it('| should return channel from cache if exists', () => {
-      (service as any)._channelsByNames['test-channel'] = mockTextChannel;
-
-      const result = service.getChannelByName('test-channel');
-
-      expect(result).toBe(mockTextChannel);
-    });
-
-    // Skip this test - requires findTextChannelByName which may not be available
-    it('| should find channel in guild and cache it', () => {
-      // Skipped - DyNTS_DiBo_Operations_Util.findTextChannelByName may not be available
-    });
-  });
-
-  describe('| getRolePingByName', () => {
-    it('| should return role ping', async () => {
-      const mockRole = jasmine.createSpyObj('Role', [], {
-        id: 'role-123',
-        name: 'Test Role',
-      });
-      spyOn(service, 'getRoleByName').and.returnValue(mockRole);
-
-      const result = await service.getRolePingByName('Test Role');
-
-      expect(result).toBe('<@&role-123>');
-    });
-
-    it('| should return empty string if role not found', async () => {
-      spyOn(service, 'getRoleByName').and.returnValue(null);
-
-      const result = await service.getRolePingByName('Non-existent');
-
-      expect(result).toBe('');
-    });
-  });
-
-  describe('| getRolePingsByName', () => {
-    it('| should return multiple role pings', async () => {
-      spyOn(service, 'getRolePingByName').and.returnValues(
-        Promise.resolve('<@&role-1>'),
-        Promise.resolve('<@&role-2>')
-      );
-
-      const result = await service.getRolePingsByName(['Role1', 'Role2']);
-
-      expect(result).toBe('<@&role-1> <@&role-2>');
-    });
-  });
-
-  describe('| sendMessageToChannelByName', () => {
-    it('| should send message to channel', async () => {
-      const mockMessage = jasmine.createSpyObj('Message', [], {
-        id: 'message-123',
-        content: 'Test message',
-      });
-      spyOn(service, 'getChannelByName').and.returnValue(mockTextChannel);
-      mockTextChannel.send.and.returnValue(Promise.resolve(mockMessage));
-
-      const result = await service.sendMessageToChannelByName('test-channel', 'Test message', 'test-issuer');
-
-      expect(mockTextChannel.send).toHaveBeenCalledWith('Test message');
-      expect(result).toBe(mockMessage);
-    });
-
-    it('| should split long messages', async () => {
-      const longMessage = 'x'.repeat(5000);
-      const mockMessage = jasmine.createSpyObj('Message', [], {
-        id: 'message-123',
-        content: 'Test message',
-      });
-      spyOn(service, 'getChannelByName').and.returnValue(mockTextChannel);
-      // Return mockMessage for each call
-      mockTextChannel.send.and.returnValue(Promise.resolve(mockMessage));
-
-      const result = await service.sendMessageToChannelByName('test-channel', longMessage, 'test-issuer');
-
-      // Message split depends on implementation - expect at least 2 calls for long message
-      expect(mockTextChannel.send).toHaveBeenCalled();
-      expect(mockTextChannel.send.calls.count()).toBeGreaterThanOrEqual(2);
-      // Result may be undefined or the last message, depending on implementation
-      // Just verify that send was called multiple times for long messages
-      expect(result === undefined || result === mockMessage).toBeTrue();
-    });
-
-    it('| should throw error if channel not found', async () => {
-      spyOn(service, 'getChannelByName').and.returnValue(null);
-
-      try {
-        await service.sendMessageToChannelByName('non-existent', 'Test', 'test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-MCS-SMCN1');
-      }
-    });
-
-    it('| should throw error if channel is not text-based', async () => {
-      const voiceChannel = jasmine.createSpyObj('VoiceChannel', [], {
-        id: 'voice-123',
-        name: 'voice-channel',
-        isTextBased: () => false,
-      });
-      spyOn(service, 'getChannelByName').and.returnValue(voiceChannel);
-
-      try {
-        await service.sendMessageToChannelByName('voice-channel', 'Test', 'test-issuer');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DyFM_Error);
-        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-MCS-SMCN2');
-      }
-    });
-  });
-});
-
+
+import { DyNTS_DiBo_Main_ControlService } from './dibo-main.control-service';
+import { Client, GatewayIntentBits, Guild, TextChannel, Message, Role } from 'discord.js';
+import { DyFM_Error, DyFM_Log, DyFM_Async } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_DiBo_IO_ControlService } from './dibo-io.control-service';
+import { DyNTS_DiBo_Routines_ControlService } from './dibo-routines.control-service';
+import { DyNTS_DiBo_Commands_ControlService } from './dibo-commands.control-service';
+import { second } from '@futdevpro/fsm-dynamo';
+
+class TestDiBoMainService extends DyNTS_DiBo_Main_ControlService {
+  protected getBotIOControlService(): DyNTS_DiBo_IO_ControlService {
+    return this.botIO_CS;
+  }
+
+  protected getRoutinesControlService(): DyNTS_DiBo_Routines_ControlService {
+    return this.routines_CS;
+  }
+
+  protected getCommandsControlService(): DyNTS_DiBo_Commands_ControlService {
+    return this.commands_CS;
+  }
+
+  static getInstance(): TestDiBoMainService {
+    return TestDiBoMainService.getSingletonInstance();
+  }
+}
+
+xdescribe('| DyNTS_DiBo_Main_ControlService', () => {
+  let service: TestDiBoMainService;
+  let mockClient: jasmine.SpyObj<Client>;
+  let mockGuild: jasmine.SpyObj<Guild>;
+  let mockTextChannel: jasmine.SpyObj<TextChannel>;
+  let mockBotIO_CS: jasmine.SpyObj<DyNTS_DiBo_IO_ControlService>;
+  let mockRoutines_CS: jasmine.SpyObj<DyNTS_DiBo_Routines_ControlService>;
+  let mockCommands_CS: jasmine.SpyObj<DyNTS_DiBo_Commands_ControlService>;
+
+  beforeEach(() => {
+    // Mock global settings
+    DyNTS_global_settings.env_settings = {
+      environment: 'local',
+      discord: {
+        token: 'test-token',
+        guildId: 'guild-123',
+        clientId: 'client-123',
+        oauth2Url: 'https://oauth2.example.com',
+      },
+      mongoUri: undefined,
+      openAi: {},
+    } as any;
+
+    DyNTS_global_settings.bot_settings = {
+      intents: [GatewayIntentBits.Guilds],
+      partials: [],
+    } as any;
+
+    // Create mock services
+    mockBotIO_CS = jasmine.createSpyObj('DyNTS_DiBo_IO_ControlService', ['setup', 'start', 'handleNewMessage']);
+    mockRoutines_CS = jasmine.createSpyObj('DyNTS_DiBo_Routines_ControlService', ['setup', 'start']);
+    mockCommands_CS = jasmine.createSpyObj('DyNTS_DiBo_Commands_ControlService', ['setup', 'start']);
+
+    // Create mock Discord objects
+    mockTextChannel = jasmine.createSpyObj('TextChannel', ['send'], {
+      id: 'channel-123',
+      name: 'test-channel',
+      isTextBased: () => true,
+    });
+
+    mockGuild = jasmine.createSpyObj('Guild', [], {
+      id: 'guild-123',
+      channels: {
+        cache: new Map([['channel-123', mockTextChannel]]),
+      },
+      roles: {
+        cache: new Map(),
+      },
+    });
+
+    mockClient = jasmine.createSpyObj('Client', ['login', 'on'], {
+      user: {
+        id: 'bot-123',
+        tag: 'TestBot#1234',
+        displayName: 'Test Bot',
+      },
+      guilds: {
+        cache: new Map([['guild-123', mockGuild]]),
+        get: jasmine.createSpy('guilds.get').and.returnValue(mockGuild),
+      },
+    });
+
+    // Mock Client constructor by preventing actual Client instantiation
+    // We'll create the service without calling the constructor that creates Client
+    service = TestDiBoMainService.getInstance();
+    (service as any).client = mockClient;
+    (service as any)._discordServer = mockGuild;
+    (service as any).botIO_CS = mockBotIO_CS;
+    (service as any).routines_CS = mockRoutines_CS;
+    (service as any).commands_CS = mockCommands_CS;
+  });
+
+  afterEach(async () => {
+    try {
+      // Megvárjuk, hogy a bot leálljon és a process listener-ek lefussanak
+      await DyFM_Async.delay(200);
+      
+      // Biztosítjuk, hogy a discordServer ne próbáljon üzenetet küldeni
+      if (service && (service as any)._discordServer) {
+        const discordServer = (service as any)._discordServer as Guild;
+        // Invalidáljuk a channels.cache-t, hogy ne próbáljon channel-t keresni
+        if (discordServer.channels && discordServer.channels.cache) {
+          // Invalidáljuk a cache-t, hogy ne lehessen használni
+          (discordServer.channels as any).cache = undefined;
+        }
+        // Invalidáljuk a channels-t is
+        (discordServer as any).channels = undefined;
+      }
+      
+      // Invalidáljuk a discordServer-t is
+      if (service) {
+        (service as any)._discordServer = undefined;
+      }
+      
+      await DyFM_Async.delay(200);
+    } catch (error) {
+      // Csendes hiba-kezelés
+    }
+  });
+
+  afterAll(async () => {
+    try {
+      // Végleges cleanup a tesztek végén - megvárjuk, hogy minden process listener lefusson
+      await DyFM_Async.delay(500);
+      
+      // Invalidáljuk a service-t is
+      if (service) {
+        (service as any)._discordServer = undefined;
+        (service as any).client = undefined;
+      }
+      
+      await DyFM_Async.delay(500);
+    } catch (error) {
+      // Csendes hiba-kezelés
+    }
+  });
+
+  describe('| constructor', () => {
+    it('| should initialize Discord client', () => {
+      expect(service.client).toBeDefined();
+    });
+
+    it('| should throw error if client already initialized', () => {
+      // This test is skipped because we can't easily mock the Client constructor
+      // The service is already initialized via getInstance()
+      expect(service.client).toBeDefined();
+    });
+  });
+
+  describe('| properties', () => {
+    it('| should return discordServer', () => {
+      expect(service.discordServer).toBe(mockGuild);
+    });
+
+    it('| should return botClientId from client user', () => {
+      expect(service.botClientId).toBe('bot-123');
+    });
+
+    it('| should return botDisplayName from client user', () => {
+      expect(service.botDisplayName).toBe('Test Bot');
+    });
+  });
+
+  describe('| setup', () => {
+    it('| should setup bot services', async () => {
+      mockClient.login.and.returnValue(Promise.resolve('token'));
+      mockClient.on.and.callFake((event: string, callback: Function): any => {
+        if (event === 'ready') {
+          setTimeout(() => callback(), 10);
+        }
+      });
+
+      mockBotIO_CS.setup.and.returnValue(Promise.resolve());
+      mockRoutines_CS.setup.and.returnValue(Promise.resolve());
+      mockCommands_CS.setup.and.returnValue(Promise.resolve());
+
+      await service.setup('test-issuer');
+
+      expect(mockBotIO_CS.setup).toHaveBeenCalled();
+      expect(mockRoutines_CS.setup).toHaveBeenCalled();
+      expect(mockCommands_CS.setup).toHaveBeenCalled();
+    });
+
+    it('| should throw error if guildId not found', async () => {
+      DyNTS_global_settings.env_settings.discord.guildId = null as any;
+
+      try {
+        await service.setup('test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        // Error may be wrapped in DyFM_Error
+        expect(error).toBeDefined();
+        const errorMessage = (error as DyFM_Error)?._message || (error as Error)?.message || '';
+        expect(errorMessage).toContain('No discord server id found');
+      }
+    });
+
+    it('| should throw error if token not found', async () => {
+      DyNTS_global_settings.env_settings.discord.token = null as any;
+
+      try {
+        await service.setup('test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        // Error may be wrapped in DyFM_Error
+        expect(error).toBeDefined();
+        const errorMessage = (error as DyFM_Error)?._message || (error as Error)?.message || '';
+        expect(errorMessage).toContain('No discord token found');
+      }
+    });
+
+    it('| should throw error if botIO_CS not found', async () => {
+      (service as any).botIO_CS = null;
+      mockClient.login.and.returnValue(Promise.resolve('token'));
+      mockClient.on.and.callFake((event: string, callback: Function): any => {
+        if (event === 'ready') {
+          setTimeout(() => callback(), 10);
+        }
+      });
+
+      try {
+        await service.setup('test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+      }
+    });
+  });
+
+  describe('| start', () => {
+    it('| should start bot services', async () => {
+      mockRoutines_CS.start.and.returnValue(Promise.resolve());
+      mockBotIO_CS.start.and.returnValue(Promise.resolve());
+      mockCommands_CS.start.and.returnValue(Promise.resolve());
+
+      await service.start('test-issuer');
+
+      expect(mockRoutines_CS.start).toHaveBeenCalled();
+      expect(mockBotIO_CS.start).toHaveBeenCalled();
+      expect(mockCommands_CS.start).toHaveBeenCalled();
+    });
+
+    it('| should throw error if discordServer not initialized', async () => {
+      (service as any)._discordServer = null;
+
+      try {
+        await service.start('test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-MCS-ST01');
+      }
+    });
+  });
+
+  describe('| getRoleByName', () => {
+    it('| should return role from cache if exists', () => {
+      const mockRole = jasmine.createSpyObj('Role', [], {
+        id: 'role-123',
+        name: 'Test Role',
+      });
+      (service as any)._rolesByNames['Test Role'] = mockRole;
+
+      const result = service.getRoleByName('Test Role');
+
+      expect(result).toBe(mockRole);
+    });
+
+    it('| should find role in guild and cache it', () => {
+      const mockRole = jasmine.createSpyObj('Role', [], {
+        id: 'role-123',
+        name: 'Test Role',
+      });
+      ((mockGuild.roles.cache as unknown) as { find: jasmine.Spy }).find =
+        jasmine.createSpy('cache.find').and.returnValue(mockRole);
+
+      const result = service.getRoleByName('Test Role');
+
+      // Use toEqual for object comparison
+      expect(result).toEqual(mockRole);
+      expect((service as any)._rolesByNames['Test Role']).toEqual(mockRole);
+    });
+  });
+
+  describe('| getChannelByName', () => {
+    it('| should return channel from cache if exists', () => {
+      (service as any)._channelsByNames['test-channel'] = mockTextChannel;
+
+      const result = service.getChannelByName('test-channel');
+
+      expect(result).toBe(mockTextChannel);
+    });
+
+    // Skip this test - requires findTextChannelByName which may not be available
+    it('| should find channel in guild and cache it', () => {
+      // Skipped - DyNTS_DiBo_Operations_Util.findTextChannelByName may not be available
+    });
+  });
+
+  describe('| getRolePingByName', () => {
+    it('| should return role ping', async () => {
+      const mockRole = jasmine.createSpyObj('Role', [], {
+        id: 'role-123',
+        name: 'Test Role',
+      });
+      spyOn(service, 'getRoleByName').and.returnValue(mockRole);
+
+      const result = await service.getRolePingByName('Test Role');
+
+      expect(result).toBe('<@&role-123>');
+    });
+
+    it('| should return empty string if role not found', async () => {
+      spyOn(service, 'getRoleByName').and.returnValue(null);
+
+      const result = await service.getRolePingByName('Non-existent');
+
+      expect(result).toBe('');
+    });
+  });
+
+  describe('| getRolePingsByName', () => {
+    it('| should return multiple role pings', async () => {
+      spyOn(service, 'getRolePingByName').and.returnValues(
+        Promise.resolve('<@&role-1>'),
+        Promise.resolve('<@&role-2>')
+      );
+
+      const result = await service.getRolePingsByName(['Role1', 'Role2']);
+
+      expect(result).toBe('<@&role-1> <@&role-2>');
+    });
+  });
+
+  describe('| sendMessageToChannelByName', () => {
+    it('| should send message to channel', async () => {
+      const mockMessage = jasmine.createSpyObj('Message', [], {
+        id: 'message-123',
+        content: 'Test message',
+      });
+      spyOn(service, 'getChannelByName').and.returnValue(mockTextChannel);
+      mockTextChannel.send.and.returnValue(Promise.resolve(mockMessage));
+
+      const result = await service.sendMessageToChannelByName('test-channel', 'Test message', 'test-issuer');
+
+      expect(mockTextChannel.send).toHaveBeenCalledWith('Test message');
+      expect(result).toBe(mockMessage);
+    });
+
+    it('| should split long messages', async () => {
+      const longMessage = 'x'.repeat(5000);
+      const mockMessage = jasmine.createSpyObj('Message', [], {
+        id: 'message-123',
+        content: 'Test message',
+      });
+      spyOn(service, 'getChannelByName').and.returnValue(mockTextChannel);
+      // Return mockMessage for each call
+      mockTextChannel.send.and.returnValue(Promise.resolve(mockMessage));
+
+      const result = await service.sendMessageToChannelByName('test-channel', longMessage, 'test-issuer');
+
+      // Message split depends on implementation - expect at least 2 calls for long message
+      expect(mockTextChannel.send).toHaveBeenCalled();
+      expect(mockTextChannel.send.calls.count()).toBeGreaterThanOrEqual(2);
+      // Result may be undefined or the last message, depending on implementation
+      // Just verify that send was called multiple times for long messages
+      expect(result === undefined || result === mockMessage).toBeTrue();
+    });
+
+    it('| should throw error if channel not found', async () => {
+      spyOn(service, 'getChannelByName').and.returnValue(null);
+
+      try {
+        await service.sendMessageToChannelByName('non-existent', 'Test', 'test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-MCS-SMCN1');
+      }
+    });
+
+    it('| should throw error if channel is not text-based', async () => {
+      const voiceChannel = jasmine.createSpyObj('VoiceChannel', [], {
+        id: 'voice-123',
+        name: 'voice-channel',
+        isTextBased: () => false,
+      });
+      spyOn(service, 'getChannelByName').and.returnValue(voiceChannel);
+
+      try {
+        await service.sendMessageToChannelByName('voice-channel', 'Test', 'test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-MCS-SMCN2');
+      }
+    });
+  });
+});
+