@futdevpro/nts-dynamo 1.15.144 → 1.15.150

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

@@ -1,214 +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();
-    });
-  });
-});
-
+
+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();
+    });
+  });
+});
+