testeranto 0.197.0 → 0.198.0

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

@@ -1,494 +0,0 @@
-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
-};