diff --git a/src/shared/auth/auth.controller.spec.ts b/src/shared/auth/auth.controller.spec.ts
index 71bb2ce..1f25675 100644
--- a/src/shared/auth/auth.controller.spec.ts
+++ b/src/shared/auth/auth.controller.spec.ts
@@ -1,22 +1,393 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AuthController } from './auth.controller';
 import { AuthService } from './auth.service';
-import { TestModule } from '../testkits';
+import { User, UserDocument } from '../schema';
+import { Model } from 'mongoose';
+import { BadRequestException } from '@nestjs/common';
+import { RegistrationMethod, UserRole, UserStatus } from '../interfaces';
+import { JwtService } from '@nestjs/jwt';
 
+// extending mongoose model ot allow us to use custom mocks
+// used jest.mock becasue i'll mock them in the test
+interface UserModel extends Model<UserDocument> {
+  verifyEmail: jest.Mock;
+  signUp: jest.Mock;
+  forgetPassword: jest.Mock;
+  generateUserHandle: jest.Mock;
+  sendEmailVerificationToken: jest.Mock;
+}
+
+// requiered to tell typescript which methods we are mocking
+// if removed, things like "authserice.resendverificationlink.mockRejectedValues" will not work
+interface MockAuthService {
+  login: jest.Mock;
+  resendVerificationLink: jest.Mock;
+  sendEmailVerificationToken: jest.Mock;
+  findByUsername: jest.Mock;
+  validateUser: jest.Mock;
+}
+
+// Main test container
 describe('AuthController', () => {
-  let controller: AuthController;
+  let authController: AuthController;
+  let userModel: UserModel;
+  let authService: MockAuthService;
+  let jwtService: JwtService;
+
+  // Mock data for typical user object
+  const mockUser = {
+    _id: '507f1f77bcf86cd799439011',
+    firstName: 'John',
+    lastName: 'Doe',
+    email: 'john@example.com',
+    userHandle: 'johndoe',
+    emailVerification: false,
+    joinMethod: RegistrationMethod.SIGN_UP,
+    role: [UserRole.ADMIN],
+    status: UserStatus.ACTIVE,
+  };
+
+  // mock a typical Http request object
+  const mockReq = {
+    protocol: 'http',
+    get: jest.fn().mockReturnValue('localhost'),
+    originalUrl: '/api/v1/auth',
+    query: {},
+  };
+
+  // to avoid conflict like services calling redis and db static functions, mocked
+  // services are defined here
+  const mockAuthService: MockAuthService = {
+    login: jest.fn().mockImplementation((req) => {
+      return Promise.resolve({
+        access_token: 'mock_token', // will be what is returned as the token
+        ...mockUser,
+      });
+    }),
+    resendVerificationLink: jest.fn().mockImplementation((req, email) => {
+      return Promise.resolve({
+        message: 'Verification email sent successfully',
+      });
+    }),
+    sendEmailVerificationToken: jest.fn().mockImplementation((req, userId) => {
+      return Promise.resolve({
+        emailVerificationCode: '123456',
+        emailVerificationUrl: 'http://localhost/verify/123456',
+      });
+    }),
+    findByUsername: jest.fn(),
+    validateUser: jest.fn(),
+  };
+  // mock for the static methods in the user schema
+  const mockUserModel = {
+    verifyEmail: jest
+      .fn()
+      .mockImplementation((userId: string, token: string) => {
+        if (token === '123456') {
+          return Promise.resolve({
+            status: 200,
+            message: 'Email Verification Successful',
+          });
+        }
+        return Promise.reject(
+          new BadRequestException('Invalid email verification token supplied'),
+        );
+      }),
+
+    signUp: jest
+      .fn()
+      .mockImplementation((req: any, createUserDto: any, sso = false) => {
+        return Promise.resolve({
+          ...mockUser,
+          ...createUserDto,
+          emailVerificationCode: '123456',
+          emailVerificationUrl: 'http://localhost/verify/123456',
+        });
+      }),
+
+    forgetPassword: jest.fn().mockImplementation((email: string) => {
+      if (email === 'john@example.com') {
+        return Promise.resolve({
+          email: 'john@example.com',
+          firstName: 'John',
+          lastName: 'Doe',
+        });
+      }
+      return Promise.reject(
+        new BadRequestException('Email supplied cannot be found'),
+      );
+    }),
+
+    sendEmailVerificationToken: jest.fn().mockImplementation((req, userId) => {
+      return Promise.resolve({
+        emailVerificationCode: '123456',
+        emailVerificationUrl: 'http://localhost/verify/123456',
+      });
+    }),
+
+    // Base mongoose model methods
+    generateUserHandle: jest.fn(),
+    findOne: jest.fn(),
+    findById: jest.fn(),
+    create: jest.fn(),
+  } as unknown as UserModel; // bypass typescript type checking || i know... but it works
+
+  // ensure that the jwt always returns the same token
+  const mockJwtService = {
+    sign: jest.fn().mockReturnValue('mock_token'),
+  };
 
   beforeEach(async () => {
+    jest.clearAllMocks(); // clear all mock implementaions
+
     const module: TestingModule = await Test.createTestingModule({
-      imports: [TestModule],
       controllers: [AuthController],
-      providers: [AuthService],
+      providers: [
+        {
+          provide: AuthService,
+          useValue: mockAuthService,
+        },
+        {
+          provide: User.name,
+          useValue: mockUserModel,
+        },
+        {
+          provide: JwtService,
+          useValue: mockJwtService,
+        },
+      ],
     }).compile();
 
-    controller = module.get<AuthController>(AuthController);
+    authController = module.get<AuthController>(AuthController);
+    userModel = module.get<UserModel>(User.name);
+    authService = module.get<MockAuthService>(AuthService);
+    jwtService = module.get<JwtService>(JwtService);
   });
 
+  // check if controller is created
   it('should be defined', () => {
-    expect(controller).toBeDefined();
+    expect(authController).toBeDefined();
+  });
+
+  // test for registration
+  describe('register', () => {
+    // basic user registration request
+    interface CreateUserDto {
+      firstName: string;
+      lastName: string;
+      email: string;
+      password: string;
+      joinMethod: RegistrationMethod;
+    }
+
+    const createUserDto: CreateUserDto = {
+      firstName: 'John',
+      lastName: 'Doe',
+      email: 'john@example.com',
+      password: 'Password123!',
+      joinMethod: RegistrationMethod.SIGN_UP,
+    };
+
+    it('should register a new user', async () => {
+      const result = await authController.register(mockReq, createUserDto);
+
+      expect(result).toHaveProperty('email', createUserDto.email);
+      expect(userModel.signUp).toHaveBeenCalledWith(mockReq, createUserDto);
+    });
+
+    it('should throw an error if user already exists', async () => {
+      userModel.signUp.mockRejectedValueOnce(
+        new BadRequestException('User already exists'),
+      );
+
+      await expect(
+        authController.register(mockReq, createUserDto),
+      ).rejects.toThrow(BadRequestException);
+    });
+    it('should throw an error if registration data is invalid', async () => {
+      const invalidUserDto = {
+        ...createUserDto,
+        email: 'invalid-email', // Invalid email format
+      };
+
+      userModel.signUp.mockRejectedValueOnce(
+        new BadRequestException('Invalid email format'),
+      );
+
+      await expect(
+        authController.register(mockReq, invalidUserDto),
+      ).rejects.toThrow(BadRequestException);
+    });
+  });
+
+  // test for login
+  describe('login', () => {
+    const loginDto = {
+      email: 'john@example.com',
+      password: 'Password123!',
+    };
+
+    it('should login successfully', async () => {
+      const mockReqWithUser = {
+        ...mockReq,
+        user: mockUser,
+      };
+
+      const result = await authController.login(mockReqWithUser, loginDto);
+
+      expect(result).toHaveProperty('access_token');
+      expect(result).toHaveProperty('email', mockUser.email);
+      expect(authService.login).toHaveBeenCalledWith(mockReqWithUser);
+    });
+
+    it('should include user details in response', async () => {
+      const mockReqWithUser = {
+        ...mockReq,
+        user: mockUser,
+      };
+
+      const result = await authController.login(mockReqWithUser, loginDto);
+
+      expect(result).toMatchObject({
+        access_token: expect.any(String),
+        email: mockUser.email,
+        firstName: mockUser.firstName,
+        lastName: mockUser.lastName,
+      });
+    });
+  });
+
+  describe('verifyEmail', () => {
+    const userId = '507f1f77bcf86cd799439011';
+    const validToken = '123456';
+    const invalidToken = 'invalid-token';
+
+    it('should verify email with valid token', async () => {
+      const result = await authController.verifyEmail(userId, validToken);
+
+      expect(result).toEqual({
+        status: 200,
+        message: 'Email Verification Successful',
+      });
+      expect(userModel.verifyEmail).toHaveBeenCalledWith(userId, validToken);
+    });
+
+    it('should throw BadRequestException for invalid token', async () => {
+      await expect(
+        authController.verifyEmail(userId, invalidToken),
+      ).rejects.toThrow(BadRequestException);
+      expect(userModel.verifyEmail).toHaveBeenCalledWith(userId, invalidToken);
+    });
+
+    it('should handle non-existent user ID', async () => {
+      const nonExistentUserId = 'non-existent-id';
+      userModel.verifyEmail.mockRejectedValueOnce(
+        new BadRequestException('User not found'),
+      );
+
+      await expect(
+        authController.verifyEmail(nonExistentUserId, validToken),
+      ).rejects.toThrow(BadRequestException);
+    });
+  });
+
+  describe('resendVerification', () => {
+    const validEmail = 'john@example.com';
+    const invalidEmail = 'nonexistent@example.com';
+
+    it('should resend verification email successfully', async () => {
+      const expectedResponse = {
+        message: 'Verification email sent successfully',
+      };
+
+      const result = await authController.resendVerification(
+        mockReq,
+        validEmail,
+      );
+
+      expect(result).toEqual(expectedResponse);
+      expect(authService.resendVerificationLink).toHaveBeenCalledWith(
+        mockReq,
+        validEmail,
+      );
+    });
+
+    it('should handle non-existent email', async () => {
+      authService.resendVerificationLink.mockRejectedValueOnce(
+        new BadRequestException(
+          `Account with email ${invalidEmail} does not exist`,
+        ),
+      );
+
+      await expect(
+        authController.resendVerification(mockReq, invalidEmail),
+      ).rejects.toThrow(BadRequestException);
+    });
+  });
+
+  describe('sendEmailVerificationToken', () => {
+    const userId = '507f1f77bcf86cd799439011';
+
+    it('should send email verification token successfully', async () => {
+      const expectedResponse = {
+        emailVerificationCode: '123456',
+        emailVerificationUrl: 'http://localhost/verify/123456',
+      };
+
+      const result = await authController.sendEmailVerificationToken(
+        mockReq,
+        userId,
+      );
+
+      expect(result).toEqual(expectedResponse);
+      expect(authService.sendEmailVerificationToken).toHaveBeenCalledWith(
+        mockReq,
+        userId,
+      );
+    });
+
+    it('should handle invalid user ID', async () => {
+      const invalidUserId = 'invalid-user-id';
+      authService.sendEmailVerificationToken.mockRejectedValueOnce(
+        new BadRequestException('User not found'),
+      );
+
+      await expect(
+        authController.sendEmailVerificationToken(mockReq, invalidUserId),
+      ).rejects.toThrow(BadRequestException);
+    });
+  });
+
+  describe('forgetPassword', () => {
+    const validEmail = 'john@example.com';
+    const invalidEmail = 'nonexistent@example.com';
+
+    it('should process forget password request for valid email', async () => {
+      const result = await authController.forgetPassword(validEmail);
+
+      expect(result).toMatchObject({
+        email: validEmail,
+        firstName: 'John',
+        lastName: 'Doe',
+      });
+      expect(userModel.forgetPassword).toHaveBeenCalledWith(validEmail);
+    });
+
+    it('should throw BadRequestException for non-existent email', async () => {
+      await expect(authController.forgetPassword(invalidEmail)).rejects.toThrow(
+        BadRequestException,
+      );
+      expect(userModel.forgetPassword).toHaveBeenCalledWith(invalidEmail);
+    });
+
+    it('should handle error during password reset process', async () => {
+      userModel.forgetPassword.mockRejectedValueOnce(
+        new Error('Failed to process password reset'),
+      );
+
+      await expect(authController.forgetPassword(validEmail)).rejects.toThrow(
+        Error,
+      );
+    });
   });
 });
