Merge branch 'fixUnitTests'

src/audit/audit.module.ts

@@ -3,7 +3,7 @@ import { Audit } from './entities/audit.entity';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { AuditService } from './services/audit.service';
 import { AuditSubscriber } from './subscribers/audit.subscriber';
-import { AuthModule } from 'src/auth/auth.module';
+import { AuthModule } from '../auth/auth.module';
 import { AuditInterceptor } from './interceptors/audit.interceptor';
 
 @Module({

src/audit/interceptors/audit.interceptor.spec.ts

@@ -1,7 +1,23 @@
 import { AuditInterceptor } from './audit.interceptor';
+import { TestingModule, Test } from '@nestjs/testing';
+import { serviceMockFactory, MockType } from '../../../test/unit/helpers';
+import { AuditService } from '../services/audit.service';
 
 describe('AuditInterceptor', () => {
+  let interceptor: AuditInterceptor;
+  let auditServiceMock: MockType<AuditService>
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        AuditInterceptor,
+        { provide: AuditService, useFactory: serviceMockFactory },
+      ],
+    }).compile();
+
+    interceptor = module.get<AuditInterceptor>(AuditInterceptor);
+    auditServiceMock = module.get(AuditService)
+  });
   it('should be defined', () => {
-    expect(new AuditInterceptor()).toBeDefined();
+    expect(interceptor).toBeDefined();
   });
 });

src/audit/services/audit.service.spec.ts

@@ -1,15 +1,25 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AuditService } from './audit.service';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { repositoryMockFactory, MockType } from '../../../test/unit/helpers';
+import { Audit } from '../entities/audit.entity';
+import { Repository } from 'typeorm';
 
 describe('AuditService', () => {
   let service: AuditService;
+  let auditRepositoryMock: MockType<Repository<Audit>>
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [AuditService],
+      providers: [
+        AuditService,
+        { provide: getRepositoryToken(Audit), useFactory: repositoryMockFactory },
+      ],
     }).compile();
 
     service = module.get<AuditService>(AuditService);
+
+    auditRepositoryMock = module.get(getRepositoryToken(Audit))
   });
 
   it('should be defined', () => {

src/audit/subscribers/audit.subscriber.spec.ts

@@ -0,0 +1,30 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { getConnectionToken } from '@nestjs/typeorm';
+import { MockType, serviceMockFactory } from '../../../test/unit/helpers';
+import { AuditSubscriber } from './audit.subscriber';
+import { AuditService } from '../services/audit.service';
+
+describe('AuditSubscriber', () => {
+  let subscriber: AuditSubscriber;
+  let auditServiceMock: MockType<AuditService>
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        AuditSubscriber,
+        { provide: getConnectionToken(), useValue: {
+            subscribers: []
+        } },
+        { provide: AuditService, useFactory: serviceMockFactory },
+      ],
+    }).compile();
+
+    subscriber = module.get<AuditSubscriber>(AuditSubscriber);
+
+    auditServiceMock = module.get(AuditService)
+  });
+
+  it('should be defined', () => {
+    expect(subscriber).toBeDefined();
+  });
+});

src/auth/auth.module.ts

@@ -4,7 +4,7 @@ import { PassportModule } from '@nestjs/passport';
 import { JwtModule } from '@nestjs/jwt';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { JwtStrategy } from './strategies/jwt.strategy';
