@futdevpro/nts-dynamo 1.15.157 → 1.15.160

package/src/_modules/mock/data-model.mock.spec.ts

@@ -1,111 +0,0 @@
-
-import {
-  Dependency_Mock, dependency_mock_DataParams, Dependent_Mock, dependent_mock_DataParams
-} from './data-model.mock';
-
-describe('| Dependency_Mock', () => {
-  it('| should create an instance with default values', () => {
-    const instance = new Dependency_Mock();
-
-    expect(instance).toBeTruthy();
-    expect(instance.string).toBeUndefined();
-    expect(instance.number).toBeUndefined();
-    expect(instance.date).toBeUndefined();
-    expect(instance.boolean).toBeUndefined();
-    expect(instance.array).toBeUndefined();
-    expect(instance.object).toBeUndefined();
-    expect(instance.objectArray).toBeUndefined();
-    expect(instance.objectArrayArray).toBeUndefined();
-  });
-
-  it('| should create an instance with provided values', () => {
-    const mockData: Dependency_Mock = {
-      string: 'test',
-      number: 42,
-      date: new Date(),
-      boolean: true,
-      array: [ 'a', 'b' ],
-      object: { key: 'value' },
-      objectArray: [{ key: 'value' }],
-      objectArrayArray: [[{ key: 'value' }]],
-    };
-    const instance = new Dependency_Mock(mockData);
-
-    expect(instance).toEqual(jasmine.objectContaining(mockData));
-  });
-});
-
-describe('| DyFM_DataModel_Params for Dependency_Mock', () => {
-  it('| should have correct dataName and properties', () => {
-    expect(dependency_mock_DataParams.dataName).toBe('dependency_mock');
-    // Check that required properties exist with correct type
-    expect(dependency_mock_DataParams.properties.string).toBeDefined();
-    expect(dependency_mock_DataParams.properties.string.type).toBe('string');
-    expect(dependency_mock_DataParams.properties.number).toBeDefined();
-    expect(dependency_mock_DataParams.properties.number.type).toBe('number');
-    expect(dependency_mock_DataParams.properties.date).toBeDefined();
-    // DyFM_DataModel_Params normalizes type to lowercase 'date'
-    expect(dependency_mock_DataParams.properties.date.type).toBe('date');
-    expect(dependency_mock_DataParams.properties.boolean).toBeDefined();
-    expect(dependency_mock_DataParams.properties.boolean.type).toBe('boolean');
-  });
-});
-
-describe('| Dependent_Mock', () => {
-  it('| should create an instance with default values', () => {
-    const instance = new Dependent_Mock();
-
-    expect(instance).toBeTruthy();
-    expect(instance.dependencyId).toBeUndefined();
-    expect(instance.string).toBeUndefined();
-    expect(instance.number).toBeUndefined();
-    expect(instance.date).toBeUndefined();
-    expect(instance.boolean).toBeUndefined();
-    expect(instance.array).toBeUndefined();
-    expect(instance.object).toBeUndefined();
-    expect(instance.objectArray).toBeUndefined();
-    expect(instance.objectArrayArray).toBeUndefined();
-  });
-
-  it('| should create an instance with provided values', () => {
-    const mockData: Dependent_Mock = {
-      dependencyId: 'dep123',
-      string: 'test',
-      number: 42,
-      date: new Date(),
-      boolean: true,
-      array: [ 'a', 'b' ],
-      object: { key: 'value' },
-      objectArray: [{ key: 'value' }],
-      objectArrayArray: [[{ key: 'value' }]],
-    };
-    const instance = new Dependent_Mock(mockData);
-
-    expect(instance).toEqual(jasmine.objectContaining(mockData));
-  });
-});
-
-describe('| DyFM_DataModel_Params for Dependent_Mock', () => {
-  it('| should have correct dataName and properties', () => {
-    expect(dependent_mock_DataParams.dataName).toBe('dependent_mock');
-    // Use jasmine.objectContaining to allow for additional properties from base class
-    // Note: DyFM_DataModel_Params normalizes array types to 'array' and object types to 'object'
-    expect(dependent_mock_DataParams.properties).toEqual(jasmine.objectContaining({
-      dependencyId: jasmine.objectContaining({
-        type: 'string',
-        unique: true,
-        required: true,
-        dependencyDataName: dependency_mock_DataParams.dataName,
-      }),
-      string: jasmine.objectContaining({ type: 'string' }),
-      number: jasmine.objectContaining({ type: 'number' }),
-      // DyFM_DataModel_Params normalizes type to lowercase 'date'
-      date: jasmine.objectContaining({ type: 'date' }),
-      boolean: jasmine.objectContaining({ type: 'boolean' }),
-      array: jasmine.objectContaining({ type: 'array' }),
-      object: jasmine.objectContaining({ type: 'object' }),
-      objectArray: jasmine.objectContaining({ type: 'array' }),
-      objectArrayArray: jasmine.objectContaining({ type: 'array' }),
-    }));
-  });
-});

