Add Three New Jobs and Their Respective Unit Tests

src/device-registry/bin/jobs/check-active-statuses.js

@@ -0,0 +1,116 @@
+const constants = require("@config/constants");
+const log4js = require("log4js");
+const logger = log4js.getLogger(
+  `${constants.ENVIRONMENT} -- /bin/jobs/check-active-statuses-job`
+);
+const DeviceModel = require("@models/Device");
+const cron = require("node-cron");
+const ACTIVE_STATUS_THRESHOLD = 0;
+const { logText, logObject } = require("@utils/log");
+
+const checkActiveStatuses = async () => {
+  try {
+    // Check for Deployed devices with incorrect statuses
+    const activeIncorrectStatusCount = await DeviceModel(
+      "airqo"
+    ).countDocuments({
+      isActive: true,
+      status: { $ne: "deployed" },
+    });
+
+    const activeMissingStatusCount = await DeviceModel("airqo").countDocuments({
+      isActive: true,
+      status: { $exists: false } || { $eq: null } || { $eq: "" },
+    });
+
+    const activeIncorrectStatusResult = await DeviceModel("airqo").aggregate([
+      {
+        $match: {
+          isActive: true,
+          status: { $ne: "deployed" },
+        },
+      },
+      {
+        $group: {
+          _id: "$name",
+        },
+      },
+    ]);
+
+    const activeMissingStatusResult = await DeviceModel("airqo").aggregate([
+      {
+        $match: {
+          isActive: true,
+          status: { $exists: false } || { $eq: null } || { $eq: "" },
+        },
+      },
+      {
+        $group: {
+          _id: "$name",
+        },
+      },
+    ]);
+
+    const activeIncorrectStatusUniqueNames = activeIncorrectStatusResult.map(
+      (doc) => doc._id
+    );
+    const activeMissingStatusUniqueNames = activeMissingStatusResult.map(
+      (doc) => doc._id
+    );
+
+    logObject("activeIncorrectStatusCount", activeIncorrectStatusCount);
+    logObject("activeMissingStatusCount", activeMissingStatusCount);
+
+    const percentageActiveIncorrectStatus =
+      (activeIncorrectStatusCount /
+        (await DeviceModel("airqo").countDocuments({ isActive: true }))) *
+      100;
+    const percentageActiveMissingStatus =
+      (activeMissingStatusCount /
+        (await DeviceModel("airqo").countDocuments({ isActive: true }))) *
+      100;
+
+    logObject(
+      "percentageActiveIncorrectStatus",
+      percentageActiveIncorrectStatus
+    );
+    logObject("percentageActiveMissingStatus", percentageActiveMissingStatus);
+
+    if (
+      percentageActiveIncorrectStatus > ACTIVE_STATUS_THRESHOLD ||
+      percentageActiveMissingStatus > ACTIVE_STATUS_THRESHOLD
+    ) {
+      logText(
+        `⁉️ Deployed devices with incorrect statuses (${activeIncorrectStatusUniqueNames.join(
+          ", "
+        )}) - ${percentageActiveIncorrectStatus.toFixed(2)}%`
+      );
+      logger.info(
+        `⁉️ Deployed devices with incorrect statuses (${activeIncorrectStatusUniqueNames.join(
+          ", "
+        )}) - ${percentageActiveIncorrectStatus.toFixed(2)}%`
+      );
+
+      logText(
+        `⁉️ Deployed devices missing status (${activeMissingStatusUniqueNames.join(
+          ", "
+        )}) - ${percentageActiveMissingStatus.toFixed(2)}%`
+      );
+      logger.info(
+        `⁉️ Deployed devices missing status (${activeMissingStatusUniqueNames.join(
+          ", "
+        )}) - ${percentageActiveMissingStatus.toFixed(2)}%`
+      );
+    }
+  } catch (error) {
+    logText(`🐛🐛 Error checking active statuses: ${error.message}`);
+    logger.error(`🐛🐛 Error checking active statuses: ${error.message}`);
+    logger.error(`🐛🐛 Stack trace: ${error.stack}`);
+  }
+};
+
+logText("Active statuses job is now running.....");
+const schedule = "30 */2 * * *"; // At minute 30 of every 2nd hour
+cron.schedule(schedule, checkActiveStatuses, {
+  scheduled: true,
+});

src/device-registry/bin/jobs/check-unassigned-devices-job.js

