Comment atteindre assertDictEqual avec assertSequenceEqual appliquée à des valeurs

Je sais que, lors de l'exécution de assertEqual sur un dictionnaire, assertDictEqual est appelé. De même, assertEqual sur une séquence d'effectuer assertSequenceEqual.

Toutefois, lorsque assertDictEqual est de comparer les valeurs, il semble ne pas faire usage de assertEqual, et donc assertSequenceEqual n'est pas appelé.

Envisager de simples dictionnaires:

lst1 = [1, 2]
lst2 = [2, 1]

d1 = {'key': lst1}
d2 = {'key': lst2}

self.assertEqual(lst1, lst2) # True
self.assertEqual(d1, d2) # False ><

Comment puis-je tester les dictionnaires tels que d1 et d2 tels que l'égalité est bien comparé, en appliquant récursivement assertEqual-comme la sémantique des valeurs?

Je veux éviter d'utiliser des modules externes (comme l'a suggéré dans cette question) si possible, sauf si elles sont natives de django extensions.

MODIFIER

Essentiellement, ce que je suis après est intégré dans la version de ce:

def assertDictEqualUnorderedValues(self, d1, d2):
    for k,v1 in d1.iteritems():
        if k not in d2:
            self.fail('Key %s missing in %s'%(k, d2))

        v2 = d2[k]

        if isinstance(v1, Collections.iterable) and not isinstance(v1, basestring):
            self.assertValuesEqual(v1, v2)
        else:
            self.assertEqual(v1, v2)

Le problème avec le code ci-dessus est que les messages d'erreur ne sont pas aussi beau que l'builtin affirme, et il y a probablement des cas limites, j'ai ignoré (comme je l'ai juste écrit que sur le dessus de ma tête).

Avec le unittest module, self.assertEqual(lst1, lst2) n'est pas Vrai --> AssertionError: Lists differ: [1, 2] != [2, 1].
mon erreur, j'ai mal lu la partie de la documentation. Je suis à la recherche d'un équivalent de assertItemsEqual plutôt que assertSequenceEqual
Eh bien, si vous faites lst1 et lst2 même si la première assertEqual réussit, puis le second, trop.
La partie sur "la recherche d'un équivalent de assertItemsEqual plutôt que assertSequenceEqual" n'a pas de sens pour moi. Mon point était que le code dans votre question à l'aide de assertEqual sur deux listes avec des éléments dans un ordre différent et que l'assertion échoue.
Si vous contrôlez le code créant les structures de données, peut-être que vous devriez utiliser jeux au lieu de les listes.

InformationsquelleAutor sapi | 2013-08-27

Lieu de les ignorer assertDictEqual, pourquoi ne pas vous récursive trier vos dicts premier?

def deep_sort(obj):
    """
    Recursively sort list or dict nested lists
    """

    if isinstance(obj, dict):
        _sorted = {}
        for key in sorted(obj):
            _sorted[key] = deep_sort(obj[key])

    elif isinstance(obj, list):
        new_list = []
        for val in obj:
            new_list.append(deep_sort(val))
        _sorted = sorted(new_list)

    else:
        _sorted = obj

    return _sorted

Puis trier, et à l'utilisation normale assertDictEqual:

    dict1 = deep_sort(dict1)
    dict2 = deep_sort(dict2)

    self.assertDictEqual(dict1, dict2)

Cette approche a l'avantage de ne pas se soucier de combien de niveaux de profondeur vos listes sont.

Exception: '<' not supported between instances of 'dict' and 'dict'

InformationsquelleAutor Chris Villa

4

La TestCase.assertEqual() les appels de méthode de la classe' assertDictEqual() pour dicts, il suffit donc de remplacer dans votre sous-classe de dérivation. Si vous n'utilisez que les autres assertXXX méthodes dans la méthode, les messages d'erreur devrait être presque aussi beau que le haut-affirme -- mais si vous pouvez fournir un msg argument mot-clé quand vous les appelez pour contrôler ce qui est affiché.
```
import collections
import unittest

class TestSOquestion(unittest.TestCase):

    def setUp(self):
        pass # whatever...

    def assertDictEqual(self, d1, d2, msg=None): # assertEqual uses for dicts
        for k,v1 in d1.iteritems():
            self.assertIn(k, d2, msg)
            v2 = d2[k]
            if(isinstance(v1, collections.Iterable) and
               not isinstance(v1, basestring)):
                self.assertItemsEqual(v1, v2, msg)
            else:
                self.assertEqual(v1, v2, msg)
        return True

    def test_stuff(self):
        lst1 = [1, 2]
        lst2 = [2, 1]

        d1 = {'key': lst1}
        d2 = {'key': lst2}

        self.assertItemsEqual(lst1, lst2) # True
        self.assertEqual(d1, d2) # True

if __name__ == '__main__':
    unittest.main()
```
De sortie:
```
> python unittest_test.py
.
---------------------------------------------------------------------->
Ran 1 test in 0.000s

OK

>
```
- Je ne peux pas garantir l'ordre des listes. Les tests sont pour un framework django, et je ne peux pas compter sur l'ordre des requêtes de base de données étant le même entre le test et le résultat attendu. Tout ce qui m'intéresse c'est que l'API est de me donner les bonnes valeurs dans certains commander.
- OK, mais je ne comprends toujours pas pourquoi/comment vous vous y attendez le premier assertEqual(lst1, lst2) être Vrai dans votre code.
- Cette solution ne fonctionne pas sur profondément imbriqués dicts + listes. La solution basée sur le tri n'.
InformationsquelleAutor martineau
1

J'ai eu le même problème, j'ai eu à tester si les champs d'un modèle où les corriger. Et Monmodèle._meta.get_all_field_names() retourne parfois ['a','b'] et, parfois, ['b','a'].

Quand je le lance:
```
self.assertEqual(MyModel._meta.get_all_field_names(), ['a', 'b'])
```
il échoue parfois.

Je l'ai résolu en mettant les deux valeurs dans un ensemble():
```
self.assertEqual(set(MyModel._meta.get_all_field_names()), set(['a', 'b'])) #true

self.assertEqual(set(MyModel._meta.get_all_field_names()), set(['b', 'a'])) #true
```
Cela ne fonctionnera pas (renvoie true (Vrai) avec:
```
self.assertEqual(set(['a','a','b','a']), set(['a','b']))  # Also true 
```
Mais depuis que je suis vérification pour les noms de champs d'un modèle , et ceux-ci sont uniques, ce qui est bon en moi.
- Vous pouvez utiliser jeu de notation pour améliorer cette situation, au lieu de set(['a','b']) essayer {'a','b'}. Aussi, il y a une fonction self.assertSetEqual({'a','a','b','a'}, {'a','b'}) qui permettra de vérifier la différence entre les deux groupes et l'échec si elles ne contiennent pas exactement les mêmes éléments.
InformationsquelleAutor Robin van Leeuwen

Vous devez vous connecter pour publier un commentaire.