diff --git a/src/users/users.controller.spec.ts b/src/users/users.controller.spec.ts
index 90fe441..b485980 100644
--- a/src/users/users.controller.spec.ts
+++ b/src/users/users.controller.spec.ts
@@ -9,7 +9,58 @@ import {
   RegistrationMethod,
   UserRole,
   UserStatus,
+  ApiReq,
 } from 'src/shared/interfaces';
+// imported to handle the paginated response from findAll
+import { Model, Document, Types } from 'mongoose';
+import { IPageable } from 'src/shared/utils';
+type UserDocument = Document<unknown, {}, User> &
+  User & { _id: Types.ObjectId };
+
+/*
+'*generates a mock user object that can be used across multiple tests
+ *choose which part you want to override using createMock({parameter:new_value})
+*/
+
+const createUserMock = (
+  overrides: Partial<UserDocument> = {},
+): UserDocument => {
+  return {
+    _id: new Types.ObjectId(),
+    firstName: 'John',
+    lastName: 'Doe',
+    email: 'john.doe@example.com',
+    password: 'hashedpassword123',
+    profileSummary: 'Experienced software engineer',
+    jobTitle: 'Senior Developer',
+    currentCompany: 'TechCorp',
+    photo: 'profilephoto.jpg',
+    age: 30,
+    phone: '123-456-7890',
+    userHandle: 'johnDoe123',
+    gender: 'male',
+    location: {
+      type: 'Point',
+      coordinates: [40.7128, -74.006],
+    },
+    deviceId: 'device12345',
+    deviceToken: 'deviceToken12345',
+    role: [UserRole.USER],
+    leadPosition: 'Tech Lead',
+    applicationStatus: ApplicationStatus.PENDING,
+    nextApplicationTime: new Date(),
+    joinMethod: RegistrationMethod.SIGN_UP,
+    status: UserStatus.ACTIVE,
+    emailVerification: true,
+    pendingInvitation: false,
+    socials: {
+      phoneNumber: '24242424',
+      email: 'balbal',
+    },
+    nextVerificationRequestDate: new Date(),
+    ...overrides, // Overrides allow customization of the mock
+  } as UserDocument;
+};
 
 describe('UsersAdminController', () => {
   let controller: UsersController;
@@ -38,7 +89,7 @@ describe('UsersAdminController', () => {
       const userMock = createUserMock({
         email: 'test@example.com',
       });
-      // redirecting the dbquery to user the userMock
+      // redirecting the dbquery to use the userMock
       jest.spyOn(usersService, 'findByEmail').mockResolvedValue(userMock);
       const result = await adminController.findByUsername(requestMock.email);
 
@@ -53,45 +104,217 @@ describe('UsersAdminController', () => {
       expect(usersService.findByEmail).toHaveBeenCalledWith('test@example.com');
     });
   });
-});
 
