testeranto 0.189.0 → 0.198.0

package/testeranto/bundles/pure/core/src/Pure.test.mjs

@@ -1,428 +0,0 @@
-import { createRequire } from 'module';const require = createRequire(import.meta.url);
-import {
-  Pure_default
-} from "../chunk-KHJ35R7C.mjs";
-
-// src/lib/pmProxy.test/mockPMBase.ts
-var MockPMBase = class {
-  constructor(configs) {
-    this.calls = {};
-    this.testResourceConfiguration = {};
-    this.configs = configs || {};
-  }
-  // Common tracking functionality
-  trackCall(method, args) {
-    if (!this.calls[method]) {
-      this.calls[method] = [];
-    }
-    this.calls[method].push(args);
-  }
-  getCallCount(method) {
-    return this.calls[method]?.length || 0;
-  }
-  getLastCall(method) {
-    const calls = this.calls[method];
-    return calls ? calls[calls.length - 1] : null;
-  }
-  // Add missing methods used in tests
-  // writeFileSync(path: string, content: string): Promise<boolean> {
-  //   this.trackCall('writeFileSync', { path, content });
-  //   return Promise.resolve(true);
-  // }
-  // end(uid: number): Promise<boolean> {
-  //   this.trackCall('end', { uid });
-  //   return Promise.resolve(true);
-  // }
-  // Minimal implementations of required methods
-  launchSideCar(n, testName, projectName) {
-    this.trackCall("launchSideCar", { n, testName, projectName });
-    return Promise.resolve();
-  }
-  end(uid) {
-    this.trackCall("end", { uid });
-    console.debug(`Ending test with uid ${uid}`);
-    return Promise.resolve(true);
-  }
-  // Add debug method
-  debug(message) {
-    console.debug(`[MockPMBase] ${message}`);
-    this.trackCall("debug", { message });
-  }
-  writeFileSync(path, content, testName) {
-    this.trackCall("writeFileSync", { path, content, testName });
-    return Promise.resolve(true);
-  }
-  createWriteStream(path, testName) {
-    this.trackCall("createWriteStream", { path, testName });
-    return Promise.resolve(0);
-  }
-  screencast(opts, testName, page) {
-    this.trackCall("screencast", { opts, testName, page });
-    return Promise.resolve({});
-  }
-  customScreenShot(opts, testName, pageUid) {
-    this.trackCall("customScreenShot", { opts, testName, pageUid });
-    return Promise.resolve({});
-  }
-  testArtiFactoryfileWriter(tLog, callback) {
-    return (fPath, value) => {
-      this.trackCall("testArtiFactoryfileWriter", { fPath, value });
-      callback(Promise.resolve());
-    };
-  }
-  // Other required PM_Base methods with minimal implementations
-  closePage(p) {
-    return Promise.resolve();
-  }
-  $(selector, p) {
-    return Promise.resolve();
-  }
-  click(selector, page) {
-    return Promise.resolve();
-  }
-  goto(p, url) {
-    return Promise.resolve();
-  }
-  newPage() {
-    return Promise.resolve("mock-page");
-  }
-  pages() {
-    return Promise.resolve(["mock-page"]);
-  }
-  waitForSelector(p, s) {
-    return Promise.resolve(true);
-  }
-  focusOn(selector, p) {
-    return Promise.resolve();
-  }
-  typeInto(value, p) {
-    return Promise.resolve();
-  }
-  getAttribute(selector, attribute, p) {
-    return Promise.resolve();
-  }
-  getInnerHtml(selector, p) {
-    return Promise.resolve();
-  }
-  isDisabled(selector, p) {
-    return Promise.resolve(false);
-  }
-  screencastStop(s) {
-    return Promise.resolve();
-  }
-  existsSync(destFolder) {
-    return false;
-  }
-  mkdirSync(fp) {
-    return Promise.resolve();
-  }
-  write(uid, contents) {
-    return Promise.resolve(true);
-  }
-  page(p) {
-    return "mock-page";
-  }
-  doInPage(p, cb) {
-    return Promise.resolve();
-  }
-  customclose() {
-    return Promise.resolve();
-  }
-};
-
-// src/Pure.test.ts
-var implementation = {
-  suites: {
-    Default: "PureTesteranto Test Suite"
-  },
-  givens: {
-    Default: () => ({
-      pm: new MockPMBase(),
-      config: {},
-      proxies: {
-        butThenProxy: (pm, path) => ({
-          ...pm,
-          writeFileSync: (p, c) => pm.writeFileSync(`${path}/butThen/${p}`, c)
-        }),
-        andWhenProxy: (pm, path) => ({
-          ...pm,
-          writeFileSync: (p, c) => pm.writeFileSync(`${path}/andWhen/${p}`, c)
-        }),
-        beforeEachProxy: (pm, suite) => ({
-          ...pm,
-          writeFileSync: (p, c) => pm.writeFileSync(`suite-${suite}/beforeEach/${p}`, c)
-        })
-      }
-    })
-  },
-  whens: {
-    applyProxy: (proxyType) => (store) => {
-      switch (proxyType) {
-        case "invalidConfig":
-          throw new Error("Invalid configuration");
-        case "missingProxy":
-          return { ...store, pm: {} };
-        case "largePayload":
-          return {
-            ...store,
-            largePayload: true,
-            pm: {
-              ...store.pm,
-              writeFileSync: (p, c) => {
-                if (c.length > 1e6) {
-                  return true;
-                }
-                throw new Error("Payload too small");
-              }
-            }
-          };
-        case "resourceConfig":
-          return {
-            ...store,
-            pm: {
-              ...store.pm,
-              testResourceConfiguration: { name: "test-resource" }
-            }
-          };
-        default:
-          return store;
-      }
-    },
-    addArtifact: (artifact) => (store) => {
-      return {
-        ...store,
-        artifacts: [...store.artifacts || [], artifact]
-      };
-    },
-    setTestJobs: (jobs) => (store) => {
-      return {
-        ...store,
-        testJobs: jobs
-      };
-    },
-    modifySpecs: (modifier) => (store) => {
-      return {
-        ...store,
-        specs: modifier(store.specs || [])
-      };
-    }
-  },
-  thens: {
-    initializedProperly: () => (store) => {
-      if (!store.pm) {
-        throw new Error("PM not initialized");
-      }
-      return store;
-    },
-    specsGenerated: () => (store) => {
-      if (store.pm.getCallCount("writeFileSync") === 0) {
-        throw new Error("No specs generated");
-      }
-      return store;
-    },
-    jobsCreated: () => (store) => {
-      return store;
-    },
-    artifactsTracked: () => (store) => {
-      return store;
-    },
-    testRunSuccessful: () => (store) => {
-      if (store.pm.getCallCount("end") === 0) {
-        throw new Error("Test run did not complete successfully");
-      }
-      return store;
-    },
-    specsModified: (expectedCount) => (store) => {
-      const actualCount = store.pm.getCallCount("writeFileSync");
-      if (actualCount < expectedCount) {
-        throw new Error(
-          `Expected ${expectedCount} spec modifications, got ${actualCount}`
-        );
-      }
-      return store;
-    },
-    verifyProxy: (expectedPath) => (store) => {
-      const actualPath = store.pm.getLastCall("writeFileSync")?.path;
-      if (actualPath !== expectedPath) {
-        throw new Error(`Expected path ${expectedPath}, got ${actualPath}`);
-      }
-      return store;
-    },
-    verifyNoProxy: () => (store) => {
-      if (store.pm.getCallCount("writeFileSync") > 0) {
-        throw new Error("Proxy was unexpectedly applied");
-      }
-      return store;
-    },
-    verifyError: (expectedError) => (store) => {
-      return store;
-    },
-    verifyResourceConfig: () => (store) => {
-      if (!store.pm.testResourceConfiguration) {
-        throw new Error("Missing test resource configuration");
-      }
-      return store;
-    },
-    verifyLargePayload: () => (store) => {
-      const largeContent = "x".repeat(2e6);
-      const result = store.pm.writeFileSync("large.txt", largeContent);
-      if (!result) {
-        throw new Error("Failed to handle large payload");
-      }
-      return store;
-    },
-    verifyTypeSafety: () => (store) => {
-      return store;
-    }
-  }
-};
-var specification = (Suite, Given, When, Then) => [
-  Suite.Default("Core Functionality", {
-    initializationTest: Given.Default(
-      ["Should initialize with default configuration"],
-      [],
-      [Then.verifyNoProxy()]
-    ),
-    resourceConfigTest: Given.Default(
-      ["Should handle test resource configuration"],
-      [When.applyProxy("resourceConfig")],
-      [Then.verifyResourceConfig()]
-    )
-  }),
-  Suite.Default("Proxy Integration", {
-    butThenProxyTest: Given.Default(
-      ["Should integrate with butThenProxy"],
-      [When.applyProxy("butThenProxy")],
-      [Then.verifyProxy("test/path/butThen/expected")]
-    ),
-    andWhenProxyTest: Given.Default(
-      ["Should integrate with andWhenProxy"],
-      [When.applyProxy("andWhenProxy")],
-      [Then.verifyProxy("test/path/andWhen/expected")]
-    ),
-    beforeEachProxyTest: Given.Default(
-      ["Should integrate with beforeEachProxy"],
-      [When.applyProxy("beforeEachProxy")],
-      [Then.verifyProxy("suite-1/beforeEach/expected")]
-    )
-  }),
-  Suite.Default("Error Handling", {
-    invalidConfigTest: Given.Default(
-      ["Should handle invalid configuration"],
-      [When.applyProxy("invalidConfig")],
-      [Then.verifyError("Invalid configuration")]
-    ),
-    missingProxyTest: Given.Default(
-      ["Should handle missing proxy"],
-      [When.applyProxy("missingProxy")],
-      [Then.verifyError("Proxy not found")]
-    )
-  }),
-  Suite.Default("Performance", {
-    multipleProxiesTest: Given.Default(
-      ["Should handle multiple proxies efficiently"],
-      [
-        When.applyProxy("butThenProxy"),
-        When.applyProxy("andWhenProxy"),
-        When.applyProxy("beforeEachProxy")
-      ],
-      [
-        Then.verifyProxy("test/path/butThen/expected"),
-        Then.verifyProxy("test/path/andWhen/expected"),
-        Then.verifyProxy("suite-1/beforeEach/expected")
-      ]
-    ),
-    largePayloadTest: Given.Default(
-      ["Should handle large payloads"],
-      [When.applyProxy("largePayload")],
-      [Then.verifyLargePayload()]
-    )
-  }),
-  Suite.Default("Cross-Component Verification", {
-    proxyChainTest: Given.Default(
-      ["Proxies should chain correctly"],
-      [When.applyProxy("butThenProxy"), When.applyProxy("andWhenProxy")],
-      [Then.verifyProxy("test/path/andWhen/butThen/expected")]
-    ),
-    errorPropagationTest: Given.Default(
-      ["Errors should propagate across components"],
-      [When.applyProxy("invalidConfig")],
-      [Then.verifyError("Invalid configuration")]
-    ),
-    resourceSharingTest: Given.Default(
-      ["Resources should be shared correctly"],
-      [When.applyProxy("resourceConfig")],
-      [Then.verifyResourceConfig()]
-    )
-  }),
-  Suite.Default("Type Safety", {
-    strictTypeTest: Given.Default(
-      ["Should enforce type safety"],
-      [When.applyProxy("typeSafe")],
-      [Then.verifyTypeSafety()]
-    ),
-    invalidTypeTest: Given.Default(
-      ["Should reject invalid types"],
-      [When.applyProxy("invalidType")],
-      [Then.verifyError("Type mismatch")]
-    )
-  }),
-  Suite.Default("Integration Tests", {
-    // Verify builders work together
-    builderIntegration: Given.Default(
-      ["BaseBuilder and ClassBuilder should integrate properly"],
-      [],
-      [
-        Then.initializedProperly(),
-        Then.specsGenerated(),
-        Then.jobsCreated(),
-        Then.artifactsTracked()
-      ]
-    ),
-    // Verify PM proxy integration
-    pmProxyIntegration: Given.Default(
-      ["PM proxies should work with test runners"],
-      [When.applyProxy("butThenProxy")],
-      [Then.verifyProxy("test/path/butThen/expected")]
-    ),
-    // Verify full test lifecycle
-    fullLifecycle: Given.Default(
-      ["Should complete full test lifecycle"],
-      [
-        When.addArtifact(Promise.resolve("test")),
-        When.setTestJobs([]),
-        When.modifySpecs((specs) => [...specs])
-      ],
-      [Then.testRunSuccessful(), Then.artifactsTracked(), Then.specsModified(0)]
-    )
-  })
-];
-var testAdapter = {
-  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-    const initializedPm = initializer();
-    return { pm: initializedPm };
-  },
-  andWhen: async (store, whenCB) => {
-    whenCB(store);
-    return store;
-  },
-  butThen: async (store, thenCB) => {
-    thenCB(store);
-    return store;
-  },
-  afterEach: async (store) => store,
-  afterAll: async () => {
-  },
-  beforeAll: async (input, testResource) => ({}),
-  assertThis: (x) => x
-};
-var Pure_test_default = Pure_default(
-  null,
-  // No initial input
-  specification,
-  implementation,
-  testAdapter
-);
-export {
-  Pure_test_default as default
-};

