mutations d'essai avec DeepFreeze pour Redux objets

Question

J'ai simple Réducteur

const uid =() => Math.random().toString(34).slice(2); 
const bots = (state = [] , action) => { 

    switch(action.type) {  
     case 'ADD_BOT': 

      return [ 
       ...state, { 
        id: uid(), 
        isDone: false, 
        text: action.bots.text 
       } 
      ] 

      //this will fail 
    case 'ADD_BOT_THAT_MUTATES': 
      console.log("mutating"); 
      action.bots.id = uid(); 
      state.push(action.bots); 
      return state; 

     default: 
     return state; 
    } 
} 
export default bots 

Et mon fichier de spécification est

import deepFreeze from 'deep-freeze'; 
import bots from '../bots'; 

describe('Simple test',() => { 

function addBot(text) { 
    return { 
    type: 'ADD_BOT', 
    bots: { 
     id: 1, 
     isDone: false, 
     text: text 
    } 
    }; 
} 

function addBotThatMutates(text) { 
    return { 
    type: 'ADD_BOT_THAT_MUTATES', 
    bots: { 
     id: 1, 
     isDone: false, 
     text: text 
    } 
    }; 
} 

    let state = []; 
    deepFreeze(state); 

    beforeEach(() => { 

     state = bots(state, addBot("initial")); 

    }); 

    it('should fail due to deepFreeze',() => { 

     //create a payload 
     let payload = addBot("test 1234"); 
     let payloadThatMutates = addBotThatMutates("test 5678"); 

     state = bots(state, payload); 

     state = bots(state, payloadThatMutates); 

     expect(3).toEqual(state.length); 
    }); 
}); 

Quand j'appelle le réducteur avec state = bots(state, payload); j'attendre pour retourner un tableau non mutées car j'utilise une instruction de propagation ES6 dans le réducteur.

Lorsque j'appelais state = bots(state, payloadThatMutates); Je m'attendais à une erreur signalée par deepFreeze. C'est parce que dans les Reducers j'utilise state.push(action.bots); qui, je crois, va muter.

Mais je ne reçois aucune erreur et mon état resultant est un tableau de 3 objets.

Est-ce que j'ai un Reducers incorrect ou n'ai-je pas compris deepFreeze?

Ce test d'unité ne fonctionne pas comme prévu. Mais mon code App/Web fonctionne si j'appelle l'action 'ADD_BOT_THAT_MUTATES et que Reducer n'obtient aucun état mis à jour, c'est-à-dire que Redux mute l'état. Ou est-ce que je viens de faire quelque chose de complètement stupide?

Answer 1

Depuis l'affichage, j'ai réussi à obtenir ma tête autour Deepfreeze et mutations Voici mes deux tests qui donnent les résultats attendus

import deepFreeze from 'deep-freeze'; 
import bots from '../bots'; 

describe('Simple test',() => { 

function addBot(text) { 
    return { 
    type: 'ADD_BOT', 
    bots: { 
     id: 1, 
     isDone: false, 
     text: text 
    } 
    }; 
} 

function addBotThatMutates(text) { 
    return { 
    type: 'ADD_BOT_THAT_MUTATES', 
    bots: { 
     id: 1, 
     isDone: false, 
     text: text 
    } 
    }; 
} 

    let state; 

    beforeEach(() => {   
    state = [] 
     state = bots(state, addBot("initial")); 
    }); 

    it('should pass due to non-muting reducer ',() => { 
     //create a payload 
     let payload = addBot("test 1234"); 
     let state2 = bots(state, payload); 
     //state has non mutated and state2 is a new array 
     expect(state.length).toEqual(1); 
     expect(state2.length).toEqual(2); 
    }); 

    it('should fail due to deepFreeze',() => { 
      deepFreeze(state); 
      //create a payload 
      let payloadThatMutates = addBotThatMutates("test 5678"); 
      //deepFreeze will throw 'object is not extensible' because state is now mutating because of the push in the the reducer 
      let state2 = bots(state, payloadThatMutates);   
      expect(state).toEqual(state2); 
    }); 

}); 

Hope this helps quelqu'un