feat: enhance server tests with static directory handling and fallback SPA logic

Author: Benevanio

backend/tests/integration/jobsApi.test.js

@@ -2,13 +2,27 @@ import { mkdtempSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
 import request from "supertest";
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import XLSX from "xlsx";
+
+const mocks = vi.hoisted(() => ({
+  run: vi.fn(),
+}));
+
+vi.mock("../../src/app.js", () => ({
+  run: mocks.run,
+}));
+
 import { createJobsApiApp } from "../../src/jobsApiApp.js";
 
 describe("jobs API", () => {
   let tmpDir;
 
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.run.mockResolvedValue(undefined);
+  });
+
   afterEach(() => {
     tmpDir = undefined;
   });
@@ -63,4 +77,67 @@ describe("jobs API", () => {
     const res = await request(app).get("/api/jobs").query({ file: "nao-existe.xlsx" }).expect(404);
     expect(res.body.message).toBe("Arquivo solicitado nao encontrado.");
   });
+
+  it("POST /api/scraper/run executa scraper e retorna metadados", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "jobs-api-"));
+    const workbook = XLSX.utils.book_new();
+    const sheet = XLSX.utils.json_to_sheet([{ titulo: "x" }]);
+    XLSX.utils.book_append_sheet(workbook, sheet, "Vagas");
+    XLSX.writeFile(workbook, join(tmpDir, "resultado.xlsx"));
+
+    const app = createJobsApiApp({ outputDir: tmpDir });
+    const res = await request(app).post("/api/scraper/run").expect(200);
+
+    expect(mocks.run).toHaveBeenCalledTimes(1);
+    expect(res.body.ok).toBe(true);
+    expect(res.body.file).toBe("resultado.xlsx");
+    expect(res.body.totalFiles).toBe(1);
+  });
+
+  it("POST /api/scraper/run retorna 409 quando ja existe execucao ativa", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "jobs-api-"));
+    let finishRun;
+    mocks.run.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          finishRun = resolve;
+        }),
+    );
+
+    const app = createJobsApiApp({ outputDir: tmpDir });
+
+    const firstRequest = new Promise((resolve, reject) => {
+      request(app)
+        .post("/api/scraper/run")
+        .end((error, response) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve(response);
+        });
+    });
+
+    await vi.waitFor(() => {
+      expect(mocks.run).toHaveBeenCalledTimes(1);
+    });
+
+    const conflict = await request(app).post("/api/scraper/run").expect(409);
+    expect(conflict.body.message).toBe("O scraper ja esta em execucao.");
+
+    finishRun();
+    const firstResult = await firstRequest;
+    expect(firstResult.status).toBe(200);
+  });
+
+  it("POST /api/scraper/run retorna 500 quando scraper falha", async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), "jobs-api-"));
+    mocks.run.mockRejectedValue(new Error("falha no scraper"));
+
+    const app = createJobsApiApp({ outputDir: tmpDir });
+    const res = await request(app).post("/api/scraper/run").expect(500);
+
+    expect(res.body.message).toBe("Erro ao executar o scraper.");
+    expect(res.body.error).toBe("falha no scraper");
+  });
 });

backend/tests/unit/services/server.test.js

@@ -1,24 +1,45 @@
+import path from "path";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 const mocks = vi.hoisted(() => ({
   listen: vi.fn(),
+  use: vi.fn(),
   createJobsApiApp: vi.fn(),
   consoleLog: vi.fn(),
+  existsSync: vi.fn(),
+  staticMiddleware: vi.fn(),
+  expressStatic: vi.fn(),
 }));
 
 mocks.createJobsApiApp.mockReturnValue({
   listen: mocks.listen,
+  use: mocks.use,
 });
 
+mocks.expressStatic.mockReturnValue(mocks.staticMiddleware);
+
 vi.mock("../../../src/jobsApiApp.js", () => ({
   createJobsApiApp: mocks.createJobsApiApp,
 }));
 
+vi.mock("fs", () => ({
+  existsSync: mocks.existsSync,
+}));
+
+vi.mock("express", () => ({
+  default: {
+    static: mocks.expressStatic,
+  },
+}));
+
 describe("server entry", () => {
   beforeEach(() => {
     vi.resetModules();
     vi.clearAllMocks();
     process.env.PORT = "3100";
+    delete process.env.ELECTRON_STATIC_DIR;
+    delete process.env.ELECTRON_OUTPUT_DIR;
+    mocks.existsSync.mockReturnValue(false);
     vi.spyOn(console, "log").mockImplementation(mocks.consoleLog);
   });
 
@@ -41,4 +62,46 @@ describe("server entry", () => {
 
     expect(mocks.listen).toHaveBeenCalledWith(3001, expect.any(Function));
   });
+
+  it("usa ELECTRON_OUTPUT_DIR quando definido", async () => {
+    process.env.ELECTRON_OUTPUT_DIR = "/tmp/electron-output";
+
+    await import("../../../src/server.js");
+
+    expect(mocks.createJobsApiApp).toHaveBeenCalledWith({
+      outputDir: "/tmp/electron-output",
+    });
+  });
+
+  it("registra static e fallback SPA quando ELECTRON_STATIC_DIR existe", async () => {
+    process.env.ELECTRON_STATIC_DIR = "/tmp/frontend-dist";
+    mocks.existsSync.mockReturnValue(true);
+
+    await import("../../../src/server.js");
+
+    expect(mocks.expressStatic).toHaveBeenCalledWith("/tmp/frontend-dist");
+    expect(mocks.use).toHaveBeenCalledTimes(2);
+    expect(mocks.use).toHaveBeenNthCalledWith(1, mocks.staticMiddleware);
+
+    const fallbackHandler = mocks.use.mock.calls[1][0];
+
+    const apiRes = {
+      status: vi.fn().mockReturnThis(),
+      json: vi.fn(),
+      sendFile: vi.fn(),
+    };
+    fallbackHandler({ path: "/api/unknown" }, apiRes);
+    expect(apiRes.status).toHaveBeenCalledWith(404);
+    expect(apiRes.json).toHaveBeenCalledWith({ error: "Rota não encontrada." });
+    expect(apiRes.sendFile).not.toHaveBeenCalled();
+
+    const pageRes = {
+      status: vi.fn().mockReturnThis(),
+      json: vi.fn(),
+      sendFile: vi.fn(),
+    };
+    fallbackHandler({ path: "/dashboard" }, pageRes);
+    expect(pageRes.sendFile).toHaveBeenCalledWith(path.join("/tmp/frontend-dist", "index.html"));
+    expect(pageRes.status).not.toHaveBeenCalled();
+  });
 });