testeranto 0.177.0 → 0.189.0

package/testeranto/bundles/web/core/src/lib/BaseSuite.test/web.test.mjs

@@ -0,0 +1,394 @@
+import {
+  BaseGiven,
+  BaseSuite,
+  BaseThen,
+  BaseWhen,
+  Web_default,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "../../../chunk-LU364HVS.mjs";
+
+// src/lib/BaseSuite.test/web.test.ts
+init_dirname();
+init_buffer();
+init_process();
+
+// src/lib/BaseSuite.test/test.ts
+init_dirname();
+init_buffer();
+init_process();
+
+// src/lib/BaseSuite.test/mock.ts
+init_dirname();
+init_buffer();
+init_process();
+var MockGiven = class extends BaseGiven {
+  constructor(name, features, whens, thens) {
+    super(
+      name,
+      features,
+      whens,
+      thens,
+      async () => ({ testStore: true, testSelection: false }),
+      // givenCB
+      {}
+      // initialValues
+    );
+  }
+  async givenThat() {
+    return { testStore: true, testSelection: false };
+  }
+  uberCatcher(e) {
+    console.error("Given error 2:", e);
+  }
+};
+var MockWhen = class extends BaseWhen {
+  async andWhen(store, whenCB, testResource, pm) {
+    const newStore = {
+      ...store,
+      testSelection: true
+      // Ensure testSelection is set for assertions
+    };
+    const result = await whenCB(newStore);
+    return result;
+  }
+  addArtifact(name, content) {
+    return this;
+  }
+};
+var MockThen = class extends BaseThen {
+  async butThen(store, thenCB, testResourceConfiguration, pm) {
+    const testSelection = {
+      name: store.name,
+      index: store.index,
+      testSelection: store.testSelection || false,
+      error: store.error ? true : void 0
+    };
+    try {
+      const result = await thenCB(testSelection);
+      if (!result || typeof result.testSelection === "undefined") {
+        throw new Error(
+          `Invalid test selection result: ${JSON.stringify(result)}`
+        );
+      }
+      return result;
+    } catch (e) {
+      console.error("[ERROR] MockThen - butThen failed:", e);
+      throw e;
+    }
+  }
+};
+var MockSuite = class extends BaseSuite {
+  constructor(name, index) {
+    if (!name) {
+      throw new Error("MockSuite requires a non-empty name");
+    }
+    const suiteName = name || "testSuite";
+    super(suiteName, index, {
+      testGiven: new MockGiven(
+        "testGiven",
+        ["testFeature"],
+        [new MockWhen("testWhen", () => Promise.resolve({ testStore: true }))],
+        [
+          new MockThen(
+            "testThen",
+            async () => Promise.resolve({ testSelection: true })
+          )
+        ]
+      )
+    });
+  }
+};
+
+// 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);
+      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) => {
+      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) => (selection) => {
+      if (!selection.name) {
+        throw new Error(`Suite name is undefined. Expected: ${expectedName}`);
+      }
+      if (selection.name !== expectedName) {
+        throw new Error(
+          `Expected suite name '${expectedName}', got '${selection.name}'`
+        );
+      }
+      return selection;
+    },
+    SuiteIndexMatches: (expectedIndex) => (selection) => {
+      if (selection.index !== expectedIndex) {
+        throw new Error(
+          `Expected suite index ${expectedIndex}, got ${selection.index}`
+        );
+      }
+      return selection;
+    },
+    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) => {
+    try {
+      const suite = await initializer();
+      if (!suite) {
+        throw new Error("Initializer returned undefined suite");
+      }
+      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) => {
+    const testSelection = {
+      testSelection: store.testSelection || false,
+      error: store.error ? true : void 0,
+      name: store.name,
+      index: store.index
+    };
+    try {
+      const result = await thenCB(testSelection);
+      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/web.test.ts
+var web_test_default = Web_default(
+  BaseSuite,
+  specification,
+  implementation,
+  testAdapter
+);
+export {
+  web_test_default as default
+};

package/testeranto/bundles/web/core/src/lib/baseBuilder.test/baseBuilder.test.web.html

@@ -0,0 +1,15 @@
+
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <script type="module" src="./baseBuilder.test.web.mjs"></script>
+  <link rel="stylesheet" href="./baseBuilder.test.web.css">
+</head>
+
+<body>
+  <div id="root">
+  </div>
+</body>
+
+</html>

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

@@ -0,0 +1,256 @@
+import {
+  BaseBuilder,
+  Web_default,
+  init_buffer,
+  init_dirname,
+  init_process
+} from "../../../chunk-LU364HVS.mjs";
+
+// src/lib/baseBuilder.test/baseBuilder.test.web.ts
+init_dirname();
+init_buffer();
+init_process();
+
+// src/lib/baseBuilder.test/baseBuilder.test.specification.ts
+init_dirname();
+init_buffer();
+init_process();
+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.implementation.ts
+init_dirname();
+init_buffer();
+init_process();
+
+// src/lib/baseBuilder.test/baseBuilder.test.mock.ts
+init_dirname();
+init_buffer();
+init_process();
+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
+init_dirname();
+init_buffer();
+init_process();
+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.web.ts
+var baseBuilder_test_web_default = Web_default(
+  MockBaseBuilder.prototype,
+  specification,
+  implementation,
+  testAdapter
+);
+export {
+  baseBuilder_test_web_default as default
+};