WIP

Signed-off-by: Alexander Trauzzi <[email protected]>

Author: atrauzzi

test/e2e/jobs/jobs.test.ts

@@ -12,12 +12,11 @@ limitations under the License.
 */
 
 import { GenericContainer, Network, StartedNetwork, StartedTestContainer, TestContainers, Wait } from "testcontainers";
-// import { LogWaitStrategy } from "testcontainers/build/wait-strategies/log-wait-strategy";
+// import { LogWaitStrategy } from "testcontaineclienrs/build/wait-strategies/log-wait-strategy";
 import { CommunicationProtocolEnum, DaprClient, DaprServer } from "../../../src";
-import { scheduler } from "node:timers/promises";
 // import { AbstractWaitStrategy } from "testcontainers/build/wait-strategies/wait-strategy";
 
-jest.setTimeout(10000);
+jest.setTimeout(40 * 1000);
 
 describe("Jobs End to End", () => {
 
@@ -29,124 +28,113 @@ describe("Jobs End to End", () => {
 
     beforeAll(async () => {
 
-        await TestContainers.exposeHostPorts(8070);
-
-        network = await new Network().start();
-
-        daprScheduler = await new GenericContainer("ghcr.io/dapr/dapr")
-          .withName("dapr-js-sdk-test-scheduler")
-          .withNetwork(network)
-          .withNetworkAliases("scheduler")
-          .withExposedPorts(8083)
-          .withCommand([
-            "./scheduler",
-            // note: Don't think this is necessary, buuuuut????
-            "--listen-address", "0.0.0.0",
-            "--port", "8083",
-            "--log-level", "debug",
-            // note: This feels redundant, but here as yet another thing I've tried.
-            // "--mode", "standalone",
-          ])
-          .withTmpFs({
-            "/data": "rw",
-          })
-          // note: Because dapr containers don't have `sh` or `bash` inside, this is kind of the best health check.
-          .withWaitStrategy(Wait.forLogMessage("api is ready").withStartupTimeout(10000))
-          .start();
-
-        daprd = await new GenericContainer("ghcr.io/dapr/dapr")
+      await TestContainers.exposeHostPorts(8070);
+
+      network = await new Network().start();
+
+      daprScheduler = await (new GenericContainer("ghcr.io/dapr/dapr")
+        .withName("dapr-js-sdk-test-scheduler")
+        .withNetwork(network)
+        .withNetworkAliases("scheduler")
+        .withExposedPorts(8083)
+        .withCommand([
+          "./scheduler",
+          // note: Don't think this is necessary, buuuuut????
+          "--listen-address", "0.0.0.0",
+          "--port", "8083",
+          "--log-level", "debug",
+          // note: This feels redundant, but here as yet another thing I've tried.
+          // "--mode", "standalone",
+        ])
+        .withTmpFs({
+          "/data": "rw",
+        })
+        // note: Because dapr containers don't have `sh` or `bash` inside, this is kind of the best health check.
+        .withWaitStrategy(Wait.forLogMessage("api is ready").withStartupTimeout(10000))
+        .start());
+
+        daprd = await (new GenericContainer("ghcr.io/dapr/dapr")
           .withName("dapr-js-sdk-test-daemon")
           .withNetwork(network)
           .withNetworkAliases("daprd")
           .withExposedPorts(8081, 8082)
           .withCommand([
             "./daprd",
             "--app-id", "dapr-js-sdk-testing",
-            // todo: Need to figure out how to tell daprd where my app can be found as it's not on `localhost`
             "--app-channel-address", "host.testcontainers.internal",
             "--app-port", "8070",
             "--dapr-grpc-port", "8081",
             "--dapr-http-port", "8082",
-            "--scheduler-host-address", `scheduler:${getPort(daprScheduler, 8083)}`,
+            "--scheduler-host-address", `scheduler:8083`,
             "--placement-host-address", "",
             "--enable-metrics", "false",
+            "--log-level", "debug",
           ])
           // note: Because dapr containers don't have `sh` or `bash` inside, this is kind of the best health check.
           .withWaitStrategy(Wait.forLogMessage("HTTP server is running on port").withStartupTimeout(10000))
-          .start()
-        ;
-
-        console.info(`Scheduler: ${getIp(daprScheduler)}`);
-        console.info(`Daemon: ${getIp(daprd)}`);
+          .start());
 
-    });
-
-    beforeEach(async () => {
+      console.info(`Scheduler: ${getIp(daprScheduler)}`);
+      console.info(`Daemon: ${getIp(daprd)}`);
 
       server = new DaprServer({
-        serverHost: "127.0.0.1",
+        serverHost: "0.0.0.0",
         serverPort: "8070",
         communicationProtocol: CommunicationProtocolEnum.HTTP,
         clientOptions: {
-          daprHost: getIp(daprd),
+          daprHost: "localhost",
           daprPort: getPort(daprd, 8082),
           communicationProtocol: CommunicationProtocolEnum.HTTP,
         },
       });
 
       client = new DaprClient({
-        daprHost: getIp(daprd),
+        daprHost: "localhost",
         daprPort: getPort(daprd, 8082),
         communicationProtocol: CommunicationProtocolEnum.HTTP,
       });
-
-      await server.start();
-    })
-
-    afterEach(async () => {
-
-      await client?.jobs.delete("test");
-      await server?.stop();
-      // await daprScheduler?.restart();
-
-      server = null;
-      client = null;
-    })
+    });
 
     afterAll(async () => {
-        await daprScheduler?.stop();
-        await daprd?.stop();
+      await server?.stop();
+      await daprd?.stop();
+      await daprScheduler?.stop();
+      await network?.stop();
     });
 
     it("Registers and receives a one second job five times.", async () => {
 
-        const callback = jest.fn(async () => { return null; });
+      const callback = jest.fn(async () => { console.info("Callback called!"); });
 
-        server?.jobs.listen("test", callback);
+      server?.jobs.listen("test", callback);
 
-        await client?.jobs.schedule(
-          "test",
-          { value: "test" },
-          "* * * * * *"
-        );
+      await server?.start();
 
-        const job = await client?.jobs.get("test");
+      await client?.jobs.schedule(
+        "test",
+        { value: "test" },
+        "* * * * * *"
+      );
 
-        await new Promise(resolve => setTimeout(resolve, 6000));
+      const job = await server?.client.jobs.get("test");
 
-        expect(job).toMatchObject({
-          "data": {
-            "value": {
-              "value": "test",
-            },
+      await (new Promise(resolve => setTimeout(resolve, 6000)));
+
+      await client?.jobs.delete("test");
+
+      expect(job).toMatchObject({
+        "data": {
+          "value": {
+            "value": "test",
           },
-          "name": "test",
-          "schedule": "* * * * * *",
-        });
-        expect(callback).toHaveBeenCalledTimes(5);
-        expect(callback).toHaveBeenCalledWith({
-          value: "test",
-        });
+        },
+        "name": "test",
+        "schedule": "* * * * * *",
+      });
+      expect(callback).toHaveBeenCalledTimes(5);
+      expect(callback).toHaveBeenCalledWith({
+        value: "test",
+      });
     });
 
   function getIp(container: StartedTestContainer | null | undefined): string {