Test: add and modify test

add "mock" prefix"
add products controller test

src/modules/auth/auth.service.spec.ts

@@ -4,15 +4,13 @@ import { JwtService } from '@nestjs/jwt';
 
 describe('AuthService', () => {
   let service: AuthService;
-  let jwtService: JwtService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [JwtService, AuthService],
     }).compile();
 
     service = module.get<AuthService>(AuthService);
-    jwtService = module.get<JwtService>(JwtService);
   });
 
   it('should be defined', () => {

src/modules/health-check/health-check.controller.spec.ts

@@ -12,42 +12,42 @@ import {
 
 describe('HealthCheckController', () => {
   let controller: HealthCheckController;
-  let health: Partial<HealthCheckService>;
-  let http: Partial<HttpHealthIndicator>;
-  let typeOrm: Partial<TypeOrmHealthIndicator>;
-  let sample: Partial<SampleHealthIndicator>;
+  let mockHealth: Partial<HealthCheckService>;
+  let mockHttp: Partial<HttpHealthIndicator>;
+  let mockTypeOrm: Partial<TypeOrmHealthIndicator>;
+  let mockSample: Partial<SampleHealthIndicator>;
 
   beforeEach(async () => {
-    health = {
+    mockHealth = {
       check: jest.fn(),
     };
-    http = {
+    mockHttp = {
       pingCheck: jest.fn(),
     };
-    typeOrm = {
+    mockTypeOrm = {
       pingCheck: jest.fn(),
     };
-    sample = {
+    mockSample = {
       isHealthy: jest.fn(),
     };
     const module: TestingModule = await Test.createTestingModule({
       controllers: [HealthCheckController],
       providers: [
         {
           provide: HealthCheckService,
-          useValue: health,
+          useValue: mockHealth,
         },
         {
           provide: HttpHealthIndicator,
-          useValue: http,
+          useValue: mockHttp,
         },
         {
           provide: TypeOrmHealthIndicator,
-          useValue: typeOrm,
+          useValue: mockTypeOrm,
         },
         {
           provide: SampleHealthIndicator,
-          useValue: sample,
+          useValue: mockSample,
         },
       ],
     }).compile();
@@ -61,7 +61,7 @@ describe('HealthCheckController', () => {
 
   it('should call health check service', () => {
     const check = jest.fn();
-    health.check = check;
+    mockHealth.check = check;
     controller.check();
     expect(check).toBeCalled();
   });
@@ -73,17 +73,17 @@ describe('HealthCheckController', () => {
     const sampleResult = { status: 'up' };
 
     const httpSpy = jest
-      .spyOn(http, 'pingCheck')
+      .spyOn(mockHttp, 'pingCheck')
       .mockResolvedValue(httpResult as unknown as HealthIndicatorResult);
     const dbSpy = jest
-      .spyOn(typeOrm, 'pingCheck')
+      .spyOn(mockTypeOrm, 'pingCheck')
       .mockResolvedValue(dbResult as unknown as HealthIndicatorResult);
     const sampleSpy = jest
-      .spyOn(sample, 'isHealthy')
+      .spyOn(mockSample, 'isHealthy')
       .mockResolvedValue(sampleResult as any);
 
     const healthSpy = jest
-      .spyOn(health, 'check')
+      .spyOn(mockHealth, 'check')
       .mockImplementation(
         async (healthIndicators: HealthIndicatorFunction[]) => {
           const results = await Promise.all(healthIndicators.map((cb) => cb()));

src/modules/products/products.controller.spec.ts

@@ -0,0 +1,27 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ProductsController } from './products.controller';
+import { ProductsService } from './products.service';
+
+describe('ProductsController', () => {
+  let controller: ProductsController;
+  let mockService: Partial<ProductsService>;
+
+  beforeEach(async () => {
+    mockService = {};
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [ProductsController],
+      providers: [
+        {
+          provide: ProductsService,
+          useValue: mockService,
+        },
+      ],
+    }).compile();
+
+    controller = module.get<ProductsController>(ProductsController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

src/modules/products/products.service.spec.ts

@@ -5,12 +5,12 @@ import { ProductsComponent } from './products.component';
 
 describe('ProductsService', () => {
   let service: ProductsService;
-  let comp: Partial<ProductsComponent>; // 가짜 컴포넌트 - partial 사용
-  let repo: ProductsRepositoryInterface; // 가짜 레포지토리 - interface 사용
+  let mockComp: Partial<ProductsComponent>; // 가짜 컴포넌트 - partial 사용
+  let mockRepo: ProductsRepositoryInterface; // 가짜 레포지토리 - interface 사용
 
   beforeEach(async () => {
-    comp = {};
-    repo = {
+    mockComp = {};
+    mockRepo = {
       doSomethingForProduct: jest.fn(),
       create: jest.fn(),
       all: jest.fn(),
@@ -23,8 +23,8 @@ describe('ProductsService', () => {
     const module: TestingModule = await Test.createTestingModule({
       providers: [
         ProductsService,
-        { provide: 'ProductsRepositoryInterface', useValue: repo },
-        { provide: ProductsComponent, useValue: comp },
+        { provide: 'ProductsRepositoryInterface', useValue: mockRepo },
+        { provide: ProductsComponent, useValue: mockComp },
       ],
     }).compile();
 

src/modules/users/users.controller.spec.ts

@@ -1,19 +1,26 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { UsersController } from './users.controller';
 import { UsersService } from './users.service';
+import { AuthService } from '../auth/auth.service';
 
 describe('UsersController', () => {
   let controller: UsersController;
-  let service: Partial<UsersService>;
+  let mockService: Partial<UsersService>;
+  let mockAuthService: Partial<UsersService>;
 
   beforeEach(async () => {
-    service = {};
+    mockService = {};
+    mockAuthService = {};
     const module: TestingModule = await Test.createTestingModule({
       controllers: [UsersController],
       providers: [
         {
           provide: UsersService,
-          useValue: service,
+          useValue: mockService,
+        },
+        {
+          provide: AuthService,
+          useValue: mockAuthService,
         },
       ],
     }).compile();

src/modules/users/users.service.spec.ts

@@ -6,13 +6,12 @@ import { AuthService } from '../auth/auth.service';
 
 describe('UsersService', () => {
   let service: UsersService;
-  let logger: Logger;
-  let authService: Partial<AuthService>;
-  let repo: UsersRepositoryInterface;
+  let mockAuthService: Partial<AuthService>;
+  let mockRepo: UsersRepositoryInterface;
 
   beforeEach(async () => {
-    authService = {};
-    repo = {
+    mockAuthService = {};
+    mockRepo = {
       create: jest.fn(),
       createMany: jest.fn(),
       all: jest.fn(),
@@ -28,11 +27,11 @@ describe('UsersService', () => {
         UsersService,
         {
           provide: AuthService,
-          useValue: authService,
+          useValue: mockAuthService,
         },
         {
           provide: 'UsersRepositoryInterface',
-          useValue: repo,
+          useValue: mockRepo,
         },
       ],
     }).compile();