testeranto 0.143.0 → 0.146.0

package/testeranto/bundles/{node → pure}/allTests/src/Pure.test.mjs

@@ -1,11 +1,119 @@
 import { createRequire } from 'module';const require = createRequire(import.meta.url);
-import {
-  MockPMBase
-} from "../chunk-VAAIAWXC.mjs";
 import {
   Pure_default
-} from "../chunk-KYSOR62N.mjs";
-import "../chunk-UED26IMH.mjs";
+} from "../chunk-W22WOQNK.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;
+  }
+  // Minimal implementations of required methods
+  launchSideCar(n, testName, projectName) {
+    this.trackCall("launchSideCar", { n, testName, projectName });
+    return Promise.resolve();
+  }
+  end(uid) {
+    this.trackCall("end", { uid });
+    return Promise.resolve(true);
+  }
+  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 = {

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

@@ -0,0 +1,323 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  BaseCheck,
+  BaseGiven,
+  BaseSuite,
+  BaseThen,
+  BaseWhen,
+  Pure_default
+} from "../../../chunk-W22WOQNK.mjs";
+
+// src/lib/BaseSuite.test/test.ts
+var MockGiven = class extends BaseGiven {
+  constructor(name, features, whens, thens) {
+    super(
+      name,
+      features,
+      whens,
+      thens,
+      async () => ({ testStore: true }),
+      // givenCB
+      {}
+      // initialValues
+    );
+  }
+  async givenThat(subject, testResourceConfiguration, artifactory, givenCB, initialValues, pm) {
+    return { testStore: true };
+  }
+  uberCatcher(e) {
+    console.error("Given error 2:", e);
+  }
+};
+var MockWhen = class extends BaseWhen {
+  async andWhen(store, whenCB, testResource, pm) {
+    return { ...store, testStore: true };
+  }
+};
+var MockThen = class extends BaseThen {
+  async butThen(store, thenCB, testResourceConfiguration, pm) {
+    return { testSelection: true };
+  }
+};
+var MockCheck = class extends BaseCheck {
+  async checkThat(subject, testResourceConfiguration, artifactory, initializer, initialValues, pm) {
+    return { testStore: true };
+  }
+};
+var TestableSuite = class extends BaseSuite {
+  constructor(name, index) {
+    super(
+      name,
+      index,
+      {
+        testGiven: new MockGiven(
+          "testGiven",
+          ["testFeature"],
+          [
+            new MockWhen(
+              "testWhen",
+              () => Promise.resolve({ testStore: true })
+            )
+          ],
+          [
+            new MockThen(
+              "testThen",
+              async () => Promise.resolve({ testSelection: true })
+            )
+          ]
+        )
+      },
+      [
+        new MockCheck(
+          "testCheck",
+          ["testFeature"],
+          () => Promise.resolve({ testStore: true }),
+          null,
+          () => {
+          }
+        )
+      ]
+    );
+  }
+};
+var specification = (Suite, Given, When, Then, Check) => [
+  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),
+          Then.FeaturesIncludes("testFeature")
+        ]
+      ),
+      // Test execution flow
+      execution: Given.Default(
+        ["BaseSuite should execute all phases successfully"],
+        [When.RunSuite()],
+        [Then.StoreValid(), Then.NoErrorsOccurred(), Then.AllChecksCompleted()]
+      ),
+      // 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(),
+        ]
+      )
+    },
+    [
+      // Additional validation checks
+      // Check.Default(
+      //   ["Verify suite state after all tests"],
+      //   [],
+      //   [
+      //     Then.AllTestsCompleted(),
+      //     Then.CleanExit()
+      //   ]
+      // )
+    ]
+  ),
+  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: () => new TestableSuite("testSuite", 0)
+  },
+  whens: {
+    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) => (suite) => {
+      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;
+    },
+    AllChecksCompleted: () => (suite) => {
+      if (suite.checks.some((check) => !check.key)) {
+        throw new Error("Expected all checks to be completed");
+      }
+      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;
+    }
+  },
+  checks: {
+    Default: () => new TestableSuite("testCheck", 1)
+  }
+};
+var testInterface = {
+  beforeEach: async (subject, initializer) => initializer(),
+  andWhen: async (store, whenCB, testResource, pm) => whenCB(store, pm),
+  butThen: async (store, thenCB, testResource, pm) => thenCB(store, pm),
+  afterEach: (store) => store,
+  afterAll: (store, pm) => {
+  },
+  assertThis: (result) => !!result,
+  beforeAll: async (input, testResource, pm) => input
+};
+
+// src/lib/BaseSuite.test/pure.test.ts
+var pure_test_default = Pure_default(
+  BaseSuite,
+  specification,
+  implementation,
+  testInterface
+);
+export {
+  pure_test_default as default
+};

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

