testeranto 0.203.0 → 0.206.0

package/dist/module/design-editor/DesignEditor.js

@@ -0,0 +1,40 @@
+import React, { useEffect, useRef } from 'react';
+import { Canvas, Rect, Text } from 'fabric';
+export const DesignEditor = () => {
+    const canvasRef = useRef(null);
+    useEffect(() => {
+        if (!canvasRef.current)
+            return;
+        // Initialize the fabric canvas
+        const canvas = new Canvas(canvasRef.current, {
+            width: 800,
+            height: 600,
+            backgroundColor: '#f0f0f0'
+        });
+        // Add a simple rectangle
+        const rect = new Rect({
+            left: 100,
+            top: 100,
+            width: 100,
+            height: 100,
+            fill: 'red',
+            angle: 0
+        });
+        // Add text
+        const text = new Text('Hello Fabric.js!', {
+            left: 50,
+            top: 50,
+            fontSize: 20,
+            fill: 'blue'
+        });
+        // Add objects to canvas
+        canvas.add(rect, text);
+        canvas.renderAll();
+        // Cleanup
+        return () => {
+            canvas.dispose();
+        };
+    }, []);
+    return (React.createElement("div", null,
+        React.createElement("canvas", { ref: canvasRef })));
+};

package/dist/module/design-editor/index.js

@@ -0,0 +1,2 @@
+export * from './DesignEditor';
+export * from './server';

package/dist/module/design-editor/server.js