-import { User } from 'src/users/entities/user.entity';
+import { User } from '../users/entities/user.entity';
 import { TypeOrmModule } from '@nestjs/typeorm';
 
 @Module({

src/auth/decorators/current-user.decorator.ts

@@ -1,7 +1,7 @@
 import { createParamDecorator, ExecutionContext } from '@nestjs/common';
 import { GqlExecutionContext } from '@nestjs/graphql';
 
-export const CurrentUser = createParamDecorator(
+export const CurrentUser = createParamDecorator (
   (data: unknown, context: ExecutionContext) => {
     const ctx = GqlExecutionContext.create(context);
     return ctx.getContext().req.user;

src/auth/decorators/roles.decorator.ts

@@ -2,7 +2,7 @@ import { applyDecorators, SetMetadata, UseGuards } from '@nestjs/common';
 import { GqlAuthGuard } from '../guards/gql-auth.guard';
 import { RolesGuard } from '../guards/roles.guard';
 
-export function Roles(...roles: string[]): <TFunction, Y>(target: any | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void {
+export function Roles(...roles: string[]): <TFunction, Y> (target: any | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void {
     return applyDecorators(
         SetMetadata('roles', roles),
         UseGuards(GqlAuthGuard, RolesGuard));

src/auth/guards/gql-auth.guard.ts

@@ -1,7 +1,7 @@
 import { ExecutionContext, Injectable } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
 import { GqlExecutionContext } from '@nestjs/graphql';
-import { Request } from 'src/core/interfaces/request.interface';
+import { Request } from '../../core/interfaces/request.interface';
 
 @Injectable()
 export class GqlAuthGuard extends AuthGuard('jwt') {

src/auth/guards/roles.guard.spec.ts

@@ -1,7 +1,23 @@
 import { RolesGuard } from './roles.guard';
+import { MockType, serviceMockFactory } from '../../../test/unit/helpers';
+import { Reflector } from '@nestjs/core';
+import { Test, TestingModule } from '@nestjs/testing';
 
 describe('RolesGuard', () => {
+  let guard: RolesGuard;
+  let reflectorMock: MockType<Reflector>
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        RolesGuard,
+        { provide: Reflector, useFactory: serviceMockFactory },
+      ],
+    }).compile();
+
+    guard = module.get<RolesGuard>(RolesGuard);
+    reflectorMock = module.get(Reflector)
+  });
   it('should be defined', () => {
-    expect(new RolesGuard()).toBeDefined();
+    expect(guard).toBeDefined();
   });
 });

src/auth/services/auth.service.spec.ts

@@ -1,15 +1,29 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AuthService } from './auth.service';
+import { serviceMockFactory, MockType, repositoryMockFactory } from '../../../test/unit/helpers';
+import { JwtService } from '@nestjs/jwt';
+import { Repository } from 'typeorm';
+import { User } from '../../users/entities/user.entity';
+import { getRepositoryToken } from '@nestjs/typeorm';
 
 describe('AuthService', () => {
   let service: AuthService;
+  let jwtServiceMock: MockType<JwtService>
+  let userRepositoryMock: MockType<Repository<User>>
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [AuthService],
+      providers: [
+        AuthService,
+        { provide: getRepositoryToken(User), useFactory: repositoryMockFactory },
+        { provide: JwtService, useFactory: serviceMockFactory },
+      ],
     }).compile();
 
     service = module.get<AuthService>(AuthService);
+
+    jwtServiceMock = module.get(JwtService)
+    userRepositoryMock = module.get(getRepositoryToken(User))
   });
 
   it('should be defined', () => {

src/auth/services/auth.service.ts

@@ -2,11 +2,11 @@ import { Injectable, UnauthorizedException } from '@nestjs/common';
 import * as bcrypt from 'bcrypt';
 
 import { JwtService } from "@nestjs/jwt";
-import { User } from 'src/users/entities/user.entity';
-import { LoginInput } from 'src/users/inputs/login.input';
+import { User } from '../../users/entities/user.entity';
+import { LoginInput } from '../../users/inputs/login.input';
 import { Repository } from 'typeorm';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Role } from 'src/users/entities/role.entity';
+import { Role } from '../../users/entities/role.entity';
 
 @Injectable()
 export class AuthService {

src/auth/strategies/jwt.strategy.ts

@@ -2,7 +2,7 @@ import { ExtractJwt, Strategy } from 'passport-jwt';
 import { PassportStrategy } from '@nestjs/passport';
 import { Injectable } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
-import { RequestUser } from 'src/core/interfaces/request-user.interface';
+import { RequestUser } from '../../core/interfaces/request-user.interface';
 
 @Injectable()
 export class JwtStrategy extends PassportStrategy(Strategy) {

src/crags/crags.module.ts

@@ -1,10 +1,10 @@
 import { Module } from '@nestjs/common';
 import { TypeOrmModule } from '@nestjs/typeorm';
-import { AuditModule } from 'src/audit/audit.module';
+import { AuditModule } from '../audit/audit.module';
 
 import { CountriesResolver } from './resolvers/countries.resolver';
 import { CountriesService } from './services/countries.service';
-import { Country } from 'src/crags/entities/country.entity';
+import { Country } from '../crags/entities/country.entity';
 
 import { CragsResolver } from './resolvers/crags.resolver';
 import { CragsService } from './services/crags.service';

src/crags/entities/area.entity.ts

@@ -1,6 +1,6 @@
 import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, BaseEntity, OneToMany, ManyToOne } from "typeorm";
 import { ObjectType, Field } from "@nestjs/graphql";
-import { Crag } from "src/crags/entities/crag.entity";
+import { Crag } from "../../crags/entities/crag.entity";
 import { Country } from "./country.entity";
 
 @Entity()

src/crags/entities/country.entity.ts

@@ -1,6 +1,6 @@
 import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, BaseEntity, OneToMany } from "typeorm";
 import { ObjectType, Field } from "@nestjs/graphql";
-import { Crag } from "src/crags/entities/crag.entity";
+import { Crag } from "../../crags/entities/crag.entity";
 import { Area } from "./area.entity";
 
 @Entity()

src/crags/entities/sector.entity.ts

@@ -1,7 +1,7 @@
 import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn, BaseEntity, ManyToOne, OneToMany } from "typeorm";
 import { ObjectType, Field, Int } from "@nestjs/graphql";
-import { Crag } from "src/crags/entities/crag.entity";
-import { Route } from "src/crags/entities/route.entity";
+import { Crag } from "../../crags/entities/crag.entity";
+import { Route } from "../../crags/entities/route.entity";
 
 @Entity()
 @ObjectType()

src/crags/resolvers/areas.resolver.spec.ts

@@ -1,15 +1,27 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AreasResolver } from './areas.resolver';
+import { MockType, serviceMockFactory, interceptorMockFactory } from '../../../test/unit/helpers';
+import { AreasService } from '../services/areas.service';
+import { AuditInterceptor } from '../../audit/interceptors/audit.interceptor';
 
 describe('AreasResolver', () => {
   let resolver: AreasResolver;
+  let areasServiceMock: MockType<AreasService>
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [AreasResolver],
+      providers: [
+        AreasResolver,
+        { provide: AreasService, useFactory: serviceMockFactory },
+      ],
+    })
+    .overrideInterceptor(AuditInterceptor).useFactory({
+      factory: interceptorMockFactory
     }).compile();
 
     resolver = module.get<AreasResolver>(AreasResolver);
+
+    areasServiceMock = module.get(AreasService)
   });
 
   it('should be defined', () => {

src/crags/resolvers/areas.resolver.ts

@@ -1,8 +1,8 @@
 import { Resolver, Mutation, Args } from '@nestjs/graphql';
 import { Area } from '../entities/area.entity';
-import { Roles } from 'src/auth/decorators/roles.decorator';
+import { Roles } from '../../auth/decorators/roles.decorator';
 import { UseInterceptors } from '@nestjs/common';
-import { AuditInterceptor } from 'src/audit/interceptors/audit.interceptor';
+import { AuditInterceptor } from '../../audit/interceptors/audit.interceptor';
 import { UpdateAreaInput } from '../dtos/update-area.input';
 import { CreateAreaInput } from '../dtos/create-area.input';
 import { AreasService } from '../services/areas.service';

src/crags/resolvers/countries.resolver.spec.ts

@@ -1,15 +1,39 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { CountriesResolver } from './countries.resolver';
+import { CountriesService } from '../services/countries.service';
+import { CragsService } from '../services/crags.service';
+import { MockType, serviceMockFactory, interceptorMockFactory, filterMockFactory } from '../../../test/unit/helpers';
+import { AuditInterceptor } from '../../audit/interceptors/audit.interceptor';
+import { NotFoundFilter } from '../filters/not-found.filter';
+import { ConflictFilter } from '../filters/conflict.filter';
 
 describe('CountriesResolver', () => {
   let resolver: CountriesResolver;
+  let countriesServiceMock: MockType<CountriesService>
+  let cragsServiceMock: MockType<CragsService>
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [CountriesResolver],
+      providers: [
+        CountriesResolver,
+        { provide: CountriesService, useFactory: serviceMockFactory },
+        { provide: CragsService, useFactory: serviceMockFactory },
+      ],
+    })
+    .overrideInterceptor(AuditInterceptor).useFactory({
+      factory: interceptorMockFactory
+    })
+    .overrideFilter(NotFoundFilter).useFactory({
+      factory: filterMockFactory
+    })
+    .overrideFilter(ConflictFilter).useFactory({
+      factory: filterMockFactory
     }).compile();
 
     resolver = module.get<CountriesResolver>(CountriesResolver);
+
+    countriesServiceMock = module.get(CountriesService)
+    cragsServiceMock = module.get(CragsService)
   });
 
   it('should be defined', () => {

src/crags/resolvers/countries.resolver.ts

@@ -3,9 +3,9 @@ import { Country } from '../entities/country.entity';
 import { CreateCountryInput } from '../dtos/create-country.input';
 import { CountriesService } from '../services/countries.service';
 import { UpdateCountryInput } from '../dtos/update-country.input';
-import { Roles } from 'src/auth/decorators/roles.decorator';
+import { Roles } from '../../auth/decorators/roles.decorator';
 import { UseInterceptors, UseFilters } from '@nestjs/common';
-import { AuditInterceptor } from 'src/audit/interceptors/audit.interceptor';
+import { AuditInterceptor } from '../../audit/interceptors/audit.interceptor';
 import { ConflictFilter } from '../filters/conflict.filter';
 import { NotFoundFilter } from '../filters/not-found.filter';
 import { Crag } from '../entities/crag.entity';

src/crags/resolvers/crags.resolver.spec.ts

@@ -1,15 +1,27 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { CragsResolver } from './crags.resolver';
+import { CragsService } from '../services/crags.service';
+import { MockType, serviceMockFactory, interceptorMockFactory } from '../../../test/unit/helpers';
+import { AuditInterceptor } from '../../audit/interceptors/audit.interceptor';
 
 describe('CragsResolver', () => {
   let resolver: CragsResolver;
+  let cragsServiceMock: MockType<CragsService>
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [CragsResolver],
+      providers: [
+        CragsResolver,
+        { provide: CragsService, useFactory: serviceMockFactory },
+      ],
+    })
+    .overrideInterceptor(AuditInterceptor).useFactory({
+      factory: interceptorMockFactory,
     }).compile();
 
     resolver = module.get<CragsResolver>(CragsResolver);
+
+    cragsServiceMock = module.get(CragsService)
   });
 
   it('should be defined', () => {

src/crags/resolvers/crags.resolver.ts

@@ -1,15 +1,15 @@
 import { Resolver, Mutation, Args, Query, ResolveField, Int, Parent, Float } from '@nestjs/graphql';
 import { UseInterceptors, UseFilters } from '@nestjs/common';
 
-import { Roles } from 'src/auth/decorators/roles.decorator';
+import { Roles } from '../../auth/decorators/roles.decorator';
 import { Crag } from '../entities/crag.entity';
 import { CreateCragInput } from '../dtos/create-crag.input';
 import { UpdateCragInput } from '../dtos/update-crag.input';
 import { CragsService } from '../services/crags.service';
-import { AuditInterceptor } from 'src/audit/interceptors/audit.interceptor';
 import { NotFoundFilter } from '../filters/not-found.filter';
 import { Sector } from '../entities/sector.entity';
 import { SectorsService } from '../services/sectors.service';
+import { AuditInterceptor } from '../../audit/interceptors/audit.interceptor';
 
 @Resolver(() => Crag)
 export class CragsResolver {