1yongs_.log

NestJS TDD (입고 알림) - 6. Result

Mon, 20 Sep 2021 09:12:53 GMT

What I Do?

Used Skill Set

NestJS, Jest, Scheduler, slack-webhook, docker

Jest 테스트 툴로 NestJS의 "품절난 모니터의 입고 알림" 애플리케이션 구현을 테스트 주도 개발론을 도입하여 개발하였다.

최근 프로그래머스:백엔드 웹 데브코스 교육과정을 들으면서 OOP, TDD 등 다양한 개념들을 접하면서 직장에서 NestJS를 사용하면서 그냥 넘겨 짚었던 개념들을 사이드 프로젝트를 만들면서 녹여내고 싶었다.

마침 모니터가 필요했는데 가성비가 좋은 V28UE 모니터를 보게 되었고 구입할려고 했는데 매일 재고가 없다고 하여 "재고 입고 알림 애플리케이션을 만들면 좋겠다."고 생각했다. 그리고 여기에 TDD를 곁들인...

Jest

실전 자바 소프트웨어 개발 책을 읽고 OOP 설계 5대 원칙, TDD 등 JAVA 뿐 만 아니라 다른 언어에서도 사용할 수 있는 개념들을 배웠고 이를 NestJS에 녹여보고자 하였다.

책에서 소개된 Given-When-Then 패턴을 적용하여 Test Code 스타일을 구현하였다.

Given 테스트에서 구체화하고자 하는 행동을 시작하기 전에 테스트 상태를 설명하는 부분
When 구체화하고자 하는 그 행동
Then 어떤 특정한 행동 때문에 발생할거라고 예상되는 변화에 대한 설명

(참고: Given-When-Then 패턴)

개발하면서 다양한 모듈을 개발하고 이를 프레임워크에 Dependency Injection 하게된다. 이제 각 모듈들에 대해 유닛 테스트를 해야하는데 여러 모듈들이 의존성에 의해 연결되어 있어서 이를 모킹해야하는데 이 부분이 많이 골칫거리였다.

하지만 HotHandCoding님의 Nest + Jest unit test 글들을 참고하게 되었고 많은 고민들을 해소할 수 있게 되었다. 모듈을 Mocking을 했는데 모듈에 대한 메서드를 spyOn하는 방법이나, TestModule에서 원래의 모듈을 주입 대신 목 객체 모듈을 주입하는 방법 등 많은 부분을 배웠다. (감사합니다)

Scheduler

이제 요청들을 매 5초 마다 실행하는 Scheduler를 실행해야 하는데, 이를 NestJS의 Cron Job을 통해서 해결 할 수 있었다.

예전에 회사에서 동료분께서 Batch 작업을 위해 Cron Job을 사용하신 것을 보았는데 이번 기회에 사용하는 기회가 와서 적용할 수 있었다.

단순히 스케쥴링 작업 뿐만아니라 Dynamic Scheduler를 통해 스케쥴러를 runtime에 등록하거나 해제할 수 있다는 점도 굉장히 인상적이었다.

Docker

도커는 책을 정독을 해야 할 것 같다. ~~(그만 구글링 하고 싶다.)~~

MacOS에서 개발한 NestJS Application을 다른 환경 (ubuntu, window) 서버에 올려야 하므로 Docker Image로 빌드해야 하는 작업 필수적이라고 생각하였다.

그래서 DockerFile을 작성하고, Docker 작업(명령어 등)을 더 손 쉽게 쓸 수 있도록 docker-compose 파일을 작성하여 git repository에 같이 포함하여 올렸다.

그래서 개발한 어플리케이션은 나의 노트북에서 돌아가지 않고, 집에 있는 데스크탑(windows)에서 잘 돌아갈 수 있게 되었다.

Result

(예정)

느낀점

개발은 하고싶은 것을 하고 만들고 싶은 것을 개발하는게 정말 매력적이라고 생각한다.

아직 못 한 부분들이 많다. 교육과정의 과제들과 회사 업무들이 거의 정리되는 시점에 다시 적용해 보도록 해야겠다.

e2e test
CI / CD
domain 기능 확장 (다른 품절 제품 얻어 오는 기능)
예외 처리

NestJS TDD (입고 알림) - 4. Scheduler

Mon, 20 Sep 2021 08:39:34 GMT

5초마다 재고 상태를 확인해주는 스케쥴링을 구해봅시다.

4-1. Setting Up Task Scheduler

우선 필요한 패키지를 설치 합시다.

> npm install --save @nestjs/schedule
> npm install --save-dev @types/cron

참고

NestJS Docs - Task Scheduling

4-2. Scheduler

매 5초마다 request를 요청하는 scheduler를 만든다. ~~(넘 심한가...?)~~

@Injectable()
export class TaskSchedulerService {
  private static readonly logger = new Logger(TaskSchedulerService.name);

  constructor(
    private readonly watcherService: WatcherService,
    private readonly schedulerRegistry: SchedulerRegistry,
  ) {}

  @Cron(CronExpression.EVERY_5_SECONDS, {
    name: 'V28UE_WATCHING',
  })
  async handleWatchingStock() {
    const requestUrl =
      'https://www.jooyonshop.co.kr/goods/goods_view.php?goodsNo=1000000165';
    // TaskSchedulerService.logger.debug('아이고난!');
    const resultRequest = await this.watcherService.getHttpRequest(requestUrl);
    const isSoldOut =
      this.watcherService.parseHtmlAndCheckIsSoldOut(resultRequest);

    if (!isSoldOut) {
      const job = this.schedulerRegistry.getCronJob('V28UE_WATCHING');
      job.stop();
      TaskSchedulerService.logger.debug('떳따!');
      this.watcherService.notify({ text: 'Buy It! Hurry Up!' });
    } else {
      TaskSchedulerService.logger.debug('아직 안떴따');
    }
  }
}

참고

NestJS Docs - Scheduler

NestJS TDD (입고 알림) - 5. Run application on Docker

Mon, 20 Sep 2021 08:39:09 GMT

5-1. Dockerfile 작성

dockerfile을 작성한다.

# First stage: build and test
FROM node:10-alpine as nodebuild    # Define the base image
WORKDIR /app                        # Define where we put the files
COPY . .                            # Copy all files from local host folder to image
RUN npm install && \                # Install dependencies
    npm run build && \              # Build the solution
    npm run test && \               # Run the tests
    npm run coverage                # Report on coverage

# Second stage: assemble the runtime image
FROM node:10-alpine as noderun      # Define base image
WORKDIR /app                        # Define work directory
COPY --from=nodebuild /app/dist/src/ ./ # Copy binaries resulting from stage build
COPY package*.json ./               # Copy dependency registry
RUN npm install --only=prod         # Install only production dependencies
EXPOSE 8000
ENTRYPOINT node /app/index.js       # Define how to start the app.

5-2. image build

test를 돌릴 image와 runtime 이미지를 따로 build한다.

> docker build . -t noti
> docker build --target nodebuild . -t noti-test:latest

5-3. run on container

그리고 test Image를 container로 실행하고, 결과 파일들을 받아온다.

> docker run --name noti-test noti-test
> docker cp noti-test:/app/coverage ./results

그리고 runtime image를 container로 실행한다.

> docker run -d --name noti-run noti

참고

Using Docker Multi-Stage Builds To Build And Test Applications

5-4. 이러한 도커 수행 과정을 docker-compose로 구성해보자.

version: '3.8'

services:
  test:
    container_name: noti-test
    image: noti-test:latest
    build:
      context: .
      target: nodebuild
      dockerfile: ./Dockerfile
  run:
    container_name: noti
    image: noti:latest
    build:
      context: .
      dockerfile: ./Dockerfile
    ports:
      - 3000:3000
    networks:
      - noti-network
    restart: unless-stopped

networks:
  noti-network:

실행은 background에서 하도록 하자.

> docker-compose up -d test
> docker-compose up -d run

궁금한 점

❓ 아니 그런데 test를 하고 test result를 복사하려는데 어떻게 자동화 하지..?

NestJS TDD (입고 알림) - 3. Slack Webhook 연동

Mon, 20 Sep 2021 08:31:00 GMT

재고가 들어 왔다고 알림을 줘야하는데 slack을 사용하여 채널에 등록된 사용자들에게 알려줍시다.

참고

NestJS sentry + slack error로그 수집

3-1. Setting Up

> npm i nestjs-slack-webhook
> npm i @slack/client @nestjs/config

SlackConfig 등록 (webhook)
- .env file 우선 환경 변수 파일을 만들어 발급받은 Slack wehook URL을 저장합니다.
```
SLACK_WEBHOOK_URL=https://hooks.slack.com/services/{비밀입니다!}
```
- src/config/slack.config.ts file NestJS에 주입할 Slack 전용 Config를 만들어 줍시다.

    import { registerAs } from '@nestjs/config';
    import { SlackOptions } from 'nestjs-slack-webhook';

    export default registerAs(
      'slack',
      (): SlackOptions => ({
        url: process.env.SLACK_WEBHOOK_URL,
      }),
    );

SlackModule Global로 등록
- src/app.module.ts file 환경변수를 등록하고, 설치한 SlackModule을 AppModule에 주입합니다.

    // ...
    import { ConfigModule, ConfigService } from '@nestjs/config';
    import slackConfig from './config/slack.config';
    import { WatcherModule } from './watcher/watcher.module';

    @Module({
      imports: [
        ConfigModule.forRoot({
          load: [slackConfig],
        }),
        SlackModule.forRootAsync({
          imports: [ConfigModule],
          inject: [ConfigService],
          useFactory: (config) => config.get('slack'),
        }),
        // ...
      ],
      // ...
    })
    export class AppModule {}