@@ -0,0 +1,92 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { WebSocketServer } from "ws";
+import fs from "fs";
+import path from "path";
+const projects = new Map();
+export function startDesignEditorServer(wssPort, httpPort) {
+    const wss = new WebSocketServer({ port: wssPort });
+    wss.on("connection", (ws, req) => {
+        // Create URL from request URL and host header
+        const url = new URL(req.url || "", `http://${req.headers.host}`);
+        const projectId = url.searchParams.get("project") || "default";
+        if (!projects.has(projectId)) {
+            projects.set(projectId, {
+                connections: new Set(),
+                design: loadDesign(projectId),
+            });
+        }
+        const project = projects.get(projectId);
+        project.connections.add(ws);
+        // Send current design to new collaborator
+        ws.send(JSON.stringify({
+            type: "design_update",
+            data: project.design,
+        }));
+        broadcastCollaborators(projectId);
+        ws.on("message", (message) => {
+            const data = JSON.parse(message);
+            if (data.type === "design_update") {
+                project.design = data.data;
+                saveDesign(projectId, data.data);
+                broadcastToProject(projectId, message.toString());
+            }
+        });
+        ws.on("close", (code, reason) => {
+            project.connections.delete(ws);
+            if (project.connections.size === 0) {
+                projects.delete(projectId);
+            }
+            else {
+                broadcastCollaborators(projectId);
+            }
+        });
+    });
+    console.log(`Design editor WebSocket server running on port ${wssPort}`);
+}
+function broadcastToProject(projectId, message) {
+    const project = projects.get(projectId);
+    if (project) {
+        project.connections.forEach((client) => {
+            if (client.readyState === client.OPEN) {
+                client.send(message);
+            }
+        });
+    }
+}
+function broadcastCollaborators(projectId) {
+    const project = projects.get(projectId);
+    if (project) {
+        const collaborators = Array.from(project.connections).map((_, i) => ({
+            id: `user-${i}`,
+            name: `Collaborator ${i + 1}`,
+        }));
+        broadcastToProject(projectId, JSON.stringify({
+            type: "collaborators_update",
+            data: collaborators,
+        }));
+    }
+}
+function loadDesign(projectId) {
+    const designsDir = path.join(process.cwd(), "designs");
+    const filePath = path.join(designsDir, `${projectId}.json`);
+    try {
+        const data = fs.readFileSync(filePath, "utf-8");
+        return JSON.parse(data);
+    }
+    catch (_a) {
+        return {
+            version: "1.0",
+            background: "#ffffff",
+            objects: [],
+        };
+    }
+}
+function saveDesign(projectId, design) {
+    const designsDir = path.join(process.cwd(), "designs");
+    if (!fs.existsSync(designsDir)) {
+        fs.mkdirSync(designsDir, { recursive: true });
+    }
+    const filePath = path.join(designsDir, `${projectId}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(design, null, 2));
+}

package/dist/module/design-editor/types.js

@@ -0,0 +1 @@
+export {};

package/dist/module/example/Calculator.js

@@ -0,0 +1,101 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class Calculator {
+    constructor() {
+        this.display = "";
+        this.values = {};
+        this.id = Math.random(); // Add a unique ID to track instances
+    }
+    press(button) {
+        this.display = this.display + button;
+        return this;
+    }
+    enter() {
+        try {
+            // Simple expression evaluation
+            // Note: Using eval is not recommended for production code
+            // This is just for testing purposes
+            const result = eval(this.display);
+            this.display = result.toString();
+        }
+        catch (error) {
+            this.display = "Error";
+            throw error;
+        }
+    }
+    memoryStore() {
+        this.setValue("memory", parseFloat(this.display) || 0);
+        this.clear();
+    }
+    memoryRecall() {
+        const memoryValue = this.getValue("memory") || 0;
+        this.display = memoryValue.toString();
+    }
+    memoryClear() {
+        this.setValue("memory", 0);
+    }
+    memoryAdd() {
+        const currentValue = parseFloat(this.display) || 0;
+        const memoryValue = this.getValue("memory") || 0;
+        this.setValue("memory", memoryValue + currentValue);
+        this.clear();
+    }
+    handleSpecialButton(button) {
+        switch (button) {
+            case "C":
+                this.clear();
+                return true;
+            case "MS":
+                this.memoryStore();
+                return true;
+            case "MR":
+                this.memoryRecall();
+                return true;
+            case "MC":
+                this.memoryClear();
+                return true;
+            case "M+":
+                this.memoryAdd();
+                return true;
+            default:
+                return false;
+        }
+    }
+    press(button) {
+        // Handle special buttons first
+        if (this.handleSpecialButton(button)) {
+            return this;
+        }
+        // For regular buttons, append to display
+        this.display = this.display + button;
+        return this;
+    }
+    getDisplay() {
+        return this.display;
+    }
+    clear() {
+        this.display = "";
+    }
+    // Keep these methods for backward compatibility if needed
+    add(a, b) {
+        return a + b;
+    }
+    subtract(a, b) {
+        return a - b;
+    }
+    multiply(a, b) {
+        return a * b;
+    }
+    divide(a, b) {
+        if (b === 0) {
+            throw new Error("Cannot divide by zero");
+        }
+        return a / b;
+    }
+    setValue(identifier, value) {
+        this.values[identifier] = value;
+    }
+    getValue(identifier) {
+        var _a;
+        return (_a = this.values[identifier]) !== null && _a !== void 0 ? _a : null;
+    }
+}

package/dist/module/example/Calculator.test.adapter.js

@@ -0,0 +1,36 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+export const adapter = {
+    beforeAll: async (input, testResource, pm) => {
+        return input;
+    },
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const result = await initializer();
+        return result;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        // The whenCB should be a function that returns a function which takes the store
+        // For press("2"), whenCB is (calculator) => { calculator.press("2"); return calculator; }
+        const transform = whenCB;
+        const result = transform(store);
+        return result;
+    },
+    butThen: async (store, thenCB, testResource, pm) => {
+        thenCB(store);
+        const display = store.getDisplay();
+        return display;
+    },
+    afterEach: async (store, key, pm) => {
+        // Clean up if needed
+        return store;
+    },
+    afterAll: async (store, pm) => {
+        // Clean up if needed
+        return store;
+    },
+    assertThis: (actual) => {
+        // The actual value comes from butThen which returns the display
+        // We don't need to do anything here as assertions are done in thenCB
+        return actual;
+    },
+};

package/dist/module/example/Calculator.test.implementation.js

@@ -0,0 +1,47 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// import { ITestImplementation } from "testeranto/src/CoreTypes";
+import { Calculator } from "./Calculator";
+import { assert } from "chai";
+export const implementation = {
+    suites: {
+        Default: "Default test suite for Calculator",
+    },
+    givens: {
+        Default: () => {
+            const calc = new Calculator();
+            return calc;
+        },
+    },
+    whens: {
+        press: (button) => (calculator) => {
+            const result = calculator.press(button);
+            return result;
+        },
+        enter: () => (calculator) => {
+            calculator.enter();
+            return calculator;
+        },
+        memoryStore: () => (calculator) => {
+            calculator.memoryStore();
+            return calculator;
+        },
+        memoryRecall: () => (calculator) => {
+            calculator.memoryRecall();
+            return calculator;
+        },
+        memoryClear: () => (calculator) => {
+            calculator.memoryClear();
+            return calculator;
+        },
+        memoryAdd: () => (calculator) => {
+            calculator.memoryAdd();
+            return calculator;
+        },
+    },
+    thens: {
+        result: (expected) => (calculator) => {
+            assert.equal(calculator.getDisplay(), expected);
+        },
+    },
+};

package/dist/module/example/Calculator.test.js

@@ -0,0 +1,6 @@
+import Testeranto from "testeranto/src/Node";
+import { specification } from "./Calculator.test.specification";
+import { implementation } from "./Calculator.test.implementation";
+import { adapter } from "./Calculator.test.adapter";
+import { Calculator } from "./Calculator";
+export default Testeranto(Calculator, specification, implementation, adapter);

package/dist/module/example/Calculator.test.specification.js

@@ -0,0 +1,88 @@
+export const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.Default("Testing Calculator operations", {
+            // Basic number input
+            testEmptyDisplay: Given.Default(["pressing nothing, the display is empty"], [], [Then.result("")]),
+            testSingleDigit: Given.Default(["entering a number puts it on the display"], [When.press("2")], [Then.result("2")]),
+            testMultipleDigits: Given.Default(["entering multiple digits concatenates them"], [When.press("2"), When.press("2")], [Then.result("22")]),
+            testLargeNumber: Given.Default(["entering a large number works correctly"], [When.press("1"), When.press("2"), When.press("3"), When.press("4"), When.press("5")], [Then.result("12345")]),
+            // Basic operations
+            testAdditionExpression: Given.Default(["addition expression is displayed correctly"], [When.press("2"), When.press("+"), When.press("3")], [Then.result("2+3")]),
+            testIncompleteAddition: Given.Default(["incomplete addition expression is displayed correctly"], [When.press("2"), When.press("+")], [Then.result("2+")]),
+            testSubtractionExpression: Given.Default(["subtraction expression is displayed correctly"], [When.press("7"), When.press("-"), When.press("3")], [Then.result("7-3")]),
+            testMultiplicationExpression: Given.Default(["multiplication expression is displayed correctly"], [When.press("4"), When.press("*"), When.press("5")], [Then.result("4*5")]),
+            testDivisionExpression: Given.Default(["division expression is displayed correctly"], [When.press("8"), When.press("/"), When.press("2")], [Then.result("8/2")]),
+            // Complex expressions
+            testMixedOperations: Given.Default(["mixed operations are displayed correctly"], [When.press("2"), When.press("+"), When.press("3"), When.press("*"), When.press("4")], [Then.result("2+3*4")]),
+            testLongExpression: Given.Default(["long complex expression is displayed correctly"], [
+                When.press("1"), When.press("+"), When.press("2"),
+                When.press("*"), When.press("3"), When.press("-"),
+                When.press("4"), When.press("/"), When.press("5")
+            ], [Then.result("1+2*3-4/5")]),
+            // Calculation tests
+            testSimpleAddition: Given.Default(["simple addition calculation"], [
+                When.press("2"), When.press("3"), When.press("+"),
+                When.press("4"), When.press("5"), When.enter()
+            ], [Then.result("68")]),
+            testSimpleSubtraction: Given.Default(["simple subtraction calculation"], [
+                When.press("9"), When.press("5"), When.press("-"),
+                When.press("3"), When.press("2"), When.enter()
+            ], [Then.result("63")]),
+            testSimpleMultiplication: Given.Default(["simple multiplication calculation"], [
+                When.press("6"), When.press("*"), When.press("7"),
+                When.enter()
+            ], [Then.result("42")]),
+            testSimpleDivision: Given.Default(["simple division calculation"], [
+                When.press("8"), When.press("4"), When.press("/"),
+                When.press("2"), When.enter()
+            ], [Then.result("42")]),
+            // Edge cases
+            testClearOperation: Given.Default(["clear operation resets the display"], [
+                When.press("1"), When.press("2"), When.press("3"),
+                When.press("C"), When.press("4")
+            ], [Then.result("4")]),
+            testStartingWithOperator: Given.Default(["starting with operator should work"], [When.press("+"), When.press("5")], [Then.result("+5")]),
+            testMultipleOperators: Given.Default(["multiple operators in sequence"], [When.press("5"), When.press("+"), When.press("-"), When.press("3")], [Then.result("5+-3")]),
+            // Decimal numbers
+            testDecimalInput: Given.Default(["decimal number input"], [When.press("3"), When.press("."), When.press("1"), When.press("4")], [Then.result("3.14")]),
+            testDecimalCalculation: Given.Default(["decimal calculation"], [
+                When.press("3"), When.press("."), When.press("1"), When.press("+"),
+                When.press("1"), When.press("."), When.press("8"), When.press("6"),
+                When.enter()
+            ], [Then.result("4.96")]),
+            // Complex calculations
+            testOrderOfOperations: Given.Default(["order of operations is respected"], [
+                When.press("2"), When.press("+"), When.press("3"),
+                When.press("*"), When.press("4"), When.enter()
+            ], [Then.result("14")]),
+            testParenthesesExpression: Given.Default(["parentheses in expression"], [
+                When.press("("), When.press("2"), When.press("+"),
+                When.press("3"), When.press(")"), When.press("*"),
+                When.press("4"), When.enter()
+            ], [Then.result("20")]),
+            // Error cases
+            testDivisionByZero: Given.Default(["division by zero shows error"], [
+                When.press("5"), When.press("/"), When.press("0"),
+                When.enter()
+            ], [Then.result("Error")]),
+            testInvalidExpression: Given.Default(["invalid expression shows error"], [
+                When.press("2"), When.press("+"), When.press("+"),
+                When.press("3"), When.enter()
+            ], [Then.result("Error")]),
+            // Memory functions
+            testMemoryStoreRecall: Given.Default(["memory store and recall"], [
+                When.press("1"), When.press("2"), When.press("3"),
+                When.press("MS"), When.press("C"), When.press("MR")
+            ], [Then.result("123")]),
+            testMemoryClear: Given.Default(["memory clear"], [
+                When.press("4"), When.press("5"), When.press("6"),
+                When.press("MS"), When.press("MC"), When.press("MR")
+            ], [Then.result("0")]),
+            testMemoryAddition: Given.Default(["memory addition"], [
+                When.press("1"), When.press("0"), When.press("M+"),
+                When.press("2"), When.press("0"), When.press("M+"),
+                When.press("MR")
+            ], [Then.result("30")])
+        }),
+    ];
+};

package/dist/module/example/Calculator.test.types.js

@@ -0,0 +1,2 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export {};

package/dist/module/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/dist/module/scripts/build-example.js

@@ -0,0 +1,100 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+console.log("Building example project (ES module version)...");
+try {
+    // Always work from the project root
+    const projectRoot = path.resolve(import.meta.dirname, "..");
+    console.log(`Project root: ${projectRoot}`);
+    // Change to project root
+    process.chdir(projectRoot);
+    console.log(`Current working directory (build-example): ${projectRoot}`);
+    // The example directory is now relative to project root
+    const exampleDir = path.join(projectRoot, "example");
+    console.log(`Example directory: ${exampleDir}`);
+    // Ensure go.mod exists - create one if it doesn't
+    const goModPath = path.join(exampleDir, "go.mod");
+    if (!fs.existsSync(goModPath)) {
+        console.log("go.mod not found, creating a new one...");
+        const defaultGoMod = `module example
+
+go 1.19
+`;
+        fs.writeFileSync(goModPath, defaultGoMod);
+        console.log("Created default go.mod");
+    }
+    else {
+        // Read the existing go.mod and remove any replace directives
+        let goModContent = fs.readFileSync(goModPath, "utf8");
+        // Remove any replace directives that might cause issues
+        const lines = goModContent.split('\n').filter(line => !line.trim().startsWith('replace '));
+        // Also remove any require directives for testeranto
+        const cleanedLines = lines.filter(line => !line.trim().startsWith('require github.com/adamwong246/testeranto'));
+        goModContent = cleanedLines.join('\n');
+        fs.writeFileSync(goModPath, goModContent);
+        console.log("Cleaned up go.mod by removing replace and testeranto require directives");
+    }
+    // Read the current go.mod content
+    let goModContent = fs.readFileSync(goModPath, "utf8");
+    // Ensure the module is properly set up
+    if (!goModContent.includes("module ")) {
+        console.log("Initializing go module...");
+        execSync("go mod init example", {
+            stdio: "pipe",
+            cwd: exampleDir,
+        });
+        // Re-read the content
+        goModContent = fs.readFileSync(goModPath, "utf8");
+    }
+    // Add the replace directive to point to the local testeranto
+    // This tells Go to use the local directory instead of trying to download from GitHub
+    if (!goModContent.includes("replace github.com/adamwong246/testeranto")) {
+        console.log("Adding replace directive...");
+        execSync("go mod edit -replace github.com/adamwong246/testeranto=../", {
+            stdio: "pipe",
+            cwd: exampleDir,
+        });
+    }
+    // Add the require directive to explicitly list the dependency
+    // This ensures the dependency is tracked even if it's not imported directly in the example
+    console.log("Adding require directive...");
+    try {
+        execSync("go mod edit -require github.com/adamwong246/testeranto@v0.0.0", {
+            stdio: "pipe",
+            cwd: exampleDir,
+        });
+    }
+    catch (error) {
+        // It's okay if this fails - the require might already be there
+        console.log("Require directive may already exist");
+    }
+    // Read the updated content
+    goModContent = fs.readFileSync(goModPath, "utf8");
+    console.log("Updated go.mod content:");
+    console.log(goModContent);
+    // Run go mod tidy to ensure dependencies are correct
+    console.log("Running go mod tidy...");
+    try {
+        const tidyOutput = execSync("go mod tidy -v", {
+            stdio: "pipe",
+            encoding: "utf-8",
+            cwd: exampleDir,
+        });
+        console.log("go mod tidy output:");
+        console.log(tidyOutput);
+    }
+    catch (error) {
+        console.error("go mod tidy failed:");
+        if (error.stdout)
+            console.error("stdout:", error.stdout.toString());
+        if (error.stderr)
+            console.error("stderr:", error.stderr.toString());
+        console.error("Continuing despite go mod tidy error...");
+    }
+    console.log("Example project built successfully!");
+}
+catch (error) {
+    console.error("Failed to build example project:");
+    console.error(error);
+    process.exit(1);
+}

package/dist/module/src/CoreTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/module/src/Helpo.js

@@ -0,0 +1,48 @@
+import React from "react";
+export const Helpo = () => (React.createElement("div", { className: "d-flex flex-column h-100" },
+    React.createElement("div", { className: "border-bottom p-3" }),
+    React.createElement("div", { className: "flex-grow-1 p-3", style: { overflowY: "auto" } },
+        React.createElement("div", { className: "d-flex mb-3" },
+            React.createElement("div", { className: "me-2" },
+                React.createElement("div", { className: "rounded-circle d-flex align-items-center justify-content-center bg-primary text-white", style: { width: "40px", height: "40px" } }, "\uD83E\uDD16")),
+            React.createElement("div", { className: "flex-grow-1" },
+                React.createElement("div", { className: "fw-bold" }, "Helpo"),
+                React.createElement("div", { className: "bg-light p-3 rounded" },
+                    React.createElement("p", null, "Hello! I'm Helpo, your helpful robot assistant. How can I assist you today?")))),
+        React.createElement("div", { className: "d-flex mb-3 justify-content-end" },
+            React.createElement("div", { className: "flex-grow-1 me-2 text-end" },
+                React.createElement("div", { className: "fw-bold" }, "You"),
+                React.createElement("div", { className: "bg-primary text-white p-3 rounded" },
+                    React.createElement("p", null,
+                        "Can you show me how to format text with ",
+                        React.createElement("strong", null, "bold"),
+                        " and",
+                        " ",
+                        React.createElement("em", null, "italic"),
+                        "?"))),
+            React.createElement("div", null,
+                React.createElement("div", { className: "rounded-circle d-flex align-items-center justify-content-center bg-secondary text-white", style: { width: "40px", height: "40px" } }, "\uD83D\uDC64"))),
+        React.createElement("div", { className: "d-flex mb-3" },
+            React.createElement("div", { className: "me-2" },
+                React.createElement("div", { className: "rounded-circle d-flex align-items-center justify-content-center bg-primary text-white", style: { width: "40px", height: "40px" } }, "\uD83E\uDD16")),
+            React.createElement("div", { className: "flex-grow-1" },
+                React.createElement("div", { className: "fw-bold" }, "Helpo"),
+                React.createElement("div", { className: "bg-light p-3 rounded" },
+                    React.createElement("p", null, "Sure! Here's an example:"),
+                    React.createElement("ul", null,
+                        React.createElement("li", null,
+                            "Use ",
+                            React.createElement("code", null, "<strong>"),
+                            " for ",
+                            React.createElement("strong", null, "bold text")),
+                        React.createElement("li", null,
+                            "Use ",
+                            React.createElement("code", null, "<em>"),
+                            " for ",
+                            React.createElement("em", null, "italic text")),
+                        React.createElement("li", null, "You can even include lists and other HTML elements")),
+                    React.createElement("p", null, "Let me know if you need help with anything else!"))))),
+    React.createElement("div", { className: "border-top p-3" },
+        React.createElement("div", { className: "input-group" },
+            React.createElement("input", { type: "text", className: "form-control", placeholder: "Type your message...", disabled: true }),
+            React.createElement("button", { className: "btn btn-primary", type: "button", disabled: true }, "Send")))));

package/dist/module/src/Init.js

@@ -0,0 +1,51 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import fs from "fs";
+export default async () => {
+    [
+        `testeranto/`,
+        `testeranto/bundles/`,
+        `testeranto/bundles/node`,
+        `testeranto/bundles/web`,
+        `testeranto/bundles/pure`,
+        `testeranto/bundles/golang`,
+        `testeranto/bundles/python`,
+        `testeranto/reports/`,
+        `testeranto/features/`,
+        // `testeranto/externalTests/`,
+        `testeranto/metafiles/`,
+        `testeranto/metafiles/node`,
+        `testeranto/metafiles/web`,
+        `testeranto/metafiles/pure`,
+        `testeranto/metafiles/golang`,
+        `testeranto/metafiles/python`,
+    ].forEach((f) => {
+        try {
+            fs.mkdirSync(`${process.cwd()}/${f}`);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/App.js`, `testeranto/App.js`);
+    fs.copyFileSync(`node_modules/testeranto/dist/prebuild/App.css`, `testeranto/App.css`);
+    // fs.copyFileSync(
+    //   `node_modules/testeranto/dist/prebuild/ReportClient.js`,
+    //   `testeranto/ReportClient.js`
+    // );
+    // fs.copyFileSync(
+    //   `node_modules/testeranto/dist/prebuild/Project.css`,
+    //   `testeranto/Project.css`
+    // );
+    // fs.copyFileSync(
+    //   `node_modules/testeranto/dist/prebuild/ReportClient.css`,
+    //   `testeranto/ReportClient.css`
+    // );
+    // fs.copyFileSync(
+    //   `node_modules/testeranto/dist/prebuild/TestReport.js`,
+    //   `testeranto/TestReport.js`
+    // );
+    // fs.copyFileSync(
+    //   `node_modules/testeranto/dist/prebuild/TestReport.css`,
+    //   `testeranto/TestReport.css`
+    // );
+};