Verificare registrazione e ricerca strumenti

Questa lezione appartiene al Modulo 23 — Verifica finale prima della consegna.

Prima di consegnare il progetto, devi verificare manualmente che le due operazioni fondamentali del Registro funzionino correttamente in tutti gli scenari: registrare uno strumento nuovo e cercarlo in seguito per nome, categoria o stato. Questa verifica non sostituisce i test automatici, ma li integra — copre l’interazione reale dell’utente con la UI.

Obiettivo della lezione

In questa lezione esegui una verifica manuale sistematica della registrazione degli strumenti e della ricerca, usando scenari concreti e una checklist con esiti attesi. Documenti i difetti trovati e li correggi prima della presentazione.

Alla fine devi avere un risultato verificabile: la checklist completata con tutti i checkbox spuntati, o i difetti trovati documentati e risolti.

Scenari da testare

La verifica manuale copre due funzionalità principali divise in scenari:

Registrazione di uno strumento:

Scenario R1 — Registrazione corretta
  Input: nome "Trapano Bosch", categoria "elettrico"
  Atteso: lo strumento appare nella lista con stato "disponibile"

Scenario R2 — Nome mancante
  Input: nome vuoto, categoria "manuale"
  Atteso: messaggio di errore "Il nome è obbligatorio", nessuno strumento salvato

Scenario R3 — Categoria mancante
  Input: nome "Martello", categoria non selezionata
  Atteso: messaggio di errore o stato predefinito (dipende dalla tua implementazione)

Scenario R4 — Strumento duplicato (stesso nome)
  Input: nome "Trapano Bosch" (già registrato)
  Atteso: comportamento definito — errore o secondo strumento con stesso nome

Ricerca di uno strumento:

Scenario S1 — Ricerca per nome (corrispondenza esatta)
  Input: digita "Trapano" nel campo di ricerca
  Atteso: lista filtra e mostra solo gli strumenti con "Trapano" nel nome

Scenario S2 — Ricerca per nome (maiuscole/minuscole)
  Input: digita "trapano" (minuscolo)
  Atteso: la ricerca è case-insensitive, mostra gli stessi risultati

Scenario S3 — Ricerca per categoria
  Input: seleziona categoria "elettrico" dal filtro
  Atteso: solo gli strumenti elettrici appaiono nella lista

Scenario S4 — Ricerca per stato
  Input: seleziona stato "disponibile" dal filtro
  Atteso: solo gli strumenti disponibili appaiono nella lista

Scenario S5 — Nessun risultato
  Input: digita "XYZ" nel campo di ricerca
  Atteso: messaggio "Nessuno strumento trovato" invece di lista vuota silenziosa

Scenario S6 — Cancellazione filtro
  Input: cancella il testo dal campo di ricerca
  Atteso: tutti gli strumenti riappaiono

Procedura guidata

1. Apri il Registro nel browser, apri anche DevTools → Application → Local Storage.
2. Svuota localStorage per partire da zero: localStorage.clear() nella console, poi ricarica.
3. Esegui lo scenario R1: registra “Trapano Bosch”. Verifica la lista e il JSON in localStorage.
4. Esegui lo scenario R2: prova a registrare con nome vuoto. Verifica il messaggio di errore.
5. Esegui gli scenari da S1 a S6 con gli strumenti già registrati.
6. Per ogni scenario, spunta il checkbox se il comportamento corrisponde all’atteso, oppure scrivi il difetto trovato.
7. Correggi i difetti trovati prima di chiudere la lezione.

Attività in classe

Usa questa scheda come foglio di verifica:

## Verifica manuale — Registrazione e ricerca strumenti

Data: _______________
Browser usato: _______________

REGISTRAZIONE
[ ] R1 — Registrazione corretta: strumento appare nella lista
[ ] R2 — Nome vuoto: messaggio di errore visibile
[ ] R3 — Categoria: comportamento documentato e coerente
[ ] R4 — Duplicati: comportamento documentato e coerente

RICERCA
[ ] S1 — Ricerca per nome (parziale): filtro funziona
[ ] S2 — Case-insensitive: "trapano" trova "Trapano"
[ ] S3 — Filtro per categoria: mostra solo categoria selezionata
[ ] S4 — Filtro per stato: mostra solo stato selezionato
[ ] S5 — Nessun risultato: messaggio "Nessuno strumento trovato"
[ ] S6 — Cancellazione filtro: lista completa ripristinata

Difetti trovati:
1. _______________
2. _______________

Difetti corretti:
1. _______________
2. _______________

Se lavori in gruppo, una persona esegue gli scenari e un’altra compila la scheda.

Spiegazione guidata per studiare

La verifica manuale prima della consegna non è un controllo casuale. È una procedura sistematica che copre ogni scenario che un utente reale potrebbe affrontare.

I difetti più comuni nella registrazione sono due: il nome vuoto che passa la validazione (la regola è nel dominio ma la UI non la fa rispettare) e il messaggio di errore che appare ma poi non scompare, lasciando l’utente confuso.

