Commander.test.ts

import { createCommander, } from './Commander';

describe('Commander', () => {
    let mockLink : any;

    beforeEach(() => {
        mockLink = {
            send  : vi.fn(),
            close : vi.fn(),
        };

        vi.useFakeTimers();
    });

    afterEach(() => {
        vi.clearAllMocks();
        vi.restoreAllMocks();
    });

    describe('createCommander', () => {
        it('should create a commander with default heartbeat interval', () => {
            const commander = createCommander(mockLink);

            expect(commander).toHaveProperty('sendCommand');
            expect(commander).toHaveProperty('dispose');
        });

        it('should send command with type and payload', () => {
            const commander = createCommander(mockLink);

            commander.sendCommand({
                type    : 'toggle',
                payload : {
                    state : true,
                },
            });

            expect(mockLink.send).toHaveBeenCalledWith({
                type    : 'toggle',
                payload : {
                    state : true,
                },
            });
        });

        it('should send command with type only', () => {
            const commander = createCommander(mockLink);

            commander.sendCommand({
                type : 'status',
            });

            expect(mockLink.send).toHaveBeenCalledWith({
                type    : 'status',
                payload : undefined,
            });
        });

        it('should update lastSent timestamp when sending command', () => {
            const commander = createCommander(mockLink, 100);

            commander.sendCommand({
                type : 'test',
            });

            expect(mockLink.send).toHaveBeenCalled();
        });

        it('should send heartbeat when no command has been sent recently', () => {
            createCommander(mockLink, 100);

            vi.advanceTimersByTime(250);

            expect(mockLink.send).toHaveBeenCalledWith({
                type : 'heartbeat',
            });
        });

        it('should not send heartbeat if command was recently sent', () => {
            const commander = createCommander(mockLink, 100);

            commander.sendCommand({
                type : 'test',
            });

            mockLink.send.mockClear();

            vi.advanceTimersByTime(50);

            expect(mockLink.send).not.toHaveBeenCalled();
        });

        it('should send heartbeat when interval has passed since last command', () => {
            const commander = createCommander(mockLink, 100);

            commander.sendCommand({
                type : 'test',
            });

            mockLink.send.mockClear();

            vi.advanceTimersByTime(250);

            expect(mockLink.send).toHaveBeenCalledWith({
                type : 'heartbeat',
            });
        });

        it('should respect custom heartbeat interval', () => {
            const commander = createCommander(mockLink, 50);

            commander.sendCommand({
                type : 'test',
            });

            mockLink.send.mockClear();

            vi.advanceTimersByTime(40);
            expect(mockLink.send).not.toHaveBeenCalled();

            vi.advanceTimersByTime(120);
            expect(mockLink.send).toHaveBeenCalledWith({
                type : 'heartbeat',
            });
        });

        it('should continue sending heartbeats at intervals', () => {
            createCommander(mockLink, 100);

            mockLink.send.mockClear();

            vi.advanceTimersByTime(250);
            expect(mockLink.send).toHaveBeenCalledTimes(1);

            vi.advanceTimersByTime(150);
            expect(mockLink.send).toHaveBeenCalledTimes(2);

            vi.advanceTimersByTime(250);
            expect(mockLink.send).toHaveBeenCalledTimes(3);
        });

        it('should reset heartbeat timer after sending command', () => {
            const commander = createCommander(mockLink, 100);

            commander.sendCommand({
                type : 'cmd1',
            });
            mockLink.send.mockClear();

            vi.advanceTimersByTime(50);
            commander.sendCommand({
                type : 'cmd2',
            });
            mockLink.send.mockClear();

            vi.advanceTimersByTime(50);
            expect(mockLink.send).not.toHaveBeenCalled();

            vi.advanceTimersByTime(160);
            expect(mockLink.send).toHaveBeenCalledWith({
                type : 'heartbeat',
            });
        });

        describe('dispose', () => {
            it('should clear the heartbeat interval', () => {
                const cmd = createCommander(mockLink, 100);

                cmd.dispose();
                mockLink.send.mockClear();

                vi.advanceTimersByTime(200);

                expect(mockLink.send).not.toHaveBeenCalled();
            });

            it('should close the device link', () => {
                const commander = createCommander(mockLink);

                commander.dispose();

                expect(mockLink.close).toHaveBeenCalled();
            });

            it('should prevent further commands after dispose', () => {
                const commander = createCommander(mockLink);

                commander.dispose();
                mockLink.send.mockClear();
            });

            it('should prevent heartbeats after dispose', () => {
                const commander = createCommander(mockLink, 100);

                commander.dispose();
                mockLink.send.mockClear();

                vi.advanceTimersByTime(500);

                expect(mockLink.send).not.toHaveBeenCalled();
            });

            it('should allow multiple dispose calls', () => {
                const commander = createCommander(mockLink);

                commander.dispose();
                commander.dispose();

                expect(mockLink.close).toHaveBeenCalledTimes(2);
            });
        });

        it('should handle rapid command sending', () => {
            const commander = createCommander(mockLink, 100);

            mockLink.send.mockClear();

            commander.sendCommand({
                type: 'cmd1',
            });

            commander.sendCommand({
                type: 'cmd2',
            });

            commander.sendCommand({
                type: 'cmd3',
            });

            expect(mockLink.send).toHaveBeenCalledTimes(3);

            vi.advanceTimersByTime(250);

            expect(mockLink.send).toHaveBeenCalledTimes(4);
        });

        it('should track lastSent correctly across multiple commands', () => {
            const commander = createCommander(mockLink, 100);

            commander.sendCommand({
                type : 'cmd1',
            });

            mockLink.send.mockClear();

            vi.advanceTimersByTime(50);

            commander.sendCommand({
                type : 'cmd2',
            });

            mockLink.send.mockClear();

            vi.advanceTimersByTime(60);

            expect(mockLink.send).not.toHaveBeenCalled();

            vi.advanceTimersByTime(150);

            expect(mockLink.send).toHaveBeenCalledWith({
                type : 'heartbeat',
            });
        });
    });
});