package/src/_modules/mock/data-model.mock.ts

@@ -1,82 +0,0 @@
-
-import { DyFM_DataModel_Params, DyFM_Metadata } from '@futdevpro/fsm-dynamo';
-
-export class Dependency_Mock extends DyFM_Metadata {
-  string?: string;
-  number?: number;
-  date?: Date;
-  boolean?: boolean;
-  array?: string[];
-  object?: any;
-  objectArray?: any[];
-  objectArrayArray?: any[][];
-
-  constructor(
-    set?: Dependent_Mock
-  ) {
-    super(set);
-
-    if (set) {
-      Object.assign(this, set);
-    }
-  }
-}
-
-export const dependency_mock_DataParams = new DyFM_DataModel_Params<Dependency_Mock>({
-  dataName: 'dependency_mock',
-  properties: {
-    string: { type: 'string' },
-    number: { type: 'number' },
-    date: { type: 'Date' },
-    boolean: { type: 'boolean' },
-    array: { type: 'string[]' },
-    object: { type: 'any' },
-    objectArray: { type: 'any[]' },
-    objectArrayArray: { type: 'any[][]' },
-  },
-});
-
-////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////
-
-export class Dependent_Mock extends DyFM_Metadata {
-  dependencyId?: string;
-
-  string?: string;
-  number?: number;
-  date?: Date;
-  boolean?: boolean;
-  array?: string[];
-  object?: any;
-  objectArray?: any[];
-  objectArrayArray?: any[][];
-
-  constructor(
-    set?: Dependent_Mock
-  ) {
-    super(set);
-
-    if (set) {
-      Object.assign(this, set);
-    }
-  }
-}
-
-export const dependent_mock_DataParams = new DyFM_DataModel_Params<Dependent_Mock>({
-  dataName: 'dependent_mock',
-  properties: {
-    dependencyId: { type: 'string',
-      unique: true, required: true,
-      dependencyDataName:  dependency_mock_DataParams.dataName,
-    },
-    string: { type: 'string' },
-    number: { type: 'number' },
-    date: { type: 'Date' },
-    boolean: { type: 'boolean' },
-    array: { type: 'string[]' },
-    object: { type: 'any' },
-    objectArray: { type: 'any[]' },
-    objectArrayArray: { type: 'any[][]' },
-  },
-});

package/src/_modules/mock/email-service-collection.mock.spec.ts

@@ -1,24 +0,0 @@
-
-import { EmailServiceCollection_Mock } from './email-service-collection.mock';
-import { EmailService_Mock } from './email-service.mock';
-
-describe('| EmailServiceCollection_Mock', () => {
-  let emailServiceCollectionMock: EmailServiceCollection_Mock;
-
-  beforeEach(() => {
-    emailServiceCollectionMock = EmailServiceCollection_Mock.getInstance();
-  });
-
-  it('| should create an instance of EmailServiceCollection_Mock', () => {
-    expect(emailServiceCollectionMock).toBeTruthy();
-  });
-
-  it('| should return a singleton instance', () => {
-    const anotherInstance = EmailServiceCollection_Mock.getInstance();
-    expect(emailServiceCollectionMock).toBe(anotherInstance);
-  });
-
-  it('| should have a test property of type EmailService_Mock', () => {
-    expect(emailServiceCollectionMock.test).toBeInstanceOf(EmailService_Mock);
-  });
-});

package/src/_modules/mock/email-service-collection.mock.ts

