Script to Migrate status COMPLETED to DONE in tasks model (#1692)

* written test for service file

* implement batch operation for task status from COMPLETED to DONE

* added code for updating task status COMPLETED to DONE

* written test for changes

* revert changes

* written integration test

* revert one change

* fix overlap problem

* added model test

* added chunk into promise.all

Author: shubhamsinghbundela

controllers/tasks.js

@@ -443,6 +443,16 @@ const assignTask = async (req, res) => {
   }
 };
 
+const updateStatus = async (req, res) => {
+  try {
+    const response = await tasks.updateTaskStatus();
+    return res.status(200).json(response);
+  } catch (error) {
+    logger.error("Error in migration scripts", error);
+    return res.boom.badImplementation(INTERNAL_SERVER_ERROR);
+  }
+};
+
 module.exports = {
   addNewTask,
   fetchTasks,
@@ -453,4 +463,5 @@ module.exports = {
   updateTaskStatus,
   overdueTasks,
   assignTask,
+  updateStatus,
 };

models/tasks.js

@@ -3,10 +3,14 @@ const tasksModel = firestore.collection("tasks");
 const ItemModel = firestore.collection("itemTags");
 const dependencyModel = firestore.collection("taskDependencies");
 const userUtils = require("../utils/users");
+const { updateTaskStatusToDone } = require("../services/tasks");
+const { chunks } = require("../utils/array");
+const { DOCUMENT_WRITE_SIZE } = require("../constants/constants");
 const { fromFirestoreData, toFirestoreData, buildTasks } = require("../utils/tasks");
 const { TASK_TYPE, TASK_STATUS, TASK_STATUS_OLD, TASK_SIZE } = require("../constants/tasks");
 const { IN_PROGRESS, NEEDS_REVIEW, IN_REVIEW, ASSIGNED, BLOCKED, SMOKE_TESTING, COMPLETED, SANITY_CHECK } = TASK_STATUS;
 const { OLD_ACTIVE, OLD_BLOCKED, OLD_PENDING, OLD_COMPLETED } = TASK_STATUS_OLD;
+const { INTERNAL_SERVER_ERROR } = require("../constants/errorMessages");
 
 /**
  * Adds and Updates tasks
@@ -575,6 +579,62 @@ const getOverdueTasks = async (days = 0) => {
   }
 };
 
+const updateTaskStatus = async () => {
+  try {
+    const snapshot = await tasksModel.where("status", "==", "COMPLETED").get();
+    const tasksStatusCompleted = [];
+    let summary = {
+      totalTasks: snapshot.size,
+      totalUpdatedStatus: 0,
+      totalOperationsFailed: 0,
+      updatedTaskDetails: [],
+      failedTaskDetails: [],
+    };
+
+    if (snapshot.size === 0) {
+      return summary;
+    }
+
+    snapshot.forEach((task) => {
+      const id = task.id;
+      const taskData = task.data();
+      tasksStatusCompleted.push({ ...taskData, id });
+    });
+    const taskStatusCompletedChunks = chunks(tasksStatusCompleted, DOCUMENT_WRITE_SIZE);
+
+    const updatedTasksPromises = await Promise.all(
+      taskStatusCompletedChunks.map(async (tasks) => {
+        const res = await updateTaskStatusToDone(tasks);
+        return {
+          totalUpdatedStatus: res.totalUpdatedStatus,
+          totalOperationsFailed: res.totalOperationsFailed,
+          updatedTaskDetails: res.updatedTaskDetails,
+          failedTaskDetails: res.failedTaskDetails,
+        };
+      })
+    );
+
+    updatedTasksPromises.forEach((res) => {
+      summary = {
+        ...summary,
+        totalUpdatedStatus: (summary.totalUpdatedStatus += res.totalUpdatedStatus),
+        totalOperationsFailed: (summary.totalOperationsFailed += res.totalOperationsFailed),
+        updatedTaskDetails: [...summary.updatedTaskDetails, ...res.updatedTaskDetails],
+        failedTaskDetails: [...summary.failedTaskDetails, ...res.failedTaskDetails],
+      };
+    });
+
+    if (summary.totalOperationsFailed === summary.totalTasks) {
+      throw Error(INTERNAL_SERVER_ERROR);
+    }
+
+    return summary;
+  } catch (error) {
+    logger.error(`Error in updating task status:  ${error}`);
+    throw error;
+  }
+};
+
 module.exports = {
   updateTask,
   fetchTasks,
@@ -591,4 +651,5 @@ module.exports = {
   fetchPaginatedTasks,
   getBuiltTasks,
   getOverdueTasks,
+  updateTaskStatus,
 };

routes/tasks.js

@@ -40,4 +40,6 @@ router.patch(
 );
 router.patch("/assign/self", authenticate, invalidateCache({ invalidationKeys: [ALL_TASKS] }), tasks.assignTask);
 
+router.post("/migration", authenticate, authorizeRoles([SUPERUSER]), tasks.updateStatus);
+
 module.exports = router;

test/integration/tasks.test.js

@@ -3,6 +3,7 @@ const sinon = require("sinon");
 const { expect } = chai;
 const chaiHttp = require("chai-http");
 
+const firestore = require("../../utils/firestore");
 const app = require("../../server");
 const tasks = require("../../models/tasks");
 const authService = require("../../services/authService");
@@ -1012,7 +1013,7 @@ describe("Tasks", function () {
         type: "feature",
         endsOn: 1234,
         startedOn: 4567,
-        status: "COMPLETED",
+        status: "completed",
         percentCompleted: 100,
         participants: [],
         assignee: appOwner.username,
@@ -1070,4 +1071,51 @@ describe("Tasks", function () {
       expect(res.body.message).to.be.equal("No overdue tasks found");
     });
   });
+
+  describe("POST /tasks/migration", function () {
+    it("Should update status COMPLETED to DONE successful", async function () {
+      const taskData1 = { status: "COMPLETED" };
+      await firestore.collection("tasks").doc("updateTaskStatus1").set(taskData1);
+      const res = await chai.request(app).post("/tasks/migration").set("cookie", `${cookieName}=${superUserJwt}`);
+      expect(res).to.have.status(200);
+      expect(res.body.totalTasks).to.be.equal(1);
+      expect(res.body.totalUpdatedStatus).to.be.equal(1);
+      expect(res.body.updatedTaskDetails).to.deep.equal(["updateTaskStatus1"]);
+      expect(res.body.totalOperationsFailed).to.be.equal(0);
+      expect(res.body.failedTaskDetails).to.deep.equal([]);
+    });
+
+    it("Should not update if not found any COMPLETED task status ", async function () {
+      const res = await chai.request(app).post("/tasks/migration").set("cookie", `${cookieName}=${superUserJwt}`);
+      expect(res).to.have.status(200);
+      expect(res.body.totalTasks).to.be.equal(0);
+      expect(res.body.totalUpdatedStatus).to.be.equal(0);
+      expect(res.body.updatedTaskDetails).to.deep.equal([]);
+      expect(res.body.totalOperationsFailed).to.be.equal(0);
+      expect(res.body.failedTaskDetails).to.deep.equal([]);
+    });
+
+    it("should throw an error if firestore batch operations fail", async function () {
+      const stub = sinon.stub(firestore, "batch");
+      stub.returns({
+        update: function () {},
+        commit: function () {
+          throw new Error("Firestore batch commit failed!");
+        },
+      });
+      const taskData1 = { status: "COMPLETED" };
+      await firestore.collection("tasks").doc("updateTaskStatus1").set(taskData1);
+      const res = await chai.request(app).post("/tasks/migration").set("cookie", `${cookieName}=${superUserJwt}`);
+      expect(res.status).to.equal(500);
+      const response = res.body;
+      expect(response.message).to.be.equal("An internal server error occurred");
+    });
+
+    it("Should return 401 if not super_user", async function () {
+      const nonSuperUserId = await addUser(appOwner);
+      const nonSuperUserJwt = authService.generateAuthToken({ userId: nonSuperUserId });
+      const res = await chai.request(app).post("/tasks/migration").set("cookie", `${cookieName}=${nonSuperUserJwt}`);
+      expect(res).to.have.status(401);
+    });
+  });
 });

test/unit/models/tasks.test.js

@@ -5,6 +5,7 @@
 /* eslint-disable security/detect-object-injection */
 
 const chai = require("chai");
+const sinon = require("sinon");
 const { expect } = chai;
 const cleanDb = require("../../utils/cleanDb");
 const tasksData = require("../../fixtures/tasks/tasks")();
@@ -304,4 +305,45 @@ describe("tasks", function () {
       expect(usersWithOverdueTasks.length).to.be.equal(4);
     });
   });
+
+  describe("update task status", function () {
+    beforeEach(async function () {
+      const addTasksPromises = [];
+      tasksData.forEach((task) => {
+        const taskData = {
+          ...task,
+          status: "COMPLETED",
+        };
+        addTasksPromises.push(tasksModel.add(taskData));
+      });
+
+      await Promise.all(addTasksPromises);
+    });
+
+    afterEach(function () {
+      sinon.restore();
+    });
+
+    it("Should update task status COMPLETED to DONE", async function () {
+      const res = await tasks.updateTaskStatus();
+      expect(res.totalTasks).to.be.equal(8);
+      expect(res.totalUpdatedStatus).to.be.equal(8);
+    });
+
+    it("should throw an error if firebase batch operation fails", async function () {
+      const stub = sinon.stub(firestore, "batch");
+      stub.returns({
+        update: function () {},
+        commit: function () {
+          throw new Error("Firestore batch update failed");
+        },
+      });
+      try {
+        await tasks.updateTaskStatus();
+      } catch (error) {
+        expect(error).to.be.an.instanceOf(Error);
+        expect(error.message).to.equal("An internal server error occurred");
+      }
+    });
+  });
 });