introduce the network status alert system

src/device-registry/.env.test

@@ -0,0 +1,4 @@
+SESSION_SECRET=test_secret
+REDIS_SERVER=127.0.0.1
+REDIS_SERVER_DEV=127.0.0.1
+REDIS_PORT=4674

src/device-registry/bin/jobs/check-network-status-job.js

@@ -0,0 +1,82 @@
+const constants = require("@config/constants");
+const log4js = require("log4js");
+const logger = log4js.getLogger(
+  `${constants.ENVIRONMENT} -- /bin/jobs/check-network-status-job`
+);
+const DeviceModel = require("@models/Device");
+const cron = require("node-cron");
+const { logText } = require("@utils/log");
+
+const BATCH_SIZE = 1000; // Define the size of each batch
+
+const checkNetworkStatus = async () => {
+  try {
+    let totalDevices = 0;
+    let offlineDevicesCount = 0;
+    let pageNumber = 0;
+
+    while (true) {
+      // Fetch a batch of devices
+      const devices = await DeviceModel("airqo")
+        .find({}, "isOnline _id")
+        .lean()
+        .limit(BATCH_SIZE)
+        .skip(pageNumber * BATCH_SIZE);
+
+      if (devices.length === 0) break; // Exit loop if no more devices
+
+      totalDevices += devices.length;
+
+      // Count offline devices in the current batch
+      offlineDevicesCount += devices.filter(
+        (device) => device.isOnline === false
+      ).length;
+
+      pageNumber++; // Move to the next batch
+    }
+
+    if (totalDevices === 0) {
+      logText("No devices found");
+      logger.info("No devices found.");
+      return;
+    }
+
+    const offlinePercentage = (offlineDevicesCount / totalDevices) * 100;
+
+    if (offlinePercentage > 60) {
+      logText(
+        `⚠️💔😥 More than 60% of devices are offline: ${offlinePercentage.toFixed(
+          2
+        )}%`
+      );
+
+      logger.warn(
+        `⚠️💔😥 More than 60% of devices are offline: ${offlinePercentage.toFixed(
+          2
+        )}%`
+      );
+    } else {
+      // logText(
+      //   `✅ Network status is acceptable: ${offlinePercentage.toFixed(
+      //     2
+      //   )}% offline`
+      // );
+      // logger.info(
+      //   `✅ Network status is acceptable: ${offlinePercentage.toFixed(
+      //     2
+      //   )}% offline`
+      // );
+    }
+  } catch (error) {
+    logText(`Error checking network status: ${error.message}`);
+    logger.error(`Error checking network status: ${error.message}`);
+    logger.error(`Stack trace: ${error.stack}`);
+  }
+};
+
+logText("Network status job is now running.....");
+const schedule = "0 */2 * * *";
+cron.schedule(schedule, checkNetworkStatus, {
+  scheduled: true,
+  timezone: constants.TIMEZONE,
+});

src/device-registry/bin/jobs/kafka-consumer.js

@@ -2,7 +2,7 @@ const { Kafka } = require("kafkajs");
 const constants = require("@config/constants");
 const log4js = require("log4js");
 const logger = log4js.getLogger(
-  `${constants.ENVIRONMENT} -- bin/kafka-consumer`
+  `${constants.ENVIRONMENT} -- bin/jobs/kafka-consumer`
 );
 const { logObject } = require("@utils/log");
 const createEvent = require("@utils/create-event");

src/device-registry/bin/jobs/new-store-readings-job.js

@@ -1,7 +1,7 @@
 const constants = require("@config/constants");
 const log4js = require("log4js");
 const logger = log4js.getLogger(
-  `${constants.ENVIRONMENT} -- /bin/new-store-readings-job`
+  `${constants.ENVIRONMENT} -- /bin/jobs/new-store-readings-job`
 );
 const EventModel = require("@models/Event");
 const DeviceModel = require("@models/Device");

src/device-registry/bin/jobs/store-readings-job.js

@@ -1,7 +1,7 @@
 const constants = require("@config/constants");
 const log4js = require("log4js");
 const logger = log4js.getLogger(
-  `${constants.ENVIRONMENT} -- /bin/store-readings-job`
+  `${constants.ENVIRONMENT} -- /bin/jobs/store-readings-job`
 );
 const EventModel = require("@models/Event");
 const ReadingModel = require("@models/Reading");