@@ -1,15 +0,0 @@
-
-import { DyNTS_EmailService } from '../../_services/core/email.service';
-import { DyNTS_Service_Collection } from '../../_services/core/service-collection.service';
-import { EmailService_Mock } from './email-service.mock';
-
-export class EmailServiceCollection_Mock extends 
-  DyNTS_Service_Collection<DyNTS_EmailService> {
-
-  static getInstance(): EmailServiceCollection_Mock {
-    return EmailServiceCollection_Mock.getSingletonInstance();
-  }
-  
-  test: EmailService_Mock = new EmailService_Mock();
-
-}

package/src/_modules/mock/email-service.mock.spec.ts

@@ -1,17 +0,0 @@
-
-import {
-  DyNTS_EmailService
-} from '../../_services/core/email.service';
-import { EmailService_Mock } from './email-service.mock';
-
-describe('| EmailService_Mock', () => {
-  let emailServiceMock: EmailService_Mock;
-
-  beforeEach(() => {
-    emailServiceMock = new EmailService_Mock();
-  });
-
-  it('| should be an instance of DyNTS_EmailService', () => {
-    expect(emailServiceMock instanceof DyNTS_EmailService).toBeTrue();
-  });
-});

package/src/_modules/mock/email-service.mock.ts

@@ -1,20 +0,0 @@
-import { DyNTS_EmailService } from '../../_services/core/email.service';
-
-
-export class EmailService_Mock extends DyNTS_EmailService {
-
-  constructor() {
-    super({
-      host: 'smtp.forpsi.com',
-      port: 465,
-      senderName: 'FutDevPro - Auto',
-      email: 'auto@futdevpro.hu',
-      pass: 'a9wY992H4CpxYAG#',
-      rootPath: __dirname,
-      /* templatePaths: {
-        // test: './email-template.mock.html',
-      }, */
-    });
-  }
-}
-

package/src/_modules/mock/email-template.mock.html

@@ -1,15 +0,0 @@
-
-<!DOCTYPE html>
-<html>
-  <body>
-    <h1>Hello!</h1>
-
-    This is a TEST!
-    {{ content }}
-
-    {{content}}}
-
-    <h4>Regards,</h4>
-
-  </body>
-</html> 

package/src/_modules/mock/endpoint.mock.ts

@@ -1,91 +0,0 @@
-import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
-
-
-export const DyNTS_endpointBase_mock: DyNTS_Endpoint_Params = 
-  new DyNTS_Endpoint_Params({
-    name: 'testBase',
-    type: DyFM_HttpCallType.get,
-    endpoint: '/test-base',
-    preProcesses: [],
-    tasks: [
-      async (req, res): Promise<void> => {
-        res.send('test-base');
-      },
-    ],
-  });
-
-export const DyNTS_endpointSimple_mock: DyNTS_Endpoint_Params = 
-  new DyNTS_Endpoint_Params({
-    name: 'testSimple',
-    type: DyFM_HttpCallType.get,
-    endpoint: '/test-simple',
-    preProcesses: [],
-    tasks: [
-      async (req, res): Promise<void> => {
-        res.send('test-simple');
-      },
-    ],
-  });
-
-export const DyNTS_endpointPost_mock: DyNTS_Endpoint_Params = 
-  new DyNTS_Endpoint_Params({
-    name: 'testPost',
-    type: DyFM_HttpCallType.post,
-    endpoint: '/test-post',
-    preProcesses: [],
-    tasks: [
-      async (req, res): Promise<void> => {
-        res.send('test-post');
-      },
-    ],
-  });
-
-export const DyNTS_endpointPut_mock: DyNTS_Endpoint_Params = 
-  new DyNTS_Endpoint_Params({
-    name: 'testPut',
-    type: DyFM_HttpCallType.put,
-    endpoint: '/test-put',
-    preProcesses: [],
-    tasks: [
-      async (req, res): Promise<void> => {
-        res.send('test-put');
-      },
-    ],
-  });
-
-export const DyNTS_endpointDelete_mock: DyNTS_Endpoint_Params = 
-  new DyNTS_Endpoint_Params({
-    name: 'testDelete',
-    type: DyFM_HttpCallType.delete,
-    endpoint: '/test-delete',
-    preProcesses: [],
-    tasks: [
-      async (req, res): Promise<void> => {
-        res.send('test-delete');
-      },
-    ],
-  });
-
-export const DyNTS_endpointThrow_mock: DyNTS_Endpoint_Params = 
-  new DyNTS_Endpoint_Params({
-    name: 'testThrow',
-    type: DyFM_HttpCallType.get,
-    endpoint: '/test-throw',
-    preProcesses: [],
-    tasks: [
-      async (req, res): Promise<void> => {
-        throw new Error('test-throw');
-      },
-    ],
-  });
-  
-export const DyNTS_endpoints_mock: DyNTS_Endpoint_Params[] = [
-  DyNTS_endpointBase_mock,
-  DyNTS_endpointSimple_mock,
-  DyNTS_endpointPost_mock,
-  DyNTS_endpointPut_mock,
-  DyNTS_endpointDelete_mock,
-  DyNTS_endpointThrow_mock,
-];

