homeio

1import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
2import os from "node:os";
3import path from "node:path";
4import { beforeEach, describe, expect, it, vi } from "vitest";
5
6vi.mock("@/lib/server/modules/apps/repository", () => ({
7  listInstalledAppsFromDb: vi.fn(),
8  findActiveStoreOperationsByAppIds: vi.fn(),
9}));
10
11vi.mock("@/lib/server/modules/docker/compose-runner", () => ({
12  getComposeRuntimeInfo: vi.fn(),
13}));
14
15const tempRoots = vi.hoisted(() => ({
16  dataRoot: "",
17  stacksRoot: "",
18}));
19
20vi.mock("node:fs/promises", async () => {
21  const actual = await vi.importActual("node:fs/promises");
22
23  return {
24    ...actual,
25    readFile: vi.fn(),
26  };
27});
28
29vi.mock("@/lib/server/modules/docker/compose-parser", () => ({
30  parseComposeFile: vi.fn(),
31  extractPrimaryServiceWithName: vi.fn(),
32}));
33
34vi.mock("@/lib/server/storage/data-root", () => ({
35  resolveDataRootDirectory: () => tempRoots.dataRoot,
36  resolveStoreStacksRoot: () => tempRoots.stacksRoot,
37}));
38
39import {
40    findActiveStoreOperationsByAppIds,
41    listInstalledAppsFromDb,
42} from "@/lib/server/modules/apps/repository";
43import {
44    invalidateInstalledAppsCache,
45    listInstalledApps,
46} from "@/lib/server/modules/apps/service";
47import {
48    extractPrimaryServiceWithName,
49    parseComposeFile,
50} from "@/lib/server/modules/docker/compose-parser";
51import { getComposeRuntimeInfo } from "@/lib/server/modules/docker/compose-runner";
52import { readFile } from "node:fs/promises";
53
54describe("apps service", () => {
55  const repositoryMock = vi.mocked(listInstalledAppsFromDb);
56  const activeOperationsMock = vi.mocked(findActiveStoreOperationsByAppIds);
57  const runtimeInfoMock = vi.mocked(getComposeRuntimeInfo);
58  const readFileMock = vi.mocked(readFile);
59  const parseComposeFileMock = vi.mocked(parseComposeFile);
60  const extractPrimaryServiceMock = vi.mocked(extractPrimaryServiceWithName);
61
62  beforeEach(() => {
63    invalidateInstalledAppsCache();
64    repositoryMock.mockReset();
65    activeOperationsMock.mockReset();
66    runtimeInfoMock.mockReset();
67    readFileMock.mockReset();
68    parseComposeFileMock.mockReset();
69    extractPrimaryServiceMock.mockReset();
70    runtimeInfoMock.mockResolvedValue({
71      status: "running",
72      containerNames: ["nextcloud-app-1"],
73      primaryContainerName: "nextcloud-app-1",
74    });
75    activeOperationsMock.mockResolvedValue({});
76    readFileMock.mockResolvedValue("");
77    parseComposeFileMock.mockReturnValue(null);
78    extractPrimaryServiceMock.mockReturnValue(null);
79    tempRoots.dataRoot = "";
80    tempRoots.stacksRoot = "";
81  });
82
83  it("caches installed apps", async () => {
84    repositoryMock.mockResolvedValueOnce([
85      {
86        id: "nextcloud",
87        name: "Nextcloud",
88        stackName: "nextcloud",
89        composePath: "/DATA/AppData/nextcloud/docker-compose.yml",
90        status: "unknown",
91        activeOperation: null,
92        updatedAt: "2026-02-22T10:00:00.000Z",
93      },
94    ]);
95
96    const first = await listInstalledApps();
97    const second = await listInstalledApps();
98
99    expect(first[0]?.containerName).toBe("nextcloud-app-1");
100    expect(first).toEqual(second);
101    expect(repositoryMock).toHaveBeenCalledTimes(1);
102  });
103
104  it("bypasses cache when requested", async () => {
105    repositoryMock.mockResolvedValue([
106      {
107        id: "immich",
108        name: "Immich",
109        stackName: "immich",
110        composePath: "/DATA/AppData/immich/docker-compose.yml",
111        status: "unknown",
112        activeOperation: null,
113        updatedAt: "2026-02-22T11:00:00.000Z",
114      },
115    ]);
116
117    await listInstalledApps({ bypassCache: true });
118    await listInstalledApps({ bypassCache: true });
119
120    expect(repositoryMock).toHaveBeenCalledTimes(2);
121  });
122
123  it("falls back to empty list when db is unavailable", async () => {
124    const unavailableError = Object.assign(
125      new Error("connect ECONNREFUSED 127.0.0.1:5432"),
126      { code: "ECONNREFUSED" },
127    );
128    repositoryMock.mockRejectedValueOnce(unavailableError);
129
130    const first = await listInstalledApps({ bypassCache: true });
131    const second = await listInstalledApps();
132
133    expect(first).toEqual([]);
134    expect(second).toEqual([]);
135    expect(repositoryMock).toHaveBeenCalledTimes(1);
136  });
137
138  it("infers web ui port from installed compose when DB port is null", async () => {
139    repositoryMock.mockResolvedValueOnce([
140      {
141        id: "dozzle",
142        name: "Dozzle",
143        stackName: "dozzle",
144        composePath: "/DATA/AppData/dozzle/docker-compose.yml",
145        webUiPort: null,
146        status: "unknown",
147        activeOperation: null,
148        updatedAt: "2026-02-22T10:00:00.000Z",
149      },
150    ]);
151    readFileMock.mockResolvedValue(
152      'services:\n  app:\n    ports:\n      - "9999:8080"\n',
153    );
154    parseComposeFileMock.mockReturnValue({
155      services: {
156        app: {
157          ports: ["9999:8080"],
158          environment: {},
159        },
160      },
161    });
162    extractPrimaryServiceMock.mockReturnValue({
163      name: "app",
164      service: {
165        ports: ["9999:8080"],
166        environment: {},
167      },
168    });
169
170    const apps = await listInstalledApps({ bypassCache: true });
171
172    expect(apps[0]?.webUiPort).toBe(9999);
173    expect(readFileMock).toHaveBeenCalledWith(
174      "/DATA/AppData/dozzle/docker-compose.yml",
175      "utf8",
176    );
177  });
178
179  it("hydrates active operations for installed apps", async () => {
180    repositoryMock.mockResolvedValueOnce([
181      {
182        id: "jellyfin",
183        name: "Jellyfin",
184        stackName: "jellyfin",
185        composePath: "/DATA/AppData/jellyfin/docker-compose.yml",
186        status: "unknown",
187        activeOperation: null,
188        updatedAt: "2026-02-22T12:00:00.000Z",
189      },
190    ]);
191    activeOperationsMock.mockResolvedValueOnce({
192      jellyfin: {
193        id: "op-1",
194        action: "redeploy",
195        status: "running",
196        progressPercent: 64,
197        currentStep: "compose-up",
198        updatedAt: "2026-02-22T12:00:05.000Z",
199      },
200    });
201
202    const apps = await listInstalledApps({ bypassCache: true });
203
204    expect(apps[0]?.activeOperation).toEqual({
205      id: "op-1",
206      action: "redeploy",
207      status: "running",
208      progressPercent: 64,
209      currentStep: "compose-up",
210      updatedAt: "2026-02-22T12:00:05.000Z",
211    });
212  });
213
214  it("normalizes stale compose paths after restore and uses the active stack root", async () => {
215    const actualRoot = await mkdtemp(path.join(os.tmpdir(), "homeio-apps-"));
216    tempRoots.dataRoot = actualRoot;
217    tempRoots.stacksRoot = path.join(actualRoot, "missing-stacks");
218
219    const actualComposePath = path.join(
220      actualRoot,
221      "data-root",
222      "Apps",
223      "grafana",
224      "docker-compose.yml",
225    );
226    await mkdir(path.dirname(actualComposePath), { recursive: true });
227    await writeFile(
228      actualComposePath,
229      "services:\n  grafana:\n    image: grafana/grafana:latest\n",
230      "utf8",
231    );
232
233    repositoryMock.mockResolvedValueOnce([
234      {
235        id: "grafana",
236        name: "Grafana",
237        stackName: "grafana",
238        composePath: "/var/lib/home-server/Apps/grafana/docker-compose.yml",
239        status: "unknown",
240        activeOperation: null,
241        updatedAt: "2026-02-22T10:00:00.000Z",
242      },
243    ]);
244
245    runtimeInfoMock.mockResolvedValueOnce({
246      status: "running",
247      containerNames: ["grafana"],
248      primaryContainerName: "grafana",
249    });
250
251    const apps = await listInstalledApps({ bypassCache: true });
252
253    expect(runtimeInfoMock).toHaveBeenCalledWith({
254      composePath: actualComposePath,
255      envPath: path.join(path.dirname(actualComposePath), ".env"),
256      stackName: "grafana",
257    });
258    expect(apps[0]?.composePath).toBe(actualComposePath);
259    expect(apps[0]?.containerName).toBe("grafana");
260  });
261});
262