@@ -0,0 +1,71 @@
+const constants = require("@config/constants");
+const log4js = require("log4js");
+const logger = log4js.getLogger(
+  `${constants.ENVIRONMENT} -- /bin/jobs/check-unassigned-devices-job`
+);
+const DeviceModel = require("@models/Device");
+const cron = require("node-cron");
+const UNASSIGNED_THRESHOLD = 0;
+const { logText, logObject } = require("@utils/log");
+
+const checkUnassignedDevices = async () => {
+  try {
+    const totalCount = await DeviceModel("airqo").countDocuments({
+      isActive: false,
+    });
+
+    const result = await DeviceModel("airqo").aggregate([
+      {
+        $match: {
+          isActive: false,
+          category: { $exists: false } || { $eq: "" },
+        },
+      },
+      {
+        $group: {
+          _id: "$name",
+        },
+      },
+    ]);
+
+    const unassignedDevicesCount = result.length;
+    const uniqueDeviceNames = result.map((doc) => doc._id);
+    logObject("unassignedDevicesCount", unassignedDevicesCount);
+    logObject("totalCount ", totalCount);
+
+    if (unassignedDevicesCount === 0) {
+      return;
+    }
+
+    const percentage = (unassignedDevicesCount / totalCount) * 100;
+
+    logObject("percentage", percentage);
+
+    if (percentage > UNASSIGNED_THRESHOLD) {
+      logText(
+        `🤦‍♀️🫣 ${percentage.toFixed(
+          2
+        )}% of deployed devices are not assigned to any category (${uniqueDeviceNames.join(
+          ", "
+        )})`
+      );
+      logger.info(
+        `🤦‍♀️🫣 ${percentage.toFixed(
+          2
+        )}% of deployed devices are not assigned to any category (${uniqueDeviceNames.join(
+          ", "
+        )})`
+      );
+    }
+  } catch (error) {
+    logText(`🐛🐛 Error checking unassigned devices: ${error.message}`);
+    logger.error(`🐛🐛 Error checking unassigned devices: ${error.message}`);
+    logger.error(`🐛🐛 Stack trace: ${error.stack}`);
+  }
+};
+
+logText("Unassigned devices job is now running.....");
+const schedule = "30 */2 * * *"; // At minute 30 of every 2nd hour
+cron.schedule(schedule, checkUnassignedDevices, {
+  scheduled: true,
+});

src/device-registry/bin/jobs/check-unassigned-sites-job.js

@@ -0,0 +1,73 @@
+const constants = require("@config/constants");
+const log4js = require("log4js");
+const logger = log4js.getLogger(
+  `${constants.ENVIRONMENT} -- /bin/jobs/check-unassigned-sites-job`
+);
+const SitesModel = require("@models/Site");
+const cron = require("node-cron");
+const UNASSIGNED_THRESHOLD = 0;
+const { logText, logObject } = require("@utils/log");
+
+const checkUnassignedSites = async () => {
+  try {
+    // Count total number of active sites
+    const totalCount = await SitesModel("airqo").countDocuments({
+      isOnline: true,
+    });
+
+    // Find sites with empty or non-existent grids array
+    const result = await SitesModel("airqo").aggregate([
+      {
+        $match: {
+          isOnline: true,
+          grids: { $size: 0 },
+        },
+      },
+      {
+        $group: {
+          _id: "$generated_name",
+        },
+      },
+    ]);
+
+    const unassignedSiteCount = result.length;
+    const uniqueSiteNames = result.map((site) => site._id);
+    logObject("unassignedSiteCount", unassignedSiteCount);
+    logObject("totalCount", totalCount);
+
+    if (unassignedSiteCount === 0) {
+      return;
+    }
+
+    const percentage = (unassignedSiteCount / totalCount) * 100;
+
+    logObject("percentage", percentage);
+
+    if (percentage > UNASSIGNED_THRESHOLD) {
+      logText(
+        `⚠️🙉 ${percentage.toFixed(
+          2
+        )}% of active sites are not assigned to any grid (${uniqueSiteNames.join(
+          ", "
+        )})`
+      );
+      logger.info(
+        `⚠️🙉 ${percentage.toFixed(
+          2
+        )}% of active sites are not assigned to any grid (${uniqueSiteNames.join(
+          ", "
+        )})`
+      );
+    }
+  } catch (error) {
+    logText(`🐛🐛 Error checking unassigned sites: ${error.message}`);
+    logger.error(`🐛🐛 Error checking unassigned sites: ${error.message}`);
+    logger.error(`🐛🐛 Stack trace: ${error.stack}`);
+  }
+};
+
+logText("Unassigned sites job is now running.....");
+const schedule = "30 */2 * * *"; // At minute 30 of every 2nd hour
+cron.schedule(schedule, checkUnassignedSites, {
+  scheduled: true,
+});

