[js][student_grades][extract_class] Add example

[js][student_grades][extract_class] Add example

Author: rgomezcasas

examples/js/js-student_grades-03_extract_class/.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+.tmp/

examples/js/js-student_grades-03_extract_class/babel.config.json

@@ -0,0 +1,4 @@
+{
+    "presets": ["@babel/preset-env"],
+    "plugins": ["@babel/plugin-proposal-class-properties"]
+}

examples/js/js-student_grades-03_extract_class/jest.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+    testEnvironment: 'node',
+    verbose: true,
+    cacheDirectory: './.tmp/jestCache',
+    transform: {'^.+\\.js$': 'babel-jest'},
+    testMatch:[ "**/tests/**/*.[jt]s?(x)", "**/?(*.)+(spec|test).[jt]s?(x)" ],
+    moduleFileExtensions: ['js']
+};

examples/js/js-student_grades-03_extract_class/package-lock.json

@@ -0,0 +1,28 @@
+{
+  "name": "student_grades",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "author": "",
+  "license": "ISC",
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "jsx"
+    ],
+    "moduleDirectories": [
+      "node_modules",
+      "src"
+    ]
+  },
+  "devDependencies": {
+    "@babel/core": "^7.11.6",
+    "@babel/plugin-proposal-class-properties": "^7.10.4",
+    "@babel/preset-env": "^7.11.5",
+    "@jest/globals": "^26.4.2",
+    "jest": "^26.4.2"
+  }
+}

examples/js/js-student_grades-03_extract_class/package.json

@@ -0,0 +1,37 @@
+export class StudentGradeCalculator {
+    constructor(yearToCalculate, teachers) {
+        this.yearToCalculate = yearToCalculate;
+        this.teachers        = teachers;
+    }
+    
+    calculate(examGrades, hasReachedMinimumClasses) {
+        if (examGrades.length !== 0) {
+            
+            let gradesSum       = 0;
+            let gradesWeightSum = 0;
+            
+            for (let examGrade of examGrades) {
+                gradesSum += (examGrade[0] * examGrade[1] / 100);
+                gradesWeightSum += examGrade[0];
+            }
+            
+            if (gradesWeightSum === 100) {
+                if (hasReachedMinimumClasses) {
+                    if (this.teachers.isThereAnyBenevolent(this.yearToCalculate)) {
+                        return Math.min(10, gradesSum + 1);
+                    } else {
+                        return gradesSum;
+                    }
+                } else {
+                    return 0;
+                }
+            } else if (gradesWeightSum > 100) {
+                return -1;
+            } else {
+                return -2;
+            }
+        } else {
+            return 0;
+        }
+    }
+}

examples/js/js-student_grades-03_extract_class/src/StudentGradeCalculator.js

@@ -0,0 +1,34 @@
+export class Teachers {
+    allYearsTeachers = {
+        2020: [
+            ["Josefina", true],
+            ["Edonisio", true],
+            ["Edufasio", false],
+        ],
+        2019: [
+            ["Eduarda", false],
+            ["Abelardo", false],
+            ["Francisca", false],
+        ]
+    };
+    
+    isThereAnyBenevolent(yearToCalculate) {
+        let isThereAnyBenevolent = false;
+    
+        for (let [year, teachers] of Object.entries(this.allYearsTeachers)) {
+            if (!(yearToCalculate != year)) {
+                for (let teacher of teachers) {
+                    if (teacher[1] != true) {
+                        continue;
+                    }
+                
+                    isThereAnyBenevolent = true;
+                }
+            } else {
+                continue;
+            }
+        }
+    
+        return isThereAnyBenevolent;
+    }
+}

examples/js/js-student_grades-03_extract_class/src/Teachers.js