package/src/_modules/mock/socket-client.mock.spec.ts

@@ -1,40 +0,0 @@
-
-import { DyFM_SocketEvent, DyFM_SocketEvent_Key } from '@futdevpro/fsm-dynamo/socket';
-
-import {
-  DyNTS_SocketClientService_Params
-} from '../socket/_models/socket-client-service-params.control-model';
-import { SocketClient_Mock } from './socket-client.mock';
-
-describe('| SocketClient_Mock', () => {
-  let socketClientMock: SocketClient_Mock;
-
-  beforeEach(() => {
-    socketClientMock = SocketClient_Mock.getInstance();
-  });
-
-  it('| should create an instance of SocketClient_Mock', () => {
-    expect(socketClientMock).toBeTruthy();
-  });
-
-  it('| should return the correct incoming events', () => {
-    const events = socketClientMock.getIncomingEvents();
-
-    expect(events.length).toBe(1);
-    expect(events[0]).toEqual(jasmine.any(DyFM_SocketEvent));
-    expect(events[0].name).toBe('connect');
-    expect(events[0].eventKey).toBe(DyFM_SocketEvent_Key.incomingNewConnection);
-    expect(events[0].tasks.length).toBe(1);
-    expect(events[0].tasks[0]).toEqual(jasmine.any(Function));
-  });
-
-  it('| should return the correct parameters', () => {
-    const params = socketClientMock.getParams();
-
-    expect(params).toEqual(jasmine.any(DyNTS_SocketClientService_Params));
-    expect(params.service).toBe('-test-socket-target-');
-    expect(params.name).toBe('socket-client-mock');
-    expect(params.port).toBe(0);
-    expect(params.socketOptions.reconnection).toBeTrue();
-  });
-});

package/src/_modules/mock/socket-client.mock.ts

@@ -1,45 +0,0 @@
-
-import { DyFM_SocketEvent, DyFM_SocketEvent_Key } from '@futdevpro/fsm-dynamo/socket';
-
-import {
-  DyNTS_SocketClientService_Params
-} from '../socket/_models/socket-client-service-params.control-model';
-import { DyNTS_SocketClient_ServiceBase } from '../socket/_services/socket-client.service';
-
-export class SocketClient_Mock extends DyNTS_SocketClient_ServiceBase {
-
-  private constructor() {
-    super();
-  } 
-  
-  static getInstance(): SocketClient_Mock {
-    return SocketClient_Mock.getSingletonInstance();
-  }
-
-  getIncomingEvents(): DyFM_SocketEvent<any>[] {
-    return [
-      new DyFM_SocketEvent({
-        name: 'connect',
-        eventKey: DyFM_SocketEvent_Key.incomingNewConnection,
-        tasks: [
-          async (content: any, issuer: string) => {
-            console.log('SocketClient_Mock: connect event received');
-          },
-        ],
-      }),
-    ];
-  }
-
-  getParams(): DyNTS_SocketClientService_Params {
-    return new DyNTS_SocketClientService_Params({
-      service: '-test-socket-target-',
-      name: 'socket-client-mock',
-      port: 0,
-      socketOptions: {
-        reconnection: true,
-      },
-    });
-  }
-
-}
-

package/src/_modules/mock/socket-server.mock.spec.ts

