Una delle domande più frequenti che gli sviluppati del framework Vue.js si pongono è: “Ma esattamente, cosa dovrei testare?”. Nello sviluppo di un’applicazione in produzione, questa è forse la domanda più frequente e che ad oggi non ha ancora ricevuto una risposta definitiva. Mentre è possibile testare troppo o troppo poco, la nostra osservazione è che gli sviluppatori molto spesso sbagliano a testare qualsiasi componente della loro applicazione, perdendo tempo e risorse utili da impiegare in altri ambiti. In questo articolo vogliamo condividere con voi alcune linee guida che utilizziamo nei nostri test dei componenti, per fornire una copertura sufficiente ad evitare grossi bug e per non perdere troppo tempo nello scrivere test ripetitivi e molto spesso inutili. Sapere cosa testare è quasi più importante che essere un esperto nello scrivere i test stessi. Diamo ovviamente per scontato che il lettore abbia già una buona infarinatura su Jest e sul Vue Test Units, utilizzando questo ambiente di sviluppo di Vue.js.
Esempio componente
Prima di arrivare alle linee guida cerchiamo di familiarizzare con il seguente componente che testeremo. Si chiama dress.vue ed è un articolo all’interno di un app di un e-commerce.

Qui ci sono i componenti del codice. Come vedete ci sono tre dipendenze: Vuex ($store), Vue Router ($router) e Vue Auth ($auth).
dress.vue
<template>
<div>
<h2>{{ item.title }}</h2>
<button @click="addToCart">Add To Cart</button>
<img :src="item.image"/>
</div>
</template>
<script>
export default {
name: "Item",
props: [ "id" ],
computed: {
item () {
return this.$store.state.find(
item => item.id === this.id
);
}
},
methods: {
addToCart () {
if (this.$auth.check()) {
this.$store.commit("ADD_TO_CART", this.id);
} else {
this.$router.push({ name: "login" });
}
}
}
};
</script>
Specifiche per il setup del file
Qui invece troviamo le specifiche per il test. All’interno mostreremo
superficialmente i nostri componenti con Vue Test Utils, lo abbiamo importato
come component “dress” che stiamo testando. Abbiamo anche creato una funzione
che genererà un oggetto di configurazione irreversibile, risparmiando le
specifiche per i props e aggirando le tre dipendenze.
item.spec.js
import { shallowMount } from "@vue/test-utils";
import Item from "@/components/Item";
function createConfig (overrides) {
const id = 1;
const mocks = {
// Vue Auth
$auth: {
check: () => false
},
// Vue Router
$router: {
push: () => {}
},
// Vuex
$store: {
state: [ { id } ],
commit: () => {}
}
};
const propsData = { id };
return Object.assign({ mocks, propsData }, overrides);
}
describe("Item.vue", () => {
// Tests go here
});
Identifichiamo la logica di base
Quando ci si approccia ai test, la prima e più importante domanda da porsi di fronte ad un componente è: “Qual è la logica di base? Cosa deve fare il componente?”
Per Item.vue ecco la logica:
• Verrà visualizzato un articolo in base alla proprietà id ricevuto,
• Se l’utente è un ospite del sito, facendo click sul pulsante “Aggiungi al carrello” lo reindirizza alla pagina di accesso,
• Se l’utente ha già effettuato l’accesso, facendo click su “Add To Cart” si attiverà una mutazione Vuex ADD_TO_CART.
Input e Output
Il trucco quando testate un’unità di un componente è trattare tale componente come una scatola nera. La logica interna dei metodi, delle proprietà computazionali ecc, conta solo nella misura in cui influiscono sugli output.
La prossima cosa molto importante da fare è identificare input e output del componente, poiché queste saranno anche gli stessi del test.
Nel caso di Item.vue gli input sono:
•Stato da Vuex e VueAuth,
•Input dell’utente trammite click sul pulsante.
Gli output invece sono:
•Markup renderizzato,
•Dati inviati alla mutazione Vuex o il push Vue Router.
TEST 1: router chiamato quando l’ospite clicca sul pulsante
Una parte della logica descritta prima ci dice “Se l’utente è un ospite, facendo click sul pulsante “Add to cart”, viene reindirizzato alla pagina di accesso”. Proviamo a scriverlo come test.
Configureremo il test facendo un allestimento superficiale del componente, cliccando sul pulsante “Add to cart”.
test("router called when guest clicks button", () => {
const config = createConfig();
const wrapper = shallowMount(Item, config);
wrapper
.find("button")
.trigger("click");
// Assertion goes here
}
Non andare oltre i limiti di input e output
In questo primo test potresti essere tentato di verificare che il percorso sia
cambiato rispetto alla pagina di accesso dopo aver fatto click sul pulsante, ad
esempio.
import router from "router";
test("router called when guest clicks button", () => {
...
// Wrong
const route = router.find(route => route.name === "login");
expect(wrapper.vm.$route.path).toBe(route.path);
}
Mentre
questo test verifica implicitamente l’output del componente, fa anche
affidamento sul funzionamento del router, che non dovrebbe essere la nostra
preoccupazione principale.
E’ meglio testare direttamente l’output, ossia la chiamata router.push.
Il completamento dell’operazione da parte del router non rientra però
nell’ambito specifico di questo test.
Spiamo (con spy) il metodo push del router e possiamo dire che viene
chiamato come oggetto route di accesso.
import router from "router";
test("router called when guest clicks button", () => {
...
jest.spyOn(config.mocks.$router, "push");
const route = router.find(route => route.name === "login");
expect(spy).toHaveBeenCalledWith(route);
}
TEST 2: Vuex chiamato quando utente Auth clicca il pulsante
Dopo aver completato il primo test ci approciamo alla logica del “Se l’utente ha effettuato l’accesso, facendo click sul pulsante “Add to cart” si attiverà una mutazione Vuex “ADD_TO_CART”.
Come nel caso precedente non è necessario verificare se lo stato di Vuex viene modificato: avremo, infatti, un test separato per l’archivio Vuex per verificarlo. Il compito di questo componente è semplicemente quello di effettuare il commit. Quindi, per prima cosa sostituiamo $auth.check in modo che ritorni true (come se un utente avesse effettuato l’accesso). Poi useremo il metodo spy di nuovo sul commit di store, e affermeremo che è stato chiamato dopo aver fatto click sul pulsante.
test("vuex called when auth user clicks button", () => {
const config = createConfig({
mocks: {
$auth: {
check: () => true
}
}
});
const spy = jest.spyOn(config.mocks.$store, "commit");
const wrapper = shallowMount(Item, config);
wrapper
.find("button")
.trigger("click");
expect(spy).toHaveBeenCalled();
}
Non testate le funzionalità delle altre librerie
Il componente Item visualizza i dati di un determinato articolo del negozio, in particolare il titolo e l’immagine ad esso associato. Forse dovremmo scrivere un test per controllarli in modo specifico? Per esempio:
test("renders correctly", () => {
const wrapper = shallowMount(Item, createConfig());
// Wrong
expect(wrapper.find("h2").text()).toBe(item.title);
}
Questo è un altro test non necessario in quanto sta solo testando la capacità di Vue di acquisire dati da Vuex e di interpolarli nel modello. La libreria Vue ha già dei test per questo meccanismo, quindi dovremmo fidarci del suo funzionamento senza ulteriori test.
TEST
3: rendering corretto
Ragioniamo per assurdo. Cosa succede se qualcuno rinomina accidentalmente il
titolo e poi dimentica di aggiornare l’interpolazione? Dovremmo testare anche
questo?
Si certo, ma se proviamo ogni aspetto del modello che stiamo creando, dove sono
i nostri limiti di testing?
Il modo migliore per testare il markup è usare un test snapshot per controllare
l’output del rendering complessivo. I test snapshot salvano il markup del
componente Vue e lo confrontano con quello nuovo generato ogni volta che viene
eseguito un test. Se qualcosa cambia lo sviluppatore viene avvisato e può
decidere se la modifica è stata intenzionale o accidentale. Questo coprirà non
solo l’interpolazione del titolo, ma anche l’immagine, il testo del pulsante,
eventuali classi e altro ancora.
test("renders correctly", () => {
const wrapper = shallowMount(Item, createConfig());
expect(wrapper).toMatchSnapshot();
});
Per
finire, ecco alcuni esempi di altre parti che non è necessario testare:
• Se la proprietà src è associata all’elemento img,
• Se i dati aggiunti all’archivio Vuex sono gli stessi che sono
interpolati,
• Se la proprietà calcolata ritorna l’oggetto giusto,
• Se il router push reindirizza alla pagina corretta.
Considerazioni finali
I tre test relativamente semplici che abbiamo appena fatto sono sufficienti per questo semplice componente. Una buona mentalità da avere quando si fa il testing dei componenti è quella di considerare un test non necessario fino a prova contraria. Ecco le principali domande che vi dovreste porre quando vi approciate al testing:
• Fa parte della logica del componente?
• Questo test verifica direttamente input e output del componente?
• Sto testando il mio codice o il codice di terze parti?
Ricordiamoci che i test sono una parte fondamentale di qualsiasi applicazione seria e in fase di produzione. All’inizio quando la vision non è chiara, lo Unit Test potrebbe rallentare lo sviluppo, ma una volta stabiliti gli utenti e i test necessari (e non ridondanti), questi sono assolutamente necessari per assicurarci che il codice di base sia mantenibile e scalabile nel tempo.
Inoltre i test sono molto utili durante lo sviluppo, sia per aiutare lo sviluppatore a pensare come progettare in maniera adeguata un componente, sia per fare il refactoring di un componente esistente, e spesso vengono eseguiti ogni volta che qualcosa viene modificato.
Buon testing a tutti!!
FONTE: https://medium.com/js-dojo/knowing-what-to-test-vue-component-unit-testing-f19b5880906a
