homeio

1import { describe, expect, it, vi, beforeEach } from "vitest";
2
3const { mockExecFile, mockAccess, mockWriteFile, mockUnlink } = vi.hoisted(() => ({
4  mockExecFile: vi.fn(),
5  mockAccess: vi.fn(),
6  mockWriteFile: vi.fn(),
7  mockUnlink: vi.fn(),
8}));
9
10vi.mock("node:child_process", () => ({ execFile: mockExecFile }));
11vi.mock("node:fs/promises", () => ({
12  access: mockAccess,
13  writeFile: mockWriteFile,
14  unlink: mockUnlink,
15}));
16vi.mock("node:util", () => ({
17  promisify: (fn: unknown) => (fn === mockExecFile ? mockExecFile : fn),
18}));
19
20import { getLocalTailscaleStatus, installTailscale } from "@/lib/server/modules/integrations/tailscale-status";
21
22const runningJson = JSON.stringify({
23  BackendState: "Running",
24  Self: {
25    HostName: "homeserver",
26    DNSName: "homeserver.example.ts.net",
27    TailscaleIPs: ["100.64.0.1"],
28    Online: true,
29  },
30});
31
32beforeEach(() => {
33  vi.clearAllMocks();
34  mockUnlink.mockResolvedValue(undefined);
35  mockWriteFile.mockResolvedValue(undefined);
36});
37
38describe("getLocalTailscaleStatus", () => {
39  it("returns not-installed when CLI is absent", async () => {
40    mockAccess.mockResolvedValue(undefined);
41    const err = Object.assign(new Error("ENOENT"), { code: "ENOENT" });
42    mockExecFile.mockRejectedValueOnce(err);
43
44    const status = await getLocalTailscaleStatus();
45
46    expect(status.installed).toBe(false);
47    expect(status.connected).toBe(false);
48    expect(status.error).toContain("not installed");
49  });
50
51  it("returns connected status when daemon is Running", async () => {
52    mockAccess.mockResolvedValue(undefined);
53    mockExecFile.mockResolvedValueOnce({ stdout: runningJson, stderr: "" });
54
55    const status = await getLocalTailscaleStatus();
56
57    expect(status.installed).toBe(true);
58    expect(status.connected).toBe(true);
59    expect(status.hostname).toBe("homeserver");
60    expect(status.tailscaleIps).toEqual(["100.64.0.1"]);
61    expect(status.issue).toBeNull();
62  });
63
64  it("reports missing_tun when /dev/net/tun is absent", async () => {
65    mockAccess.mockRejectedValue(new Error("ENOENT"));
66    mockExecFile.mockRejectedValueOnce(new Error("failed to open /dev/net/tun: no such file"));
67
68    const status = await getLocalTailscaleStatus();
69
70    expect(status.tunAvailable).toBe(false);
71    expect(status.issue).toBe("missing_tun");
72  });
73
74  it("reports service_unavailable when daemon is down but TUN exists", async () => {
75    mockAccess.mockResolvedValue(undefined);
76    mockExecFile.mockRejectedValueOnce(new Error("dial tcp: connect refused"));
77
78    const status = await getLocalTailscaleStatus();
79
80    expect(status.installed).toBe(true);
81    expect(status.issue).toBe("service_unavailable");
82  });
83});
84
85describe("installTailscale", () => {
86  it("returns installed status without activating when no auth key", async () => {
87    mockAccess.mockResolvedValue(undefined);
88    mockExecFile.mockResolvedValueOnce({ stdout: runningJson, stderr: "" });
89    mockExecFile.mockResolvedValueOnce({ stdout: runningJson, stderr: "" });
90
91    const result = await installTailscale(undefined);
92
93    expect(result.installed).toBe(true);
94    expect(result.activated).toBe(true);
95    expect(mockWriteFile).not.toHaveBeenCalled();
96  });
97
98  it("writes key to temp file and uses file: prefix instead of inline arg", async () => {
99    mockAccess.mockResolvedValue(undefined);
100    mockExecFile
101      .mockResolvedValueOnce({ stdout: runningJson, stderr: "" })
102      .mockResolvedValueOnce({ stdout: runningJson, stderr: "" })
103      .mockResolvedValueOnce({ stdout: "", stderr: "" })
104      .mockResolvedValueOnce({ stdout: "", stderr: "" })
105      .mockResolvedValueOnce({ stdout: "", stderr: "" });
106
107    await installTailscale("tskey-auth-test");
108
109    const tailscaleUpCall = mockExecFile.mock.calls.find(
110      (call: unknown[]) =>
111        Array.isArray(call[1]) &&
112        (call[1] as string[]).some((a) => (a as string).startsWith("--auth-key")),
113    );
114    expect(tailscaleUpCall).toBeDefined();
115    const authKeyArg = (tailscaleUpCall?.[1] as string[]).find((a) =>
116      (a as string).startsWith("--auth-key"),
117    );
118    expect(authKeyArg).toMatch(/^--auth-key=file:/);
119    expect(authKeyArg).not.toContain("tskey-auth-test");
120
121    expect(mockWriteFile).toHaveBeenCalledWith(
122      expect.stringContaining("ts-key-"),
123      "tskey-auth-test",
124      { mode: 0o600 },
125    );
126    expect(mockUnlink).toHaveBeenCalled();
127  });
128
129  it("cleans up temp file even when tailscale up fails", async () => {
130    mockAccess.mockResolvedValue(undefined);
131    const ok = { stdout: runningJson, stderr: "" };
132    mockExecFile
133      .mockResolvedValueOnce(ok)
134      .mockResolvedValueOnce(ok)
135      .mockResolvedValueOnce({ stdout: "", stderr: "" })
136      .mockResolvedValueOnce({ stdout: "", stderr: "" })
137      .mockRejectedValueOnce(new Error("auth failed"));
138
139    await expect(installTailscale("tskey-bad")).rejects.toThrow("auth failed");
140
141    expect(mockUnlink).toHaveBeenCalled();
142  });
143
144  it("rejects concurrent install calls", async () => {
145    mockAccess.mockResolvedValue(undefined);
146    let resolveFirst!: () => void;
147    const slowPromise = new Promise<{ stdout: string; stderr: string }>((res) => {
148      resolveFirst = () => res({ stdout: runningJson, stderr: "" });
149    });
150    mockExecFile.mockReturnValueOnce(slowPromise).mockReturnValue(slowPromise);
151
152    const first = installTailscale(undefined);
153    await expect(installTailscale(undefined)).rejects.toThrow("already in progress");
154    resolveFirst();
155    await first.catch(() => {});
156  });
157});
158