discord-rpg-concept/shared/modules/admin/update.service.test.ts

import { describe, expect, test, mock, beforeEach, afterAll, spyOn } from "bun:test";
import * as fs from "fs/promises";

// Mock child_process BEFORE importing the service
const mockExec = mock((cmd: string, callback?: any) => {
    // Handle calls without callback (like exec().unref())
    if (!callback) {
        return { unref: () => { } };
    }

    if (cmd.includes("git rev-parse")) {
        callback(null, { stdout: "main\n" });
    } else if (cmd.includes("git fetch")) {
        callback(null, { stdout: "" });
    } else if (cmd.includes("git log")) {
        callback(null, { stdout: "abcdef Update 1\n123456 Update 2" });
    } else if (cmd.includes("git diff")) {
        callback(null, { stdout: "package.json\nsrc/index.ts" });
    } else if (cmd.includes("git reset")) {
        callback(null, { stdout: "HEAD is now at abcdef Update 1" });
    } else if (cmd.includes("bun install")) {
        callback(null, { stdout: "Installed dependencies" });
    } else if (cmd.includes("drizzle-kit migrate")) {
        callback(null, { stdout: "Migrations applied" });
    } else {
        callback(null, { stdout: "" });
    }
});

mock.module("child_process", () => ({
    exec: mockExec
}));

// Mock fs/promises
const mockWriteFile = mock((path: string, content: string) => Promise.resolve());
const mockReadFile = mock((path: string, encoding: string) => Promise.resolve("{}"));
const mockUnlink = mock((path: string) => Promise.resolve());

mock.module("fs/promises", () => ({
    writeFile: mockWriteFile,
    readFile: mockReadFile,
    unlink: mockUnlink
}));

// Mock view module to avoid import issues
mock.module("./update.view", () => ({
    getPostRestartEmbed: () => ({ title: "Update Complete" }),
    getInstallingDependenciesEmbed: () => ({ title: "Installing..." }),
}));