-/*
-'*generates a mock user object that can be used across multiple tests
- *choose which part you want to override using createMock({parameter:new_value})
-*/
-const createUserMock = (overrides: Partial<User> = {}): User => {
-  return {
-    firstName: 'John',
-    lastName: 'Doe',
-    email: 'john.doe@example.com',
-    password: 'hashedpassword123',
-    profileSummary: 'Experienced software engineer',
-    jobTitle: 'Senior Developer',
-    currentCompany: 'TechCorp',
-    photo: 'profilephoto.jpg',
-    age: 30,
-    phone: '123-456-7890',
-    userHandle: 'johnDoe123',
-    gender: 'male',
-    location: {
-      type: 'Point',
-      coordinates: [40.7128, -74.006],
-    },
-    deviceId: 'device12345',
-    deviceToken: 'deviceToken12345',
-    role: [UserRole.USER],
-    leadPosition: 'Tech Lead',
-    applicationStatus: ApplicationStatus.PENDING,
-    nextApplicationTime: new Date(),
-    joinMethod: RegistrationMethod.SIGN_UP,
-    status: UserStatus.ACTIVE,
-    emailVerification: true,
-    pendingInvitation: false,
-    socials: {
-      phoneNumber: '24242424',
-      email: 'balbal',
-    },
-    nextVerificationRequestDate: new Date(),
-    ...overrides, // Overrides will allow you to customize the mock as needed
-  };
-};
+  describe('findAll', () => {
+    // clearing mock data between test to prevent data leaking
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    // create a diffenent request for api
+    const createRequestMock = (query = {}): ApiReq => ({
+      query: {
+        page: '1',
+        limit: '10',
+        order: 'DESC',
+        ...query,
+      },
+    });
+
+    it('should return paginated users with default parameters', async () => {
+      // Create mock request
+      const requestMock = createRequestMock();
+
+      // mongoose record style and spreads a user data onto it
+      const mockRecords = [
+        {
+          _id: new Types.ObjectId(),
+          ...createUserMock({ email: 'user1@example.com' }),
+        },
+        {
+          _id: new Types.ObjectId(),
+          ...createUserMock({ email: 'user2@example.com' }),
+        },
+      ];
+      // expected findAll service response
+      const mockPaginatedResponse: IPageable<UserDocument> = {
+        results: mockRecords,
+        totalRecords: 2,
+        perPageLimit: 10,
+        totalPages: 1,
+        currentPage: 1,
+        previousPage: null,
+        nextPage: null,
+      };
+      jest
+        .spyOn(usersService, 'findAll')
+        .mockResolvedValue(mockPaginatedResponse);
+      const result = await adminController.findAll(requestMock);
+      expect(result).toEqual(mockPaginatedResponse);
+      expect(usersService.findAll).toHaveBeenCalledWith(requestMock);
+    });
+    it('should handle filtering by user status', async () => {
+      const requestMock = createRequestMock({
+        userByStatuses: `${UserStatus.ACTIVE},${UserStatus.DISABLE}`,
+      });
+
+      const mockRecords = [
+        {
+          _id: new Types.ObjectId(),
+          ...createUserMock({
+            email: 'active@example.com',
+            status: UserStatus.ACTIVE,
+          }),
+        },
+      ];
+
+      const mockPaginatedResponse: IPageable<UserDocument> = {
+        results: mockRecords,
+        totalRecords: 1,
+        perPageLimit: 10,
+        totalPages: 1,
+        currentPage: 1,
+        previousPage: null,
+        nextPage: null,
+      };
+
+      jest
+        .spyOn(usersService, 'findAll')
+        .mockResolvedValue(mockPaginatedResponse);
+
+      const result = await adminController.findAll(requestMock);
+
+      expect(result).toEqual(mockPaginatedResponse);
+      expect(usersService.findAll).toHaveBeenCalledWith(requestMock);
+    });
+
+    it('should handle filtering by user roles', async () => {
+      const requestMock = createRequestMock({
+        userByRoles: `${UserRole.USER},${UserRole.ADMIN}`,
+      });
+
+      const mockRecords = [
+        {
+          _id: new Types.ObjectId(),
+          ...createUserMock({
+            email: 'admin@example.com',
+            role: [UserRole.ADMIN],
+          }),
+        },
+      ];
+
+      const mockPaginatedResponse: IPageable<UserDocument> = {
+        results: mockRecords,
+        totalRecords: 1,
+        perPageLimit: 10,
+        totalPages: 1,
+        currentPage: 1,
+        previousPage: null,
+        nextPage: null,
+      };
+
+      jest
+        .spyOn(usersService, 'findAll')
+        .mockResolvedValue(mockPaginatedResponse);
+
+      const result = await adminController.findAll(requestMock);
+
+      expect(result).toEqual(mockPaginatedResponse);
+      expect(usersService.findAll).toHaveBeenCalledWith(requestMock);
+    });
+
+    it('should handle multiple filters combined', async () => {
+      const requestMock = createRequestMock({
+        userByStatuses: UserStatus.ACTIVE,
+        userByRoles: UserRole.USER,
+        userDateRange: '2023-01-01,2023-12-31',
+        page: '2',
+        limit: '5',
+        order: 'ASC',
+      });
+
+      const mockRecords = [
+        {
+          _id: new Types.ObjectId(),
+          ...createUserMock(),
+        },
+      ];
+
+      const mockPaginatedResponse: IPageable<UserDocument> = {
+        results: mockRecords,
+        totalRecords: 6,
+        perPageLimit: 5,
+        totalPages: 2,
+        currentPage: 2,
+        previousPage: 1,
+        nextPage: null,
+      };
+
+      jest
+        .spyOn(usersService, 'findAll')
+        .mockResolvedValue(mockPaginatedResponse);
+
+      const result = await adminController.findAll(requestMock);
+
+      expect(result).toEqual(mockPaginatedResponse);
+      expect(usersService.findAll).toHaveBeenCalledWith(requestMock);
+    });
+
+    it('should handle empty results', async () => {
+      const requestMock = createRequestMock({
+        userByStatuses: UserStatus.DEACTIVATED,
+      });
+
+      const mockPaginatedResponse: IPageable<UserDocument> = {
+        results: [],
+        totalRecords: 0,
+        perPageLimit: 10,
+        totalPages: 0,
+        currentPage: 1,
+        previousPage: null,
+        nextPage: null,
+      };
+
+      jest
+        .spyOn(usersService, 'findAll')
+        .mockResolvedValue(mockPaginatedResponse);
+
+      const result = await adminController.findAll(requestMock);
+
+      expect(result).toEqual(mockPaginatedResponse);
+      expect(usersService.findAll).toHaveBeenCalledWith(requestMock);
+    });
+  });
+  describe('change Password', () => {
+    const mockUser = createUserMock({ _id: new Types.ObjectId() });
+    const mockRequest = {
+      user: {
+        _id: mockUser._id,
+        email: mockUser.email,
+        role: [UserRole.ADMIN],
+      },
+    };
+    const UserChangePasswordDto = {
+      oldPassword: 'oldPassword@123',
+      newPassword: 'newPassword@123',
+      confirmPassword: 'newPassword@123',
+    };
+
+    it('should change the user password', async () => {
+      const updatedUser = { ...mockUser, password: 'newHashedPassword' };
+      jest.spyOn(usersService, 'changePassword').mockResolvedValue(updatedUser);
+      const result = await adminController.changePassword(
+        mockRequest,
+        mockUser._id.toString(),
+        UserChangePasswordDto,
+      );
+      expect(result).toEqual(updatedUser);
+      expect(usersService.changePassword).toHaveBeenLastCalledWith(
+        mockRequest,
+        mockUser._id.toString(),
+        UserChangePasswordDto,
+        true,
+      );
+    });
+  });
+});
diff --git a/test/jest-e2e.json b/test/jest-e2e.json
index 1580f5b..867dbd1 100644
--- a/test/jest-e2e.json
+++ b/test/jest-e2e.json
@@ -7,6 +7,7 @@
     "^.+\\.(t|j)s$": "ts-jest"
   },
   "moduleNameMapper": {
-    "^src/(.*)$": "<rootDir>/$1"
+    "^src/(.*)$": "<rootDir>/$1",
+    "testTimeout": 10000
   }
 }