testeranto 0.177.0 → 0.197.0

package/testeranto/bundles/node/core/chunk-4JTDLQVA.mjs

@@ -0,0 +1,253 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  PM,
+  TesterantoCore,
+  defaultTestResourceRequirement
+} from "./chunk-4CSH4UJE.mjs";
+
+// src/PM/node.ts
+import net from "net";
+import fs from "fs";
+import path from "path";
+var fPaths = [];
+var PM_Node = class extends PM {
+  constructor(t, ipcFile) {
+    super();
+    this.testResourceConfiguration = t;
+    this.client = net.createConnection(ipcFile, () => {
+      return;
+    });
+  }
+  start() {
+    throw new Error("DEPRECATED");
+  }
+  stop() {
+    throw new Error("stop not implemented.");
+  }
+  send(command, ...argz) {
+    const key = Math.random().toString();
+    if (!this.client) {
+      console.error(
+        `Tried to send "${command} (${argz})" but the test has not been started and the IPC client is not established. Exiting as failure!`
+      );
+      process.exit(-1);
+    }
+    return new Promise((res) => {
+      const myListener = (event) => {
+        const x = JSON.parse(event);
+        if (x.key === key) {
+          process.removeListener("message", myListener);
+          res(x.payload);
+        }
+      };
+      process.addListener("message", myListener);
+      this.client.write(JSON.stringify([command, ...argz, key]));
+    });
+  }
+  async launchSideCar(n) {
+    return this.send(
+      "launchSideCar",
+      n,
+      this.testResourceConfiguration.name
+    );
+  }
+  stopSideCar(n) {
+    return this.send(
+      "stopSideCar",
+      n,
+      this.testResourceConfiguration.name
+    );
+  }
+  async pages() {
+    return this.send("pages", ...arguments);
+  }
+  waitForSelector(p, s) {
+    return this.send("waitForSelector", ...arguments);
+  }
+  closePage(p) {
+    return this.send("closePage", ...arguments);
+  }
+  goto(page, url) {
+    return this.send("goto", ...arguments);
+  }
+  async newPage() {
+    return this.send("newPage");
+  }
+  $(selector, page) {
+    return this.send("$", ...arguments);
+  }
+  isDisabled(selector) {
+    return this.send("isDisabled", ...arguments);
+  }
+  getAttribute(selector, attribute, p) {
+    return this.send("getAttribute", ...arguments);
+  }
+  getInnerHtml(selector, p) {
+    return this.send("getInnerHtml", ...arguments);
+  }
+  // setValue(selector: string) {
+  //   return this.send("getValue", ...arguments);
+  // }
+  focusOn(selector) {
+    return this.send("focusOn", ...arguments);
+  }
+  typeInto(selector) {
+    return this.send("typeInto", ...arguments);
+  }
+  page() {
+    return this.send("page");
+  }
+  click(selector) {
+    return this.send("click", ...arguments);
+  }
+  screencast(opts, page) {
+    return this.send(
+      "screencast",
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path
+      },
+      page,
+      this.testResourceConfiguration.name
+    );
+  }
+  screencastStop(p) {
+    return this.send("screencastStop", ...arguments);
+  }
+  customScreenShot(x, y) {
+    const opts = x[0];
+    const page = x[1];
+    return this.send(
+      "customScreenShot",
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path
+      },
+      this.testResourceConfiguration.name,
+      page
+    );
+  }
+  async existsSync(destFolder) {
+    return await this.send(
+      "existsSync",
+      this.testResourceConfiguration.fs + "/" + destFolder
+    );
+  }
+  mkdirSync() {
+    return this.send("mkdirSync", this.testResourceConfiguration.fs + "/");
+  }
+  async write(uid, contents) {
+    return await this.send("write", ...arguments);
+  }
+  async writeFileSync(x) {
+    const z = arguments["0"];
+    const filepath = arguments[0];
+    const contents = arguments[1];
+    return await this.send(
+      "writeFileSync",
+      this.testResourceConfiguration.fs + "/" + filepath,
+      contents,
+      this.testResourceConfiguration.name
+    );
+  }
+  async createWriteStream(filepath) {
+    return await this.send(
+      "createWriteStream",
+      this.testResourceConfiguration.fs + "/" + filepath,
+      this.testResourceConfiguration.name
+    );
+  }
+  async end(uid) {
+    return await this.send("end", ...arguments);
+  }
+  async customclose() {
+    return await this.send(
+      "customclose",
+      this.testResourceConfiguration.fs,
+      this.testResourceConfiguration.name
+    );
+  }
+  testArtiFactoryfileWriter(tLog, callback) {
+    return (fPath, value) => {
+      callback(
+        new Promise((res, rej) => {
+          tLog("testArtiFactory =>", fPath);
+          const cleanPath = path.resolve(fPath);
+          fPaths.push(cleanPath.replace(process.cwd(), ``));
+          const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+          fs.mkdir(targetDir, { recursive: true }, async (error) => {
+            if (error) {
+              console.error(`\u2757\uFE0FtestArtiFactory failed`, targetDir, error);
+            }
+            if (Buffer.isBuffer(value)) {
+              fs.writeFileSync(fPath, value, "binary");
+              res();
+            } else if (`string` === typeof value) {
+              fs.writeFileSync(fPath, value.toString(), {
+                encoding: "utf-8"
+              });
+              res();
+            } else {
+              const pipeStream = value;
+              const myFile = fs.createWriteStream(fPath);
+              pipeStream.pipe(myFile);
+              pipeStream.on("close", () => {
+                myFile.close();
+                res();
+              });
+            }
+          });
+        })
+      );
+    };
+  }
+  // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
+  startPuppeteer(options) {
+  }
+};
+
+// src/Node.ts
+var ipcfile;
+var NodeTesteranto = class extends TesterantoCore {
+  constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
+    super(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      testAdapter,
+      () => {
+      }
+    );
+  }
+  async receiveTestResourceConfig(partialTestResource) {
+    return await this.testJobs[0].receiveTestResourceConfig(
+      new PM_Node(JSON.parse(partialTestResource), ipcfile)
+    );
+  }
+};
+var testeranto = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = defaultTestResourceRequirement) => {
+  try {
+    const t = new NodeTesteranto(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      testAdapter
+    );
+    process.on("unhandledRejection", (reason, promise) => {
+      console.error("Unhandled Rejection at:", promise, "reason:", reason);
+    });
+    ipcfile = process.argv[3];
+    process.exit((await t.receiveTestResourceConfig(process.argv[2])).fails);
+  } catch (e) {
+    console.error(e);
+    console.error(e.stack);
+    process.exit(-1);
+  }
+};
+var Node_default = testeranto;
+
+export {
+  Node_default
+};

