¿Diferencia entre assertEquals y assertSame en phpunit?

PHPUnit contiene un método assertEquals: https://phpunit.de/manual/current/en/appendixes.assertions.html#appendixes.assertions.assertEquals

También tiene un método assertSame: https://phpunit.de/manual/current/en/appendixes.assertions.html#appendixes.assertions.assertSame

A primera vista, parece que hacen lo mismo. ¿Cuál es la diferencia entre los dos? ¿Por qué se especifican ambos?

Uso ambos esporádicamente, pero de acuerdo con los documentos:

assertSame

Reporta un error identificado por $messagesi las dos variables $expectedy $actualno tienen el mismo tipo y valor ".

Y como puede ver en el ejemplo debajo del extracto anterior, están pasando '2204'y 2204, que fallarán al usarlo assertSameporque uno es un stringy uno es un int,básicamente:

'2204' !== 2204
assertSame('2204', 2204) // this test fails

assertEquals

"Reporta un error identificado por $ message si las dos variables $ esperado y $ actual no son iguales".

assertEqualsno parece tener en cuenta el tipo de datos, por lo que se utiliza el ejemplo anterior de 2204:

'2204' == 2204
assertEquals('2204', 2204) // this test passes

Acabo de ejecutar algunas pruebas unitarias con los ejemplos anteriores y, de hecho, resultaron en un comportamiento documentado.

Cuando se trata de comparación de objetos:

assertSame: solo se puede afirmar si 2 objetos hacen referencia a la misma instancia de objeto. Entonces, incluso si 2 objetos separados tienen exactamente los mismos valores para todos sus atributos, assertSame fallará si no hacen referencia a la misma instancia.

    $expected = new \stdClass();
    $expected->foo = 'foo';
    $expected->bar = 'bar';

    $actual = new \stdClass();
    $actual->foo = 'foo';
    $actual->bar = 'bar';

    $this->assertSame($expected, $actual); FAILS

assertEquals: puede afirmar si 2 objetos separados coinciden con sus valores de atributo en cualquier caso. Entonces es el método adecuado para afirmar la coincidencia de objetos.

    $this->assertEquals($expected, $actual); PASSES

https://phpunit.de/manual/current/en/appendixes.assertions.html

$this->assertEquals(3, true);
$this->assertSame(3, true);

¡El primero pasará!

El segundo fallará.

Esa es la diferencia.

Creo que siempre deberías usar assertSame.

Como se ha dicho antes, AssertSameinforma un error si los dos elementos no comparten el tipo y el valor, pero también es importante tener en cuenta esto en la documentación :

Informa de un error identificado por $ message si las dos variables $ esperado y $ actual no hacen referencia al mismo objeto.

Entonces, esta prueba también fallaría aunque compartan el tipo y el valor:

class SameTest extends TestCase
{
    public function testFailure()
    {
        $this->assertSame(new stdClass, new stdClass);
    }
}

Además,

// Passes
$this->assertSame("123.", "123.");
$this->assertEquals("123.", "123");
// Fails
$this->assertSame("123.", "123");

asertSame () == Comprueba si la salida real y el parámetro esperado son iguales.

es decir :

$this->assertSame('$expected','$expected');

o

$this->assertSame('100','100');

assertEquals == Si vemos con respecto a la página de un sitio web, tengo una página que tiene 2 'tabla', por lo que cuando ejecuto assertEquals comprobaré su recuento de que la 'tabla' es 2 utilizando una función de recuento. P.ej:

$this->assertEquals(2, $var->filter('table')->count()); 

Aquí podemos ver que assertEquals comprueba que hay 2 tablas encontradas en la página web. también podemos usar divisiones que se encuentran en la página usando '#nombre de división' dentro del corchete.

Ej. 2:

public function testAdd()
{
    $calc = new Calculator();

    $result = $calc->add(30, 12);

    // assert that our calculator added the numbers correctly!
    $this->assertEquals(42, $result);
}

Como se mencionó anteriormente, se assertEquals()trata principalmente de un valor interpretado, ya sea por tipo de malabarismo o un objeto con un método de presentación __magic ( __toString()por ejemplo).

Un buen caso de uso para assertSame() es probar una fábrica de singleton.

class CacheFactoryTest extends TestCase
{
    public function testThatCacheFactoryReturnsSingletons()
    {
        $this->assertSame(CacheFactory::create(), CacheFactory::create());
    }
}