@flusys/nestjs-task-manager 7.0.2 → 8.0.0-beta.1

package/fesm/services/task-list.service.spec.js

@@ -1,280 +0,0 @@
-import { Test } from '@nestjs/testing';
-import { EventBusRegistry } from '@flusys/nestjs-shared/classes';
-import { UtilsService } from '@flusys/nestjs-shared/modules';
-import { createMockDataSourceProvider, createMockQueryBuilder, createMockRepository } from '@test-utils/mocks/repository.mock';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { TaskListService } from './task-list.service';
-import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
-function buildTaskList(overrides = {}) {
-    return {
-        id: 'list-uuid-1',
-        boardId: 'board-uuid-1',
-        name: 'To Do',
-        color: '#6B7280',
-        position: 0,
-        isActive: true,
-        isDoneList: false,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        deletedAt: null,
-        createdById: null,
-        updatedById: null,
-        deletedById: null,
-        ...overrides
-    };
-}
-function mockQueryRunner(repo) {
-    const qr = {
-        connect: jest.fn().mockResolvedValue(undefined),
-        startTransaction: jest.fn().mockResolvedValue(undefined),
-        commitTransaction: jest.fn().mockResolvedValue(undefined),
-        rollbackTransaction: jest.fn().mockResolvedValue(undefined),
-        release: jest.fn().mockResolvedValue(undefined),
-        manager: {
-            save: jest.fn((_target, entities)=>Promise.resolve(entities))
-        }
-    };
-    repo.manager.connection.createQueryRunner.mockReturnValue(qr);
-    return qr;
-}
-describe('TaskListService', ()=>{
-    const mockUtilsService = {
-        clearCache: jest.fn(),
-        getCacheKey: jest.fn().mockReturnValue('cache-key'),
-        trackCacheKey: jest.fn()
-    };
-    // Call history is shared across tests in this file; reset it so each cache assertion is exact.
-    beforeEach(()=>{
-        mockUtilsService.clearCache.mockClear();
-    });
-    let service;
-    let mockRepo;
-    beforeEach(async ()=>{
-        mockRepo = createMockRepository();
-        const mockDataSourceProvider = createMockDataSourceProvider(mockRepo);
-        const module = await Test.createTestingModule({
-            providers: [
-                TaskListService,
-                {
-                    provide: 'CACHE_INSTANCE',
-                    useValue: {}
-                },
-                {
-                    provide: UtilsService,
-                    useValue: mockUtilsService
-                },
-                {
-                    provide: TaskManagerDataSourceProvider,
-                    useValue: mockDataSourceProvider
-                }
-            ]
-        }).compile();
-        service = await module.resolve(TaskListService);
-    });
-    describe('convertSingleDtoToEntity (via insert)', ()=>{
-        it('creates a list applying default color, position and flags', async ()=>{
-            mockQueryRunner(mockRepo);
-            const result = await service.insert({
-                boardId: 'board-1',
-                name: 'Backlog'
-            }, buildMockUser());
-            expect(result).toEqual(expect.objectContaining({
-                boardId: 'board-1',
-                name: 'Backlog',
-                color: '#6B7280',
-                position: 0,
-                isDoneList: false,
-                isActive: true
-            }));
-        });
-        it('respects explicit color, position and isDoneList on create', async ()=>{
-            mockQueryRunner(mockRepo);
-            const result = await service.insert({
-                boardId: 'board-1',
-                name: 'Done',
-                color: '#22C55E',
-                position: 3,
-                isDoneList: true
-            }, buildMockUser());
-            expect(result).toEqual(expect.objectContaining({
-                color: '#22C55E',
-                position: 3,
-                isDoneList: true
-            }));
-        });
-        it('throws NotFoundException on update when the list does not exist', async ()=>{
-            mockQueryRunner(mockRepo);
-            mockRepo.findOne.mockResolvedValue(null);
-            await expect(service.update({
-                id: 'missing-id',
-                name: 'Renamed'
-            }, buildMockUser())).rejects.toThrow();
-        });
-        it('merges update fields onto the existing entity, preserving unspecified fields', async ()=>{
-            mockQueryRunner(mockRepo);
-            const existing = buildTaskList({
-                id: 'list-1',
-                name: 'Old Name',
-                color: '#111111',
-                position: 5
-            });
-            mockRepo.findOne.mockResolvedValue(existing);
-            const result = await service.update({
-                id: 'list-1',
-                name: 'New Name'
-            }, buildMockUser());
-            expect(result).toEqual(expect.objectContaining({
-                id: 'list-1',
-                name: 'New Name',
-                color: '#111111',
-                position: 5
-            }));
-        });
-    });
-    describe('getFilterQuery', ()=>{
-        it('filters by boardId, filters by isActive and always orders by position ascending', async ()=>{
-            const qb = createMockQueryBuilder();
-            const { query, isRaw } = await service.getFilterQuery(qb, {
-                boardId: 'board-1',
-                isActive: true
-            }, buildMockUser());
-            expect(qb.andWhere).toHaveBeenCalledWith('task_list.boardId = :boardId', {
-                boardId: 'board-1'
-            });
-            expect(qb.andWhere).toHaveBeenCalledWith('task_list.isActive = :isActive', {
-                isActive: true
-            });
-            expect(qb.orderBy).toHaveBeenCalledWith('task_list.position', 'ASC');
-            expect(isRaw).toBe(false);
-            expect(query).toBe(qb);
-        });
-        it('ignores a non-boolean isActive filter value', async ()=>{
-            const qb = createMockQueryBuilder();
-            await service.getFilterQuery(qb, {
-                isActive: 'not-a-boolean'
-            }, buildMockUser());
-            expect(qb.andWhere).not.toHaveBeenCalledWith(expect.stringContaining('isActive'), expect.anything());
-        });
-        it('orders by position even without any filters supplied', async ()=>{
-            const qb = createMockQueryBuilder();
-            await service.getFilterQuery(qb, {}, buildMockUser());
-            expect(qb.orderBy).toHaveBeenCalledWith('task_list.position', 'ASC');
-        });
-    });
-    describe('reorderLists', ()=>{
-        it('assigns positions in steps of 100 following the given order', async ()=>{
-            await service.reorderLists({
-                boardId: 'board-1',
-                orderedIds: [
-                    'list-a',
-                    'list-b',
-                    'list-c'
-                ]
-            });
-            expect(mockRepo.update).toHaveBeenNthCalledWith(1, {
-                id: 'list-a',
-                boardId: 'board-1'
-            }, {
-                position: 0
-            });
-            expect(mockRepo.update).toHaveBeenNthCalledWith(2, {
-                id: 'list-b',
-                boardId: 'board-1'
-            }, {
-                position: 100
-            });
-            expect(mockRepo.update).toHaveBeenNthCalledWith(3, {
-                id: 'list-c',
-                boardId: 'board-1'
-            }, {
-                position: 200
-            });
-        });
-        it('invalidates the list cache, each reordered entry, and the parent board cache', async ()=>{
-            await service.reorderLists({
-                boardId: 'board-1',
-                orderedIds: [
-                    'list-a',
-                    'list-b'
-                ]
-            });
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_list', expect.anything());
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_list', expect.anything(), 'list-a');
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_list', expect.anything(), 'list-b');
-            expect(mockUtilsService.clearCache).toHaveBeenCalledWith('task_board', expect.anything());
-        });
-        it('handles reordering a single-item list (position 0)', async ()=>{
-            await service.reorderLists({
-                boardId: 'board-1',
-                orderedIds: [
-                    'only-list'
-                ]
-            });
-            expect(mockRepo.update).toHaveBeenCalledWith({
-                id: 'only-list',
-                boardId: 'board-1'
-            }, {
-                position: 0
-            });
-            expect(mockRepo.update).toHaveBeenCalledTimes(1);
-        });
-        it('does nothing (no updates) for an empty ordered list', async ()=>{
-            await service.reorderLists({
-                boardId: 'board-1',
-                orderedIds: []
-            });
-            expect(mockRepo.update).not.toHaveBeenCalled();
-        });
-    });
-    describe('domain events', ()=>{
-        let publish;
-        beforeEach(()=>{
-            publish = jest.fn().mockResolvedValue(undefined);
-            EventBusRegistry.reset();
-            EventBusRegistry.setBus({
-                publish,
-                subscribe: jest.fn(),
-                close: jest.fn()
-            });
-            EventBusRegistry.configureModule('task-manager', {
-                enabled: true
-            });
-        });
-        afterEach(()=>{
-            EventBusRegistry.reset();
-        });
-        it('publishes task-manager.task_list.reordered with every list id', async ()=>{
-            await service.reorderLists({
-                boardId: 'board-1',
-                orderedIds: [
-                    'list-a',
-                    'list-b'
-                ]
-            });
-            expect(publish).toHaveBeenCalledWith(expect.objectContaining({
-                name: 'task-manager.task_list.reordered',
-                payload: expect.objectContaining({
-                    ids: [
-                        'list-a',
-                        'list-b'
-                    ],
-                    metadata: {
-                        boardId: 'board-1'
-                    }
-                })
-            }));
-        });
-        it('does not publish when the task manager module has events disabled', async ()=>{
-            EventBusRegistry.configureModule('task-manager', {
-                enabled: false
-            });
-            await service.reorderLists({
-                boardId: 'board-1',
-                orderedIds: [
-                    'list-a'
-                ]
-            });
-            expect(publish).not.toHaveBeenCalled();
-        });
-    });
-});