NotifyService 인자로 받은 메세지를 slack 채널에 발송하는 서비스를 만들어 줍니다.

  import { Injectable } from '@nestjs/common';
  import { IncomingWebhook, IncomingWebhookSendArguments } from '@slack/client';
  import { InjectSlack } from 'nestjs-slack-webhook';

  @Injectable()
  export class NotifyService {
    constructor(
      @InjectSlack()
      private readonly slack: IncomingWebhook,
    ) {}

    async notify(args: IncomingWebhookSendArguments) {
      return await this.slack.send(args);
    }
  }

3-2. WatcherService Test Code 작성

WatcherService에 NotifyService를 사용할 겁니다.

우선 NotifyService Mock 객체를 만들어 주자

const mockNotifyService = {
  notify: jest.fn(),
};

그리고 NotifyService를 TestModule에 주입합시다.


describe('WatcherService', () => {
  // ...
  let notifyService: NotifyService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      // ...
      providers: [
        // ...
        { provide: NotifyService, useValue: mockNotifyService }, // <- 주입
      ],
    }).compile();

test 코드를 작성할때 NotifyService를 jest의 spyOn 의 기능으로 메서드 구라를 칩시다.

또한 toHaveBeenCalledTimes, toHaveBeenCalledWith 메서드로 해당 method가 수행 되었는지 체크합시다.

describe('notify()', () => {
  it('should notify to slack', async () => {
    // given
    const requestNotify: IncomingWebhookSendArguments = {
      text: '(test-code) Buy It! Hurry Up!',
    };
    const resultNotify: IncomingWebhookResult = {
      text: 'ok',
    };
    jest
      .spyOn(notifyService, 'notify')
      .mockImplementation(
        async (arg: IncomingWebhookSendArguments) => resultNotify,
      );

    // when
    const result = await watcherService.notify(requestNotify);

    // then
    // expect(notifyService.notify).toHaveBeenCalledTimes(1);
    expect(result).toEqual(resultNotify);

    expect(notifyService.notify).toHaveBeenCalledTimes(1);
    expect(notifyService.notify).toHaveBeenCalledWith(requestNotify);
  });
});

3-3. WatcherService notify method 작성

테스트코드를 작동 할 수 있도록 소스 코드를 구현합니다.

@Injectable()
export class WatcherService {
  constructor(
    // ...
    private readonly notifyService: NotifyService,
  ) {}

  // ...

  async notify(requestNotifyToSlack: IncomingWebhookSendArguments) {
    return await this.notifyService.notify(requestNotifyToSlack);
  }
}

그럼 결과로 test를 통과하게 할 수 있게 되었습니다.

 PASS  src/crawler/watcher.service.spec.ts
  WatcherService
    ✓ should be defined (9 ms)
    getHTTPRequest()
      ✓ should request http given url (4 ms)
    parseHtmlAndCheckIsSoldOut()
      ✓ should parse Html And Check Is SoldOut (8 ms)
      ✓ should parse Html And Check Is SoldOut is false (4 ms)
    notify()
      ✓ should notify to slack (2 ms) # <====== 테스트 통과

참고

NotifyService에 대한 테스트코드도 미리 작성해야합니다.

NestJS TDD (입고 알림) - 2. 재고 상태 얻기

Mon, 20 Sep 2021 08:17:37 GMT

재고상태를 요청하는 watcher service를 만들어 봅시다.

2-1. watcher service를 만들어 줍니다.

> nest generate module watcher
> nest gnereate service watcher

그러면 watcher.service.spec.ts 파일이 만들어지는데 이 파일이 watcher.service.ts 에 대한 테스트를 담당합니다.

2-2. 우선 시나리오를 통해 `WatcherService` 에서 어떤 것을 해야할 지 파악해보죠.

Get URL HTTP Request
Parse HTML And Check Sold Out
Notify Slack Notifier

2-3. 그리고 Test 코드를 먼저 작성합시다. (TDD)

describe('getHTTPRequest()', () => {
  it.todo('should request http given url');
  it.todo('should throw exception cant request http'); // TODO:
});

describe('parseHtmlAndCheckIsSoldOut()', () => {
  it.todo('should parse Html And Check Is SoldOut');
  it.todo('should parse Html And Check Is SoldOut is false');
});

describe('notify()', () => {
  it.todo('should notify to SlackNotifer');
  it.todo('should throw exception cant notify slacknotifier'); // TODO:
});

하나 하나씩 Test들을 만들어 나갑시다.

2-4. Get URL HTTP Request

구현하기 전에 테스트 코드를 먼저 작성합시다.

it('should request http given url', async () => {
  // given
  const givenUrl = 'https://www.naver.com';

  // when
  const result = await watcherService.getHttpRequest(givenUrl);

  // then
  expect(result).not.toBeNull();
});

이렇게 작성하고 돌리시면 당연히 에러가 나겠죠. 당연합니다.

2-5. 이제 이 코드를 잘 돌아가게끔 수정합시다.

(요즘 axios는 rxjs를 써서 하는게 대세인가봅니다... 배울게 너무 많아 🥲)

// carwler.service.ts
async getHttpRequest(givenUrl: string) {
  const result = await firstValueFrom(
    this.httpService.get(givenUrl).pipe(map((response) => response.data)),
  );

  WatcherService.logger.log(result);
  return result;
}

2-6. 결과

그럼 결과 메세지로 이렇게 뜨고 passed 되었다고 합니다.

그럼 나머지 테스트 코드도 작성해봅시다. (링크)

NestJS TDD (입고 알림) - 1. Intro

Mon, 20 Sep 2021 08:11:15 GMT

최근 Java Spring 공부하다가 TDD, DI 등 NestJS를 하면서 얼렁뚱땅 넘어간 개념들을 다시 톺아보는 기회를 가졌었다. 최근에 테크 유튜브 잇섭님이 주연테크 V28UE 모니터 제품을 리뷰하면서 해당 제품이 한달 째 재고가 없다... 🥲

그래서 이번 기회에 NestJS에 Jest 테스트 도구로 테스트 주도 개발론을 직접 적용 해봄으로써 TDD에 한 걸음 더 다 가보자.

1. Overview

1-1. Architecture

1-2. FlowChart

CrawlingService
Scheduler
Slack Notifier
Run on Docker Container

1-3. Setting Up Package

우선 필요한 패키지들을 설치해줍니다.

NestJS Testing

> npm i --save-dev @nestjs/testing
> npm i --save @nestjs/axios

그리고 package.json에서 jest setting 에 verbose: true 를 줘야지 테스트 돌리고나서 좀 자세하게 나온다. ~~(어쩐지 console.log도 안보이더라...)~~ 😒 그리고 jest에서 rootDir를 src로 쓸려면 moduleNameMapper를 jest config에서 설정해줘야한다.

{
  // ...

  "jest": {
    // ...

    "verbose": true, // test 할 때 자세히 보기 설정
    "moduleNameMapper": {
      // rootDir를 src로 설정.
      "^src/(.*)$": "/$1"
    }
  }
}

NestJS Testing (Jest)

Mon, 05 Apr 2021 16:47:25 GMT

NestJS Testing

Index

Testing
Set up
- Create New Project
- Generate User Resource
- installation
- Setting up Project
Unit Testing
- install
- Setting Up Tests
- Unit Test
Result
- Test Coverage
End-to-End(e2e) Testing
- Setting Up

Test Code?

최근 급하게 만들어야할 프로젝트가 생기면서 테스트 코드를 만들지 않고 진행하였습니다. 급하게 마무리가 되고 여러 이슈들이 발생하여 코드를 고치는 순간 다른부분에서 에러가 발생합니다. 이럴 때 정말 난처합니다. 😭

Application이 점점 커져갈수록, 수정사항도 많아집니다. 하지만 수정으로이한 부작용(Side-effect)가 발생하죠. 만약 귀찮더라도 Test Code를 작성했더라면..? 에러가 어디에서 발생하는지 쉽게 Catch할 수 있을 것 이고, 디버깅 편리 및 유지보수가 편리해지는 등 코드에 대해 유연한 대처를 할 수 있습니다.

Test Code에 대한 자세한 내용은 설마 아직도 테스트 코드를 작성 안 하시나요? 글에서 참고하시면 좋을 것 같습니다.

이 프로젝트에서는 실제 Database와 연결하여 게시글 CRUD 작업을 해보는 Unit Test와 End-to-end Test를 진행해볼 예정입니다.

Set up

Create New Project

nest new nestjs-test

Generate User Resource

nest generate resource post 
? What transport layer do you use? REST API
? Would you like to generate CRUD entry points? Yes

installation

npm i @nestjs/config @nestjs/mapped-types @nestjs/typeorm typeorm mysql2 joi
npm i class-validator class-transformer

Setting Up Project

Main.ts

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
      forbidNonWhitelisted: true,
      transform: true,
    }),
  );

  await app.listen(3000);
}
bootstrap();