src/device-registry/bin/jobs/store-signals-job.js

@@ -1,7 +1,7 @@
 const constants = require("@config/constants");
 const log4js = require("log4js");
 const logger = log4js.getLogger(
-  `${constants.ENVIRONMENT} -- /bin/store-signals-job`
+  `${constants.ENVIRONMENT} -- /bin/jobs/store-signals-job`
 );
 const EventModel = require("@models/Event");
 const SignalModel = require("@models/Signal");

src/device-registry/bin/jobs/test/ut_check-network-status-job.js

@@ -0,0 +1,88 @@
+require("module-alias/register");
+const sinon = require("sinon");
+const { expect } = require("chai");
+const log4js = require("log4js");
+const DeviceModel = require("@models/Device");
+const { logText } = require("@utils/log");
+const checkNetworkStatus = require("@bin/jobs/check-network-status-job");
+
+describe("checkNetworkStatus", () => {
+  let loggerStub;
+  let findStub;
+
+  beforeEach(() => {
+    // Stub the logger methods
+    loggerStub = sinon.stub(log4js.getLogger(), "info");
+    sinon.stub(log4js.getLogger(), "warn");
+    sinon.stub(log4js.getLogger(), "error");
+
+    // Stub the DeviceModel find method
+    findStub = sinon.stub(DeviceModel.prototype, "find").returns({
+      lean: () => ({
+        limit: () => ({
+          skip: () => Promise.resolve([]), // Default to an empty array
+        }),
+      }),
+    });
+  });
+
+  afterEach(() => {
+    // Restore all stubs
+    sinon.restore();
+  });
+
+  it("should log 'No devices found' when there are no devices", async () => {
+    await checkNetworkStatus();
+
+    expect(loggerStub.calledWith("No devices found.")).to.be.true;
+    expect(logText.calledWith("No devices found")).to.be.true;
+  });
+
+  it("should calculate offline percentage correctly and log acceptable status", async () => {
+    findStub.returns({
+      lean: () => ({
+        limit: () => ({
+          skip: () =>
+            Promise.resolve([{ isOnline: true }, { isOnline: false }]), // Mock devices
+        }),
+      }),
+    });
+
+    await checkNetworkStatus();
+
+    expect(
+      loggerStub.calledWith("✅ Network status is acceptable: 50.00% offline")
+    ).to.be.true;
+  });
+
+  it("should calculate offline percentage correctly and log warning if more than 60% are offline", async () => {
+    findStub.returns({
+      lean: () => ({
+        limit: () => ({
+          skip: () =>
+            Promise.resolve([
+              { isOnline: false },
+              { isOnline: false },
+              { isOnline: true },
+            ]), // Mock devices
+        }),
+      }),
+    });
+
+    await checkNetworkStatus();
+
+    expect(
+      loggerStub.calledWith("⚠️ More than 60% of devices are offline: 66.67%")
+    ).to.be.true;
+  });
+
+  it("should handle errors gracefully", async () => {
+    findStub.throws(new Error("Database error"));
+
+    await checkNetworkStatus();
+
+    expect(
+      loggerStub.calledWith("Error checking network status: Database error")
+    ).to.be.true;
+  });
+});

src/device-registry/bin/server.js

@@ -25,6 +25,7 @@ const { logText, logObject } = require("@utils/log");
 const jsonify = require("@utils/jsonify");
 require("@bin/jobs/store-signals-job");
 require("@bin/jobs/new-store-readings-job");
