@canva/cli 1.6.0 → 1.8.0

package/templates/common/utils/tests/table_wrapper.tests.ts

@@ -1,252 +0,0 @@
-import type { Cell, TableElement } from "@canva/design";
-import { TableWrapper } from "../table_wrapper";
-
-describe("TableWrapper", () => {
-  describe("create", () => {
-    it("should create a new table", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      const element = wrapper.toElement();
-      expect(element.rows.length).toBe(2);
-      expect(element.rows[0].cells.length).toBe(3);
-      expect(element.rows[1].cells.length).toBe(3);
-    });
-    it("should throw an error if the row count is less than 1", () => {
-      expect(() => TableWrapper.create(0, 1)).toThrow();
-    });
-    it("should throw an error if the column count is less than 1", () => {
-      expect(() => TableWrapper.create(1, 0)).toThrow();
-    });
-    it("should throw an error if the number of cells exceeds 225", () => {
-      expect(() => TableWrapper.create(16, 15)).toThrow();
-    });
-  });
-
-  describe("fromElement", () => {
-    it("should create a table wrapper from an existing table element", () => {
-      const element: TableElement = {
-        type: "table",
-        rows: [
-          {
-            cells: [
-              { colSpan: 2, type: "empty" },
-              { type: "empty" },
-              { rowSpan: 2, type: "empty" },
-            ],
-          },
-          {
-            cells: [
-              {
-                type: "string",
-                value: "hello",
-              },
-              {
-                type: "empty",
-                attributes: { backgroundColor: "#ff00ff" },
-              },
-              { type: "empty" },
-            ],
-          },
-        ],
-      };
-      const wrapper = TableWrapper.fromElement(element);
-      expect(wrapper.toElement()).toEqual(element);
-
-      // Make sure the new element is not a reference
-      if (element.rows[1].cells[1]?.attributes) {
-        element.rows[1].cells[1].attributes.backgroundColor = "#ff0000";
-      }
-      expect(wrapper.toElement()).not.toEqual(element);
-    });
-    it("should throw an error if the element is not a table", () => {
-      const element = {
-        type: "TEXT",
-        children: ["hello"],
-      };
-      expect(() => {
-        TableWrapper.fromElement(element as unknown as TableElement);
-      }).toThrow();
-    });
-    it("should throw an error if the element has no rows", () => {
-      expect(() => {
-        TableWrapper.fromElement({
-          type: "TABLE",
-        } as unknown as TableElement);
-      }).toThrow();
-      expect(() => {
-        TableWrapper.fromElement({
-          type: "table",
-          rows: [],
-        });
-      }).toThrow();
-    });
-    it("should throw an error if any row of the element has no cells", () => {
-      const element: TableElement = {
-        type: "table",
-        rows: [{ cells: [] }],
-      };
-      expect(() => {
-        TableWrapper.fromElement(element);
-      }).toThrow();
-    });
-    it("should throw an error if number of cells is inconsistent", () => {
-      const element: TableElement = {
-        type: "table",
-        rows: [
-          { cells: [{ type: "empty" }, { type: "empty" }] },
-          { cells: [{ type: "empty" }] },
-        ],
-      };
-      expect(() => {
-        TableWrapper.fromElement(element);
-      }).toThrow();
-    });
-  });
-
-  describe("addRow", () => {
-    it("should add a row to the table", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      wrapper.addRow(0);
-      const element = wrapper.toElement();
-      expect(element.rows.length).toBe(3);
-      expect(element.rows[0].cells.length).toBe(3);
-    });
-    it("should copy the fill value if top and bottom cells are the same", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      wrapper.setCellDetails(1, 1, {
-        type: "empty",
-        attributes: { backgroundColor: "#ff0000" },
-      });
-      wrapper.setCellDetails(2, 1, {
-        type: "empty",
-        attributes: { backgroundColor: "#ff0000" },
-      });
-      wrapper.addRow(1);
-      const newCell = wrapper.getCellDetails(2, 1);
-      expect(newCell?.attributes).toBeDefined();
-      expect(newCell?.attributes?.backgroundColor).toBe("#ff0000");
-    });
-    it("should expand the row span if top and bottom cells belong to the same merged cell", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      wrapper.setCellDetails(1, 1, { rowSpan: 2, type: "empty" });
-      wrapper.addRow(1);
-      const mergedCell = wrapper.getCellDetails(1, 1);
-      expect(mergedCell?.rowSpan).toBe(3);
-    });
-    it("should throw an error if the row position is out of bounds", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      expect(() => wrapper.addRow(-1)).toThrow();
-      expect(() => wrapper.addRow(3)).toThrow();
-    });
-  });
-
-  describe("addColumn", () => {
-    it("should add a column to the table", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      wrapper.addColumn(0);
-      const element = wrapper.toElement();
-      expect(element.rows.length).toBe(2);
-      expect(element.rows[0].cells.length).toBe(4);
-    });
-    it("should copy the fill value if left and right cells are the same", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      wrapper.setCellDetails(1, 1, {
-        type: "empty",
-        attributes: { backgroundColor: "#ff0000" },
-      });
-      wrapper.setCellDetails(1, 2, {
-        type: "empty",
-        attributes: { backgroundColor: "#ff0000" },
-      });
-      wrapper.addColumn(1);
-      const newCell = wrapper.getCellDetails(1, 2);
-      expect(newCell?.attributes).toBeDefined();
-      expect(newCell?.attributes?.backgroundColor).toBe("#ff0000");
-    });
-    it("should expand the column span if left and right cells belong to the same merged cell", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      wrapper.setCellDetails(1, 1, { type: "empty", colSpan: 2 });
-      wrapper.addColumn(1);
-      const mergedCell = wrapper.getCellDetails(1, 1);
-      expect(mergedCell?.colSpan).toBe(3);
-    });
-    it("should throw an error if the column position is out of bounds", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      expect(() => wrapper.addColumn(-1)).toThrow();
-      expect(() => wrapper.addColumn(4)).toThrow();
-    });
-  });
-
-  describe("isGhostCell", () => {
-    it("should return true if the cell is a ghost cell", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      wrapper.setCellDetails(1, 1, { type: "empty", colSpan: 2 });
-      expect(wrapper.isGhostCell(1, 1)).toBe(false);
-      expect(wrapper.isGhostCell(1, 2)).toBe(true);
-      expect(wrapper.isGhostCell(1, 3)).toBe(false);
-    });
-    it("should throw an error if the position is out of bounds", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      expect(() => wrapper.isGhostCell(0, 1)).toThrow();
-      expect(() => wrapper.isGhostCell(3, 1)).toThrow();
-      expect(() => wrapper.isGhostCell(1, 0)).toThrow();
-      expect(() => wrapper.isGhostCell(1, 4)).toThrow();
-    });
-  });
-
-  describe("setCellDetails", () => {
-    it("should set the cell details", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      wrapper.setCellDetails(1, 1, {
-        colSpan: 2,
-        rowSpan: 2,
-        type: "string",
-        value: "hello",
-        attributes: { backgroundColor: "#ff0000" },
-      });
-      expect(wrapper.isGhostCell(1, 1)).toBe(false);
-      expect(wrapper.isGhostCell(1, 2)).toBe(true);
-      expect(wrapper.isGhostCell(2, 1)).toBe(true);
-      expect(wrapper.isGhostCell(2, 2)).toBe(true);
-      const element = wrapper.toElement();
-      const firstCell = element.rows[0].cells[0] as Cell & {
-        type: "string";
-        value: string;
-      };
-      expect(firstCell?.type).toBe("string");
-      expect(firstCell.value).toBe("hello");
-      expect(firstCell.attributes).toBeDefined();
-      expect(firstCell.attributes?.backgroundColor).toBe("#ff0000");
-    });
-    it("should throw an error if the position is out of bounds", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      expect(() => wrapper.setCellDetails(0, 1, { type: "empty" })).toThrow();
-      expect(() => wrapper.setCellDetails(3, 1, { type: "empty" })).toThrow();
-      expect(() => wrapper.setCellDetails(1, 0, { type: "empty" })).toThrow();
-      expect(() => wrapper.setCellDetails(1, 4, { type: "empty" })).toThrow();
-    });
-    it("should throw an error if the rowSpan is invalid", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      expect(() =>
-        wrapper.setCellDetails(1, 1, { type: "empty", rowSpan: -1 }),
-      ).toThrow();
-      expect(() =>
-        wrapper.setCellDetails(1, 1, { type: "empty", rowSpan: 0 }),
-      ).toThrow();
-      expect(() =>
-        wrapper.setCellDetails(1, 1, { type: "empty", rowSpan: 3 }),
-      ).toThrow();
-    });
-    it("should throw an error if the colSpan is invalid", () => {
-      const wrapper = TableWrapper.create(2, 3);
-      expect(() =>
-        wrapper.setCellDetails(1, 1, { type: "empty", colSpan: -1 }),
-      ).toThrow();
-      expect(() =>
-        wrapper.setCellDetails(1, 1, { type: "empty", colSpan: 0 }),
-      ).toThrow();
-      expect(() =>
-        wrapper.setCellDetails(1, 1, { type: "empty", colSpan: 4 }),
-      ).toThrow();
-    });
-  });
-});