describe("UpdateService", () => {
    let UpdateService: any;

    beforeEach(async () => {
        mockExec.mockClear();
        mockWriteFile.mockClear();
        mockReadFile.mockClear();
        mockUnlink.mockClear();

        // Dynamically import to ensure mock is used
        const module = await import("./update.service");
        UpdateService = module.UpdateService;
    });

    afterAll(() => {
        mock.restore();
    });

    describe("checkForUpdates", () => {
        test("should return updates if git log has output", async () => {
            const result = await UpdateService.checkForUpdates();

            expect(result.hasUpdates).toBe(true);
            expect(result.branch).toBe("main");
            expect(result.log).toContain("Update 1");
        });

        test("should call git rev-parse, fetch, and log commands", async () => {
            await UpdateService.checkForUpdates();

            const calls = mockExec.mock.calls.map((c: any) => c[0]);
            expect(calls.some((cmd: string) => cmd.includes("git rev-parse"))).toBe(true);
            expect(calls.some((cmd: string) => cmd.includes("git fetch"))).toBe(true);
            expect(calls.some((cmd: string) => cmd.includes("git log"))).toBe(true);
        });
    });

    describe("performUpdate", () => {
        test("should run git reset --hard with correct branch", async () => {
            await UpdateService.performUpdate("main");

            const lastCall = mockExec.mock.lastCall;
            expect(lastCall).toBeDefined();
            expect(lastCall![0]).toContain("git reset --hard origin/main");
        });
    });

    describe("checkUpdateRequirements", () => {
        test("should detect package.json and schema.ts changes", async () => {
            const result = await UpdateService.checkUpdateRequirements("main");

            expect(result.needsInstall).toBe(true);
            expect(result.needsMigrations).toBe(false); // mock doesn't include schema.ts
            expect(result.error).toBeUndefined();
        });

        test("should call git diff with correct branch", async () => {
            await UpdateService.checkUpdateRequirements("develop");

            const lastCall = mockExec.mock.lastCall;
            expect(lastCall).toBeDefined();
            expect(lastCall![0]).toContain("git diff HEAD..origin/develop");
        });
    });

    describe("installDependencies", () => {
        test("should run bun install and return output", async () => {
            const output = await UpdateService.installDependencies();

            expect(output).toBe("Installed dependencies");
            const lastCall = mockExec.mock.lastCall;
            expect(lastCall![0]).toBe("bun install");
        });
    });

    describe("prepareRestartContext", () => {
        test("should write context to file", async () => {
            const context = {
                channelId: "123",
                userId: "456",
                timestamp: Date.now(),
                runMigrations: true,
                installDependencies: false
            };

            await UpdateService.prepareRestartContext(context);

            expect(mockWriteFile).toHaveBeenCalled();
            const lastCall = mockWriteFile.mock.lastCall as [string, string] | undefined;
            expect(lastCall).toBeDefined();
            expect(lastCall![0]).toContain("restart_context");
            expect(JSON.parse(lastCall![1])).toEqual(context);
        });
    });

    describe("triggerRestart", () => {
        test("should use RESTART_COMMAND env var when set", async () => {
            const originalEnv = process.env.RESTART_COMMAND;
            process.env.RESTART_COMMAND = "pm2 restart bot";

            await UpdateService.triggerRestart();

            const lastCall = mockExec.mock.lastCall;
            expect(lastCall).toBeDefined();
            expect(lastCall![0]).toBe("pm2 restart bot");

            process.env.RESTART_COMMAND = originalEnv;
        });

        test("should write to trigger file when no env var", async () => {
            const originalEnv = process.env.RESTART_COMMAND;
            delete process.env.RESTART_COMMAND;

            await UpdateService.triggerRestart();

            expect(mockWriteFile).toHaveBeenCalled();
            const lastCall = mockWriteFile.mock.lastCall as [string, string] | undefined;
            expect(lastCall).toBeDefined();
            expect(lastCall![0]).toContain("restart_trigger");

            process.env.RESTART_COMMAND = originalEnv;
        });
    });

    describe("handlePostRestart", () => {
        const createMockClient = (channel: any = null) => ({
            channels: {
                fetch: mock(() => Promise.resolve(channel))
            }
        });

        const createMockChannel = () => ({
            isSendable: () => true,
            send: mock(() => Promise.resolve())
        });

        test("should ignore stale context (>10 mins old)", async () => {
            const staleContext = {
                channelId: "123",
                userId: "456",
                timestamp: Date.now() - (15 * 60 * 1000), // 15 mins ago
                runMigrations: true,
                installDependencies: true
            };

            mockReadFile.mockImplementationOnce(() => Promise.resolve(JSON.stringify(staleContext)));

            const mockChannel = createMockChannel();
            // Create mock with instanceof support
            const channel = Object.assign(mockChannel, { constructor: { name: "TextChannel" } });
            Object.setPrototypeOf(channel, Object.create({ constructor: { name: "TextChannel" } }));

            const mockClient = createMockClient(channel);

            await UpdateService.handlePostRestart(mockClient);

            // Should not send any message for stale context
            expect(mockChannel.send).not.toHaveBeenCalled();
            // Should clean up the context file
            expect(mockUnlink).toHaveBeenCalled();
        });

        test("should do nothing if no context file exists", async () => {
            mockReadFile.mockImplementationOnce(() => Promise.reject(new Error("ENOENT")));

            const mockClient = createMockClient();

            await UpdateService.handlePostRestart(mockClient);

            // Should not throw and not try to clean up
            expect(mockUnlink).not.toHaveBeenCalled();
        });

        test("should clean up context file after processing", async () => {
            const validContext = {
                channelId: "123",
                userId: "456",
                timestamp: Date.now(),
                runMigrations: false,
                installDependencies: false
            };

            mockReadFile.mockImplementationOnce(() => Promise.resolve(JSON.stringify(validContext)));

            // Create a proper TextChannel mock
            const { TextChannel } = await import("discord.js");
            const mockChannel = Object.create(TextChannel.prototype);
            mockChannel.isSendable = () => true;
            mockChannel.send = mock(() => Promise.resolve());

            const mockClient = createMockClient(mockChannel);

            await UpdateService.handlePostRestart(mockClient);

            expect(mockUnlink).toHaveBeenCalled();
        });
    });
});