src/device-registry/bin/jobs/test/ut_check-active-statuses.js

@@ -0,0 +1,97 @@
+require("module-alias/register");
+const sinon = require("sinon");
+const chai = require("chai");
+const expect = chai.expect;
+const sinonChai = require("sinon-chai");
+
+const checkActiveStatuses = require("@bin/jobs/check-active-statuses");
+
+const DeviceModelMock = sinon.mock(DeviceModel);
+const logTextSpy = sinon.spy(console.log);
+const logObjectSpy = sinon.spy(console.log);
+const loggerErrorSpy = sinon.spy(logger.error);
+
+beforeEach(() => {
+  DeviceModelMock = sinon.mock(DeviceModel);
+  logTextSpy = sinon.spy(console.log);
+  logObjectSpy = sinon.spy(console.log);
+  loggerErrorSpy = sinon.spy(logger.error);
+});
+
+afterEach(() => {
+  sinon.restore();
+});
+
+describe("checkActiveStatuses", () => {
+  describe("when devices have incorrect statuses", () => {
+    it("should log deployed devices with incorrect statuses", async () => {
+      DeviceModelMock.expects("countDocuments")
+        .twice()
+        .resolves(5);
+
+      const result = await checkActiveStatuses();
+
+      expect(logTextSpy).to.have.been.calledWith(sinon.match.string);
+      expect(logObjectSpy).to.have.been.calledWith(sinon.match.object);
+      expect(logger.info).to.have.been.calledWith(sinon.match.string);
+      expect(logTextSpy).to.have.been.calledWith(sinon.match.string);
+      expect(logger.info).to.have.been.calledWith(sinon.match.string);
+
+      sinon.assert.notCalled(loggerErrorSpy);
+    });
+  });
+
+  describe("when devices have missing status fields", () => {
+    it("should log deployed devices missing status", async () => {
+      DeviceModelMock.expects("countDocuments")
+        .twice()
+        .resolves(3);
+
+      const result = await checkActiveStatuses();
+
+      expect(logTextSpy).to.have.been.calledWith(sinon.match.string);
+      expect(logObjectSpy).to.have.been.calledWith(sinon.match.object);
+      expect(logger.info).to.have.been.calledWith(sinon.match.string);
+      expect(logTextSpy).to.have.been.calledWith(sinon.match.string);
+      expect(logger.info).to.have.been.calledWith(sinon.match.string);
+
+      sinon.assert.notCalled(loggerErrorSpy);
+    });
+  });
+
+  describe("when both conditions are met", () => {
+    it("should log both deployed devices with incorrect statuses and missing status fields", async () => {
+      DeviceModelMock.expects("countDocuments")
+        .thrice()
+        .resolves([5, 3]);
+
+      const result = await checkActiveStatuses();
+
+      expect(logTextSpy).to.have.been.calledThrice();
+      expect(logObjectSpy).to.have.been.calledTwice();
+      expect(logger.info).to.have.been.calledTwice();
+      expect(logger.info).to.have.been.calledWith(sinon.match.string);
+      expect(logger.info).to.have.been.calledWith(sinon.match.string);
+
+      sinon.assert.notCalled(loggerErrorSpy);
+    });
+  });
+
+  describe("when error occurs", () => {
+    it("should log the error message", async () => {
+      const error = new Error("Test error");
+
+      DeviceModelMock.expects("countDocuments").throws(error);
+
+      await checkActiveStatuses();
+
+      expect(logTextSpy).to.have.been.calledWith(sinon.match.string);
+      expect(logger.error).to.have.been.calledWith(sinon.match.string);
+      expect(logger.error).to.have.been.calledWith(sinon.match.string);
+      expect(logger.error).to.have.been.calledWith(sinon.match.string);
+
+      sinon.assert.notCalled(logObjectSpy);
+      sinon.assert.notCalled(logger.info);
+    });
+  });
+});