Add load test

Signed-off-by: Xavier Geerinck <[email protected]>

Author: XavierGeerinck

src/implementation/Client/HTTPClient/HTTPClient.ts

@@ -1,6 +1,8 @@
 import fetch from "node-fetch";
 import { CommunicationProtocolEnum } from "../../..";
 import IClient from "../../../interfaces/Client/IClient";
+import http from "node:http";
+import https from "node:https";
 
 export default class HTTPClient implements IClient {
   private readonly isInitialized: boolean;
@@ -9,6 +11,9 @@ export default class HTTPClient implements IClient {
   private readonly clientPort: string;
   private readonly clientUrl: string;
 
+  private readonly httpAgent;
+  private readonly httpsAgent;
+
   constructor(host = "127.0.0.1", port = "50050") {
     this.isInitialized = true;
     this.clientHost = host;
@@ -21,6 +26,9 @@ export default class HTTPClient implements IClient {
     }
 
     this.client = fetch;
+
+    this.httpAgent = new http.Agent({ keepAlive: true, keepAliveMsecs: 30 * 1000 });
+    this.httpsAgent = new https.Agent({ keepAlive: true, keepAliveMsecs: 30 * 1000 });
   }
 
   getClient(): typeof fetch {
@@ -64,7 +72,14 @@ export default class HTTPClient implements IClient {
       }
     }
 
+
     const urlFull = url.startsWith("http") ? url : `${this.clientUrl}${url}`;
+
+    // Decide which agent to use
+    // we use an agent so we can reuse an open connection, limiting handshake requirements
+    const agent = urlFull.startsWith("https") ? this.httpsAgent : this.httpAgent;
+    params.agent = agent;
+
     // console.log(`${params.method} - ${urlFull} (${params.body})`);
     const res = await fetch(urlFull, params);
 

test/e2e/actors.http.test.ts

@@ -40,6 +40,10 @@ describe('http/actors', () => {
     await server.startServer(); // Start the general server
   });
 
+  afterAll(async () => {
+    await server.stopServer();
+  });
+
   describe('actorProxy', () => {
     it('should be able to create an actor object through the proxy', async () => {
       const builder = new ActorProxyBuilder<DemoActorCounterImpl>(DemoActorCounterImpl, client);

test/e2e/main.grpc.test.ts

@@ -28,6 +28,10 @@ describe('grpc/main', () => {
     await server.startServer();
   });
 
+  afterAll(async () => {
+    await server.stopServer();
+  });
+
   describe('binding', () => {
     it('should be able to receive events', async () => {
       await client.binding.send('binding-mqtt', 'create', { hello: 'world' });

test/e2e/main.http.test.ts

@@ -28,6 +28,10 @@ describe('http/main', () => {
     await server.startServer();
   });
 
+  afterAll(async () => {
+    await server.stopServer();
+  });
+
   describe('binding', () => {
     it('should be able to receive events', async () => {
       await client.binding.send('binding-mqtt', 'create', { hello: 'world' });

test/load/pubsub.http.test.ts

@@ -1,36 +1,20 @@
-import { CommunicationProtocolEnum, DaprClient, DaprServer, HttpMethod } from '../../src';
+import { CommunicationProtocolEnum, DaprClient } from '../../src';
 
-const serverHost = '127.0.0.1';
-const serverPort = '50001';
 const daprHost = '127.0.0.1';
 const daprPort = '50000'; // Dapr Sidecar Port of this Example Server
-const daprAppId = 'test-suite';
 
 describe('load/http', () => {
-  let server: DaprServer;
   let client: DaprClient;
-  // const mockBindingReceive = jest.fn(async (data: object) => console.log('mockBindingReceive'));
-  // const mockPubSubSubscribe = jest.fn(async (data: object) => console.log('mockPubSubSubscribe'));
 
   // We need to start listening on some endpoints already
   // this because Dapr is not dynamic and registers endpoints on boot
   beforeAll(async () => {
-    server = new DaprServer(serverHost, serverPort, daprHost, daprPort, CommunicationProtocolEnum.HTTP);
     client = new DaprClient(daprHost, daprPort, CommunicationProtocolEnum.HTTP);
-
-    // await server.binding.receive('binding-mqtt', mockBindingReceive);
-
-    // Start server
-    await server.startServer();
   });
 
-  afterAll(async () => {
-    await server.stopServer();
-  })
-
   describe('pubsub', () => {
-    it('should be able to send 500 events as quickly as possible without errors', async () => {
-      const amountOfCalls = 1;
+    it('should be able to send 2500 events as quickly as possible without errors', async () => {
+      const amountOfCalls = 2500;
 
       // Create the promises
       let promises = [];
@@ -40,17 +24,13 @@ describe('load/http', () => {
       }
 
       // Await the promises
+      const tStart = Date.now();
       const res = await Promise.all(promises);
-      console.log(res);
-
-      // Delay a bit for event to arrive
-      // await new Promise((resolve, reject) => setTimeout(resolve, 250));
-
-      // expect(mockPubSubSubscribe.mock.calls.length).toBe(1);
+      const tEnd = Date.now();
 
-      // Also test for receiving data
-      // @ts-ignore
-      // expect(mockPubSubSubscribe.mock.calls[0][0]['hello']).toEqual('world');
-    });
+      expect(res.filter(i => i === true).length).toEqual(amountOfCalls);
+      console.log(`Execution time: ${tEnd - tStart}ms`);
+      // @todo: do we add an execution time test?
+    }, 30 * 1000);
   });
 });