package/fesm/services/task-manager-config.service.js

@@ -1,59 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { Inject, Injectable } from '@nestjs/common';
-import { TASK_MANAGER_MODULE_OPTIONS } from '../config/task-manager.constants';
-import { TaskManagerModuleOptions } from '../interfaces';
-export class TaskManagerConfigService {
-    isCompanyFeatureEnabled() {
-        return this.options.bootstrapAppConfig?.enableCompanyFeature ?? false;
-    }
-    getDatabaseMode() {
-        return this.options.bootstrapAppConfig?.databaseMode ?? 'single';
-    }
-    isMultiTenant() {
-        return this.getDatabaseMode() === 'multi-tenant';
-    }
-    getJwtSecret() {
-        return this.options.config?.jwtSecret;
-    }
-    getOptions() {
-        return this.options;
-    }
-    constructor(options){
-        _define_property(this, "options", void 0);
-        this.options = options;
-    }
-}
-TaskManagerConfigService = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(TASK_MANAGER_MODULE_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof TaskManagerModuleOptions === "undefined" ? Object : TaskManagerModuleOptions
-    ])
-], TaskManagerConfigService);

package/fesm/services/task-manager-config.service.spec.js

@@ -1,94 +0,0 @@
-import { TaskManagerConfigService } from './task-manager-config.service';
-function buildOptions(overrides = {}) {
-    return {
-        bootstrapAppConfig: undefined,
-        config: undefined,
-        ...overrides
-    };
-}
-describe('TaskManagerConfigService', ()=>{
-    describe('isCompanyFeatureEnabled', ()=>{
-        it('returns true when bootstrapAppConfig enables the company feature', ()=>{
-            const service = new TaskManagerConfigService(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'single',
-                    enableCompanyFeature: true
-                }
-            }));
-            expect(service.isCompanyFeatureEnabled()).toBe(true);
-        });
-        it('defaults to false when bootstrapAppConfig is missing', ()=>{
-            const service = new TaskManagerConfigService(buildOptions({
-                bootstrapAppConfig: undefined
-            }));
-            expect(service.isCompanyFeatureEnabled()).toBe(false);
-        });
-        it('defaults to false when enableCompanyFeature is not set on bootstrapAppConfig', ()=>{
-            const service = new TaskManagerConfigService(buildOptions({
-                bootstrapAppConfig: {}
-            }));
-            expect(service.isCompanyFeatureEnabled()).toBe(false);
-        });
-    });
-    describe('getDatabaseMode', ()=>{
-        it('returns the configured database mode', ()=>{
-            const service = new TaskManagerConfigService(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'multi-tenant'
-                }
-            }));
-            expect(service.getDatabaseMode()).toBe('multi-tenant');
-        });
-        it('defaults to "single" when bootstrapAppConfig is missing', ()=>{
-            const service = new TaskManagerConfigService(buildOptions({
-                bootstrapAppConfig: undefined
-            }));
-            expect(service.getDatabaseMode()).toBe('single');
-        });
-    });
-    describe('isMultiTenant', ()=>{
-        it('returns true when database mode is multi-tenant', ()=>{
-            const service = new TaskManagerConfigService(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'multi-tenant'
-                }
-            }));
-            expect(service.isMultiTenant()).toBe(true);
-        });
-        it('returns false when database mode is single', ()=>{
-            const service = new TaskManagerConfigService(buildOptions({
-                bootstrapAppConfig: {
-                    databaseMode: 'single'
-                }
-            }));
-            expect(service.isMultiTenant()).toBe(false);
-        });
-    });
-    describe('getJwtSecret', ()=>{
-        it('returns the configured jwt secret', ()=>{
-            const service = new TaskManagerConfigService(buildOptions({
-                config: {
-                    jwtSecret: 'super-secret'
-                }
-            }));
-            expect(service.getJwtSecret()).toBe('super-secret');
-        });
-        it('returns undefined when config is missing', ()=>{
-            const service = new TaskManagerConfigService(buildOptions({
-                config: undefined
-            }));
-            expect(service.getJwtSecret()).toBeUndefined();
-        });
-    });
-    describe('getOptions', ()=>{
-        it('returns the exact options object it was constructed with', ()=>{
-            const options = buildOptions({
-                config: {
-                    jwtSecret: 'secret'
-                }
-            });
-            const service = new TaskManagerConfigService(options);
-            expect(service.getOptions()).toBe(options);
-        });
-    });
-});

