Tests, Refactoring

Author: oklemenz2

jest.config.js

@@ -11,7 +11,7 @@ module.exports = {
   coverageReporters: ["lcov", "text"],
   coverageThreshold: {
     global: {
-      branches: 70,
+      branches: 75,
       functions: 90,
       lines: 90,
       statements: 90,

src/adapter/redis.js

@@ -13,7 +13,7 @@ class RedisAdapter {
   }
 
   async setup() {
-    this.client = await redis.createMainClientAndConnect();
+    this.client = await redis.createPrimaryClientAndConnect();
   }
 
   async on() {

src/redis/index.js

@@ -11,35 +11,35 @@ xsenv.loadEnv(path.join(process.cwd(), "default-env.json"));
 
 const TIMEOUT = 5 * 1000;
 
-let mainClientPromise;
-let secondClientPromise;
+let primaryClientPromise;
+let secondaryClientPromise;
 
-const createMainClientAndConnect = () => {
-  if (mainClientPromise) {
-    return mainClientPromise;
+const createPrimaryClientAndConnect = () => {
+  if (primaryClientPromise) {
+    return primaryClientPromise;
   }
 
   const errorHandlerCreateClient = (err) => {
     LOG?.error("Error from redis client for pub/sub failed", err);
-    mainClientPromise = null;
-    setTimeout(createMainClientAndConnect, TIMEOUT);
+    primaryClientPromise = null;
+    setTimeout(createPrimaryClientAndConnect, TIMEOUT);
   };
-  mainClientPromise = _createClientAndConnect(errorHandlerCreateClient);
-  return mainClientPromise;
+  primaryClientPromise = _createClientAndConnect(errorHandlerCreateClient);
+  return primaryClientPromise;
 };
 
-const createSecondClientAndConnect = () => {
-  if (secondClientPromise) {
-    return secondClientPromise;
+const createSecondaryClientAndConnect = () => {
+  if (secondaryClientPromise) {
+    return secondaryClientPromise;
   }
 
   const errorHandlerCreateClient = (err) => {
     LOG?.error("Error from redis client for pub/sub failed", err);
-    secondClientPromise = null;
-    setTimeout(createSecondClientAndConnect, TIMEOUT);
+    secondaryClientPromise = null;
+    setTimeout(createSecondaryClientAndConnect, TIMEOUT);
   };
-  secondClientPromise = _createClientAndConnect(errorHandlerCreateClient);
-  return secondClientPromise;
+  secondaryClientPromise = _createClientAndConnect(errorHandlerCreateClient);
+  return secondaryClientPromise;
 };
 const _createClientBase = () => {
   let credentials;
@@ -94,7 +94,13 @@ const _createClientAndConnect = async (errorHandlerCreateClient) => {
   return client;
 };
 
+const clearClients = () => {
+  primaryClientPromise = null;
+  secondaryClientPromise = null;
+};
+
 module.exports = {
-  createMainClientAndConnect,
-  createSecondClientAndConnect,
+  createPrimaryClientAndConnect,
+  createSecondaryClientAndConnect,
+  clearClients,
 };

src/socket/socket.io.js

@@ -83,14 +83,14 @@ class SocketIOServer extends SocketServer {
         const adapterFactory = require(adapterImpl);
         switch (adapterImpl) {
           case "@socket.io/redis-adapter":
-            client = await redis.createMainClientAndConnect();
-            subClient = await redis.createSecondClientAndConnect();
+            client = await redis.createPrimaryClientAndConnect();
+            subClient = await redis.createSecondaryClientAndConnect();
             if (client && subClient) {
               adapter = adapterFactory.createAdapter(client, subClient, options);
             }
             break;
           case "@socket.io/redis-streams-adapter":
-            client = await redis.createMainClientAndConnect();
+            client = await redis.createPrimaryClientAndConnect();
             if (client) {
               adapter = adapterFactory.createAdapter(client, options);
             }

test/_env/mocks/redis.js

@@ -3,8 +3,16 @@
 const onMessage = [];
 const onError = [];
 
+let createClientError = false;
+let connectError = false;
+
 const client = {
-  connect: jest.fn(() => {}),
+  connect: jest.fn(() => {
+    if (connectError) {
+      connectError = false;
+      throw new Error("connect error");
+    }
+  }),
   on: jest.fn((event, cb) => {
     switch (event) {
       case "message":
@@ -32,7 +40,21 @@ const client = {
 
 module.exports = {
   client,
+  throwError(kind) {
+    switch (kind) {
+      case "createClient":
+        createClientError = true;
+        break;
+      case "connect":
+        connectError = true;
+        break;
+    }
+  },
   createClient: jest.fn(() => {
+    if (createClientError) {
+      createClientError = false;
+      throw new Error("create client error");
+    }
     return client;
   }),
   createCluster: jest.fn(() => {

test/base.test.js

@@ -16,6 +16,7 @@ describe("Base", () => {
     const connected = (_socket) => {
       socket = _socket;
     };
+    socketServer.setup();
     socketServer.service("test", connected);
     expect(socket).toEqual({
       socket: null,
@@ -26,6 +27,12 @@ describe("Base", () => {
       broadcast: expect.any(Function),
       disconnect: expect.any(Function),
     });
+    expect(socket.setup()).toBeUndefined();
+    expect(socket.context()).toBeUndefined();
+    expect(socket.on()).toBeUndefined();
+    expect(socket.emit()).toBeUndefined();
+    expect(socket.broadcast()).toBeUndefined();
+    expect(socket.disconnect()).toBeUndefined();
   });
 
   test("Mock Response", async () => {

test/redis.test.js

@@ -2,6 +2,7 @@
 
 const cds = require("@sap/cds");
 const xsenv = require("@sap/xsenv");
+const redisMock = require("./_env/mocks/redis");
 jest.mock("redis", () => require("./_env/mocks/redis"));
 const redis = require("../src/redis");
 
@@ -15,15 +16,35 @@ describe("Redis", () => {
   afterAll(() => {});
 
   test("Client", async () => {
-    const main = await redis.createMainClientAndConnect();
+    const main = await redis.createPrimaryClientAndConnect();
     expect(main).toBeDefined();
-    const second = await redis.createSecondClientAndConnect();
+    const second = await redis.createSecondaryClientAndConnect();
     expect(second).toBeDefined();
   });
 
   test("Client fail", async () => {
-    const main = await redis.createMainClientAndConnect();
+    const main = await redis.createPrimaryClientAndConnect();
     expect(main).toBeDefined();
     main.error(new Error("Failed"));
+    expect(main.on).toHaveBeenNthCalledWith(1, "error", expect.any(Function));
+  });
+
+  test("Client createClient exception", async () => {
+    redis.clearClients();
+    redisMock.throwError("createClient");
+    let main = await redis.createPrimaryClientAndConnect();
+    expect(main).toBeUndefined();
+    redisMock.throwError("createClient");
+    let secondary = await redis.createSecondaryClientAndConnect();
+    expect(secondary).toBeUndefined();
+  });
+
+  test("Client connect exception", async () => {
+    redis.clearClients();
+    redisMock.throwError("connect");
+    let main = await redis.createPrimaryClientAndConnect();
+    redisMock.throwError("connect");
+    let secondary = await redis.createSecondaryClientAndConnect();
+    expect(secondary).toBeUndefined();
   });
 });