App Module

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: '.env',
      isGlobal: true,
      validationSchema: Joi.object({
        NODE_PORT: Joi.string().required(),
        MYSQL_HOST: Joi.string().required(),
        MYSQL_PORT: Joi.string().required(),
        MYSQL_USERNAME: Joi.string().required(),
        MYSQL_PASSWORD: Joi.string().required(),
        MYSQL_DATABASE: Joi.string().required(),
      }),
    }),
    TypeOrmModule.forRoot({
      type: 'mysql',
      host: process.env.MYSQL_HOST,
      port: +process.env.MYSQL_PORT,
      username: process.env.MYSQL_USERNAME,
      password: process.env.MYSQL_PASSWORD,
      database: process.env.MYSQL_DATABASE,
      synchronize: true,
      logging: true,
      entities: [Posts],
      charset: 'utf8mb4_unicode_ci',
      timezone: '+09:00',
    }),
    PostModule,
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

Post Entity

@Entity({ name: 'post' })
export class Post {
  @PrimaryGeneratedColumn('uuid')
  id: string;

  @Column()
  title: string;

  @Column()
  contents: string;

  @CreateDateColumn()
  createdAt: Date;

  @UpdateDateColumn()
  updatedAt: Date;

  @DeleteDateColumn()
  deletedAt: Date;

  @VersionColumn()
  version: number;
}

Post Module

@Module({
  imports: [TypeOrmModule.forFeature([Posts])],
  controllers: [PostController],
  providers: [PostService],
})
export class PostModule {}

Post Controller

@Controller('post')
export class PostController {
  constructor(private readonly postService: PostService) {}

  @Post()
  create(@Body() createPostDto: CreatePostDto) {
    return this.postService.create(createPostDto);
  }

  @Get()
  findAll() {
    return this.postService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.postService.findOne(id);
  }

  @Put(':id')
  update(@Param('id') id: string, @Body() updatePostDto: UpdatePostDto) {
    return this.postService.update(id, updatePostDto);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.postService.remove(id);
  }
}

Post Service

@Injectable()
export class PostService {
  private static readonly logger = new Logger(PostService.name);

  constructor(
    @InjectRepository(Posts)
    private readonly postRepository: Repository,
  ) {}

  async create(createPostDto: CreatePostDto): Promise {
    try {
      const result = await this.postRepository.save(createPostDto);
      PostService.logger.debug(result);
      return result;
    } catch (error) {
      PostService.logger.debug(error);
      throw error;
    }
  }

  async findAll(): Promise {
    try {
      const posts = await this.postRepository.find();
      PostService.logger.debug(posts);
      return posts;
    } catch (error) {
      PostService.logger.debug(error);
      throw error;
    }
  }

  async findOne(id: string): Promise {
    try {
      const post = await this.postRepository.findOne({
        id,
      });
      PostService.logger.debug(post);
      return post;
    } catch (error) {
      PostService.logger.debug(error);
      throw error;
    }
  }

  async update(id: string, updatePostDto: UpdatePostDto) {
    try {
      const post = await this.postRepository.findOne({
        id,
      });
      if (!post) {
        throw new EntityNotFoundError(Posts, id);
      }
      PostService.logger.debug(post);
      const result = await this.postRepository.save({
        ...post,
        ...updatePostDto,
      });
      return result;
    } catch (error) {
      PostService.logger.debug(error);
      throw error;
    }
  }

  async remove(id: string) {
    try {
      const post = await this.postRepository.findOne({
        id,
      });
      if (!post) {
        throw new EntityNotFoundError(Posts, id);
      }
      PostService.logger.debug(post);
      const result = await this.postRepository.softDelete({
        id,
      });
      return result;
    } catch (error) {
      PostService.logger.debug(error);
      throw error;
    }
  }
}

Unit Testing

install

Install Jest Testing Tool package.

npm i --save-dev @nestjs/testing

rm ./src/post/post.controller.spec.ts    // controller test는 나중에 진행하기 위함합니다.

Setting Up Tests

NestJS의 Testing Tool은 Jest 입니다. 기본적으로 제공하고 있기 때문에 npm run test를 하면 Nest가 .spec 등 test 파일들을 자동으로 검사하여 Test를 진행합니다.

Error!

하지만 npm run test하면 Error가 나옵니다.

Cannot find module 'src/jwt/jwt.service' from 'users/users.service.ts'

Testing Tool(Jest)이 src 경로를 찾지 못하는 경우입니다. 우리는 TypeScript를 사용하고 있기 때문에 ../../이런 식으로 쓸 필요가 없습니다. 하지만 Jest는 그렇지 못합니다 👶.

Solve

packge.json에서 Jest가 파일을 찾는 방식을 수정합니다.

{
  // ...
  "jest": {
    // ...
    "moduleNameMapper": {
      "^src/(.*)$": "/$1"
    }
  }
}

Error또 발생!

$ npm run test

FAIL  src/post/post.service.spec.ts (7.18 s)
● PostService › should be defined

  Nest can't resolve dependencies of the PostService (?). Please make sure that the argument PostsRepository at index [0] is available in the RootTestModule context.

  Potential solutions:
  - If PostsRepository is a provider, is it part of the current RootTestModule?
  - If PostsRepository is exported from a separate @Module, is that module imported within RootTestModule?
    @Module({
      imports: [ /* the Module containing PostsRepository */ ]
    })

이게 무슨말이면, PostService는 repository가 필요한데, test Module에서 repository를 제공하지 않아 생기는 문제입니다.

그렇다고 TypeORM Module의 Repository를 제공하지 않습니다. 저희는 Mock Repository를 제공할 것 입니다.

Mock에 대해서 모르신다면 밑에 참고 게시글을 꼭 참고하세요.

Mock 🔍

참고사이트: Mock이란? - 人 CoDOM

Solve

post.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Posts } from './entities/post.entity';
import { PostService } from './post.service';

const mockPostRepository = () => ({
  save: jest.fn(),
  find: jest.fn(),
  findOne: jest.fn(),
  softDelete: jest.fn(),
});

type MockRepository = Partial, jest.Mock>>;

describe('PostService', () => {
  let service: PostService;
  let postRepository: MockRepository;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        PostService,
        {
          provide: getRepositoryToken(Posts),
          useValue: mockPostRepository(),
        },
      ],
    }).compile();

    service = module.get(PostService);
    postRepository = module.get>(
      getRepositoryToken(Posts),
    );
  });

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

MockRepository 🔍
type MockRepository = Partial<
  Record, jest.Mock>
>;
Repository를 Mocking 하기위해 Repository Type을 정의한 것

Partial : 타입 T의 모든 요소를 optional하게 한다.

Record : 타입 T의 모든 K의 집합으로 타입을 만들어준다.

keyof Repository : Repository의 모든 method key를 불러온다.

jest.Mock : 3번의 key들을 다 가짜로 만들어준다.

type MockRepository : 이를 type으로 정의해준다.

Result

PASS  src/post/post.service.spec.ts
PostService
  ✓ should be defined (12 ms)

Test Suites: 1 passed, 1 total
Tests:       1 passed, 1 total
Snapshots:   0 total
Time:        1.729 s, estimated 5 s
Ran all test suites related to changed files.

Watch Usage: Press w to show more.

Unit Test

Unit Test는 코드의 각 줄에 문제가 있나 없나를 검사합니다. (이 함수가 제대로 동작하냐 안하냐는 e2e에 가깝습니다.)

Unit Test는 우리가 의도한대로

잘 작동되는지 테스트를 확인하고,
원하는 출력물이 나오며,
고립된 결과를

원합니다.

Test `create()` method

post.service.spec.ts

// ...

describe('PostService', () => {
  // ...
  describe('create()', () => {
    it.todo('should fail on exception');
    it.todo('should create Posts');
  });
});

여기서 describe('create()', () => {...}) 는 테스트할 create() method의 큰 범주라고 생각하시면 됩니다.

it.todo(...)는 모든 경우의 수에 대해 test를 하는 것이고 todo() 는 test를 나중에 만들거라고 jest에게 알려줍니다.

result

PASS  src/post/post.service.spec.ts (5.055 s)
  PostService
    ✓ should be defined (14 ms)
    create()
      ✎ todo should fail on exception
      ✎ todo should create Posts

Test Suites: 1 passed, 1 total
Tests:       2 todo, 1 passed, 3 total
Snapshots:   0 total
Time:        5.315 s
Ran all test suites related to changed files.

Watch Usage: Press w to show more.

post.service.spec.ts

describe('PostService', () => {
  describe('create()', () => {
    const createArgs = {
      title: '제목',
      contents: '글',
    };
    it('should fail on exception', async () => {
      // postRepository.save() error 발생
      postRepository.save.mockRejectedValue('save error'); // 실패할꺼라고 가정한다.
      const result = await service.create(createArgs);
      expect(result).toEqual('save error'); // 진짜 에러 발생했넴
    });

    it('should create Posts', async () => {
      postRepository.save.mockResolvedValue(createArgs); // 성공할꺼라고 가정한다.
      const result = await service.create(createArgs); //

      expect(postRepository.save).toHaveBeenCalledTimes(1); // save가 1번 불러졌니?
      expect(postRepository.save).toHaveBeenCalledWith(createArgs); // 매개변수로 createArgs가 주어졌니?

      expect(result).toEqual(createArgs); // 이 create() method의 결과가 `createArgs`와 똑같니?
    });
  });
});

result

PASS  src/post/post.service.spec.ts
  PostService
    ✓ should be defined (11 ms)
    create()
      ✓ should fail on exception (19 ms)
      ✓ should create Posts (9 ms)

[Nest] 38755   - 2021. 03. 05. 오후 6:16:19   [PostService] Object:
{
  "title": "제목",
  "contents": "글"
}

Test Suites: 1 passed, 1 total
Tests:       3 passed, 3 total
Snapshots:   0 total
Time:        4.761 s

Test `findAll()` method