I difetti più comuni nella ricerca sono: la ricerca case-sensitive che non trova “Trapano” quando l’utente scrive “trapano”, e il filtro per stato che non si aggiorna quando viene aggiunto un nuovo strumento.

Quando esegui la verifica, non saltare gli scenari che sembrano ovvi. Lo scenario S2 (maiuscole/minuscole) sembra banale ma è uno degli errori più frequenti. Lo scenario S5 (nessun risultato) è spesso trascurato: una lista vuota silenziosa fa credere all’utente che il Registro sia vuoto, non che la ricerca non abbia trovato nulla.

Il punto di questa verifica non è solo trovare difetti. È anche documentare il comportamento attuale del sistema in modo che tu possa descriverlo durante la presentazione senza incertezze.

Passo per passo nel progetto

1. Apri presentation/formRegistraStrumento.js e verifica che la validazione del nome vuoto sia presente.
2. Apri application/cercaStrumenti.js e verifica che la ricerca per nome sia case-insensitive.
3. Apri il browser e svuota localStorage.
4. Registra almeno tre strumenti di categorie diverse con stati diversi.
5. Esegui ogni scenario di ricerca e documenta il risultato.
6. Se trovi un difetto, apri il file responsabile e correggi prima di continuare.
7. Al termine, salva la scheda compilata come documento di consegna.

Esempio da leggere lentamente

Questo è il codice che gestisce la ricerca nel Registro. Verificalo durante la revisione:

// application/cercaStrumenti.js
function cercaStrumenti(archivio, filtri = {}) {
  let risultati = archivio.tutti();

  if (filtri.nome) {
    const nomeLower = filtri.nome.toLowerCase(); // case-insensitive
    risultati = risultati.filter(s =>
      s.nome.toLowerCase().includes(nomeLower)
    );
  }

  if (filtri.categoria) {
    risultati = risultati.filter(s => s.categoria === filtri.categoria);
  }

  if (filtri.stato) {
    risultati = risultati.filter(s => s.stato === filtri.stato);
  }

  return risultati; // array vuoto se nessuno corrisponde, non null
}

// presentation/ricercaStrumenti.js
function onCambioFiltro() {
  const nome = document.getElementById('filtro-nome').value;
  const categoria = document.getElementById('filtro-categoria').value;
  const stato = document.getElementById('filtro-stato').value;

  const risultati = cercaStrumenti(archivioStrumentiLocale, { nome, categoria, stato });
  renderLista(risultati); // renderLista gestisce il caso array vuoto con lo stato vuoto
}

Verifica: la funzione usa .toLowerCase() per entrambi? Restituisce un array vuoto e non null? La UI gestisce l’array vuoto con il messaggio “Nessuno strumento trovato”?

Prova di comprensione

Prima di chiudere la lezione, rispondi per iscritto a queste domande:

• Se la ricerca per nome è case-sensitive, in quale file devi aggiungere .toLowerCase()?
• Cosa vede l’utente se nessuno strumento corrisponde al filtro nel tuo Registro attuale?
• Come verifichi che la registrazione non salva lo strumento quando il nome è vuoto?
• Quali strumenti di test usi durante la verifica manuale (DevTools, console, etc.)?

Una risposta accettabile usa i nomi reali dei file e degli scenari verificati.

Errori da evitare

• saltare gli scenari che sembrano ovvi — i difetti più frequenti sono in quelli;
• non svuotare localStorage prima di iniziare la verifica — i dati residui alterano i risultati;
• non documentare il comportamento attuale dei casi ambigui (duplicati, categoria mancante);
• non verificare cosa appare in DevTools mentre si registra — il JSON è la prova della correttezza;
• considerare “funziona nel caso principale” come sufficiente per la consegna.

Prodotto da consegnare

Consegna la scheda di verifica compilata con:

• tutti i checkbox R1-R4 e S1-S6 spuntati;
• eventuali difetti trovati e la correzione applicata;
• il comportamento documentato per i casi ambigui (duplicati, categoria mancante).

Checklist di chiusura

Prima di chiudere la lezione, controlla:

• localStorage è stato svuotato prima di iniziare la verifica;
• almeno tre strumenti di categorie diverse sono stati registrati;
• la ricerca per nome è case-insensitive;
• la ricerca senza risultati mostra un messaggio esplicito;
• tutti gli scenari R1-R4 e S1-S6 sono stati eseguiti.

Risultato atteso

Alla fine lo studente deve saper dire:

Ho verificato manualmente registrazione e ricerca nel Registro prima della consegna.
Registrazione: nome vuoto mostra errore, strumento appare nella lista con stato disponibile.
Ricerca: la ricerca per nome è case-insensitive, i filtri per categoria e stato funzionano.
La ricerca senza risultati mostra il messaggio apposito invece di una lista vuota silenziosa.
I difetti trovati erano questi: [elenco] e sono stati corretti così: [elenco].

Se questa spiegazione non è possibile, la lezione non è ancora davvero conclusa.