réducteur de base pouvant muter état de l'application

Question

J'utilise Redux spread operator pour, espérons-le, conserver l'état en tant qu'objets immuables. Cependant, je parviens à faire échouer le test unitaire le plus simple.

Je suppose que l'erreur est probablement liée à immutables, mais est-ce que je n'utilise pas correctement l'opérateur spread?

Voici mon unité test:

describe('app logic',() => { 
 
    it('initialises app',() => { 
 
    const newState = reducer(INITIAL_STATE, {type: "NEXT"}) 
 
    const expectState = { 
 
     start: true, 
 
     render_component: null, 
 
     requests: {}, 
 
     results: {}, 
 
    } 
 
    console.log('newState', newState) 
 
    console.log('expected state', expectState) 
 
    expect(newState).to.equal(expectState) 
 
    }) 
 
})

et voici mon réducteur

export const INITIAL_STATE = { 
 
    start: false, 
 
    render_component: null, 
 
    requests: {}, 
 
    results: {} 
 
} 
 

 
export const next = (state) => { 
 
    if (state === INITIAL_STATE) { 
 
    return { 
 
     ...state, 
 
     start: true, 
 
    } 
 
    } 
 
    return state 
 
} 
 

 
export function reducer(state = INITIAL_STATE, action) { 
 
    switch (action.type) { 
 
    case 'NEXT': 
 
     return next(state) 
 
    default: 
 
     return state 
 
    } 
 
}

j'imprimer les deux objets, et t Hé, regardez pareil. i obtenir l'erreur:

1) logique app initialise app:

AssertionError: expected { Object (start, render_component, ...) } to equal { Object (start, render_component, ...) } 

Answer 1

Je ne sais pas exactement quelle bibliothèque test que vous utilisez, mais généralement un nom comme .equal est utilisé pour tester stricte égalité (===), ce qui signifie (au moins dans le cas des objets) que les deux choses comparées doivent effectivement référencer exactement le même objet. Ainsi, par exemple,

const original = { a: 1 }; // creates a new object, assign it 
const testMe = { a: 1 }; // creates another new object, assign it 
console.log(original === testMe) // false 

devient fausse, car si les objets ont le même contenu , ils ne font pas référence exactement le même objet. Ce sont des objets séparés, créés indépendamment, qui ont le même contenu. Comparez cela à

const original = {a: 1}; // create a new object 
const testMe = original; // create another reference to the same object 
console.log(original === testMe); // true 

Alors, quand vous revenez

return { 
    ...state, 
    start: true, 
} 

vous créez et retourner un nouvel objet, donc naturellement peut pas référence le même objet que vous avez créé et attribué au nom de la variable expectedState. Si ce qui vous intéresse n'est pas l'égalité stricte, mais plutôt que le contenu des deux objets est le même, il existe d'autres méthodes que .equal, généralement nommé quelque chose avec deep (car ils vont profondément dans les objets/tableaux/quoi que ce soit pour vérifier si les valeurs sont les mêmes).

Chai.js a des exemples des deux expect(x).to.equal(y) et expect(x).to.deep.equal(y) dans leurs documents: http://chaijs.com/api/bdd/#method_equal

Votre bibliothèque test a probablement très similaire, sinon identique, syntaxe.