package/fesm/services/task-manager-datasource.provider.js

@@ -1,74 +0,0 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import { MultiTenantDataSourceService } from '@flusys/nestjs-shared/modules';
-import { Inject, Injectable, Optional, Scope } from '@nestjs/common';
-import { REQUEST } from '@nestjs/core';
-import { Request } from 'express';
-import { getTaskManagerEntitiesByConfig } from '../entities';
-import { TaskManagerConfigService } from './task-manager-config.service';
-export class TaskManagerDataSourceProvider extends MultiTenantDataSourceService {
-    static buildParentOptions(options) {
-        return {
-            bootstrapAppConfig: options.bootstrapAppConfig,
-            defaultDatabaseConfig: options.config?.defaultDatabaseConfig,
-            tenantDefaultDatabaseConfig: options.config?.tenantDefaultDatabaseConfig,
-            tenants: options.config?.tenants
-        };
-    }
-    getEnableCompanyFeatureForTenant(tenant) {
-        return tenant?.enableCompanyFeature ?? this.configService.isCompanyFeatureEnabled();
-    }
-    async createDataSourceFromConfig(config) {
-        const currentTenant = this.getCurrentTenant();
-        const enableCompanyFeature = this.getEnableCompanyFeatureForTenant(currentTenant ?? undefined);
-        const entities = getTaskManagerEntitiesByConfig(enableCompanyFeature);
-        return super.createDataSourceFromConfig(config, entities);
-    }
-    constructor(configService, request){
-        super(TaskManagerDataSourceProvider.buildParentOptions(configService.getOptions()), request), _define_property(this, "configService", void 0), this.configService = configService;
-    }
-}
-_define_property(TaskManagerDataSourceProvider, "tenantConnections", new Map());
-_define_property(TaskManagerDataSourceProvider, "singleDataSource", null);
-_define_property(TaskManagerDataSourceProvider, "tenantsRegistry", new Map());
-_define_property(TaskManagerDataSourceProvider, "initialized", false);
-_define_property(TaskManagerDataSourceProvider, "connectionLocks", new Map());
-_define_property(TaskManagerDataSourceProvider, "singleConnectionLock", null);
-TaskManagerDataSourceProvider = _ts_decorate([
-    Injectable({
-        scope: Scope.REQUEST
-    }),
-    _ts_param(0, Inject(TaskManagerConfigService)),
-    _ts_param(1, Optional()),
-    _ts_param(1, Inject(REQUEST)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof TaskManagerConfigService === "undefined" ? Object : TaskManagerConfigService,
-        typeof Request === "undefined" ? Object : Request
-    ])
-], TaskManagerDataSourceProvider);