package/templates/dam/scripts/start/tests/start.tests.ts

@@ -1,61 +0,0 @@
-/* eslint-disable no-console */
-
-import type { ChildProcess } from "child_process";
-import { spawn } from "child_process";
-import * as treeKill from "tree-kill";
-
-describe("start script", () => {
-  let serverProcess: ChildProcess;
-
-  afterEach(() => {
-    if (serverProcess?.pid && !serverProcess.exitCode) {
-      treeKill(serverProcess.pid);
-    }
-  });
-
-  it("should execute 'npm run start' and start a dev server", async () => {
-    const testServerPort = 8089;
-    serverProcess = await spawn(
-      `npm run start -- -p ${testServerPort} --no-preview`,
-      {
-        shell: true,
-      },
-    );
-
-    if (!serverProcess.pid) {
-      throw new Error("Unable to start server");
-    }
-
-    // wait for the server to start and collect output until it reports the running URL
-    let output = "";
-    await new Promise<void>((resolve, reject) => {
-      serverProcess.stdout?.on("data", (data) => {
-        output += data.toString();
-        if (output.includes("Development URL")) {
-          resolve();
-        }
-      });
-
-      serverProcess.stderr?.on("data", (data) => {
-        console.error("Server process error: ", data.toString());
-        reject();
-      });
-
-      // timeout and fail test if the server hasn't correctly started in 10 seconds
-      setTimeout(() => {
-        if (serverProcess?.pid && !serverProcess.exitCode) {
-          treeKill(serverProcess.pid);
-        }
-        reject(new Error("Test timed out"));
-      }, 10000);
-    });
-
-    // check that the server is running and accessible
-    const expectedServerURL = `http://localhost:${testServerPort}`;
-    expect(output).toContain(expectedServerURL);
-    expect(serverProcess.exitCode).toBeNull();
-
-    // clean up
-    treeKill(serverProcess.pid);
-  }, 15000); // 15 seconds timeout to allow for the server to start
-});