Manipolare gli eventi con Vue.js

In questo articolo parleremo di come manipolare gli eventi con Vue.js, da quelli nativi del framework, passando per quelli personalizzabili e infine parlando del bus degli eventi.
Ecco, in dettaglio, i contenuti che tratteremo:

  • Manipolare eventi con Vue
  • Tipi di eventi che si possono manipolare
  • Metodi per la gestione degli eventi
  • Oggetti Evento
  • Modificatori Eventi
  • Eventi personalizzati
  • Bus Eventi

Quando vuoi creare un sito web dinamico probabilmente vuoi che sia in grado di rispondere agli eventi. Esistono molti tipi di eventi in un sito, sia appartenenti al framework che personalizzabili a seconda degli obbiettivi. Un sito senza eventi non è altro un insieme di dati e scritte con cui l'utente non può interagire.

Ad esempio, se un utente fa un click su un pulsante, invia un modulo o sposta semplicemente il mouse, il sito dinamico che utilizza Vue dovrà rispondere in qualche maniera, facendo apparire un messaggio o inviando una richiesta a qualche componente.

Vediamo come si possono gestire questi eventi con Vue.js, il framework open-source di Javascript per la creazione dell'interfaccia utente e delle Single Page Applications.

Manipolare eventi con Vue

Possiamo catturare un evento soltanto aggiungendo la direttiva v-on al relativo elemento DOM con cui vogliamo interagire, seguito dall'evento che vogliamo catturare.
Supponiamo di voler gestire il click dell'utente su un pulsante: possiamo aggiungere la direttiva all'elemento e il nostro modello Vue diventerebbe:

<button v-on:click="clickHandler"></button>

Notiamo, quindi, che aggiungendo una direttiva all'argomento v-on, questo sarà il nome dell'evento che vogliamo gestire (nel nostro caso il click).

Associamo, ora, un'espressione alla direttiva, che sarà il nome del metodo che si desidera utilizzare per gestire l'evento. Come possiamo vedere sopra è stato chiamato "ClickHandler".

Suggerimento: la direttiva v-on ha una comoda scorciatoia "@" che può essere utilizzata al posto di v-on nel seguente modo:

<button @click = "clickHandler"></button>

Sono a tutti gli effetti dei "sinonimi" quindi potete usare quello che stilisticamente vi aggrada di più.

Tipi di eventi che si possono manipolare

Oltre al semplice click, quali altri eventi appartenenti al DOM possono essere gestiti con questo framework? Vue.js, facendo parte di Javascript, può gestire qualsiasi tipo di evento nativo Web o Mobile (nonchè eventi personalizzati di cui si parlerà più avanti) tra cui troviamo:

  • Submit,
  • Keyup,
  • Drag,
  • Scroll,
  • Reset,
  • Abort.

E molti altri. Qui potete trovare una lista completa degli eventi più comuni DOM. Una volta quindi identificato l'evento che ci serve e il componente che emetterà lo stesso, con v-on o @ possiamo collegarli in maniera molto sepmplice ed efficace.
Vediamo ora che metodi abbiamo a disposizione per la gestione degli eventi.

Metodi per la gestione degli eventi

Nella gestione degli eventi possiamo associare un metodo al nostro evento, creando così un codice personalizzato a seconda degli scopi del nostro sito.
Manteniamo semplice il nostro esempio per capire il funzionamento generale e registriamo un messaggio sulla console. Ovviamente potremmo fare qualcosa di più interessante come mostrare/nascondere un altro elemento, incrementare il contatore ecc ecc.

<div id="app">
  <button v-on:click="clickHanlder"></button>
</div>

new Vue({
  el: "#app",
  methods: {
    clickHandler () {
      console.log("You clicked the button!");
    }
  }
})

Come possiamo vedere una volta raccolto il segnale dell'evento avvenuto, il metodo all'interno del nostro elemento Vue farà apparire nella console la scritta "You clicked the button!".
Una altra cosa da notare è che mentre nell'elemento <button> clickHandler è il nome dell'evento, nell'elemento Vue è una funzione, e quindi viene rappresentato come clickHandler().

Oggetti evento

