No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Test Driven Development

21/26
Recursos

Aportes 60

Preguntas 6

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Esto no me lo ense帽aron en la universidad. Esta genial!!!

Test Driven Development


Este consiste en primeros las pruebas y luego el software. Etapas:

  1. Escribir un test que falle
  2. Hacer que el c贸digo funcione
  3. Eliminar la redundancia

Escribir el siguiente comando para que nos de los resultados del test mas el nombre del test.

php vendor/phpunit/phpunit/phpunit --testdox tests/CalculatorTest.php

Con un alias es m谩s c贸modo ejecutar las pruebas:

La clase esta adelanta, vean primero las dos proximas, esta es la ultima de este modulo

TDD: Test Driven Development

Metodolog铆a que propone escribir primero la prueba y luego la funcionalidad.

Cuando ejecuto me sale que no encuentra la clase Calculator.php pero si la tengo definida


Sin embargo obtengo este error

Pero investigue en internet y con el codigo "require (鈥楥alculator.php鈥);"
Si me funciona perfectamente Talvez a alguien le interese
Porque sera

<?php 

use PHPUnit\Framework\TestCase;


class CalculatorTest extends TestCase
{
    public function testAddWillReturnTheSumOfItsParameters()
    {
        $sut = new Calculator();
     
        $this->assertEquals(8, $sut->add(5,3));
        $this->assertEquals(5, $sut->add(5,0));
    }

    public function testAddWillReturnTheSubtractOfItsParameters()
    {
        $sut = new Calculator();
     
        $this->assertEquals(5, $sut->subtract(8,3));
        $this->assertEquals(8, $sut->subtract(10,2));
        $this->assertEquals(2, $sut->subtract(4,2));
    }
    
    public function testAddWillReturnTheMultiplyOfItsParameters()
    {
        $sut = new Calculator();
     
        $this->assertEquals(24, $sut->multiply(8,3));
        $this->assertEquals(20, $sut->multiply(10,2));
        $this->assertEquals(8, $sut->multiply(4,2));
    }

    public function testAddWillReturnTheDivideOfItsParameters()
    {
        $sut = new Calculator();
     
        $this->assertEquals(5, $sut->divide(10,2));
        $this->assertEquals(20, $sut->divide(40,2));
        $this->assertEquals(4, $sut->divide(8,2));
    }
}



<?php
class Calculator
{
    public function add(int $a, int $b): int
    {
        return $a + $b;
    }
    
    public function subtract(int $a, int $b): int
    {
        return $a - $b;
    }
    
    public function multiply(int $a, int $b): int
    {
        return $a * $b;
    }

    public function divide(int $a, int $b): float
    {
        if ($b ===0) {
            throw new InvalidArgumentException('No se puede dividir entre 0');
        }
        return $a / $b;
    }
    
}



Resultados de pruebas:


root@debian:/var/www/html/platzi/platzi-tdd# vendor/phpunit/phpunit/phpunit --testdox  tests/CalculatorTest.php
PHPUnit 8.2.2 by Sebastian Bergmann and contributors.

Calculator
 鉁 Add will return the sum of its parameters
 鉁 Add will return the subtract of its parameters
 鉁 Add will return the multiply of its parameters
 鉁 Add will return the divide of its parameters

Time: 52 ms, Memory: 4.00 MB

