Merge pull request #381 from boostcampwm2023/BE-feature/profiles-module

프로필 모듈 개선

Author: Conut-1

nestjs-BE/server/package-lock.json

@@ -36,6 +36,7 @@
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.0",
     "dotenv": "^16.3.1",
+    "lodash": "^4.17.21",
     "mongoose": "^8.0.2",
     "passport": "^0.6.0",
     "passport-jwt": "^4.0.1",
@@ -49,6 +50,7 @@
     "@nestjs/testing": "^10.0.0",
     "@types/express": "^4.17.17",
     "@types/jest": "^29.5.2",
+    "@types/lodash": "^4.17.15",
     "@types/multer": "^1.4.11",
     "@types/node": "^20.3.1",
     "@types/passport-jwt": "^3.0.13",

nestjs-BE/server/package.json

@@ -6,7 +6,6 @@ import { AuthController } from './auth.controller';
 import { AuthService } from './auth.service';
 import { JwtStrategy } from './strategies/jwt.strategy';
 import { JwtAuthGuard } from './guards/jwt-auth.guard';
-import { MatchUserProfileGuard } from './guards/match-user-profile.guard';
 import { IsProfileInSpaceGuard } from './guards/is-profile-in-space.guard';
 import { UsersModule } from '../users/users.module';
 import { ProfilesModule } from '../profiles/profiles.module';
@@ -27,12 +26,10 @@ import { ProfileSpaceModule } from '../profile-space/profile-space.module';
     AuthService,
     JwtStrategy,
     { provide: APP_GUARD, useClass: JwtAuthGuard },
