api/api/src/unraid-api/cli/__test__/developer.command.test.ts

import { Test, TestingModule } from '@nestjs/testing';

import { InquirerService } from 'nest-commander';
import { beforeEach, describe, expect, it, vi } from 'vitest';

import { DeveloperToolsService } from '@app/unraid-api/cli/developer/developer-tools.service.js';
import { DeveloperCommand } from '@app/unraid-api/cli/developer/developer.command.js';
import { LogService } from '@app/unraid-api/cli/log.service.js';

describe('DeveloperCommand', () => {
    let module: TestingModule;
    let command: DeveloperCommand;
    let developerToolsService: DeveloperToolsService;
    let logService: LogService;
    let inquirerService: InquirerService;

    beforeEach(async () => {
        module = await Test.createTestingModule({
            providers: [
                DeveloperCommand,
                {
                    provide: DeveloperToolsService,
                    useValue: {
                        setSandboxMode: vi.fn(),
                        enableModalTest: vi.fn(),
                        disableModalTest: vi.fn(),
                        getModalTestStatus: vi.fn().mockResolvedValue({ enabled: false }),
                        getModalTestingGuide: vi.fn().mockReturnValue(['test guide']),
                    },
                },
                {
                    provide: LogService,
                    useValue: {
                        info: vi.fn(),
                        error: vi.fn(),
                        warn: vi.fn(),
                    },
                },
                {
                    provide: InquirerService,
                    useValue: {
                        prompt: vi.fn(),
                    },
                },
            ],
        }).compile();

        command = module.get<DeveloperCommand>(DeveloperCommand);
        developerToolsService = module.get<DeveloperToolsService>(DeveloperToolsService);
        logService = module.get<LogService>(LogService);
        inquirerService = module.get<InquirerService>(InquirerService);
    });

    it('should handle sandbox option directly', async () => {
        await command.run([], { sandbox: true });

        expect(developerToolsService.setSandboxMode).toHaveBeenCalledWith(true);
    });

    it('should handle enable-modal option directly', async () => {
        await command.run([], { 'enable-modal': true });

        expect(developerToolsService.enableModalTest).toHaveBeenCalled();
        expect(logService.info).toHaveBeenCalledWith('test guide');
    });

    it('should handle disable-modal option directly', async () => {
        await command.run([], { 'disable-modal': true });

        expect(developerToolsService.disableModalTest).toHaveBeenCalled();
    });

    it('should show modal test status', async () => {
        vi.mocked(inquirerService.prompt).mockResolvedValue({
            tool: 'modal-test',
            modalAction: 'status',
        });

        await command.run([], {});

        expect(developerToolsService.getModalTestStatus).toHaveBeenCalled();
        expect(logService.info).toHaveBeenCalledWith('Modal Test Tool Status');
    });

    it('should handle sandbox selection in interactive mode', async () => {
        vi.mocked(inquirerService.prompt).mockResolvedValue({
            tool: 'sandbox',
            sandboxEnabled: true,
        });

        await command.run([], {});

        expect(developerToolsService.setSandboxMode).toHaveBeenCalledWith(true);
    });

    it('should handle modal test enable in interactive mode', async () => {
        vi.mocked(inquirerService.prompt).mockResolvedValue({
            tool: 'modal-test',
            modalAction: 'enable',
        });

        await command.run([], {});

        expect(developerToolsService.enableModalTest).toHaveBeenCalled();
    });

    it('should handle errors gracefully', async () => {
        const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
            throw new Error('process.exit called');
        });

        vi.mocked(developerToolsService.setSandboxMode).mockRejectedValue(new Error('Test error'));

        await expect(command.run([], { sandbox: true })).rejects.toThrow('process.exit called');

        expect(mockExit).toHaveBeenCalledWith(1);
        mockExit.mockRestore();
    });
});