unit test

package.json

@@ -39,17 +39,23 @@
     "testEnvironment": "node"
   },
   "devDependencies": {
+    "@nestjs/platform-express": "^9.0.3",
+    "@nestjs/testing": "^9.0.3",
+    "@nestjs/typeorm": "^9.0.0",
     "@types/jest": "^28.1.5",
     "@types/lodash": "^4.14.182",
     "@types/node": "^18.0.4",
+    "@types/supertest": "^2.0.12",
     "@typescript-eslint/eslint-plugin": "^4.33.0",
     "@typescript-eslint/parser": "^4.33.0",
     "eslint": "^7.32.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-prettier": "^3.4.1",
     "jest": "^28.1.3",
+    "pg": "^8.7.3",
     "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
+    "supertest": "^6.2.4",
     "ts-jest": "^28.0.6",
     "typescript": "^4.7.4"
   },

src/crud-base.ts

@@ -305,7 +305,7 @@ export class CrudBase<T extends ValidCrudEntity<T>> {
     return new BlankReturnMessageDto(200, 'success');
   }
 
-  async remove(id: EntityId<T>, cond: FindOptionsWhere<T> = {}) {
+  async delete(id: EntityId<T>, cond: FindOptionsWhere<T> = {}) {
     let result: UpdateResult | DeleteResult;
     const searchCond = {
       id,
@@ -382,7 +382,7 @@ export class CrudBase<T extends ValidCrudEntity<T>> {
 
 export function CrudService<T extends ValidCrudEntity<T>>(
   entityClass: ClassType<T>,
-  crudOptions: CrudOptions<T>,
+  crudOptions: CrudOptions<T> = {},
 ) {
   return class CrudServiceImpl extends CrudBase<T> {
     constructor(repo: Repository<T>) {

src/decorators/restful.ts

@@ -87,7 +87,7 @@ export class RestfulFactory<T extends TimeBase> {
     ]);
   }
 
-  findOneId() {
+  idParam() {
     if (this.idType === Number) {
       return Param('id', ParseIntPipe);
     } else {

tests/sample.spec.ts → tests/entity.spec.ts

-import { Index } from 'typeorm';
 import { plainToInstance } from 'class-transformer';
-import { EnumColumn, IntColumn, StringColumn, IdBase, StringIdBase } from '..';
 import { validateSync } from 'class-validator';
+import { Gender, User, User2 } from './utility/user';
 
-enum Gender {
-  F = 'F',
-  M = 'M',
-}
-
-class User extends IdBase() {
-  @Index()
-  @StringColumn(5, {
-    required: true,
-  })
-  name: string;
-
-  @IntColumn('int', { unsigned: true })
-  age: number;
-
-  @EnumColumn(Gender)
-  gender: Gender;
-}
-
-class User2 extends StringIdBase({ length: 20 }) {
-  @Index()
-  @StringColumn(5, {
-    required: true,
-  })
-  name: string;
-
-  @IntColumn('int', { unsigned: true })
-  age: number;
-
-  @EnumColumn(Gender)
-  gender: Gender;
-}
-
-describe('nicot', () => {
+describe('entity', () => {
   it('creates entity class', () => {
     expect(
       validateSync(plainToInstance(User, { name: 'John', age: 20 })),

tests/module.spec.ts

+import { NestExpressApplication } from '@nestjs/platform-express';
+import { Controller, Injectable } from '@nestjs/common';
+import { CrudService } from '../src/crud-base';
+import { Gender, User } from './utility/user';
+import { RestfulFactory } from '../src/decorators';
+import { Test } from '@nestjs/testing';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { DataSource } from 'typeorm';
+import request from 'supertest';
+
+@Injectable()
+class UserService extends CrudService(User) {
+  constructor(db: DataSource) {
+    super(db.getRepository(User));
+  }
+}
+
+const dec = new RestfulFactory(User);
+class UpdateUserDto extends dec.updateDto {}
+
+@Controller('user')
+class UserController {
+  constructor(private userService: UserService) {}
+
+  @dec.create()
+  create(@dec.createParam() user: User) {
+    return this.userService.create(user);
+  }
+
+  @dec.findOne()
+  findOne(@dec.idParam() id: number) {
+    return this.userService.findOne(id);
+  }
+
+  @dec.findAll()
+  findAll(@dec.findAllParam() user: UpdateUserDto) {
+    return this.userService.findAll(user);
+  }
+
+  @dec.update()
+  update(@dec.idParam() id: number, @dec.updateParam() user: UpdateUserDto) {
+    return this.userService.update(id, user);
+  }
+
+  @dec.delete()
+  delete(@dec.idParam() id: number) {
+    return this.userService.delete(id);
+  }
+}
+
+describe('app', () => {
+  let app: NestExpressApplication;
+
+  beforeEach(async () => {
+    const module = await Test.createTestingModule({
+      imports: [
+        TypeOrmModule.forRoot({
+          type: 'postgres',
+          dropSchema: true,
+          synchronize: true,
+          entities: [User],
+          host: 'localhost',
+          port: 5432,
+          username: 'postgres',
+          password: 'postgres',
+          database: 'postgres',
+        }),
+      ],
+      providers: [UserService],
+      controllers: [UserController],
+    }).compile();
+    app = module.createNestApplication<NestExpressApplication>();
+    await app.init();
+  });
+
+  it('should work with database', async () => {
+    const userService = app.get(UserService);
+    expect(userService).toBeDefined();
+    const user = new User();
+    user.name = 'Yuzu';
+    user.age = 20;
+    user.gender = Gender.F;
+    const createResult = await userService.create(user);
+    expect(createResult.data).toBeInstanceOf(User);
+    const getUser = await userService.findOne(createResult.data.id);
+    expect(getUser.data.name).toBe('Yuzu');
+    const getUsers = await userService.findAll({ name: 'Yuzu' });
+    expect(getUsers.data).toHaveLength(1);
+    await userService.update(createResult.data.id, {
+      name: 'Nana',
+    });
+    const getUpdatedUser = await userService.findOne(createResult.data.id);
+    expect(getUpdatedUser.data.name).toBe('Nana');
+    await userService.delete(createResult.data.id);
+    const getDeletedUser = await userService.findAll({ name: 'Nana' });
+    expect(getDeletedUser.data).toHaveLength(0);
+  });
+
+  it('should work with controller', async () => {
+    const server = await app.getHttpServer();
+    await request(server)
+      .post('/user')
+      .send({ name: 'Yuzu', age: 20, gender: 'F' })
+      .expect(201);
+    await request(server)
+      .get('/user/1')
+      .expect({
+        success: true,
+        statusCode: 200,
+        message: 'success',
+        data: { id: 1, name: 'Yuzu', age: 20, gender: 'F' },
+      });
+    await request(server)
+      .patch('/user/1')
+      .send({ name: 'Nana' })
+      .expect(200)
+      .expect({
+        success: true,
+        statusCode: 200,
+        message: 'success',
+      });
+    await request(server)
+      .get('/user/1')
+      .expect({
+        success: true,
+        statusCode: 200,
+        message: 'success',
+        data: { id: 1, name: 'Nana', age: 20, gender: 'F' },
+      });
+    await request(server).delete('/user/1').expect({
+      success: true,
+      statusCode: 204,
+      message: 'success',
+    });
+    await request(server).get('/user/1').expect(404);
+  });
+});

tests/utility/user.ts

+import { Entity, Index } from 'typeorm';
+import { EnumColumn, IntColumn, StringColumn } from '../../src/decorators';
+import { IdBase, StringIdBase } from '../../src/bases';
+
+export enum Gender {
+  F = 'F',
+  M = 'M',
+}
+
+@Entity()
+export class User extends IdBase() {
+  @Index()
+  @StringColumn(5, {
+    required: true,
+  })
+  name: string;
+
+  @IntColumn('int', { unsigned: true })
+  age: number;
+
+  @EnumColumn(Gender)
+  gender: Gender;
+}
+
+@Entity()
+export class User2 extends StringIdBase({ length: 20 }) {
+  @Index()
+  @StringColumn(5, {
+    required: true,
+  })
+  name: string;
+
+  @IntColumn('int', { unsigned: true })
+  age: number;
+
+  @EnumColumn(Gender)
+  gender: Gender;
+}