Existe-t-il un matcheur jasmine permettant de comparer des objets sur des sous-ensembles de leurs propriétés ?

Question

J'ai un objet qui peut être étendu en fonction du comportement à tester, mais je veux m'assurer que les propriétés d'origine sont toujours présentes.

var example = {'foo':'bar', 'bar':'baz'}

var result = extendingPipeline(example)
// {'foo':'bar', 'bar':'baz', 'extension': Function}

expect(result).toEqual(example) //fails miserably

J'aimerais avoir un matcheur qui passerait dans ce cas, à peu près comme suit :

expect(result).toInclude(example)

Je sais que je peux écrire un sélecteur personnalisé, mais il me semble que ce problème est tellement courant qu'il devrait déjà exister une solution. Où dois-je la chercher ?

Answer 1

Jasmin 2.0

expect(result).toEqual(jasmine.objectContaining(example))

Depuis cette correction : https://github.com/pivotal/jasmine/commit/47884032ad255e8e15144dcd3545c3267795dee0 cela fonctionne même sur des objets imbriqués, il suffit d'envelopper chaque objet que vous voulez faire correspondre partiellement dans jasmine.objectContaining()

Un exemple simple :

it('can match nested partial objects', function ()
{
    var joc = jasmine.objectContaining;
    expect({ 
        a: {x: 1, y: 2}, 
        b: 'hi' 
    }).toEqual(joc({
        a: joc({ x: 1})
    }));
});

Answer 2

J'ai eu le même problème. Je viens d'essayer ce code, il fonctionne pour moi :

expect(Object.keys(myObject)).toContain('myKey');

Answer 3

Je ne pense pas que ce soit si commun et je ne pense pas que vous puissiez en trouver un. Il suffit d'en écrire un :

beforeEach(function () {
    this.addMatchers({
        toInclude: function (expected) {
            var failed;

            for (var i in expected) {
                if (expected.hasOwnProperty(i) && !this.actual.hasOwnProperty(i)) {
                    failed = [i, expected[i]];
                    break;
                }
            }

            if (undefined !== failed) {
                this.message = function() {
                    return 'Failed asserting that array includes element "'
                        + failed[0] + ' => ' + failed[1] + '"';
                };
                return false;
            }

            return true;
        }
    });
});

Answer 4

J'ai pensé que je proposerais une alternative en utilisant une carte moderne en javascript et un opérateur de repos. Nous sommes capables d'omettre des propriétés en utilisant la déstructuration avec l'opérateur rest. Voir la description détaillée dans cet article .

var example = {'foo':'bar', 'bar':'baz'}

var { extension, ...rest } = extendingPipeline(example)

expect(rest).toEqual(example)

Answer 5

jasmine.objectContaining() ne fonctionne que pour une seule couche.

expect(result).toMatchObject(example) vérifie que l'exemple d'objet qui est transmis correspond à un sous-ensemble de propriétés du résultat.