@@ -1,44 +0,0 @@
-
-import {
-  DyNTS_SocketServerService_Params
-} from '../socket/_models/socket-server-service-params.control-model';
-import { DyNTS_SocketServer_Mock } from './socket-server.mock';
-
-describe('| DyNTS_SocketServer_Mock', () => {
-  let socketServerMock: DyNTS_SocketServer_Mock;
-
-  beforeEach(() => {
-    socketServerMock = DyNTS_SocketServer_Mock.getInstance();
-  });
-
-  it('| should return an instance of DyNTS_SocketServer_Mock', () => {
-    expect(socketServerMock).toBeInstanceOf(DyNTS_SocketServer_Mock);
-  });
-
-  it('| should return correct service parameters', () => {
-    const params = socketServerMock.getServiceParams();
-
-    expect(params).toBeInstanceOf(DyNTS_SocketServerService_Params);
-    expect(params.name).toBe('test');
-    expect(params.port).toBe(0);
-  });
-
-  it('| should return an empty array for incoming events', () => {
-    const events = socketServerMock.getIncomingEvents();
-
-    expect(events).toEqual([]);
-  });
-
-  /* it('| should return correct presence from subscription event content', async () => {
-    const mockSocketSubscription = { issuerId: 'testIssuerId' };
-    const mockSocket = {} as Socket;
-
-    const presence = await socketServerMock.getPresenceFromSubscriptionEventContent(
-      mockSocketSubscription, mockSocket);
-
-    expect(presence).toBeInstanceOf(DyNTS_SocketPresence);
-    expect(presence.issuerLocalId).toBe('testIssuerId');
-    expect(presence.sockets).toEqual([ mockSocket ]);
-    expect(presence.issuer).toBe('ISSUER socketServer_Mock');
-  }); */
-});

package/src/_modules/mock/socket-server.mock.ts

@@ -1,46 +0,0 @@
-import { DyFM_SocketEvent } from '@futdevpro/fsm-dynamo/socket';
-import { Socket } from 'socket.io';
-
-import {
-  DyNTS_SocketPresence
-} from '../socket/_models/socket-presence.control-model';
-import {
-  DyNTS_SocketServerService_Params
-} from '../socket/_models/socket-server-service-params.control-model';
-import { DyNTS_SocketServerService } from '../socket/_services/socket-server.service';
-
-/**
- * Mock Socket Server Service for testing purposes
- * Uses port 0 so the OS assigns a random available port
- */
-export class DyNTS_SocketServer_Mock extends
-  DyNTS_SocketServerService<DyNTS_SocketPresence> {
-
-  static getInstance(): DyNTS_SocketServer_Mock {
-    return DyNTS_SocketServer_Mock.getSingletonInstance();
-  }
-
-  getServiceParams(): DyNTS_SocketServerService_Params<any> {
-    return new DyNTS_SocketServerService_Params({
-      name: 'test',
-      port: 0,
-    });
-  }
-
-  getIncomingEvents(): DyFM_SocketEvent<any>[] {
-    return [];
-  }
-
-  protected async getPresenceFromSubscriptionEventContent(
-    socketSubscription: any, 
-    socket: Socket
-  ): Promise<DyNTS_SocketPresence> {
-    return new DyNTS_SocketPresence({ 
-      issuerLocalId: socketSubscription.issuerId, 
-      sockets: [ socket ],
-      issuer: 'ISSUER socketServer_Mock',
-    });
-  }
-}
-
-

package/src/_modules/oauth2/_routes/oauth2.controller.spec.ts

