Comment tester deux structures de données js immuables imbriquées pour une égalité profonde?

Question

Dire que j'ai la structure de données immuable imbriquée suivante:

import { Record, List } from 'immutable' 

const foo = List([ 
     Record({ 
      id: 1, 
      gameState: Record({}) 
     }) 
     ]) 

Comment puis-je tester que deux structures de données immuables js imbriquées sont égaux entre eux?

test.js

import jest from 'jest' 
import { Record, List } from 'immutable' 

describe('test',() => { 
    it('that foo equals expected',() => { 
     const expected = List([ 
       Record({ 
       id: 1, 
       gameState: Record({}) 
       }) 
      ]) 
     expect(foo).toEqual(expected) 
    }) 

Answer 1

ImmutableJS collections supportent hashCode qui devrait donner un identifiant unique pour différentes structures de données et une autre identique pour les structures de données ayant le même contenu. Cela fonctionne récursivement dans les échantillons que j'ai regardés.

Answer 2

Pour la plupart des types ImmutableJS, le test que vous avez fonctionnerait correctement. Le problème est la façon dont vous utilisez les enregistrements. Contrairement à Map, List etc le constructeur Record(...) ne renvoie pas un nouvel objet, il renvoie un constructeur qui peut ensuite être utilisé pour créer de nouveaux objets. À partir des documents (https://facebook.github.io/immutable-js/docs/#/Record):

[Enregistrement] Crée une nouvelle classe qui produit des instances d'enregistrement. Un enregistrement est similaire à un objet JS, mais applique un ensemble spécifique de clés de chaîne autorisées et possède des valeurs par défaut.

Si vous voulez enregistrer d'utilisateur, vous pouvez écrire votre test comme celui-ci:

import { Record, List, is } from 'immutable' 

describe('test',() => { 
    it('that foo equals expected',() => { 
     const gameState = Record({}); 
     const gameRecord = Record({ 
      id: 1, 
      gameState: new gameState() 
     }); 

     const foo = List([ 
      new gameRecord() 
     ]); 

     const expected = List([ 
      new gameRecord() 
     ]); 
     expect(foo.equals(expected)).toBe(true); 
    }) 
}); 

Comparez cela à l'aide d'une carte au lieu d'un enregistrement. Le test ci-dessous utilisant la fonction toEqual de jest se déroule comme prévu:

import { Map, List, is } from 'immutable' 

describe('test',() => { 
    it('that foo equals expected',() => { 

     const foo = List([ 
      Map({ 
       id: 1, 
       gameState: Map({}) 
      }) 
     ]); 

     const expected = List([ 
      Map({ 
       id: 1, 
       gameState: Map({}) 
      }) 
     ]) 
     expect(foo).toEqual(expected); 
    }) 
});