Benevolent teachers can decide if we increase one extra point to all studens (code logic in order to be extracted in its own method and illustrate complex if conditions)

JavierCane · JavierCane · commit 51bb022dcd57 · 2020-09-21T17:39:59.000+02:00
diff --git a/examples/java/java-student_grades-01_base_example/src/main/java/tv/codely/student_grades/StudentGradeCalculator.java b/examples/java/java-student_grades-01_base_example/src/main/java/tv/codely/student_grades/StudentGradeCalculator.java
@@ -1,13 +1,55 @@
 package tv.codely.student_grades;
 
+import java.util.AbstractMap;
 import java.util.List;
 import java.util.Map;
 
 public class StudentGradeCalculator {
-    public Float calculateGrades(final List<Pair<Integer, Float>> examsGrades, final boolean hasReachedMinimumClasses) {
+    final private Map<Integer, List<Pair<String, Boolean>>> allYearsTeachers = Map.ofEntries(
+        new AbstractMap.SimpleImmutableEntry<>(
+            2020,
+            List.of(
+                new Pair<>("Josefina", true),
+                new Pair<>("Edonisio", true),
+                new Pair<>("Edufasio", false)
+            )
+        ),
+        new AbstractMap.SimpleImmutableEntry<>(
+            2019,
+            List.of(
+                new Pair<>("Eduarda", false),
+                new Pair<>("Abelardo", false),
+                new Pair<>("Francisca", false)
+            )
+        )
+    );
+    private final int                                       yearToCalculate;
+
+    public StudentGradeCalculator(final int yearToCalculate) {
+        this.yearToCalculate = yearToCalculate;
+    }
+
+    public float calculateGrades(final List<Pair<Integer, Float>> examsGrades, final boolean hasReachedMinimumClasses) {
         if (!examsGrades.isEmpty()) {
-            Float gradesSum = 0f;
-            Integer gradesWeightSum = 0;
+            boolean hasToIncreaseOneExtraPoint = false;
+
+            for (Map.Entry<Integer, List<Pair<String, Boolean>>> yearlyTeachers : allYearsTeachers.entrySet()) {
+                if (!(yearToCalculate != yearlyTeachers.getKey())) {
+                    List<Pair<String, Boolean>> teachers = yearlyTeachers.getValue();
+
+                    for (Pair<String, Boolean> teacher : teachers) {
+                        if (teacher.second() != true) {
+                            continue;
+                        }
+                        hasToIncreaseOneExtraPoint = true;
+                    }
+                } else {
+                    continue;
+                }
+            }
+
+            float gradesSum       = 0f;
+            int   gradesWeightSum = 0;
 
             for (Pair<Integer, Float> examGrade : examsGrades) {
                 gradesSum += (examGrade.first() * examGrade.second() / 100);
@@ -16,7 +58,11 @@ public Float calculateGrades(final List<Pair<Integer, Float>> examsGrades, final
 
             if (gradesWeightSum == 100) {
                 if (hasReachedMinimumClasses) {
-                    return gradesSum;
+                    if (hasToIncreaseOneExtraPoint) {
+                        return Float.min(10f, gradesSum + 1);
+                    } else {
+                        return gradesSum;
+                    }
                 } else {
                     return 0f;
                 }
diff --git a/examples/java/java-student_grades-01_base_example/src/test/java/tv/codely/student_grades/StudentGradeCalculatorShould.java b/examples/java/java-student_grades-01_base_example/src/test/java/tv/codely/student_grades/StudentGradeCalculatorShould.java
@@ -10,7 +10,7 @@
 public class StudentGradeCalculatorShould {
     @Test
     void fail_given_there_are_no_exams() {
-        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2019);
 
         final List<Pair<Integer, Float>> examsGrades              = Collections.emptyList();
         final boolean                    hasReachedMinimumClasses = true;
@@ -20,7 +20,7 @@ void fail_given_there_are_no_exams() {
 
     @Test
     void calculate_same_grade_given_one_single_exam_and_attending_the_minimum_classes() {
-        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2019);
 
         final List<Pair<Integer, Float>> examsGrades              = List.of(new Pair<>(100, 5f));
         final boolean                    hasReachedMinimumClasses = true;
@@ -30,7 +30,7 @@ void calculate_same_grade_given_one_single_exam_and_attending_the_minimum_classe
 
     @Test
     void calculate_average_grade_given_different_exam_grades_and_attending_the_minimum_classes() {
-        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2019);
 
         final List<Pair<Integer, Float>> examsGrades = List.of(
             new Pair<>(10, 4f),
@@ -51,7 +51,7 @@ void calculate_average_grade_given_different_exam_grades_and_attending_the_minim
 
     @Test
     void round_up_to_2_decimals_given_odd_exam_grades_and_attending_the_minimum_classes() {
-        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2019);
 
         final List<Pair<Integer, Float>> examsGrades = List.of(
             new Pair<>(50, 4f),
@@ -66,7 +66,7 @@ void round_up_to_2_decimals_given_odd_exam_grades_and_attending_the_minimum_clas
 
     @Test
     void fail_when_there_are_no_exams_and_has_not_attended_the_minimum_classes() {
-        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2019);
 
         final List<Pair<Integer, Float>> examsGrades              = Collections.emptyList();
         final boolean                    hasReachedMinimumClasses = false;
@@ -76,7 +76,7 @@ void fail_when_there_are_no_exams_and_has_not_attended_the_minimum_classes() {
 
     @Test
     void fail_given_one_single_exam_but_not_attending_the_minimum_classes() {
-        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2019);
 
         final List<Pair<Integer, Float>> examsGrades              = List.of(new Pair<>(100, 5f));
         final boolean                    hasReachedMinimumClasses = false;
@@ -86,7 +86,7 @@ void fail_given_one_single_exam_but_not_attending_the_minimum_classes() {
 
     @Test
     void fail_given_different_exam_grades_but_not_attending_the_minimum_classes() {
-        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2019);
 
         final List<Pair<Integer, Float>> examsGrades = List.of(
             new Pair<>(10, 4f),
@@ -106,14 +106,11 @@ void fail_given_different_exam_grades_but_not_attending_the_minimum_classes() {
     }
 
     @Test
-    void fail_given_odd_exam_grades_but_not_attending_the_minimum_classes() {
-        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
+    void fail_given_odd_exam_grades_but_attending_the_minimum_classes() {
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2019);
 
-        final List<Pair<Integer, Float>> examsGrades = List.of(
-            new Pair<>(50, 5f),
-            new Pair<>(50, 4f)
-        );
-        final boolean hasReachedMinimumClasses = false;
+        final List<Pair<Integer, Float>> examsGrades              = List.of(new Pair<>(100, 5f));
+        final boolean                    hasReachedMinimumClasses = false;
 
         assertEquals(0, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
     }
@@ -122,7 +119,7 @@ void fail_given_odd_exam_grades_but_not_attending_the_minimum_classes() {
 
     @Test
     void validate_all_exam_grades_weight_below_100() {
-        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2019);
 
         final List<Pair<Integer, Float>> examsGrades = List.of(
             new Pair<>(10, 4f),
@@ -135,7 +132,7 @@ void validate_all_exam_grades_weight_below_100() {
 
     @Test
     void validate_all_exam_grades_weight_over_100() {
-        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator();
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2019);
 
         final List<Pair<Integer, Float>> examsGrades = List.of(
             new Pair<>(90, 4f),
@@ -145,4 +142,36 @@ void validate_all_exam_grades_weight_over_100() {
 
         assertEquals(-1, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
     }
+
+    // hasToRaiseOnePoint
+
+    @Test
+    void not_increase_one_extra_point_if_there_is_not_any_benevolent_teacher_in_the_year_to_calculate_grades() {
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2019);
+
+        final List<Pair<Integer, Float>> examsGrades              = List.of(new Pair<>(100, 9.8f));
+        final boolean                    hasReachedMinimumClasses = true;
+
+        assertEquals(9.8f, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
+    }
+
+    @Test
+    void increase_one_extra_point_if_there_is_any_benevolent_teacher_in_the_year_to_calculate_grades() {
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2020);
+
+        final List<Pair<Integer, Float>> examsGrades              = List.of(new Pair<>(100, 5f));
+        final boolean                    hasReachedMinimumClasses = true;
+
+        assertEquals(6, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
+    }
+
+    @Test
+    void maintain_10_as_the_maximum_grade_even_if_increasing_one_extra_point() {
+        StudentGradeCalculator studentGradeCalculator = new StudentGradeCalculator(2020);
+
+        final List<Pair<Integer, Float>> examsGrades              = List.of(new Pair<>(100, 9.8f));
+        final boolean                    hasReachedMinimumClasses = true;
+
+        assertEquals(10, studentGradeCalculator.calculateGrades(examsGrades, hasReachedMinimumClasses));
+    }
 }
