Come testare i modali nei componenti React con Enzyme?

Ciao a tutti, colleghi sviluppatori di React! Se lavori con componenti React e hai a che fare con modali, sai quanto può essere complicato testarli correttamente. È qui che Enzyme torna molto utile. E indovina un po'? Sono un fornitore di Enzyme, quindi ho alcuni ottimi spunti da condividere con te su come testare i modali nei componenti React utilizzando Enzyme.

Prima di tutto, capiamo rapidamente cos'è l'Enzima. Enzyme è un'utilità di test JavaScript per React che semplifica l'asserzione, la manipolazione e l'analisi dell'output dei componenti React. Fornisce una serie di metodi utili per testare i componenti React in modo più intuitivo. Quando si tratta di modali in React, vogliamo assicurarci che si aprano e si chiudano correttamente, che il contenuto all'interno sia visualizzato come previsto e che qualsiasi interazione con la modale funzioni come previsto.

Impostazione del tuo progetto

Prima di iniziare a testare le modali, devi avere Enzyme configurato nel tuo progetto. Se non lo hai già fatto, puoi installarlo utilizzando npm o Yarn. Basta eseguire il seguente comando nel tuo terminale:

npm install --save-dev enzima enzima-adattatore-react-16

Questo installerà Enzyme e l'adattatore per React 16. Se stai utilizzando una versione diversa di React, assicurati di installare l'adattatore appropriato.

Una volta installato Enzyme, devi configurarlo nel file di installazione del test. Ecco un esempio di come puoi farlo:

importa l'enzima da 'enzima'; importa l'adattatore da 'enzyme-adapter-react-16'; Enzyme.configure({ adattatore: nuovo adattatore() });

Test della visibilità modale

Una delle prime cose che vogliamo testare quando si tratta di modali è la loro visibilità. Una modale dovrebbe aprirsi quando viene attivata un'azione specifica, come fare clic su un pulsante. Diciamo di avere un semplice componente React con un pulsante che apre una finestra modale:

importa React, { useState } da 'react'; const ModalComponent = () => { const [isModalOpen, setIsModalOpen] = useState(false); const openModal = () => { setIsModalOpen(true); }; return ( <div> <button onClick={openModal}>Apri modale</button> {isModalOpen && <div className="modal">Questa è una modale</div>} </div> ); }; esporta ModalComponent predefinito;

Per verificare se la finestra modale si apre quando si fa clic sul pulsante, possiamo utilizzare Enzyme'spoco profondometodo di rendering. Ecco il codice di prova:

importa React da 'react'; import { superficiale } da 'enzima'; importa ModalComponent da './ModalComponent'; description('ModalComponent', () => { it('dovrebbe aprire la finestra modale quando si fa clic sul pulsante', () => { const wrapper = superficiale(<ModalComponent />); const button = wrapper.find('button'); button.simulate('click'); wait(wrapper.find('.modal').exists()).toBe(true); }); });

In questo test, per prima cosa eseguiamo il rendering superficiale del fileComponente modale. Quindi troviamo il pulsante utilizzandowrapper.find('pulsante')e simulare un evento clic su di esso. Infine, controlliamo se l'elemento modale con la classecapitaleesiste nell'output del componente.

Test del contenuto modale

Una volta testata la visibilità della modale, potremmo voler testare anche il contenuto all'interno della modale. Ad esempio, se la modale mostra alcuni dati dinamici, vogliamo assicurarci che vengano visualizzati correttamente. Aggiorniamo il nostroComponente modaleper visualizzare alcuni dati dinamici:

importa React, { useState } da 'react'; const ModalComponent = () => { const [isModalOpen, setIsModalOpen] = useState(false); const [modalData, setModalData] = useState('Alcuni dati iniziali'); const openModal = () => { setIsModalOpen(true); }; return ( <div> <button onClick={openModal}>Apri Modal</button> {isModalOpen && <div className="modal">{modalData}</div>} </div> ); }; esporta ModalComponent predefinito;

Ora scriviamo un test per verificare se il contenuto modale è corretto:

Squalene Oil/ Squalene 1000mg Soft Capsules Cherry Juice Powder,cherry Extract Powder Supplier Wholesale

importa React da 'react'; import { superficiale } da 'enzima'; importa ModalComponent da './ModalComponent'; description('ModalComponent', () => { it('dovrebbe visualizzare il contenuto modale corretto', () => { const wrapper = superficiale(<ModalComponent />); const button = wrapper.find('button'); button.simulate('click'); wait(wrapper.find('.modal').text()).toBe('Alcuni dati iniziali'); }); });

