template-saas/apps/backend/dist/modules/feature-flags/__tests__/feature-flags.controller.spec.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const testing_1 = require("@nestjs/testing");
const feature_flags_controller_1 = require("../feature-flags.controller");
const feature_flags_service_1 = require("../services/feature-flags.service");
describe('FeatureFlagsController', () => {
    let controller;
    let service;
    const mockRequestUser = {
        id: 'user-123',
        sub: 'user-123',
        tenant_id: 'tenant-123',
        email: 'test@example.com',
        role: 'admin',
    };
    const mockFlag = {
        id: 'flag-123',
        key: 'feature_new_dashboard',
        name: 'New Dashboard',
        description: 'Enable new dashboard UI',
        is_enabled: true,
        default_value: false,
        created_at: new Date('2026-01-01'),
    };
    const mockTenantFlag = {
        id: 'tf-123',
        tenant_id: 'tenant-123',
        flag_id: 'flag-123',
        enabled: true,
    };
    const mockUserFlag = {
        id: 'uf-123',
        user_id: 'user-456',
        flag_id: 'flag-123',
        enabled: true,
    };
    const mockEvaluation = {
        key: 'feature_new_dashboard',
        enabled: true,
        source: 'tenant',
    };
    beforeEach(async () => {
        const module = await testing_1.Test.createTestingModule({
            controllers: [feature_flags_controller_1.FeatureFlagsController],
            providers: [
                {
                    provide: feature_flags_service_1.FeatureFlagsService,
                    useValue: {
                        createFlag: jest.fn(),
                        getAllFlags: jest.fn(),
                        getFlagById: jest.fn(),
                        updateFlag: jest.fn(),
                        deleteFlag: jest.fn(),
                        toggleFlag: jest.fn(),
                        getTenantFlags: jest.fn(),
                        setTenantFlag: jest.fn(),
                        removeTenantFlag: jest.fn(),
                        getUserFlags: jest.fn(),
                        setUserFlag: jest.fn(),
                        removeUserFlag: jest.fn(),
                        evaluateFlag: jest.fn(),
                        evaluateAllFlags: jest.fn(),
                        isEnabled: jest.fn(),
                    },
                },
            ],
        }).compile();
        controller = module.get(feature_flags_controller_1.FeatureFlagsController);
        service = module.get(feature_flags_service_1.FeatureFlagsService);
    });
    afterEach(() => {
        jest.clearAllMocks();
    });
    describe('createFlag', () => {
        it('should create a flag', async () => {
            const dto = { key: 'new_feature', name: 'New Feature', enabled: true };
            service.createFlag.mockResolvedValue(mockFlag);
            const result = await controller.createFlag(dto);
            expect(result).toEqual(mockFlag);
            expect(service.createFlag).toHaveBeenCalledWith(dto);
        });
    });
    describe('getAllFlags', () => {
        it('should return all flags', async () => {
            service.getAllFlags.mockResolvedValue([mockFlag]);
            const result = await controller.getAllFlags();
            expect(result).toEqual([mockFlag]);
            expect(service.getAllFlags).toHaveBeenCalled();
        });
    });
    describe('getFlagById', () => {
        it('should return flag by id', async () => {
            service.getFlagById.mockResolvedValue(mockFlag);
            const result = await controller.getFlagById('flag-123');
            expect(result).toEqual(mockFlag);
            expect(service.getFlagById).toHaveBeenCalledWith('flag-123');
        });
    });
    describe('updateFlag', () => {
        it('should update a flag', async () => {
            const dto = { name: 'Updated Feature', enabled: false };
            const updated = { ...mockFlag, ...dto };
            service.updateFlag.mockResolvedValue(updated);
            const result = await controller.updateFlag('flag-123', dto);
            expect(result.name).toBe('Updated Feature');
            expect(service.updateFlag).toHaveBeenCalledWith('flag-123', dto);
        });
    });
    describe('deleteFlag', () => {
        it('should delete a flag', async () => {
            service.deleteFlag.mockResolvedValue(undefined);
            const result = await controller.deleteFlag('flag-123');
            expect(result).toEqual({ success: true });
            expect(service.deleteFlag).toHaveBeenCalledWith('flag-123');
        });
    });
    describe('toggleFlag', () => {
        it('should toggle flag to enabled', async () => {
            const toggled = { ...mockFlag, is_enabled: true };
            service.toggleFlag.mockResolvedValue(toggled);
            const result = await controller.toggleFlag('flag-123', 'true');
            expect(result.is_enabled).toBe(true);
            expect(service.toggleFlag).toHaveBeenCalledWith('flag-123', true);
        });
        it('should toggle flag to disabled', async () => {
            const toggled = { ...mockFlag, is_enabled: false };
            service.toggleFlag.mockResolvedValue(toggled);
            const result = await controller.toggleFlag('flag-123', 'false');
            expect(result.is_enabled).toBe(false);
            expect(service.toggleFlag).toHaveBeenCalledWith('flag-123', false);
        });
    });
    describe('getTenantFlags', () => {
        it('should return tenant flag overrides', async () => {
            service.getTenantFlags.mockResolvedValue([mockTenantFlag]);
            const result = await controller.getTenantFlags(mockRequestUser);
            expect(result).toEqual([mockTenantFlag]);
            expect(service.getTenantFlags).toHaveBeenCalledWith('tenant-123');
        });
    });
    describe('setTenantFlag', () => {
        it('should set tenant flag override', async () => {
            const dto = { flag_id: 'flag-123', enabled: true };
            service.setTenantFlag.mockResolvedValue(mockTenantFlag);
            const result = await controller.setTenantFlag(mockRequestUser, dto);
            expect(result).toEqual(mockTenantFlag);
            expect(service.setTenantFlag).toHaveBeenCalledWith('tenant-123', dto);
        });
    });
    describe('removeTenantFlag', () => {
        it('should remove tenant flag override', async () => {
            service.removeTenantFlag.mockResolvedValue(undefined);
            const result = await controller.removeTenantFlag(mockRequestUser, 'flag-123');
            expect(result).toEqual({ success: true });
            expect(service.removeTenantFlag).toHaveBeenCalledWith('tenant-123', 'flag-123');
        });
    });
    describe('getUserFlags', () => {
        it('should return user flag overrides', async () => {
            service.getUserFlags.mockResolvedValue([mockUserFlag]);
            const result = await controller.getUserFlags(mockRequestUser, 'user-456');
            expect(result).toEqual([mockUserFlag]);
            expect(service.getUserFlags).toHaveBeenCalledWith('tenant-123', 'user-456');
        });
    });
    describe('setUserFlag', () => {
        it('should set user flag override', async () => {
            const dto = { user_id: 'user-456', flag_id: 'flag-123', enabled: true };
            service.setUserFlag.mockResolvedValue(mockUserFlag);
            const result = await controller.setUserFlag(mockRequestUser, dto);
            expect(result).toEqual(mockUserFlag);
            expect(service.setUserFlag).toHaveBeenCalledWith('tenant-123', dto);
        });
    });
    describe('removeUserFlag', () => {
        it('should remove user flag override', async () => {
            service.removeUserFlag.mockResolvedValue(undefined);
            const result = await controller.removeUserFlag('user-456', 'flag-123');
            expect(result).toEqual({ success: true });
            expect(service.removeUserFlag).toHaveBeenCalledWith('user-456', 'flag-123');
        });
    });
    describe('evaluateFlag', () => {
        it('should evaluate a single flag', async () => {
            service.evaluateFlag.mockResolvedValue(mockEvaluation);
            const result = await controller.evaluateFlag(mockRequestUser, 'feature_new_dashboard');
            expect(result).toEqual(mockEvaluation);
            expect(service.evaluateFlag).toHaveBeenCalledWith('feature_new_dashboard', {
                tenantId: 'tenant-123',
                userId: 'user-123',
            });
        });
    });
    describe('evaluateAllFlags', () => {
        it('should evaluate all flags', async () => {
            const allEvaluations = { feature_new_dashboard: true, feature_beta: false };
            service.evaluateAllFlags.mockResolvedValue(allEvaluations);
            const result = await controller.evaluateAllFlags(mockRequestUser);
            expect(result).toEqual(allEvaluations);
            expect(service.evaluateAllFlags).toHaveBeenCalledWith({
                tenantId: 'tenant-123',
                userId: 'user-123',
            });
        });
    });
    describe('isEnabled', () => {
        it('should return true when flag is enabled', async () => {
            service.isEnabled.mockResolvedValue(true);
            const result = await controller.isEnabled(mockRequestUser, 'feature_new_dashboard');
            expect(result).toEqual({ key: 'feature_new_dashboard', enabled: true });
            expect(service.isEnabled).toHaveBeenCalledWith('feature_new_dashboard', {
                tenantId: 'tenant-123',
                userId: 'user-123',
            });
        });
        it('should return false when flag is disabled', async () => {
            service.isEnabled.mockResolvedValue(false);
            const result = await controller.isEnabled(mockRequestUser, 'feature_beta');
            expect(result).toEqual({ key: 'feature_beta', enabled: false });
        });
    });
});
//# sourceMappingURL=feature-flags.controller.spec.js.map