Possiamo anche passare alla funzione un'oggetto chiamato event. La funzione che abbiamo creato diventerà un'eventHandler, e ciò apre molte più possibilità su come rispondere allo stesso.
Questo oggetto contiene molte proprietà e metodi utili tra cui un riferimento all'elemento da cui ha avuto origine (event.target), l'ora in cui si è verificato (event.timeStamp) e altro.
Tutte queste proprietà possono essere viste nella console e sono davvero moltissime. Vediamo come si trasforma la nostra funzione.

clickHandler (event) {
  console.log(`The button was clicked at ${event.timeStamp}.`);
}

Notiamo che questo oggetto è fornito dall'API nativa, non da Vue, quindi è lo stesso oggetto che potremmo trovare in Javascript puro. Ecco il riferimento dell'interfaccia dell'evento per comodità.

Modificatori eventi

Una buona pratica comune nelle app Javascript è gestire manualmente l'invio di un modulo anzichè utilizzare la funzione nativa. Per fare ciò, è necessario utilizzare il metodo nativo preventDefault() dell'evento di invio prima di eseguire il codice di gestione dei moduli, altrimenti la pagina verrà reindirizzata prima che possa essere completata.
preventDefault() è un metodo dell'interfaccia event presentata prima, in sostanza dice che se l'evento non viene esplicitamente gestito, la sua azione predefinita non deve essere presa come "normale".

formHandler (event) {
  event.preventDefault();
  // form handling logic
}

Invece di farlo manualmente nel handler, Vue offre un modificatore di eventi per farlo direttamente dal modello.
La sintassi quindi prevede il richiamo all'evento (con v-on o @) e il modificatore successivamente. Si noti che il modificatore viene aggiunto dopo il " . " nella directory corrente:

<form @submit.prevent="formHandler"></form>

Vue offre diversi modifcatori di eventi utili negli scenari comuni di gestione degli stessi:

  • .stop
  • .prevent
  • .capture
  • .self
  • .once
  • .passive

Ora che conosciamo gli eventi e come possiamo gestirli utilizzando il paramentro nativo event e i modificatori, vediamo come poter creare degli eventi personalizzati.

Eventi personalizzati

Finora abbiamo parlato della gestione di eventi nativi. Ma Vue è un framework basato su componenti, quindi possiamo fare in modo che un componente emetta il proprio evento?

Ovviamente la risposta è sì, e questo può essere molto utile nell'ottica di un sito con funzioni particolari. Supponiamo che un componente figlio (child) invii i dati a un componente genitore (parent). Non possiamo usare oggetti props in questo caso, poichè i dati di questi oggetti vanno solo da genitore a figlio e non viceversa.
Come sappiamo i props sono delle speciali keyword che sono usate per passare dati da un componente all'altro, l'unico intoppo sta nel fatto che sono unidirezionali e readonly quindi per il nostro caso non vanno bene.

ParentComponent
|
| (data travels down via props, never up)
v
ChildComponent

La soluzione è avere un figlio che emette un event e allo stesso tempo avere un genitore che lo ascolta.
Facciamo un esempio per chiarire ogni dubbio. Abbiamo un componente genitore chiamato MainPage, e un componente figlio chiamato DialogComponent.
Quando il figlio viene chiuso, questo emetterà un evento ascoltato dal padre.
Per fare questo chiamiamo this.$emit("my-event") dal componente figlio quando vogliamo che l'evento venga emesso.

DialogComponent

export default {
  methods: {
    onClose() {
      this.$emit("dialog-closed");
    }
  }
};

Il componente genitore può poi gestire l'evento personalizzato esattamente nella stessa maniera con cui avrebbe gestito un evento nativo del linguaggio.

MainPage

<div>
  <dialog-component @dialog-closed="eventHandler" />
</div>

Possiamo anche inviare dati dell'oggetto event al nostro evento personalizzato, il quale può essere ricevuto nel metodo di handling.

DialogComponent

onClose() {
  this.$emit("dialog-closed", { time: Date.now() });
}

MainPage

eventHandler (event, { time }) {
  console.log(`Dialog was closed at ${time}`);
}

Suggerimento: usa i kebab-case per i nomi del tuo evento personalizzato! I kebab-case è una pratica di scrivere gli identificatori separando le parole che lo compongono con dei trattini. HTML non fa distinzione fra maiuscole e minuscole, quindi un nome evento di tipo camel-case, ad esempio myEvent, sarà confuso col myevent nell'esempio.
Come possiamo intuire, il camel-case è invece la pratica di scrivere gli identificatori distinguendoli l'uno dall'altro trammite lettera maiuscola. E' meglio, quindi, usare kebab-case ad esempio "my-event" ed evitare confuzione nella generazione del codice.

