728x90
반응형

지난글에 이어서 PATCH와 DELETE를 구현해보자.

 

먼저 npm 모듈을 설치하고 UpdateCatDto를 만들어준다.

 

$ npm i @nestjs/mapped-types

 

update-cat.dto.ts

import {IsString, IsNumber} from 'class-validator'
import { PartialType } from '@nestjs/mapped-types';
import { CreateCatDto } from './create-cat.dto';

export class UpdateCatDto extends PartialType(CreateCatDto) {}

 

Update 먼저 구현해보자.  컨트롤러와 서비스를 바꿔준다.

 

cats.controller.ts

import { Controller, Get, Param, Post, Delete, Patch, Body, Query } from '@nestjs/common';
import { CatsService } from './cats.service';
import { CreateCatDto } from './dto/create-cat.dto';
import { UpdateCatDto } from './dto/update-cat.dto';
import { Cat } from './schemas/cat.schema';


@Controller('cats')
export class CatsController {
    constructor(private readonly catsService: CatsService) {}

    @Get()
    async getAll(): Promise<Cat[]> {
        return await this.catsService.getAll();
    }

    @Get('/:id')
    async getOne(@Param('id') catId: number): Promise<Cat[]> {
        console.log(catId)
        return await this.catsService.getOne(catId);
    }

    @Post()
    async create(@Body() catsData : CreateCatDto) {
        return await this.catsService.create(catsData);
    }

    @Patch('/:id')
    async update(@Param('id') catId: number, @Body() updateData: UpdateCatDto) {
        return this.catsService.update(catId,updateData)
    }

}

 

cats.service.ts

import { Model } from 'mongoose';
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Cat, CatDocument } from './schemas/cat.schema';
import { CreateCatDto } from './dto/create-cat.dto';
import { UpdateCatDto } from './dto/update-cat.dto';

@Injectable()
export class CatsService {
  constructor(@InjectModel(Cat.name) private catModel: Model<CatDocument>) {}

  async getAll(): Promise<Cat[]> {
    return await this.catModel.find().exec();
  }

  async getOne(id:number): Promise<Cat[]> {
    return await this.catModel.find({"id" : id});
  } 

  async create(catsData: CreateCatDto) {
    let latestId = await this.catModel.findOne();
    return await this.catModel.create({...catsData, id : parseInt(latestId ? latestId.id : 0)+1});
  }

  async update(id: number, updateData : UpdateCatDto) {
    try {
      await this.catModel.where({"id" : id}).update(updateData);
      return true
    }
    catch(e) {
      return false
    }
  }
}

PATCH 메소드로 요청을 보내보자.


 GetAll()로 확인해보자.

 

정상적으로 id가 1인 데이터의 name이 "초코"로 바뀐 것을 확인할 수 있다.

 

 

DELETE도 만들어보자.

 

cats.controller.ts

import { Controller, Get, Param, Post, Delete, Patch, Body, Query } from '@nestjs/common';
import { CatsService } from './cats.service';
import { CreateCatDto } from './dto/create-cat.dto';
import { UpdateCatDto } from './dto/update-cat.dto';
import { Cat } from './schemas/cat.schema';


@Controller('cats')
export class CatsController {
    constructor(private readonly catsService: CatsService) {}

    @Get()
    async getAll(): Promise<Cat[]> {
        return await this.catsService.getAll();
    }

    @Get('/:id')
    async getOne(@Param('id') catId: number): Promise<Cat[]> {
        console.log(catId)
        return await this.catsService.getOne(catId);
    }

    @Post()
    async create(@Body() catsData : CreateCatDto) {
        return await this.catsService.create(catsData);
    }

    @Patch('/:id')
    async update(@Param('id') catId: number, @Body() updateData: UpdateCatDto) {
        return this.catsService.update(catId,updateData)
    }

    @Delete('/:id')
    async delete(@Param('id') catId: number) {
        return this.catsService.delete(catId);
    }

}

 

cats.service.ts

import { Model } from 'mongoose';
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Cat, CatDocument } from './schemas/cat.schema';
import { CreateCatDto } from './dto/create-cat.dto';
import { UpdateCatDto } from './dto/update-cat.dto';

