Cleanup and fixes

backend/src/app.module.ts

@@ -4,7 +4,7 @@ import configuration from './config/configuration';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
 import { DatabaseModule } from './database/database.module';
-import { PostsModule } from './posts/posts.module';
+import { BlogPostsModule } from './blogposts/blogposts.module';
 import { UsersModule } from './users/users.module';
 
 @Module({
@@ -13,7 +13,7 @@ import { UsersModule } from './users/users.module';
       load: [configuration]
     }),
     DatabaseModule,
-    PostsModule,
+    BlogPostsModule,
     UsersModule
   ],
   controllers: [AppController],

backend/src/blogposts/blogpost.entity.ts

@@ -1,7 +1,7 @@
 import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';
 
 @Entity()
-export class Post {
+export class BlogPost {
   @PrimaryGeneratedColumn()
   id: number
 

backend/src/blogposts/blogposts.controller.spec.ts

@@ -0,0 +1,34 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { BlogPostsController } from './blogposts.controller';
+import { BlogPostsService } from './blogposts.service';
+import { BlogPost } from './blogpost.entity';
+
+const mockBlogPost = new BlogPost();
+
+describe('BlogPostsController', () => {
+  let controller: BlogPostsController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [BlogPostsController],
+      providers: [
+        BlogPostsService,
+        {
+          provide: getRepositoryToken(BlogPost),
+          useValue: {
+            findAll: jest.fn().mockResolvedValue([mockBlogPost]),
+            findOne: jest.fn().mockResolvedValue(mockBlogPost),
+            create: jest.fn().mockResolvedValue(1),
+          },
+        },
+      ]
+    }).compile();
+
+    controller = module.get<BlogPostsController>(BlogPostsController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

backend/src/blogposts/blogposts.controller.ts

@@ -0,0 +1,25 @@
+import { Body, Controller, Get, Param, Post } from '@nestjs/common';
+import { BlogPostsService } from './blogposts.service';
+import { CreateBlogPostDto } from './dto/create-blog-post.dto';
+import { BlogPost } from './blogpost.entity';
+
+@Controller('blogposts')
+export class BlogPostsController {
+
+  constructor(private readonly blogPostsService: BlogPostsService) {}
+
+  @Get()
+  findAll(): Promise<BlogPost[]> {
+    return this.blogPostsService.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: number): Promise<BlogPost | null> {
+    return this.blogPostsService.findOne(id);
+  }
+
+  @Post()
+  create(@Body() createBlogPostDto: CreateBlogPostDto): Promise<number> {
+    return this.blogPostsService.create(createBlogPostDto);
+  }
+}

backend/src/blogposts/blogposts.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { BlogPost } from './blogpost.entity';
+import { BlogPostsService } from './blogposts.service';
+import { BlogPostsController } from './blogposts.controller';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([BlogPost])],
+  controllers: [BlogPostsController],
+  providers: [BlogPostsService],
+  exports: [TypeOrmModule]
+})
+export class BlogPostsModule {}

backend/src/blogposts/blogposts.repositorymock.factory.ts

@@ -0,0 +1,4 @@
+// @ts-ignore
+export const repositoryMockFactory: () => MockType<Repository<any>> = jest.fn(() => ({
+  findOne: jest.fn(entity => entity),
+}));

backend/src/blogposts/blogposts.service.spec.ts

