feat(be): implement admin announcement module

apps/backend/apps/admin/src/announcement/announcement.resolver.spec.ts

@@ -0,0 +1,23 @@
+import { Test, type TestingModule } from '@nestjs/testing'
+import { expect } from 'chai'
+import { AnnouncementResolver } from './announcement.resolver'
+import { AnnouncementService } from './announcement.service'
+
+describe('AnnouncementResolver', () => {
+  let resolver: AnnouncementResolver
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        AnnouncementResolver,
+        { provide: AnnouncementService, useValue: {} }
+      ]
+    }).compile()
+
+    resolver = module.get<AnnouncementResolver>(AnnouncementResolver)
+  })
+
+  it('shoulld be defined', () => {
+    expect(resolver).to.be.ok
+  })
+})

apps/backend/apps/admin/src/announcement/announcement.resolver.ts

@@ -1,44 +1,91 @@
+import { InternalServerErrorException, Logger } from '@nestjs/common'
 import { Resolver, Query, Mutation, Args, Int } from '@nestjs/graphql'
-import { Announcement } from '@generated'
+import {
+  DuplicateFoundException,
+  EntityNotExistException
+} from '@libs/exception'
+import { Announcement } from '@admin/@generated'
 import { AnnouncementService } from './announcement.service'
-import { CreateAnnouncementInput } from './dto/create-announcement.input'
-import { UpdateAnnouncementInput } from './dto/update-announcement.input'
+import { AnnouncementInput } from './dto/announcement.input'
 
 @Resolver(() => Announcement)
 export class AnnouncementResolver {
+  private readonly logger = new Logger(AnnouncementResolver.name)
   constructor(private readonly announcementService: AnnouncementService) {}
 
   @Mutation(() => Announcement)
-  createAnnouncement(
+  async createAnnouncement(
     @Args('createAnnouncementInput')
-    createAnnouncementInput: CreateAnnouncementInput
+    announcementInput: AnnouncementInput
   ) {
-    return this.announcementService.create(createAnnouncementInput)
+    try {
+      return await this.announcementService.createAnnouncement(
+        announcementInput
+      )
+    } catch (error) {
+      if (error instanceof DuplicateFoundException || EntityNotExistException) {
+        throw error.convert2HTTPException()
+      }
+      this.logger.error(error)
+      throw new InternalServerErrorException()
+    }
   }
 
-  @Query(() => [Announcement], { name: 'announcement' })
-  findAll() {
-    return this.announcementService.findAll()
+  @Query(() => [Announcement], { name: 'getAnnouncements' })
+  async getAnnouncements(
+    @Args('contestId', { type: () => Int }) contestId: number,
+    @Args('problemId', { type: () => Int, nullable: true }) problemId?: number
+  ) {
+    try {
+      return await this.announcementService.getAnnouncements(
+        contestId,
+        problemId
+      )
+    } catch (error) {
+      this.logger.error(error)
+      throw new InternalServerErrorException()
+    }
   }
 
-  @Query(() => Announcement, { name: 'announcement' })
-  findOne(@Args('id', { type: () => Int }) id: number) {
-    return this.announcementService.findOne(id)
+  @Query(() => Announcement, { name: 'getAnnouncementById' })
+  async getAnnouncementById(@Args('id', { type: () => Int }) id: number) {
+    try {
+      return await this.announcementService.getAnnouncementById(id)
+    } catch (error) {
+      if (error instanceof EntityNotExistException) {
+        throw error.convert2HTTPException()
+      }
+      this.logger.error(error)
+      throw new InternalServerErrorException()
+    }
   }
 
   @Mutation(() => Announcement)
-  updateAnnouncement(
-    @Args('updateAnnouncementInput')
-    updateAnnouncementInput: UpdateAnnouncementInput
+  async updateAnnouncement(
+    @Args('id', { type: () => Int }) id: number,
+    @Args('content', { type: () => String }) content: string
   ) {
-    return this.announcementService.update(
-      updateAnnouncementInput.id,
-      updateAnnouncementInput
-    )
+    try {
+      return await this.announcementService.updateAnnouncement(id, content)
+    } catch (error) {
+      if (error instanceof EntityNotExistException) {
+        throw error.convert2HTTPException()
+      }
+      this.logger.error(error)
+      throw new InternalServerErrorException()
+    }
   }
 
   @Mutation(() => Announcement)
-  removeAnnouncement(@Args('id', { type: () => Int }) id: number) {
-    return this.announcementService.remove(id)
+  async removeAnnouncement(@Args('id', { type: () => Int }) id: number) {
+    try {
+      return await this.announcementService.removeAnnouncement(id)
+    } catch (error) {
+      if (error instanceof EntityNotExistException) {
+        throw error.convert2HTTPException()
+      }
+      this.logger.error(error)
+      throw new InternalServerErrorException()
+    }
   }
 }

apps/backend/apps/admin/src/announcement/announcement.service.spec.ts

@@ -0,0 +1,147 @@
+import { Test, type TestingModule } from '@nestjs/testing'
+import { faker } from '@faker-js/faker'
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library'
+import { expect } from 'chai'
+import { stub } from 'sinon'
+import {
+  DuplicateFoundException,
+  EntityNotExistException
+} from '@libs/exception'
+import { PrismaService } from '@libs/prisma'
+import { AnnouncementService } from './announcement.service'
+
+const problemId = faker.number.int()
+const contestId = faker.number.int()
+const id = faker.number.int()
+const announcementInput = {
+  problemId,
+  contestId,
+  content: faker.string.sample()
+}
+
+const announcement = {
+  ...announcementInput,
+  id
+}
+
+const contestProblem = {
+  problemId
+}
+
+const db = {
+  announcement: {
+    findFirst: stub(),
+    findFirstOrThrow: stub(),
+    findMany: stub().resolves([announcement]),
+    update: stub(),
+    delete: stub(),
+    create: stub().resolves(announcement)
+  },
+  contestProblem: {
+    findFirst: stub(),
+    findFirstOrThrow: stub()
+  }
+}
+
+const PrismaErrorInstance = new PrismaClientKnownRequestError('error', {
+  code: '4xx',
+  clientVersion: 'x.x.x'
+})
+
+PrismaErrorInstance.name = 'NotFoundError'
+
+describe('AnnouncementService', () => {
+  let service: AnnouncementService
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [AnnouncementService, { provide: PrismaService, useValue: db }]
+    }).compile()
+
+    service = module.get<AnnouncementService>(AnnouncementService)
+  })
+
+  it('should be defined', () => {
+    expect(service).to.be.ok
+  })
+
+  describe('createAnnouncement', () => {
+    it('should return created announcement', async () => {
+      db.announcement.findFirst.resolves(null)
+      db.contestProblem.findFirstOrThrow.resolves(contestProblem)
+
+      const res = await service.createAnnouncement(announcementInput)
+      expect(res).to.deep.equal(announcement)
+    })
+
+    it('should throw error when given announcement already exists', async () => {
+      db.announcement.findFirst.resolves(announcement)
+
+      await expect(
+        service.createAnnouncement(announcementInput)
+      ).to.be.rejectedWith(DuplicateFoundException)
+    })
+
+    it('should throw error when given problemId is invalid', async () => {
+      db.announcement.findFirst.resolves(null)
+      db.contestProblem.findFirstOrThrow.rejects(PrismaErrorInstance)
+
+      await expect(
+        service.createAnnouncement(announcementInput)
+      ).to.be.rejectedWith(EntityNotExistException)
+    })
+  })
+
+  describe('getAnnouncements', () => {
+    it('should return all announcements', async () => {
+      db.announcement.findMany()
+      const res = await service.getAnnouncements(problemId)
+      expect(res).to.deep.equal([announcement])
+    })
+  })
+
+  describe('getAnnouncementById', () => {
+    it('should throw error when given id is invalid', async () => {
+      db.announcement.findFirstOrThrow.rejects(PrismaErrorInstance)
+      await expect(service.getAnnouncementById(id)).to.be.rejectedWith(
+        EntityNotExistException
+      )
+    })
+    it('should return an announcement', async () => {
+      db.announcement.findFirstOrThrow.resolves(announcement)
+      const res = await service.getAnnouncementById(id)
+      expect(res).to.deep.equal(announcement)
+    })
+  })
+
+  describe('updateAnnouncement', () => {
+    it('should return updated announcement', async () => {
+      db.announcement.update.resolves(announcement)
+      const res = await service.updateAnnouncement(
+        id,
+        announcementInput.content
+      )
+      expect(res).to.deep.equal(announcement)
+    })
+    it('should throw error when given id is invalid', async () => {
+      db.announcement.update.rejects(PrismaErrorInstance)
+      await expect(
+        service.updateAnnouncement(id, announcementInput.content)
+      ).to.be.rejectedWith(EntityNotExistException)
+    })
+  })
+
+  describe('removeAnnouncement', () => {
+    it('should return deleted announcement', async () => {
+      db.announcement.delete.resolves(announcement)
+      const res = await service.removeAnnouncement(id)
+      expect(res).to.deep.equal(announcement)
+    })
+    it('should throw error when given id is invalid', async () => {
+      db.announcement.delete.rejects(PrismaErrorInstance)
+      await expect(service.removeAnnouncement(id)).to.be.rejectedWith(
+        EntityNotExistException
+      )
+    })
+  })
+})