In questo test, seguiamo un processo simile a quello precedente. Eseguiamo il rendering superficiale del componente, facciamo clic sul pulsante per aprire la finestra modale, quindi controlliamo se il testo all'interno della finestra modale è uguale ai dati previsti.

Test della chiusura modale

Proprio come testare l'apertura della modale, dobbiamo testare anche la sua funzionalità di chiusura. Aggiungiamo un pulsante di chiusura al nostroComponente modale:

importa React, { useState } da 'react'; const ModalComponent = () => { const [isModalOpen, setIsModalOpen] = useState(false); const [modalData, setModalData] = useState('Alcuni dati iniziali'); const openModal = () => { setIsModalOpen(true); }; const closeModal = () => { setIsModalOpen(false); }; return ( <div> <button onClick={openModal}>Apri modale</button> {isModalOpen && ( <div className="modal"> {modalData} <button onClick={closeModal}>Chiudi modale</button> </div> )} </div> ); }; esporta ModalComponent predefinito;

Ora scriviamo un test per verificare se la modale si chiude quando si fa clic sul pulsante di chiusura:

importa React da 'react'; import { superficiale } da 'enzima'; importa ModalComponent da './ModalComponent'; description('ModalComponent', () => { it('dovrebbe chiudere la finestra modale quando si fa clic sul pulsante di chiusura', () => { const wrapper = superficiale(<ModalComponent />); const openButton = wrapper.find('button').first(); openButton.simulate('click'); const closeButton = wrapper.find('.modal button'); closeButton.simulate('click'); aspetta(wrapper.find('.modal').exists()).toBe(false } });

In questo test, apriamo prima la modale facendo clic sul pulsante Apri. Quindi troviamo il pulsante di chiusura all'interno del modale e simuliamo un evento clic su di esso. Infine, controlliamo se l'elemento modale non esiste più nell'output del componente.

Test modali più complessi

A volte, i modali possono essere più complessi, con più stati e interazioni. Ad esempio, un modale potrebbe avere un modulo al suo interno e dobbiamo verificare se l'invio del modulo funziona correttamente. Aggiungiamo un modulo semplice al nostroComponente modale:

importa React, { useState } da 'react'; const ModalComponent = () => { const [isModalOpen, setIsModalOpen] = useState(false); const [modalData, setModalData] = useState('Alcuni dati iniziali'); const [formData, setFormData] = useState(''); const openModal = () => { setIsModalOpen(true); }; const closeModal = () => { setIsModalOpen(false); }; const handleSubmit = (e) => { e.preventDefault(); setModalData(formData); chiudiModale(); }; return ( <div> <button onClick={openModal}>Apri modale</button> {isModalOpen && ( <div className="modal"> <form onSubmit={handleSubmit}> <input type="text" value={formData} onChange={(e) => setFormData(e.target.value)} /> <button type="submit">Invia</button> </form> <button onClick={closeModal}>Chiudi modale</button> </div> )} </div> ); }; esporta ModalComponent predefinito;

Ora scriviamo un test per verificare se l'invio del modulo aggiorna i dati modali e chiude il modale:

importa React da 'react'; import { superficiale } da 'enzima'; importa ModalComponent da './ModalComponent'; description('ModalComponent', () => { it('dovrebbe aggiornare i dati modali e chiudere il modale all'invio del modulo', () => { const wrapper = superficiale(<ModalComponent />); const openButton = wrapper.find('button').first(); openButton.simulate('click'); const input = wrapper.find('input'); input.simulate('change', { target: { valore: 'Nuovo dati' } }); const form = wrapper.find('form'); form.simulate('submit', { preventDefault: () => {} });

In questo test, apriamo prima la finestra modale, quindi simuliamo un evento di modifica nel campo di input per aggiornare i dati del modulo. Successivamente, simuliamo un evento di invio del modulo e controlliamo se la modale è chiusa e i dati modali vengono aggiornati correttamente.

Conclusione

Testare le modali nei componenti React con Enzyme all'inizio può sembrare un po' scoraggiante, ma una volta capito, diventa un gioco da ragazzi. Seguendo i passaggi e gli esempi che ho condiviso qui, dovresti essere in grado di testare le tue modali in modo efficace e assicurarti che funzionino come previsto.

Se stai cercando prodotti Enzyme di alta qualità per le tue esigenze di test, non esitare a farlocontattaciper ulteriori informazioni Siamo qui per aiutarti a rendere il processo di test il più agevole possibile.

E se sei interessato ad altri prodotti, dai un'occhiata a questi link: