Add Unit Tests for Backend Services and Controllers

.vscode/extensions.json

@@ -2,6 +2,7 @@
   "recommendations": [
     "dbaeumer.vscode-eslint",
     "esbenp.prettier-vscode",
-    "unifiedjs.vscode-mdx"
+    "unifiedjs.vscode-mdx",
+    "orta.vscode-jest"
   ]
 }

NoteBlockWorld.code-workspace

@@ -0,0 +1,24 @@
+{
+  "folders": [
+    {
+      "path": ".",
+      "name": "Root"
+    },
+    {
+      "path": "./server",
+      "name": "Backend"
+    },
+    {
+      "path": "./shared",
+      "name": "Shared"
+    },
+    {
+      "path": "./web",
+      "name": "Frontend"
+    }
+  ],
+  "settings": {
+    "mdx.server.enable": true,
+    "jest.disabledWorkspaceFolders": ["Root", "Frontend"]
+  }
+}

server/jest.config.js

@@ -0,0 +1,35 @@
+module.exports = {
+  moduleFileExtensions: ['js', 'json', 'ts'],
+  rootDir: '.',
+  testRegex: '.*\\.spec\\.ts$',
+  transform: {
+    '^.+\\.(t|j)s$': [
+      'ts-jest',
+      {
+        tsconfig: '<rootDir>/tsconfig.json',
+        ignoreCodes: ['TS151001'],
+      },
+    ],
+  },
+  collectCoverageFrom: ['**/*.(t|j)s'],
+  coverageDirectory: './coverage',
+  testEnvironment: 'node',
+  moduleNameMapper: {
+    '^@shared/(.*)$': '<rootDir>/../shared/$1',
+    '^@server/(.*)$': '<rootDir>/src/$1',
+  },
+  testPathIgnorePatterns: [
+    '<rootDir>/node_modules/',
+    '<rootDir>/dist/',
+    '<rootDir>/coverage/',
+  ],
+  coveragePathIgnorePatterns: [
+    '<rootDir>/node_modules/',
+    '<rootDir>/coverage/',
+    '<rootDir>/dist/',
+    '<rootDir>/src/.*\\.module\\.ts$',
+    '<rootDir>/src/main.ts',
+    '.eslintrc.js',
+    'jest.config.js',
+  ],
+};

server/package.json

@@ -76,22 +76,5 @@
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.1.3"
-  },
-  "jest": {
-    "moduleFileExtensions": [
-      "js",
-      "json",
-      "ts"
-    ],
-    "rootDir": "src",
-    "testRegex": ".*\\.spec\\.ts$",
-    "transform": {
-      "^.+\\.(t|j)s$": "ts-jest"
-    },
-    "collectCoverageFrom": [
-      "**/*.(t|j)s"
-    ],
-    "coverageDirectory": "../coverage",
-    "testEnvironment": "node"
   }
 }

server/src/GetRequestUser.spec.ts

@@ -0,0 +1,42 @@
+import { ExecutionContext, HttpException, HttpStatus } from '@nestjs/common';
+
+import { GetRequestToken, validateUser } from './GetRequestUser';
+import { UserDocument } from './user/entity/user.entity';
+
+describe('GetRequestToken', () => {
+  it('should be a defined decorator', () => {
+    const mockExecutionContext = {
+      switchToHttp: jest.fn().mockReturnThis(),
+    } as unknown as ExecutionContext;
+
+    const result = GetRequestToken(null, mockExecutionContext);
+
+    expect(typeof result).toBe('function');
+  });
+});
+
+describe('validateUser', () => {
+  it('should return the user if the user exists', () => {
+    const mockUser = {
+      _id: 'test-id',
+      username: 'testuser',
+    } as unknown as UserDocument;
+
+    const result = validateUser(mockUser);
+
+    expect(result).toEqual(mockUser);
+  });
+
+  it('should throw an error if the user does not exist', () => {
+    expect(() => validateUser(null)).toThrowError(
+      new HttpException(
+        {
+          error: {
+            user: 'User not found',
+          },
+        },
+        HttpStatus.UNAUTHORIZED,
+      ),
+    );
+  });
+});