@Injectable()
export class CatsService {
  constructor(@InjectModel(Cat.name) private catModel: Model<CatDocument>) {}

  async getAll(): Promise<Cat[]> {
    return await this.catModel.find().exec();
  }

  async getOne(id:number): Promise<Cat[]> {
    return await this.catModel.find({"id" : id});
  } 

  async create(catsData: CreateCatDto) {
    let latestId = await this.catModel.findOne();
    return await this.catModel.create({...catsData, id : parseInt(latestId ? latestId.id : 0)+1});
  }

  async update(id: number, updateData : UpdateCatDto) {
    try {
      await this.catModel.where({"id" : id}).update(updateData);
      return true
    }
    catch(e) {
      return false
    }
  }

  async delete(id: number) {
    try {
      await this.catModel.remove({"id" : id});
      return true
    }
    catch(e) {
      return false
    }
  }
}

 


postman으로 실행해본다.


getAll() 전체데이터를 확인해본다.

 

 

이렇게 몽고DB로 연결해서 데이터 CRUD 하는 것을 완성하였다.

728x90
반응형

'Back-End > Nest.js' 카테고리의 다른 글

Nest.js | Middleware  (0) 2021.10.28
Nest.js | Swagger  (0) 2021.10.28
Nest.js | MongoDB | Create  (0) 2021.10.06
Nest.js | MongoDB | Find  (0) 2021.10.06
Nest.js | MongoDB | Model,Schema,Controller  (0) 2021.10.06
728x90
반응형

먼저 main.ts 파일에 pipe를 추가한다.

 

main.ts

import { ValidationPipe } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(
    new ValidationPipe({
      whitelist : true, 
      forbidNonWhitelisted : true,
      transform : true
    })
  )
  await app.listen(3000);
}
bootstrap();

 

그다음 컨트롤러와 서비스를 바꿔주자. GetOne 메소드도 추가하였다.

 

cats.cantroller.ts

import { Controller, Get, Param, Post, Delete, Patch, Body, Query } from '@nestjs/common';
import { CatsService } from './cats.service';
import { CreateCatDto } from './dto/create-cat.dto';
import { Cat } from './schemas/cat.schema';


@Controller('cats')
export class CatsController {
    constructor(private readonly catsService: CatsService) {}

    @Get()
    async getAll(): Promise<Cat[]> {
        return await this.catsService.getAll();
    }

    @Get('/:id')
    async getOne(@Param('id') catId: number): Promise<Cat[]> {
        console.log(catId)
        return await this.catsService.getOne(catId);
    }

    @Post()
    async create(@Body() catsData : CreateCatDto) {
        return await this.catsService.create(catsData);
    }

}

 

cats.service.ts

import { Model } from 'mongoose';
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Cat, CatDocument } from './schemas/cat.schema';
import { CreateCatDto } from './dto/create-cat.dto';

@Injectable()
export class CatsService {
  constructor(@InjectModel(Cat.name) private catModel: Model<CatDocument>) {}

  async getAll(): Promise<Cat[]> {
    return await this.catModel.find().exec();
  }

  async getOne(id:number) {
    return await this.catModel.find({"id" : id});
  } 

  async create(catsData: CreateCatDto) {
    let latestId = await this.catModel.findOne();
    return await this.catModel.create({...catsData, id : parseInt(latestId ? latestId.id : 0)+1});
  }
}

생성할 때 id가 최근의 id +1 이 되게끔 하였다.

 

2번 생성한 뒤 postman으로 getAll()을 확인해보자.

 

 

 

mongoose에서 Create는 추가한 값을 그대로 반환해준다. 아주 성공적으로 id가 +1씩 되면서 잘 되었다.

 

 

배열 안에 잘 담겨서 반환된 것을 확인할 수 있다.

728x90
반응형

'Back-End > Nest.js' 카테고리의 다른 글

Nest.js | Swagger  (0) 2021.10.28
Nest.js | MongoDB | PATCH and DELETE  (0) 2021.10.06
Nest.js | MongoDB | Find  (0) 2021.10.06
Nest.js | MongoDB | Model,Schema,Controller  (0) 2021.10.06
Nest.js | MongoDB | Schema  (0) 2021.10.06
728x90
반응형

