testeranto 0.140.2 → 0.143.0

package/testeranto/bundles/node/allTests/src/PM/__tests__/nodeSidecar.testeranto.mjs

@@ -4,7 +4,8 @@ import {
 } from "../../../chunk-PG6KUKNP.mjs";
 import {
   Node_default
-} from "../../../chunk-4PJCC2XT.mjs";
+} from "../../../chunk-W44DUDBK.mjs";
+import "../../../chunk-UED26IMH.mjs";
 
 // src/PM/nodeSidecar.ts
 import net from "net";

package/testeranto/bundles/node/allTests/src/PM/__tests__/pureSidecar.testeranto.mjs

@@ -4,7 +4,8 @@ import {
 } from "../../../chunk-PG6KUKNP.mjs";
 import {
   Node_default
-} from "../../../chunk-4PJCC2XT.mjs";
+} from "../../../chunk-W44DUDBK.mjs";
+import "../../../chunk-UED26IMH.mjs";
 
 // src/PM/pureSidecar.ts
 import net from "net";

package/testeranto/bundles/node/allTests/src/PM/__tests__/webSidecar.testeranto.mjs

@@ -4,7 +4,8 @@ import {
 } from "../../../chunk-PG6KUKNP.mjs";
 import {
   Node_default
-} from "../../../chunk-4PJCC2XT.mjs";
+} from "../../../chunk-W44DUDBK.mjs";
+import "../../../chunk-UED26IMH.mjs";
 
 // src/PM/webSidecar.ts
 import net from "net";

package/testeranto/bundles/node/allTests/src/Pure.test.mjs

@@ -0,0 +1,261 @@
+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";
+
+// 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");
+              }
+            }
+          };
+        default:
+          return store;
+      }
+    }
+  },
+  thens: {
+    verifyProxy: (expectedPath) => (store) => {
+      const testPath = "expected";
+      const result = store.pm.writeFileSync(testPath, "content");
+      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) => {
+      try {
+        store.pm.writeFileSync("test", "content");
+        throw new Error("Expected error but none was thrown");
+      } catch (error) {
+        if (!error.message.includes(expectedError)) {
+          throw new Error(`Expected error "${expectedError}", got "${error.message}"`);
+        }
+      }
+      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;
+    }
+  },
+  checks: {
+    Default: () => ({})
+  }
+};
+var specification = (Suite, Given, When, Then, Check) => [
+  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 testInterface = {
+  beforeEach: async (subject, initializer) => {
+    return { pm: initializer() };
+  },
+  andWhen: async (store, whenCB) => whenCB(store),
+  butThen: async (store, thenCB) => thenCB(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,
+  testInterface
+);
+export {
+  Pure_test_default as default
+};

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

@@ -1,12 +1,14 @@
 import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  Node_default
+} from "../../chunk-W44DUDBK.mjs";
 import {
   BaseCheck,
   BaseGiven,
   BaseSuite,
   BaseThen,
-  BaseWhen,
-  Node_default
-} from "../../chunk-4PJCC2XT.mjs";
+  BaseWhen
+} from "../../chunk-UED26IMH.mjs";
 
 // src/lib/BaseSuite.test.ts
 var MockGiven = class extends BaseGiven {
@@ -131,7 +133,23 @@ var specification = (Suite, Given, When, Then, Check) => [
       //   ]
       // )
     ]
-  )
+  ),
+  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: {

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

@@ -0,0 +1,226 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  Node_default
+} from "../../../chunk-W44DUDBK.mjs";
+import {
+  BaseBuilder as BaseBuilder2
+} from "../../../chunk-UED26IMH.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 BaseBuilder2 {
+  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.ts
+var baseBuilder_test_default = Node_default(
+  BaseBuilder.prototype,
+  specification,
+  implementation,
+  testInterface
+);
+export {
+  baseBuilder_test_default as default
+};