OK (4 tests, 11 assertions)```

Si est谩n en linux y creo que igual en cualquier consola bash de Windows, pueden crear un alias para no escribir tantos phpunit:

alias maketests="vendor/phpunit/phpunit/phpunit"

Y simplemente hacen sus pruebas ejecutando 鈥渕aketests鈥, como disclaimer, los alias son temporales, cuando apagues tu PC se borrar谩, pero es 煤til durante la sesi贸n de trabajo:D!

Resumen Clase: TDD, desarrollo guiado por las pruebas, es decir escribir primero el c贸digo de las pruebas y despu茅s desarrollar el c贸digo del sistema por medio de las pruebas escritas. Primero Escribimos los test para que falle y despu茅s escribimos las funciones con lo m铆nimo de c贸digo para que el c贸digo sea un existo, es decir pasar de rojo a verde, despu茅s refactorizamos las funciones y volvemos a correr las pruebas para que pasen de nuevo con 茅xito todas, realizamos esto con todas las funcionalidades de nuestro sistema. Por ultimo podemos decir que el TDD nos obliga a escribir el m铆nimo de c贸digo en nuestras funciones.

Como haces para que se detecten los namespaces sin cargar la clase autoload.php???

Excelente Profe! Solo que creo que deber铆a haber un curso completo de TDD en PHP utilizando PHPUnit, porque ya lo he visto en 3 cursos y s贸lo est谩n abarcando la parte b谩sica. 驴Hay planes de un curso as铆?

Este curso profundiza el tema
Curso de Fundamentos de Pruebas de Software

CalculatorTest.php

<?php

use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase {
    public function testAddWillReturnTheSumOfItsParameter() {
        $sut = new Calculator();

        $this->assertEquals(8, $sut->add(5, 3));
        $this->assertEquals(5, $sut->add(5,0));
    }

    public function testAddWillReturnTheSubtractItsParameter() {
        $sut = new Calculator();

        $this->assertEquals(0, $sut->subtract(3, 3));
        $this->assertEquals(8, $sut->subtract(3, -5));
    }
    
    public function testAddWillReturnTheMultiplyItsParameter() {
        $sut = new Calculator();

        $this->assertEquals(9, $sut->multiply(3, 3));
        $this->assertEquals(20, $sut->multiply(5, 4));
    }

    public function testAddWillReturnTheDivideItsParameter() {
        $sut = new Calculator();

        $this->assertEquals(4, $sut->divide(20, 5));
        $this->assertEquals(2.5, $sut->divide(10, 4));
    }
}

Calculator.php

<?php

class Calculator {
    public function add(int $num1, int $num2) {
        return $num1 + $num2;
    }
    
    public function subtract(int $num1, int $num2) {
        return $num1 - $num2;
    }

    public function multiply(int $num1, int $num2) {
        return $num1 * $num2;
    }

    public function divide(int $num1, int $num2) {
        if(! $num2 == 0) {
            return $num1 / $num2;
        } else {
            throw new InvalidArgumentException("The number is not divide by zero");
        }
    }
}

En python se tienen paquetes para probar las aplicaciones desarrolladas en Python.

En las primeras clases el mentor dice que no es buena practica clean code, iniciar un bloque de c贸digo en otra linea:

function test()
{
echo 鈥淓sto no es buena practica鈥;
}

deber铆a ser as铆:

function test(){
echo 鈥淓sto si鈥;
}

驴Esto es porque en TDD cambia esta "convenci贸n"?

Les dejo este art铆culo, para saber un poco m谩s de la teor铆a de TDD:
https://developer.ibm.com/articles/5-steps-of-test-driven-development/

Este consiste en primeros las pruebas y luego el software. Etapas:

Escribir un test que falle
Hacer que el c贸digo funcione
Eliminar la redundancia
Escribir el siguiente comando para que nos de los resultados del test mas el nombre del test.

Cu谩l es la forma correcta de aplicar esto en python con Django?

amazing

$sut = system under test
Modificador --testdox

sin 鈥攖extdox

PS C:\Users\lynch\Sites\Platzi\platzi-tdd> php vendor/phpunit/phpunit/phpunit tests/CalculatorTest.php 
PHPUnit 9.5.22 #StandWithUkraine

Could not use "PHPUnit\TextUI\ResultPrinter" as printer: class does not exist
PS C:\Users\luisa\Sites\Platzi\platzi-tdd> 

con --testdox

PS C:\Users\lynch\Sites\Platzi\platzi-tdd> php vendor/phpunit/phpunit/phpunit --testdox tests/CalculatorTest.php 
PHPUnit 9.5.22 #StandWithUkraine

Warning:       Using a custom test suite loader is deprecated

Calculator
 鉁 Add will return the sum of its parameters

Time: 00:00.013, Memory: 6.00 MB

OK (1 test, 1 assertion)
PS C:\Users\luisa\Sites\Platzi\platzi-tdd> 

Desde la clase anterior estoy con ese error =(

  public $n1 = 10;
  public $n2 = 3;

  public function testAddTwoParameters(){
    $calc = new Calculator();
    $this->assertEquals( ($this->n1 + $this->n2), $calc->add($this->n1, $this->n2));
  }

  public function testSubtractTwoParameters(){
    $calc = new Calculator();
    $this->assertEquals( ($this->n1 - $this->n2), $calc->sust($this->n1, $this->n2));
  }

  public function testDivideTwoParameters(){
    $calc = new Calculator();
    $this->assertEquals( ($this->n1 / $this->n2), $calc->div($this->n1, $this->n2));
  }

  public function testMultiplyTwoParameters(){
    $calc = new Calculator();
    $this->assertEquals( ($this->n1 * $this->n2), $calc->mult($this->n1, $this->n2));
  }

es te curso me ha ense帽ado mas afondo ya que en las univercidaes no tenense帽an afondo lo que en realidad es el tema

Aqu铆 aprendiendo algo de TDD con PHP, interesante. Reto cumplido, comparto el c贸digo:
Por cierto, muy buena la regla mnemot茅cnica y su aplicaci贸n con --testdox

<?php
    class Calculator {
        public function add(int $a, int $b) {
            return $a + $b;
        }

        public function sub(int $a, int $b) {
            return $a - $b;
        }

        public function mul(int $a, int $b) {
            return $a * $b;
        }

        public function div(int $a, int $b) {
            return $a / $b;
        }
    }
<?php
    use PHPUnit\Framework\TestCase;
    class CalculatorTest extends TestCase {
        public function testAddWillReturnTheSumOfItsParameters() {
            $sut = new Calculator(); //sut means Subject Under Test
            $this->assertEquals(8, $sut->add(5, 3));
            $this->assertEquals(5, $sut->add(2, 3));
        }

        public function testSubWillReturnTheSubstractionOfItsParameters() {
            $sut = new Calculator(); //sut means Subject Under Test
            $this->assertEquals(5, $sut->sub(8, 3));
            $this->assertEquals(2, $sut->sub(5, 3));
        }

        public function testMulWillReturnTheMultiplicationOfItsParameters() {
            $sut = new Calculator(); //sut means Subject Under Test
            $this->assertEquals(25, $sut->mul(5, 5));
            $this->assertEquals(12, $sut->mul(3, 4));
        }

        public function testDivWillReturnTheDivisionOfItsParameters() {
            $sut = new Calculator(); //sut means Subject Under Test
            $this->assertEquals(3, $sut->div(15, 5));
            $this->assertEquals(6, $sut->div(24, 4));
        }
    }

PHPUnit 8.2.2 by Sebastian Bergmann and contributors.

Calculator
鉁 Add will return the sum of its parameters
鉁 Sub will return the substraction of its parameters
鉁 Mul will return the multiplication of its parameters
鉁 Div will return the division of its parameters

Time: 26 ms, Memory: 4.00 MB

OK (4 tests, 8 assertions)

<code> 

Genial !

Mi codigo:

<?php

class Calculator {
  public function add(int $a,int $b) : int {
    return $a + $b;
  }

  public function rest(int $a, int $b) : int {
    return $a - $b;
  }

  public function multiplication(int $a, int $b) : int {
    return $a * $b;
  }
}

Tests:

<?php

use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase {
  public function testAddWillReturnTheSumsOfItsParameters() {
    $sut = new Calculator();

    $this->assertEquals(8 ,$sut->add(5,3));
    $this->assertEquals(5 ,$sut->add(5,0));
  }

  public function testRestWillReturnTheRestOfItsParameters() {
    $sut = new Calculator;

    $this->assertEquals(10 ,$sut->rest(15,5));
    $this->assertEquals(15 ,$sut->rest(25,10));
  }

  public function testMultiplicationWillReturnTheMultiplicationOfItsParameters() {
    $sut = new Calculator;

    $this->assertEquals(75 ,$sut->multiplication(15,5));
    $this->assertEquals(250 ,$sut->multiplication(25,10));
  }
}

Reto cumplido

CalculatorTest.php

<?php

use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase
{
    public function testAddWillReturnTheSumOfItsPAremeters() 
    {
        $sut = new Calculator();

        $this->assertEquals(8, $sut->add(5, 3));
        $this->assertEquals(2, $sut->subtract(6, 4));
        $this->assertEquals(5, $sut->divide(15, 3));
        $this->assertEquals(15, $sut->multiply(5, 3));
    }
}

Calculator.php

<?php

class Calculator 
{
    public function add(int $num1, int $num2) : int
    {
        return $num1 + $num2;
    }

    public function subtract(int $num1, int $num2) : int 
    {
        return $num1 - $num2 ;
    }

    public function divide(int $num1, int $num2) : int 
    {
        return $num1 / $num2;
    }

    public function multiply(int $num1, int $num2) : int
    {
        return $num1 * $num2;
    }
}

Que interesante clase, bastante 煤til !

As铆 como existe ->assertEquals, tambi茅n existen otros metodos de la clase TestCase:
https://gist.github.com/loonies/1255249

totalmente distinta a como trabajo, a aplicar!

La mayor铆a de universidades siempre ense帽an lo mismo, no actualizan sus 铆ndices de contenido.

隆Genial!

System Under Test ?

Muy buena explicaci贸n. todo entendible.

Algo nuevo que se aprende. Bastante 煤til!

CalculatorTest.php

use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase {
  public function testAddWillReturnTheSumOfItsParameters()
  {
    $sut = new Calculator();
    $this->assertEquals( 8, $sut->add(5,3) );
    $this->assertEquals( 5, $sut->add(5,0) );
    $this->assertEquals( 2.7, $sut->add(1.2, 1.5) );
  }
  public function testSubWillReturnTheSubstractionOfItsParameters()
  {
    $sut = new Calculator();
    $this->assertEquals( 5, $sut->sub(8,3) );
    $this->assertEquals( -6, $sut->sub(2,8) );
    $this->assertEquals( 0, $sut->sub(15,15) );
    $this->assertEquals( 3.4, $sut->sub(7, 3.6) );
  }
  public function testMulWillReturnTheMultiplicationOfItsParameters()
  {
    $sut = new Calculator();
    $this->assertEquals( 27, $sut->mul(9,3) );
    $this->assertEquals( -8, $sut->mul(4,-2) );
    $this->assertEquals( 0, $sut->mul(5, 0) );
    $this->assertEquals( 2.5, $sut->mul(5, 0.5) );
  }
  public function testDivWillReturnTheDivisionOfItsParameters()
  {
    $sut = new Calculator();
    $this->assertEquals( 3, $sut->div(9,3) );
    $this->assertEquals( 0.4, $sut->div(4,10) );
  }

  public function testDivisionByZeroWillReturnAnException()
  {
    $sut = new Calculator();
    $this->expectException("Exception");
    $this->expectExceptionMessage("No es posible dividir por 0.");
    $sut->div(5,0);
  }
}

Calculator.php

class Calculator
{
  public function add( float $a, float $b ) : float
  {
    return $a + $b;
  }
  public function sub( float $a, float $b ) : float
  {
    return $a - $b;
  }
  public function mul( float $a, float $b) : float
  {
    return $a * $b;
  }
  public function div( float $a, float $b): float
  {
    if($b !== 0) {
      return $a / $b;
    } else {
      throw new \Exception("No es posible dividir por 0.");
    }
  }
}

Todo muy claro. gracias

Mi c贸digo de la calculadora:

<?php
/**
 * 
 */
class Calculator
{

  public function add(float $a, float $b) : float {
    return $a + $b;
  }

  public function sub(float $a, float $b) : float {
  	return $a - $b;
  }

  public function mul(float $a, float $b) : float {
  	return $a * $b;
  }
  
  public function div(float $a, float $b) : float {

  	if($b === 0) {
  		throw new Exception("No es posible la divisi贸n entre 0"); 	
  	}
	return $a / $b;

  }
  
}
?>

Mis pruebas:

<?php

use PHPUnit\Framework\TestCase; 

/**
 * 
 */
class CalculatorTest extends TestCase {
	
	public function testAddWillReturnTheSumOfItsParameters () {
		$sut = new Calculator();

		$this->assertEquals(8, $sut->add(5, 3));
		$this->assertEquals(5, $sut->add(5, 0));
		$this->assertEquals(6, $sut->add(5.5, 0.5));

	}

	public function testSubWillReturnTheSubstractionOfItsParameters(){
    	$sut = new Calculator();
	    
	    $this->assertEquals(2, $sut->sub(4,2));
	    $this->assertEquals(-2, $sut->sub(2,4));
	    $this->assertEquals(0, $sut->sub(1,1));
	    $this->assertEquals(6.5, $sut->sub(10, 3.5) );
 	}	

	public function testMulWillReturnTheSubstractionOfItsParameters(){
    	$sut = new Calculator();
	    
	    $this->assertEquals(8, $sut->mul(4,2));
	    $this->assertEquals(4, $sut->mul(2,2));
	    $this->assertEquals(0, $sut->mul(1,0));
	    $this->assertEquals(-12, $sut->mul(-3, 4));
	    $this->assertEquals(12, $sut->mul(-3, -4));
	    $this->assertEquals(0, $sut->mul(-3, 0));
 	}	

	public function testDivWillReturnTheSubstractionOfItsParameters(){
    	$sut = new Calculator();
	    
	    $this->assertEquals(2, $sut->div(4,2));
	    $this->assertEquals(1, $sut->div(2,2));
	    $this->assertEquals(-4, $sut->div(-12,3));
	    $this->assertEquals(2.5, $sut->div(5,2));
	    $this->assertEquals(-2.5, $sut->div(-5,2));

 	}

	public function testZeroDivWillReturnTheSubstractionOfItsParameters(){

	    $sut = new Calculator();
	    $this->expectException("Exception");
	    $this->expectExceptionMessage("No es posible la divisi贸n entre 0.");
	    $sut->div(10.5,2);

 	}

}

?>

El tema de los nombres espec铆ficos es algo muy presente en el libro C贸digo Limpio o Clean Code, muy bueno!

C贸mo es que no me ense帽aron nada de testing en la universidad?
Esto es tan extenso e importante 馃槷

muy buena pr谩ctica tdd

Es un muy buen curso

As铆 resolv铆 el reto

CalculatorTest.php

<?php

use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase{
  public function testAddWillReturnTheSumOfItsParameters(){
    $sut = new Calculator();

    $this->assertEquals(8, $sut->add(5, 3));
    $this->assertEquals(5, $sut->add(5, 0));
  }

  public function testSubWillReturnTheSubstractionOfItsParameters(){
    $sut = new Calculator();

    $this->assertEquals(2, $sut->sub(5, 3));
    $this->assertEquals(4, $sut->sub(8, 4));
  }

  public function testMultWillReturnTheMultiplicationOfItsParameters(){
    $sut = new Calculator();

    $this->assertEquals(15, $sut->mult(5, 3));
    $this->assertEquals(24, $sut->mult(3, 8));
  }

  public function testDivWillReturnTheDivisionOfItsParameters(){
    $sut = new Calculator();

    $this->assertEquals(5, $sut->div(15, 3));
    $this->assertEquals(8, $sut->div(56, 7));
  }
}

Calculator.php

<?php
class Calculator
{
  public function add(int $num1, int $num2) : int
  {
    return $num1 + $num2;
  }
  public function sub(int $num1, int $num2) : int
  {
    return $num1 - $num2;
  }
  public function mult(int $num1, int $num2) : int
  {
    return $num1 * $num2;
  }
  public function div(int $num1, int $num2) : float
  {
    return $num1 / $num2;
  }
}

馃槃

class CalculatorTest extends TestCase{
    public function testAddWillBeReturnTheSumOfItsParameters(){
        $sut = new Calculator();

        $this->assertEquals(8, $sut->add(5,3) );
        
    }
    public function testSubstractWillBeReturnTheSubstractionOfItsParameters(){
        $sut = new Calculator();

        $this->assertEquals(2, $sut->substract(5,3) );
        
    }
    public function testMultiplyWillBeReturnTheMultiplicationOfItsParameters(){
        $sut = new Calculator();

        $this->assertEquals(15, $sut->multiply(5,3) );
        
    }
    public function testDivideWillBeReturnTheDivisionOfItsParameters(){
        $sut = new Calculator();

        $this->assertEquals(1, $sut->divide(5,5) );
        $this->assertEquals(2, $sut->divide(4,2) );
    }
}

mi codigo de testing:

<?php

use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase
{
    public function testAddWillReturnTheSumOfItsParameters()
    {
        $sut = new Calculator();

        $this-> assertEquals(8, $sut->add(5, 3));
        $this-> assertEquals(9, $sut->add(7, 2));
    }

    public function testSubstractWillReturnTheSubstractionOfItsParameters()
    {
        $sut = new Calculator();

        $this->assertEquals(6, $sut->substract(6, 0));
        $this->assertEquals(9, $sut->substract(11, 2));
        $this->assertEquals(2, $sut->substract(6, 4));
    }

    public function testMultiplyWillReturnTheMultiplicationOfItsParameters()
    {
        $sut = new Calculator();

        $this->assertEquals(6, $sut->multiply(2, 3));
        $this->assertEquals(10, $sut->multiply(10, 1));
    }

    public function testDivideWillReturnTheDivitionOfItsParameters()
    {
        $sut = new Calculator();

        $this->assertEquals(6, $sut->divide(6, 1));
        $this->assertEquals(9, $sut->divide(27, 3));
        $this->assertEquals(1, $sut->divide(4, 4));
    }
}

y el resultado de las pruebas 馃槃

TDD Reto:

Glamit@DESKTOP-R9AVVDM MINGW64 /c/wamp/www/edu/platzi/php/curso_buenas_practicas_de_escritura_de_codigo/platzi-tdd (main)
$ phpunit tests/CalculatorTest.php
PHPUnit 8.2.2 by Sebastian Bergmann and contributors.

Calculator
鉁 Add will return the sum of its parameters
鉁 Subtract will return the subtraction of its parameters
鉁 Multiply will return the product of its parameters
鉁 Divide will return the division of its parameters
鉁 Divide will throw invalid argument exception when the second parameter equals zero

Time: 138 ms, Memory: 4.00 MB

OK (5 tests, 9 assertions)

PHPUnit en lo personal es la parte que mas me ha costado implementar de todo lo que he aprendido, pero es por la costumbre de realizar el c贸digo y probarlo de la manera manual, definitivamente esta es una buena practica que debemos de tener en todos nuestros desarrollos, el Test de los mismos鈥

Malas pr谩ctica para escritura del c贸digo declarando variables $a y $b , Seg煤n lo aprendido en clase deben declararse descriptivas por ejemplo $numero1 y $numero2 馃槈!!

Muy interedante. Me pareci贸 genial la lectura de la funci贸n como aparece como si fuera una descripci贸n jeje. 馃榾

Reto:

<?php

use PHPUnit\Framework\TestCase;
use Jchook\AssertThrows\AssertThrows;

class CalculatorTest extends TestCase
{
    use AssertThrows;

    public function testAddWillReturnTheSumOfItsParameters()
    {
        $sut = new Calculator();

        $this->assertEquals(8, $sut->add(5, 3));
        $this->assertEquals(5, $sut->add(5, 0));
    }

    public function testSubtractWillReturnTheSubtractOfItsParameters()
    {
        $sut = new Calculator();

        $this->assertEquals(2, $sut->subtract(5, 3));
        $this->assertEquals(5, $sut->subtract(5, 0));
    }

    public function testMultiplyWillReturnTheProductOfItsParameters()
    {
        $sut = new Calculator();

        $this->assertEquals(15, $sut->multiply(5, 3));
        $this->assertEquals(0, $sut->multiply(5, 0));
    }

    public function testDivideWillReturnTheDivisionOfItsParameters()
    {
        $sut = new Calculator();

        $this->assertEquals(2, $sut->divide(6, 3));
        $this->assertEquals(2.5, $sut->divide(5, 2));
    }

    public function testDivideWillThrowInvalidArgumentExceptionWhenTheSecondParameterEqualsZero()
    {
        $sut = new Calculator();

        $this->assertThrows(InvalidArgumentException::class, function() use ($sut) {
            $sut->divide(5, 0);
        });
    }
}

<?php

class Calculator
{
    public function add(int $a, int $b)
    {
        return $a + $b;
    }

    public function subtract(int $a, int $b)
    {
        return $a - $b;
    }

    public function multiply(int $a, int $b)
    {
        return $a * $b;
    }

    public function divide(int $a, int $b)
    {
        if ($b == 0) {
            throw new \InvalidArgumentException("Division by zero");
        }
        return $a / $b;
    }
}
PHPUnit 8.2.2 by Sebastian Bergmann and contributors.

Calculator
 鉁 Add will return the sum of its parameters
 鉁 Subtract will return the subtraction of its parameters
 鉁 Multiply will return the product of its parameters
 鉁 Divide will return the division of its parameters
 鉁 Divide will throw invalid argument exception when the second parameter equals zero

Para la aserci贸n de excepci贸n en la divisi贸n por cero hice uso del paquete Exception assertions for PHPUnit

composer require jchook/phpunit-assert-throws

Le hice un fork al repositorio del profe y ah铆 sub铆 mi reto

[email protected]:RubenchoWeb/platzi-tdd.git```

Muy interesante el tema de las pruebas automatizadas.

Creo que debo retomar PHP tuve problemas al instalar las librer铆as

super interesante