334 lines
13 KiB
TypeScript
334 lines
13 KiB
TypeScript
import { describe, expect, test, mock, beforeEach, afterAll } from "bun:test";
|
|
|
|
// 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: () => { } };
|
|
}
|
|
|
|
// Simulate successful command execution
|
|
let stdout = "";
|
|
|
|
if (cmd.includes("git rev-parse --abbrev-ref")) {
|
|
stdout = "main\n";
|
|
} else if (cmd.includes("git rev-parse --short")) {
|
|
stdout = "abc1234\n";
|
|
} else if (cmd.includes("git rev-parse HEAD")) {
|
|
stdout = "abc1234567890\n";
|
|
} else if (cmd.includes("git fetch")) {
|
|
stdout = "";
|
|
} else if (cmd.includes("git log")) {
|
|
stdout = "abcdef|Update 1|Author1\n123456|Update 2|Author2";
|
|
} else if (cmd.includes("git diff")) {
|
|
stdout = "package.json\nsrc/index.ts\nshared/lib/schema.ts";
|
|
} else if (cmd.includes("git reset")) {
|
|
stdout = "HEAD is now at abcdef Update 1";
|
|
} else if (cmd.includes("bun install")) {
|
|
stdout = "Installed dependencies";
|
|
} else if (cmd.includes("drizzle-kit migrate")) {
|
|
stdout = "Migrations applied";
|
|
} else if (cmd.includes("bun run build")) {
|
|
stdout = "Build completed";
|
|
}
|
|
|
|
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("@/modules/admin/update.view", () => ({
|
|
getPostRestartEmbed: () => ({ embeds: [{ title: "Update Complete" }], components: [] }),
|
|
getPostRestartProgressEmbed: () => ({ title: "Progress..." }),
|
|
}));
|
|
|
|
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.commits.length).toBeGreaterThan(0);
|
|
expect(result.commits[0].message).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);
|
|
});
|
|
|
|
test("should include requirements in the response", async () => {
|
|
const result = await UpdateService.checkForUpdates();
|
|
|
|
expect(result.requirements).toBeDefined();
|
|
expect(result.requirements.needsRootInstall).toBe(true); // package.json is in mock
|
|
expect(result.requirements.needsMigrations).toBe(true); // schema.ts is in mock
|
|
expect(result.requirements.changedFiles).toContain("package.json");
|
|
});
|
|
});
|
|
|
|
describe("performUpdate", () => {
|
|
test("should run git reset --hard with correct branch", async () => {
|
|
await UpdateService.performUpdate("main");
|
|
|
|
const calls = mockExec.mock.calls.map((c: any) => c[0]);
|
|
expect(calls.some((cmd: string) => cmd.includes("git reset --hard origin/main"))).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("checkUpdateRequirements (deprecated)", () => {
|
|
test("should detect package.json and schema.ts changes", async () => {
|
|
const result = await UpdateService.checkUpdateRequirements("main");
|
|
|
|
expect(result.needsRootInstall).toBe(true);
|
|
expect(result.needsMigrations).toBe(true);
|
|
expect(result.error).toBeUndefined();
|
|
});
|
|
|
|
test("should call git diff with correct branch", async () => {
|
|
await UpdateService.checkUpdateRequirements("develop");
|
|
|
|
const calls = mockExec.mock.calls.map((c: any) => c[0]);
|
|
expect(calls.some((cmd: string) => cmd.includes("git diff HEAD..origin/develop"))).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("installDependencies", () => {
|
|
test("should run bun install for root only", async () => {
|
|
const output = await UpdateService.installDependencies({ root: true, web: false });
|
|
|
|
expect(output).toContain("Root");
|
|
const calls = mockExec.mock.calls.map((c: any) => c[0]);
|
|
expect(calls.some((cmd: string) => cmd === "bun install")).toBe(true);
|
|
});
|
|
|
|
test("should run bun install for both root and web in parallel", async () => {
|
|
const output = await UpdateService.installDependencies({ root: true, web: true });
|
|
|
|
expect(output).toContain("Root");
|
|
expect(output).toContain("Web");
|
|
const calls = mockExec.mock.calls.map((c: any) => c[0]);
|
|
expect(calls.some((cmd: string) => cmd === "bun install")).toBe(true);
|
|
expect(calls.some((cmd: string) => cmd.includes("cd web && bun install"))).toBe(true);
|
|
});
|
|
});
|
|
|
|
describe("categorizeChanges", () => {
|
|
test("should categorize files correctly", () => {
|
|
const files = [
|
|
"bot/commands/admin/update.ts",
|
|
"bot/modules/admin/update.view.ts",
|
|
"web/src/components/Button.tsx",
|
|
"shared/lib/utils.ts",
|
|
"package.json",
|
|
"drizzle/0001_migration.sql"
|
|
];
|
|
|
|
const categories = UpdateService.categorizeChanges(files);
|
|
|
|
expect(categories["Commands"]).toBe(1);
|
|
expect(categories["Modules"]).toBe(1);
|
|
expect(categories["Web Dashboard"]).toBe(1);
|
|
expect(categories["Library"]).toBe(1);
|
|
expect(categories["Dependencies"]).toBe(1);
|
|
expect(categories["Database"]).toBe(1);
|
|
});
|
|
});
|
|
|
|
describe("prepareRestartContext", () => {
|
|
test("should write context to file", async () => {
|
|
const context = {
|
|
channelId: "123",
|
|
userId: "456",
|
|
timestamp: Date.now(),
|
|
runMigrations: true,
|
|
installDependencies: false,
|
|
buildWebAssets: false,
|
|
previousCommit: "abc1234",
|
|
newCommit: "def5678"
|
|
};
|
|
|
|
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("saveRollbackPoint", () => {
|
|
test("should save current commit hash to file", async () => {
|
|
const commit = await UpdateService.saveRollbackPoint();
|
|
|
|
expect(commit).toBeTruthy();
|
|
expect(mockWriteFile).toHaveBeenCalled();
|
|
const lastCall = mockWriteFile.mock.lastCall as [string, string] | undefined;
|
|
expect(lastCall![0]).toContain("rollback_commit");
|
|
});
|
|
});
|
|
|
|
describe("hasRollbackPoint", () => {
|
|
test("should return true when rollback file exists", async () => {
|
|
mockReadFile.mockImplementationOnce(() => Promise.resolve("abc123"));
|
|
|
|
// Clear cache first
|
|
(UpdateService as any).rollbackPointExists = null;
|
|
|
|
const result = await UpdateService.hasRollbackPoint();
|
|
expect(result).toBe(true);
|
|
});
|
|
|
|
test("should return false when rollback file does not exist", async () => {
|
|
mockReadFile.mockImplementationOnce(() => Promise.reject(new Error("ENOENT")));
|
|
|
|
// Clear cache first
|
|
(UpdateService as any).rollbackPointExists = null;
|
|
|
|
const result = await UpdateService.hasRollbackPoint();
|
|
expect(result).toBe(false);
|
|
});
|
|
});
|
|
|
|
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 calls = mockExec.mock.calls.map((c: any) => c[0]);
|
|
expect(calls.some((cmd: string) => cmd === "pm2 restart bot")).toBe(true);
|
|
|
|
process.env.RESTART_COMMAND = originalEnv;
|
|
});
|
|
|
|
test("should call process.exit when no env var is set", async () => {
|
|
const originalEnv = process.env.RESTART_COMMAND;
|
|
delete process.env.RESTART_COMMAND;
|
|
|
|
// Just verify it doesn't throw - actual process.exit is mocked by setTimeout
|
|
await UpdateService.triggerRestart();
|
|
|
|
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({ edit: mock(() => Promise.resolve()), delete: 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,
|
|
buildWebAssets: false,
|
|
previousCommit: "abc",
|
|
newCommit: "def"
|
|
};
|
|
|
|
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,
|
|
buildWebAssets: false,
|
|
previousCommit: "abc",
|
|
newCommit: "def"
|
|
};
|
|
|
|
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({ edit: mock(() => Promise.resolve()), delete: mock(() => Promise.resolve()) }));
|
|
|
|
const mockClient = createMockClient(mockChannel);
|
|
|
|
await UpdateService.handlePostRestart(mockClient);
|
|
|
|
expect(mockUnlink).toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|