package/testeranto/bundles/node/core/chunk-C3APFDUV.mjs

@@ -0,0 +1,70 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  BaseGiven,
+  BaseSuite,
+  BaseThen,
+  BaseWhen
+} from "./chunk-4CSH4UJE.mjs";
+
+// src/lib/BaseSuite.test/mock.ts
+var MockGiven = class extends BaseGiven {
+  constructor(name, features, whens, thens) {
+    super(
+      name,
+      features,
+      whens,
+      thens,
+      async () => ({ testStore: true }),
+      // givenCB
+      {}
+      // initialValues
+    );
+  }
+  async givenThat() {
+    return { testStore: true };
+  }
+  uberCatcher(e) {
+    console.error("Given error 2:", e);
+  }
+};
+var MockWhen = class extends BaseWhen {
+  async andWhen(store, whenCB, testResource, pm) {
+    const selection = { testSelection: true };
+    const result = await whenCB(selection)(store);
+    return { ...store, ...result };
+  }
+  addArtifact(path) {
+  }
+};
+var MockThen = class extends BaseThen {
+  async butThen(store, thenCB, testResourceConfiguration, pm, ...args) {
+    const selection = { testSelection: true };
+    await thenCB(selection);
+    return selection;
+  }
+};
+var MockSuite = class extends BaseSuite {
+  constructor(name, index) {
+    if (!name) {
+      throw new Error("MockSuite requires a non-empty name");
+    }
+    const suiteName = name || "testSuite";
+    super(suiteName, index, {
+      testGiven: new MockGiven(
+        "testGiven",
+        ["testFeature"],
+        [new MockWhen("testWhen", async () => Promise.resolve({ testSelection: true }))],
+        [
+          new MockThen(
+            "testThen",
+            async () => Promise.resolve(new BaseSuite("temp", 0, {}))
+          )
+        ]
+      )
+    });
+  }
+};
+
+export {
+  MockSuite
+};