server/src/app.module.ts

@@ -24,10 +24,7 @@ import { UserModule } from './user/user.module';
       useFactory: (
         configService: ConfigService,
       ): MongooseModuleFactoryOptions => {
-        const url = configService.get<string>('MONGO_URL');
-        if (!url) {
-          throw new Error('Missing DB config');
-        }
+        const url = configService.getOrThrow<string>('MONGO_URL');
         Logger.debug(`Connecting to ${url}`);
 
         return {
@@ -39,8 +36,8 @@ import { UserModule } from './user/user.module';
     }),
     SongModule,
     UserModule,
-    AuthModule,
-    FileModule,
+    AuthModule.forRootAsync(),
+    FileModule.forRootAsync(),
     SongBrowserModule,
   ],
   controllers: [],

server/src/auth/auth.controller.spec.ts

@@ -0,0 +1,113 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { Request, Response } from 'express';
+
+import { AuthController } from './auth.controller';
+import { AuthService } from './auth.service';
+
+const mockAuthService = {
+  githubLogin: jest.fn(),
+  googleLogin: jest.fn(),
+  discordLogin: jest.fn(),
+  verifyToken: jest.fn(),
+};
+
+describe('AuthController', () => {
+  let controller: AuthController;
+  let authService: AuthService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [AuthController],
+      providers: [
+        {
+          provide: AuthService,
+          useValue: mockAuthService,
+        },
+      ],
+    }).compile();
+
+    controller = module.get<AuthController>(AuthController);
+    authService = module.get<AuthService>(AuthService);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  describe('githubRedirect', () => {
+    it('should call AuthService.githubLogin', async () => {
+      const req = {} as Request;
+      const res = {} as Response;
+
+      await controller.githubRedirect(req, res);
+
+      expect(authService.githubLogin).toHaveBeenCalledWith(req, res);
+    });
+
+    it('should handle exceptions', async () => {
+      const req = {} as Request;
+      const res = {} as Response;
+      const error = new Error('Test error');
+      (authService.githubLogin as jest.Mock).mockRejectedValueOnce(error);
+
+      await expect(controller.githubRedirect(req, res)).rejects.toThrow(
+        'Test error',
+      );
+    });
+  });
+
+  describe('googleRedirect', () => {
+    it('should call AuthService.googleLogin', async () => {
+      const req = {} as Request;
+      const res = {} as Response;
+
+      await controller.googleRedirect(req, res);
+
+      expect(authService.googleLogin).toHaveBeenCalledWith(req, res);
+    });
+
+    it('should handle exceptions', async () => {
+      const req = {} as Request;
+      const res = {} as Response;
+      const error = new Error('Test error');
+      (authService.googleLogin as jest.Mock).mockRejectedValueOnce(error);
+
+      await expect(controller.googleRedirect(req, res)).rejects.toThrow(
+        'Test error',
+      );
+    });
+  });
+
+  describe('discordRedirect', () => {
+    it('should call AuthService.discordLogin', async () => {
+      const req = {} as Request;
+      const res = {} as Response;
+
+      await controller.discordRedirect(req, res);
+
+      expect(authService.discordLogin).toHaveBeenCalledWith(req, res);
+    });
+
+    it('should handle exceptions', async () => {
+      const req = {} as Request;
+      const res = {} as Response;
+      const error = new Error('Test error');
+      (authService.discordLogin as jest.Mock).mockRejectedValueOnce(error);
+
+      await expect(controller.discordRedirect(req, res)).rejects.toThrow(
+        'Test error',
+      );
+    });
+  });
+
+  describe('verify', () => {
+    it('should call AuthService.verifyToken', async () => {
+      const req = {} as Request;
+      const res = {} as Response;
+
+      await controller.verify(req, res);
+
+      expect(authService.verifyToken).toHaveBeenCalledWith(req, res);
+    });
+  });
+});