testeranto 0.135.0 → 0.140.1

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

@@ -0,0 +1,187 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  PM_sidecar
+} from "../../../chunk-PG6KUKNP.mjs";
+import {
+  Node_default
+} from "../../../chunk-4PJCC2XT.mjs";
+
+// src/PM/nodeSidecar.ts
+import net from "net";
+var PM_Node_Sidecar = class extends PM_sidecar {
+  constructor(t) {
+    super();
+    this.testResourceConfiguration = t;
+    this.client = {};
+  }
+  start(stopper) {
+    return new Promise((res) => {
+      process.on("message", async (message) => {
+        if (message === "stop") {
+          console.log("STOP!", stopper.toString());
+          await stopper();
+          process.exit();
+        } else if (message.path) {
+          this.client = net.createConnection(message.path, () => {
+            res();
+          });
+        }
+      });
+    });
+  }
+  stop() {
+    return new Promise((resolve) => {
+      if (this.client) {
+        this.client.end(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+  }
+  testArtiFactoryfileWriter(tLog, callback) {
+    return (fPath, value) => {
+      callback(Promise.resolve());
+    };
+  }
+  send(command, ...argz) {
+    return new Promise((res) => {
+      const key = Math.random().toString();
+      const myListener = (event) => {
+        const x = JSON.parse(event);
+        if (x.key === key) {
+          process.removeListener("message", myListener);
+          res(x.payload);
+        }
+      };
+      process.addListener("message", myListener);
+      this.client.write(JSON.stringify([command, ...argz, key]));
+    });
+  }
+};
+
+// src/PM/__tests__/nodeSidecar.testeranto.ts
+var specification = (Suite, Given, When, Then) => {
+  return [
+    Suite.SidecarInitialized(
+      "Sidecar message passing works correctly",
+      {
+        basicSend: Given.SidecarReady(
+          ["can send and receive messages"],
+          [When.SendTestMessage("test-message")],
+          [Then.MessageReceived("test-message")]
+        ),
+        cleanup: Given.SidecarReady(
+          ["cleans up listeners after message"],
+          [When.VerifyCleanup()],
+          [Then.ListenersCleaned()]
+        )
+      },
+      []
+    )
+  ];
+};
+var implementation = {
+  suites: { SidecarInitialized: (x) => x },
+  givens: {
+    SidecarReady: () => {
+      const config = {
+        name: "test-sidecar",
+        fs: "/tmp",
+        ports: [3001],
+        browserWSEndpoint: ""
+      };
+      return new PM_Node_Sidecar(config);
+    }
+  },
+  whens: {
+    SendTestMessage: (message) => async (sidecar) => {
+      let callbackFn;
+      const mockProcess = {
+        on: (event, callback) => {
+          if (event === "message") {
+            callbackFn = callback;
+            callback(
+              JSON.stringify({
+                key: "mock-key",
+                payload: message
+              })
+            );
+          }
+          return mockProcess;
+        },
+        addListener: () => mockProcess,
+        removeListener: () => mockProcess
+      };
+      process = mockProcess;
+      let writeCalled = false;
+      sidecar.client.write = (data) => {
+        writeCalled = true;
+        return true;
+      };
+      await sidecar.send("test-command", message);
+      return { writeCalled, callbackFn };
+    },
+    VerifyCleanup: () => async (sidecar) => {
+      let addListenerCalled = false;
+      let removeListenerCalled = false;
+      const mockProcess = {
+        addListener: () => {
+          addListenerCalled = true;
+          return mockProcess;
+        },
+        removeListener: () => {
+          removeListenerCalled = true;
+          return mockProcess;
+        }
+      };
+      process = mockProcess;
+      await sidecar.send("test-command", "test");
+      return { addListenerCalled, removeListenerCalled };
+    }
+  },
+  thens: {
+    MessageReceived: (expected) => (actual) => {
+      if (actual !== expected) {
+        throw new Error(`Expected "${expected}" but got "${actual}"`);
+      }
+      return actual;
+    },
+    ListenersCleaned: () => (result, { removeListenerCalled }) => {
+      if (!removeListenerCalled) {
+        throw new Error("Expected removeListener to be called");
+      }
+      return result;
+    }
+  },
+  checks: { SidecarState: () => "unknown" }
+};
+var testInterface = {
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    const sidecar = initializer();
+    sidecar.client = {
+      write: () => true,
+      end: () => {
+      },
+      on: () => {
+      }
+    };
+    return sidecar;
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    try {
+      await whenCB(store, testResource, pm);
+    } catch (e) {
+      console.error("Error in andWhen:", e);
+      throw e;
+    }
+  }
+};
+var nodeSidecar_testeranto_default = Node_default(
+  () => new PM_Node_Sidecar({}),
+  specification,
+  implementation,
+  testInterface
+);
+export {
+  nodeSidecar_testeranto_default as default
+};

package/testeranto/bundles/node/{mothership → allTests}/src/PM/__tests__/pureSidecar.testeranto.mjs

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

package/testeranto/bundles/node/{mothership → allTests}/src/PM/__tests__/webSidecar.testeranto.mjs

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

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

@@ -0,0 +1,305 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  BaseCheck,
+  BaseGiven,
+  BaseSuite,
+  BaseThen,
+  BaseWhen,
+  Node_default
+} from "../../chunk-4PJCC2XT.mjs";
+
+// src/lib/BaseSuite.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:", 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()
+      //   ]
+      // )
+    ]
+  )
+];
+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
+};
+var BaseSuite_test_default = Node_default(
+  BaseSuite.prototype,
+  specification,
+  implementation,
+  testInterface
+);
+export {
+  BaseSuite_test_default as default
+};

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