describe('findAll()', () => {
  it('should be find All', async () => {
    postRepository.find.mockResolvedValue([]);

    const result = await service.findAll();

    expect(postRepository.find).toHaveBeenCalledTimes(1);

    expect(result).toEqual([]);
  });
  it('should fail on exception', async () => {
    postRepository.find.mockRejectedValue('find error');
    const result = await service.findAll();
    expect(result).toEqual('find error');
  });
});

Test `findOne()` method

describe('findOne()', () => {
  const findOneArgs = { id: '1' };

  it('should be findOne', async () => {
    const mockedPost = {
      id: '1',
      title: '음',
      description: '힘드노',
    };
    postRepository.findOne.mockResolvedValue(mockedPost);

    const result = await service.findOne(findOneArgs.id);

    expect(postRepository.findOne).toHaveBeenCalledTimes(1);
    expect(postRepository.findOne).toHaveBeenCalledWith(findOneArgs);

    expect(result).toEqual(mockedPost);
  });
  it('should fail if no post is found', async () => {
    postRepository.findOne.mockResolvedValue(null);

    const result = await service.findOne(findOneArgs.id);

    expect(postRepository.findOne).toHaveBeenCalledTimes(1);
    expect(postRepository.findOne).toHaveBeenCalledWith(findOneArgs);

    expect(result).toEqual(new EntityNotFoundError(Posts, findOneArgs.id));
  });
  it('should fail on findOne exception', async () => {
    postRepository.findOne.mockRejectedValue('find error');
    const result = await service.findOne(findOneArgs.id);
    expect(result).toEqual('find error');
  });
});

Test `update()` method

describe('update()', () => {
  const findOneArgs = { id: '1' };
  const updateArgs = {
    title: 'new',
  };

  it('should be update post', async () => {
    const oldPosts = {
      id: '1',
      title: 'old',
      description: 'description',
    };
    const newPosts = {
      id: '1',
      title: 'new',
      description: 'description',
    };

    postRepository.findOne.mockResolvedValue(oldPosts);
    postRepository.save.mockResolvedValue(newPosts);

    const result = await service.update(findOneArgs.id, updateArgs);

    expect(postRepository.findOne).toHaveBeenCalledTimes(1);
    expect(postRepository.findOne).toHaveBeenCalledWith(findOneArgs);

    expect(postRepository.save).toHaveBeenCalledTimes(1);
    expect(postRepository.save).toHaveBeenCalledWith({
      ...oldPosts,
      ...updateArgs,
    });

    expect(result).toEqual(newPosts);
  });
  it('should fail if no post is found', async () => {
    postRepository.findOne.mockResolvedValue(null);

    const result = await service.findOne(findOneArgs.id);

    expect(postRepository.findOne).toHaveBeenCalledTimes(1);
    expect(postRepository.findOne).toHaveBeenCalledWith(findOneArgs);

    expect(result).toEqual(new EntityNotFoundError(Posts, findOneArgs.id));
  });
  it('should fail on findOne exception', async () => {
    postRepository.findOne.mockRejectedValue('find error');
    const result = await service.findOne(findOneArgs.id);
    expect(result).toEqual('find error');
  });
  it('should fail on save exception', async () => {
    postRepository.save.mockResolvedValue('find error');
    const result = await service.update(findOneArgs.id, updateArgs);
    expect(result).toEqual('find error');
  });
});

Test `remove()` method

describe('remove()', () => {
  const removeArgs = '1';
  const findOneArgs = { id: '1' };
  const softDeleteArgs = { id: '1' };

  it('should be remove post', async () => {
    postRepository.findOne.mockResolvedValue(findOneArgs);
    postRepository.softDelete.mockResolvedValue(softDeleteArgs);

    await service.remove(removeArgs);

    expect(postRepository.findOne).toHaveBeenCalledTimes(1);
    expect(postRepository.findOne).toHaveBeenCalledWith(findOneArgs);

    expect(postRepository.softDelete).toHaveBeenCalledTimes(1);
    expect(postRepository.softDelete).toHaveBeenCalledWith(softDeleteArgs);
  });

  it('should fail if no post is found', async () => {
    postRepository.findOne.mockResolvedValue(null);

    const result = await service.remove(findOneArgs.id);

    expect(postRepository.findOne).toHaveBeenCalledTimes(1);
    expect(postRepository.findOne).toHaveBeenCalledWith(findOneArgs);

    expect(result).toEqual(new EntityNotFoundError(Posts, findOneArgs.id));
  });
  it('should fail on findOne exception', async () => {
    postRepository.findOne.mockRejectedValue('find error');
    const result = await service.findOne(findOneArgs.id);
    expect(result).toEqual('find error');
  });
  it('should fail on remove exception', async () => {
    postRepository.findOne.mockRejectedValue('remove error');
    const result = await service.findOne(findOneArgs.id);
    expect(result).toEqual('remove error');
  });
});

Result

Test Coverage

npm run test:cov

---------------------|---------|----------|---------|---------|-------------------
File                 | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
---------------------|---------|----------|---------|---------|-------------------
All files            |   58.33 |      100 |   56.25 |   58.49 |                   
 src                 |   41.94 |      100 |      75 |      36 |                   
  app.controller.ts  |     100 |      100 |     100 |     100 |                   
  app.module.ts      |       0 |      100 |     100 |       0 | 1-42              
  app.service.ts     |     100 |      100 |     100 |     100 |                   
  main.ts            |       0 |      100 |       0 |       0 | 1-18
 src/post            |   63.89 |      100 |      50 |   66.67 | 
  post.controller.ts |       0 |      100 |       0 |       0 | 1-40
  post.module.ts     |       0 |      100 |     100 |       0 | 1-12
  post.service.ts    |     100 |      100 |     100 |     100 | 
  # post.service.ts 가 coverage 100% 를 달성했습니다! 👏👏👏
 src/post/dto        |       0 |      100 |     100 |       0 | 
  create-post.dto.ts |       0 |      100 |     100 |       0 | 1-4
  update-post.dto.ts |       0 |      100 |     100 |       0 | 1-4
 src/post/entities   |     100 |      100 |     100 |     100 |
  post.entity.ts     |     100 |      100 |     100 |     100 |
---------------------|---------|----------|---------|---------|-------------------
Test Suites: 1 failed, 1 passed, 2 total
Tests:       1 failed, 16 passed, 17 total
Snapshots:   0 total
Time:        8.027 s
Ran all test suites.

coverage 로 부터 Unit Test의 어떤 부분이 Test가 빠졌는지 확인이 가능합니다.

100%를 다 채우면 기분이 너무 좋습니다. ~~(INTJ)~~

End-to-End(e2e) Testing

(공사중 🛠)

Setting up

project RootDir의 test/post.e2e-spec.ts 를 만들어줍니다.

import { INestApplication } from '@nestjs/common';
import { Test, TestingModule } from '@nestjs/testing';
import { AppModule } from 'src/app.module';
import { getConnection } from 'typeorm';

describe('PostController (e2e)', () => { let app: INestApplication;

// Test 전 beforeAll(async () => { const moduleFixture: TestingModule = await Test.createTestingModule({ imports: [AppModule], }).compile();

app = moduleFixture.createNestApplication();

});

// Test 후 afterAll(async () => { await getConnection().dropDatabase(); app.close(); });

describe('create', () => { it.todo('should create Post'); }); describe('findAll', () => { it.todo('should findAll Posts'); }); describe('findOne', () => { it.todo('should findOne Post.'); }); describe('update', () => { it.todo('should update Post.'); }); describe('remove', () => { it.todo('should remove Post.'); }); });