@@ -0,0 +1,224 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  BaseBuilder,
+  Pure_default
+} from "../../../chunk-W22WOQNK.mjs";
+
+// src/lib/baseBuilder.test/baseBuilder.test.specification.ts
+var specification = (Suite, Given, When, Then, Check) => {
+  return [
+    Suite.Default(
+      "Testing BaseBuilder functionality",
+      {
+        testInitialization: Given.Default(
+          ["BaseBuilder should initialize correctly"],
+          [],
+          [Then.initializedProperly()]
+        ),
+        testSpecsGeneration: Given.Default(
+          ["BaseBuilder should generate specs from test specification"],
+          [],
+          [Then.specsGenerated()]
+        ),
+        testJobsCreation: Given.Default(
+          ["BaseBuilder should create test jobs"],
+          [],
+          [Then.jobsCreated()]
+        )
+      },
+      []
+    )
+  ];
+};
+
+// src/lib/baseBuilder.test/baseBuilder.test.implementation.ts
+import { PassThrough } from "stream";
+
+// src/lib/baseBuilder.test/TestBaseBuilder.ts
+var TestBaseBuilder = class extends BaseBuilder {
+  constructor(input, suitesOverrides = {}, givenOverrides = {}, whenOverrides = {}, thenOverrides = {}, checkOverrides = {}, testResourceRequirement = { ports: [] }, testSpecification = () => []) {
+    super(
+      input,
+      suitesOverrides,
+      givenOverrides,
+      whenOverrides,
+      thenOverrides,
+      checkOverrides,
+      testResourceRequirement,
+      testSpecification
+    );
+    this.summary = {};
+    this.summary = {};
+  }
+  /**
+   * Simplified version for testing that doesn't actually run tests
+   */
+  testRun(puppetMaster) {
+    this.summary = {
+      [puppetMaster.testResourceConfiguration.name]: {
+        typeErrors: 0,
+        staticErrors: 0,
+        runTimeError: "",
+        prompt: "",
+        failingFeatures: {}
+      }
+    };
+    return Promise.resolve({
+      failed: false,
+      fails: 0,
+      artifacts: [],
+      logPromise: Promise.resolve(),
+      features: []
+    });
+  }
+};
+
+// src/lib/baseBuilder.test/baseBuilder.test.implementation.ts
+var implementation = {
+  suites: {
+    Default: "BaseBuilder test suite"
+  },
+  givens: {
+    Default: () => {
+      return new TestBaseBuilder(
+        {},
+        {},
+        {},
+        {},
+        {},
+        {},
+        { ports: [] },
+        () => []
+      );
+    },
+    WithCustomInput: (input) => {
+      return new TestBaseBuilder(
+        input,
+        {},
+        {},
+        {},
+        {},
+        {},
+        { ports: [] },
+        () => []
+      );
+    },
+    WithResourceRequirements: (requirements) => {
+      return new TestBaseBuilder(
+        {},
+        {},
+        {},
+        {},
+        {},
+        {},
+        requirements,
+        () => []
+      );
+    }
+  },
+  whens: {
+    addArtifact: (artifact) => (builder) => {
+      builder.artifacts.push(artifact);
+      return builder;
+    },
+    setTestJobs: (jobs) => (builder) => {
+      builder.testJobs = jobs;
+      return builder;
+    }
+  },
+  thens: {
+    initializedProperly: () => (builder) => {
+      if (!(builder instanceof BaseBuilder)) {
+        throw new Error("Builder was not properly initialized");
+      }
+      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;
+    },
+    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;
+    },
+    checksOverridesConfigured: () => (builder) => {
+      if (!builder.checkOverides) {
+        throw new Error("Checks overrides not configured");
+      }
+      return builder;
+    }
+  },
+  checks: {
+    Default: () => new PassThrough()
+    // Not used in these tests
+  }
+};
+
+// src/lib/baseBuilder.test/baseBuilder.test.interface.ts
+var testInterface = {
+  beforeEach: async (subject, initializer) => {
+    return initializer();
+  },
+  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) => {
+  }
+};
+
+// src/lib/baseBuilder.test/baseBuilder.test.pure.ts
+var baseBuilder_test_pure_default = Pure_default(
+  BaseBuilder.prototype,
+  specification,
+  implementation,
+  testInterface
+);
+export {
+  baseBuilder_test_pure_default as default
+};