@futdevpro/nts-dynamo 1.15.157 → 1.15.163

package/src/_modules/bot/_services/bot-messaging-provider.service-base.spec.ts

@@ -1,349 +0,0 @@
-
-import { DyNTS_Bot_MessagingProvider_ServiceBase, DyNTS_Bot_MessagingProvider_Config } from './bot-messaging-provider.service-base';
-import { DyFM_Msg_Provider_Type } from '@futdevpro/fsm-dynamo/messaging';
-import { DyNTS_Bot_ChannelWrapper } from '../_models/bot-channel-wrapper.interface';
-import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
-import { DyNTS_Bot_UserWrapper } from '../_models/bot-user-wrapper.interface';
-
-class MockChannel {
-  id: string;
-  name: string;
-}
-
-class MockMessage {
-  id: string;
-  content: string;
-}
-
-class MockUser {
-  id: string;
-  username: string;
-}
-
-class MockRole {
-  id: string;
-  name: string;
-}
-
-class TestMessagingProvider extends DyNTS_Bot_MessagingProvider_ServiceBase<
-  MockChannel,
-  MockMessage,
-  MockUser,
-  DyNTS_Bot_MessagingProvider_Config,
-  MockRole
-> {
-  readonly name = 'test-provider';
-  readonly type = DyFM_Msg_Provider_Type.dynamo;
-  readonly config: DyNTS_Bot_MessagingProvider_Config = {
-    reportChannelName: 'test-channel',
-  };
-
-  get botId(): string {
-    return 'bot-123';
-  }
-
-  get botDisplayName(): string {
-    return 'Test Bot';
-  }
-
-  async setup(issuer: string): Promise<void> {
-    // Mock implementation
-  }
-
-  async start(issuer: string): Promise<void> {
-    // Mock implementation
-  }
-
-  async getChannelByName(name: string): Promise<DyNTS_Bot_ChannelWrapper<MockChannel>> {
-    const channel = this.channelCache.get(name) || { id: 'channel-1', name };
-    return this.wrapChannel(channel);
-  }
-
-  async getChannelById(id: string): Promise<DyNTS_Bot_ChannelWrapper<MockChannel>> {
-    const channel = { id, name: 'test-channel' };
-    return this.wrapChannel(channel);
-  }
-
-  async sendMessageToChannelByName(channelName: string, message: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<MockMessage>> {
-    const channel = await this.getChannelByName(channelName);
-    return this.sendMessageToChannel(channel, message, issuer);
-  }
-
-  async getMessagesFromChannelByChannelName(channelName: string, limit?: number): Promise<DyNTS_Bot_MessageWrapper<MockMessage>[]> {
-    return [];
-  }
-
-  async getLastMessageInChannel(channelName: string): Promise<DyNTS_Bot_MessageWrapper<MockMessage>> {
-    return this.wrapMessage({ id: 'msg-1', content: 'Last message' });
-  }
-
-  async clearChannel(channelWrapper: DyNTS_Bot_ChannelWrapper<MockChannel>): Promise<void> {
-    // Mock implementation
-  }
-
-  async sendMessageToChannel(channelWrapper: DyNTS_Bot_ChannelWrapper<MockChannel>, content: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<MockMessage>> {
-    return this.wrapMessage({ id: 'msg-1', content });
-  }
-
-  async replyToMessage(messageWrapper: DyNTS_Bot_MessageWrapper<MockMessage>, content: string): Promise<DyNTS_Bot_MessageWrapper<MockMessage>> {
-    return this.wrapMessage({ id: 'msg-2', content });
-  }
-
-  async sendTyping(channelWrapper: DyNTS_Bot_ChannelWrapper<MockChannel>): Promise<void> {
-    // Mock implementation
-  }
-
-  async sendTypingForMessage(messageWrapper: DyNTS_Bot_MessageWrapper<MockMessage>): Promise<void> {
-    // Mock implementation
-  }
-
-  async fetchMessages(channelWrapper: DyNTS_Bot_ChannelWrapper<MockChannel>, limit: number): Promise<DyNTS_Bot_MessageWrapper<MockMessage>[]> {
-    return [];
-  }
-
-  async fetchMessagesById(id: string, limit: number): Promise<DyNTS_Bot_MessageWrapper<MockMessage>[]> {
-    return [];
-  }
-
-  async fetchMessagesForMessage(messageWrapper: DyNTS_Bot_MessageWrapper<MockMessage>, limit: number): Promise<DyNTS_Bot_MessageWrapper<MockMessage>[]> {
-    return [];
-  }
-
-  async fetchAllMessagesWithPaging(channelWrapper: DyNTS_Bot_ChannelWrapper<MockChannel>, maxFetch?: number): Promise<DyNTS_Bot_MessageWrapper<MockMessage>[]> {
-    return [];
-  }
-
-  async deleteMessage(messageWrapper: DyNTS_Bot_MessageWrapper<MockMessage>): Promise<void> {
-    // Mock implementation
-  }
-
-  async updateMessage(message: MockMessage, issuer: string): Promise<void> {
-    // Mock implementation
-  }
-
-  async getUserByName(username: string): Promise<DyNTS_Bot_UserWrapper<MockUser>> {
-    return this.wrapUser({ id: 'user-1', username });
-  }
-
-  getUserMention(userId: string): string {
-    return `<@${userId}>`;
-  }
-
-  async readMembersInChannel(channelName: string): Promise<DyNTS_Bot_UserWrapper<MockUser>[]> {
-    return [];
-  }
-
-  async readMemberNamesInChannel(channelName: string): Promise<string[]> {
-    return [];
-  }
-
-  async getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_Bot_MessageWrapper<MockMessage>> {
-    return this.wrapMessage({ id: 'msg-1', content: 'Last message' });
-  }
-
-  async getLastMentionOf(channelName: string, username: string): Promise<DyNTS_Bot_MessageWrapper<MockMessage>> {
-    return this.wrapMessage({ id: 'msg-1', content: 'Last mention' });
-  }
-
-  async readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<any[]> {
-    return [];
-  }
-
-  async readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_Bot_UserWrapper<MockUser>[]): Promise<any[]> {
-    return [];
-  }
-
-  getRoleByName?(roleName: string): any {
-    return this.roleCache.get(roleName) || { id: 'role-1', name: roleName };
-  }
-
-  async getRolePingByName?(roleName: string): Promise<string> {
-    return `<@&role-1>`;
-  }
-
-  async getRolePingsByName?(roleNames: string[]): Promise<string> {
-    return roleNames.map(name => `<@&role-1>`).join(' ');
-  }
-
-  async create_onMessageEventListener(
-    handler: (message: DyNTS_Bot_MessageWrapper<MockMessage>, issuer: string) => Promise<void>
-  ): Promise<void> {
-    // Mock implementation
-  }
-
-  create_onErrorEventListener(handler: (error: any) => void): void {
-    // Mock implementation
-  }
-
-  async sendReport(message: string): Promise<DyNTS_Bot_MessageWrapper<MockMessage>> {
-    return this.sendMessageToChannelByName(this.config.reportChannelName, message, 'system');
-  }
-
-  async sendReportIn(message: string): Promise<DyNTS_Bot_MessageWrapper<MockMessage>> {
-    return this.sendMessageToChannelByName(this.config.reportChannelName, message, 'system');
-  }
-
-  async wrapMessage(message: MockMessage): Promise<DyNTS_Bot_MessageWrapper<MockMessage>> {
-    const self = this;
-    return {
-      id: message.id,
-      content: message.content,
-      rawPlatformMessage: message,
-      channelId: 'channel-1',
-      userId: 'user-1',
-      username: 'test-user',
-      timestamp: new Date(),
-      getChannel: async () => self.getChannelById('channel-1'),
-      getUser: async () => self.getUserByName('test-user'),
-      reply: async (content: string) => self.replyToMessage(await self.wrapMessage(message), content),
-      delete: async () => self.deleteMessage(await self.wrapMessage(message)),
-    } as any;
-  }
-
-  async wrapChannel(channel: MockChannel): Promise<DyNTS_Bot_ChannelWrapper<MockChannel>> {
-    const self = this;
-    return {
-      id: channel.id,
-      name: channel.name,
-      rawPlatformChannel: channel,
-      sendMessage: async (content: string, issuer: string) =>
-        self.sendMessageToChannel(await self.wrapChannel(channel), content, issuer),
-      getMessages: async (limit: number) => self.fetchMessages(await self.wrapChannel(channel), limit),
-      clear: async () => self.clearChannel(await self.wrapChannel(channel)),
-    } as any;
-  }
-
-  async wrapUser(user: MockUser): Promise<DyNTS_Bot_UserWrapper<MockUser>> {
-    return {
-      id: user.id,
-      username: user.username,
-      rawPlatformUser: user,
-      mention: this.getUserMention(user.id),
-    } as any;
-  }
-
-  static getInstance(): TestMessagingProvider {
-    return TestMessagingProvider.getSingletonInstance();
-  }
-}
-
-xdescribe('| DyNTS_Bot_MessagingProvider_ServiceBase', () => {
-  let provider: TestMessagingProvider;
-
-  beforeEach(() => {
-    provider = TestMessagingProvider.getInstance();
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = TestMessagingProvider.getInstance();
-    const instance2 = TestMessagingProvider.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(TestMessagingProvider);
-  });
-
-  describe('| properties', () => {
-    it('| should have name property', () => {
-      expect(provider.name).toBe('test-provider');
-    });
-
-    it('| should have type property', () => {
-      expect(provider.type).toBe(DyFM_Msg_Provider_Type.dynamo);
-    });
-
-    it('| should have botId getter', () => {
-      expect(provider.botId).toBe('bot-123');
-    });
-
-    it('| should have botDisplayName getter', () => {
-      expect(provider.botDisplayName).toBe('Test Bot');
-    });
-
-    it('| should have config property', () => {
-      expect(provider.config).toBeDefined();
-      expect(provider.config.reportChannelName).toBe('test-channel');
-    });
-  });
-
-  describe('| channelCache', () => {
-    it('| should cache channels', () => {
-      const channel: MockChannel = { id: 'channel-1', name: 'test-channel' };
-      (provider as any).channelCache.set('test-channel', channel);
-
-      expect((provider as any).channelCache.get('test-channel')).toBe(channel);
-    });
-  });
-
-  describe('| roleCache', () => {
-    it('| should cache roles', () => {
-      const role: MockRole = { id: 'role-1', name: 'test-role' };
-      (provider as any).roleCache.set('test-role', role);
-
-      expect((provider as any).roleCache.get('test-role')).toBe(role);
-    });
-  });
-
-  describe('| wrapMessage', () => {
-    it('| should wrap message correctly', async () => {
-      const message: MockMessage = { id: 'msg-1', content: 'Test message' };
-      const wrapped = await provider.wrapMessage(message);
-
-      expect(wrapped.id).toBe('msg-1');
-      expect(wrapped.content).toBe('Test message');
-      expect(wrapped.rawPlatformMessage).toBe(message);
-    });
-  });
-
-  describe('| wrapChannel', () => {
-    it('| should wrap channel correctly', async () => {
-      const channel: MockChannel = { id: 'channel-1', name: 'test-channel' };
-      const wrapped = await provider.wrapChannel(channel);
-
-      expect(wrapped.id).toBe('channel-1');
-      expect(wrapped.name).toBe('test-channel');
-      expect(wrapped.rawPlatformChannel).toBe(channel);
-    });
-  });
-
-  describe('| wrapUser', () => {
-    it('| should wrap user correctly', async () => {
-      const user: MockUser = { id: 'user-1', username: 'test-user' };
-      const wrapped = await provider.wrapUser(user);
-
-      expect(wrapped.id).toBe('user-1');
-      expect(wrapped.username).toBe('test-user');
-      expect(wrapped.rawPlatformUser).toBe(user);
-    });
-  });
-
-  describe('| getUserMention', () => {
-    it('| should return user mention', () => {
-      const mention = provider.getUserMention('user-123');
-
-      expect(mention).toBe('<@user-123>');
-    });
-  });
-
-  describe('| sendReport', () => {
-    it('| should send report to report channel', async () => {
-      spyOn(provider, 'sendMessageToChannelByName').and.returnValue(provider.wrapMessage({ id: 'msg-1', content: 'Report' }));
-
-      const result = await provider.sendReport('Test report');
-
-      expect(provider.sendMessageToChannelByName).toHaveBeenCalledWith('test-channel', 'Test report', 'system');
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe('| sendReportIn', () => {
-    it('| should send report in report channel', async () => {
-      spyOn(provider, 'sendMessageToChannelByName').and.returnValue(provider.wrapMessage({ id: 'msg-1', content: 'Report' }));
-
-      const result = await provider.sendReportIn('Test report');
-
-      expect(provider.sendMessageToChannelByName).toHaveBeenCalledWith('test-channel', 'Test report', 'system');
-      expect(result).toBeDefined();
-    });
-  });
-});
-

package/src/_modules/bot/_services/bot-messaging-provider.service-base.ts

@@ -1,158 +0,0 @@
-import { DyFM_AnyError, DyFM_Object } from '@futdevpro/fsm-dynamo';
-import { DyFM_Msg_Provider_Type } from '@futdevpro/fsm-dynamo/messaging';
-
-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_Global_Settings } from '../_models/bot-global-settings.interface';
-import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
-import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
-import { DyNTS_Bot_UserWrapper } from '../_models/bot-user-wrapper.interface';
-
-//export interface DyNTS_Bot_MessagingProvider_Config<
-//  T_MessagingProviderConfig = any
-//> extends DyNTS_Bot_Global_Settings {
-//  /** Unique identifier for this provider instance (required when using multiple providers) */
-//  /* messagingProviderId?: string; */
-//  /* messagingProvider: DyFM_Msg_Provider_Type | string; */
-//  /* messagingProviderInstance?: DyNTS_Bot_MessagingProvider; */
-//  config: T_MessagingProviderConfig; /* MessagingProvider_DiscordConfig | MessagingProvider_SlackConfig | MessagingProvider_TeamsConfig | MessagingProvider_DynamoConfig; */
-//}
-
-export interface DyNTS_Bot_MessagingProvider_Config {
-  reportChannelName: string;
-}
-
-export interface Slack_MessagingProviderConfig extends DyNTS_Bot_MessagingProvider_Config {
-  token: string;
-  workspace: string;
-}
-
-export interface Teams_MessagingProviderConfig extends DyNTS_Bot_MessagingProvider_Config {
-  appId: string;
-  appPassword: string;
-  tenantId: string;
-}
-
-export interface Dynamo_MessagingProviderConfig extends DyNTS_Bot_MessagingProvider_Config {
-  defaultConversationId?: string; // Optional default conversation
-  botUserId?: string; // Bot user ID in messaging system
-  botDisplayName?: string; // Bot display name
-}
-
-export abstract class DyNTS_Bot_MessagingProvider_ServiceBase<
-  T_MessagingPlatformChannel extends any = any,
-  T_MessagingPlatformMessage extends any = any,
-  T_MessagingPlatformUser extends any = any,
-  T_MessagingProviderConfig extends DyNTS_Bot_MessagingProvider_Config = DyNTS_Bot_MessagingProvider_Config,
-  T_MessagingPlatformRole extends any = any,
-> extends DyNTS_SingletonService {
-
-  abstract readonly name: string;
-  /** used as id as well */
-  abstract readonly type: DyFM_Msg_Provider_Type | string;
-
-  abstract get botId(): string;
-  abstract get botDisplayName(): string;
-  /* abstract get providerId(): string; */
-  /* abstract isReady(): boolean; */
-
-  /* get id(): DyFM_Msg_Provider_Type | string {
-    return this.type;
-  } */
-  
-  abstract readonly config: T_MessagingProviderConfig;
-
-  /* protected _channelsByNames: {
-    [key: string]: DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>;
-  } = {};
-  protected _rolesByNames: {
-    [key: string]: any[];
-  } = {}; */
-
-  protected readonly channelCache: Map<string, T_MessagingPlatformChannel> = new Map();
-  protected readonly roleCache: Map<string, T_MessagingPlatformRole> = new Map();
-
-  /* constructor(
-    setConfig?: T_MessagingProviderConfig
-  ) {
-    super();
-
-    if (setConfig) {
-      this.config = setConfig;
-    }
-  } */
-
-  // Initialization
-  //abstract preInitialize(): Promise<void>;
-  //abstract initialize(): Promise<void>;
-  abstract setup(issuer: string): Promise<void>;
-  abstract start(issuer: string): Promise<void>;
-  //abstract login(): Promise<void>;
-  //abstract getToken(): string;
-  
-  // Channel operations
-  abstract getChannelByName(name: string): Promise<DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>>;
-  abstract getChannelById(id: string): Promise<DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>>;
-  abstract sendMessageToChannelByName(channelName: string, message: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
-  abstract getMessagesFromChannelByChannelName(channelName: string, limit?: number): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>[]>;
-  abstract getLastMessageInChannel(channelName: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
-  abstract clearChannel(channelWrapper: DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>): Promise<void>;
-  
-  // Message operations
-  abstract sendMessageToChannel(channelWrapper: DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>, content: string, issuer: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
-  abstract replyToMessage(messageWrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, content: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
-  abstract sendTyping(channelWrapper: DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>): Promise<void>;
-  abstract sendTypingForMessage(messageWrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>): Promise<void>;
-  abstract fetchMessages(channelWrapper: DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>, limit: number): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>[]>;
-  abstract fetchMessagesById(id: string, limit: number): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>[]>;
-  abstract fetchMessagesForMessage(messageWrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, limit: number): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>[]>;
-  abstract fetchAllMessagesWithPaging(channelWrapper: DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>, maxFetch?: number): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>[]>;
-  abstract deleteMessage(messageWrapper: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>): Promise<void>;
-  abstract updateMessage(message: T_MessagingPlatformMessage, issuer: string): Promise<void>;
-  
-  // User operations
-  abstract getUserByName(username: string): Promise<DyNTS_Bot_UserWrapper<T_MessagingPlatformUser>>;
-  abstract getUserMention(userId: string): string;
-  abstract readMembersInChannel(channelName: string): Promise<DyNTS_Bot_UserWrapper<T_MessagingPlatformUser>[]>;
-  abstract readMemberNamesInChannel(channelName: string): Promise<string[]>;
-  
-  // Advanced message queries
-  abstract getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
-  abstract getLastMentionOf(channelName: string, username: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
-  abstract readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]>;
-  abstract readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_Bot_UserWrapper<T_MessagingPlatformUser>[]): Promise<DyNTS_Bot_LastMentionDate[]>;
-  
-  // Platform-specific features (optional, may return null/undefined for unsupported platforms)
-  abstract getRoleByName?(roleName: string): any;
-  abstract getRolePingByName?(roleName: string): Promise<string>;
-  abstract getRolePingsByName?(roleNames: string[]): Promise<string>;
-  
-  // Event binding
-  //abstract onMessage(
-  //  message: T_MessagingPlatformMessage,
-  //  /* handler: (message: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string, providerId?: string) => void */
-  //): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>; /* void; */
-  abstract create_onMessageEventListener(
-    handler: (message: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, issuer: string) => Promise<void>
-  ): Promise<void>;
-  //abstract create_onReadyEventListener(handler: () => void): void;
-  abstract create_onErrorEventListener(handler: (error: DyFM_AnyError) => void): void;
-
-  abstract sendReport(message: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
-  abstract sendReportIn(message: string): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
-
-  abstract wrapMessage(message: T_MessagingPlatformMessage): Promise<DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>>;
-  abstract wrapChannel(channel: T_MessagingPlatformChannel): Promise<DyNTS_Bot_ChannelWrapper<T_MessagingPlatformChannel>>;
-  abstract wrapUser(user: T_MessagingPlatformUser): Promise<DyNTS_Bot_UserWrapper<T_MessagingPlatformUser>>;
-  
-  /* abstract channelIsTextBased(channel: T_MessagingPlatformChannel): boolean;
-  abstract channelIsVoiceBased(channel: T_MessagingPlatformChannel): boolean;
-  abstract channelIsDM(channel: T_MessagingPlatformChannel): boolean; */
-  // Metadata
-  //abstract getBotId(): string;
-  //abstract getBotDisplayName(): string;
-  ////abstract getProviderName(): string;
-  //abstract getProviderId(): string;
-  //abstract isReady(): boolean;
-}

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

@@ -1,111 +0,0 @@
-
-import { DyNTS_Bot_Routines_ControlService } from './bot-routines.control-service';
-import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service';
-import { DyNTS_Bot_MessagingProvider_ServiceBase } from './bot-messaging-provider.service-base';
-import { DyFM_Error } from '@futdevpro/fsm-dynamo';
-import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
-
-class TestBotRoutinesService extends DyNTS_Bot_Routines_ControlService {
-  protected declare mainBot_CS: any;
-  protected getMainBotControlService(): DyNTS_Bot_Main_ControlService {
-    return {
-      defaultProvider: {
-        botId: 'bot-123',
-      },
-    } as any;
-  }
-
-  startRoutines = async (issuer: string): Promise<void> => {
-    // Mock implementation
-  };
-
-  static getInstance(): TestBotRoutinesService {
-    return TestBotRoutinesService.getSingletonInstance();
-  }
-}
-
-xdescribe('| DyNTS_Bot_Routines_ControlService', () => {
-  let service: TestBotRoutinesService;
-
-  beforeEach(() => {
-    service = TestBotRoutinesService.getInstance();
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = TestBotRoutinesService.getInstance();
-    const instance2 = TestBotRoutinesService.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(TestBotRoutinesService);
-  });
-
-  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('| routinesStarted', () => {
-    it('| should return undefined initially', () => {
-      // Reset the private _routinesStarted field to undefined for clean test
-      (service as any)._routinesStarted = undefined;
-      expect(service.routinesStarted).toBeFalsy();
-    });
-
-    it('| should return true after start', async () => {
-      (service as any).mainBot_CS = (service as any).getMainBotControlService();
-      await service.start('issuer-123');
-
-      expect(service.routinesStarted).toBe(true);
-    });
-  });
-
-  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 TestBotRoutinesService {
-        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 TestBotRoutinesService {
-        protected override getMainBotControlService(): any {
-          return {
-            defaultProvider: null,
-          };
-        }
-      } as any)();
-
-      await expectAsync(
-        serviceWithoutProvider.start('issuer-123')
-      ).toBeRejected();
-    });
-
-    it('| should start routines and set routinesStarted flag', async () => {
-      (service as any).mainBot_CS = (service as any).getMainBotControlService();
-      spyOn(service, 'startRoutines').and.returnValue(Promise.resolve());
-
-      await service.start('issuer-123');
-
-      expect(service.startRoutines).toHaveBeenCalledWith('issuer-123');
-      expect(service.routinesStarted).toBe(true);
-    });
-  });
-});
-