```

NestJS sentry + slack error로그 수집

Mon, 05 Apr 2021 16:20:15 GMT

Sentry는 코드를 진단하고 고치며 최적화하여 개발자를 돕는 모니터링 플랫폼 애플리케이션(오픈소스) 입니다.

NestJS에서 에러가 발생했을때 sentry에 전달하고, sentry client인 raven을 통한 인터셉터로 slack에 알리는 애플리케이션을 구축해봅니다.

참고 🔍 (이 포스팅의 주요 핵심 개념은 NestJS의 Interceptor 기능 입니다.) NestJS - Interceptor Sentry.io 🙈[Spring] Interceptor (1) - 개념 및 예제🐵

NestJS 프로젝트 생성 및 페키지 관련 설치

$ nest new sentry-test
$ cd sentry-test
$ npm i @sentry/node nest-raven

Sentry 설정

Sentry App

Sentry 웹 → Project → Create a new Project → Node 선택 → 프로젝트 생성후 DSN 복사

Sentry 연결 및 초기화

main.ts에 sentry 연결

import { NestFactory } from '@nestjs/core';
import { init as SentryInit } from '@sentry/node';**
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

    // connect Sentry
  SentryInit({
    dsn:
      'https://940633ab27b94fdd8afc6ae73b986030@o561269.ingest.sentry.io/이히히',
  });

  await app.listen(3000);
}
bootstrap();

NOTION sentry는 무료버전으로 request 수가 제한되어있습니다. 되도록 NODE_ENV == 'production' 환경에서 적용하도록 합시다.

NestJS Interceptor 설정

// app.module.ts

import { HttpException, Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { APP_INTERCEPTOR } from '@nestjs/core';
import { RavenInterceptor, RavenModule } from 'nest-raven';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [
    RavenModule,
    ConfigModule.forRoot({
      envFilePath: '.env',
    }),
  ],
  controllers: [AppController],
  providers: [
    AppService,

    {
      provide: APP_INTERCEPTOR, // 전역 인터셉터로 지정
      useValue: new RavenInterceptor({
        filters: [
          {
            type: HttpException,
            // Filter exceptions of type HttpException.
            // Ignore those that have status code of less than 500
            filter: (exception: HttpException) => {
              return 500 > exception.getStatus();
            },
          },
        ],
      }),
    },

  ],
})
export class AppModule {}

Slack 설정

Slack API Incoming Webhooks 생성

Slack API 홈페이지 → Create New App → 이름 및 workspace 지정 → Feature/Incoming Webhooks 메뉴 → Activate Incoming Webhooks 를 On → Webhook URL .env 파일에 저장

// .env
SLACK_WEBHOOK=https://hooks.slack.com/services/T01SZ44S95J/B01TGPASYDN/이히히

Slack 메세징 솔루션 사용

$ npm i @slack/client

NestJS Interceptor 적용

webhook.interceptor.ts

import {
    CallHandler,
    ExecutionContext,
    Injectable,
    NestInterceptor,
} from '@nestjs/common';
import { captureException } from '@sentry/minimal';
import { Observable } from 'rxjs';
import { catchError } from 'rxjs/operators';
import { IncomingWebhook } from '@slack/client';

@Injectable()
export class WebhookInterceptor implements NestInterceptor {
    intercept(_: ExecutionContext, next: CallHandler) /** : Observable*/ {
    return next.handle().pipe(
        catchError((error) => {
        const webhook = new IncomingWebhook(**process.env.SLACK_WEBHOOK**);
        webhook.send({
            attachments: [
            {
                color: 'danger',
                text: '회사 드가자~ 드가자~!',
                fields: [
                {
                    title: `Request Message: ${error.message}`,
                    value: error.stack,
                    short: false,
                },
                ],
                ts: Math.floor(new Date().getTime() / 1000).toString(), // unix form
            },
            ],
        });
        return null;
        }),
    );
    }
}

app.module.ts

import { HttpException, Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { APP_INTERCEPTOR } from '@nestjs/core';
import { RavenInterceptor, RavenModule } from 'nest-raven';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { WebhookInterceptor } from './webhook.interceptor';

@Module({ // ...

providers: [
// ...

  // Webhook Interceptor 적용
{
    provide: APP_INTERCEPTOR,
    useClass: WebhookInterceptor,
},

],

}) export class AppModule {}

# Test
1. app.controller.ts

```ts
import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }

  @Get('error')
  getError() {
    throw new Error('this is error!!');
  } 
}

App 실행 후, error request
```
$ curl -o http://127.0.0.1:3000/error
```

Result

NestJS Auth - Authorization

Sun, 14 Feb 2021 14:33:57 GMT

Index

이전까지 AuthGuard를 만들어 @UseGuard() 데코레이터로 적용한 Authentication 과정을 진행하였습니다. 이번 글에서는 Role-based access control 메커니즘을 적용하여 역할과 권한에 대해 정의하여 액세스를 제어해 봅시다.

Role-Based Authorization

Add Role

먼저 User Entity에 Role 이라는 권한(역할) Column을 추가해줍니다.

User Entity
```
// src/user/entity/user.entity.ts
```

export enum UserRole { CLIENT = 'CLIENT', ADMIN = 'ADMIN', }

@Entity({ name: 'users' }) export class User { // ....

@Column({ type: 'enum', enum: UserRole, default: UserRole.CLIENT, }) role: UserRole;

// ... }

### Role Guards
`@Role()` 이라는 Decorator를 만듭니다. 이 데코레이터는 지정한 특정 리소스에 대해 필요한 role(권한)을 허가합니다. 
예를 들어 `admin`이 필요한 리소스에 접근하기 위해 사용자는 `role` column에 `admin`으로 지정이 되어야 하죠. 
- Role Guard
```ts
// src/auth/role.decorator.ts

import { SetMetadata } from '@nestjs/common';
import { UserRole } from 'src/user/entity/user.entity';

// 'Any' : 모든 role에 대해 허용
export type AllowedRole = keyof typeof UserRole | 'Any';

export const Role = (roles: AllowedRole[]) => SetMetadata('roles', roles);

참고 🔍

Nest 는 @SetMetadata() decorator를 통해 route handler에 custom metadata를 붙일 수 있도록 기능을 제공합니다.

NestJS Docs - Excution context(Reflection and metadata)

Auth Guard route의 roles custom metadata에 접근하기 위해, framework 밖에서 제공하는 Reflector 헬퍼 클레스를 사용합니다.
```
// src/auth/auth.guard.ts
```

@Injectable() export class AuthGuard implements CanActivate {

constructor(private reflector: Reflector) {} // roles custom metadata에 접근하기 위해 reflector 사용

canActivate( context: ExecutionContext, ): boolean | Promise | Observable { // const requiredRoles = this.reflector.get( 'roles', context.getHandler(), );

if (!requiredRoles) { // role이 필요없는 resource면 그냥 넘어감 
  return true;
}

const request = context.switchToHttp().getRequest();
const user: User = request['user'];
if (!user) 
  return false;

if (requiredRoles.includes('Any')) 
  return true; // `Any` 권한은 로그인된 사용자 중 아무나 접근이 가능하다는 뜻.
return requiredRoles.includes(user.role); // 사용자의 role이 resource가 필요한 권한에 포함되어있는지 검사!

} }

- User Role Guards
이제 Controller에 Role Decorator를 적용해봅시다.
```ts
// src/user/user.controller.ts

@Controller('user')
export class UserController {
  // ...

  @Get('/me')
  @Role([UserRole.CLIENT])
  @UseGuards(AuthGuard)
  getMe() {
    return 'Get Me!';
  }