+require("@bin/jobs/check-network-status-job");
 
 if (isEmpty(constants.SESSION_SECRET)) {
   throw new Error("SESSION_SECRET environment variable not set");

src/device-registry/bin/test/ut_index.js

@@ -1,85 +1,82 @@
 require("module-alias/register");
-const { expect } = require("chai");
 const sinon = require("sinon");
-const proxyquire = require("proxyquire");
-
-// Import the functions to be tested
-// const kafkaConsumer = require("@bin/kafka-consumer");
-// const createServer = require("@bin/server");
-const main = require("@bin/index");
-
-const kafkaConsumer = proxyquire("@bin/kafka-consumer", {
-  // Replace the original module with a mock version
-  myModule: {
-    fetchData: () => {
-      // Mock implementation without relying on environmental variables
-      return "Mocked Data";
-    },
-  },
-});
-
-const createServer = proxyquire("@bin/server", {
-  // Replace the original module with a mock version
-  myModule: {
-    fetchData: () => {
-      // Mock implementation without relying on environmental variables
-      return "Mocked Data";
-    },
-  },
-});
+const { expect } = require("chai");
+const log4js = require("log4js");
+const kafkaConsumer = require("@bin/jobs/kafka-consumer");
+const createServer = require("@bin/server");
+const constants = require("@config/constants");
+const log4jsConfiguration = require("@config/log4js");
 
-describe("Main Function", () => {
+describe("Application Initialization", () => {
+  let loggerStub;
   let kafkaConsumerStub;
   let createServerStub;
 
   beforeEach(() => {
-    kafkaConsumerStub = sinon.stub(kafkaConsumer);
+    // Stub the logger methods
+    loggerStub = sinon.stub(log4js.getLogger(), "error");
+
+    // Stub kafkaConsumer and createServer
+    kafkaConsumerStub = sinon.stub(kafkaConsumer, "default").resolves();
     createServerStub = sinon.stub(createServer);
+
+    // Configure log4js for testing
+    log4js.configure(log4jsConfiguration);
   });
 
   afterEach(() => {
+    // Restore all stubs
     sinon.restore();
   });
 
-  it("should call kafkaConsumer and createServer functions", async () => {
-    try {
-      // Call the main function
-      await main();
-
-      // Check if the kafkaConsumer and createServer functions are called
-      expect(kafkaConsumerStub.calledOnce).to.be.true;
-      expect(createServerStub.calledOnce).to.be.true;
-    } catch (error) {
-      throw error;
-    }
+  it("should start the Kafka consumer and create the server", async () => {
+    await main(); // Call the main function
+
+    expect(kafkaConsumerStub.calledOnce).to.be.true; // Check if kafkaConsumer was called
+    expect(createServerStub.calledOnce).to.be.true; // Check if createServer was called
   });
 
-  it("should catch and log errors if main function throws an error", async () => {
-    const errorToThrow = new Error("Test error");
-    const consoleErrorSpy = sinon.spy(console, "error");
-
-    // Stub the main function to throw an error
-    sinon.stub(main, "kafkaConsumer").throws(errorToThrow);
-
-    try {
-      // Call the main function
-      await main();
-
-      // Check if the error is caught and logged
-      expect(
-        consoleErrorSpy.calledOnceWithExactly(
-          "Error starting the application: ",
-          errorToThrow
-        )
-      ).to.be.true;
-    } catch (error) {
-      throw error;
-    } finally {
-      // Restore the stubs and spies
-      sinon.restore();
-      consoleErrorSpy.restore();
-    }
+  it("should log an error if starting Kafka fails", async () => {
+    const errorMessage = "Kafka connection error";
+    kafkaConsumerStub.rejects(new Error(errorMessage)); // Simulate an error from kafkaConsumer
+
+    await main(); // Call the main function
+
+    expect(
+      loggerStub.calledWithMatch(
+        sinon.match.string,
+        sinon.match({ message: errorMessage })
+      )
+    ).to.be.true;
+  });
+
+  it("should log an error if creating the server fails", async () => {
+    const errorMessage = "Server creation error";
+    kafkaConsumerStub.resolves(); // Ensure kafkaConsumer resolves
+    createServerStub.throws(new Error(errorMessage)); // Simulate an error from createServer
+
+    await main(); // Call the main function
+
+    expect(
+      loggerStub.calledWithMatch(
+        sinon.match.string,
+        sinon.match({ message: errorMessage })
+      )
+    ).to.be.true;
   });
 
-  // Add more test cases as needed
+  it("should handle errors thrown during application startup", async () => {
+    const startupError = new Error("Startup error");
+
+    // Simulate an error during startup
+    sinon.stub(console, "error"); // Stub console.error to suppress output during tests
+    await main().catch(() => {});
+
+    expect(
+      loggerStub.calledWithMatch(
+        sinon.match.string,
+        sinon.match({ message: startupError.message })
+      )
+    ).to.be.true;
+  });
 });