@futdevpro/nts-dynamo 1.15.157 → 1.15.163

package/src/_modules/bot/_modules/teams-bot/_services/teb-messaging-provider.control-service.spec.ts

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

package/src/_modules/bot/_modules/teams-bot/_services/teb-messaging-provider.control-service.ts

@@ -1,197 +0,0 @@
-import { DyFM_AnyError, DyFM_Error } from '@futdevpro/fsm-dynamo';
-import { DyFM_Msg_Provider_Type } from '@futdevpro/fsm-dynamo/messaging';
-
-import { 
-  DyNTS_Bot_MessagingProvider_ServiceBase, DyNTS_Bot_MessagingProvider_Config, Teams_MessagingProviderConfig 
-} from '../../../_services/bot-messaging-provider.service-base';
-import { DyNTS_Bot_ChannelWrapper } from '../../../_models/bot-channel-wrapper.interface';
-import { DyNTS_Bot_LastMessageDate } from '../../../_models/bot-last-message-date.interface';
-import { DyNTS_Bot_LastMentionDate } from '../../../_models/bot-last-mention-date.interface';
-import { DyNTS_Bot_MessageWrapper } from '../../../_models/bot-message-wrapper.interface';
-import { DyNTS_Bot_UserWrapper } from '../../../_models/bot-user-wrapper.interface';
-
-// Stub types for Teams - will be replaced with actual Teams SDK types when implemented
-type TeamsChannel = any;
-type TeamsMessage = any;
-type TeamsUser = any;
-
-export class DyNTS_TeB_MessagingProvider_ControlService extends DyNTS_Bot_MessagingProvider_ServiceBase<
-  TeamsChannel,
-  TeamsMessage,
-  TeamsUser,
-  Teams_MessagingProviderConfig,
-  any
-> {
-  readonly name = 'teams';
-  readonly type = DyFM_Msg_Provider_Type.teams;
-
-  get botId(): string {
-    return 'teams-bot-stub';
-  }
-
-  get botDisplayName(): string {
-    return 'Teams Bot (Stub)';
-  }
-  
-  override readonly config: Teams_MessagingProviderConfig;
-
-  /* override protected readonly channelCache: Map<string, TeamsChannel> = new Map();
-  override protected readonly roleCache: Map<string, any> = new Map(); */
-
-  constructor(setConfig: Teams_MessagingProviderConfig) {
-    super();
-    this.config = setConfig;
-  }
-
-  async setup(issuer: string): Promise<void> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async start(issuer: string): Promise<void> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  // Channel operations
-  async getChannelByName(name: string): Promise<DyNTS_Bot_ChannelWrapper<TeamsChannel>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async getChannelById(id: string): Promise<DyNTS_Bot_ChannelWrapper<TeamsChannel>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async sendMessageToChannelByName(channelName: string, message: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async getMessagesFromChannelByChannelName(channelName: string, limit?: number): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>[]> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async getLastMessageInChannel(channelName: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async clearChannel(channelWrapper: DyNTS_Bot_ChannelWrapper<TeamsChannel>): Promise<void> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  // Message operations
-  async sendMessageToChannel(channelWrapper: DyNTS_Bot_ChannelWrapper<TeamsChannel>, content: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async replyToMessage(messageWrapper: DyNTS_Bot_MessageWrapper<TeamsMessage>, content: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async sendTyping(channelWrapper: DyNTS_Bot_ChannelWrapper<TeamsChannel>): Promise<void> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async sendTypingForMessage(messageWrapper: DyNTS_Bot_MessageWrapper<TeamsMessage>): Promise<void> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async fetchMessagesById(id: string, limit: number): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>[]> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async fetchMessages(channelWrapper: DyNTS_Bot_ChannelWrapper<TeamsChannel>, limit: number): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>[]> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async fetchMessagesForMessage(messageWrapper: DyNTS_Bot_MessageWrapper<TeamsMessage>, limit: number): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>[]> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async fetchAllMessagesWithPaging(channelWrapper: DyNTS_Bot_ChannelWrapper<TeamsChannel>, maxFetch?: number): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>[]> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async deleteMessage(messageWrapper: DyNTS_Bot_MessageWrapper<TeamsMessage>): Promise<void> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async updateMessage(message: TeamsMessage, issuer: string): Promise<void> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  // User operations
-  async getUserByName(username: string): Promise<DyNTS_Bot_UserWrapper<TeamsUser>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  getUserMention(userId: string): string {
-    return `<@${userId}>`;
-  }
-
-  async readMembersInChannel(channelName: string): Promise<DyNTS_Bot_UserWrapper<TeamsUser>[]> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async readMemberNamesInChannel(channelName: string): Promise<string[]> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  // Advanced message queries
-  async getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async getLastMentionOf(channelName: string, username: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_Bot_UserWrapper<TeamsUser>[]): Promise<DyNTS_Bot_LastMentionDate[]> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  // Platform-specific features
-  getRoleByName?(roleName: string): any {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  getRolePingByName?(roleName: string): Promise<string> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  getRolePingsByName?(roleNames: string[]): Promise<string> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  // Event binding
-  async create_onMessageEventListener(
-    handler: (message: DyNTS_Bot_MessageWrapper<TeamsMessage>, issuer: string) => Promise<void>
-  ): Promise<void> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  create_onErrorEventListener(handler: (error: DyFM_AnyError) => void): void {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async sendReport(message: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  async sendReportIn(message: string): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  wrapMessage(message: TeamsMessage): Promise<DyNTS_Bot_MessageWrapper<TeamsMessage>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  wrapChannel(channel: TeamsChannel): Promise<DyNTS_Bot_ChannelWrapper<TeamsChannel>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-
-  wrapUser(user: TeamsUser): Promise<DyNTS_Bot_UserWrapper<TeamsUser>> {
-    throw new Error('Teams provider not yet implemented');
-  }
-}

package/src/_modules/bot/_modules/teams-bot/index.ts

@@ -1,11 +0,0 @@
-//
-// Teams Bot Provider
-//
-// This module provides Teams-specific implementation of the Bot provider interface
-//
-
-// TYPES
-export * from './_models/teb-platform.types';
-
-// SERVICES
-export * from './_services/teb-messaging-provider.control-service';

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

@@ -1,116 +0,0 @@
-
-import { DyNTS_Bot_Commands_ControlService } from './bot-commands.control-service';
-import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service';
-import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
-import { DyNTS_Bot_MessagingProvider_ServiceBase } from './bot-messaging-provider.service-base';
-import { DyFM_Error, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-import { DyNTS_GlobalService } from '../../../_services/core/global.service';
-
-class TestBotCommandsService extends DyNTS_Bot_Commands_ControlService {
-  protected declare mainBot_CS: any;
-  protected getMainBotControlService(): DyNTS_Bot_Main_ControlService {
-    return {
-      defaultProvider: {
-        botId: 'bot-123',
-      },
-    } as any;
-  }
-
-  static getInstance(): TestBotCommandsService {
-    return TestBotCommandsService.getSingletonInstance();
-  }
-}
-
-xdescribe('| DyNTS_Bot_Commands_ControlService', () => {
-  let service: TestBotCommandsService;
-  let mockDBService: jasmine.SpyObj<{
-    find: (f: unknown) => Promise<unknown[]>;
-    getAll: () => Promise<unknown[]>;
-    getDataById: (id: string) => Promise<unknown>;
-  }>;
-
-  beforeAll(() => {
-    if (!DyNTS_global_settings.systemShortCodeName) {
-      (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
-    }
-  });
-
-  beforeEach(() => {
-    DyNTS_global_settings.env_settings = {
-      environment: DyFM_EnvironmentFlag.local,
-      mongoUri: 'mongodb://localhost:27017/test',
-    } as typeof DyNTS_global_settings.env_settings;
-
-    mockDBService = jasmine.createSpyObj('DyNTS_DBService', [
-      'find', 'findOne', 'getDataById', 'getAll', 'getDataListByIds', 'getDataByDependencyId',
-      'getDataListByDependencyId', 'getDataListByDependencyIds', 'createData', 'modifyData',
-      'markDeletedById', 'trueDeleteDataById', 'trueDeleteAllData', 'restoreDeletedById',
-    ]);
-    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService as never);
-    spyOn(DyNTS_GlobalService, 'getDBServiceByKey').and.returnValue(mockDBService as never);
-
-    service = TestBotCommandsService.getInstance();
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = TestBotCommandsService.getInstance();
-    const instance2 = TestBotCommandsService.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(TestBotCommandsService);
-  });
-
-  describe('| defaultProvider', () => {
-    it('| should return default provider from main bot service', () => {
-      (service as any).mainBot_CS = (service as any).getMainBotControlService();
-
-      expect(service.defaultProvider).toBeDefined();
-    });
-  });
-
-  describe('| setup', () => {
-    it('| should setup main bot service', async () => {
-      await service.setup('issuer-123');
-
-      expect((service as any).mainBot_CS).toBeDefined();
-    });
-
-    it('| should throw error when main bot service not found', async () => {
-      const serviceWithoutMainBot = new (class extends TestBotCommandsService {
-        protected override getMainBotControlService(): any {
-          return null;
-        }
-      } as any)();
-
-      await expectAsync(
-        serviceWithoutMainBot.setup('issuer-123')
-      ).toBeRejected();
-    });
-  });
-
-  describe('| start', () => {
-    it('| should throw error when default provider not started', async () => {
-      const serviceWithoutProvider = new (class extends TestBotCommandsService {
-        protected override getMainBotControlService(): any {
-          return {
-            defaultProvider: null,
-          };
-        }
-      } as any)();
-
-      await expectAsync(
-        serviceWithoutProvider.start('issuer-123')
-      ).toBeRejected();
-    });
-
-    it('| should succeed when default provider is started', async () => {
-      (service as any).mainBot_CS = (service as any).getMainBotControlService();
-
-      await expectAsync(
-        service.start('issuer-123')
-      ).toBeResolved();
-    });
-  });
-});
-