Stats calculator jan 15 2

ThePhasesOfCraftship/2_best_practice_first/testingBasics/exercises/2_Arrange_Act_Assert_Backwards/2_2_Stats_Calculator/src/index.spec.ts

@@ -1,5 +1,58 @@
+import {Statistics, StatsCalculator} from "./index";
+
+type HappyCase = [number[], Statistics];
 
 describe('stats calculator', () => {
+    const happyCases: HappyCase[] = [
+        [[1, 2, 3], {
+            min: 1,
+            max: 3,
+            numberOfElements: 3,
+            average: 2
+        }],
+        [[2, 3, 1, 6], {
+            min: 1,
+            max: 6,
+            numberOfElements: 4,
+            average: 3
+        }],
+        [[2, 4, 21, -8, 53, 40], {
+            min: -8,
+            max: 53,
+            numberOfElements: 6,
+            average: 18.666666666666668
+        }],
+        [[0, 0, 0], {
+            min: 0,
+            max: 0,
+            numberOfElements: 3,
+            average: 0
+        }]
+    ];
+    it.each(happyCases)("should know that for the numbers %s the result should be %s", (numbers, expected) => {
+        expect(StatsCalculator.run(numbers)).toEqual(expected)
+    })
+
+    it('should throw an error message \"Input contains invalid numbers (e.g., NaN or non-numeric values).\" if the list contains a non number', () => {
+        const numbers = [0, 0, "d"];
+
+        // @ts-ignore
+        expect(() => StatsCalculator.run(numbers)).toThrowError("Input contains invalid numbers (e.g., NaN or non-numeric values).");
+    })
+
+    it('should throw an error message \"Input must be a non-empty array of numbers.\" if the list is empty', () => {
+        const numbers: number[] = [];
+
+        expect(() => StatsCalculator.run(numbers)).toThrowError("Input must be a non-empty array of numbers.");
+    })
 
+    it('should throw an error message \"Input must be a non-empty array of numbers.\" if the input is an object', () => {
+        const numbers= {
+            a: 1,
+            b: 2
+        };
 
+        // @ts-ignore
+        expect(() => StatsCalculator.run(numbers)).toThrowError("Input must be a non-empty array of numbers.");
+    })
 })

ThePhasesOfCraftship/2_best_practice_first/testingBasics/exercises/2_Arrange_Act_Assert_Backwards/2_2_Stats_Calculator/src/index.ts

@@ -0,0 +1,67 @@
+export type Statistics = {
+    min: number,
+    max: number,
+    numberOfElements: number,
+    average: number
+}
+
+export class StatsCalculator {
+    static run(numbers: number[]): Statistics {
+
+        this.validate(numbers);
+
+        const min = this.minOf(numbers);
+        const max = this.maxOf(numbers);
+        const numberOfElements = this.numberOfElementsOf(numbers);
+        const average = this.averageOf(numbers);
+
+        return {
+            min,
+            max,
+            numberOfElements,
+            average
+        }
+    }
+
+    private static validate(numbers: number[]) {
+        if (this.isEmpty(numbers) || this.isNotArray(numbers)) {
+            throw new Error("Input must be a non-empty array of numbers.")
+        }
+
+        if (this.someIsNotANumber(numbers)) {
+            throw new Error("Input contains invalid numbers (e.g., NaN or non-numeric values).")
+        }
+    }
+
+    private static isEmpty(numbers: number[]) {
+        return numbers.length === 0;
+    }
+
+    private static isNotArray(numbers: number[]) {
+        return !Array.isArray(numbers);
+    }
+
+    private static someIsNotANumber(numbers: number[]) {
+        return numbers.some(num => typeof num !== "number" || isNaN(num));
+    }
+
+    private static minOf(numbers: number[]) {
+        return numbers.reduce((min, current) => current < min ? current : min);
+    }
+
+    private static maxOf(numbers: number[]) {
+        return numbers.reduce((max, current) => current > max ? current : max);
+    }
+
+    private static numberOfElementsOf(numbers: number[]) {
+        return numbers.length;
+    }
+
+    private static averageOf(numbers: number[]) {
+        return this.sumOf(numbers) / numbers.length;
+    }
+
+    private static sumOf(numbers: number[]) {
+        return numbers.reduce((total, current) => total + current, 0);
+    }
+}