homeio

1import { describe, expect, it } from "vitest";
2
3import {
4  buildInstallPayloadFromClassic,
5  buildSettingsPayloadFromClassic,
6  buildInitialComposeDraft,
7  classicStateToCompose,
8  composeToClassicState,
9  createDefaultClassicState,
10  safeComposeToClassicState,
11} from "@/modules/apps/components/configurator/configurator-mapper";
12
13describe("configurator-mapper", () => {
14  it("maps compose draft to classic state", () => {
15    const composeDraft = `services:\n  app:\n    image: ghcr.io/example/app:latest\n    ports:\n      - \"8080:80\"\n    volumes:\n      - \"/data/app:/config\"\n    environment:\n      APP_URL: \"http://example.local:8080\"\n      TZ: \"UTC\"\n    network_mode: bridge\n    restart: unless-stopped\n    privileged: true\n    cap_add:\n      - NET_ADMIN\n    hostname: example-app\n    devices:\n      - /dev/ttyUSB0:/dev/ttyUSB0\n    command: [\"--config\",\"/config/settings.yaml\"]\n`;
16
17    const state = composeToClassicState({
18      composeDraft,
19      seed: {
20        title: "Example",
21        iconUrl: "",
22        fallbackPort: 8080,
23      },
24    });
25
26    expect(state.dockerImage).toBe("ghcr.io/example/app:latest");
27    expect(state.webUi.port).toBe("8080");
28    expect(state.ports[0]?.container).toBe("80");
29    expect(state.volumes[0]?.host).toBe("/data/app");
30    expect(state.envVars.find((entry) => entry.key === "TZ")?.value).toBe("UTC");
31    expect(state.restartPolicy).toBe("unless-stopped");
32    expect(state.privileged).toBe(true);
33    expect(state.capabilities).toContain("NET_ADMIN");
34    expect(state.devices[0]).toBe("/dev/ttyUSB0:/dev/ttyUSB0");
35    expect(state.containerCommands).toEqual(["--config", "/config/settings.yaml"]);
36  });
37
38  it("maps long syntax ports and volumes to classic state", () => {
39    const composeDraft = `services:
40  app:
41    image: ghcr.io/example/app:latest
42    ports:
43      - target: 80
44        published: 8080
45        protocol: tcp
46    volumes:
47      - type: bind
48        source: /data/app
49        target: /config
50      - type: volume
51        source: app-cache
52        target: /cache
53`;
54
55    const state = composeToClassicState({
56      composeDraft,
57      seed: {
58        title: "Example",
59        iconUrl: "",
60      },
61    });
62
63    expect(state.ports[0]?.host).toBe("8080");
64    expect(state.ports[0]?.container).toBe("80");
65    expect(state.volumes[0]?.host).toBe("/data/app");
66    expect(state.volumes[0]?.container).toBe("/config");
67    expect(state.volumes[1]?.host).toBe("app-cache");
68    expect(state.volumes[1]?.container).toBe("/cache");
69  });
70
71  it("prefers app service over db sidecar when appId matches sidecar name", () => {
72    const composeDraft = `services:
73  app:
74    image: photoprism/photoprism:240915
75    ports:
76      - "2342:2342"
77    network_mode: host
78  photoprism-db:
79    image: mariadb:10.8
80`;
81
82    const state = composeToClassicState({
83      composeDraft,
84      appId: "photoprism",
85      seed: {
86        title: "Photoprism",
87        iconUrl: "",
88      },
89    });
90
91    expect(state.dockerImage).toBe("photoprism/photoprism:240915");
92    expect(state.webUi.port).toBe("2342");
93    expect(state.network).toBe("host");
94    expect(state.ports[0]?.host).toBe("2342");
95  });
96
97  it("replaces loopback APP_URL host with fallback host for editing", () => {
98    const composeDraft = `services:
99  app:
100    image: ghcr.io/example/app:latest
101    environment:
102      APP_URL: "http://localhost:3000"
103`;
104
105    const state = composeToClassicState({
106      composeDraft,
107      seed: {
108        title: "Example",
109        iconUrl: "",
110        fallbackPort: 3000,
111        fallbackHost: "192.168.1.12",
112      },
113    });
114
115    expect(state.webUi.host).toBe("192.168.1.12");
116    expect(state.webUi.port).toBe("3000");
117  });
118
119  it("maps classic state back to compose while keeping unknown top-level fields", () => {
120    const seed = createDefaultClassicState({
121      title: "Sample",
122      iconUrl: "",
123      fallbackPort: 8080,
124    });
125
126    const nextState = {
127      ...seed,
128      dockerImage: "nginx:1.27",
129      hostname: "sample-app",
130      envVars: [{ id: "env-1", key: "TZ", value: "UTC" }],
131      ports: [{ id: "p-1", host: "18080", container: "80", protocol: "TCP" as const }],
132    };
133
134    const previousCompose = `name: sample-stack\nservices:\n  app:\n    image: old:image\n`;
135    const compose = classicStateToCompose(nextState, previousCompose);
136
137    expect(compose).toContain("name: sample-stack");
138    expect(compose).toContain("image: nginx:1.27");
139    expect(compose).toContain("18080:80");
140    expect(compose).toContain("hostname: sample-app");
141    expect(compose).toContain("TZ: UTC");
142  });
143
144  it("removes ports when network mode is host", () => {
145    const seed = createDefaultClassicState({
146      title: "Host App",
147      iconUrl: "",
148      fallbackPort: 8123,
149    });
150
151    const compose = classicStateToCompose({
152      ...seed,
153      network: "host",
154      ports: [{ id: "p-1", host: "8123", container: "8123", protocol: "TCP" as const }],
155    });
156
157    expect(compose).toContain("network_mode: host");
158    expect(compose).not.toContain("ports:");
159    expect(compose).not.toContain("8123:8123");
160  });
161
162  it("returns parse error for invalid yaml", () => {
163    const parsed = safeComposeToClassicState({
164      composeDraft: "services:\n  app: [",
165      seed: {
166        title: "Broken",
167        iconUrl: "",
168      },
169    });
170
171    expect(parsed.state).toBeNull();
172    expect(parsed.error).toBeTruthy();
173  });
174
175  it("builds install payload including env and web ui port", () => {
176    const state = createDefaultClassicState({
177      title: "Install Me",
178      iconUrl: "",
179      fallbackPort: 8080,
180      fallbackHost: "localhost",
181    });
182
183    const payload = buildInstallPayloadFromClassic({
184      appId: "install-me",
185      state: {
186        ...state,
187        envVars: [{ id: "env-1", key: "TZ", value: "UTC" }],
188      },
189    });
190
191    expect(payload.appId).toBe("install-me");
192    expect(payload.webUiPort).toBe(8080);
193    expect(payload.env?.TZ).toBe("UTC");
194    expect(payload.env?.APP_URL).toContain("localhost:8080");
195    expect(payload.env?.VOLUMES).toBeUndefined();
196  });
197
198  it("sends the link override on its own, without touching the compose", () => {
199    const initial = createDefaultClassicState({
200      title: "Reverse Proxied",
201      iconUrl: "",
202      fallbackPort: 8080,
203      fallbackHost: "homeio.example.com",
204    });
205
206    const payload = buildSettingsPayloadFromClassic({
207      appId: "reverse-proxied",
208      current: { ...initial, webUiLink: "https://myapp.example.com" },
209      initial,
210    });
211
212    expect(payload.webUiUrl).toBe("https://myapp.example.com");
213    // Nothing that lives in the compose file changed, so no redeploy.
214    expect(payload.webUiPort).toBeUndefined();
215    expect(payload.env).toBeUndefined();
216  });
217
218  it("clears the link override when the field is emptied", () => {
219    const initial = createDefaultClassicState({
220      title: "Back To Auto",
221      iconUrl: "",
222      fallbackPort: 8080,
223      fallbackHost: "homeio.example.com",
224      webUiLink: "https://myapp.example.com",
225    });
226
227    const payload = buildSettingsPayloadFromClassic({
228      appId: "back-to-auto",
229      current: { ...initial, webUiLink: "  " },
230      initial,
231    });
232
233    expect(payload.webUiUrl).toBeNull();
234  });
235
236  it("leaves the link alone when only the web ui port changes", () => {
237    const initial = createDefaultClassicState({
238      title: "Port Only",
239      iconUrl: "",
240      fallbackPort: 8080,
241      fallbackHost: "homeio.example.com",
242    });
243
244    const payload = buildSettingsPayloadFromClassic({
245      appId: "port-only",
246      current: { ...initial, webUi: { ...initial.webUi, port: "9090" } },
247      initial,
248    });
249
250    expect(payload.webUiUrl).toBeUndefined();
251    expect(payload.webUiPort).toBe(9090);
252  });
253
254  it("keeps the container APP_URL separate from the link override", () => {
255    const initial = createDefaultClassicState({
256      title: "Two Concerns",
257      iconUrl: "",
258      fallbackPort: 8080,
259      fallbackHost: "homeio.example.com",
260    });
261
262    const payload = buildSettingsPayloadFromClassic({
263      appId: "two-concerns",
264      current: {
265        ...initial,
266        webUi: { ...initial.webUi, host: "internal.example.com" },
267      },
268      initial,
269    });
270
271    // The Web UI row still composes the container's APP_URL...
272    expect(payload.env?.APP_URL).toBe("http://internal.example.com:8080");
273    // ...and no longer doubles as the rendered link.
274    expect(payload.webUiUrl).toBeUndefined();
275  });
276
277  it("does not rebuild compose volumes from legacy VOLUMES env metadata", () => {
278    const compose = buildInitialComposeDraft({
279      appId: "legacy-app",
280      template: {
281        id: "legacy-app",
282        name: "Legacy App",
283        description: "",
284        platform: "linux",
285        categories: [],
286        logoUrl: null,
287        repositoryUrl: "",
288        stackFile: "docker-compose.yml",
289        status: "installed",
290        webUiPort: null,
291        updateAvailable: false,
292        localDigest: null,
293        remoteDigest: null,
294        note: "",
295        env: [],
296        screenshots: [],
297        installedConfig: {
298          appId: "legacy-app",
299          templateName: "legacy-app",
300          stackName: "legacy-app",
301          composePath: "/tmp/docker-compose.yml",
302          status: "installed",
303          webUiPort: null,
304          env: {
305            VOLUMES: '[{"host":"/DATA/AppData/legacy-app/data","container":"/data"}]',
306          },
307          displayName: "Legacy App",
308          iconUrl: null,
309          installedAt: null,
310          updatedAt: new Date().toISOString(),
311          isUpToDate: true,
312          lastUpdateCheck: null,
313          localDigest: null,
314          remoteDigest: null,
315        },
316      },
317    });
318
319    expect(compose).not.toContain("/DATA/AppData/legacy-app/data:/data");
320    expect(compose).toContain("environment:");
321  });
322
323  it("patches only immich primary service and preserves other compose content", () => {
324    const immichCompose = `services:
325  immich-server:
326    image: ghcr.io/immich-app/immich-server:v2.5.0
327    ports:
328      - "2283:2283"
329    depends_on:
330      - redis
331      - database
332    environment:
333      TZ: UTC
334  immich-machine-learning:
335    image: ghcr.io/immich-app/immich-machine-learning:v2.5.0
336  redis:
337    image: redis:7
338  database:
339    image: postgres:14
340    volumes:
341      - pgdata:/var/lib/postgresql/data
342networks:
343  default:
344    name: immich_default
345volumes:
346  pgdata:
347`;
348
349    const parsed = safeComposeToClassicState({
350      composeDraft: immichCompose,
351      seed: { title: "Immich", iconUrl: "" },
352      appId: "immich",
353      primaryServiceName: "immich-server",
354    });
355    expect(parsed.error).toBeNull();
356    expect(parsed.state?.dockerImage).toBe("ghcr.io/immich-app/immich-server:v2.5.0");
357
358    const nextCompose = classicStateToCompose(
359      {
360        ...parsed.state!,
361        dockerImage: "ghcr.io/immich-app/immich-server:v2.5.6",
362        envVars: [{ id: "env-1", key: "TZ", value: "Europe/Paris" }],
363      },
364      immichCompose,
365      { appId: "immich", primaryServiceName: "immich-server" },
366    );
367
368    expect(nextCompose).toContain("immich-server:");
369    expect(nextCompose).toContain("image: ghcr.io/immich-app/immich-server:v2.5.6");
370    expect(nextCompose).toContain("immich-machine-learning:");
371    expect(nextCompose).toContain("redis:");
372    expect(nextCompose).toContain("depends_on:");
373    expect(nextCompose).toContain("volumes:");
374    expect(nextCompose).toContain("pgdata:");
375    expect(nextCompose).toContain("networks:");
376    expect(nextCompose).not.toContain("\n  app:\n");
377  });
378});
379