@galadrim/galadmin 0.1.236 → 0.2.7

package/tests/integration/routes.importExport.integration.test.ts

@@ -0,0 +1,404 @@
+import * as request from "supertest";
+import { buildAppForManager } from "../helpers/app";
+import { baseConfig, fruitView, EDITOR, VIEWER } from "../helpers/fixtures";
+import {
+  BackendName,
+  DbHarness,
+  describeIntegration,
+  getMysql2Harness,
+  getMysqlHarness,
+  getPgHarness,
+  resetTables,
+} from "./dbHarness";
+
+jest.mock("axios");
+
+/**
+ * /recordsExport, /recordsImport and /subrecordsImport against real engines.
+ * The scripted suite asserted generated SQL strings; here exports are checked
+ * by their CSV output and imports by the rows the engine actually holds.
+ */
+describeIntegration("import/export routes against real databases", () => {
+  const harnesses: Record<BackendName, DbHarness> = {} as any;
+
+  beforeAll(async () => {
+    harnesses.mysql = await getMysqlHarness();
+    harnesses.mysql2 = await getMysql2Harness();
+    harnesses.postgresql = await getPgHarness();
+  });
+
+  afterAll(async () => {
+    await harnesses.mysql?.stop();
+    await harnesses.mysql2?.stop();
+    await harnesses.postgresql?.stop();
+  });
+
+  describe.each([
+    ["mysql", () => harnesses.mysql],
+    ["mysql2", () => harnesses.mysql2],
+    ["postgresql", () => harnesses.postgresql],
+  ])("backend: %s", (_backend, getHarness) => {
+    let harness: DbHarness;
+
+    beforeEach(async () => {
+      harness = getHarness();
+      await resetTables(harness);
+    });
+
+    const dataLines = (content: string) => content.split("\r\n").slice(1);
+
+    const seedFruits = async (rows: Array<Record<string, any>>) => {
+      for (const r of rows) {
+        const { err } = await harness.query(
+          "INSERT INTO fruits (fruitName, acidity, note, age, ownerId) VALUES (?, ?, ?, ?, ?)",
+          [
+            r.fruitName ?? null,
+            r.acidity ?? null,
+            r.note ?? null,
+            r.age ?? null,
+            r.ownerId ?? null,
+          ],
+        );
+        expect(err).toBeFalsy();
+      }
+    };
+
+    describe("POST /api/recordsExport", () => {
+      const exportConfig = (viewOverrides: any = {}) =>
+        baseConfig({
+          views: [
+            fruitView({
+              primaryId: "id",
+              columns: [
+                { label: "Nom", name: "fruitName" },
+                { label: "Acidité", name: "acidity" },
+                {
+                  label: "Notes",
+                  name: "note",
+                  dataType: "textarea",
+                  hideInTable: true,
+                  includeInExport: true,
+                },
+                { label: "Caché", name: "hidden", hideInTable: true },
+                { label: "Vendu", name: "age", dataType: "tinyint" },
+              ],
+              ...viewOverrides,
+            }),
+          ],
+        });
+
+      const postExport = (instance: any, body: any = {}) =>
+        request(instance)
+          .post("/api/recordsExport")
+          .send({ viewIndex: 0, filters: [], ...body });
+
+      it("exports a semicolon-delimited CSV with header and formatted rows", async () => {
+        await seedFruits([
+          { fruitName: "pomme", acidity: 3, note: "bonne", age: 1 },
+        ]);
+        const res = await postExport(
+          buildAppForManager(harness.manager, exportConfig()),
+        ).expect(200);
+        const lines = res.body.content.split("\r\n");
+        expect(lines[0]).toBe("Nom;Acidité;Notes;Vendu");
+        expect(lines[1]).toBe("pomme;3;\"bonne\";Oui");
+      });
+
+      it("clamps the limit to 999999 (allRecords)", async () => {
+        await seedFruits(
+          Array.from({ length: 12 }, (_, i) => ({ fruitName: `f${i + 1}` })),
+        );
+        const instance = buildAppForManager(
+          harness.manager,
+          exportConfig({ limit: 5 }),
+        );
+        const res = await postExport(instance).expect(200);
+        // allRecords overrides the view limit: every row is exported.
+        expect(dataLines(res.body.content)).toHaveLength(12);
+      });
+
+      it("applies orderBy with direction", async () => {
+        await seedFruits([
+          { fruitName: "a", acidity: 1 },
+          { fruitName: "b", acidity: 3 },
+          { fruitName: "c", acidity: 2 },
+        ]);
+        const res = await postExport(
+          buildAppForManager(harness.manager, exportConfig()),
+          { orderBy: "acidity", isDesc: true },
+        ).expect(200);
+        expect(dataLines(res.body.content)[0]).toMatch(/^b;/);
+      });
+
+      it("applies view filters, subview filters and body filters", async () => {
+        await seedFruits([
+          { fruitName: "keep", age: 30, acidity: 2 },
+          { fruitName: "too-young", age: 5, acidity: 5 },
+          { fruitName: "too-old", age: 60, acidity: 5 },
+          { fruitName: "too-sour", age: 30, acidity: 0 },
+        ]);
+        const config = exportConfig({
+          filters: "age > 10",
+          subviews: [{ label: "Old", filters: "age < 50" }],
+        });
+        const res = await postExport(
+          buildAppForManager(harness.manager, config),
+          { subviewIndex: 0, filters: "acidity > 1" },
+        ).expect(200);
+        expect(dataLines(res.body.content)).toHaveLength(1);
+        expect(dataLines(res.body.content)[0]).toMatch(/^keep;/);
+      });
+
+      it("scopes the export to the caller's rows via filtersFromUser", async () => {
+        // The export must be scoped exactly like the list view, otherwise a
+        // user could download rows their filtersFromUser clause hides.
+        await seedFruits([
+          { fruitName: "mine", ownerId: 2 },
+          { fruitName: "theirs", ownerId: 1 },
+        ]);
+        const config = exportConfig({
+          filtersFromUser: (userId: number) => `ownerId = ${userId}`,
+        });
+        const res = await postExport(
+          buildAppForManager(harness.manager, config, {
+            role: "editor",
+            userId: 2,
+          }),
+        ).expect(200);
+        expect(dataLines(res.body.content)).toHaveLength(1);
+        expect(dataLines(res.body.content)[0]).toMatch(/^mine;/);
+      });
+
+      it("returns 500 when the engine rejects the query", async () => {
+        const config = exportConfig({ filters: "price < 10" });
+        await postExport(buildAppForManager(harness.manager, config)).expect(
+          500,
+        );
+      });
+
+      it("renders null values as empty strings", async () => {
+        await seedFruits([{ fruitName: null, acidity: null, note: null, age: 0 }]);
+        const res = await postExport(
+          buildAppForManager(harness.manager, exportConfig()),
+        ).expect(200);
+        expect(dataLines(res.body.content)[0]).toBe(";;\"\";Non");
+      });
+    });
+
+    describe("POST /api/recordsImport", () => {
+      const importConfig = (overrides: any = {}) =>
+        baseConfig({
+          views: [
+            fruitView({
+              primaryId: "id",
+              parseImportFile: jest.fn().mockResolvedValue([
+                { id: 1, fruitName: "pomme" },
+                { id: 2, fruitName: "poire" },
+              ]),
+              importFileUniqueField: "id",
+              ...overrides,
+            }),
+          ],
+        });
+
+      const postImport = (instance: any) =>
+        request(instance)
+          .post("/api/recordsImport")
+          .field("viewIndex", "0")
+          .attach("data", Buffer.from("fake,csv"), "import.csv");
+
+      it("bulk upserts the parsed records on conflict", async () => {
+        // id 1 already exists: the import must update it, not duplicate it.
+        const { err } = await harness.query(
+          "INSERT INTO fruits (id, fruitName) VALUES (1, 'old')",
+        );
+        expect(err).toBeFalsy();
+        const config = importConfig();
+        const res = await postImport(
+          buildAppForManager(harness.manager, config),
+        ).expect(200);
+        // MySQL reports 1 per inserted row and 2 per updated one (1+2=3).
+        if (harness.dbType === "POSTGRESQL") {
+          // GAP: the PG driver result exposes rowCount, not affectedRows,
+          // so the route answers with an empty object.
+          expect(res.body).toEqual({});
+        } else {
+          expect(res.body).toEqual({ affectedRows: 3 });
+        }
+        expect(config.views[0].parseImportFile).toHaveBeenCalledWith(
+          expect.objectContaining({ originalFilename: "import.csv" }),
+        );
+        const { rows } = await harness.query(
+          "SELECT id, fruitName FROM fruits ORDER BY id",
+        );
+        expect(rows).toEqual([
+          { id: 1, fruitName: "pomme" },
+          { id: 2, fruitName: "poire" },
+        ]);
+      });
+
+      it("returns 0 when the import file holds no records", async () => {
+        const config = importConfig({
+          parseImportFile: jest.fn().mockResolvedValue([]),
+        });
+        const res = await postImport(
+          buildAppForManager(harness.manager, config),
+        ).expect(200);
+        expect(res.body).toEqual({ affectedRows: 0 });
+        const { rows } = await harness.query("SELECT * FROM fruits");
+        expect(rows).toHaveLength(0);
+      });
+
+      it("returns 500 when parseImportFile is missing", async () => {
+        const config = importConfig();
+        delete (config.views[0] as any).parseImportFile;
+        const res = await postImport(
+          buildAppForManager(harness.manager, config),
+        ).expect(500);
+        expect(res.text).toContain("parseImportFile");
+      });
+
+      it("rejects a read-only role with 403 before parsing or importing", async () => {
+        // Imports are bulk writes: they require a role that can write the view.
+        const config = importConfig({
+          roles: ["editor"],
+          readRoles: ["viewer"],
+        });
+        await postImport(
+          buildAppForManager(harness.manager, config, VIEWER),
+        ).expect(403);
+        expect(config.views[0].parseImportFile).not.toHaveBeenCalled();
+        const { rows } = await harness.query("SELECT * FROM fruits");
+        expect(rows).toHaveLength(0);
+      });
+
+      // NOTE: a throwing parseImportFile is awaited OUTSIDE the try/catch of
+      // the multiparty callback -> unhandled rejection, the 500 is never sent
+      // and the process can crash. Listed in README under "Known robustness
+      // limitations".
+
+      it("returns 500 with a message when the insert fails", async () => {
+        const config = importConfig({
+          parseImportFile: jest
+            .fn()
+            .mockResolvedValue([{ id: 1, nope: "x" }]),
+        });
+        // The mapped column "nope" does not exist: engine error -> 500.
+        const res = await postImport(
+          buildAppForManager(harness.manager, config),
+        ).expect(500);
+        expect(res.body.message).toBe("Une erreur est survenue.");
+      });
+    });
+
+    describe("POST /api/subrecordsImport", () => {
+      const panelConfig = (overrides: any = {}) => {
+        const panel = {
+          label: "Notes",
+          tableName: "fruit_notes",
+          primaryId: "id",
+          createConfig: {
+            label: "New note",
+            recordIdKey: "fruitId",
+            columns: [{ label: "Texte", name: "text" }],
+          },
+          parseImportFile: jest
+            .fn()
+            .mockResolvedValue([{ text: "note a" }, { text: "note b" }]),
+          ...overrides,
+        };
+        return baseConfig({ views: [fruitView({ recordViewPanels: [panel] })] });
+      };
+
+      const postSubImport = (instance: any) =>
+        request(instance)
+          .post("/api/subrecordsImport")
+          .field("viewIndex", "0")
+          .field("panelIndex", "0")
+          .field("recordId", "7")
+          .attach("data", Buffer.from("fake,csv"), "notes.csv");
+
+      it("bulk upserts panel records bound to the parent record", async () => {
+        const config = panelConfig();
+        const res = await postSubImport(
+          buildAppForManager(harness.manager, config),
+        );
+        if (harness.dbType === "POSTGRESQL") {
+          // The MySQL-only INSERT IGNORE syntax fails on PG — see the
+          // characterization test below.
+          expect(res.status).toBe(500);
+          return;
+        }
+        expect(res.status).toBe(200);
+        expect(res.body).toEqual({ affectedRows: 2 });
+        expect(
+          config.views[0].recordViewPanels[0].parseImportFile,
+        ).toHaveBeenCalledWith(
+          expect.objectContaining({ originalFilename: "notes.csv" }),
+          "7",
+        );
+        const { rows } = await harness.query(
+          "SELECT fruitId, text FROM fruit_notes ORDER BY id",
+        );
+        expect(rows).toEqual([
+          { fruitId: 7, text: "note a" },
+          { fruitId: 7, text: "note b" },
+        ]);
+      });
+
+      it("CHARACTERIZATION: PostgreSQL rejects the MySQL-only INSERT IGNORE syntax", async () => {
+        // The panel import always builds INSERT IGNORE ... ON DUPLICATE KEY
+        // UPDATE regardless of dialect; convertQuery quotes the unknown
+        // keywords instead of translating them, so PG answers 500.
+        const res = await postSubImport(
+          buildAppForManager(harness.manager, panelConfig()),
+        );
+        if (harness.dbType === "POSTGRESQL") {
+          expect(res.status).toBe(500);
+        } else {
+          expect(res.status).toBe(200);
+        }
+      });
+
+      it("returns 0 when the file holds no records", async () => {
+        const config = panelConfig({
+          parseImportFile: jest.fn().mockResolvedValue([]),
+        });
+        const res = await postSubImport(
+          buildAppForManager(harness.manager, config),
+        ).expect(200);
+        expect(res.body).toEqual({ affectedRows: 0 });
+      });
+
+      it("returns 500 when parseImportFile is missing", async () => {
+        const config = panelConfig();
+        delete (config.views[0].recordViewPanels[0] as any).parseImportFile;
+        const res = await postSubImport(
+          buildAppForManager(harness.manager, config),
+        ).expect(500);
+        expect(res.text).toContain("parseImportFile");
+      });
+
+      it("returns 500 when createConfig is missing", async () => {
+        const config = panelConfig();
+        delete (config.views[0].recordViewPanels[0] as any).createConfig;
+        const res = await postSubImport(
+          buildAppForManager(harness.manager, config),
+        ).expect(500);
+        expect(res.text).toContain("createConfig");
+      });
+
+      it("rejects a read-only role with 403 before importing", async () => {
+        const config = panelConfig({ roles: ["editor"] });
+        await postSubImport(
+          buildAppForManager(harness.manager, config, VIEWER),
+        ).expect(403);
+        expect(
+          config.views[0].recordViewPanels[0].parseImportFile,
+        ).not.toHaveBeenCalled();
+        const { rows } = await harness.query("SELECT * FROM fruit_notes");
+        expect(rows).toHaveLength(0);
+      });
+    });
+  });
+});