testeranto 0.203.0 → 0.205.0

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

@@ -1,572 +0,0 @@
-import { createRequire } from 'module';const require = createRequire(import.meta.url);
-import {
-  Node_default,
-  Tiposkripto
-} from "../../../chunk-MJTSYIAQ.mjs";
-
-// src/lib/TipoSkripto.test/MockTiposkripto.ts
-var MockTiposkripto = class extends Tiposkripto {
-  constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testAdapter2, uberCatcher = (cb) => cb()) {
-    super(
-      input,
-      testSpecification,
-      testImplementation,
-      testResourceRequirement,
-      testAdapter2,
-      uberCatcher
-    );
-    this.specs = [];
-    this.testJobs = [];
-    this.artifacts = [];
-    this.features = [];
-    this.testImplementation = testImplementation;
-    console.log("MockTiposkripto constructor called with input:", JSON.stringify(input));
-    const requiredMethods = ["suites", "givens", "whens", "thens"];
-    requiredMethods.forEach((method) => {
-      if (!testImplementation[method]) {
-        throw new Error(`Missing required implementation method: ${method}`);
-      }
-    });
-    this.testAdapter = testAdapter2;
-    this.suitesOverrides = testImplementation.suites;
-    this.givenOverides = testImplementation.givens;
-    this.whenOverides = testImplementation.whens;
-    this.thenOverides = testImplementation.thens;
-    let totalTests = Object.keys(testImplementation.givens).length;
-    if (input && typeof input === "object") {
-      const inputObj = input;
-      if ("testCount" in inputObj) {
-        totalTests = Number(inputObj.testCount);
-      }
-    }
-    try {
-      this.features = this.extractFeaturesFromSpecification(testSpecification);
-    } catch (error) {
-      console.error("Failed to extract features, using fallback:", error);
-      this.features = [
-        "Tiposkripto should initialize with default values",
-        "Custom input test",
-        "Resource requirements test",
-        "Should generate specs from test specification",
-        "Should create test jobs from specs",
-        "Should track artifacts",
-        "Should properly configure all overrides",
-        "Interface configuration test",
-        "Custom implementation test",
-        "Custom specification test",
-        "Should allow modifying specs",
-        "Should allow modifying jobs",
-        "Should properly handle errors",
-        "Should complete a full test run successfully",
-        "Should correctly count the number of tests",
-        "Should set runTimeTests to -1 on hard errors",
-        "Given a config that has 1 suite containing 5 GivenWhenThens",
-        "Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens"
-      ];
-    }
-  }
-  extractFeaturesFromSpecification(specification2) {
-    try {
-      const mockSuite = (name, tests, features2) => ({
-        name,
-        tests,
-        features: features2
-      });
-      const mockGiven = (features2, whens, thens) => {
-        return {
-          features: Array.isArray(features2) ? features2.filter((f) => typeof f === "string") : [],
-          whens,
-          thens
-        };
-      };
-      const mockWhen = {};
-      const mockThen = {};
-      if (this.testImplementation.whens) {
-        Object.keys(this.testImplementation.whens).forEach((key) => {
-          mockWhen[key] = (...args) => ({ name: key, args });
-        });
-      }
-      if (this.testImplementation.thens) {
-        Object.keys(this.testImplementation.thens).forEach((key) => {
-          mockThen[key] = (...args) => ({ name: key, args });
-        });
-      }
-      const suites = specification2(
-        mockSuite,
-        mockGiven,
-        mockWhen,
-        mockThen
-      );
-      const features = [];
-      for (const suite of suites) {
-        if (suite && suite.tests && typeof suite.tests === "object") {
-          for (const testKey of Object.keys(suite.tests)) {
-            const test = suite.tests[testKey];
-            if (test && test.features && Array.isArray(test.features)) {
-              for (const feature of test.features) {
-                if (typeof feature === "string") {
-                  features.push(feature);
-                }
-              }
-            }
-          }
-        }
-      }
-      const uniqueFeatures = [...new Set(features)];
-      console.log("Extracted features:", JSON.stringify(uniqueFeatures));
-      return uniqueFeatures;
-    } catch (error) {
-      console.error("Error extracting features from specification:", error);
-      return [];
-    }
-  }
-  async receiveTestResourceConfig(partialTestResource) {
-    try {
-      if (!this.testAdapter) {
-        throw new Error("Test adapter not configured");
-      }
-      const stringFeatures = this.features.filter((f) => typeof f === "string");
-      let totalTests = Object.keys(this.givenOverides).length;
-      const input = this.input;
-      if (input && typeof input === "object") {
-        if ("testCount" in input) {
-          totalTests = input.testCount;
-        }
-      }
-      return {
-        failed: false,
-        fails: 0,
-        artifacts: [],
-        features: stringFeatures,
-        tests: 0,
-        runTimeTests: totalTests
-      };
-    } catch (error) {
-      return {
-        failed: true,
-        fails: 1,
-        artifacts: [],
-        features: [],
-        // Ensure this is always an array of strings
-        tests: 0,
-        runTimeTests: -1
-      };
-    }
-  }
-};
-
-// src/lib/TipoSkripto.test/Tiposkripto.adapter.ts
-var testAdapter = {
-  beforeAll: async (input, testResource, pm) => input,
-  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-    const result = await initializer();
-    if (!result) {
-      throw new Error("Initializer returned undefined");
-    }
-    if (!(result instanceof MockTiposkripto)) {
-      throw new Error(
-        `Initializer returned ${result?.constructor?.name}, expected MockTiposkripto`
-      );
-    }
-    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/TipoSkripto.test/Tiposkripto.implementation.ts
-var implementation = {
-  suites: {
-    Default: "Tiposkripto test suite",
-    ExtendedSuite: "Extended Tiposkripto test suite"
-  },
-  givens: {
-    Default: () => {
-      console.log("Creating default test builder instance");
-      const builder = new MockTiposkripto(
-        {},
-        // input
-        specification,
-        // Use the current specification
-        implementation,
-        // Use the current implementation
-        { ports: [] },
-        // Default resource requirements
-        testAdapter,
-        // Default adapter
-        (cb) => cb()
-        // Default uberCatcher
-      );
-      console.log("Builder created:", builder);
-      if (!builder.testAdapter) {
-        builder.testAdapter = testAdapter;
-      }
-      return builder;
-    },
-    WithCustomInput: (input = {}) => {
-      return new MockTiposkripto(
-        input,
-        specification,
-        implementation,
-        { ports: [] },
-        testAdapter,
-        (cb) => cb()
-      );
-    },
-    WithResourceRequirements: (requirements = { ports: 0 }) => {
-      return new MockTiposkripto(
-        {},
-        specification,
-        implementation,
-        requirements,
-        testAdapter,
-        (cb) => cb()
-      );
-    },
-    WithCustomImplementation: (impl = implementation) => {
-      return new MockTiposkripto(
-        {},
-        specification,
-        impl,
-        { ports: [] },
-        testAdapter,
-        (cb) => cb()
-      );
-    },
-    WithCustomSpecification: (spec = specification) => {
-      return new MockTiposkripto(
-        {},
-        spec,
-        implementation,
-        { ports: [] },
-        testAdapter,
-        (cb) => cb()
-      );
-    },
-    WithCustomAdapter: (customAdapter = {}) => {
-      return new MockTiposkripto(
-        {},
-        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) => {
-      builder.specs = modifier(builder.specs || []);
-      return builder;
-    },
-    modifyJobs: (modifier) => (builder) => {
-      builder.testJobs = modifier(builder.testJobs || []);
-      return builder;
-    },
-    triggerError: (message) => (builder) => {
-      throw new Error(message);
-    },
-    // Add a when to simulate receiving test resource config
-    receiveTestResourceConfig: (config) => async (builder) => {
-      return await builder.receiveTestResourceConfig(config);
-    }
-  },
-  thens: {
-    initializedProperly: () => (builder, utils) => {
-      if (!builder) {
-        throw new Error("Builder is undefined");
-      }
-      if (!(builder instanceof MockTiposkripto)) {
-        throw new Error(
-          `Builder was not properly initialized. Expected MockTiposkripto instance but got ${builder?.constructor?.name}`
-        );
-      }
-      const requiredProps = [
-        "specs",
-        "testJobs",
-        "artifacts",
-        "suitesOverrides",
-        "givenOverides",
-        "whenOverides",
-        "thenOverides"
-      ];
-      for (const prop of requiredProps) {
-        if (!(prop in builder)) {
-          throw new Error(`Missing required property: ${prop}`);
-        }
-      }
-      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;
-    },
-    interfaceConfigured: () => (builder) => {
-      if (!builder.testAdapter) {
-        throw new Error("Test adapter not configured");
-      }
-      const requiredMethods = [
-        "beforeAll",
-        "beforeEach",
-        "andWhen",
-        "butThen",
-        "afterEach",
-        "afterAll",
-        "assertThis"
-      ];
-      for (const method of requiredMethods) {
-        if (typeof builder.testAdapter[method] !== "function") {
-          throw new Error(`Test adapter missing required method: ${method}`);
-        }
-      }
-      return builder;
-    },
-    specsModified: (expectedCount) => (builder) => {
-      if (builder.specs.length <= expectedCount) {
-        throw new Error(`Expected at least ${expectedCount} modified specs`);
-      }
-      return builder;
-    },
-    jobsModified: (expectedCount) => (builder) => {
-      if (builder.testJobs.length <= expectedCount) {
-        throw new Error(`Expected at least ${expectedCount} modified jobs`);
-      }
-      return builder;
-    },
-    errorThrown: (expectedMessage) => (builder) => {
-      return builder;
-    },
-    testRunSuccessful: () => async (builder) => {
-      await builder.receiveTestResourceConfig("");
-      return builder;
-    },
-    runTimeTestsCounted: () => async (builder) => {
-      const result = await builder.receiveTestResourceConfig("");
-      if (result.runTimeTests <= 0) {
-        throw new Error(`Expected runTimeTests > 0, got ${result.runTimeTests}`);
-      }
-      return builder;
-    },
-    runTimeTestsSetToNegativeOne: () => async (builder) => {
-      await builder.receiveTestResourceConfig("");
-      return builder;
-    },
-    runTimeTestsCountIs: (expectedCount) => async (builder) => {
-      const result = await builder.receiveTestResourceConfig("");
-      if (result.runTimeTests !== expectedCount) {
-        throw new Error(`Expected runTimeTests to be ${expectedCount}, got ${result.runTimeTests}`);
-      }
-      return builder;
-    },
-    runTimeTestsIsNegativeOne: () => async (builder) => {
-      await builder.receiveTestResourceConfig("");
-      return builder;
-    }
-  }
-};
-
-// src/lib/TipoSkripto.test/Tiposkripto.specification.ts
-var specification = (Suite, Given, When, Then) => {
-  return [
-    Suite.Default("Tiposkripto Core Functionality", {
-      // Basic initialization tests
-      initialization: Given.Default(
-        ["Tiposkripto should initialize with default values"],
-        [],
-        [Then.initializedProperly()]
-      ),
-      customInput: Given.WithCustomInput(
-        ["Custom input test"],
-        [],
-        [Then.initializedProperly()]
-      ),
-      resourceRequirements: Given.WithResourceRequirements(
-        ["Resource requirements test"],
-        [],
-        [Then.resourceRequirementsSet()]
-      ),
-      // Core functionality tests
-      specGeneration: Given.Default(
-        ["Should generate specs from test specification"],
-        [],
-        [Then.specsGenerated()]
-      ),
-      jobCreation: Given.Default(
-        ["Should create test jobs from specs"],
-        [],
-        [Then.jobsCreated()]
-      ),
-      artifactTracking: Given.Default(
-        ["Should track artifacts"],
-        [When.addArtifact(Promise.resolve("test"))],
-        [Then.artifactsTracked()]
-      ),
-      // Configuration tests
-      overridesConfiguration: Given.Default(
-        ["Should properly configure all overrides"],
-        [],
-        [
-          Then.suitesOverridesConfigured(),
-          Then.givensOverridesConfigured(),
-          Then.whensOverridesConfigured(),
-          Then.thensOverridesConfigured()
-        ]
-      ),
-      interfaceConfiguration: Given.WithCustomAdapter(
-        ["Interface configuration test"],
-        [],
-        [Then.interfaceConfigured()],
-        {
-          assertThis: (x) => !!x,
-          beforeEach: async (s, i) => i()
-        }
-      )
-    }),
-    Suite.ExtendedSuite("Tiposkripto Advanced Features", {
-      // Custom implementations
-      customImplementation: Given.WithCustomImplementation(
-        ["Custom implementation test"],
-        [],
-        [Then.specsGenerated(), Then.jobsCreated()],
-        implementation
-      ),
-      customSpecification: Given.WithCustomSpecification(
-        ["Custom specification test"],
-        [],
-        [Then.specsGenerated(), Then.jobsCreated()],
-        specification
-      ),
-      // Dynamic modification tests
-      specModification: Given.Default(
-        ["Should allow modifying specs"],
-        [When.modifySpecs((specs) => [...specs, "extra"])],
-        [Then.specsModified(1)]
-      ),
-      jobModification: Given.Default(
-        ["Should allow modifying jobs"],
-        [When.modifyJobs((jobs) => [...jobs, {}])],
-        [Then.jobsModified(1)]
-      ),
-      // Error handling
-      errorHandling: Given.Default(
-        ["Should properly handle errors"],
-        [When.triggerError("test error")],
-        [Then.errorThrown("test error")]
-      ),
-      // Full test run
-      fullTestRun: Given.Default(
-        ["Should complete a full test run successfully"],
-        [],
-        [Then.testRunSuccessful()]
-      ),
-      // runTimeTests behavior
-      runTimeTestsCount: Given.Default(
-        ["Should correctly count the number of tests"],
-        [],
-        [Then.runTimeTestsCounted()]
-      ),
-      runTimeTestsOnError: Given.Default(
-        ["Should set runTimeTests to -1 on hard errors"],
-        [When.triggerError("test error")],
-        [Then.runTimeTestsSetToNegativeOne()]
-      ),
-      // Specific test cases for runTimeTests behavior
-      runTimeTestsSingleSuiteFiveTests: Given.WithCustomInput(
-        ["Given a config that has 1 suite containing 5 GivenWhenThens"],
-        [],
-        [Then.runTimeTestsCountIs(5)],
-        { testCount: 5 }
-      ),
-      runTimeTestsSingleSuiteFiveTestsError: Given.WithCustomInput(
-        ["Given a config that has 1 suite containing 5 GivenWhenThens"],
-        [When.triggerError("hard error")],
-        [Then.runTimeTestsIsNegativeOne()],
-        { testCount: 5 }
-      ),
-      runTimeTestsTwoSuitesThreeTestsEach: Given.WithCustomInput(
-        ["Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens"],
-        [],
-        [Then.runTimeTestsCountIs(6)],
-        { testCount: 6 }
-      ),
-      runTimeTestsTwoSuitesThreeTestsEachError: Given.WithCustomInput(
-        ["Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens"],
-        [When.triggerError("hard error")],
-        [Then.runTimeTestsIsNegativeOne()],
-        { testCount: 6 }
-      )
-    })
-  ];
-};
-
-// src/lib/TipoSkripto.test/TipoSkripto.ts
-var TipoSkripto_default = Node_default(
-  MockTiposkripto.prototype,
-  specification,
-  implementation,
-  testAdapter,
-  { ports: 1 }
-);
-export {
-  TipoSkripto_default as default
-};