testeranto 0.177.0 → 0.197.0

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

@@ -0,0 +1,494 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  PM,
+  TesterantoCore,
+  defaultTestResourceRequirement
+} from "../../../chunk-4CSH4UJE.mjs";
+
+// src/PM/pure.ts
+var PM_Pure = class extends PM {
+  constructor(t) {
+    super();
+    this.server = {};
+    this.testResourceConfiguration = t;
+  }
+  getInnerHtml(selector, page) {
+    throw new Error("pure.ts getInnerHtml not implemented");
+  }
+  stopSideCar(uid) {
+    throw new Error("pure.ts stopSideCar not implemented");
+  }
+  trackCall(method, args) {
+  }
+  start() {
+    return new Promise((r) => r());
+  }
+  stop() {
+    return new Promise((r) => r());
+  }
+  async createWriteStream(filepath, testName) {
+    throw new Error("pure.ts createWriteStream not implemented");
+    return "";
+  }
+  launchSideCar(n) {
+    return globalThis["launchSideCar"](n, this.testResourceConfiguration.name);
+  }
+  pages() {
+    return globalThis["pages"]();
+  }
+  waitForSelector(p, s) {
+    return globalThis["waitForSelector"](p, s);
+  }
+  closePage(p) {
+    return globalThis["closePage"](p);
+  }
+  goto(cdpPage, url) {
+    return globalThis["goto"](cdpPage.mainFrame()._id, url);
+  }
+  newPage() {
+    return globalThis["newPage"]();
+  }
+  $(selector) {
+    return globalThis["$"](selector);
+  }
+  isDisabled(selector) {
+    return globalThis["isDisabled"](selector);
+  }
+  getAttribute(selector, attribute) {
+    return globalThis["getAttribute"](selector, attribute);
+  }
+  getValue(selector) {
+    return globalThis["getValue"](selector);
+  }
+  focusOn(selector) {
+    return globalThis["focusOn"](selector);
+  }
+  typeInto(selector, value) {
+    return globalThis["typeInto"](selector, value);
+  }
+  page() {
+    return globalThis["page"]();
+  }
+  click(selector) {
+    return globalThis["click"](selector);
+  }
+  screencast(opts, page) {
+    return globalThis["screencast"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path
+      },
+      page,
+      this.testResourceConfiguration.name
+    );
+  }
+  screencastStop(p) {
+    return globalThis["screencastStop"](p);
+  }
+  customScreenShot(opts, page) {
+    return globalThis["customScreenShot"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path
+      },
+      page,
+      this.testResourceConfiguration.name
+    );
+  }
+  // TODO: fix these
+  existsSync(destFolder) {
+    return Promise.resolve(true);
+  }
+  mkdirSync() {
+    return true;
+  }
+  write(uid, contents) {
+    return Promise.resolve(true);
+  }
+  writeFileSync() {
+    return Promise.resolve(true);
+  }
+  /////////////////////////////////////////////////////
+  end(uid) {
+    return globalThis["end"](uid);
+  }
+  customclose() {
+    globalThis["customclose"](
+      this.testResourceConfiguration.fs,
+      this.testResourceConfiguration.name
+    );
+  }
+  testArtiFactoryfileWriter(tLog, callback) {
+    return (fPath, value) => {
+      this.trackCall("testArtiFactoryfileWriter", { fPath, value });
+      callback(Promise.resolve());
+    };
+  }
+  // startPuppeteer(options?: any): any {
+  //   // return puppeteer.connect(options).then((b) => {
+  //   //   this.browser = b;
+  //   // });
+  // }
+};
+
+// src/Pure.ts
+var PureTesteranto = class extends TesterantoCore {
+  constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter3) {
+    super(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      testAdapter3,
+      () => {
+      }
+    );
+  }
+  async receiveTestResourceConfig(partialTestResource) {
+    const t = JSON.parse(partialTestResource);
+    const pm = new PM_Pure(t);
+    try {
+      const result = this.testJobs[0].receiveTestResourceConfig(pm);
+      return result;
+    } catch (e) {
+      console.error("[ERROR] Test job failed:", e);
+      return {
+        failed: true,
+        fails: -1,
+        artifacts: [],
+        // logPromise: Promise.resolve(),
+        features: []
+      };
+    }
+  }
+};
+var Pure_default = async (input, testSpecification, testImplementation, testAdapter3, testResourceRequirement = defaultTestResourceRequirement) => {
+  return new PureTesteranto(
+    input,
+    testSpecification,
+    testImplementation,
+    testResourceRequirement,
+    testAdapter3
+  );
+};
+
+// src/lib/core.test/core.test.specification.ts
+var specification2 = (Suite, Given, When, Then) => {
+  const summary = {
+    suites: {
+      "Testeranto Core Functionality": {
+        features: {},
+        artifacts: []
+      },
+      "Testeranto Advanced Features": {
+        features: {},
+        artifacts: []
+      }
+    },
+    features: {},
+    artifacts: []
+  };
+  return [
+    Suite.Default(
+      "Testeranto Core Functionality",
+      summary.suites["Testeranto Core Functionality"],
+      {
+        // Initialization tests
+        defaultInitialization: Given.Default(
+          ["Should initialize with default values"],
+          [],
+          [
+            Then.initializedProperly(),
+            Then.specsGenerated(),
+            Then.jobsCreated(),
+            Then.artifactsTracked()
+          ]
+        ),
+        customInputInitialization: Given.WithCustomInput(
+          { test: "input" },
+          [],
+          [Then.initializedProperly()]
+        ),
+        // Configuration tests
+        resourceConfig: Given.WithResourceRequirements(
+          { ports: [3e3, 3001] },
+          [],
+          [Then.resourceRequirementsSet()]
+        ),
+        interfaceConfig: Given.WithCustomAdapter(
+          {
+            assertThis: (x) => !!x,
+            beforeEach: async (s, i) => i()
+          },
+          [],
+          [Then.interfaceConfigured()]
+        ),
+        // Core operations
+        specGeneration: Given.Default(
+          ["Should generate test specs"],
+          [],
+          [Then.specsGenerated()]
+        ),
+        jobCreation: Given.Default(
+          ["Should create test jobs"],
+          [],
+          [Then.jobsCreated()]
+        ),
+        artifactHandling: Given.Default(
+          ["Should track artifacts"],
+          [When.addArtifact(Promise.resolve("test"))],
+          [Then.artifactsTracked()]
+        )
+      },
+      []
+    ),
+    Suite.ExtendedSuite("Testeranto Advanced Features", summary.suites["Testeranto Advanced Features"], {
+      // Error handling
+      errorPropagation: Given.Default(
+        ["Should propagate errors properly"],
+        [When.triggerError("test error")],
+        [Then.errorThrown("test error")]
+      ),
+      // Dynamic behavior
+      specModification: Given.Default(
+        ["Should allow spec modification"],
+        [When.modifySpecs((specs) => [...specs, { name: "extra" }])],
+        [Then.specsModified(1)]
+      ),
+      // Full lifecycle
+      testExecution: Given.Default(
+        ["Should execute full test lifecycle"],
+        [],
+        [Then.testRunSuccessful()]
+      ),
+      // Custom implementations
+      // Removed customImpl test since WithCustomImplementation isn't defined
+      dynamicSpecs: Given.Default(
+        ["Should handle dynamic spec changes"],
+        [When.modifySpecs((specs) => specs)],
+        [Then.specsGenerated()]
+      )
+    })
+  ];
+};
+
+// src/lib/core.test/MockCore.ts
+var MockCore = class extends TesterantoCore {
+  constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testAdapter3, uberCatcher = (cb) => cb()) {
+    const requiredMethods = ["suites", "givens", "whens", "thens"];
+    requiredMethods.forEach((method) => {
+      if (!testImplementation[method]) {
+        throw new Error(`Missing required implementation method: ${method}`);
+      }
+    });
+    super(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      testAdapter3,
+      uberCatcher
+    );
+    this.specs = [];
+    this.testJobs = [];
+    this.artifacts = [];
+  }
+  async receiveTestResourceConfig(partialTestResource) {
+    return {
+      failed: false,
+      fails: 0,
+      artifacts: [],
+      // logPromise: Promise.resolve(),
+      features: []
+    };
+  }
+};
+
+// src/lib/core.test/core.test.implementation.ts
+var implementation = {
+  suites: {
+    Default: "Testeranto test suite",
+    ExtendedSuite: "Extended Testeranto test suite"
+  },
+  givens: {
+    Default: () => {
+      const input = { debug: true };
+      const resourceReq = { ports: [3e3] };
+      try {
+        const instance = new MockCore(
+          input,
+          specification,
+          implementation,
+          resourceReq,
+          testAdapter,
+          (cb) => cb()
+        );
+        return instance;
+      } catch (e) {
+        console.error("[ERROR] Failed to create MockCore:", e);
+        throw e;
+      }
+    },
+    WithCustomInput: (input) => {
+      return new MockCore(
+        input,
+        specification,
+        implementation,
+        { ports: [] },
+        testAdapter,
+        (cb) => cb()
+      );
+    },
+    WithResourceRequirements: (requirements) => {
+      return new MockCore(
+        {},
+        specification,
+        implementation,
+        requirements,
+        testAdapter,
+        (cb) => cb()
+      );
+    },
+    WithCustomAdapter: (customAdapter) => {
+      return new MockCore(
+        {},
+        specification,
+        implementation,
+        { ports: [] },
+        { ...testAdapter, ...customAdapter },
+        (cb) => cb()
+      );
+    }
+  },
+  whens: {
+    addArtifact: (artifact) => (builder) => {
+      builder.artifacts.push(artifact);
+      return builder;
+    },
+    setTestJobs: (jobs) => (builder) => {
+      builder.testJobs = jobs;
+      return builder;
+    },
+    modifySpecs: (modifier) => (builder) => {
+      console.log("Modifying specs - current count:", builder.specs?.length);
+      const newSpecs = modifier(builder.specs || []);
+      console.log("Modifying specs - new count:", newSpecs.length);
+      builder.specs = newSpecs;
+      return builder;
+    },
+    triggerError: (message) => (builder) => {
+      throw new Error(message);
+    }
+  },
+  thens: {
+    initializedProperly: () => (builder) => {
+      if (!builder) {
+        throw new Error("Builder is undefined");
+      }
+      if (!(builder instanceof MockCore)) {
+        throw new Error(
+          `Builder is not MockCore (got ${builder.constructor.name})`
+        );
+      }
+      if (!builder.testResourceRequirement) {
+        throw new Error("testResourceRequirement not set");
+      }
+      if (!builder.testAdapter) {
+        throw new Error("testAdapter not set");
+      }
+      return builder;
+    },
+    specsGenerated: () => (builder) => {
+      if (!Array.isArray(builder.specs)) {
+        throw new Error("Specs were not generated");
+      }
+      return builder;
+    },
+    jobsCreated: () => (builder) => {
+      if (!Array.isArray(builder.testJobs)) {
+        throw new Error("Test jobs were not created");
+      }
+      return builder;
+    },
+    artifactsTracked: () => (builder) => {
+      if (!Array.isArray(builder.artifacts)) {
+        throw new Error("Artifacts array not initialized");
+      }
+      return builder;
+    },
+    resourceRequirementsSet: () => (builder) => {
+      if (!builder.testResourceRequirement) {
+        throw new Error("Resource requirements not set");
+      }
+      return builder;
+    },
+    interfaceConfigured: () => (builder) => {
+      if (!builder.testAdapter) {
+        throw new Error("Test adapter not configured");
+      }
+      return builder;
+    },
+    errorThrown: (expectedMessage) => (builder) => {
+      return builder;
+    },
+    testRunSuccessful: () => async (builder) => {
+      try {
+        await builder.receiveTestResourceConfig("");
+        return builder;
+      } catch (e) {
+        throw new Error(`Test run failed: ${e.message}`);
+      }
+    },
+    specsModified: (expectedCount) => (builder) => {
+      if (!builder.specs || builder.specs.length !== expectedCount) {
+        throw new Error(
+          `Expected ${expectedCount} specs, got ${builder.specs?.length}`
+        );
+      }
+      return builder;
+    }
+  }
+};
+
+// src/lib/core.test/core.test.adapter.ts
+var testAdapter2 = {
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    try {
+      const result = await initializer();
+      if (!result) {
+        throw new Error("Initializer returned undefined");
+      }
+      if (!(result instanceof MockCore)) {
+        throw new Error(
+          `Initializer returned ${result?.constructor?.name}, expected MockCore`
+        );
+      }
+      return result;
+    } catch (e) {
+      console.error("[ERROR] BeforeEach failed:", e);
+      throw e;
+    }
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    return whenCB(store, pm);
+  },
+  butThen: async (store, thenCB, testResource, pm) => {
+    return thenCB(store, pm);
+  },
+  afterEach: (store) => store,
+  afterAll: (store, pm) => {
+  },
+  assertThis: (result) => !!result,
+  beforeAll: async (input, testResource, pm) => input
+};
+
+// src/lib/core.test/core.test.ts
+var core_test_default = Pure_default(
+  MockCore.prototype,
+  specification2,
+  implementation,
+  testAdapter2
+);
+export {
+  core_test_default as default
+};