Bus eventi

Come abbiamo visto sopra, un componente figlio può inviare un evento ad un componente padre. Ma cosa succede se si desidera che un componente invii un evento a qualsiasi altro componente nella gerarchia? Ad esempio ad un fratello, ad un nonno e cosi via.

Per raggiungere questo obbiettivo possiamo usare un modello chiamato "bus degli eventi". Creiamo un'istanza separata di Vue per trasportare un evento a qualsiasi componente che lo importa.

Prima di tutto, creiamo ed esportiamo un'istanza di Vue in un nuovo file del modulo:

eventBus.js

import Vue from "vue";
export default new Vue();

Poi, importiamo il bus nel componente dove vorremmo emettere il nostro evento. Possiamo usare l'$emit metodo dell'istanza Vue che abbiamo già visto in precedenza e tra parentesi mettiamo il nome dell'evento emesso.

import eventBus from "./eventBus";export default {
  ...
  methods: {
    myMethod () {
      eventBus.$emit("my-event")
    }
  }
}

Infine, importiamo il bus di un componente in cui desideriamo ascoltare l'evento. Dovremmo, però, impostare un ascoltatore da qualche parte nel nostro codice. Utilizziamo, quindi, un hook del ciclo di vita come created, in quanto possiamo accedere all'istanza del componente in quel punto del codice.

Questo viene fatto con il metodo $on del bus che accetta due argomenti: il nome dell'evento che si desidera ascoltare e una funzione di callback (che nel nostro caso è una arrow-function).
Nel nostro esempio, come visto in precedenza, facciamo una semplice operazione di stampa nella console, ma voi potete sbizzarrirvi nella gestione di questi eventi facendo cose più interessanti.

import eventBus from "./eventBus";
export default {
  ...
  created () {
    eventBus.$on("my-event", () => {
      console.log("my-event called on global event bus");
    });
  }
}

Ed il gioco è fatto: un modo di condividere i dati tra tutti i componenti della tua app!

Per riassumere quindi:

  • se vogliamo inviare un evento dal padre al figlio possiamo utilizzare i props
  • se vogliamo inviare dal figlio al padre dobbiamo usare l'oggetto event e creare una connessione tra l'emit e l'ascoltatore (componente parent)
  • se vogliamo inviare il segnale in qualsiasi punto della gerarchia possiamo utilizzare il bus degli eventi e modificarlo a nostro piacimento.

Una soluzione più scalabile per il passaggio di dati in un'app consiste nell'utilizzare Vuex.

FONTE: Medium Anthony Gore


Array in Javascript: l'essenziale e qualcosa in più

Un array è un oggetto globale che può contenere diversi elementi al suo interno. Funziona anche come un elenco, uno stack o una coda (queue in inglese) in Javascript. All’interno possiamo trovare elementi dello stesso tipo o invece una combinazione di tipi non omogenei tra di loro.
Definiamo un array:

const arrayNazioni = [‘India’, ‘Germania’, ‘China’, ‘Giappone’];

Possiamo anche definire un array usando il costruttore:

const array = new Array(‘India’, ‘Germania’, ‘China’, ‘Giappone’);

I metodi essenziali
Esistono molti metodi negli array in Javascript. Vedremo i più importanti in questo articolo, osservando la sintassi e facendo un esempio per rendere l’utilizzo più chiaro.

•Map
La funzione “Map” è uno dei metodi disponibili sul tipo di un array in JS. Crea un nuovo array con i risultati delle chiamate di una funzione callback su ogni elemento dell’array chiamante.
La sintassi è:

array.map((valore, indice, array) => {…….});

Il ‘valore’ è il valore dell’elemento corrente, ‘indice’ è l’indice dell’array dell’elemento corrente e l’array è l’oggetto dell’array a cui appartiene l’elemento corrente.

Facciamo un esempio:

const array = [5,10,15,20];
//passiamo la funzione a map
const newArray = array.map(x=>x*10);
console.log(newArray); //[50,100,150,200]