  @Get('/admin')
  @Role([UserRole.ADMIN])
  @UseGuards(AuthGuard)
  getAdmin() {
    return `U R Admin`;
  }
}

Custom Decorator

만약 현재 방식으로 swagger나 다른 decorator를 Auth 과정을 함께 쓴다면 controller는 골뱅이 무침이 될 것 같습니다.

그래서 우리는 Auth에 필요한 Decorator를 모~두 묶어 제공해봅시다.

Auth에 필요한 Decorator 묶기

Custom Decorator를 만들어 봅시다.

Auth Decorator 현재는 2개만 적용했지만, 더 많은 데코레이터를 나열하여 적용시킬 수 있습니다.
```
// src/auth/auth.decorator.ts
```

import { applyDecorators, UseGuards } from '@nestjs/common'; import { AuthGuard } from './auth.guard'; import { AllowedRole, Role } from './role.guard';

export function Auth(roles: AllowedRole[]) { return applyDecorators(Role(roles), UseGuards(AuthGuard)); }

> **참고 🔍**
> 
> * [NestJS Docs - Custom decorators(decorator composition)](https://docs.nestjs.com/custom-decorators#decorator-composition)

- user controller
Controller에 적용시켜 봅시다.
```ts
@Controller('user')
export class UserController {

  // ...

  @Get('/me')
  // @Role([UserRole.CLIENT])
  // @UseGuards(AuthGuard) 밑에꺼로 단축 가능
  @Auth([UserRole.CLIENT])
  getMe() {
    return 'Get Me!';
  }

  @Get('/admin')
  @Auth([UserRole.ADMIN])
  getAdmin() {
    return `U R Admin`;
  }
}

참고 🔍

Github Repository

NestJS Auth - Authentication

Sun, 14 Feb 2021 14:29:41 GMT

이전 글까지는 Authentication을 준비하는 단계였습니다. 이번글에서는 JWT를 이용한 회원가입과 로그인 과정 및 사용자 **인증(Authentication) 과정을 다루어 보도록 하겠습니다.

참고 🔍

[JWT] 토큰(Token) 기반 인증에 대한 소개

Index 📋

User Module

Register Repository to use User entity User Module에서 TypeOrmModule의 forFeature() 메서드를 사용하여 현재 scope(User)에서 어떤 repository를 등록할 것 인지 결정합니다.

// src/user/user.module.ts

import { Module } from '@nestjs/common';
import { UserService } from './user.service';
import { UserController } from './user.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './entity/user.entity';

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  providers: [UserService],
  controllers: [UserController],
})
export class UserModule {}

User Service

Inject Repository Module에 등록하면 우리는 현재의 범위(User)에서 UsersRepository를 @InjectRepository() decorator를 사용하여 UserService안에 inject 할 수 있습니다.

// src/user/user.service.ts

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

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private readonly usersRepository: Repository,
  ) {}
}

먼저 필요한 package를 설치하고, DTO(Data Transfer Object)를 통해 Validation 작업을 합니다.

참고 🔍

데이터 전송 객체(DTO)

$ npm i class-validator class-transformer

// src/main.ts

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
      forbidNonWhitelisted: true,
      transform: true,
    }),
  );

  await app.listen(3000);
}
bootstrap();

Define DTO(Data Transfer Object)

// src/user/dtos/create-user.dto.ts

import { IsEmail, IsString } from 'class-validator';

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

  @IsString()
  password: string;

  @IsString()
  name: string;
}

Insert User Object to Database user repository의 save() method를 통해 database에 object를 insert 해줍니다. 그전에 등록할 계정이 이미 존재한다면 error를 반환합니다.
```
// src/user/user.service.ts
```

import { ForbiddenException, HttpException, Injectable } from '@nestjs/common'; import { InjectRepository } from '@nestjs/typeorm'; import { Repository } from 'typeorm'; import { CreateUserRequestDto } from './dtos/create-user.dto'; import { User } from './entity/user.entity';

@Injectable() export class UserService { constructor( @InjectRepository(User) private readonly usersRepository: Repository, ) {}

async create(data: CreateUserRequestDto) { const isExist = await this.usersRepository.findOne({ username: data.username, }); if (isExist) { throw new ForbiddenException({ statusCode: HttpStatus.FORBIDDEN, message: [이미 등록된 사용자입니다.], error: 'Forbidden', }); } try { await this.usersRepository.save(data); } catch (error) { return { ...error, }; } return { statusCode: HttpStatus.CREATED, }; } }


### User Controller
- Create User End Point
  - UserController가 `POST` 요청으로 body에 사용자를 생성할 데이터를 `http://localhost:{PORT}/user`로 받습니다.
  - 추가로 생성자로 `UserService` instance를 inject 합니다.
```ts
// src/user/user.controller.ts

import { Body, Controller, HttpCode, HttpStatus, Post } from '@nestjs/common';
import { CreateUserRequestDto } from './dtos/create-user.dto';
import { UserService } from './user.service';

@Controller('user')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Post()
  @HttpCode(HttpStatus.CREATED)
  create(@Body() data: CreateUserRequestDto) {
    return this.userService.create(data);
  }
}

Hashing Password 🧶

사용자 등록하기 위해 DB에 Insert 되기 전, 비밀번호를 hashing 하는 작업을 해보도록 하겠습니다.

Install bcrypt package
```
$ npm install bcrypt
```
TypeORM Listeners and Subscribers TypeORM - Listeners and Subscribers 를 참고하시면 TypeORM에 특별한 기능이 있습니다.

Any of your entities can have methods with custom logic that listen to specific entity events. You must mark those methods with special decorators depending on what event you want to listen to.

모든 Entity들은 특정 entity event를 기다리고 있는 사용자 정의 로직 메서드를 가질 수 있습니다.

저는 @BeforeInsert() 라는 데코레이터를 사용하여, 사용자를 등록하여 DB에 Insert 되기 전, 비밀번호를 hashing 하는 작업을 해보도록 하겠습니다.

// src/user/entity/user.entity.ts

// ...
@Entity({ name: 'users' })
export class User {
  // ...

  @BeforeInsert()
  async hashPassword(): Promise {
    try {
      this.password = await bcrypt.hash(this.password, 10);
    } catch (e) {
      console.log(e);
      throw new InternalServerErrorException();
    }
  }
}

Token Generate 🎫

아이디와 비밀번호로 로그인을 받으면 우리의 서버에서 계정 정보를 검증하고 맞다면 sigined 토큰을 발급 해줍니다. (토큰에는 중요한 개인정보가 담기면 안됩니다! 그저 발급한 토큰이 우리의 서버에서 정상적으로 발급된 토큰임을 증명하기 위함입니다.)

(나중에 사용자는 인증이 필요한 End point에 요청하기 위해 발급받은 토큰을 이용하게 됩니다.)

Set Up
```
$ npm i jsonwebtoken
```

$ nest generate module jwt $ nest generate service jwt

그리고 JWT Module을 option으로 privateKey를 받는 동적모듈로 만들기 위해 option interface와 di token 값(`jwt constant`)을 만들어줍니다.

> **참고 🔍**
- [NestJS Docs - Dynamic Modules](https://docs.nestjs.com/fundamentals/dynamic-modules)
- [NestJS 메일 발송 Dynamic Module](https://velog.io/@1yongs_/NestJS-%EB%A9%94%EC%9D%BC-%EB%B0%9C%EC%86%A1-Dynamic-Module)

- JWT Interface
```ts
export interface JwtModuleOptions {
  privateKey: string;
}

JWT Constant

export const CONFIG_OPTIONS = 'CONFIG_OPTIONS';

JWT Module JWT Module을 @Global() decorator로 전역에서 사용할 수 있도록 하고, forRoot() static method로 Dynamic Module을 반환하도록 합니다.

@Module({})
@Global()
export class JwtModule {
  static forRoot(options: JwtModuleOptions): DynamicModule {
    return {
      module: JwtModule,
      exports: [JwtService],
      providers: [
        {
          provide: CONFIG_OPTIONS,
          useValue: options,
        },
        JwtService,
      ],
    };
  }
}

App Module AppModule에 JWTModule을 import 하도록 합시다. privateKey는 JWT 생성과 검증에 필요한 비밀키를 지정합니다. (예: mYsEcReTkEy0011)

// src/app.module.ts

@Module({
  imports: [

    JwtModule.forRoot({
      privateKey: process.env.PRIVATE_KEY, // JWT private Key 아무거나. 
    }),
  ]
})
// ...

JWT Service (토큰 발행) JwtService에는 토큰 발행을 담당하는 sign method를 정의해줍니다. 토큰에는 userId (uuid)를 담아서 줍니다.

import { Inject, Injectable } from '@nestjs/common';
import * as jwt from 'jsonwebtoken';
import { CONFIG_OPTIONS } from './jwt.constants';
import { JwtModuleOptions } from './jwt.interface';

@Injectable()
export class JwtService {
  constructor(
    @Inject(CONFIG_OPTIONS) private readonly options: JwtModuleOptions,
  ) {}

  // 로그인 성공하면 token을 만들어 보냄
  sign(userId: string): string {
    return jwt.sign({ id: userId }, this.options.privateKey);
  }
}

Verify User

id와 password를 받아 사용자를 확인하는 기능을 만듭니다.

user entity User Entity에 비밀번호를 검증하는 helper method를 추가합니다.

참고 🔍

Gist - add helper methods on TypeORM modles Example

// src/user/entity/user.entity.ts

@Entity({ name: 'users' })
export class User {
  // ...

  async checkPassword(inputPassword: string): Promise {
    try {
      return await bcrypt.compare(inputPassword, this.password);
    } catch (error) {
      console.log(error);
      throw new InternalServerErrorException({
        ...error.response,
      });
    }
  }
}

DTO

export class SignInRequestDto {
  username: string;
    password: string;
}

export class SignInResponseDto { statusCode: number; token?: string; error?: string; message?: string; }


- User Service
사용자임을 확인하고 token을 발행해줍니다.
```ts
// src/user/user.service.ts

@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository,
    private readonly jwtService: JwtService,
  ) {}

  // ...

  async signIn({
    username,
    password,
  }: SignInRequestDto): Promise {
    try {
      const user = await this.userRepository.findOne({ username });
      if (!user) {
        throw new NotFoundException({
          error: 'Not Found',
          message: ['사용자를 찾지 못했습니다.'],
        });
      }
      const passwordCorrect = await user.checkPassword(password);
      if (!passwordCorrect) {
        throw new BadRequestException({
          error: 'Bad Request',
          message: ['비밀번호가 틀렸습니다.'],
        });
      }

      const token = this.jwtService.sign(user.id);
      return {
        statusCode: 201,
        token,
      };
    } catch (error) {
      return {
        statusCode: error.status,
        ...error.response,
      };
    }
  }
}

User Controller

POST* 요청으로 request body로는 username과 password를 받습니다.

@Controller('users')
export class UserController {
 constructor(private readonly userService: UserService) {}

@Post('/sign-in') signIn(@Body() data: SignInRequestDto): Promise { return this.userService.signIn(data); } }


## Authentication
로그인된 사용자가 인증이 필요한 서버의 어느 한 End point로 요청하기위해 발행된 토큰을 request header의 `x-jwt`라는 이름으로 담아 요청합니다.

이 때 우리는 모든 요청에 대해 header를 검사하는 `JwtMiddleware`를 만들어 줍니다.
### Verify Token

- jwt service (토큰 검증)
`verify` method를 추가해줍니다.
```ts
// src/jwt/jwt.service.ts

@Injectable()
export class JwtService {
  // ...

  verify(token: string) {
    return jwt.verify(token, this.options.privateKey);
  }
}

user service (사용자 찾기)
```
// src/user/user.service.ts
```

@Injectable() export class UserService { // ...

async findById(id: string): Promise { return await this.userRepository.findOne(id); } }



- JWT Middleware
 JWT Middleware에서는 header의 `x-jwt`토큰을 검증하여 request object에 `'user': User`를 추가합니다.
다음으로 `next()` method를 호출하여 다음 함수로 넘어갑니다. (header에 `x-jwt`이 없다면 user를 추가하지 않고 다음으로 넘어갑니다.)

```ts
// src/jwt/jwt.middleware.ts

@Injectable()
export class JwtMiddleware implements NestMiddleware {
  constructor(
    private readonly userService: UserService,
    private readonly jwtService: JwtService,
  ) {}

  async use(req: Request, res: Response, next: NextFunction) {
    if ('x-jwt' in req.headers) {
      const token = req.headers['x-jwt'];
      const decoded = this.jwtService.verify(token.toString());
      if (typeof decoded === 'object' && decoded.hasOwnProperty('id')) {
        try {
          const user = await this.userService.findById(decoded['id']);
          req['user'] = user;
        } catch (err) {
          console.log(err);
        }
      }
    }
    next();
  }
}

App Module App Module에 JWT Middleware를 모든 요청으로 적용시켜줍니다.
```
// src/app.module.ts
```

@Module({ // ... }) export class AppModule implements NestModule { configure(consumer: MiddlewareConsumer) { consumer .apply(JwtMiddleware) .forRoutes({ path: '/', method: RequestMethod.ALL }); } }


> **참고 🔍**
- [NestJS Docs - Middleware](https://docs.nestjs.com/middleware)

### Auth Guard
- Set up

$ nest generate guard auth auth

- Auth Guard
```ts
@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise | Observable {

    const request = context.switchToHttp().getRequest();
    const user: User = request['user'];

    if (!user) return false;
    return true;
  }
}

Use Guards

Auth Guard 적용 @UserGuards() decorator를 사용하여 우리가 만든 AuthGuard를 적용해줍니다. token검증을 성공하면 Get Me!를 받고, 검증에 실패하면 UnAuthorized Error를 받습니다.

// src/user/user.controller.ts

@Controller('users')
export class UserController {
  // ...