먼저 다음과 같이 main.ts 파일에 파이프를 추가해준다.

 

main.ts

import { ValidationPipe } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(
    new ValidationPipe({
      whitelist : true, 
      forbidNonWhitelisted : true,
      transform : true
    })
  )
  await app.listen(3000);
}
bootstrap();

 

그다음 controller와 service에 GET메소드로 getAll() 메소드를 만들어보자.

 

cats.controller.ts

import { Controller, Get, Param, Post, Delete, Patch, Body, Query } from '@nestjs/common';
import { CatsService } from './cats.service';
import { CreateCatDto } from './dto/create-cat.dto';
import { Cat } from './schemas/cat.schema';


@Controller('cats')
export class CatsController {
    constructor(private readonly catsService: CatsService) {}

    @Get()
    async getAll(): Promise<Cat[]> {
        return await this.catsService.getAll();
    }


}

 

cats.service.ts

import { Model } from 'mongoose';
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Cat, CatDocument } from './schemas/cat.schema';
import { CreateCatDto } from './dto/create-cat.dto';

@Injectable()
export class CatsService {
  constructor(@InjectModel(Cat.name) private catModel: Model<CatDocument>) {}

  async getAll(): Promise<Cat[]> {
    return await this.catModel.find().exec();
  }
}

 

postman으로 확인해보자

 

 

아직 추가한 Document가 없기 때문에 당연히 빈배열로 받아와진다.

728x90
반응형

'Back-End > Nest.js' 카테고리의 다른 글

Nest.js | MongoDB | PATCH and DELETE  (0) 2021.10.06
Nest.js | MongoDB | Create  (0) 2021.10.06
Nest.js | MongoDB | Model,Schema,Controller  (0) 2021.10.06
Nest.js | MongoDB | Schema  (0) 2021.10.06
Nest.js | E2E TESTING | PATCH and DELETE  (0) 2021.09.30
728x90
반응형

기본적인 cats 모듈,컨트롤러,서비스를 만들고 schemas 폴더를 다음과 같이 옮긴다.

$ nest g module cats
$ nest g co cats
$ nest g s cats

 

 

cats.module.ts 파일을 수정해준다.

cats.module.ts

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { CatsController } from './cats.controller';
import { CatsService } from './cats.service';
import { Cat, CatSchema } from './schemas/cat.schema';

@Module({
  imports: [MongooseModule.forFeature([{ name: Cat.name, schema: CatSchema }])],
  controllers: [CatsController],
  providers: [CatsService],
})
export class CatsModule {}

 

그 다음 지정된 스키마를 @InjectModel() 데코레이터를 사용하여 CatService에 삽입한다.

cats.service.ts

import { Model } from 'mongoose';
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Cat, CatDocument } from './schemas/cat.schema';
import { CreateCatDto } from './dto/create-cat.dto';

@Injectable()
export class CatsService {
  constructor(@InjectModel(Cat.name) private catModel: Model<CatDocument>) {}

}

 

아직 DTO파일을 안 만들었기 때문에 에러가 뜬다. DTO파일을 작성해보자.

 

$ npm i class-validator class-transformer

 

 

create-cat.dto.ts

import {IsString, IsNumber} from 'class-validator'

export class CreateCatDto {
    @IsString()
    readonly name: string;

    @IsNumber()
    readonly age: number;
    
    @IsString({each:true})
    readonly breed: string;
}

 

이제 Contoller를 작성해보자.

 

cat.controller.ts

import { Controller, Get } from '@nestjs/common';
import { CatsService } from './cats.service';
import { Cat } from './schemas/cat.schema';


@Controller('cats')
export class CatsController {
    constructor(private readonly catsService: CatsService) {}

}

 

여기까지 cats모듈과 dto를 만들어보았다.

 

728x90
반응형

'Back-End > Nest.js' 카테고리의 다른 글

Nest.js | MongoDB | Create  (0) 2021.10.06
Nest.js | MongoDB | Find  (0) 2021.10.06
Nest.js | MongoDB | Schema  (0) 2021.10.06
Nest.js | E2E TESTING | PATCH and DELETE  (0) 2021.09.30
Nest.js | E2E TESTING | Testing GET movies id  (0) 2021.09.30
728x90
반응형