@@ -0,0 +1,158 @@
+import {StudentGradeCalculator} from '../src/StudentGradeCalculator';
+import {Teachers} from "../src/Teachers";
+
+describe('StudentGradeCalculator should', () => {
+    it('fail given there are no exams', () => {
+        const calculator = new StudentGradeCalculator(2019, new Teachers(), new Teachers());
+        
+        const examsGrades              = [];
+        const hasReachedMinimumClasses = true;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(0);
+    });
+    
+    it('calculate same grade given one single exam and attending the minimum classes', () => {
+        const calculator = new StudentGradeCalculator(2019, new Teachers());
+        
+        const examsGrades              = [[100, 5]];
+        const hasReachedMinimumClasses = true;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(5);
+    });
+    
+    it('calculate average grade given different exam grades and attending the minimum classes', () => {
+        const calculator = new StudentGradeCalculator(2019, new Teachers());
+        
+        const examsGrades              = [
+            [10, 4],
+            [10, 6],
+            [10, 2],
+            [10, 8],
+            [10, 0],
+            [10, 10],
+            [10, 0],
+            [10, 10],
+            [10, 0],
+            [10, 10],
+        ];
+        const hasReachedMinimumClasses = true;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(5);
+    });
+    
+    it('round up to 2 decimals given odd exam grades and attending the minimum classes', () => {
+        const calculator = new StudentGradeCalculator(2019, new Teachers());
+        
+        const examsGrades              = [
+            [50, 4],
+            [50, 5]
+        ];
+        const hasReachedMinimumClasses = true;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(4.5);
+    });
+    
+    // hasReachedMinimumClasses
+    
+    it('fail when there are no exams and has not attended the minimum classes', () => {
+        const calculator = new StudentGradeCalculator(2019, new Teachers());
+        
+        const examsGrades              = [];
+        const hasReachedMinimumClasses = false;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(0);
+    });
+    
+    it('fail given one single exam but not attending the minimum classes', () => {
+        const calculator = new StudentGradeCalculator(2019, new Teachers());
+        
+        const examsGrades              = [[100, 5]];
+        const hasReachedMinimumClasses = false;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(0);
+    });
+    
+    it('fail given different exam grades but not attending the minimum classes', () => {
+        const calculator = new StudentGradeCalculator(2019, new Teachers());
+        
+        const examsGrades              = [
+            [10, 4],
+            [10, 6],
+            [10, 2],
+            [10, 8],
+            [10, 0],
+            [10, 10],
+            [10, 0],
+            [10, 10],
+            [10, 0],
+            [10, 10],
+        ];
+        const hasReachedMinimumClasses = false;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(0);
+    });
+    
+    it('fail given odd exam grades but not attending the minimum classes', () => {
+        const calculator = new StudentGradeCalculator(2019, new Teachers());
+        
+        const examsGrades              = [[50, 5], [50, 4]];
+        const hasReachedMinimumClasses = false;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(0);
+    });
+    
+    // Weight
+    
+    it('validate all exam grades weight below 100', () => {
+        const calculator = new StudentGradeCalculator(2019, new Teachers());
+        
+        const examsGrades              = [
+            [10, 4],
+            [10, 6]
+        ];
+        const hasReachedMinimumClasses = false;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(-2);
+    });
+    
+    it('validate all exam grades weight over 100', () => {
+        const calculator = new StudentGradeCalculator(2019, new Teachers());
+        
+        const examsGrades              = [
+            [90, 4],
+            [20, 6]
+        ];
+        const hasReachedMinimumClasses = false;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(-1);
+    });
+    
+    // hasToRaiseOnePoint
+    
+    it('not increase one extra point if there is not any benevolent teacher in the year to calculate grades', () => {
+        const calculator = new StudentGradeCalculator(2019, new Teachers());
+        
+        const examsGrades              = [[100, 9.8]];
+        const hasReachedMinimumClasses = true;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(9.8);
+    });
+   
+    it('increase one extra point if there is any benevolent teacher in the year to calculate grades', () => {
+        const calculator = new StudentGradeCalculator(2020, new Teachers());
+        
+        const examsGrades              = [[100, 5]];
+        const hasReachedMinimumClasses = true;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(6);
+    });
+    
+    it('maintain 10 as the maximum grade even if increasing one extra point', () => {
+        const calculator = new StudentGradeCalculator(2020, new Teachers());
+        
+        const examsGrades              = [[100, 9.8]];
+        const hasReachedMinimumClasses = true;
+        
+        expect(calculator.calculate(examsGrades, hasReachedMinimumClasses)).toBe(10);
+    });
+});