Possiamo anche creare un nuovo array che contiene una proprietà singola dell’array, per esempio:

const prodotti = [
    {nome: ’Mobile’, prezzo: [800,1000]}
    {nome: ’Playstation’, prezzo: [300,400]}
    {nome: ‘Xbox’, prezzo: [350,425]}
]

const tuttiPrezzi = prodotti.map(prodotti => prodotti.prezzi);
console.log(tuttiPrezzi); //[[800,1000],[300,400], [350,425]]

Esiste un altro modo per iterare sugli oggetti di un array, ossia il metodo forEach().

array.forEach((number, i) => {
    newArray[i] = number *5;
});
console.log(newArray); //[5,10,20,25]

La differenza principale tra map() e forEach() è che map restituisce il valore tramite la funzione di callback. Nel caso di forEach, invce, non succede nulla col valore tornato dalla stessa funzione. Quindi è bene scegliere il metodo più adatto alle proprie esigenze.

•Reduce
Il metodo Reduce() esegue una funzione di ‘riduzione’
che forniamo su ciascun elemento dell’array, che si traduce quindi in un
singolo valore di output. La sintassi è la seguente:

arr.reduce(callback(accumulatore, valoreCorrente, indice, array), valoreIniziale)

La
funzione di callback (reducer) accetta due argomenti separati:
l’accumulatore, ossia il valore momentaneo corrente, e il valoreCorrente ossia
l’elemento analizzato in quel dato momento nel ciclo. Il valore restituito
viene utilizzato come accumulatore per l’elemento successivo nel ciclo.
Nel primo ciclo viene invece utilizzato il valoreIniziale fornito (facoltativo).
L’indice è ovviamente l’indice dell’array dell’elemento corrente, l’array
invece è l’oggetto dell’array a cui appartiene l’elemento che si vuole
analizzare Il valoreIniziale, indice e array sono tutti facoltativi, quindi a
seconda del contesto è bene utilizzarli o meno.

const array2 = [10,20,30,40];
const reducer = (accumulatore, valoreCorrente) => accumulatore + valoreCorrente;
console.log(array2.reduce(reducer)); //100

Proviamo ad usare la stessa logica con forEach() per capire la differenza:

let totale = 0;
array2.forEach(function(num) {
totale = totale + num;
});
console.log(total); //100

•Filter
A differenza di map(), il metodo filter() 
crea un nuovo array con tutti gli elementi che superano la condizione
implementata dalla funzione di callback, un vero e proprio “filtro”. La
sintassi è la seguente:

array.filter(callback, [thisObject]);

Esempio:

var numeri = [12,7,18,9,11,2,35];
const risultati = numeri.filter(numeri => numeri > 10);
console.log(risultati); //[12,18,11,35]

•Sort
Sort() viene utilizzato per ordinare gli elementi di un array. L’oggetto
fornito alla funzione muta, quindi stiamo modificando l’array originale.
La complessità temporale e spaziale dell’ordinamento non è costante nel tempo
in quanto dipende da come viene implementato il metodo.

Ecco un esempio:

let arraySort = [‘India’, ‘Germania’, ‘China’, ‘Giappone’];
console.log(‘sorted array: ‘, arraySort.sort()); // [‘China’, ’Germania’, ‘India’, ‘Giappone’]
//ordinati in ordine alfabetico

•Reverse
Reverse() è usato negli array per invertire l’ordine degli elementi. Anche in questo caso siamo di fronte ad un metodo che muta l’array.

Ecco un esempio:

let arraySort = [‘India’, ‘Germania’, ‘China’, ‘Giappone’];
console.log(‘reversed array: ‘, array.Sort.reverse()); // [‘Giappone’, ’China’, ’Germania’, ’India’]

Conclusioni

In questo breve articolo abbiamo trattato alcuni
importanti metodi degli array in Javascript, la loro sintassi e il loro
utilizzo. Gli array vanno utilizzati con cura perché sono strutture dati molto
performanti ma se utilizzate nella maniera errata possono portare ad enormi bug
nelle applicazioni. La scelta dei giusti metodi e di come implementarli è solo
il primo passo per trattare con un argomento così importante! Buona
programmazione a tutti!

FONTE: https://medium.com/swlh/the-essentials-of-javascript-arrays-68f39339038e


VUE.js: la componente di testing e cosa testare

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