Add Auth module tests

Author: bnopne

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

@@ -0,0 +1,78 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UnauthorizedException } from '@nestjs/common';
+import { type PoolClient } from 'pg';
+
+import { PgPoolService } from 'src/modules/pg-pool/pg-pool.service';
+
+import { AuthController } from './auth.controller';
+import { SignInWithPasscodeBody, SignInWithPasscodeResponse } from './dto';
+import { AuthService } from './auth.service';
+
+describe('Test AuthController', () => {
+  const VALID_PASSCODE = 'valid';
+  const INVALID_PASSCODE = 'invalid';
+  const TOKEN = 'token';
+
+  const MOCK_POOL_CLIENT = {} as PoolClient;
+
+  let testModule: TestingModule;
+  let controller: AuthController;
+
+  beforeEach(async () => {
+    testModule = await Test.createTestingModule({
+      controllers: [AuthController],
+    })
+      .useMocker((token) => {
+        switch (token) {
+          case AuthService:
+            return {
+              signInWithAdminPasscode: async (
+                client: unknown,
+                passcode: string,
+              ) => {
+                if (passcode === VALID_PASSCODE) {
+                  return TOKEN;
+                }
+
+                throw new UnauthorizedException();
+              },
+            };
+          case PgPoolService:
+            return {
+              runInTransaction: <R>(
+                func: (client: PoolClient) => Promise<R>,
+              ) => {
+                return func(MOCK_POOL_CLIENT);
+              },
+            };
+        }
+      })
+      .compile();
+
+    controller = testModule.get(AuthController);
+  });
+
+  it('throws exception if invalid passcode is provided', () => {
+    const body = new SignInWithPasscodeBody();
+    body.passcode = INVALID_PASSCODE;
+    expect(controller.signInWithPasscode(body)).rejects.toBeInstanceOf(
+      UnauthorizedException,
+    );
+  });
+
+  it('throws exception if invalid request provided', () => {
+    expect(
+      controller.signInWithPasscode({
+        foo: 'bar',
+      } as unknown as SignInWithPasscodeBody),
+    ).rejects.toBeInstanceOf(UnauthorizedException);
+  });
+
+  it('returns response if valid passcode is provided', () => {
+    const body = new SignInWithPasscodeBody();
+    body.passcode = VALID_PASSCODE;
+    expect(controller.signInWithPasscode(body)).resolves.toStrictEqual(
+      new SignInWithPasscodeResponse(TOKEN),
+    );
+  });
+});

server/src/modules/auth/auth.guard.spec.ts

@@ -0,0 +1,59 @@
+import { type ExecutionContext, UnauthorizedException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+
+import { AuthGuard } from './auth.guard';
+import { type JWTPayload } from './types';
+
+const VALID_TOKEN = 'VALID';
+const INVALID_TOKEN = 'INVALID';
+const JWT_PAYLOAD: JWTPayload = {
+  userId: '1',
+};
+
+const getMockExecutionContext = (token?: string) => {
+  const request = {
+    headers: {
+      authorization: token ? `Bearer ${token}` : undefined,
+    },
+  };
+
+  return {
+    switchToHttp: () => ({
+      getRequest: () => request,
+    }),
+  } as ExecutionContext;
+};
+
+describe('Test AuthGuard', () => {
+  let guard: AuthGuard;
+
+  beforeEach(() => {
+    guard = new AuthGuard({
+      verifyAsync: async (token: string) => {
+        if (token === VALID_TOKEN) {
+          return JWT_PAYLOAD;
+        } else {
+          throw new UnauthorizedException();
+        }
+      },
+    } as JwtService);
+  });
+
+  it('throws error if no token provided in request', async () => {
+    await expect(
+      guard.canActivate(getMockExecutionContext()),
+    ).rejects.toBeInstanceOf(UnauthorizedException);
+  });
+
+  it('throws error if invalid token provided in request', async () => {
+    await expect(
+      guard.canActivate(getMockExecutionContext(INVALID_TOKEN)),
+    ).rejects.toBeInstanceOf(UnauthorizedException);
+  });
+
+  it('returns true if valid token provided in request, sets payload to request object', async () => {
+    const ctx = getMockExecutionContext(VALID_TOKEN);
+    await expect(guard.canActivate(ctx)).resolves.toBe(true);
+    expect(ctx.switchToHttp().getRequest().userId).toBe(JWT_PAYLOAD.userId);
+  });
+});

server/src/modules/auth/auth.service.spec.ts

@@ -0,0 +1,102 @@
+import { UnauthorizedException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { Test, TestingModule } from '@nestjs/testing';
+import { type PoolClient } from 'pg';
+
+import { AdminPasscodeService } from 'src/modules/admin-passcode/admin-passcode.service';
+
+import { AuthService } from './auth.service';
+import { type JWTPayload } from './types';
+
+const MOCK_POOL_CLIENT = {} as PoolClient;
+
+describe('Test AuthService', () => {
+  describe('Test signInWithAdminPasscode', () => {
+    const VALID_PASSCODE = 'pass';
+    const INVALID_PASSCODE = 'no pass';
+    const USER_ID = '1';
+
+    let testModule: TestingModule;
+    let service: AuthService;
+
+    beforeEach(async () => {
+      testModule = await Test.createTestingModule({
+        providers: [AuthService],
+      })
+        .useMocker((token) => {
+          switch (token) {
+            case JwtService:
+              return {
+                signAsync: async (payload: JWTPayload) => payload,
+              };
+            case AdminPasscodeService:
+              return {
+                getUserId: async (client: unknown, passcode: string) =>
+                  passcode === VALID_PASSCODE ? USER_ID : undefined,
+              };
+          }
+        })
+        .compile();
+
+      service = testModule.get(AuthService);
+    });
+
+    it('throws exception if invalid passcode provided', () => {
+      expect(
+        service.signInWithAdminPasscode(MOCK_POOL_CLIENT, INVALID_PASSCODE),
+      ).rejects.toBeInstanceOf(UnauthorizedException);
+    });
+
+    it('returns payload if valid passcode provided', () => {
+      expect(
+        service.signInWithAdminPasscode(MOCK_POOL_CLIENT, VALID_PASSCODE),
+      ).resolves.toBe(JSON.stringify({ userId: USER_ID }));
+    });
+  });
+
+  describe('Test verifyJwt', () => {
+    const VALID_TOKEN = 'VALID';
+    const INVALID_TOKEN = 'INVALID';
+    const JWT_PAYLOAD: JWTPayload = {
+      userId: '1',
+    };
+
+    let testModule: TestingModule;
+    let service: AuthService;
+
+    beforeEach(async () => {
+      testModule = await Test.createTestingModule({
+        providers: [AuthService],
+      })
+        .useMocker((token) => {
+          switch (token) {
+            case JwtService:
+              return {
+                verifyAsync: async (token: string): Promise<JWTPayload> => {
+                  if (token === VALID_TOKEN) {
+                    return JWT_PAYLOAD;
+                  } else {
+                    throw new UnauthorizedException();
+                  }
+                },
+              };
+            case AdminPasscodeService:
+              return {};
+          }
+        })
+        .compile();
+
+      service = testModule.get(AuthService);
+    });
+
+    it('throws exception if invalid token is provided', () => {
+      expect(service.verifyJwt(INVALID_TOKEN)).rejects.toBeInstanceOf(
+        UnauthorizedException,
+      );
+    });
+
+    it('returns payload if valid token is provided', () => {
+      expect(service.verifyJwt(VALID_TOKEN)).resolves.toBe(JWT_PAYLOAD);
+    });
+  });
+});