-    MatchUserProfileGuard,
     IsProfileInSpaceGuard,
   ],
   exports: [
     AuthService,
-    MatchUserProfileGuard,
     ProfilesModule,
     IsProfileInSpaceGuard,
     ProfileSpaceModule,

nestjs-BE/server/src/auth/auth.module.ts

@@ -8,8 +8,8 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { InviteCode, Space } from '@prisma/client';
 import { InviteCodesController } from './invite-codes.controller';
 import { InviteCodesService } from './invite-codes.service';
-import { MatchUserProfileGuard } from '../auth/guards/match-user-profile.guard';
 import { ProfilesService } from '../profiles/profiles.service';
+import { MatchUserProfileGuard } from '../profiles/guards/match-user-profile.guard';
 import { IsProfileInSpaceGuard } from '../auth/guards/is-profile-in-space.guard';
 import { ProfileSpaceService } from '../profile-space/profile-space.service';
 

nestjs-BE/server/src/invite-codes/invite-codes.controller.spec.ts

@@ -9,8 +9,8 @@ import {
 import { ApiTags, ApiOperation, ApiResponse, ApiBody } from '@nestjs/swagger';
 import { InviteCodesService } from './invite-codes.service';
 import { CreateInviteCodeDto } from './dto/create-invite-code.dto';
-import { MatchUserProfileGuard } from '../auth/guards/match-user-profile.guard';
 import { IsProfileInSpaceGuard } from '../auth/guards/is-profile-in-space.guard';
+import { MatchUserProfileGuard } from '../profiles/guards/match-user-profile.guard';
 
 @Controller('inviteCodes')
 @ApiTags('inviteCodes')

nestjs-BE/server/src/invite-codes/invite-codes.controller.ts

@@ -3,9 +3,10 @@ import { InviteCodesService } from './invite-codes.service';
 import { InviteCodesController } from './invite-codes.controller';
 import { SpacesModule } from '../spaces/spaces.module';
 import { AuthModule } from '../auth/auth.module';
+import { ProfilesModule } from '../profiles/profiles.module';
 
 @Module({
-  imports: [AuthModule, SpacesModule],
+  imports: [AuthModule, SpacesModule, ProfilesModule],
   controllers: [InviteCodesController],
   providers: [InviteCodesService],
 })

nestjs-BE/server/src/invite-codes/invite-codes.module.ts

@@ -1,24 +1,21 @@
-import { PartialType } from '@nestjs/mapped-types';
 import { ApiProperty } from '@nestjs/swagger';
-import { MaxLength } from 'class-validator';
-import { CreateProfileDto } from './create-profile.dto';
+import { IsOptional, MaxLength } from 'class-validator';
 import { MAX_NAME_LENGTH } from '../../config/constants';
 
-export class UpdateProfileDto extends PartialType(CreateProfileDto) {
+export class UpdateProfileDto {
+  @IsOptional()
   @MaxLength(MAX_NAME_LENGTH)
   @ApiProperty({
     example: 'new nickname',
     description: 'Updated nickname of the profile',
     required: false,
   })
-  nickname?: string;
+  nickname: string;
 
   @ApiProperty({
     example: 'new image.png',
     description: 'Updated Profile image file',
     required: false,
   })
-  image?: string;
-
-  uuid?: string;
+  image: Express.Multer.File;
 }

nestjs-BE/server/src/profiles/dto/update-profile.dto.ts

@@ -0,0 +1,116 @@
+import { BadRequestException, ForbiddenException } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { MatchUserProfileGuard } from './match-user-profile.guard';
+import { ProfilesService } from '../profiles.service';
+
+import type { ExecutionContext } from '@nestjs/common';
+import type { TestingModule } from '@nestjs/testing';
+import type { Profile } from '@prisma/client';
+
+describe('MatchUserProfileGuard', () => {
+  const userUuid = 'user uuid';
+  const profileUuid = 'profile uuid';
+  let guard: MatchUserProfileGuard;
+  let profilesService: ProfilesService;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [{ provide: ProfilesService, useValue: {} }],
+    }).compile();
+
+    profilesService = module.get<ProfilesService>(ProfilesService);
+
+    guard = new MatchUserProfileGuard(profilesService);
+  });
+
+  it('throw bad request when profile uuid not include', async () => {
+    const context = createExecutionContext({ user: { uuid: userUuid } });
+
+    await expect(guard.canActivate(context)).rejects.toThrow(
+      BadRequestException,
+    );
+  });
+
+  it('throw bad request when user uuid not include (body)', async () => {
+    const context = createExecutionContext({
+      body: { profile_uuid: profileUuid },
+    });
+
+    await expect(guard.canActivate(context)).rejects.toThrow(
+      BadRequestException,
+    );
+  });
+
+  it('throw bad request when user uuid not include (query)', async () => {
+    const context = createExecutionContext({
+      query: { profile_uuid: profileUuid },
+    });
+
+    await expect(guard.canActivate(context)).rejects.toThrow(
+      BadRequestException,
+    );
+  });
+
+  it('throw bad request when user uuid not include (params)', async () => {
+    const context = createExecutionContext({
+      params: { profile_uuid: profileUuid },
+    });
+
+    await expect(guard.canActivate(context)).rejects.toThrow(
+      BadRequestException,
+    );
+  });
+
+  it('throw forbidden when profile not found', async () => {
+    const context = createExecutionContext({
+      user: { uuid: userUuid },
+      params: { profile_uuid: profileUuid },
+    });
+    profilesService.findProfileByProfileUuid = jest.fn(async () => null);
+
+    await expect(guard.canActivate(context)).rejects.toThrow(
+      ForbiddenException,
+    );
+  });
+
+  it("throw forbidden when profile not user's profile", async () => {
+    const context = createExecutionContext({
+      user: { uuid: userUuid },
+      params: { profile_uuid: profileUuid },
+    });
+    profilesService.findProfileByProfileUuid = jest.fn(
+      async () => ({ userUuid: 'other user uuid' }) as Profile,
+    );
+
+    await expect(guard.canActivate(context)).rejects.toThrow(
+      ForbiddenException,
+    );
+  });
+
+  it('return true when valid user', async () => {
+    const context = createExecutionContext({
+      user: { uuid: userUuid },
+      params: { profile_uuid: profileUuid },
+    });
+    profilesService.findProfileByProfileUuid = jest.fn(
+      async () => ({ userUuid }) as Profile,
+    );
+
+    await expect(guard.canActivate(context)).resolves.toBeTruthy();
+  });
+});
+
+function createExecutionContext(request: object): ExecutionContext {
+  const innerRequest = {
+    body: {},
+    params: {},
+    query: {},
+    ...request,
+  };
+  const context: ExecutionContext = {
+    switchToHttp: () => ({
+      getRequest: () => innerRequest,
+    }),
+  } as ExecutionContext;
+  return context;
+}