이 글은 NestJS document 사이트 기반으로 작성했습니다.

 

https://docs.nestjs.kr/techniques/mongodb

 

네스트JS 한국어 매뉴얼 사이트

네스트JS 한국, 네스트JS Korea 한국어 매뉴얼

docs.nestjs.kr

 

몽고DB설치하는 법은 아래 링크에서 확인 부탁드립니다.

 

https://typo.tistory.com/entry/MongoDB%EC%84%A4%EC%B9%98%ED%95%98%EA%B8%B0%EC%82%AD%EC%A0%9C%ED%95%98%EA%B8%B0?category=866148

 

MongoDB | 설치하기, 삭제하기

1.    몽고DB의 public GPG key 주입 ubuntu@dev:~$ wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | sudo apt-key add - OK 2.    몽고DB를 위한 리스트 파일 생성 ubuntu@dev:~$ echo "d..

typo.tistory.com

 

mongoDB가 준비되었다면 이제 mongoose를 프로젝트 폴더에 설치해준다.

$ npm install --save @nestjs/mongoose mongoose

 

 

이제 MongooseModule을 루트 AppModule로 가져올 수 있다. ( id와 패스워드는 각자 설정한대로)

forRoot() 메소드는 Mongoose 패키지의 mongoose.connect()와 동일한 구성 객체를 허용한다.

 

app.module.ts

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';

@Module({
  imports: [MongooseModule.forRoot('mongodb://test:test1234@localhost:27017/admin')],
})
export class AppModule {}

 

Mongoose에서는 모든 것이 스키마에서 파생된다. 스키마는 모델을 정의하는 데 사용된다.

schemas 폴더를 만들고 cat.schema.ts 파일을 작성해보자.

 

/src/cat/schemas/cat.schema.ts

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

export type CatDocument = Cat & Document;

@Schema()
export class Cat {
  @Prop()
  id: number;

  @Prop()
  name: string;

  @Prop()
  age: number;

  @Prop()
  breed: string;
}

export const CatSchema = SchemaFactory.createForClass(Cat);

 

@Props() 데코레이터는 문서의 속성을 정의한다. 예를 들어 다음과 같이 정의할 수 있다.

@Prop([String])
tags: string[];

 

또는 사용 가능한 옵션에 대한 옵션 객체 인수를 받는다. 기본값을 지정하거나 속성이 필요한지 여부를 나타낼 수 있다.

@Prop({ required: true })
name: string;

 

또는 데코레이터를 사용하지 않음을 선호하는 경우 스키마를 수동으로 정의할 수 있다.

export const CatSchema = new mongoose.Schema({
  name: String,
  age: Number,
  breed: String,
});

 

 

728x90
반응형
728x90
반응형

DELETE와 PATCH도 추가해보자.

DELETE를 먼저 테스트 수행하면 남아있는 데이터가 없기 때문에 PATCH부터 작성한다.

 

  describe('/movies/:id',() => {
    it('GET 200', () => {
      return request(app.getHttpServer())
        .get('/movies/1')
        .expect(200)
    });
    it('GET 404', () => {
      return request(app.getHttpServer())
        .get('/movies/999')
        .expect(404)
    });
    it('PATCH 200', () => {
      return request(app.getHttpServer())
        .patch('/movies/1')
        .send({ title : 'Updated Test'})
        .expect(200)
    });
    it('DELETE 200', () => {
      return request(app.getHttpServer())
        .delete('/movies/1')
        .expect(200);
    });
  });

 

테스트를 수행해보면

 

정상으로 작동했다.

 

이번에는 잘못된 데이터를 가진 movie를 create하는지 테스트해보자.

  describe('/movies', () => {
    it('GET',() => {
      return request(app.getHttpServer())
        .get('/movies')
        .expect(200)
        .expect([]);
    });

    it('POST 201',() => {
      return request(app.getHttpServer())
        .post('/movies')
        .send({
          title: 'Test Movie',
          genres: ['test'],
          year: 2000
        })
        .expect(201)
    });

    it('POST 400',() => {
      return request(app.getHttpServer())
        .post('/movies')
        .send({
          title: 'Test Movie',
          genres: ['test'],
          year: 2000,
          other: "thing"
        })
        .expect(400)
    });

    it('DELETE', () => {
      return request(app.getHttpServer())
        .delete('/movies')
        .expect(404)
    });
  });

 

