Move controllers to module structure and add controller-level tests

Author: GideonBature

src/.DS_Store

@@ -1,5 +1,4 @@
 import { Request, Response } from "express";
-// Integration test for NFTController
 import NFTController from "../../presentation/controllers/NFTController";
 
 describe("NFTController Integration", () => {
@@ -12,7 +11,7 @@ describe("NFTController Integration", () => {
     const res = {
       status: jest.fn().mockReturnThis(),
       json: jest.fn(),
-    } as Partial<Response>;
+    } as unknown as Response;
     await NFTController.createNFT(req as Request, res as Response);
     expect(res.status).toHaveBeenCalledWith(400);
     expect(res.json).toHaveBeenCalledWith(

src/modules/nft/__tests__/controllers/NFTController.int.test.ts

@@ -1,27 +1,132 @@
 // Integration test for OrganizationController
-import { NextFunction, Request, Response } from "express";
 import OrganizationController from "../../presentation/controllers/OrganizationController";
+import request from "supertest";
+import express, { Express } from "express";
 
-describe("OrganizationController Integration", () => {
-  it("should have a createOrganization method", () => {
-    expect(typeof OrganizationController.createOrganization).toBe("function");
+// Mock the OrganizationService
+jest.mock("../../../../services/OrganizationService");
+import { OrganizationService } from "../../../../services/OrganizationService";
+
+// Mock asyncHandler to just return the function (for test simplicity)
+jest.mock("../../../../utils/asyncHandler", () => ({
+  asyncHandler: <T extends (...args: unknown[]) => unknown>(fn: T) => fn,
+}));
+
+function setupApp(): Express {
+  const app = express();
+  app.use(express.json());
+  // OrganizationController is a singleton instance
+  app.post("/organizations", OrganizationController.createOrganization);
+  app.get("/organizations/:id", OrganizationController.getOrganizationById);
+  app.get(
+    "/organizations/email/:email",
+    OrganizationController.getOrganizationByEmail
+  );
+  app.put("/organizations/:id", OrganizationController.updateOrganization);
+  app.delete("/organizations/:id", OrganizationController.deleteOrganization);
+  app.get("/organizations", OrganizationController.getAllOrganizations);
+  return app;
+}
+
+describe("OrganizationController", () => {
+  let app: Express;
+
+  beforeEach(() => {
+    app = setupApp();
+    jest.clearAllMocks();
+  });
+
+  describe("POST /organizations", () => {
+    it("should create an organization and return 201", async () => {
+      const mockOrg = { id: "1", name: "Org" };
+      (OrganizationService as jest.Mock).mockImplementation(() => ({
+        createOrganization: jest.fn().mockResolvedValue(mockOrg),
+      }));
+      const res = await request(app).post("/organizations").send({
+        name: "Org",
+        email: "org@mail.com",
+        password: "pass",
+        category: "cat",
+        wallet: "wallet",
+      });
+      expect(res.status).toBe(201);
+      expect(res.body).toEqual(mockOrg);
+    });
+  });
+
+  describe("GET /organizations/:id", () => {
+    it("should return an organization by id", async () => {
+      const mockOrg = { id: "1", name: "Org" };
+      (OrganizationService as jest.Mock).mockImplementation(() => ({
+        getOrganizationById: jest.fn().mockResolvedValue(mockOrg),
+      }));
+      const res = await request(app).get("/organizations/1");
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual(mockOrg);
+    });
+    it("should return 404 if not found", async () => {
+      (OrganizationService as jest.Mock).mockImplementation(() => ({
+        getOrganizationById: jest.fn().mockResolvedValue(null),
+      }));
+      const res = await request(app).get("/organizations/1");
+      expect(res.status).toBe(404);
+      expect(res.body.error).toBe("Organization not found");
+    });
+  });
+
+  describe("GET /organizations/email/:email", () => {
+    it("should return an organization by email", async () => {
+      const mockOrg = { id: "1", name: "Org" };
+      (OrganizationService as jest.Mock).mockImplementation(() => ({
+        getOrganizationByEmail: jest.fn().mockResolvedValue(mockOrg),
+      }));
+      const res = await request(app).get("/organizations/email/test@mail.com");
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual(mockOrg);
+    });
+    it("should return 404 if not found", async () => {
+      (OrganizationService as jest.Mock).mockImplementation(() => ({
+        getOrganizationByEmail: jest.fn().mockResolvedValue(null),
+      }));
+      const res = await request(app).get("/organizations/email/test@mail.com");
+      expect(res.status).toBe(404);
+      expect(res.body.error).toBe("Organization not found");
+    });
+  });
+
+  describe("PUT /organizations/:id", () => {
+    it("should update an organization and return 200", async () => {
+      const mockOrg = { id: "1", name: "Updated Org" };
+      (OrganizationService as jest.Mock).mockImplementation(() => ({
+        updateOrganization: jest.fn().mockResolvedValue(mockOrg),
+      }));
+      const res = await request(app)
+        .put("/organizations/1")
+        .send({ name: "Updated Org" });
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual(mockOrg);
+    });
+  });
+
+  describe("DELETE /organizations/:id", () => {
+    it("should delete an organization and return 204", async () => {
+      (OrganizationService as jest.Mock).mockImplementation(() => ({
+        deleteOrganization: jest.fn().mockResolvedValue(undefined),
+      }));
+      const res = await request(app).delete("/organizations/1");
+      expect(res.status).toBe(204);
+    });
   });
 
-  test("should return error if required fields are missing on createOrganization", async () => {
-    const req = { body: {} } as Partial<Request>;
-    const res = {
-      status: jest.fn().mockReturnThis(),
-      json: jest.fn(),
-    } as Partial<Response>;
-    const next = jest.fn() as NextFunction;
-    OrganizationController.createOrganization(
-      req as Request,
-      res as Response,
-      next
-    );
-    expect(res.status).toHaveBeenCalledWith(400);
-    expect(res.json).toHaveBeenCalledWith(
-      expect.objectContaining({ error: expect.any(String) })
-    );
+  describe("GET /organizations", () => {
+    it("should return all organizations", async () => {
+      const mockOrgs = [{ id: "1" }, { id: "2" }];
+      (OrganizationService as jest.Mock).mockImplementation(() => ({
+        getAllOrganizations: jest.fn().mockResolvedValue(mockOrgs),
+      }));
+      const res = await request(app).get("/organizations");
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual(mockOrgs);
+    });
   });
 });

src/modules/organization/__tests__/controllers/OrganizationController.int.test.ts

@@ -1,8 +1,155 @@
 // Integration test for UserController
+import request from "supertest";
+import express, { Express } from "express";
 import UserController from "../../presentation/controllers/UserController";
 
-describe("UserController Integration", () => {
-  it("should have a createUser method", () => {
-    expect(typeof UserController.prototype.createUser).toBe("function");
+// Mock the UserService
+jest.mock("../../../../services/UserService");
+import { UserService } from "../../../../services/UserService";
+
+// Mock DTOs
+jest.mock("../../../../modules/user/dto/CreateUserDto", () => {
+  return {
+    CreateUserDto: function () {
+      return {};
+    },
+  };
+});
+jest.mock("../../../../modules/user/dto/UpdateUserDto", () => {
+  return {
+    UpdateUserDto: function () {
+      return {};
+    },
+  };
+});
+
+function setupApp(): Express {
+  const app = express();
+  app.use(express.json());
+  const controller = new UserController();
+  app.post("/users", controller.createUser.bind(controller));
+  app.get("/users/:id", controller.getUserById.bind(controller));
+  app.get("/users", controller.getUserByEmail.bind(controller));
+  app.put("/users/:id", controller.updateUser.bind(controller));
+  return app;
+}
+
+describe("UserController", () => {
+  let app: Express;
+
+  beforeEach(() => {
+    app = setupApp();
+    jest.clearAllMocks();
+  });
+
+  describe("POST /users", () => {
+    it("should create a user and return 201", async () => {
+      const mockUser = { id: "1", email: "test@example.com" };
+      (UserService as jest.Mock).mockImplementation(() => ({
+        createUser: jest.fn().mockResolvedValue(mockUser),
+      }));
+      const res = await request(app)
+        .post("/users")
+        .send({ email: "test@example.com" });
+      expect(res.status).toBe(201);
+      expect(res.body).toEqual(mockUser);
+    });
+
+    it("should handle errors and return 400", async () => {
+      (UserService as jest.Mock).mockImplementation(() => ({
+        createUser: jest.fn().mockRejectedValue(new Error("fail")),
+      }));
+      const res = await request(app)
+        .post("/users")
+        .send({ email: "test@example.com" });
+      expect(res.status).toBe(400);
+      expect(res.body.error).toBe("fail");
+    });
+  });
+
+  describe("GET /users/:id", () => {
+    it("should return a user by id", async () => {
+      const mockUser = { id: "1", email: "test@example.com" };
+      (UserService as jest.Mock).mockImplementation(() => ({
+        getUserById: jest.fn().mockResolvedValue(mockUser),
+      }));
+      const res = await request(app).get("/users/1");
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual(mockUser);
+    });
+
+    it("should return 404 if user not found", async () => {
+      (UserService as jest.Mock).mockImplementation(() => ({
+        getUserById: jest.fn().mockResolvedValue(null),
+      }));
+      const res = await request(app).get("/users/1");
+      expect(res.status).toBe(404);
+      expect(res.body.error).toBe("User not found");
+    });
+
+    it("should handle errors and return 400", async () => {
+      (UserService as jest.Mock).mockImplementation(() => ({
+        getUserById: jest.fn().mockRejectedValue(new Error("fail")),
+      }));
+      const res = await request(app).get("/users/1");
+      expect(res.status).toBe(400);
+      expect(res.body.error).toBe("fail");
+    });
+  });
+
+  describe("GET /users?email=", () => {
+    it("should return a user by email", async () => {
+      const mockUser = { id: "1", email: "test@example.com" };
+      (UserService as jest.Mock).mockImplementation(() => ({
+        getUserByEmail: jest.fn().mockResolvedValue(mockUser),
+      }));
+      const res = await request(app).get("/users?email=test@example.com");
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual(mockUser);
+    });
+
+    it("should return 400 if email is missing", async () => {
+      const res = await request(app).get("/users");
+      expect(res.status).toBe(400);
+      expect(res.body.error).toBe("Email is required");
+    });
+
+    it("should return 404 if user not found", async () => {
+      (UserService as jest.Mock).mockImplementation(() => ({
+        getUserByEmail: jest.fn().mockResolvedValue(null),
+      }));
+      const res = await request(app).get("/users?email=test@example.com");
+      expect(res.status).toBe(404);
+      expect(res.body.error).toBe("User not found");
+    });
+
+    it("should handle errors and return 400", async () => {
+      (UserService as jest.Mock).mockImplementation(() => ({
+        getUserByEmail: jest.fn().mockRejectedValue(new Error("fail")),
+      }));
+      const res = await request(app).get("/users?email=test@example.com");
+      expect(res.status).toBe(400);
+      expect(res.body.error).toBe("fail");
+    });
+  });
+
+  describe("PUT /users/:id", () => {
+    it("should update a user and return 200", async () => {
+      (UserService as jest.Mock).mockImplementation(() => ({
+        updateUser: jest.fn().mockResolvedValue(undefined),
+      }));
+      const res = await request(app).put("/users/1").send({ name: "Updated" });
+      expect(res.status).toBe(200);
+      expect(res.body.message).toBe("User updated successfully");
+    });
+
+    it("should handle errors and return 400", async () => {
+      (UserService as jest.Mock).mockImplementation(() => ({
+        updateUser: jest.fn().mockRejectedValue(new Error("fail")),
+      }));
+      const res = await request(app).put("/users/1").send({ name: "Updated" });
+      expect(res.status).toBe(400);
+      expect(res.body.error).toBe("fail");
+    });
   });
 });