PHPUnit: affirmer que deux ensembles sont égaux, mais l'ordre des éléments n'est pas important

La façon la plus propre de le faire serait d'étendre phpunit avec une nouvelle affirmation de la méthode. Mais voici une idée pour un moyen plus simple pour l'instant. Code non testé, veuillez vérifier:

Quelque part dans votre application:

 /**
 * Determine if two associative arrays are similar
 *
 * Both arrays must have the same indexes with identical values
 * without respect to key ordering 
 * 
 * @param array $a
 * @param array $b
 * @return bool
 */
function arrays_are_similar($a, $b) {
  //if the indexes don't match, return immediately
  if (count(array_diff_assoc($a, $b))) {
    return false;
  }
  //we know that the indexes, but maybe not values, match.
  //compare the values between the two arrays
  foreach($a as $k => $v) {
    if ($v !== $b[$k]) {
      return false;
    }
  }
  //we have identical indexes, and no unequal values
  return true;
}

Dans votre test:

$this->assertTrue(arrays_are_similar($foo, $bar));

Mon problème est que j'ai 2 tableaux (array touches ne sont pas pertinentes pour moi, juste les valeurs).

Par exemple, j'ai voulu tester si

$expected = array("0" => "green", "2" => "red", "5" => "blue", "9" => "pink");

avait le même contenu (afin de ne pas pertinente pour moi) que

$actual = array("0" => "pink", "1" => "green", "3" => "yellow", "red", "blue");

J'ai donc utilisé array_diff.

Résultat Final a été (si les matrices sont égales, la différence de résultat dans un tableau vide). Veuillez noter que l'écart est calculé de deux façons (Merci @béret, @GordonM)

$this->assertEmpty(array_merge(array_diff($expected, $actual), array_diff($actual, $expected)));

---

Pour un message d'erreur plus détaillé (en cours de débogage), vous pouvez également tester comme cela (merci @DenilsonSá):

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

---

Ancienne version avec des bugs à l'intérieur:

$this->assertEmpty(array_diff($array2, $array1));

Simple méthode d'assistance

protected function assertEqualsArrays($expected, $actual, $message) {
    $this->assertTrue(count($expected) == count(array_intersect($expected, $actual)), $message);
}

Ou si vous avez besoin de plus d'informations de débogage lorsque les tableaux ne sont pas égaux

protected function assertEqualsArrays($expected, $actual, $message) {
    sort($expected);
    sort($actual);

    $this->assertEquals($expected, $actual, $message);
}

À l'aide de array_diff():

$a1 = array(1, 2, 3);
$a2 = array(3, 2, 1);

//error when arrays don't have the same elements (order doesn't matter):
$this->assertEquals(0, count(array_diff($a1, $a2)) + count(array_diff($a2, $a1)));

Ou avec 2 affirme (plus facile à lire):

//error when arrays don't have the same elements (order doesn't matter):
$this->assertEquals(0, count(array_diff($a1, $a2)));
$this->assertEquals(0, count(array_diff($a2, $a1)));

Si les touches sont les mêmes, mais de l'ordre de ce qui devrait résoudre cela.

Vous avez juste à obtenir les clés dans le même ordre et de comparer les résultats.

 /**
 * Assert Array structures are the same
 *
 * @param array       $expected Expected Array
 * @param array       $actual   Actual Array
 * @param string|null $msg      Message to output on failure
 *
 * @return bool
 */
public function assertArrayStructure($expected, $actual, $msg = '') {
    ksort($expected);
    ksort($actual);
    $this->assertSame($expected, $actual, $msg);
}

Les solutions proposées comme ne pas faire le travail pour moi parce que je voulais être capable de gérer un tableau multi-dimensionnel et d'avoir un message clair de ce qui est différent entre les deux tableaux.

Voici ma fonction

public function assertArrayEquals($array1, $array2, $rootPath = array())
{
    foreach ($array1 as $key => $value)
    {
        $this->assertArrayHasKey($key, $array2);

        if (isset($array2[$key]))
        {
            $keyPath = $rootPath;
            $keyPath[] = $key;

            if (is_array($value))
            {
                $this->assertArrayEquals($value, $array2[$key], $keyPath);
            }
            else
            {
                $this->assertEquals($value, $array2[$key], "Failed asserting that `".$array2[$key]."` matches expected `$value` for path `".implode(" > ", $keyPath)."`.");
            }
        }
    }
}

Puis de l'utiliser

$this->assertArrayEquals($array1, $array2, array("/"));

Si les valeurs sont juste des int ou des chaînes, et pas de multiples niveau des tableaux....

Pourquoi ne pas trier les tableaux, les convertir en chaîne...

    $mapping = implode(',', array_sort($myArray));

    $list = implode(',', array_sort($myExpectedArray));

... et puis comparer chaîne:

    $this->assertEquals($myExpectedArray, $myArray);

Une autre option, comme si vous ne l'avez pas déjà assez, est de combiner assertArraySubset combiné avec assertCount pour faire de votre affirmation. Donc, votre code devrait ressembler à quelque chose comme.


self::assertCount(EXPECTED_NUM_ELEMENT, $array);
self::assertArraySubset(SUBSET, $array);


De cette façon, vous sont indépendants, mais encore affirmer que tous vos éléments sont présents.