package/fesm/services/task-manager-datasource.provider.spec.js

@@ -1,127 +0,0 @@
-import { TaskManagerDataSourceProvider } from './task-manager-datasource.provider';
-import { getTaskManagerEntitiesByConfig } from '../entities';
-function buildConfigService(overrides = {}) {
-    const options = {
-        bootstrapAppConfig: {
-            databaseMode: 'single',
-            enableCompanyFeature: false
-        },
-        config: {
-            defaultDatabaseConfig: {
-                type: 'mysql',
-                host: 'localhost',
-                port: 3306,
-                username: 'root',
-                password: 'password',
-                database: 'flusys_test'
-            },
-            tenantDefaultDatabaseConfig: undefined,
-            tenants: []
-        },
-        ...overrides
-    };
-    return {
-        getOptions: jest.fn().mockReturnValue(options),
-        isCompanyFeatureEnabled: jest.fn().mockReturnValue(options.bootstrapAppConfig?.enableCompanyFeature ?? false)
-    };
-}
-describe('TaskManagerDataSourceProvider', ()=>{
-    afterEach(()=>{
-        // Reset the isolated static caches this provider owns so tests don't leak state between runs.
-        TaskManagerDataSourceProvider.tenantConnections = new Map();
-        TaskManagerDataSourceProvider.singleDataSource = null;
-        TaskManagerDataSourceProvider.tenantsRegistry = new Map();
-        TaskManagerDataSourceProvider.initialized = false;
-        TaskManagerDataSourceProvider.connectionLocks = new Map();
-        TaskManagerDataSourceProvider.singleConnectionLock = null;
-    });
-    it('constructs and forwards bootstrap/database config to the base class', ()=>{
-        const configService = buildConfigService();
-        const provider = new TaskManagerDataSourceProvider(configService, undefined);
-        expect(configService.getOptions).toHaveBeenCalled();
-        expect(provider.getDatabaseMode()).toBe('single');
-        expect(provider.isMultiTenant()).toBe(false);
-    });
-    it('reflects multi-tenant mode from bootstrapAppConfig', ()=>{
-        const configService = buildConfigService({
-            bootstrapAppConfig: {
-                databaseMode: 'multi-tenant'
-            }
-        });
-        const provider = new TaskManagerDataSourceProvider(configService, undefined);
-        expect(provider.isMultiTenant()).toBe(true);
-    });
-    it('owns isolated static caches, separate from the base MultiTenantDataSourceService', ()=>{
-        // Each DataSource Provider must override BOTH static cache properties and the
-        // methods that read them — otherwise modules would share connections (see FLUSYS_NEST/CLAUDE.md).
-        expect(TaskManagerDataSourceProvider.tenantConnections).not.toBe(Object.getPrototypeOf(TaskManagerDataSourceProvider).tenantConnections);
-    });
-    describe('getEnableCompanyFeatureForTenant', ()=>{
-        it('uses the tenant override when the tenant explicitly sets enableCompanyFeature', ()=>{
-            const configService = buildConfigService();
-            configService.isCompanyFeatureEnabled.mockReturnValue(false);
-            const provider = new TaskManagerDataSourceProvider(configService, undefined);
-            const result = provider.getEnableCompanyFeatureForTenant({
-                enableCompanyFeature: true
-            });
-            expect(result).toBe(true);
-        });
-        it('falls back to the module-level config when tenant does not override', ()=>{
-            const configService = buildConfigService();
-            configService.isCompanyFeatureEnabled.mockReturnValue(true);
-            const provider = new TaskManagerDataSourceProvider(configService, undefined);
-            const result = provider.getEnableCompanyFeatureForTenant(undefined);
-            expect(result).toBe(true);
-            expect(configService.isCompanyFeatureEnabled).toHaveBeenCalled();
-        });
-        it('falls back to module-level config when tenant is provided without the flag set', ()=>{
-            const configService = buildConfigService();
-            configService.isCompanyFeatureEnabled.mockReturnValue(false);
-            const provider = new TaskManagerDataSourceProvider(configService, undefined);
-            const result = provider.getEnableCompanyFeatureForTenant({});
-            expect(result).toBe(false);
-        });
-    });
-    describe('createDataSourceFromConfig', ()=>{
-        it('builds a DataSource using core entities when company feature is disabled', async ()=>{
-            const configService = buildConfigService();
-            configService.isCompanyFeatureEnabled.mockReturnValue(false);
-            const provider = new TaskManagerDataSourceProvider(configService, undefined);
-            const fakeDataSource = {
-                isInitialized: true
-            };
-            const superSpy = jest.spyOn(Object.getPrototypeOf(Object.getPrototypeOf(provider)), 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
-            const config = {
-                type: 'mysql',
-                host: 'localhost',
-                port: 3306,
-                username: 'root',
-                password: 'password',
-                database: 'flusys_test'
-            };
-            const result = await provider.createDataSourceFromConfig(config);
-            expect(superSpy).toHaveBeenCalledWith(config, getTaskManagerEntitiesByConfig(false));
-            expect(result).toBe(fakeDataSource);
-            superSpy.mockRestore();
-        });
-        it('builds a DataSource using company entities when the tenant enables the company feature', async ()=>{
-            const configService = buildConfigService();
-            configService.isCompanyFeatureEnabled.mockReturnValue(false);
-            const provider = new TaskManagerDataSourceProvider(configService, undefined);
-            jest.spyOn(provider, 'getCurrentTenant').mockReturnValue({
-                enableCompanyFeature: true
-            });
-            const fakeDataSource = {
-                isInitialized: true
-            };
-            const superSpy = jest.spyOn(Object.getPrototypeOf(Object.getPrototypeOf(provider)), 'createDataSourceFromConfig').mockResolvedValue(fakeDataSource);
-            const config = {
-                type: 'mysql',
-                database: 'flusys_test'
-            };
-            await provider.createDataSourceFromConfig(config);
-            expect(superSpy).toHaveBeenCalledWith(config, getTaskManagerEntitiesByConfig(true));
-            superSpy.mockRestore();
-        });
-    });
-});