implements all activities controller functions and their tests

Author: jackgarritano

src/controllers/activities.controller.ts

@@ -1,15 +1,15 @@
-import { ActivitiesModel, type ActivitiesType } from "../models/activities.model";
+import {
+  ActivitiesModel,
+  type ActivitiesType,
+} from "../models/activities.model";
 import { HttpError, HttpStatus, checkMongooseErrors } from "../utils/errors";
 import { checkDuplicateItemName } from "../utils/checkDuplicates";
 
 export const createActivity = async (activitiesFields: ActivitiesType) => {
   try {
-		if(await checkDuplicateItemName(activitiesFields.itemName)){
-			throw new HttpError(
-				HttpStatus.BAD_REQUEST,
-				"Duplicate item name",
-			)
-		}
+    if (await checkDuplicateItemName(activitiesFields.itemName)) {
+      throw new HttpError(HttpStatus.BAD_REQUEST, "Duplicate item name");
+    }
 
     const newActivities = new ActivitiesModel(activitiesFields);
     await newActivities.save();
@@ -30,7 +30,7 @@ export const createActivity = async (activitiesFields: ActivitiesType) => {
 };
 
 export const getAllActivities = async (user: string) => {
-	try {
+  try {
     const activities = await ActivitiesModel.find({ user: user });
     return activities;
   } catch (err: unknown) {
@@ -47,4 +47,91 @@ export const getAllActivities = async (user: string) => {
       { cause: err },
     );
   }
-}
+};
+
+export const getActivityById = async (user: string, activityId: string) => {
+  try {
+    const activities = await ActivitiesModel.findOne({
+      user: user,
+      _id: activityId,
+    });
+    return activities;
+  } catch (err: unknown) {
+    //rethrow any errors as HttpErrors
+    if (err instanceof HttpError) {
+      throw err;
+    }
+    //checks if mongoose threw and will rethrow with appropriate status code and message
+    checkMongooseErrors(err);
+
+    throw new HttpError(
+      HttpStatus.INTERNAL_SERVER_ERROR,
+      "Activity retrieval failed",
+      { cause: err },
+    );
+  }
+};
+
+export const updateActivity = async (
+  user: string,
+  activitiesFields: ActivitiesType,
+) => {
+  try {
+    const _id = activitiesFields._id; // Extract the _id from activitiesFields
+    if (!_id) {
+      throw new HttpError(
+        HttpStatus.BAD_REQUEST,
+        "Missing activity ID for update",
+      );
+    }
+
+    const updatedActivity = await ActivitiesModel.findOneAndUpdate(
+      { _id: _id, user: user }, // Query to match the document by _id and user
+      { $set: activitiesFields }, // Update operation
+      { new: true, runValidators: true }, // Options: return the updated document and run schema validators
+    );
+    return updatedActivity;
+  } catch (err: unknown) {
+    //rethrow any errors as HttpErrors
+    if (err instanceof HttpError) {
+      throw err;
+    }
+    //checks if mongoose threw and will rethrow with appropriate status code and message
+    checkMongooseErrors(err);
+
+    throw new HttpError(
+      HttpStatus.INTERNAL_SERVER_ERROR,
+      "Activity update failed",
+      { cause: err },
+    );
+  }
+};
+
+export const deleteActivity = async (user: string, activityId: string) => {
+  try {
+    const deletedActivity = await ActivitiesModel.findOneAndDelete({
+      _id: activityId,
+      user: user,
+    });
+    if (!deletedActivity) {
+      throw new HttpError(
+        HttpStatus.NOT_FOUND,
+        "Activity not found or already deleted",
+      );
+    }
+    return { message: "Activity deleted successfully" };
+  } catch (err: unknown) {
+    //rethrow any errors as HttpErrors
+    if (err instanceof HttpError) {
+      throw err;
+    }
+    //checks if mongoose threw and will rethrow with appropriate status code and message
+    checkMongooseErrors(err);
+
+    throw new HttpError(
+      HttpStatus.INTERNAL_SERVER_ERROR,
+      "Activity deletion failed",
+      { cause: err },
+    );
+  }
+};

src/tests/controllers.tests/activities.test.ts

@@ -1,32 +1,69 @@
 import { dbConnect, dbDisconnect } from "../dbHandler";
 import { ActivitiesType } from "../../models/activities.model";
 import { activityDummyData1 } from "./dummyData";
-import { createActivity, getAllActivities } from "../../controllers/activities.controller";
+import {
+  createActivity,
+  getAllActivities,
+  getActivityById,
+  updateActivity,
+  deleteActivity,
+} from "../../controllers/activities.controller";
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
 
 describe("Activities controller tests", () => {
-	beforeEach(async () => dbConnect());
-	afterEach(async () => dbDisconnect());
+  beforeEach(async () => dbConnect());
+  afterEach(async () => dbDisconnect());
 
-	test("Adds and retrieves an activity", async () => {
-		await createActivity(activityDummyData1 as ActivitiesType);
-		const returnedActivities = await getAllActivities(activityDummyData1.user);
+  test("Adds and retrieves an activity", async () => {
+    await createActivity(activityDummyData1 as ActivitiesType);
+    const returnedActivities = await getAllActivities(activityDummyData1.user);
 
-		//get back the 1 activity that was added
-		expect(returnedActivities.length).to.equal(1);
-		expect(returnedActivities[0]).toMatchObject(activityDummyData1);
+    //get back the 1 activity that was added
+    expect(returnedActivities.length).to.equal(1);
+    expect(returnedActivities[0]).toMatchObject(activityDummyData1);
 
-		//Can't add duplicate name
-		await expect(createActivity(activityDummyData1 as ActivitiesType)).rejects.toThrowError();
+    //Can't add duplicate name
+    await expect(
+      createActivity(activityDummyData1 as ActivitiesType),
+    ).rejects.toThrowError();
 
-		const returnedActivities2 = await getAllActivities(activityDummyData1.user);
+    const returnedActivities2 = await getAllActivities(activityDummyData1.user);
 
-		//if duplicate, shouldn't add to db
-		expect(returnedActivities2.length).to.equal(1);
+    //if duplicate, shouldn't add to db
+    expect(returnedActivities2.length).to.equal(1);
 
-		const returnedActivities3 = await getAllActivities("fakeuserid");
+    const returnedActivities3 = await getAllActivities("fakeuserid");
 
-		//don't get records for a different user id
+    //don't get records for a different user id
+    expect(returnedActivities3.length).to.equal(0);
+  });
+
+  test("Finds, updates, and deletes an activity", async () => {
+    await createActivity(activityDummyData1 as ActivitiesType);
+    const returnedActivities = await getAllActivities(activityDummyData1.user);
+
+    const returnedActivity = await getActivityById(
+      activityDummyData1.user,
+      returnedActivities[0]._id,
+    );
+
+    expect(returnedActivity).toMatchObject(activityDummyData1);
+
+    await updateActivity(activityDummyData1.user, {
+      ...activityDummyData1,
+      _id: returnedActivities[0]._id,
+      itemName: "activitiesItem2",
+    } as ActivitiesType);
+    const returnedActivity2 = await getActivityById(
+      activityDummyData1.user,
+      returnedActivities[0]._id,
+    );
+    expect(returnedActivity2?.itemName).to.equal("activitiesItem2");
+
+    await deleteActivity(activityDummyData1.user, returnedActivities[0]._id);
+		const returnedActivities3 = await getAllActivities(activityDummyData1.user);
 		expect(returnedActivities3.length).to.equal(0);
-	})
-})
+
+		await expect(updateActivity(activityDummyData1.user, {} as ActivitiesType)).rejects.toThrowError("Missing");
+  });
+});