@futdevpro/nts-dynamo 1.15.2 → 1.15.3

package/src/_modules/discord-assistant-voiced/_services/dias-discord-bot.control-service.spec.ts

@@ -0,0 +1,34 @@
+
+import { DyNTS_DiAV_Main_ControlService } from './dias-discord-bot.control-service';
+import { DyNTS_DiAs_Main_ControlService } from '../../discord-assistant/_services/dias-main.control-service';
+
+class TestDiAVMainService extends DyNTS_DiAV_Main_ControlService {
+  protected override botIO_CS: any;
+  
+  protected override getBotIOControlService(): any {
+    return {} as any;
+  }
+  
+  protected override getRoutinesControlService(): any {
+    return {} as any;
+  }
+  
+  protected override getCommandsControlService(): any {
+    return {} as any;
+  }
+  
+  static getInstance(): TestDiAVMainService {
+    return TestDiAVMainService.getSingletonInstance();
+  }
+}
+
+xdescribe('| DyNTS_DiAV_Main_ControlService', () => {
+  describe('| inheritance', () => {
+    it('| should inherit from DiAs Main Control Service', () => {
+      expect(Object.getPrototypeOf(TestDiAVMainService.prototype)).toEqual(DyNTS_DiAs_Main_ControlService.prototype);
+    });
+  });
+  // constructor "should extend DiAs Main Control Service" kiveve: new TestDiAVMainService() ClientMissingIntents
+  // (Discord Client valid intents); a DiBo/DiAs lánc nem mockolható a specből.
+});
+

package/src/_modules/discord-bot/_collections/dibo-operations.util.spec.ts