package/testeranto/bundles/node/core/src/lib/BaseSuite.test/node.test.mjs

@@ -0,0 +1,295 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  MockSuite
+} from "../../../chunk-C3APFDUV.mjs";
+import {
+  Node_default
+} from "../../../chunk-4JTDLQVA.mjs";
+import {
+  BaseSuite
+} from "../../../chunk-4CSH4UJE.mjs";
+
+// src/lib/BaseSuite.test/test.ts
+var specification = (Suite, Given, When, Then) => [
+  Suite.Default("BaseSuite Core Functionality Tests", {
+    // Test initialization and basic properties
+    initialization: Given.Default(
+      ["BaseSuite should initialize with correct name and index"],
+      [],
+      [Then.SuiteNameMatches("testSuite"), Then.SuiteIndexMatches(0)]
+    )
+    // // Test execution flow
+    // execution: Given.Default(
+    //   ["BaseSuite should execute all phases successfully"],
+    //   [When.RunSuite()],
+    //   [Then.StoreValid()]
+    // ),
+    // // Test multiple features
+    // multipleFeatures: Given.Default(
+    //   ["BaseSuite should handle multiple features"],
+    //   [When.AddFeature("additionalFeature")],
+    //   [
+    //     Then.FeaturesIncludes("testFeature"),
+    //     Then.FeaturesIncludes("additionalFeature"),
+    //     Then.FeatureCountMatches(2),
+    //   ]
+    // ),
+    // // Test error handling
+    // errorHandling: Given.Default(
+    //   ["BaseSuite should handle errors gracefully"],
+    //   [When.RunSuiteWithError()],
+    //   [Then.ErrorCountMatches(1), Then.FailedFlagSet()]
+    // ),
+  })
+  // Suite.Default("Comprehensive Integration", {
+  //   fullStackTest: Given.Default(
+  //     ["All components should work together"],
+  //     [
+  //       When.addArtifact(Promise.resolve("test")),
+  //       When.modifySpecs((specs) => [...specs, "extra"]),
+  //       When.modifyJobs((jobs) => [...jobs, {}]),
+  //     ],
+  //     [
+  //       Then.specsModified(1),
+  //       Then.jobsModified(1),
+  //       Then.artifactsTracked(),
+  //       Then.testRunSuccessful(),
+  //     ]
+  //   ),
+  // }),
+];
+var implementation = {
+  suites: {
+    Default: "BaseSuite Comprehensive Test Suite"
+  },
+  givens: {
+    Default: () => {
+      return async () => {
+        const suite = new MockSuite("testSuite", 0);
+        return {
+          name: suite.name,
+          index: suite.index,
+          testStore: true
+        };
+      };
+    }
+  },
+  whens: {
+    addArtifact: (artifact) => (suite) => {
+      suite.artifacts.push(artifact);
+      return suite;
+    },
+    modifySpecs: (modifier) => (suite) => {
+      suite.specs = modifier(suite.specs);
+      return suite;
+    },
+    modifyJobs: (modifier) => (suite) => {
+      suite.testJobs = modifier(suite.testJobs);
+      return suite;
+    },
+    RunSuite: () => async (suite) => {
+      const mockConfig = {
+        name: "test",
+        fs: "/tmp",
+        ports: [3e3],
+        environment: {},
+        timeout: 5e3,
+        retries: 3
+      };
+      const mockArtifactory = (key, value) => {
+      };
+      const mockTLog = (...args) => {
+      };
+      const mockPM = {
+        server: null,
+        testResourceConfiguration: mockConfig,
+        start: async () => {
+        },
+        stop: async () => {
+        },
+        testArtiFactoryfileWriter: () => {
+        },
+        $: () => {
+        },
+        click: () => {
+        },
+        closePage: () => {
+        },
+        createWriteStream: async () => ""
+      };
+      return await suite.run(
+        null,
+        mockConfig,
+        mockArtifactory,
+        mockTLog,
+        mockPM
+      );
+    },
+    RunSuiteWithError: () => async (suite) => {
+      try {
+        await suite.run(
+          null,
+          {},
+          // Invalid config
+          () => {
+          },
+          () => {
+          },
+          {}
+        );
+      } catch (e) {
+      }
+      return suite;
+    },
+    AddFeature: (feature) => (suite) => {
+      const firstGivenKey = Object.keys(suite.givens)[0];
+      if (firstGivenKey) {
+        suite.givens[firstGivenKey].features.push(feature);
+      }
+      return suite;
+    }
+  },
+  thens: {
+    SuiteNameMatches: (expectedName) => (ssel, utils) => (store) => {
+      if (store.name !== expectedName) {
+        throw new Error(
+          `Expected suite name '${expectedName}', got '${store.name}'`
+        );
+      }
+      return Promise.resolve({ testSelection: true });
+    },
+    SuiteIndexMatches: (expectedIndex) => (ssel, utils) => (store) => {
+      if (store.index !== expectedIndex) {
+        throw new Error(
+          `Expected suite index ${expectedIndex}, got ${store.index}`
+        );
+      }
+      return Promise.resolve({ testSelection: true });
+    },
+    FeaturesIncludes: (feature) => (ssel, utils) => (store) => {
+      return Promise.resolve({ testSelection: true });
+    },
+    FeatureCountMatches: (expectedCount) => (suite) => {
+      const actualCount = suite.features().length;
+      if (actualCount !== expectedCount) {
+        throw new Error(
+          `Expected ${expectedCount} features, got ${actualCount}`
+        );
+      }
+      return suite;
+    },
+    StoreValid: () => (suite) => {
+      if (!suite.store?.testStore) {
+        throw new Error("Expected valid store after execution");
+      }
+      return suite;
+    },
+    NoErrorsOccurred: () => (suite) => {
+      if (suite.failed || suite.fails > 0) {
+        throw new Error("Expected no errors to occur during execution");
+      }
+      return suite;
+    },
+    ErrorCountMatches: (expectedCount) => (suite) => {
+      if (suite.fails !== expectedCount) {
+        throw new Error(
+          `Expected ${expectedCount} errors, got ${suite.fails}`
+        );
+      }
+      return suite;
+    },
+    FailedFlagSet: () => (suite) => {
+      if (!suite.failed) {
+        throw new Error("Expected failed flag to be set after error");
+      }
+      return suite;
+    },
+    AllTestsCompleted: () => (suite) => {
+      if (!suite.store) {
+        throw new Error("Expected all tests to be completed");
+      }
+      return suite;
+    },
+    CleanExit: () => (suite) => {
+      if (suite.failed && suite.fails === 0) {
+        throw new Error("Expected clean exit state");
+      }
+      return suite;
+    },
+    specsModified: (expectedCount) => (suite) => {
+      if (suite.specs.length !== expectedCount) {
+        throw new Error(`Expected ${expectedCount} modified specs`);
+      }
+      return suite;
+    },
+    jobsModified: (expectedCount) => (suite) => {
+      if (suite.testJobs.length !== expectedCount) {
+        throw new Error(`Expected ${expectedCount} modified jobs`);
+      }
+      return suite;
+    },
+    artifactsTracked: () => (suite) => {
+      if (suite.artifacts.length === 0) {
+        throw new Error("Expected artifacts to be tracked");
+      }
+      return suite;
+    },
+    testRunSuccessful: () => (suite) => {
+      if (suite.failed) {
+        throw new Error("Expected test run to be successful");
+      }
+      return suite;
+    }
+  }
+};
+var testAdapter = {
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    try {
+      const suite = await initializer();
+      if (!suite) {
+        throw new Error("Initializer returned undefined suite");
+      }
+      return {
+        name: suite.name,
+        index: suite.index,
+        testStore: true,
+        testSelection: false,
+        ...suite.store || {}
+      };
+    } catch (e) {
+      console.error("Given error:", e);
+      throw e;
+    }
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    const selection = { testSelection: true };
+    const result = await whenCB(selection)(store);
+    return { ...store, ...result };
+  },
+  butThen: async (store, thenCB, testResource, pm) => {
+    try {
+      const selection = { testSelection: true };
+      await thenCB(selection);
+      return selection;
+    } catch (e) {
+      console.error("Then error:", e.toString());
+      throw e;
+    }
+  },
+  afterEach: (store) => store,
+  afterAll: (store, pm) => {
+  },
+  assertThis: (result) => !!result,
+  beforeAll: async (input, testResource, pm) => input
+};
+
+// src/lib/BaseSuite.test/node.test.ts
+var node_test_default = Node_default(
+  BaseSuite,
+  specification,
+  implementation,
+  testAdapter
+);
+export {
+  node_test_default as default
+};