userController&test

server/package.json

@@ -20,8 +20,8 @@
     "test:e2e": "jest --config ./test/jest-e2e.json"
   },
   "dependencies": {
-    "@nestjs/common": "^6.0.0",
-    "@nestjs/core": "^6.0.0",
+    "@nestjs/common": "^6.2.4",
+    "@nestjs/core": "^6.2.4",
     "@nestjs/platform-express": "^6.0.0",
     "@nestjs/typeorm": "^6.1.1",
     "class-validator": "^0.9.1",
@@ -33,12 +33,13 @@
     "web3": "^1.0.0-beta.55"
   },
   "devDependencies": {
-    "@nestjs/testing": "^6.1.1",
+    "@nestjs/testing": "^6.2.4",
     "@types/express": "^4.16.0",
     "@types/jest": "^23.3.13",
     "@types/node": "^10.12.18",
     "@types/supertest": "^2.0.7",
     "jest": "^23.6.0",
+    "jest-create-mock-instance": "^1.1.0",
     "nodemon": "^1.18.9",
     "prettier": "^1.15.3",
     "supertest": "^3.4.1",

server/src/app/user/user.service.impl.spec.ts

@@ -4,6 +4,7 @@ import {TestingModule, Test} from '@nestjs/testing';
 import {User} from '../../domain/user/user.entity';
 import {UserDto} from '../../domain/user/dto/user.dto';
 import {UserRepository} from '../../port/persistence/repository/user.repository.impl';
+import {BadRequestException} from "@nestjs/common";
 
 describe('UserServiceImpl', () => {
     const address = 'testAddress';
@@ -44,11 +45,13 @@ describe('UserServiceImpl', () => {
 
             expect(await service.get(id)).toBe(user);
         });
-        it('should return undefined', async () => {
+        it('should throw BadRequestException', async () => {
             when(mockRepository.findById(null)).thenReturn(undefined);
             service = new UserServiceImpl(instance(mockRepository));
 
-            expect(await service.get(null)).toBeUndefined();
+            await expect(service.get(null))
+                .rejects
+                .toThrowError(BadRequestException);
         });
     });
     describe('#create()', () => {

server/src/app/user/user.service.impl.ts

@@ -1,4 +1,4 @@
-import {Inject, Injectable} from '@nestjs/common';
+import {BadRequestException, Inject, Injectable} from '@nestjs/common';
 import {UserService} from './user.service';
 import {UserDto} from '../../domain/user/dto/user.dto';
 import {User} from '../../domain/user/user.entity';
@@ -11,6 +11,10 @@ export class UserServiceImpl implements UserService {
     constructor(@Inject('IUserRepository') private userRepository: IUserRepository) {}
 
     async get(id: number): Promise<User> {
+        let user = await this.userRepository.findById(id);
+        if (user == undefined) {
+            throw new BadRequestException('no user with the id')
+        }
         return await this.userRepository.findById(id);
     }
     async create(userDto: UserDto): Promise<User> {

server/src/port/module/user.module.ts

@@ -1,10 +1,12 @@
 import { Module } from '@nestjs/common';
 import {UserServiceImpl} from '../../app/user/user.service.impl';
 import {UserRepository} from '../persistence/repository/user.repository.impl';
+import {UserController} from "../../web/user/user.controller";
 
 @Module({
+    controllers: [UserController],
     providers: [
-        UserServiceImpl,
+        {provide: 'UserService', useClass: UserServiceImpl},
         {provide: 'IUserRepository', useClass: UserRepository},
     ],
 })

server/src/web/user/user.controller.spec.ts

@@ -0,0 +1,150 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { UserController } from './user.controller';
+import {instance, mock, when} from 'ts-mockito';
+import {UserService} from '../../app/user/user.service';
+import {UserServiceImpl} from '../../app/user/user.service.impl';
+import {User} from '../../domain/user/user.entity';
+import {UserDto} from '../../domain/user/dto/user.dto';
+import {BadRequestException} from "@nestjs/common";
+
+describe('User Controller', () => {
+  const mockUserService = mock(UserServiceImpl);
+  const address = 'testAddress';
+  const name = 'name';
+  let user: User;
+  let controller: UserController;
+
+  beforeEach(() => {
+    user = new User(address, name);
+  });
+
+  describe('dependency resolve', () => {
+    it('should be defined', async () => {
+      const module: TestingModule = await Test.createTestingModule({
+        controllers: [
+          UserController,
+        ],
+        providers: [
+          {
+            provide: 'UserService',
+            useValue: instance(mockUserService),
+          },
+        ],
+      }).compile();
+
+      controller = module.get<UserController>(UserController);
+      expect(controller).toBeDefined();
+    });
+  });
+  describe('#get()', () => {
+    const id = 1;
+
+    it('should return user', async () => {
+      when(mockUserService.get(id)).thenReturn(new Promise((resolve) => {
+        resolve(user);
+      }));
+      controller = new UserController(instance(mockUserService));
+
+      expect(await controller.get(id)).toBe(user);
+
+    });
+    it('should return undefined', async () => {
+      when(mockUserService.get(id)).thenThrow(new BadRequestException('no user with the id'));
+      controller = new UserController(instance(mockUserService));
+
+      await expect(controller.get(id))
+          .rejects
+          .toThrowError(BadRequestException);
+    });
+  });
+  describe('#create()', () => {
+    let userDto: UserDto;
+
+    it('should return user', async () => {
+      userDto = new UserDto(address, name);
+      when(mockUserService.create(userDto)).thenReturn(new Promise((resolve => {
+        resolve(user);
+      })));
+      controller = new UserController(instance(mockUserService));
+
+      expect(await controller.create(userDto)).toBe(user);
+
+    });
+    it('should return undefined', async () => {
+      userDto = new UserDto();
+      when(mockUserService.create(userDto)).thenThrow(new Error('some errors'));
+      controller = new UserController(instance(mockUserService));
+
+      await expect(controller.create(userDto))
+          .rejects
+          .toThrowError('some errors');
+    });
+  });
+  describe('#delete()', () => {
+    const id = 1;
+
+    it('should return undefined', async () => {
+      when(mockUserService.delete(id)).thenReturn(new Promise((resolve => resolve(undefined))));
+      controller = new UserController(instance(mockUserService));
+
+      expect(await controller.delete(id)).toBe(undefined);
+    });
+  });
+  describe('#increaseLevel()', () => {
+    const id = 1;
+    const amount = 10;
+
+    it('should return user', async () => {
+      when(mockUserService.increaseLevel(id, amount)).thenReturn(new Promise((resolve => resolve(user))));
+      controller = new UserController(instance(mockUserService));
+
+      expect(await controller.increaseLevel(id, amount)).toBe(user);
+    });
+    it('should throw error', async () => {
+      when(mockUserService.increaseLevel(id, amount)).thenThrow(new Error('some errors'));
+      controller = new UserController(instance(mockUserService));
+
+      await expect(controller.increaseLevel(id, amount))
+          .rejects
+          .toThrowError('some errors');
+    });
+  });
+  describe('#increasePoint()', () => {
+    const id = 1;
+    const amount = 10;
+
+    it('should return user', async () => {
+      when(mockUserService.increasePoint(id, amount)).thenReturn(new Promise((resolve => resolve(user))));
+      controller = new UserController(instance(mockUserService));
+
+      expect(await controller.increasePoint(id, amount)).toBe(user);
+    });
+    it('should thorow error', async () => {
+      when(mockUserService.increasePoint(id, amount)).thenThrow(new Error('some errors'));
+      controller = new UserController(instance(mockUserService));
+
+      await expect(controller.increasePoint(id, amount))
+          .rejects
+          .toThrowError('some errors');
+    });
+  });
+  describe('#decreasePoint()', () => {
+    const id = 1;
+    const amount = 10;
+
+    it('should return user', async () => {
+      when(mockUserService.decreasePoint(id, amount)).thenReturn(new Promise((resolve => resolve(user))));
+      controller = new UserController(instance(mockUserService));
+
+      expect(await controller.decreasePoint(id, amount)).toBe(user);
+    });
+    it('should thorow error', async () => {
+      when(mockUserService.decreasePoint(id, amount)).thenThrow(new Error('some errors'));
+      controller = new UserController(instance(mockUserService));
+
+      await expect(controller.decreasePoint(id, amount))
+          .rejects
+          .toThrowError('some errors');
+    });
+  });
+});

server/src/web/user/user.controller.ts

@@ -0,0 +1,40 @@
+import {BadRequestException, Body, Controller, Delete, Get, Inject, Injectable, Param, Post, Req} from '@nestjs/common';
+import {User} from '../../domain/user/user.entity';
+import {UserDto} from '../../domain/user/dto/user.dto';
+import {DeleteResult} from 'typeorm';
+import {UserService} from '../../app/user/user.service';
+
+@Injectable()
+@Controller('users')
+export class UserController {
+    constructor(@Inject('UserService') private service: UserService) {}
+
+    @Get(':id')
+    async get(@Param('id') id: number): Promise<User> {
+        return await this.service.get(id);
+    }
+
+    @Post()
+    async create(@Body() userDto: UserDto): Promise<User> {
+        return await this.service.create(userDto);
+    }
+
+    @Delete(':id')
+    async delete(@Param('id') id: number): Promise<DeleteResult> {
+        return await this.service.delete(id);
+    }
+
+    @Post(':id')
+    async increaseLevel(@Param('id') id: number, @Param('amount') amount: number): Promise<User> {
+        return await this.service.increaseLevel(id, amount);
+    }
+
+    @Post(':id')
+    async decreasePoint(@Param('id') id: number, @Param('amount') amount: number): Promise<User> {
+        return await this.service.decreasePoint(id, amount);
+    }
+    @Post(':id')
+    async increasePoint(@Param('id') id: number, @Param('amount') amount: number): Promise<User> {
+        return await this.service.increasePoint(id, amount);
+    }
+}