add: getRegisteredCourse

__tests__/grpc/timetable.service.test.ts

@@ -29,12 +29,14 @@ import { updateRegisteredCourseUseCase } from '../../src/usecase/updateRegistere
 import { updateTagsUseCase } from '../../src/usecase/updateTags'
 import { deleteRegisteredCoursesUseCase } from '../../src/usecase/deleteRegisteredCourses'
 import { deleteTagsUseCase } from '../../src/usecase/deleteTags'
+import { getRegisteredCourseUseCase } from '../../src/usecase/getRegisteredCourse'
 
 jest.mock('../../src/usecase/createRegisteredCourses')
 jest.mock('../../src/usecase/createTags')
 jest.mock('../../src/usecase/updateRegisteredCourses')
 jest.mock('../../src/usecase/updateTags')
 jest.mock('../../src/usecase/getRegisteredCoursesByYear')
+jest.mock('../../src/usecase/getRegisteredCourse')
 jest.mock('../../src/usecase/getTags')
 jest.mock('../../src/usecase/deleteRegisteredCourses')
 jest.mock('../../src/usecase/deleteTags')
@@ -95,7 +97,7 @@ const courses: IRegisteredCourseWithoutId[] = [
 
 const tags: ITagWithoutId[] = [{ userId, name: 'test tag' }]
 
-describe('getRegisteredCourses', () => {
+describe('getRegisteredCoursesByYear', () => {
   test('getRegisteredCourses', (done) => {
     mocked(getRegisteredCoursesByYearUseCase).mockImplementation(
       async ({ userId, year }) => {
@@ -131,6 +133,49 @@ describe('getRegisteredCourses', () => {
   })
 })
 
+describe('getRegisteredCourses', () => {
+  test('getRegisteredCourses', (done) => {
+    const _id = v4()
+    mocked(getRegisteredCourseUseCase).mockImplementation(
+      async ({ userId, id }) => {
+        expect(userId).toBe(userId)
+        expect(id).toBe(_id)
+        // @ts-ignore
+        return grpcCourseToEntity(courses).map(({ tags, ...cc }) => ({
+          ...cc,
+          tags: tags.map((t) => ({
+            id: t.id,
+            userId: cc.userId,
+            name: 'tag name',
+            courses: [],
+          })),
+        }))[0]
+      }
+    )
+    client.getRegisteredCourse({ id: _id, userId }, (err, res) => {
+      expect(err).toBeNull()
+      expect(res).toEqual(deepContaining(courses[0]))
+      done()
+    })
+  })
+  test('not found error', (done) => {
+    mocked(getRegisteredCourseUseCase).mockRejectedValueOnce(
+      new NotFoundError('指定された講義は登録されていません')
+    )
+    client.getRegisteredCourse({ id: v4(), userId }, (err, res) => {
+      expect(err?.code).toEqual(Status.NOT_FOUND)
+      done()
+    })
+  })
+  test('unexpected error', (done) => {
+    mocked(getRegisteredCourseUseCase).mockImplementation(throwUnexpectedError)
+    client.getRegisteredCourse({ id: v4(), userId }, (err, res) => {
+      expect(err).toBeTruthy()
+      done()
+    })
+  })
+})
+
 describe('getTags', () => {
   test('getTags', (done) => {
     // @ts-ignore

__tests__/usecase/getRegisteredCourse.test.ts

@@ -0,0 +1,74 @@
+import { getConnection } from 'typeorm'
+import { v4 } from 'uuid'
+import { connectDatabase, disconnectDatabase } from '../../src/database'
+import { RegisteredCourse } from '../../src/database/model/registeredCourse'
+import { Tag } from '../../src/database/model/tag'
+import { CourseMethod, Day, Module } from '../../src/database/type'
+import { NotFoundError } from '../../src/error'
+import { getRegisteredCourseUseCase } from '../../src/usecase/getRegisteredCourse'
+import { getRegisteredCoursesByYearUseCase } from '../../src/usecase/getRegisteredCoursesByYear'
+import { clearDB } from '../database/_cleardb'
+import { deepContaining } from '../_deepContaining'
+
+const userId = v4()
+const tags = [
+  { id: v4(), userId, name: 'test tag1' },
+  { id: v4(), userId, name: 'test tag2' },
+]
+
+const data = [
+  {
+    id: v4(),
+    userId,
+    year: 2020,
+    courseId: v4(),
+    tags: [],
+    memo: 'memo',
+    attendance: 1,
+    absence: 2,
+    late: 3,
+  },
+  {
+    id: v4(),
+    userId,
+    year: 2020,
+    name: 'custom course name',
+    instructor: 'custom instructor name',
+    credit: 1.5,
+    methods: [CourseMethod.OnlineAsynchronous, CourseMethod.FaceToFace],
+    schedules: [
+      {
+        module: Module.SpringA,
+        day: Day.Mon,
+        period: 1,
+        room: '3A201',
+      },
+    ],
+    tags: [{ id: tags[0].id }],
+    memo: 'memo',
+    attendance: 1,
+    absence: 2,
+    late: 3,
+  },
+]
+
+beforeAll(async () => {
+  await connectDatabase()
+  await clearDB()
+  await getConnection().getRepository(Tag).save(tags)
+  await getConnection().getRepository(RegisteredCourse).save(data)
+})
+
+test('データが取得できる', () => {
+  return expect(
+    getRegisteredCourseUseCase({ userId, id: data[0].id })
+  ).resolves.toEqual(deepContaining(data[0]))
+})
+
+test('講義が見つからない場合はエラー', () => {
+  return expect(
+    getRegisteredCourseUseCase({ userId, id: v4() })
+  ).rejects.toThrow(NotFoundError)
+})
+
+afterAll(disconnectDatabase)

protos/TimetableService.proto

@@ -7,7 +7,7 @@ service TimetableService {
   /* 指定された年度とユーザーの登録済み講義を取得する */
   rpc GetRegisteredCoursesByYear(GetRegisteredCoursesRequest) returns (GetRegisteredCoursesResponse);
   /* 指定されたidの講義を取得 */
-  /*rpc GetRegisteredCourses(GetRegisteredCourseRequest) returns (GetRegisteredCourseResponse);*/
+  rpc GetRegisteredCourse(GetRegisteredCourseRequest) returns (RegisteredCourse);
   /* 指定されたユーザーのタグをすべて取得する */
   rpc GetTags(GetTagsRequest) returns (GetTagsResponse);
   /* 講義を登録する */
@@ -34,11 +34,7 @@ message GetRegisteredCoursesResponse {
 
 message GetRegisteredCourseRequest {
   string userId = 1;
-  repeated string ids = 2;
-}
-
-message GetRegisteredCourseResponse {
-  repeated RegisteredCourse courses = 1;
+  string id = 2;
 }
 
 message GetTagsRequest {

src/grpc/timetable.service.ts

@@ -6,6 +6,7 @@ import {
   DeleteTagsResponse,
   GetRegisteredCoursesResponse,
   GetTagsResponse,
+  RegisteredCourse,
   TimetableService,
   UpdateRegisteredCoursesResponse,
   UpdateTagsResponse,
@@ -25,6 +26,7 @@ import { updateRegisteredCourseUseCase } from '../usecase/updateRegisteredCourse
 import { updateTagsUseCase } from '../usecase/updateTags'
 import { deleteRegisteredCoursesUseCase } from '../usecase/deleteRegisteredCourses'
 import { deleteTagsUseCase } from '../usecase/deleteTags'
+import { getRegisteredCourseUseCase } from '../usecase/getRegisteredCourse'
 
 /**
  * TimetableServiceの実装
@@ -43,6 +45,14 @@ export const timetableService: GrpcServer<TimetableService> = {
       callback(toGrpcError(e))
     }
   },
+  async getRegisteredCourse({ request }, callback) {
+    try {
+      const res = await getRegisteredCourseUseCase(request)
+      callback(null, RegisteredCourse.create(entityToGrpcCourse([res])[0]))
+    } catch (e) {
+      callback(toGrpcError(e))
+    }
+  },
   async getTags({ request }, callback) {
     try {
       const tags = await getTagsUseCase(request)

src/usecase/getRegisteredCourse.ts

@@ -0,0 +1,17 @@
+import { getRepository } from 'typeorm'
+import { RegisteredCourse } from '../database/model/registeredCourse'
+import { NotFoundError } from '../error'
+
+type Input = {
+  userId: string
+  id: string
+}
+
+export async function getRegisteredCourseUseCase({ userId, id }: Input) {
+  const res = await getRepository(RegisteredCourse).findOne({
+    where: { userId, id },
+    relations: ['tags'],
+  })
+  if (!res) throw new NotFoundError('指定されたidの講義は登録されていません')
+  return res
+}