  @Get('/me')
  @UseGuards(AuthGuard)
  getMe() {
    return 'Get Me!';
  }
}

참고 🔍

NestJS Docs - Guards
NestJS Docs - Security: Authentication
Custom Decorator 이전에 Middleware에서 request object에 user를 넣었었습니다. 이를 next() method로 다음으로 넘어온 함수에서 사용하기 위해 Custom Decorator로 정의한 @AuthUser()를 사용합니다.

// src/auth/auth-user.decorator.ts

import { createParamDecorator, ExecutionContext } from '@nestjs/common';

export const AuthUser = createParamDecorator(
  (data: unknown, context: ExecutionContext) => {
    const request = context.switchToHttp().getRequest();
    const user = request['user'];
    return user;
  },
);

참고 🔍

NestJS Docs - Custom Decorators

정리

사용자 인증 / 인가 부분은 많은 기술 내용들과 작업들을 담고 있기 때문에 글을 쓰면서도 아직 부족하다는 느낌을 많이 받았습니다. 추후에 수정을 하면서 채워나가도록 하겠습니다... ༼;´༎ຶ + ༎ຶ༽

NestJS Auth - Setup

Sun, 14 Feb 2021 12:53:18 GMT

Index

MySQL Setup
- docker-compose
NestJS Setup
- Create Project
- TypeORM Setup (Connect DB)
- User Entity Model

MySQL docker-compose

Docker Compose

MySQL Container 환경을 구성합니다. 기존 MySQL를 사용하기 원하시는 사용자는 (Optinal)이라고 적힌 부분을 Skip 하셔도 됩니다.

docker-compose.yml이란 파일을 생성합니다. (Optinal)

services:
  mysql:
    image: mysql:5.7
    container_name: dev-mysql
    restart: always
    ports:
      - 10310:3306
    environment:
      TZ: Asia/Seoul
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: dev
      MYSQL_USER: dev
      MYSQL_PASSWORD: dev
    command:
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_unicode_ci
      - --skip-character-set-client-handshake
    volumes:
      - dev-mysql:/var/lib/mysql

volumes:
  dev-mysql:

docker-compose up -d 명령어를 사용하여 MySQL Docker Container를 생성해줍니다. (Optinal)
MySQL WorkBench에서 Container가 생성되었는지 확인하고, 아래에 적힌 ID, Password로 Database에 Connect 합니다. (Optinal)

id: root
pw: root

Schema(Database)를 만들어 줍니다.
왼쪽 위 Administration 탭의 Users and Privileges에서 새로운 account를 등록해줍니다.
```
# 사용자 마음대로
```

id: ilyong pw: ilyong

![](https://images.velog.io/images/1yongs_/post/50f3afd4-8aa7-41f4-8f18-fb286732efbf/workbench_add_account.png)

![](https://images.velog.io/images/1yongs_/post/a78705ab-5eb8-4832-9afb-94face6f1fb6/workbench_add_account2.png)


## NestJS Setup
### Create Project
- `@nestjs/cli` Package를 통해 프로젝트를 만들어 줍니다.
```sh
$ nest new nestjs-auth

참고 🔍

NestJS Docs - CLI

TypeORM Setup (Connect DB)

필요한 Package를 설치해줍니다.

$ npm i joi @nestjs/config
$ npm i @nestjs/typeorm typeorm mysql2

우선 Database 연결에 필요한 환경변수가 정의된 파일을 만들어줍니다.
```
# File Should exist on Project Root Directory
# File Name : `.env`
```

NODE_PORT=3000

MySQL Database Hostname

MYSQL_HOST=127.0.0.1

MySQL Database Port

MYSQL_PORT=10310

MySQL Database username

MYSQL_USERNAME=ilyong

MySQL Database Password

MYSQL_PASSWORD=ilyong

MySQL Database Schema Name

MYSQL_DATABASE=ilyong


- `ConfigModule`을 통해 Nest Project에 환경변수를 불러옵니다.
```ts
// src/app.module.ts

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import * as Joi from 'joi';

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: '.env',
      isGlobal: true,
      validationSchema: Joi.object({
        NODE_PORT: Joi.string().required(),
        MYSQL_HOST: Joi.string().required(),
        MYSQL_PORT: Joi.string().required(),
        MYSQL_USERNAME: Joi.string().required(),
        MYSQL_PASSWORD: Joi.string().required(),
        MYSQL_DATABASE: Joi.string().required(),
      }),
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

참고 🔍

NestJS Docs - Schema validation
NestJS Docs - Configuration
TypeOrmModule을 사용하여 MySQL Database에 연결합니다.
```
// src/app.module.ts
```

@Module({ imports: [ // ...

TypeOrmModule.forRoot({
  type: 'mysql',
  host: process.env.MYSQL_HOST,
  port: +process.env.MYSQL_PORT,
  username: process.env.MYSQL_USERNAME,
  password: process.env.MYSQL_PASSWORD,
  database: process.env.MYSQL_DATABASE,
  // Application이 실행(변경)될 때마다 database schema가 자동으로 생성(DB에 바로 반영)됩니다. 
  // (주의! 배포 환경에서 쓰지마시오)
  synchronize: true,
  // Query를 할때마다 Console Log를 찍어줍니다.
  logging: true,
  // The charset for the connection. (default: 'UTF8_GENERAL_CI')
  charset: 'utf8mb4_unicode_ci',
  // The timezone configured on the MySQL server.
  timezone: '+09:00',
  // Database 연결에 대해 불러올 Entity를 정의합니다.
  // Entity는 데이터베이스 테이블에 매핑되는 Class입니다.
  entities: [],
}),

// ...
,

}) export class AppModule {}



> **참고 🔍**
- [NestJS Docs - Database](https://docs.nestjs.com/techniques/database)
- [NestJS Docs - TypeORM](https://docs.nestjs.com/recipes/sql-typeorm)
- [TypeORM Docs - Connection Options](https://typeorm.io/#/connection-options)
- [TypeORM Docs - What Is Entities?](https://typeorm.io/#/entities)

### User Entity Model

**TypeORM**은 [Repository Design Pattern](https://typeorm.io/#/working-with-repository)을 지원합니다. 따라서 각 Entity는 자신의 Repository를 가집니다. 이러한 Repository들은 database 연결로부터 얻어질 수 있습니다.

- 우선 사용자 관련 로직을 처리하기 위해 `Module`, `Controller`, `Service`를 생성합니다.
```sh
$ nest generate module user
$ nest generate service user
$ nest generate controller user

그리고 User Entity를 정의해줍니다.
```
// src/user/entity/user.entity.ts
```

import { Column, CreateDateColumn, DeleteDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn, VersionColumn } from "typeorm";

@Entity({ name: 'users' }) export class User { @PrimaryGeneratedColumn('uuid') id: string; // Primary Key

@Column() username: string; // id(email 형식)

@Column() name: string; // 사용자명

@Column() password: string; // 비밀번호

@Column({ nullable: true }) avatar: string; // 프로필 이미지 (nullable)

@CreateDateColumn() createdAt: Date;

@UpdateDateColumn() updatedAt: Date;

@DeleteDateColumn() deletedAt: Date;

@VersionColumn() version: string; }


- `User entity` 사용을 시작하기 위해서 `TypeOrmModule`의 `forRoot()` method 옵션 중 하나인 `entities` Array에 EnInserting 함으로써 `TypeORM`에 이를 알려야 합니다.

```ts
// src/app.module.ts

// ...
import { User } from './user/entity/user.entity';

@Module({
  imports: [
    // ...
    TypeOrmModule.forRoot({
      // ...

      entities: [User],

      // ...

저장하고 Nest Application을 실행하여 Database에 적용되었는지 확인해봅시다.
```
$ npm run start:dev
```

실행하면 TypeORM이 MySQL Database에 연결하고 Table을 생성하기 위한 Query문을 실행하고 NestJS Server가 실행됩니다. 그리고 아래 사진과 같이 users 라는 Table이 된 것을 확인할 수 있습니다.

NestJS Auth - Intro

Sat, 13 Feb 2021 17:47:16 GMT

인증은 대부분의 애플리케이션에서 필수적인 부분입니다. 인증을 다루는 방식과 전략은 다양합니다.

이 예제에서는 Json Web Token을 이용한 토큰 기반 인증을 사용할 것 입니다.

Index

Authentication 이란?
Authorization 이란?
NestJS Guard 란?

Authentication 이란?

Authentication(인증)은 사용자의 신원을 증명 하는 프로세스입니다. 이 예제에서는 ID/PW로 서비스의 사용자를 증명하고, 서버에서 받은 JSON Web Token을 가지고 필요한 리소스에 접근하여 인증을 합니다.

네이버 로그인 예제

Authorization 이란?

Authorization(인가 또는 권한 부여)란 인증된 주체에게 작업을 수행할 수 있는 사용 권한을 부여하는 작업입니다. 액세스가 허용된 데이터 및 해당 데이터로 할 수 있는 작업을 지정합니다.

사용자를 추방하거나, 특정 데이터(게시글)에 대한 CRUD 권한을 부여 및 지정하는 작업입니다.

네이버 카페 글쓰기 등급제한 예제

NestJS Guard 란?

NestJS의 Guard는 run-time 중에 주어진 요청을 특정 조건(허가, 역할, ACLs 등)에 따라 route handler가 허가할지 안할지를 결정합니다.

일반적인 Express Application에서 인증은 미들웨어에서 처리되었습니다. 미들웨어는 토큰 유효성 검사 및 request 객체에 속성을 붙이는 것 등이 특정 route context(그리고 그것의 metadata)와 강하게 연결되지 않기 때문에, 미들웨어는 인증에서 괜찮은 선택입니다.

하지만 미들웨어는 next() 함수가 불린 후 어떤 handler가 실행되었는지 모릅니다. 하지만 Guard는 ExecutionContext instance로 접근하여 다음에 실행될 것이 무엇인지 정확히 알고있습니다. 이는 코드를 DRY원칙과 선언적으로 만드는데 도움을 줍니다.

이 예제에서 ExecutionContext를 다룰때 다시 한번 언급하겠습니다.

Reference

NestJS Documents - Guards JSON Web Tokens

Redis + Socket.IO + NestJS Chat App

Fri, 05 Feb 2021 09:03:57 GMT

최근 회사 프로젝트를 진행하면서 Chatting 모듈을 만들어야했는데

운영하는 서버는 사용량에 따라 서버의 대수를 늘리는 Scale Out을 하여 능력을 향상시킵니다. 이로 인해 서버가 여러대로 늘어감에 따라 소켓 서버들간에 데이터를 주고받을 수 있는 중간 서버가 필요해졌습니다.

해결책으로 Redis의 PUB/SUB 기능을 사용하여 소켓간의 메시지를 관리합니다.

서버는 Node.js 프레임워크 NestJS를 사용하고, 채팅에 필요한 소켓은 Socket.io 라이브러리를 사용합니다.

이는 나중에 Redis와 Socket를 Adapter Pattern으로 적용하기 편리해지기 때문입니다. 그리고 각 서버들은 Docker를 이용하여 실행합니다.

📋 TODO

Set up Docker
Set up Chatting Application
Apply Websocket Adapter
Test

1. Set up Docker

Docker-Compose 로 Redis 환경을 구성합니다.

// docker-compose.yml

version: '3'

services:
  redis:
    image: redis
    restart: always
    container_name: ilyong-redis
    ports:
      - 10300:6379

$ docker-compose up -d 명령어를 사용하여 Redis Docker Image를 실행합니다.

$ docker-compose up -d
Creating network "nestjs-socketio_default" with the default driver
Pulling redis (redis:)...
latest: Pulling from library/redis
a076a628af6f: Pull complete
f40dd07fe7be: Pull complete
ce21c8a3dbee: Pull complete
ee99c35818f8: Pull complete
56b9a72e68ff: Pull complete
3f703e7f380f: Pull complete
Digest: sha256:0f97c1c9daf5b69b93390ccbe8d3e2971617ec4801fd0882c72bf7cad3a13494
Status: Downloaded newer image for redis:latest
Creating ilyong-redis ... done

$ docker ps 로 상태를 확인합니다.

$ docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED         STATUS         PORTS                     NAMES
959e05e10871   redis     "docker-entrypoint.s…"   7 seconds ago   Up 6 seconds   0.0.0.0:10300->6379/tcp   ilyong-redis

2. Set up Chatting Application

Generate NestJS

$ nest new nestjs-socketio
$ nest generate module chat
$ nest generate gateway chat chat

Install package

NestJS WebSocket 관련 package를 설치해줍니다.

$ npm i --save @nestjs/websockets @nestjs/platform-socket.io
$ npm i --save-dev @types/socket.io

Setting Up Chatting Application

환경 변수를 사용하기위해 @nestjs/config package를 설치해줍니다.

$ npm i --save @nestjs/config joi

// src/app.module.ts

@Module({
imports: [
  ConfigModule.forRoot({
    envFilePath: `.env`,
    validationSchema: Joi.object({
      NODE_PORT: Joi.string().required(),
      REDIS_PORT: Joi.string().required(),
      REDIS_HOST: Joi.string().required(),
    }),
  }),
  ChatModule,
],
controllers: [AppController],
providers: [AppService],
})

Gateway를 사용하여 WebSocket 통신 모듈을 구현합니다.

// src/chat.gateway.ts

import { Logger } from '@nestjs/common';
import {
  OnGatewayConnection,
  OnGatewayDisconnect,
  OnGatewayInit,
  SubscribeMessage,
  WebSocketGateway,
  WebSocketServer,
} from '@nestjs/websockets';
import { Server, Socket } from 'socket.io';

@WebSocketGateway({ namespace: 'chat' }) // namespace는 optional 입니다!
export class ChatGateway
  implements OnGatewayConnection, OnGatewayDisconnect, OnGatewayInit {
  private static readonly logger = new Logger(ChatGateway.name);

  @WebSocketServer()
  server: Server;

  afterInit() {
    ChatGateway.logger.debug(`Socket Server Init Complete`);
  }

  handleConnection(client: Socket) {
    ChatGateway.logger.debug(
      `${client.id}(${client.handshake.query['username']}) is connected!`,
    );

    this.server.emit('msgToClient', {
      name: `admin`,
      text: `join chat.`,
    });
  }

  handleDisconnect(client: Socket) {
    ChatGateway.logger.debug(`${client.id} is disconnected...`);
  }

  @SubscribeMessage('msgToServer')
  handleMessage(
    client: Socket,
    payload: { name: string; text: string },
  ): void {
    this.server.emit('msgToClient', payload);
  }
}

NestJS 서버에서 정적 파일을 사용하도록 설정하고, VueJS로 간단히 만든 채팅 페이지를 불러오도록 합니다.

// src/main.ts

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useStaticAssets(join(__dirname, '..', 'static'));
  await app.listen(process.env.NODE_PORT);
}
bootstrap();





  
    
    
    
    
    Nestjs SocketIO
    
    
    
  
  
    
      
        
          {{ title }}
          

          
          
            
            

            
              
                
                  
                    {{ message.name }}: {{ message.text }}

// assets/3000/main.js

const app = new Vue({
  el: '#app',
  data: {
    title: 'Nestjs Websockets Chat',
    name: '',
    text: '',
    messages: [],
    socket: null,
  },
  methods: {
    sendMessage() {
      if (this.validateInput()) {
        const message = {
          name: this.name,
          text: this.text,
        };
        this.socket.emit('msgToServer', message);
        this.text = '';
      }
    },
    receivedMessage(message) {
      this.messages.push(message);
    },
    validateInput() {
      return this.name.length > 0 && this.text.length > 0;
    },
  },
  created() {
    this.socket = io('http://localhost:3000/chat'); // assets/3001 폴더에서 3001 포트로 수정해줍니다.
    this.socket.on('msgToClient', (message) => {
      this.receivedMessage(message);
    });
  },
});

1yongs_.log

NestJS TDD (입고 알림) - 6. Result

What I Do?

Jest

Scheduler

Docker

Result

느낀점

NestJS TDD (입고 알림) - 4. Scheduler

4-1. Setting Up Task Scheduler

4-2. Scheduler

참고

NestJS TDD (입고 알림) - 5. Run application on Docker

5-1. Dockerfile 작성

5-2. image build

5-3. run on container

참고

5-4. 이러한 도커 수행 과정을 docker-compose로 구성해보자.

궁금한 점

NestJS TDD (입고 알림) - 3. Slack Webhook 연동

참고

3-1. Setting Up

3-2. WatcherService Test Code 작성

3-3. WatcherService notify method 작성

참고

NestJS TDD (입고 알림) - 2. 재고 상태 얻기

2-1. watcher service를 만들어 줍니다.

2-2. 우선 시나리오를 통해 WatcherService 에서 어떤 것을 해야할 지 파악해보죠.

2-3. 그리고 Test 코드를 먼저 작성합시다. (TDD)

2-4. Get URL HTTP Request

2-5. 이제 이 코드를 잘 돌아가게끔 수정합시다.

2-6. 결과

NestJS TDD (입고 알림) - 1. Intro

1. Overview

1-1. Architecture

1-2. FlowChart

1-3. Setting Up Package

NestJS Testing (Jest)

NestJS Testing

Index

Test Code?

Set up

Create New Project

Generate User Resource

installation

Setting Up Project

Main.ts

App Module

Post Entity

Post Module

Post Controller

Post Service

Unit Testing

install

Setting Up Tests

Error!

Solve

Error또 발생!

Solve

Unit Test

Test create() method

Test findAll() method

Test findOne() method

Test update() method

Test remove() method

Result

Test Coverage

End-to-End(e2e) Testing

Setting up

NestJS sentry + slack error로그 수집

NestJS 프로젝트 생성 및 페키지 관련 설치

Sentry 설정

Sentry App

Sentry 연결 및 초기화

NestJS Interceptor 설정

Slack 설정

Slack API Incoming Webhooks 생성

Slack 메세징 솔루션 사용

NestJS Interceptor 적용

Result

2-2. 우선 시나리오를 통해 `WatcherService` 에서 어떤 것을 해야할 지 파악해보죠.

Test `create()` method

Test `findAll()` method

Test `findOne()` method

Test `update()` method

Test `remove()` method