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/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,105 @@
+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';
+
+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)).thenReturn(new Promise((resolve) => resolve(undefined)));
+      controller = new UserController(instance(mockUserService));
+
+      expect(await controller.get(id)).toBe(undefined);
+    });
+  });
+  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)).thenReturn(new Promise(((resolve) => resolve(undefined))));
+      controller = new UserController(instance(mockUserService));
+
+      expect(await controller.create(userDto)).toBe(undefined);
+    });
+  });
+  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 return undefined', async () => {
+      when(mockUserService.increaseLevel(id, amount)).thenReturn(undefined);
+      controller = new UserController(instance(mockUserService));
+
+      expect(await controller.increaseLevel(id, amount)).toBe(undefined);
+    });
+  });
+});

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

@@ -0,0 +1,44 @@
+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> {
+        let user = await this.service.get(id);
+        if (user == undefined) {
+            throw new BadRequestException('no user with the id');
+        }
+        return user;
+    }
+
+    @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);
+    }
+}

server/test/user/user.e2e-spec.ts

@@ -0,0 +1,81 @@
+import {INestApplication} from '@nestjs/common';
+import {Test} from '@nestjs/testing';
+import request from 'supertest';
+import {UserModule} from '../../src/port/module/user.module';
+import {UserServiceImpl} from '../../src/app/user/user.service.impl';
+import {User} from '../../src/domain/user/user.entity';
+import createMockInstance from "jest-create-mock-instance";
+import {UserService} from "../../src/app/user/user.service";
+
+
+describe('User', () => {
+   let app: INestApplication;
+
+   const mockUserServiceImpl = createMockInstance(UserServiceImpl);
+
+   afterAll(async () => await app.close());
+
+   describe('#get()',  () => {
+       let url: string;
+       let user: User;
+       let response;
+
+       it('should return 200', async () => {
+           url = '/users/1';
+           user = new User('testAddress', 'testName');
+           response = { address: 'testAddress', name: 'testName', point: 0, level: 0 };
+
+           mockUserServiceImpl.get = jest.fn().mockReturnValue(user);
+
+           const module = await Test.createTestingModule({
+               imports: [UserModule],
+           })
+               .overrideProvider('UserService')
+               .useValue(mockUserServiceImpl)
+               .compile();
+
+           app = module.createNestApplication();
+           await app.init();
+
+           return request(app.getHttpServer())
+               .get(url)
+               .expect(200)
+               .expect(response);
+       });
+       it('should return 400', async () => {
+           url = '/users/1';
+           response = { statusCode: 400, error: 'Bad Request', message: 'no user with the id' };
+           mockUserServiceImpl.get = jest.fn().mockReturnValue(undefined);
+           const module = await Test.createTestingModule({
+               imports: [UserModule],
+           })
+               .overrideProvider('UserService')
+               .useValue(mockUserServiceImpl)
+               .compile();
+
+           app = module.createNestApplication();
+           await app.init();
+
+           return request(app.getHttpServer())
+               .get(url)
+               .expect(400)
+               .expect(response);
+       });
+   });
+   describe('#create()', () => {
+       it('should return 200', async () => {
+
+       });
+       it('should return 400', async () => {
+
+       });
+   });
+   describe('#delete()',  () => {
+       it('should return 200', async () => {
+
+       });
+       it('should return 400', async () => {
+
+       });
+   });
+});