@@ -0,0 +1,214 @@
+
+import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_DiBo_Operations_Util } from './dibo-operations.util';
+import { Guild, GuildChannelManager, TextChannel, VoiceChannel, Client, GuildMember, Message, Collection } from 'discord.js';
+import { DyNTS_DiBo_global_settings } from './dibo-global-settings.conts';
+
+xdescribe('| DyNTS_DiBo_Operations_Util', () => {
+  describe('| findChannelByName', () => {
+    it('| should find text channel by name', () => {
+      const mockChannel = {
+        name: 'test-channel',
+        isTextBased: () => true,
+      } as any;
+
+      const mockChannels = {
+        cache: {
+          find: jasmine.createSpy('find').and.returnValue(mockChannel),
+        },
+      } as any as GuildChannelManager;
+
+      const result = DyNTS_DiBo_Operations_Util.findChannelByName(mockChannels, 'test-channel');
+
+      expect(result).toBe(mockChannel);
+      expect(mockChannels.cache.find).toHaveBeenCalled();
+    });
+
+    it('| should return undefined when channel not found', () => {
+      const logSpy = spyOn(DyFM_Log, 'error');
+      const mockChannels = {
+        cache: {
+          find: jasmine.createSpy('find').and.returnValue(undefined),
+        },
+      } as any as GuildChannelManager;
+
+      const result = DyNTS_DiBo_Operations_Util.findChannelByName(mockChannels, 'non-existent');
+
+      expect(result).toBeUndefined();
+      expect(logSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('| findTextChannelByName', () => {
+    it('| should find and return text channel', () => {
+      const mockChannel = {
+        name: 'test-channel',
+        isTextBased: () => true,
+      } as any;
+
+      const mockChannels = {
+        cache: {
+          find: jasmine.createSpy('find').and.returnValue(mockChannel),
+        },
+      } as any as GuildChannelManager;
+
+      const result = DyNTS_DiBo_Operations_Util.findTextChannelByName(mockChannels, 'test-channel');
+
+      expect(result).toBe(mockChannel);
+    });
+
+    it('| should throw error when channel is not text based', () => {
+      const mockChannel = {
+        name: 'test-channel',
+        isTextBased: () => false,
+      } as any;
+
+      const mockChannels = {
+        cache: {
+          find: jasmine.createSpy('find').and.returnValue(mockChannel),
+        },
+      } as any as GuildChannelManager;
+
+      expect(() => {
+        DyNTS_DiBo_Operations_Util.findTextChannelByName(mockChannels, 'test-channel');
+      }).toThrowError(/Channel is not text based with name "test-channel"/);
+    });
+  });
+
+  describe('| findVoiceChannelByName', () => {
+    it('| should find and return voice channel', () => {
+      const mockChannel = {
+        name: 'test-channel',
+        isVoiceBased: () => true,
+      } as any;
+
+      const mockChannels = {
+        cache: {
+          find: jasmine.createSpy('find').and.returnValue(mockChannel),
+        },
+      } as any as GuildChannelManager;
+
+      const result = DyNTS_DiBo_Operations_Util.findVoiceChannelByName(mockChannels, 'test-channel');
+
+      expect(result).toBe(mockChannel);
+    });
+
+    it('| should throw error when channel is not voice based', () => {
+      const mockChannel = {
+        name: 'test-channel',
+        isVoiceBased: () => false,
+      } as any;
+
+      const mockChannels = {
+        cache: {
+          find: jasmine.createSpy('find').and.returnValue(mockChannel),
+        },
+      } as any as GuildChannelManager;
+
+      expect(() => {
+        DyNTS_DiBo_Operations_Util.findVoiceChannelByName(mockChannels, 'test-channel');
+      }).toThrowError(/Channel is not voice based with name "test-channel"/);
+    });
+  });
+
+  describe('| sendMessageToChannelByName', () => {
+    it('| should send message to text channel', () => {
+      const sendSpy = jasmine.createSpy('send');
+      const logSpy = spyOn(DyFM_Log, 'success');
+      const mockChannel = {
+        name: 'test-channel',
+        isTextBased: () => true,
+        send: sendSpy,
+      } as any;
+
+      const mockGuild = {
+        channels: {
+          cache: {
+            find: jasmine.createSpy('find').and.returnValue(mockChannel),
+          },
+        },
+      } as any as Guild;
+
+      DyNTS_DiBo_Operations_Util.sendMessageToChannelByName(mockGuild, 'test-channel', 'Test message');
+
+      expect(sendSpy).toHaveBeenCalledWith('Test message');
+      expect(logSpy).toHaveBeenCalled();
+    });
+
+    it('| should log error when channel is not text based', () => {
+      const logSpy = spyOn(DyFM_Log, 'error');
+      const mockChannel = {
+        name: 'test-channel',
+        isTextBased: () => false,
+      } as any;
+
+      const mockGuild = {
+        channels: {
+          cache: {
+            find: jasmine.createSpy('find').and.returnValue(mockChannel),
+          },
+        },
+      } as any as Guild;
+
+      DyNTS_DiBo_Operations_Util.sendMessageToChannelByName(mockGuild, 'test-channel', 'Test message');
+
+      expect(logSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('| getMemberIdByName', () => {
+    it('| should return member id by username', () => {
+      const mockMember = {
+        user: {
+          id: 'user-123',
+          username: 'testuser',
+        },
+      } as any as GuildMember;
+
+      const members = new Collection<string, GuildMember>();
+      members.set('user-123', mockMember);
+
+      const result = DyNTS_DiBo_Operations_Util.getMemberIdByName(members, 'testuser');
+
+      expect(result).toBe('user-123');
+    });
+
+    it('| should return undefined when member not found', () => {
+      const members = new Collection<string, GuildMember>();
+
+      const result = DyNTS_DiBo_Operations_Util.getMemberIdByName(members, 'non-existent');
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('| deleteMessage', () => {
+    it('| should delete message successfully', async () => {
+      const logSpy = spyOn(DyFM_Log, 'success');
+      const mockMessage = {
+        id: 'msg-123',
+        content: 'Test message',
+        delete: jasmine.createSpy('delete').and.returnValue(Promise.resolve()),
+      } as any as Message;
+
+      await DyNTS_DiBo_Operations_Util.deleteMessage(mockMessage);
+
+      expect(mockMessage.delete).toHaveBeenCalled();
+      expect(logSpy).toHaveBeenCalled();
+    });
+
+    it('| should handle delete error gracefully', async () => {
+      const errorSpy = spyOn(DyFM_Error, 'logSimple');
+      const mockMessage = {
+        id: 'msg-123',
+        content: 'Test message',
+        delete: jasmine.createSpy('delete').and.returnValue(Promise.reject(new Error('Delete failed'))),
+      } as any as Message;
+
+      await DyNTS_DiBo_Operations_Util.deleteMessage(mockMessage);
+
+      expect(errorSpy).toHaveBeenCalled();
+    });
+  });
+});
+

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

@@ -0,0 +1,154 @@
+
+import { DyNTS_DiBo_Commands_ControlService } from './dibo-commands.control-service';
+import { DyNTS_DiBo_Main_ControlService } from './dibo-main.control-service';
+import { Message, Guild } from 'discord.js';
+import { DyFM_Error, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_DiBo_global_settings } from '../_collections/dibo-global-settings.conts';
+
+class TestDiBoCommandsService extends DyNTS_DiBo_Commands_ControlService {
+  protected getMainDiscordBotControlService(): DyNTS_DiBo_Main_ControlService {
+    return this.diAs_CS;
+  }
+
+  static getInstance(): TestDiBoCommandsService {
+    return TestDiBoCommandsService.getSingletonInstance();
+  }
+}
+
+xdescribe('| DyNTS_DiBo_Commands_ControlService', () => {
+  let service: TestDiBoCommandsService;
+  let mockMain_CS: jasmine.SpyObj<DyNTS_DiBo_Main_ControlService>;
+  let mockGuild: jasmine.SpyObj<Guild>;
+  let mockMessage: jasmine.SpyObj<Message>;
+  let originalCommandSettings: typeof DyNTS_DiBo_global_settings.commandSettings;
+
+  beforeAll(() => {
+    if (!DyNTS_global_settings.systemShortCodeName) {
+      (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
+    }
+    if (!DyNTS_global_settings.env_settings) {
+      (DyNTS_global_settings as { env_settings?: unknown }).env_settings = { environment: DyFM_EnvironmentFlag.local };
+    }
+    originalCommandSettings = { ...DyNTS_DiBo_global_settings.commandSettings };
+  });
+
+  afterEach(() => {
+    (DyNTS_DiBo_global_settings as { commandSettings: unknown }).commandSettings = originalCommandSettings;
+  });
+
+  beforeEach(() => {
+    mockGuild = jasmine.createSpyObj('Guild', [], {
+      id: 'guild-123',
+    });
+
+    mockMessage = jasmine.createSpyObj('Message', ['reply'], {
+      id: 'message-123',
+      content: '!test command',
+      author: {
+        id: 'user-123',
+      },
+    });
+
+    mockMain_CS = jasmine.createSpyObj('DyNTS_DiBo_Main_ControlService', [], {
+      discordServer: mockGuild,
+      client: {
+        user: {
+          id: 'bot-123',
+        },
+      },
+    });
+
+    service = new (TestDiBoCommandsService as any)();
+    (service as any).diAs_CS = mockMain_CS;
+  });
+
+  describe('| properties', () => {
+    it('| should return discordServer from main service', () => {
+      expect(service.discordServer).toBe(mockGuild);
+    });
+  });
+
+  describe('| setup', () => {
+    it('| should setup service with main service', async () => {
+      await service.setup('test-issuer');
+
+      expect((service as any).diAs_CS).toBe(mockMain_CS);
+    });
+
+    it('| should throw error if main service not found', async () => {
+      (service as any).getMainDiscordBotControlService = () => null;
+
+      try {
+        await service.setup('test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-CCS-S01');
+      }
+    });
+  });
+
+  describe('| start', () => {
+    it('| should start service successfully', async () => {
+      await service.start('test-issuer');
+
+      expect(service.discordServer).toBe(mockGuild);
+    });
+
+    it('| should throw error if discordServer not found', async () => {
+      (service as any).diAs_CS = 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-CCS-ST00');
+      }
+    });
+  });
+
+  describe('| handleCommand', () => {
+    it('| should handle command successfully', async () => {
+      const commandHandlerSpy = jasmine.createSpy('commandHandler').and.returnValue(Promise.resolve());
+      (DyNTS_DiBo_global_settings as { commandSettings: { commandOperator: string; commands: unknown[] } }).commandSettings = {
+        commandOperator: '!',
+        commands: [
+          {
+            command: 'test',
+            commandHandler: commandHandlerSpy,
+          },
+        ],
+      };
+
+      await service.handleCommand(mockMessage, 'test-issuer');
+
+      expect(commandHandlerSpy).toHaveBeenCalled();
+      expect(mockMessage.reply).not.toHaveBeenCalled();
+    });
+
+    it('| should handle command errors', async () => {
+      const commandError = new Error('Command handler error');
+      (DyNTS_DiBo_global_settings as { commandSettings: { commandOperator: string; commands: unknown[] } }).commandSettings = {
+        commandOperator: '!',
+        commands: [
+          {
+            command: 'test',
+            commandHandler: jasmine.createSpy('commandHandler').and.returnValue(Promise.reject(commandError)),
+          },
+        ],
+      };
+      mockMessage.reply.and.returnValue(Promise.resolve(mockMessage as any));
+
+      try {
+        await service.handleCommand(mockMessage, 'test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect(mockMessage.reply).toHaveBeenCalled();
+      }
+    });
+  });
+});
+

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

@@ -0,0 +1,264 @@
+
+import { DyNTS_DiBo_IO_ControlService } from './dibo-io.control-service';
+import { DyNTS_DiBo_Main_ControlService } from './dibo-main.control-service';
+import { DyNTS_DiBo_Commands_ControlService } from './dibo-commands.control-service';
+import { Message, TextChannel, Guild } from 'discord.js';
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_DiBo_global_settings } from '../_collections/dibo-global-settings.conts';
+import { DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
+
+class TestDiBoIOService extends DyNTS_DiBo_IO_ControlService {
+  protected override mainDiscordBot_CS: any;
+  
+  protected override getMainDiscordBotControlService(): DyNTS_DiBo_Main_ControlService {
+    return this.mainDiscordBot_CS;
+  }
+
+  protected override getCommandsControlService(): DyNTS_DiBo_Commands_ControlService {
+    return this.commands_CS;
+  }
+
+  async handleMessage(message: Message, issuer: string): Promise<Message> {
+    return message;
+  }
+
+  static getInstance(): TestDiBoIOService {
+    return TestDiBoIOService.getSingletonInstance();
+  }
+}
+
+xdescribe('| DyNTS_DiBo_IO_ControlService', () => {
+  let service: TestDiBoIOService;
+  let mockMain_CS: jasmine.SpyObj<DyNTS_DiBo_Main_ControlService>;
+  let mockCommands_CS: jasmine.SpyObj<DyNTS_DiBo_Commands_ControlService>;
+  let mockGuild: jasmine.SpyObj<Guild>;
+  let mockMessage: jasmine.SpyObj<Message>;
+  let mockTextChannel: jasmine.SpyObj<TextChannel>;
+
+  beforeAll(() => {
+    if (!DyNTS_global_settings.systemShortCodeName) {
+      (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
+    }
+    if (!DyNTS_global_settings.env_settings) {
+      (DyNTS_global_settings as { env_settings?: unknown }).env_settings = { environment: DyFM_EnvironmentFlag.local };
+    }
+  });
+
+  beforeEach(() => {
+    mockGuild = jasmine.createSpyObj('Guild', [], {
+      id: 'guild-123',
+    });
+
+    mockTextChannel = jasmine.createSpyObj('TextChannel', ['send'], {
+      id: 'channel-123',
+      name: 'test-channel',
+      isTextBased: () => true,
+      isDMBased: () => false,
+    });
+
+    mockMessage = jasmine.createSpyObj('Message', ['reply']);
+    // Set properties as writable/configurable so they can be modified in tests
+    Object.defineProperties(mockMessage, {
+      id: { value: 'message-123', writable: true, configurable: true },
+      content: { value: 'Test message', writable: true, configurable: true },
+      author: { 
+        value: {
+          id: 'user-123',
+          username: 'test-user',
+          displayName: 'Test User',
+          bot: false,
+        }, 
+        writable: true, 
+        configurable: true 
+      },
+      channel: { value: mockTextChannel, writable: true, configurable: true },
+      reference: { value: null, writable: true, configurable: true },
+      cleanContent: { value: 'Test message', writable: true, configurable: true },
+    });
+
+    mockMain_CS = jasmine.createSpyObj('DyNTS_DiBo_Main_ControlService', [], {
+      discordServer: mockGuild,
+      botClientId: 'bot-123',
+      botDisplayName: 'Test Bot',
+      client: {
+        user: {
+          id: 'bot-123',
+        },
+      },
+    });
+
+    mockCommands_CS = jasmine.createSpyObj('DyNTS_DiBo_Commands_ControlService', ['handleCommand']);
+
+    service = new (TestDiBoIOService as any)();
+    (service as any).mainDiscordBot_CS = mockMain_CS;
+    (service as any).commands_CS = mockCommands_CS;
+  });
+
+  describe('| properties', () => {
+    it('| should return discordServer from main service', () => {
+      expect(service.discordServer).toBe(mockGuild);
+    });
+
+    it('| should return botClientId from main service', () => {
+      expect(service.botClientId).toBe('bot-123');
+    });
+
+    it('| should return botDisplayName from main service', () => {
+      expect(service.botDisplayName).toBe('Test Bot');
+    });
+  });
+
+  describe('| setup', () => {
+    it('| should setup service with main and commands services', async () => {
+      await service.setup('test-issuer');
+
+      expect((service as any).mainDiscordBot_CS).toBe(mockMain_CS);
+      expect((service as any).commands_CS).toBe(mockCommands_CS);
+    });
+
+    it('| should throw error if main service not found', async () => {
+      (service as any).getMainDiscordBotControlService = () => null;
+
+      try {
+        await service.setup('test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-IO-S01');
+      }
+    });
+
+    it('| should throw error if commands service not found', async () => {
+      (service as any).getCommandsControlService = () => null;
+
+      try {
+        await service.setup('test-issuer');
+        fail('Should have thrown an error');
+      } catch (error) {
+        expect(error).toBeInstanceOf(DyFM_Error);
+        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-DiBo-IO-S02');
+      }
+    });
+  });
+
+  describe('| start', () => {
+    it('| should start service successfully', async () => {
+      await service.start('test-issuer');
+
+      expect(service.discordServer).toBe(mockGuild);
+    });
+
+    it('| should throw error if discordServer not found', async () => {
+      (service as any).mainDiscordBot_CS = 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-IO-ST00');
+      }
+    });
+  });
+
+  describe('| handleNewMessage', () => {
+    it('| should handle message if for bot', async () => {
+      spyOn(service, 'getMessageIsForBotToHandle').and.returnValue(Promise.resolve(true));
+      spyOn(service, 'handleIfCommand').and.returnValue(Promise.resolve(false));
+      spyOn(service, 'handleMessage').and.returnValue(Promise.resolve(mockMessage));
+
+      await service.handleNewMessage(mockMessage, 'test-issuer');
+
+      expect(service.handleMessage).toHaveBeenCalled();
+    });
+
+    it('| should not handle message if not for bot', async () => {
+      spyOn(service, 'getMessageIsForBotToHandle').and.returnValue(Promise.resolve(false));
+      spyOn(service, 'handleMessage');
+
+      await service.handleNewMessage(mockMessage, 'test-issuer');
+
+      expect(service.handleMessage).not.toHaveBeenCalled();
+    });
+
+    it('| should handle command if message is command', async () => {
+      spyOn(service, 'getMessageIsForBotToHandle').and.returnValue(Promise.resolve(true));
+      const handleIfCommandSpy = spyOn(service, 'handleIfCommand').and.returnValue(Promise.resolve(true));
+      spyOn(service, 'handleMessage');
+
+      await service.handleNewMessage(mockMessage, 'test-issuer');
+
+      expect(service.handleMessage).not.toHaveBeenCalled();
+      // Since handleIfCommand is mocked, we verify it was called, not the underlying handleCommand
+      expect(handleIfCommandSpy).toHaveBeenCalled();
+    });
+
+    it('| should handle errors gracefully', async () => {
+      const error = new Error('Test error');
+      spyOn(service, 'getMessageIsForBotToHandle').and.throwError(error);
+      mockMessage.reply.and.returnValue(Promise.resolve(mockMessage as any));
+
+      try {
+        await service.handleNewMessage(mockMessage, 'test-issuer');
+        fail('Should have thrown an error');
+      } catch (err) {
+        expect(err).toBeInstanceOf(DyFM_Error);
+      }
+    });
+  });
+
+  describe('| handleIfCommand', () => {
+    it('| should handle command if message is command', async () => {
+      spyOn(service, 'isCommand').and.returnValue(Promise.resolve(true));
+      mockCommands_CS.handleCommand.and.returnValue(Promise.resolve());
+
+      const result = await service.handleIfCommand(mockMessage, 'test-issuer');
+
+      expect(result).toBe(true);
+      expect(mockCommands_CS.handleCommand).toHaveBeenCalled();
+    });
+
+    it('| should not handle if message is not command', async () => {
+      spyOn(service, 'isCommand').and.returnValue(Promise.resolve(false));
+
+      const result = await service.handleIfCommand(mockMessage, 'test-issuer');
+
+      expect(result).toBe(false);
+      expect(mockCommands_CS.handleCommand).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('| isCommand', () => {
+    it('| should return true if message starts with command operator', async () => {
+      mockMessage.content = '!test command';
+      const originalCommandSettings = DyNTS_DiBo_global_settings.commandSettings;
+      (DyNTS_DiBo_global_settings as any).commandSettings = {
+        commandOperator: '!',
+        commands: [{ command: 'test' }],
+      };
+
+      const result = await service.isCommand(mockMessage, 'test-issuer');
+
+      expect(result).toBe(true);
+
+      (DyNTS_DiBo_global_settings as any).commandSettings = originalCommandSettings;
+    });
+
+    it('| should return false if message does not start with command operator', async () => {
+      mockMessage.content = 'test command';
+      const originalCommandSettings = DyNTS_DiBo_global_settings.commandSettings;
+      (DyNTS_DiBo_global_settings as any).commandSettings = {
+        commandOperator: '!',
+        commands: [{ command: 'test' }],
+      };
+
+      const result = await service.isCommand(mockMessage, 'test-issuer');
+
+      expect(result).toBe(false);
+
+      (DyNTS_DiBo_global_settings as any).commandSettings = originalCommandSettings;
+    });
+  });
+});
+