@@ -4,7 +4,7 @@ import {
   __commonJS,
   __require,
   __toESM
-} from "../../chunk-V2EQEXU2.mjs";
+} from "../../chunk-4PJCC2XT.mjs";
 
 // node_modules/depd/index.js
 var require_depd = __commonJS({

package/testeranto/dev.html

@@ -0,0 +1,29 @@
+
+    <!DOCTYPE html>
+    <html lang="en">
+  
+    <head>
+      <meta name="description" content="Webpage description goes here" />
+      <meta charset="utf-8" />
+      <title>testeranto - testeranto</title>
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <meta name="author" content="" />
+      <base href="/" target="_blank">
+  
+      <script type="application/json" id="bigConfig">
+        ["allTests","react"]
+      </script>
+  
+      <link rel="stylesheet" href="./testeranto/Project.css" />
+      <script type="module" src="./testeranto/Project.js"></script>
+  
+    </head>
+  
+    <body>
+      <div id="root">
+        react is loading
+      </div>
+    </body>
+  
+    </html>
+        

package/testeranto/index.html

@@ -1,28 +1,29 @@
 
-  <!DOCTYPE html>
-  <html lang="en">
-
-  <head>
-    <meta name="description" content="Webpage description goes here" />
-    <meta charset="utf-8" />
-    <title>testeranto - testeranto</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta name="author" content="" />
-
-    <script type="application/json" id="bigConfig">
-      ["mothership","react"]
-    </script>
-
-    <link rel="stylesheet" href="Project.css" />
-    <script type="module" src="Project.js"></script>
-
-  </head>
-
-  <body>
-    <div id="root">
-      react is loading
-    </div>
-  </body>
-
-  </html>
-      
+    <!DOCTYPE html>
+    <html lang="en">
+  
+    <head>
+      <meta name="description" content="Webpage description goes here" />
+      <meta charset="utf-8" />
+      <title>testeranto - testeranto</title>
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <meta name="author" content="" />
+      <base href="undefined" target="_blank">
+  
+      <script type="application/json" id="bigConfig">
+        ["allTests","react"]
+      </script>
+  
+      <link rel="stylesheet" href="./testeranto/Project.css" />
+      <script type="module" src="./testeranto/Project.js"></script>
+  
+    </head>
+  
+    <body>
+      <div id="root">
+        react is loading
+      </div>
+    </body>
+  
+    </html>
+        

package/testeranto/reports/allTests/config.json

@@ -0,0 +1,57 @@
+{
+  "tests": [
+    [
+      "./src/lib/BaseSuite.test.ts",
+      "node",
+      {
+        "ports": 1
+      },
+      []
+    ],
+    [
+      "./src/mothership/test.ts",
+      "node",
+      {
+        "ports": 1
+      },
+      []
+    ],
+    [
+      "./src/PM/__tests__/nodeSidecar.testeranto.ts",
+      "node",
+      {
+        "ports": 1
+      },
+      []
+    ],
+    [
+      "./src/PM/__tests__/pureSidecar.testeranto.ts",
+      "node",
+      {
+        "ports": 1
+      },
+      []
+    ],
+    [
+      "./src/PM/__tests__/webSidecar.testeranto.ts",
+      "node",
+      {
+        "ports": 1
+      },
+      []
+    ]
+  ],
+  "clearScreen": false,
+  "debugger": false,
+  "externals": [],
+  "externalTests": {},
+  "importPlugins": [],
+  "minify": false,
+  "nodePlugins": [],
+  "ports": [
+    "3333"
+  ],
+  "src": "",
+  "webPlugins": [],
+  "buildDir": "/Users/adam/Code/testeranto/testeranto/bundles/allTests"
+}

package/testeranto/reports/{mothership/index.html → allTests/dev.html}

@@ -8,6 +8,8 @@
       <title>testeranto - testeranto</title>
       <meta name="viewport" content="width=device-width, initial-scale=1" />
       <meta name="author" content="" />
+      
+      <base href="/" target="_blank">
   
       <link rel="stylesheet" href="../ReportClient.css" />
       <script type="module" src="../ReportClient.js"></script>

package/testeranto/reports/allTests/index.html

@@ -0,0 +1,26 @@
+
+    <!DOCTYPE html>
+    <html lang="en">
+  
+    <head>
+      <meta name="description" content="Webpage description goes here" />
+      <meta charset="utf-8" />
+      <title>testeranto - testeranto</title>
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <meta name="author" content="" />
+      
+      <base href="undefined" target="_blank">
+  
+      <link rel="stylesheet" href="../ReportClient.css" />
+      <script type="module" src="../ReportClient.js"></script>
+  
+    </head>
+  
+    <body>
+      <div id="root">
+        react is loading
+      </div>
+    </body>
+  
+    </html>
+