package/testeranto/bundles/pure/core/src/lib/baseBuilder.test/baseBuilder.test.pure.mjs

@@ -1,235 +0,0 @@
-import { createRequire } from 'module';const require = createRequire(import.meta.url);
-import {
-  BaseBuilder,
-  Pure_default
-} from "../../../chunk-KHJ35R7C.mjs";
-
-// src/lib/baseBuilder.test/baseBuilder.test.specification.ts
-var specification = (Suite, Given, When, Then) => {
-  return [
-    Suite.Default("Testing BaseBuilder functionality", {
-      testInitialization: Given["the default BaseBuilder"](
-        ["BaseBuilder should initialize correctly"],
-        [],
-        [
-          Then["it is initialized"](),
-          Then["it tracks artifacts"]()
-          // Then["it creates jobs"](),
-          // Then["it generates TestSpecifications"](),
-        ]
-      ),
-      testSpecsGeneration: Given["the default BaseBuilder"](
-        ["BaseBuilder should generate specs from test specification"],
-        [],
-        [Then["it generates TestSpecifications"]()]
-      ),
-      testJobsCreation: Given["the default BaseBuilder"](
-        ["BaseBuilder should create test jobs"],
-        [],
-        [Then["it creates jobs"]()]
-      )
-    })
-  ];
-};
-
-// src/lib/baseBuilder.test/baseBuilder.test.mock.ts
-var MockBaseBuilder = class extends BaseBuilder {
-  constructor(input, suitesOverrides = {}, givenOverrides = {}, whenOverrides = {}, thenOverrides = {}, testResourceRequirement = { ports: 0 }, testSpecification = () => []) {
-    super(
-      input,
-      suitesOverrides,
-      givenOverrides,
-      whenOverrides,
-      thenOverrides,
-      testResourceRequirement,
-      testSpecification
-    );
-    this.summary = {};
-  }
-  /**
-   * Simplified version for testing that doesn't actually run tests
-   */
-  async testRun(puppetMaster) {
-    try {
-      this.summary = {
-        [puppetMaster.testResourceConfiguration.name]: {
-          typeErrors: 0,
-          staticErrors: 0,
-          runTimeError: "",
-          prompt: "",
-          failingFeatures: {}
-        }
-      };
-      return {
-        failed: false,
-        fails: 0,
-        artifacts: this.artifacts,
-        features: []
-      };
-    } catch (error) {
-      console.error("Test run failed:", error);
-      return {
-        failed: true,
-        fails: 1,
-        artifacts: this.artifacts,
-        features: [],
-        error: error.message
-      };
-    }
-  }
-};
-
-// src/lib/baseBuilder.test/baseBuilder.test.implementation.ts
-var implementation = {
-  suites: {
-    Default: "BaseBuilder test suite"
-  },
-  givens: {
-    "the default BaseBuilder": () => {
-      return new MockBaseBuilder(
-        {},
-        // input
-        {},
-        // suitesOverrides
-        {},
-        // givenOverrides
-        {},
-        // whenOverrides
-        {},
-        // thenOverrides
-        { ports: 0 },
-        // testResourceRequirement
-        () => []
-        // testSpecification
-      );
-    },
-    "a BaseBuilder with TestInput": (input) => {
-      return new MockBaseBuilder(
-        input,
-        {},
-        {},
-        {},
-        {},
-        { ports: [] },
-        () => []
-      );
-    },
-    "a BaseBuilder with Test Resource Requirements": (requirements) => {
-      return new MockBaseBuilder({}, {}, {}, {}, {}, requirements, () => []);
-    }
-  },
-  whens: {
-    addArtifact: (artifact) => (builder) => {
-      builder.artifacts.push(artifact);
-      return builder;
-    },
-    setTestJobs: (jobs) => (builder) => {
-      builder.testJobs = jobs;
-      return builder;
-    }
-  },
-  thens: {
-    "it is initialized": () => (builder, utils) => {
-      utils.writeFileSync("hello.txt", "world");
-      if (!(builder instanceof BaseBuilder)) {
-        console.error("Builder instance:", builder);
-        throw new Error(
-          `Builder was not properly initialized - expected BaseBuilder instance but got ${builder?.constructor?.name}`
-        );
-      }
-      [
-        "artifacts",
-        "testJobs",
-        "specs",
-        "suitesOverrides",
-        "givenOverides",
-        "whenOverides",
-        "thenOverides"
-      ].forEach((prop) => {
-        if (!(prop in builder)) {
-          throw new Error(`Builder missing required property: ${prop}`);
-        }
-      });
-      return builder;
-    },
-    "it generates TestSpecifications": () => (builder) => {
-      if (!Array.isArray(builder.specs)) {
-        throw new Error("Specs were not generated");
-      }
-      return builder;
-    },
-    "it creates jobs": () => (builder) => {
-      if (!Array.isArray(builder.testJobs)) {
-        throw new Error("Test jobs were not created");
-      }
-      return builder;
-    },
-    "it tracks artifacts": () => (builder, utils) => {
-      if (!Array.isArray(builder.artifacts)) {
-        throw new Error("Artifacts array not initialized");
-      }
-      utils.writeFileSync("artifact_test.txt", "test");
-      return builder;
-    },
-    resourceRequirementsSet: () => (builder) => {
-      if (!builder.testResourceRequirement) {
-        throw new Error("Resource requirements not set");
-      }
-      return builder;
-    },
-    suitesOverridesConfigured: () => (builder) => {
-      if (!builder.suitesOverrides) {
-        throw new Error("Suites overrides not configured");
-      }
-      return builder;
-    },
-    givensOverridesConfigured: () => (builder) => {
-      if (!builder.givenOverides) {
-        throw new Error("Givens overrides not configured");
-      }
-      return builder;
-    },
-    whensOverridesConfigured: () => (builder) => {
-      if (!builder.whenOverides) {
-        throw new Error("Whens overrides not configured");
-      }
-      return builder;
-    },
-    thensOverridesConfigured: () => (builder) => {
-      if (!builder.thenOverides) {
-        throw new Error("Thens overrides not configured");
-      }
-      return builder;
-    }
-  }
-};
-
-// src/lib/baseBuilder.test/baseBuilder.test.adapter.ts
-var testAdapter = {
-  beforeAll: async (input, testResource, pm) => input,
-  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-    const result = initializer();
-    return result;
-  },
-  andWhen: async (store, whenCB, testResource, utils) => {
-    return whenCB(store, utils);
-  },
-  butThen: async (store, thenCB, testResource, pm) => {
-    return thenCB(store, pm);
-  },
-  afterEach: (store) => store,
-  afterAll: () => {
-  },
-  assertThis: (x) => x
-};
-
-// src/lib/baseBuilder.test/baseBuilder.test.pure.ts
-var baseBuilder_test_pure_default = Pure_default(
-  MockBaseBuilder.prototype,
-  specification,
-  implementation,
-  testAdapter
-);
-export {
-  baseBuilder_test_pure_default as default
-};