@@ -0,0 +1,32 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { BlogPostsService } from './blogposts.service';
+import { BlogPost } from './blogpost.entity';
+
+const mockBlogPost = new BlogPost();
+
+describe('BlogPostsService', () => {
+  let service: BlogPostsService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        BlogPostsService,
+        {
+          provide: getRepositoryToken(BlogPost),
+          useValue: {
+            findAll: jest.fn().mockResolvedValue([mockBlogPost]),
+            findOne: jest.fn().mockResolvedValue(mockBlogPost),
+            create: jest.fn().mockResolvedValue(1),
+          },
+        },
+      ],
+    }).compile();
+
+    service = module.get<BlogPostsService>(BlogPostsService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/blogposts/blogposts.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { DataSource, Repository } from 'typeorm';
+import { BlogPost } from './blogpost.entity';
+import { CreateBlogPostDto } from './dto/create-blog-post.dto';
+
+@Injectable()
+export class BlogPostsService {
+  constructor(
+    @InjectRepository(BlogPost)
+    private blogPostsRepository: Repository<BlogPost>
+  ) {}
+
+  findAll(): Promise<BlogPost[]> {
+    return this.blogPostsRepository.find();
+  }
+
+  findOne(id: number): Promise<BlogPost | null> {
+    return this.blogPostsRepository.findOneBy({ id });
+  }
+
+  async create(createBlogPostDto: CreateBlogPostDto): Promise<number> {
+    const newBlogPost = this.blogPostsRepository.create({
+      title: createBlogPostDto.title,
+      body: createBlogPostDto.body
+    });
+    const blogPost = await this.blogPostsRepository.save(newBlogPost);
+    return blogPost.id;
+  }
+
+  async remove(id: number): Promise<void> {
+    await this.blogPostsRepository.delete(id);
+  }
+}

backend/src/blogposts/dto/create-blog-post.dto.ts

@@ -0,0 +1,4 @@
+export class CreateBlogPostDto {
+  title: string;
+  body: string;
+}

backend/src/mocktype.ts

@@ -0,0 +1,3 @@
+export type MockType<T> = {
+  [P in keyof T]?: jest.Mock<{}>;
+};

backend/src/posts/dto/create-post.dto.ts

@@ -1,4 +0,0 @@
-export CreatePostDto {
-  title: string;
-  body: string;
-}

backend/src/posts/posts.controller.spec.ts

@@ -1,18 +0,0 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { PostsController } from './posts.controller';
-
-describe('PostsController', () => {
-  let controller: PostsController;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      controllers: [PostsController],
-    }).compile();
-
-    controller = module.get<PostsController>(PostsController);
-  });
-
-  it('should be defined', () => {
-    expect(controller).toBeDefined();
-  });
-});

backend/src/posts/posts.controller.ts

@@ -1,24 +0,0 @@
-import { Controller, Get } from '@nestjs/common';
-import { PostsService } from './posts.service';
-import { CreatePostDto } from './dto';
-
-@Controller('posts')
-export class PostsController {
-
-  constructor(private readonly postsService: PostService) {}
-
-  @Get()
-  findAll(): string {
-    return this.postsService.findAll();
-  }
-
-  @Get(':id')
-  findOne(@Param('id') id: string): string {
-    return this.postsService.findOne(id);
-  }
-
-  @Post()
-  create(@Body() createPostDto: CreatePostDto): string {
-    return this.postsService;
-  }
-}

backend/src/posts/posts.module.ts

@@ -1,9 +0,0 @@
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { Post } from './Post.entity';
-
-@Module({
-  imports: [TypeOrmModule.forFeature([Post])],
-  exports: [TypeOrmModule]
-})
-export class PostsModule {}

backend/src/posts/posts.service.spec.ts

@@ -1,18 +0,0 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { PostsService } from './posts.service';
-
-describe('PostsService', () => {
-  let service: PostsService;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [PostsService],
-    }).compile();
-
-    service = module.get<PostsService>(PostsService);
-  });
-
-  it('should be defined', () => {
-    expect(service).toBeDefined();
-  });
-});

backend/src/posts/posts.service.ts

@@ -1,33 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
-import { Post } from './Post.entity';
-
-@Injectable()
-export class PostsService {
-  constructor(
-    @InjectRepository(Post)
-    private PostsRepository: Repository<Post>,
-  ) {}
-
-  findAll(): Promise<Post[]> {
-    return this.PostsRepository.find();
-  }
-
-  findOne(id: number): Promise<Post | null> {
-    return this.PostsRepository.findOneBy({ id });
-  }
-
-  async create(title: string, body: string) Promise<void> {
-    const newPost = this.PostsRepository.create({
-      title: title,
-      body: body
-    });
-    const post = await this.PostsRepository.save(newPost);
-    return post.id;
-  }
-
-  async remove(id: number): Promise<void> {
-    await this.PostsRepository.delete(id);
-  }
-}

backend/src/users/users.service.spec.ts

@@ -1,12 +1,25 @@
 import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
 import { UsersService } from './users.service';
+import { User } from './user.entity';
+
+const mockUser = new User();
 
 describe('UsersService', () => {
   let service: UsersService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [UsersService],
+      providers: [
+        UsersService ,
+        {
+          provide: getRepositoryToken(User),
+          useValue: {
+            save: jest.fn().mockResolvedValue(mockUser),
+            find: jest.fn().mockResolvedValue([mockUser]),
+          },
+        },
+      ]
     }).compile();
 
     service = module.get<UsersService>(UsersService);