Andrez higuera

Project.md

@@ -0,0 +1,4 @@
+# Descripción del Proyecto
+Este es un proyecto base para el backend desarrollado en el curso DevOps. 
+
+Desarrollado y modificado por Andrez Higuera.

README.md

@@ -1,2 +1,4 @@
 Readme.md
 # backend-base
+
+- Proyecto actualizado por **Andrez Higuera**

__test__/calculadora.spec.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from "@jest/globals";
-import { restar, suma, operar } from "../src/calculadora.js";
+import { restar, suma, operar, multiplicar, dividir, potencia, factorial } from "../src/calculadora.js";
 import app from "../src/server.js";
 import request from "supertest";
 
@@ -25,17 +25,82 @@ describe("Calculadora", () => {
 
         let a: any = 100;
         let b: any = 200;
+
+        // Resta
         expect(operar("resta", b, a)).toBe(100);
-
+
+        // Suma
         a = 10;
         b = "a";
         expect(operar("suma", a, b)).toBeNaN();
-
+    
         a = undefined;
         b = 1;
         expect(() => { operar("suma", a, b) }).toThrow("No se puede sumar indefinidos");
-
-    });
+
+        // Multiplicación
+        a = 10;
+        b = 20;
+        expect(operar("multiplicacion", a, b)).toBe(200);
+
+        a = 10;
+        b = "a";
+        expect(operar("multiplicacion", a, b)).toBeNaN();
+
+        a = undefined;
+        b = 1;
+        expect(() => { operar("multiplicacion", a, b) }).toThrow("No se puede multiplicar indefinidos");
+
+        // División
+        a = 10;
+        b = 2;
+        expect(operar("division", a, b)).toBe(5);
+
+        a = 10;
+        b = 0;
+        expect(() => { operar("division", a, b) }).toThrow("No se puede dividir por cero");
+
+        a = 10;
+        b = "a";
+        expect(operar("division", a, b)).toBeNaN();
+
+        a = undefined;
+        b = 1;
+        expect(() => { operar("division", a, b) }).toThrow("No se puede dividir indefinidos");
+
+        // Potencia
+        a = 2;
+        b = 3;
+        expect(operar("potencia", a, b)).toBe(8);
+
+        a = 2;
+        b = "a";
+        expect(operar("potencia", a, b)).toBeNaN();
+
+        a = undefined;
+        b = 1;
+        expect(() => { operar("potencia", a, b) }).toThrow("No se puede calcular la potencia con indefinidos");
+
+        // Factorial
+        a = 5;
+        expect(operar("factorial", a)).toBe(120);
+
+        a = 0;
+        expect(operar("factorial", a)).toBe(1);
+
+        a = -1;
+        expect(() => { operar("factorial", a) }).toThrow("El factorial solo está definido para números no negativos");
+
+        a = "a";
+        expect(() => { operar("factorial", a) }).toThrow("El factorial solo está definido para números no negativos");
+
+        a = undefined;
+        expect(() => { operar("factorial", a) }).toThrow("No se puede calcular el factorial de un indefinido");
+
+        a = 10;
+        b = 20;
+        expect(() => { operar("operacion_invalida", a, b) }).toThrow("Operación no reconocida");
+    });    
 
     test("restar dos numeros", () => {
 
@@ -52,14 +117,78 @@ describe("Calculadora", () => {
         expect(() => { restar(a, b) }).toThrow("No se puede sumar indefinidos");
     });
 
+    // Nuevos tests agregados
+
+    test("multiplicar dos numeros", () => {
+        let a: any = 10;
+        let b: any = 20;
+        expect(multiplicar(a, b)).toBe(200);
+
+        a = 10;
+        b = "a";
+        expect(multiplicar(a, b)).toBeNaN();
+
+        a = undefined;
+        b = 1;
+        expect(() => { multiplicar(a, b) }).toThrow("No se puede multiplicar indefinidos");
+    });
+
+    test("dividir dos numeros", () => {
+        let a: any = 10;
+        let b: any = 2;
+        expect(dividir(a, b)).toBe(5);
+
+        a = 10;
+        b = 0;
+        expect(() => { dividir(a, b) }).toThrow("No se puede dividir por cero");
+
+        a = 10;
+        b = "a";
+        expect(dividir(a, b)).toBeNaN();
+
+        a = undefined;
+        b = 1;
+        expect(() => { dividir(a, b) }).toThrow("No se puede dividir indefinidos");
+    });
+
+    test("calcular la potencia de dos numeros", () => {
+        let a: any = 2;
+        let b: any = 3;
+        expect(potencia(a, b)).toBe(8);
+
+        a = 2;
+        b = "a";
+        expect(potencia(a, b)).toBeNaN();
+
+        a = undefined;
+        b = 1;
+        expect(() => { potencia(a, b) }).toThrow("No se puede calcular la potencia con indefinidos");
+    });
+
+    test("calcular el factorial de un numero", () => {
+        let a: any = 5;
+        expect(factorial(a)).toBe(120);
+
+        a = 0;
+        expect(factorial(a)).toBe(1);
+
+        a = -1;
+        expect(() => { factorial(a) }).toThrow("El factorial solo está definido para números no negativos");
+
+        a = "a";
+        expect(() => { factorial(a) }).toThrow("El factorial solo está definido para números no negativos");
+
+        a = undefined;
+        expect(() => { factorial(a) }).toThrow("No se puede calcular el factorial de un indefinido");
+    });
 
     test("test de endpoint /", async () => {
         return await request(app)
             .get("/")
             .expect("Content-Type", /text/)
             .expect(200)
             .then((response) => {
-                expect(response.text).toBe("Hola mundo al usuario cmd");
+                expect(response.text).toBe("Hola mundo al usuario Andrez Higuera");
             })
     });
 

src/calculadora.ts

@@ -1,12 +1,22 @@
-function operar(operacion: string, a: number, b: number) {
+function operar(operacion: string, a: number, b?: number) {
     if (operacion === 'suma') {
         return suma(a, b);
     } else if (operacion === 'resta') {
         return restar(a, b);
+    } else if (operacion === 'multiplicacion') {
+        return multiplicar(a, b);
+    } else if (operacion === 'division') {
+        return dividir(a, b);
+    } else if (operacion === 'potencia') {
+        return potencia(a, b);
+    } else if (operacion === 'factorial') {
+        return factorial(a);
+    } else {
+        throw new Error("Operación no reconocida");
     }
 }
 
-function suma(a: number, b: number) {
+function suma(a: number, b?: number) {
 
     if (a === undefined || b === undefined) {
         console.log("retornando throw")
@@ -20,7 +30,7 @@ function suma(a: number, b: number) {
     return a + b;
 }
 
-function restar(a: number, b: number) {
+function restar(a: number, b?: number) {
     if (a === undefined || b === undefined) {
         console.log("retornando throw")
         throw new Error("No se puede sumar indefinidos");
@@ -33,4 +43,60 @@ function restar(a: number, b: number) {
     return a - b;
 }
 
-export { suma, operar, restar };
+function multiplicar(a: number, b?: number) {
+    if (a === undefined || b === undefined) {
+        throw new Error("No se puede multiplicar indefinidos");
+    }
+
+    if (typeof a !== 'number' || typeof b !== 'number') {
+        return NaN;
+    }
+
+    return a * b;
+}
+
+function dividir(a: number, b?: number) {
+    if (a === undefined || b === undefined) {
+        throw new Error("No se puede dividir indefinidos");
+    }
+
+    if (typeof a !== 'number' || typeof b !== 'number') {
+        return NaN;
+    }
+
+    if (b === 0) {
+        throw new Error("No se puede dividir por cero");
+    }
+
+    return a / b;
+}
+
+function potencia(a: number, b?: number) {
+    if (a === undefined || b === undefined) {
+        throw new Error("No se puede calcular la potencia con indefinidos");
+    }
+
+    if (typeof a !== 'number' || typeof b !== 'number') {
+        return NaN;
+    }
+
+    return Math.pow(a, b);
+}
+
+function factorial(a: number): number {
+    if (a === undefined) {
+        throw new Error("No se puede calcular el factorial de un indefinido");
+    }
+
+    if (typeof a !== 'number' || a < 0) {
+        throw new Error("El factorial solo está definido para números no negativos");
+    }
+
+    if (a === 0 || a === 1) {
+        return 1;
+    }
+
+    return a * factorial(a - 1);
+}
+
+export { suma, operar, restar, multiplicar, dividir, potencia, factorial };

src/config.ts

@@ -1,4 +1,4 @@
 export const configuration = {
-    username: 'cmd',
+    username: 'Andrez Higuera',
     port: 3001
 }