테스트를 수행해보면

 

 

정상적으로 작동하였다.

728x90
반응형
728x90
반응형

 

우리가 테스트를 진행하는 동안에 테스트를 마치고 다른 테스트를 진행할 때 항상 만들어 두었던 데이터베이스가

사라졌었다.( 새로운 테스트 진행마다 앱이 새로 생성됨 ) 이 과정이 귀찮으면 beforeAll Hook을 추가할 수 있다.

 

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

 

이 부분의 beforeEach를 beforeAll로 바꿔준다. 그다음 GET 메서드에서 id로 getOne함수를 사용하는 부분을 추가하자.

 

import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from './../src/app.module';

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

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

    app = moduleFixture.createNestApplication();
    await app.init();
  });

  it('/ (GET)', () => {
    return request(app.getHttpServer())
      .get('/')
      .expect(200)
      .expect('this is home');
  });

  describe('/movies', () => {
    it('GET',() => {
      return request(app.getHttpServer())
        .get('/movies')
        .expect(200)
        .expect([]);
    });

    it('POST',() => {
      return request(app.getHttpServer())
        .post('/movies')
        .send({
          title: 'Test Movie',
          genres: ['test'],
          year: 2000
        })
        .expect(201)
    });

    it('DELETE', () => {
      return request(app.getHttpServer())
        .delete('/movies')
        .expect(404)
    });
  });

  describe('/movies/:id',() => {
    it('GET 200', () => {
      return request(app.getHttpServer())
        .get('/movies/1')
        .expect(200)
    })
  })

});

 

/movies/:id에 200 status를 받게끔 코딩하고 테스트를 진행해보면

 

이렇게 에러가 뜨는 것을 확인할 수 있다. 왜 그럴까?

 

실제 서버에서 돌아갈 때는 id가 number라고  뜬다(main.ts에서 transform을 써서 number로 받아옴)

하지만 테스팅 서버에서는 

어떤 pipe에도 올리지 않았다.

 

main.ts에서 적용했던 것처럼 테스팅서버에서도 적용하고 실행해보자.

 

 

아주 잘 작동하는것을 확인할 수 있다.

728x90
반응형
728x90
반응형

유닛 테스트를 좋아하는 사람들이 있는 반면에 e2e 테스트를 좋아하는 사람들도 있다.

e2e테스트는 유닛 테스트할 때처럼 하나하나 테스트하지 않는다.

 

 

먼저 Nest 앱을 만들 때 자동으로 만들어진 이 파일들 부터 보면

 

app.e2e-spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import * as request from 'supertest';
import { AppModule } from './../src/app.module';

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

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

    app = moduleFixture.createNestApplication();
    await app.init();
  });

  it('/ (GET)', () => {
    return request(app.getHttpServer())
      .get('/')
      .expect(200)
      .expect('Hello World!');
  });
});

 

 

여기서 유닛테스트를 할 때와는 다르게 it함수 안 쪽에 '/'에 GET method로 들어오는 요청들에 대해 테스트를 한 다는것을 볼 수 있다. 이는 Controller, Service, Pipe의 결과에 대해 모든 테스트를 하고 있다는 뜻이기도 하다.

 

일단 먼저 e2e테스트를 실행해보자.

$ npm run test:e2e

 

 

 

실패다. 자세히 읽어보면

이 부분에서 우리가 루트 경로에 지정했던 문자열과 테스트할 때의 문자열이 다른것을 확인 할 수 있다.

 

app.controller.ts

import { Controller, Get } from '@nestjs/common';

@Controller('')
export class AppController {
    @Get()
    home() {
        return 'this is home'
    }
}

 

때문에 "Hello World!" 였던 부분을 "this is home"으로 바꿔서 다시 실행해보자.

 

app.e2e-spec.ts

it('/ (GET)', () => {
    return request(app.getHttpServer())
      .get('/')
      .expect(200)
      .expect('this is home');
  });

 

테스트를 실행해보자.

 