@@ -1,107 +0,0 @@
-
-import { DyNTS_OAuth2_Controller } from './oauth2.controller';
-import { DyNTS_Endpoint_Params } from '../../../_models/control-models/endpoint-params.control-model';
-import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
-import { DyNTS_OAuth2_AuthService } from '../_services/oauth2.auth-service';
-import { DyNTS_OAuth2_ControlService } from '../_services/oauth2.control-service';
-
-describe('| DyNTS_OAuth2_Controller', () => {
-  let controller: DyNTS_OAuth2_Controller;
-  let mockAuthService: jasmine.SpyObj<DyNTS_OAuth2_AuthService>;
-  let mockControlService: jasmine.SpyObj<DyNTS_OAuth2_ControlService>;
-
-  beforeEach(() => {
-    // Reset singleton instances to prevent state leakage between tests
-    (DyNTS_OAuth2_Controller as any).instance = undefined;
-    (DyNTS_OAuth2_ControlService as any).instance = undefined;
-    (DyNTS_OAuth2_AuthService as any).instance = undefined;
-
-    // Mock the services to prevent circular dependency
-    mockAuthService = jasmine.createSpyObj('DyNTS_OAuth2_AuthService', [
-      'authenticate_token',
-      'getTokenFromRequest',
-    ]);
-    mockControlService = jasmine.createSpyObj('DyNTS_OAuth2_ControlService', [
-      'handleAuthorizationRequest',
-      'handleTokenRequest',
-      'handleUserInfoRequest',
-      'handleTokenRevocation',
-    ]);
-    
-    spyOn(DyNTS_OAuth2_AuthService, 'getInstance').and.returnValue(mockAuthService);
-    spyOn(DyNTS_OAuth2_ControlService, 'getInstance').and.returnValue(mockControlService);
-
-    // Now we can safely get the Controller instance
-    controller = DyNTS_OAuth2_Controller.getInstance();
-    
-    // Replace the services with our mocks
-    (controller as any).authService = mockAuthService;
-    (controller as any).controlService = mockControlService;
-  });
-
-  it('| should be a singleton instance', () => {
-    const instance1 = DyNTS_OAuth2_Controller.getInstance();
-    const instance2 = DyNTS_OAuth2_Controller.getInstance();
-
-    expect(instance1).toBe(instance2);
-    expect(instance1).toBeInstanceOf(DyNTS_OAuth2_Controller);
-  });
-
-  describe('| setupEndpoints', () => {
-    it('| should setup all OAuth2 endpoints', () => {
-      controller.setupEndpoints();
-
-      expect(controller.endpoints).toBeDefined();
-      expect(controller.endpoints.length).toBe(4);
-    });
-
-    it('| should setup authorize endpoint', () => {
-      controller.setupEndpoints();
-
-      const authorizeEndpoint = controller.endpoints.find(ep => ep.name === 'authorize');
-      expect(authorizeEndpoint).toBeDefined();
-      expect(authorizeEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(authorizeEndpoint?.endpoint).toBe('/oauth2/authorize');
-      expect((authorizeEndpoint as any)?.tasks).toBeDefined();
-      expect((authorizeEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup token endpoint', () => {
-      controller.setupEndpoints();
-
-      const tokenEndpoint = controller.endpoints.find(ep => ep.name === 'token');
-      expect(tokenEndpoint).toBeDefined();
-      expect(tokenEndpoint?.type).toBe(DyFM_HttpCallType.post);
-      expect(tokenEndpoint?.endpoint).toBe('/oauth2/token');
-      expect((tokenEndpoint as any)?.tasks).toBeDefined();
-      expect((tokenEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup userinfo endpoint', () => {
-      controller.setupEndpoints();
-
-      const userinfoEndpoint = controller.endpoints.find(ep => ep.name === 'userinfo');
-      expect(userinfoEndpoint).toBeDefined();
-      expect(userinfoEndpoint?.type).toBe(DyFM_HttpCallType.get);
-      expect(userinfoEndpoint?.endpoint).toBe('/oauth2/userinfo');
-      expect((userinfoEndpoint as any)?.preProcesses).toBeDefined();
-      expect((userinfoEndpoint as any)?.preProcesses?.length).toBe(1);
-      expect((userinfoEndpoint as any)?.tasks).toBeDefined();
-      expect((userinfoEndpoint as any)?.tasks?.length).toBe(1);
-    });
-
-    it('| should setup revoke endpoint', () => {
-      controller.setupEndpoints();
-
-      const revokeEndpoint = controller.endpoints.find(ep => ep.name === 'revoke');
-      expect(revokeEndpoint).toBeDefined();
-      expect(revokeEndpoint?.type).toBe(DyFM_HttpCallType.post);
-      expect(revokeEndpoint?.endpoint).toBe('/oauth2/revoke');
-      expect((revokeEndpoint as any)?.preProcesses).toBeDefined();
-      expect((revokeEndpoint as any)?.preProcesses?.length).toBe(1);
-      expect((revokeEndpoint as any)?.tasks).toBeDefined();
-      expect((revokeEndpoint as any)?.tasks?.length).toBe(1);
-    });
-  });
-});
-