ChatGPTを使ったクリーンなプログラミングを実践してみた

• user.entity.ts

user.entity.ts
typescript
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  username: string;

  @Column()
  password: string;
}

 

• authentication.service.ts

typescript
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import * as bcrypt from 'bcrypt';
import { User } from './user.entity';

@Injectable()
export class AuthenticationService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
  ) {}

  async validateUser(username: string, password: string): Promise<boolean> {
    const user = await this.userRepository.findOne({ username });

    if (!user) {
      return false;
    }

    const isMatch = await bcrypt.compare(password, user.password);
    return isMatch;
  }
}

 

• authentication.service.spec.ts

typescript
import { Test, TestingModule } from '@nestjs/testing';
import { AuthenticationService } from './authentication.service';
import { getRepositoryToken } from '@nestjs/typeorm';
import { User } from './user.entity';
import * as bcrypt from 'bcrypt';

describe('AuthenticationService', () => {
  let service: AuthenticationService;
  let mockUserRepository;

  beforeEach(async () => {
    mockUserRepository = {
      findOne: jest.fn(),
    };

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        AuthenticationService,
        {
          provide: getRepositoryToken(User),
          useValue: mockUserRepository,
        },
      ],
    }).compile();

    service = module.get<AuthenticationService>(AuthenticationService);
  });

  it('should return false if username is not found', async () => {
    mockUserRepository.findOne.mockReturnValue(null);
    expect(await service.validateUser('unknown', 'password')).toBe(false);
  });

  it('should return false if password is incorrect', async () => {
    const hashedPassword = await bcrypt.hash('correct_password', 5);
    mockUserRepository.findOne.mockReturnValue({ username: 'known', password: hashedPassword });

    expect(await service.validateUser('known', 'wrong_password')).toBe(false);
  });

  it('should return true if username and password are correct', async () => {
    const hashedPassword = await bcrypt.hash('correct_password', 5);
    mockUserRepository.findOne.mockReturnValue({ username: 'known', password: hashedPassword });

    expect(await service.validateUser('known', 'correct_password')).toBe(true);
  });
});

 

• user.controller.ts

typescript
// user.controller.ts
import { Controller, Post, Body, HttpException, HttpStatus } from '@nestjs/common';
import { AuthenticationService } from './authentication.service';

@Controller('user')
export class UserController {
  constructor(private readonly authService: AuthenticationService) {}

  @Post('login')
  async login(@Body('username') username: string, @Body('password') password: string) {
    const isValid = await this.authService.validateUser(username, password);
    if (!isValid) {
      throw new HttpException('Unauthorized', HttpStatus.UNAUTHORIZED);
    }
    return { status: 'OK' };
  }
}

 

typescript
// authentication.service.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { AuthenticationService } from './authentication.service';
import { getRepositoryToken } from '@nestjs/typeorm';
import { User } from './user.entity';
import * as bcrypt from 'bcrypt';

describe('AuthenticationService', () => {
  let service: AuthenticationService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        AuthenticationService,
        {
          provide: getRepositoryToken(User),
          useValue: {
            findOne: jest.fn().mockImplementation((username) => {
              if (username.username === 'test') {
                return { username: 'test', password: bcrypt.hashSync('password', 5) };
              }
              return null;
            }),
          },
        },
      ],
    }).compile();

    service = module.get<AuthenticationService>(AuthenticationService);
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  it('should return false if username is not found', async () => {
    expect(await service.validateUser('unknown', 'password')).toBe(false);
  });

  it('should return false if password is incorrect', async () => {
    expect(await service.validateUser('test', 'wrongpassword')).toBe(false);
  });

  it('should return true if username and password are correct', async () => {
    expect(await service.validateUser('test', 'password')).toBe(true);
  });
});

 

// user.controller.spec.ts
import { Test, TestingModule } from '@nestjs/testing';
import { UserController } from './user.controller';
import { AuthenticationService } from './authentication.service';
import { HttpException, HttpStatus } from '@nestjs/common';

describe('UserController', () => {
  let controller: UserController;
  let authService: AuthenticationService;

  beforeEach(async () => {
    authService = { validateUser: jest.fn() } as any;
    const module: TestingModule = await Test.createTestingModule({
      controllers: [UserController],
      providers: [{ provide: AuthenticationService, useValue: authService }],
    }).compile();

    controller = module.get<UserController>(UserController);
  });

  it('should be defined', () => {
    expect(controller).toBeDefined();
  });

  it('should return 401 if validation fails', async () => {
    authService.validateUser.mockResolvedValue(false);
    await expect(controller.login('test', 'wrongpassword')).rejects.toThrow(
      new HttpException('Unauthorized', HttpStatus.UNAUTHORIZED),
    );
  });

  it('should return OK if validation succeeds', async () => {
    authService.validateUser.mockResolvedValue(true);
    await expect(controller.login('test', 'password')).resolves.toEqual({ status: 'OK' });
  });
});

openapi: "3.0.0"
info:
  version: "1.0.0"
  title: "Authentication API"
  description: "API for authenticating users"
paths:
  /user/login:
    post:
      summary: "Login a user"
      description: "This can only be done by the logged in user."
      operationId: "loginUser"
      requestBody:
        description: "Created user object"
        required: true
        content:
          application/json:
            schema:
              $ref: "#/components/schemas/Login"
      responses:
        "200":
          description: "successful operation"
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ApiResponse"
        "401":
          description: "Unauthorized"
          content: {}

components:
  schemas:
    Login:
      type: "object"
      properties:
        username:
          type: "string"
        password:
          type: "string"
    ApiResponse:
      type: "object"
      properties:
        status:
          type: "string"

・user.controller.ts

typescript
import { Controller, Post, Body, HttpException, HttpStatus, UsePipes, ValidationPipe } from '@nestjs/common';
import { AuthenticationService } from './authentication.service';
import { LoginDto } from './login.dto';

@Controller('user')
export class UserController {
 constructor(private readonly authService: AuthenticationService) {}

 @UsePipes(new ValidationPipe())
 @Post('login')
 async login(@Body() loginDto: LoginDto) {
   const { username, password } = loginDto;
   const isValid = await this.authService.validateUser(username, password);
   if (!isValid) {
     throw new HttpException('Unauthorized', HttpStatus.UNAUTHORIZED);
   }
   return { status: 'OK' };
 }
}

 
・login.dto.ts

typescript
import { IsEmail, IsNotEmpty } from 'class-validator';

export class LoginDto {
  @IsEmail()
  username: string;

  @IsNotEmpty()
  password: string;
}