Issue #361: Adds a test that checks if a student can only belong in a single grade. (#362)

Author: pedrorolo

exercises/grade-school/grade-school.example.ts

@@ -1,31 +1,35 @@
-export default class GradeSchool {
-  private roster = new Map<number, Set<string>>()
+type Student = string
+type Grade = number
+type StudentRooster = Map<string, Student[]>
+type StudentGrades = Map<Student, Grade>
 
-  public addStudent(name: string, grade: number): void {
-    const students = this.roster.get(grade) || new Set<string>()
-    students.add(name)
-    this.roster.set(grade, students)
+class GradeSchool {
+  private studentGrades: StudentGrades
+  constructor() { this.studentGrades = new Map() }
+  private studentGradeEntries(): [Student, Grade][] {
+    return Array.from(this.studentGrades.entries());
   }
+  public studentRoster(): StudentRooster {
+    const grades: Grade[] =
+      Array.from(new Set(this.studentGrades.values()).values())
+        .sort()
 
-  public studentsInGrade(grade: number): string[] {
-    const toReturn = this.roster.get(grade) || new Set<string>()
-    return Array.from(toReturn).sort()
-  }
-
-  public studentRoster(): Map<string, string[]> {
-    const temp = new Map<string, string[]>()
-    const keys: number[] = []
-
-    for (const key of this.roster.keys()) {
-      keys.push(key)
-    }
-    keys.sort()
+    const emptyStudentsRooster: StudentRooster = new Map()
 
-    for (const each of keys) {
-      const values = this.roster.get(each) || new Set<string>()
-      temp.set(each.toString(10), Array.from(values).sort())
-    }
+    const gradesReducer =
+      (rooster: StudentRooster, grade: Grade): StudentRooster =>
+        rooster.set(grade.toString(), this.studentsInGrade(grade))
 
-    return temp
+    return grades.reduce(gradesReducer, emptyStudentsRooster)
+  }
+  addStudent(s: Student, g: Grade): void {
+    this.studentGrades.set(s, g)
+  }
+  studentsInGrade(g: Grade): Student[] {
+    return this.studentGradeEntries()
+      .filter(([_, sg]) => sg == g)
+      .map(([s, _]) => s).sort()
   }
 }
+
+export default GradeSchool

exercises/grade-school/grade-school.test.ts

@@ -11,10 +11,18 @@ describe('School', () => {
     expect(gradeSchool.studentRoster().size === 0).toEqual(true)
   })
 
+  xit("A student can't be in two different grades", () => {
+    gradeSchool.addStudent('Aimee', 2)
+    gradeSchool.addStudent('Aimee', 1)
+
+    const emptyGrade = gradeSchool.studentsInGrade(2)
+    expect(emptyGrade).toEqual([])
+  })
+
   xit('adding a student adds them to the roster for the given grade', () => {
     gradeSchool.addStudent('Aimee', 2)
 
-    const expectedDb = new Map(Object.entries({ 2 : [ 'Aimee' ] }))
+    const expectedDb = new Map(Object.entries({ 2: ['Aimee'] }))
     expect(gradeSchool.studentRoster()).toEqual(expectedDb)
   })
 
@@ -23,15 +31,15 @@ describe('School', () => {
     gradeSchool.addStudent('James', 2)
     gradeSchool.addStudent('Paul', 2)
 
-    const expectedDb = new Map(Object.entries({ 2 : [ 'Blair', 'James', 'Paul' ] }))
+    const expectedDb = new Map(Object.entries({ 2: ['Blair', 'James', 'Paul'] }))
     expect(gradeSchool.studentRoster()).toEqual(expectedDb)
   })
 
   xit('adding students to different grades adds them to the roster', () => {
     gradeSchool.addStudent('Chelsea', 3)
     gradeSchool.addStudent('Logan', 7)
 
-    const expectedDb = new Map(Object.entries({ 3 : [ 'Chelsea' ], 7 : [ 'Logan'] }))
+    const expectedDb = new Map(Object.entries({ 3: ['Chelsea'], 7: ['Logan'] }))
     expect(gradeSchool.studentRoster()).toEqual(expectedDb)
   })
 
@@ -40,7 +48,7 @@ describe('School', () => {
     gradeSchool.addStudent('Bradley', 5)
     gradeSchool.addStudent('Jeff', 1)
 
-    const expectedStudents = [ 'Bradley', 'Franklin' ]
+    const expectedStudents = ['Bradley', 'Franklin']
     expect(gradeSchool.studentsInGrade(5)).toEqual(expectedStudents)
   })
 
@@ -55,9 +63,9 @@ describe('School', () => {
     gradeSchool.addStudent('Kyle', 3)
 
     const expectedSortedStudents = new Map(Object.entries({
-      3 : ['Kyle'],
-      4 : ['Christopher', 'Jennifer'],
-      6 : ['Kareem']
+      3: ['Kyle'],
+      4: ['Christopher', 'Jennifer'],
+      6: ['Kareem']
     }))
     expect(gradeSchool.studentRoster()).toEqual(expectedSortedStudents)
   })
@@ -67,14 +75,14 @@ describe('School', () => {
     const roster = gradeSchool.studentRoster()
     const result = roster.get('2') || []
     result.push('Oops.')
-    const expectedDb = new Map(Object.entries({ 2 : [ 'Aimee' ] }))
+    const expectedDb = new Map(Object.entries({ 2: ['Aimee'] }))
     expect(gradeSchool.studentRoster()).toEqual(expectedDb)
   })
 
   xit('roster cannot be modified outside of module using studentsInGrade()', () => {
     gradeSchool.addStudent('Aimee', 2)
     gradeSchool.studentsInGrade(2).push('Oops.')
-    const expectedDb = new Map(Object.entries({ 2 : [ 'Aimee' ] }))
+    const expectedDb = new Map(Object.entries({ 2: ['Aimee'] }))
     expect(gradeSchool.studentRoster()).toEqual(expectedDb)
   })