[Test] test

services/frontend/tests/unit/courseMatrix.test.ts

@@ -2,16 +2,28 @@ import { assert, describe, it } from 'vitest'
 
 import { calculateExcelData, getHopsCourses } from '@/components/CustomPopulation/courseMatrix'
 import { CreditTypeCode } from '@oodikone/shared/types'
+import type { StudentCourse } from '@oodikone/shared/types/studentData'
 
 import { createCourse as createBaseCourse, createStudent, createStudyPlan } from '@oodikone/shared/test/utils'
 
+// Each course id is its own course group unless overridden
 const createCourse = (
   course_id: string,
   credits: number,
   passed: boolean,
   date: Date,
-  credittypecode: CreditTypeCode = passed ? CreditTypeCode.PASSED : CreditTypeCode.FAILED
-) => createBaseCourse({ course_id, date, passed, grade: passed ? '5' : 'Hyl.', credits, credittypecode })
+  overrides: Partial<StudentCourse> = {}
+) =>
+  createBaseCourse({
+    course_id,
+    courseGroupId: course_id,
+    date,
+    passed,
+    grade: passed ? '5' : 'Hyl.',
+    credits,
+    credittypecode: passed ? CreditTypeCode.PASSED : CreditTypeCode.FAILED,
+    ...overrides,
+  })
 
 const createHops = (includedCourses: string[]) => createStudyPlan({ included_courses: includedCourses })
 
@@ -52,6 +64,21 @@ void describe('getHopsCourses', () => {
     assert.equal(result.length, 1)
     assert.equal(result[0].credits, 6)
   })
+
+  void it('dedupes completions of different versions of the same course group keeping the latest', () => {
+    const student = createStudent({
+      courses: [
+        createCourse('A-2023', 5, true, new Date('2024-09-01'), { courseGroupId: 'group-a' }),
+        createCourse('A-2025', 6, true, new Date('2025-01-15'), { courseGroupId: 'group-a' }),
+      ],
+      studyplans: [createHops(['A-2023', 'A-2025'])],
+    })
+
+    const result = getHopsCourses(student)
+
+    assert.equal(result.length, 1)
+    assert.equal(result[0].course_id, 'A-2025')
+  })
 })
 
 void describe('calculateExcelData', () => {
@@ -71,12 +98,12 @@ void describe('calculateExcelData', () => {
         studyplans: [createHops(['course-a', 'course-b'])],
       }),
     ]
-    const courseInfoById = new Map([
+    const courseInfoByGroupId = new Map([
       ['course-a', { code: 'A', name: 'Course A' }],
       ['course-b', { code: 'B', name: 'Course B' }],
     ])
 
-    const data = calculateExcelData(students, courseInfoById)
+    const data = calculateExcelData(students, courseInfoByGroupId)
 
     assert.deepEqual(data.completedCoursesRows, [
       ['1', 'Testi Opiskelija', 'Course A (A)'],
@@ -88,18 +115,42 @@ void describe('calculateExcelData', () => {
     ])
   })
 
-  void it('falls back to id as the code for courses missing from the course map', () => {
+  void it('displays the course group code for other versions and aggregates versions of the same group', () => {
     const students = [
       createStudent({
         studentNumber: '1',
-        courses: [createCourse('unknown-course-id', 5, true, new Date('2024-09-01'))],
+        courses: [createCourse('course-a-v1', 5, true, new Date('2024-09-01'), { courseGroupId: 'group-a' })],
+        studyplans: [createHops(['course-a-v1'])],
+      }),
+      createStudent({
+        studentNumber: '2',
+        courses: [createCourse('course-a-v2', 5, true, new Date('2025-09-01'), { courseGroupId: 'group-a' })],
+        studyplans: [createHops(['course-a-v2'])],
+      }),
+    ]
+    const courseInfoByGroupId = new Map([['group-a', { code: 'A', name: 'Course A' }]])
+
+    const data = calculateExcelData(students, courseInfoByGroupId)
+
+    assert.deepEqual(data.completedCoursesRows, [
+      ['1', 'Testi Opiskelija', 'Course A (A)'],
+      ['2', 'Testi Opiskelija', 'Course A (A)'],
+    ])
+    assert.deepEqual(data.courseCounterRows, [['A', 'Course A', '2', '10']])
+  })
+
+  void it('falls back to the course code of the credit for courses missing from the course map', () => {
+    const students = [
+      createStudent({
+        studentNumber: '1',
+        courses: [createCourse('unknown-course-id', 5, true, new Date('2024-09-01'), { course_code: 'UNKNOWN01' })],
         studyplans: [createHops(['unknown-course-id'])],
       }),
     ]
 
     const data = calculateExcelData(students, new Map())
 
-    assert.deepEqual(data.completedCoursesRows, [['1', 'Testi Opiskelija', ' (unknown-course-id)']])
-    assert.deepEqual(data.courseCounterRows, [['unknown-course-id', '', '1', '5']])
+    assert.deepEqual(data.completedCoursesRows, [['1', 'Testi Opiskelija', ' (UNKNOWN01)']])
+    assert.deepEqual(data.courseCounterRows, [['UNKNOWN01', '', '1', '5']])
   })
 })