testeranto 0.171.0 → 0.173.0

package/testeranto/bundles/node/allTests/chunk-M6DO7VMB.mjs

@@ -1,252 +0,0 @@
-import { createRequire } from 'module';const require = createRequire(import.meta.url);
-import {
-  PM,
-  TesterantoCore,
-  defaultTestResourceRequirement
-} from "./chunk-E75CSRER.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(filepath, contents) {
-    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) {
-    console.log("receiveTestResourceConfig", partialTestResource);
-    const t = JSON.parse(partialTestResource);
-    const pm = new PM_Node(t, ipcfile);
-    return await this.testJobs[0].receiveTestResourceConfig(pm);
-  }
-};
-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];
-    const f = await t.receiveTestResourceConfig(process.argv[2]);
-    console.error("goodbye node with failures", f.fails);
-    process.exit(f.fails);
-  } catch (e) {
-    console.error("goodbye node with caught error", e);
-    process.exit(-1);
-  }
-};
-var Node_default = testeranto;
-
-export {
-  Node_default
-};

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

@@ -1,323 +0,0 @@
-import { createRequire } from 'module';const require = createRequire(import.meta.url);
-import {
-  MockSuite
-} from "../../../chunk-3EUGBAOM.mjs";
-import {
-  Node_default
-} from "../../../chunk-M6DO7VMB.mjs";
-import {
-  BaseSuite
-} from "../../../chunk-E75CSRER.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: () => {
-      const suite = new MockSuite("testSuite", 0);
-      console.log("[DEBUG] Created test suite:", suite.name, suite.index);
-      return suite;
-    }
-  },
-  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) => {
-      console.log("[DEBUG] Running RunSuite");
-      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) => (suite) => {
-      console.log(
-        "[DEBUG] SuiteNameMatches - expected:",
-        expectedName,
-        "actual:",
-        suite?.name
-      );
-      if (!suite?.name) {
-        throw new Error(`Suite name is undefined. Expected: ${expectedName}`);
-      }
-      if (suite.name !== expectedName) {
-        throw new Error(
-          `Expected suite name '${expectedName}', got '${suite.name}'`
-        );
-      }
-      return suite;
-    },
-    SuiteIndexMatches: (expectedIndex) => (suite) => {
-      if (suite.index !== expectedIndex) {
-        throw new Error(
-          `Expected suite index ${expectedIndex}, got ${suite.index}`
-        );
-      }
-      return suite;
-    },
-    FeaturesIncludes: (feature) => (suite) => {
-      if (!suite.features().includes(feature)) {
-        throw new Error(`Expected features to include ${feature}`);
-      }
-      return suite;
-    },
-    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) => {
-    console.log("[DEBUG] Running beforeEach with subject:", subject);
-    try {
-      const suite = await initializer();
-      if (!suite) {
-        throw new Error("Initializer returned undefined suite");
-      }
-      console.log("[DEBUG] beforeEach result:", {
-        name: suite.name,
-        index: suite.index,
-        store: suite.store
-      });
-      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) => whenCB(store, pm),
-  butThen: async (store, thenCB, testResource, pm) => {
-    console.log(
-      "[DEBUG] butThen - input store:",
-      JSON.stringify(store, null, 2)
-    );
-    const testSelection = {
-      testSelection: store.testSelection || false,
-      error: store.error ? true : void 0
-    };
-    console.log(
-      "[DEBUG] butThen - created testSelection:",
-      JSON.stringify(testSelection, null, 2)
-    );
-    try {
-      const result = await thenCB(testSelection);
-      console.log("[DEBUG] butThen - result:", JSON.stringify(result, null, 2));
-      if (!result || typeof result.testSelection === "undefined") {
-        throw new Error(
-          `Invalid test selection result: ${JSON.stringify(result)}`
-        );
-      }
-      return result;
-    } catch (e) {
-      console.error("Then error:", e.toString());
-      console.error("Full store state:", JSON.stringify(store, null, 2));
-      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
-};