'/' GET 으로 'this is home' 이라는 반환 값을 성공적으로 받았다.

 

이번엔 movies에서 코드를 추가하고 적용해보자

  it('/movies (GET)',() => {
    return request(app.getHttpServer())
      .get('/movies')
      .expect(200)
      .expect([]);
  })

 

테스트를 해보면

 

 

정상적으로 테스트가 진행되었다.

유닛테스트를 할 때 처럼 좀 더 깔끔하게 다듬어서 POST까지 테스트해보자.

 

app.e2e-spec.ts

  describe('/movies', () => {
    it('GET',() => {
      return request(app.getHttpServer())
        .get('/movies')
        .expect(200)
        .expect([]);
    });

    it('POST',() => {
      return request(app.getHttpServer())
        .post('/movies')
        .send({
          title: 'Test Movie',
          genres: ['test'],
          year: 2000
        })
        .expect(201)
    });
  });

 

테스트를 해보면

성공하였다. 이번엔 DELETE까지 추가해보자.

    it('DELETE', () => {
      return  request(app.getHttpServer())
        .delete('/movies')
        .expect(404)
    });

 

 

이렇게 GET, POST, DELETE 메소드 별로 테스트를 해보았다.

728x90
반응형
728x90
반응형

계속해서 이번엔 Delete와 Create를 테스트 해보자.

 

  describe("deleteOne", () => {

    it("deletes a movie", () => {
      service.create({
        title:"Test Movie",
        genres: ['test'],
        year: 2000
      });
      const allMovies = service.getAll().length;
      service.deleteOne(1);
      const afterDelete = service.getAll().length;
      expect(afterDelete).toBeLessThan(allMovies);
    });

  });

 

한 개의 데이터를 삭제 했으니 기존의 것보다 개수가 줄었다는 것을 테스트한다.

404 error 까지 코드를 추가하고 테스트를 실행해보자.

 

  describe("deleteOne", () => {

    it("deletes a movie", () => {
      service.create({
        title:"Test Movie",
        genres: ['test'],
        year: 2000
      });
      const allMovies = service.getAll().length;
      service.deleteOne(1);
      const afterDelete = service.getAll().length;
      expect(afterDelete).toBeLessThan(allMovies);
    });
    it("should throw 404 error", () => {
      try {
        service.deleteOne(999);
      }
      catch(e){
        expect(e).toBeInstanceOf(NotFoundException)
      }
    })

  });

 

 

이처럼 테스트가 정상 작동하는 것을 볼 수 있다.

 

Create도 마찬가지로 추가하고 테스트를 진행해보자.

  describe("create", () => {

    it("should create a movie", () => {
      const beforeCreate = service.getAll().length;
      service.create({
        title: 'Test Movie',
        genres: ['test'],
        year: 2000
      });
      const afterCreate = service.getAll().length;
      expect(afterCreate).toBeGreaterThan(beforeCreate)
    })

  })

 

728x90
반응형
728x90
반응형

이제 function을 테스트해보자.

 

movies.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { MoviesService } from './movies.service';

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

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [MoviesService],
    }).compile();

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

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

  describe("getAll", () => {
    it("should be return an array", () => {
      const result = service.getAll();
      expect(result).toBeInstanceOf(Array);
    })
  })

});

 

이런 식으로 하단 부분에 테스트 코드를 추가해보면, getAll 함수가 array를 반환하는지에 대해 테스트를 해볼 수 있다.

 

getOne부분도 추가해보자

  describe("getOne", () => {
    it("should be return a movie", () => {
      service.create({
        title:"Test Movie",
        genres: ['test'],
        year: 2000
      });
      
      const movie = service.getOne(1);
      expect(movie).toBeDefined()
    })
  })

 

 

자 이제 npm run test를 해보면, 

 

테스트가 정상적으로 수행되는 것을 확인할 수 있다.

 

 

이번엔 404 error를 테스트해보자.

  it("should throw 404 error", () => {
    try {
      service.getOne(999);
    }
    catch(e){
      expect(e).toBeInstanceOf(NotFoundException)
    }
  })

코드를 추가하고 npm run test를 실행한다.

 

 

테스트가 정상 작동하는 것을 확인할 수 있다.

728x90
반응형

+ Recent posts