nestjs-BE/server/src/profiles/entities/profile.entity.ts

@@ -13,7 +13,7 @@ export class MatchUserProfileGuard implements CanActivate {
 
   async canActivate(context: ExecutionContext): Promise<boolean> {
     const request = context.switchToHttp().getRequest();
-    const userUuid = request.user.uuid;
+    const userUuid = request.user?.uuid;
     const profileUuid =
       request.body.profile_uuid ||
       request.query.profile_uuid ||

nestjs-BE/server/src/profiles/guards/match-user-profile.guard.spec.ts

@@ -1,28 +1,18 @@
-import {
-  ForbiddenException,
-  HttpStatus,
-  NotFoundException,
-} from '@nestjs/common';
+import { HttpStatus } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
 import { ProfilesController } from './profiles.controller';
 import { ProfilesService } from './profiles.service';
 
+import type { UpdateProfileDto } from './dto/update-profile.dto';
+
 describe('ProfilesController', () => {
   let controller: ProfilesController;
   let profilesService: ProfilesService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [ProfilesController],
-      providers: [
-        {
-          provide: ProfilesService,
-          useValue: {
-            findProfileByUserUuid: jest.fn(),
-            updateProfile: jest.fn(),
-          },
-        },
-      ],
+      providers: [{ provide: ProfilesService, useValue: {} }],
     }).compile();
 
     controller = module.get<ProfilesController>(ProfilesController);
@@ -40,9 +30,7 @@ describe('ProfilesController', () => {
         nickname: 'test nickname',
       };
 
-      jest
-        .spyOn(profilesService, 'findProfileByUserUuid')
-        .mockResolvedValue(testProfile);
+      profilesService.findProfileByUserUuid = jest.fn(async () => testProfile);
 
       const response = controller.findProfileByUserUuid(userUuidMock);
 
@@ -55,41 +43,28 @@ describe('ProfilesController', () => {
         userUuidMock,
       );
     });
-
-    it('not found profile', async () => {
-      jest
-        .spyOn(profilesService, 'findProfileByUserUuid')
-        .mockRejectedValue(new NotFoundException());
-
-      const response = controller.findProfileByUserUuid(userUuidMock);
-
-      await expect(response).rejects.toThrow(NotFoundException);
-    });
   });
 
   describe('update', () => {
     const imageMock = {} as Express.Multer.File;
-    const userUuidMock = 'user uuid';
+    const profileUuidMock = 'profile uuid';
     const bodyMock = {
-      uuid: 'profile test uuid',
       nickname: 'test nickname',
-    };
+    } as UpdateProfileDto;
 
     it('updated profile', async () => {
       const testProfile = {
-        uuid: 'profile test uuid',
-        userUuid: userUuidMock,
+        uuid: profileUuidMock,
+        userUuid: 'user uuid',
         image: 'www.test.com/image',
         nickname: 'test nickname',
       };
 
-      jest
-        .spyOn(profilesService, 'updateProfile')
-        .mockResolvedValue(testProfile);
+      profilesService.updateProfile = jest.fn(async () => testProfile);
 
       const response = controller.updateProfile(
         imageMock,
-        userUuidMock,
+        profileUuidMock,
         bodyMock,
       );
 
@@ -99,25 +74,10 @@ describe('ProfilesController', () => {
         data: testProfile,
       });
       expect(profilesService.updateProfile).toHaveBeenCalledWith(
-        userUuidMock,
-        bodyMock.uuid,
-        imageMock,
-        bodyMock,
-      );
-    });
-
-    it('not found user', async () => {
-      jest
-        .spyOn(profilesService, 'updateProfile')
-        .mockRejectedValue(new ForbiddenException());
-
-      const response = controller.updateProfile(
+        profileUuidMock,
         imageMock,
-        userUuidMock,
         bodyMock,
       );
-
-      await expect(response).rejects.toThrow(ForbiddenException);
     });
   });
 });