feat(db_prodotti): aggiunge scraper e viewer catalogo ALDI

Dataset a sé stante (non collegato a lib/): scraper Playwright per il
catalogo pubblico aldi.it (protetto da bot-detection Akamai) e viewer
HTML statico basato su sql.js per sfogliare il db nel browser.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

.gitignore

@@ -19,6 +19,13 @@ test/widget_test.dart
 /macos/
 /windows/
 /web/
+
+# db_prodotti — dataset generato dallo scraper, rigenerabile con scrape_aldi.py
+db_prodotti/*.db
+db_prodotti/*.json
+db_prodotti/*.log
+db_prodotti/__pycache__/
 /.idea/
 *.iml
 .metadata
+coverage/

CLAUDE.md

@@ -4,113 +4,95 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-BitePlan è un'app Android per meal planning, conversione crudo/cotto e lista della spesa, scritta in Flutter. Tutta la UI e la UX sono in **italiano**. L'obiettivo finale è un APK Android buildabile via Docker.
+BitePlan è un'app Android per meal planning, conversione crudo/cotto e lista della spesa, scritta in Flutter. Tutta la UI e la UX sono in **italiano**. Il rilascio avviene come APK Android buildato via Docker.
+
+## Ruolo atteso
+
+Quando viene richiesta una modifica o una nuova funzionalità, segui questo flusso:
+
+1. **Analizza prima di implementare**: valuta se la richiesta ha senso — fattibilità, complessità reale, impatto su architettura/UX/persistenza. Se esiste un modo migliore di implementarla, proponilo; se la richiesta è mal posta o ha un costo sproporzionato al beneficio, dillo esplicitamente con l'alternativa. Motiva i giudizi con riferimenti concreti al codice.
+2. **Implementa da esperto**: se la richiesta va bene (o dopo l'eventuale discussione), implementala seguendo le convenzioni del progetto (feature-first, Provider, tutto in italiano).
+3. **Suggerisci i test, non scriverli**: al termine indica quali test coprirebbero la modifica (casi e file dove andrebbero), ma implementali solo se richiesto esplicitamente.
 
 ## Comandi
 
 ```bash
-# Sviluppo (web server con hot reload)
-cd docker/dev && docker compose up
-# → http://localhost:5173
-# Con il container attivo: docker compose attach dev  →  r = hot reload
+# Sviluppo (host, no Docker)
+emulator -avd biteplan &          # AVD dedicato, Pixel 6 / Android 14 (google_apis x86_64)
+flutter run                       # hot reload con "r", hot restart con "R"
 
-# Test (dalla root del progetto — richiede immagine biteplan-build)
+# Analisi statica
+flutter analyze                   # lint: package:flutter_lints/flutter.yaml
+
+# Test rapidi (host)
+flutter test                                            # tutta la suite
+flutter test test/features/meal_planner/qr_test.dart    # singolo file
+
+# Test riproducibili (Docker, immagine biteplan-build — usati come riferimento)
 docker run --rm -v "$(pwd):/workspace" -w /workspace biteplan-build \
   bash -c "flutter pub get --enforce-lockfile && flutter test"
 
-# Test singolo file
-docker run --rm -v "$(pwd):/workspace" -w /workspace biteplan-build \
-  bash -c "flutter test test/features/meal_planner/qr_test.dart"
+# Integration test (richiede emulatore avviato)
+flutter test integration_test/app_test.dart
 
-# Build APK (headless, da host)
-bash docker/build/build.sh                        # debug  → dist/biteplan-debug.apk
-export BITEPLAN_KEYSTORE_PASS=password            # richiesto solo per --release
-bash docker/build/build.sh --release              # release → dist/biteplan-release.apk
+# Build APK (headless, via Docker)
+bash docker/build.sh                        # debug  → dist/biteplan-debug.apk
+export BITEPLAN_KEYSTORE_PASS=password      # richiesto solo per --release
+bash docker/build.sh --release              # release → dist/biteplan-release.apk
 ```
 
+## Sviluppo locale
+
+- **Flutter host**: installato in `~/flutter` (tag `3.41.9`, stessa versione pinnata nel Dockerfile), nel `PATH` via `~/.bashrc`. Docker non si usa più per il dev; resta per test di riferimento e build APK (isolamento, `--enforce-lockfile`, firma release).
+- **Emulatore**: Android SDK in `/home/davide/android-sdk`; accelerazione hardware via `/dev/kvm` (WSL2 con KVM abilitato).
+- **AVD `biteplan`**: dedicato a questo progetto (Pixel 6, Android 14, google_apis/x86_64). Non riutilizzare AVD di altri progetti (es. `palladium_wallet`).
+- **Permessi**: le build Docker girano come root nel volume montato — se `.dart_tool/` o `build/` risultano di proprietà root, serve `sudo chown -R davide:davide .dart_tool build` prima di usare flutter da host.
+- **Setup e uso dell'emulatore Android** (installazione SDK, creazione AVD, comandi `adb`, troubleshooting): [docs/emulatore.md](docs/emulatore.md).
+
 ## Build e firma
 
-- **Flutter pinnato**: versione `3.41.9` nei Dockerfile (`ARG FLUTTER_VERSION`); aggiornare anche `.flutter-version`
-- **Gradle cache**: named volume Docker `gradle-cache`, isolata dall'host
+- **Flutter pinnato**: versione `3.41.9` in `docker/Dockerfile` (`ARG FLUTTER_VERSION`); aggiornare anche `.flutter-version` e l'install host
 - **Dipendenze**: `pubspec.lock` committato; la build usa `--enforce-lockfile` e fallisce se il lock non è allineato
-- **Keystore**: `docker/biteplan.jks` è in `.gitignore`; da ottenere dall'autore o generare con `keytool`
-- **Firma release**: password passata via `BITEPLAN_KEYSTORE_PASS` (mai hardcoded); alias keystore: `biteplan`
+- **Keystore**: `docker/biteplan.jks` è in `.gitignore`; da ottenere dall'autore o generare con `keytool`. Password via `BITEPLAN_KEYSTORE_PASS` (mai hardcoded); alias: `biteplan`
 - **applicationId**: `com.davide.biteplan` — non cambiare, garantisce aggiornamento diretto dalla v1.2.1
 - **versionCode**: letto da `pubspec.yaml` (`version: X.Y.Z+BUILD`); BUILD deve essere sempre crescente
+- **kAppVersion**: `lib/core/constants/app_constants.dart` duplica la versione di `pubspec.yaml` a mano (nessuna sincronizzazione automatica) — aggiornarla ad ogni bump di versione, altrimenti l'update checker confronta contro il valore sbagliato
 
 ## Architettura
 
+Feature-first sotto `lib/features/` (meal_planner, converter, shopping_list, guide), ognuna con `models/`, `providers/`, `presentation/`. Codice trasversale in `lib/shared/` e `lib/core/`.
+
 ```
 lib/
-├── main.dart
-├── app.dart                          # MaterialApp, NavigationBar; initState chiama UpdateService.checkUpdate() e mostra showUpdateDialog() se c'è aggiornamento
-├── core/
-│   ├── constants/app_constants.dart  # kDayIds, kMealSlots, kStorageKey*, kAppVersion
-│   └── theme/app_theme.dart
+├── app.dart                          # MaterialApp + NavigationBar; in initState chiama UpdateService.checkUpdate() e mostra showUpdateDialog()
+├── core/constants/app_constants.dart # kDayIds, kMealSlots, kStorageKey*, kAppVersion
+├── core/theme/app_theme.dart          # ThemeData Material 3, seed color 0xFF2d6a4f
 ├── shared/
-│   ├── services/
-│   │   ├── storage_service.dart      # wrapper SharedPreferences (load/save)
-│   │   ├── update_service.dart       # checkUpdate() → GitHub API, isNewer(), parseTagName() (@visibleForTesting)
-│   │   └── url_launcher_service.dart # MethodChannel 'com.davide.biteplan/launcher' → Intent.ACTION_VIEW
-│   └── widgets/
-│       └── update_dialog.dart        # showUpdateDialog() — AlertDialog con "Più tardi" / "Scarica"
+│   ├── services/storage_service.dart      # wrapper SharedPreferences (load/save)
+│   ├── services/update_service.dart       # checkUpdate() → GitHub API; isNewer(), parseTagName() (@visibleForTesting)
+│   ├── services/url_launcher_service.dart # MethodChannel 'com.davide.biteplan/launcher' → Intent.ACTION_VIEW
+│   └── widgets/update_dialog.dart         # showUpdateDialog() — "Più tardi" / "Scarica"
 ├── features/
-│   ├── meal_planner/
-│   │   ├── models/meal_plan.dart         # MealPlan, DayPlan
-│   │   ├── providers/meal_planner_provider.dart
-│   │   ├── qr_codec.dart                 # buildQrPayload, parseMealPlanFromQr
-│   │   └── presentation/
-│   │       ├── pages/meal_planner_page.dart
-│   │       ├── pages/qr_scan_page.dart
-│   │       └── widgets/meal_card.dart, qr_share_sheet.dart
-│   ├── converter/
-│   │   ├── models/conversion_entry.dart  # rawToCooked, cookedToRaw (metodi sul model)
-│   │   ├── providers/converter_provider.dart
-│   │   └── presentation/pages/converter_page.dart
-│   ├── shopping_list/
-│   │   ├── models/shopping_item.dart     # quantity per aggregazione duplicati
-│   │   ├── providers/shopping_list_provider.dart
-│   │   └── presentation/
-│   │       ├── pages/shopping_list_page.dart
-│   │       └── widgets/shopping_item_tile.dart
-│   └── guide/
-│       └── presentation/
-│           ├── pages/guide_page.dart          # 3 tab: Pasti, Converti, Spesa
-│           └── widgets/info_bottom_sheet.dart # aperto dal bottone info in AppBar
-└── assets/data/conversions.json       # 50+ alimenti × metodi cottura
+│   ├── meal_planner/                 # MealPlan/DayPlan, qr_codec.dart (buildQrPayload, parseMealPlanFromQr), pagine planner + scan QR
+│   ├── converter/                    # ConversionEntry con rawToCooked/cookedToRaw, dati da assets/data/conversions.json
+│   ├── shopping_list/                # ShoppingItem con quantity per aggregazione duplicati
+│   └── guide/                        # guide_page (3 tab) + info_bottom_sheet
+└── assets/data/conversions.json      # 50+ alimenti × metodi cottura
 ```
 
-**State management**: Provider (`ChangeNotifier`).  
-**Persistenza**: `shared_preferences`, chiavi `meals` e `shopping_list` (JSON serializzato).  
-**Conversione**: logica in `ConversionEntry` — `rawToCooked = raw * yieldFactor`, `cookedToRaw = cooked / yieldFactor`.  
-**UI**: Material 3, seed color `Color(0xFF2d6a4f)`, tutto in italiano.  
-**QR**: payload JSON `{ "v": 1, "meals": { ... } }`, limite 2953 byte (capacità QR con error correction L).  
-**Update checker**: `UpdateService.checkUpdate()` usa `dart:io` `HttpClient` (nessun package aggiuntivo); disabilitato su web (`kIsWeb`). Il `MethodChannel` `com.davide.biteplan/launcher` è implementato in `android/app/src/main/kotlin/com/davide/biteplan/MainActivity.kt`.  
-**Widget test con MethodChannel**: usare `TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler` per mockare il canale nei test — vedi `test/shared/widgets/update_dialog_test.dart`.
+**State management**: Provider (`ChangeNotifier`), uno per feature, registrati in `main.dart` con `MultiProvider`.
+**Persistenza**: `shared_preferences`, chiavi `meals` e `shopping_list` (JSON serializzato).
+**Conversione**: logica in `ConversionEntry` — `rawToCooked = raw * yieldFactor`, `cookedToRaw = cooked / yieldFactor`.
+**UI**: Material 3, seed color `Color(0xFF2d6a4f)`, tutto in italiano.
+**QR**: payload JSON `{ "v": 1, "meals": { ... } }`, limite 2953 byte (capacità QR con error correction L).
+**Update checker**: `UpdateService.checkUpdate()` usa `dart:io` `HttpClient` (nessun package aggiuntivo); disabilitato su web (`kIsWeb`). Il `MethodChannel` `com.davide.biteplan/launcher` è implementato in `android/app/src/main/kotlin/com/davide/biteplan/MainActivity.kt`.
 
 ## Testing
 
-130 test (unit + widget). Non richiedono device fisico.
+184 test unit + widget in `test/` (rispecchia la struttura di `lib/`), più un integration test in `integration_test/app_test.dart`. I test unit/widget non richiedono device. Coverage ~93% su `lib/` (esclusi per scelta: `main.dart`, il percorso camera di `qr_scan_page`). Dettaglio di cosa è coperto/escluso e come lanciare la suite: [docs/testing.md](docs/testing.md).
 
-```
-test/
-├── helpers/pump_app.dart              # estensione pumpApp per widget test
-├── features/
-│   ├── converter/
-│   │   ├── models/conversion_entry_test.dart
-│   │   └── providers/converter_provider_test.dart
-│   ├── meal_planner/
-│   │   ├── models/meal_plan_test.dart
-│   │   ├── providers/meal_planner_provider_test.dart
-│   │   ├── widgets/meal_card_test.dart
-│   │   └── qr_test.dart
-│   └── shopping_list/
-│       ├── models/shopping_item_test.dart
-│       ├── providers/shopping_list_provider_test.dart
-│       └── widgets/shopping_item_tile_test.dart
-└── shared/
-    ├── services/update_service_test.dart
-    └── widgets/update_dialog_test.dart
-```
-
-I test usano `SharedPreferences.setMockInitialValues({})` per isolare lo storage.
+- Storage isolato con `SharedPreferences.setMockInitialValues({})`
+- Widget test: estensione `pumpApp` in `test/helpers/pump_app.dart`
+- MethodChannel nei test: `TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler` — vedi `test/shared/widgets/update_dialog_test.dart`
+- `test/coverage_helper_test.dart` importa tutta `lib/` così lcov include anche i file a coverage zero — aggiungere i nuovi file lì
+- **Non chiamare** `loadDb()`/`load()` dei provider dentro il body di `testWidgets`: l'async reale nella zona FakeAsync può bloccare la suite (timeout 10 min). Farlo nel `setUp` — vedi `test/features/converter/pages/converter_page_test.dart`

README.md

@@ -2,9 +2,29 @@
 
 App Android per la gestione della dieta quotidiana — pianificazione pasti, conversione crudo/cotto e lista della spesa.
 
-## Funzionalità
+> Un'unica app per pianificare la settimana, sapere quanto pesare crudo o cotto e non dimenticare cosa comprare.
 
-### Piano Pasti
+![License](https://img.shields.io/badge/license-EUPL--1.2-blue)
+![Flutter](https://img.shields.io/badge/flutter-3.41.9-02569B?logo=flutter)
+![Platform](https://img.shields.io/badge/platform-Android-3DDC84?logo=android)
+
+## Overview
+
+BitePlan nasce per unire in un'unica app tre attività che di solito richiedono strumenti
+separati: pianificare i pasti della settimana, convertire i pesi degli alimenti tra crudo e
+cotto (utile per chi segue una dieta con quantità espresse in una delle due forme), e tenere
+una lista della spesa sincronizzata con quanto pianificato.
+
+- **Problema risolto**: evitare di ricalcolare a mano le rese di cottura e di dimenticare
+  ingredienti quando si fa la spesa.
+- **Perché esiste**: progetto personale dell'autore, pensato per un uso quotidiano reale.
+- **Limiti noti**: i coefficienti di resa sono medie indicative (vedi
+  [docs/conversioni.md](docs/conversioni.md)); il piano pasti si condivide tra dispositivi
+  solo via QR code, senza account né sincronizzazione cloud; nessuna build iOS.
+
+## Features
+
+### Piano pasti
 - Pianificazione settimanale su 7 giorni × 3 pasti (colazione, pranzo, cena)
 - Card accordion per giorno, giorno corrente aperto di default
 - Aggiunta e rimozione di voci per ogni pasto
@@ -28,7 +48,32 @@ App Android per la gestione della dieta quotidiana — pianificazione pasti, con
 - All'avvio controlla silenziosamente l'ultima release su GitHub
 - Se disponibile una versione più recente, mostra un dialog con link diretto al download dell'APK
 
-## Stack
+## Architecture
+
+Feature-first sotto `lib/features/`, ognuna con modelli, provider (state management) e
+presentation; persistenza su `SharedPreferences`. Dettaglio del flusso dati per feature in
+[docs/architettura.md](docs/architettura.md).
+
+```text
+biteplan/
+├── lib/
+│   ├── app.dart               # MaterialApp + navigazione
+│   ├── core/                  # costanti, tema
+│   ├── shared/                # servizi e widget condivisi
+│   └── features/
+│       ├── meal_planner/
+│       ├── converter/
+│       ├── shopping_list/
+│       └── guide/
+├── assets/data/conversions.json
+├── android/                   # progetto nativo (MethodChannel in Kotlin)
+├── test/                      # unit + widget test
+├── integration_test/
+├── docs/                      # guida utente, architettura, fonti conversioni
+└── docker/                    # build APK headless, test riproducibili
+```
+
+## Requisiti e dipendenze
 
 | Livello | Tecnologia |
 |---|---|
@@ -38,81 +83,160 @@ App Android per la gestione della dieta quotidiana — pianificazione pasti, con
 | QR code | qr_flutter + mobile_scanner |
 | Build APK | Docker (headless) |
 
-## Sviluppo
+Requisiti host per lo sviluppo:
 
-Il container dev avvia un web server Flutter accessibile dal browser, con hot reload.
+- **Linux x86_64** (Ubuntu/Debian o simili; funziona anche su **WSL2** se il kernel espone `/dev/kvm`)
+- **KVM** per l'accelerazione hardware — senza, l'emulatore è inutilizzabile. Verifica con:
+  ```bash
+  ls /dev/kvm          # deve esistere
+  groups | grep kvm    # l'utente deve essere nel gruppo kvm
+  # se manca il gruppo: sudo usermod -aG kvm $USER  (poi rilogin)
+  ```
+- **Java 17+** (`sudo apt install openjdk-21-jdk`)
+- Strumenti di base: `git curl unzip` — e ~15 GB di spazio libero
+
+## Installazione
+
+**1. Flutter** (versione pinnata `3.41.9`, la stessa di `.flutter-version`):
 
 ```bash
-cd docker/dev
-docker compose up
-# → http://localhost:5173
+git clone --depth 1 --branch 3.41.9 https://github.com/flutter/flutter.git ~/flutter
+echo 'export PATH="$HOME/flutter/bin:$PATH"' >> ~/.bashrc && source ~/.bashrc
+flutter --version   # al primo avvio scarica il Dart SDK
 ```
 
-Con il container attivo, in un altro terminale:
+**2. Android SDK command-line tools:**
 
 ```bash
-docker compose attach dev
-# r → hot reload  |  R → hot restart  |  q → esci
+mkdir -p ~/android-sdk/cmdline-tools
+cd ~/android-sdk/cmdline-tools
+curl -O https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip
+unzip commandlinetools-linux-11076708_latest.zip && mv cmdline-tools latest
+rm commandlinetools-linux-11076708_latest.zip
+
+cat >> ~/.bashrc <<'EOF'
+export ANDROID_HOME="$HOME/android-sdk"
+export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH"
+EOF
+source ~/.bashrc
 ```
 
-Vedi [docker/README.md](docker/README.md) per i dettagli e la build APK.
+**3. Pacchetti SDK e licenze:**
+
+```bash
+sdkmanager "platform-tools" "emulator" \
+  "platforms;android-34" "build-tools;34.0.0" \
+  "system-images;android-34;google_apis;x86_64"
+yes | sdkmanager --licenses
+```
+
+**4. AVD dedicato al progetto** (Pixel 6, Android 14):
+
+```bash
+echo "no" | avdmanager create avd -n biteplan \
+  -k "system-images;android-34;google_apis;x86_64" -d pixel_6
+```
+
+**5. Verifica e primo avvio:**
+
+```bash
+flutter doctor        # "Android toolchain" deve risultare ✓
+emulator -avd biteplan &
+# attendi il boot (1-2 min al primo avvio), poi dalla root del progetto:
+flutter run
+```
+
+> **Nota WSL2**: serve un kernel con KVM abilitato (WSL2 recenti lo hanno di serie —
+> verifica con `ls /dev/kvm`). La finestra dell'emulatore compare tramite WSLg.
+
+## Utilizzo
+
+```bash
+emulator -avd biteplan &
+flutter run
+# hot reload con "r", hot restart con "R"
+```
+
+Per l'uso dell'app una volta installata, vedi la [guida utente](docs/guida-utente.md).
+
+### Installare e testare un APK già buildato
+
+Una volta creato l'AVD `biteplan` (vedi sopra), per installare e provare un APK di debug
+già buildato (es. `dist/biteplan-debug.apk` generato da `bash docker/build.sh`) senza
+passare da `flutter run`:
+
+```bash
+emulator -avd biteplan &
+adb wait-for-device
+adb shell 'while [ "$(getprop sys.boot_completed)" != "1" ]; do sleep 1; done'
+
+adb install -r dist/biteplan-debug.apk   # -r = reinstalla sovrascrivendo se già presente
+adb shell monkey -p com.davide.biteplan -c android.intent.category.LAUNCHER 1
+
+# log in tempo reale
+adb logcat --pid=$(adb shell pidof -s com.davide.biteplan)
+
+# disinstalla quando hai finito
+adb uninstall com.davide.biteplan
+```
+
+> Per lo sviluppo iterativo (hot reload) usa `flutter run` — questa procedura serve a
+> validare l'APK esatto che verrà distribuito.
 
 ## Test
 
-La suite copre unit test e widget test. Richiede l'immagine Docker `biteplan-build`
-(creata automaticamente al primo `bash docker/build/build.sh`).
+Cosa è coperto, cosa no e insidie note: [docs/testing.md](docs/testing.md).
 
 ```bash
-# Tutti i test (dalla root del progetto)
-docker run --rm -v "$(pwd):/workspace" -w /workspace biteplan-build \
-  bash -c "flutter pub get && flutter test"
+flutter test                                            # tutta la suite (host)
+flutter test test/features/meal_planner/qr_test.dart    # singolo file
 
-# Un singolo file
+# versione riproducibile via Docker (immagine biteplan-build, creata al primo bash docker/build.sh)
 docker run --rm -v "$(pwd):/workspace" -w /workspace biteplan-build \
-  bash -c "flutter test test/features/meal_planner/qr_test.dart"
+  bash -c "flutter pub get --enforce-lockfile && flutter test"
 ```
 
-### Struttura
+Struttura di `test/` (rispecchia `lib/`):
 
-```
+```text
 test/
-├── helpers/
-│   └── pump_app.dart                     # estensione pumpApp per widget test
+├── helpers/pump_app.dart                 # estensione pumpApp per widget test
 ├── features/
-│   ├── converter/
-│   │   ├── models/conversion_entry_test.dart
-│   │   └── providers/converter_provider_test.dart
-│   ├── meal_planner/
-│   │   ├── models/meal_plan_test.dart
-│   │   ├── providers/meal_planner_provider_test.dart
-│   │   ├── widgets/meal_card_test.dart
-│   │   └── qr_test.dart
-│   └── shopping_list/
-│       ├── models/shopping_item_test.dart
-│       ├── providers/shopping_list_provider_test.dart
-│       └── widgets/shopping_item_tile_test.dart
-└── shared/
-    ├── services/
-    │   └── update_service_test.dart      # parsing versione e confronto semver
-    └── widgets/
-        └── update_dialog_test.dart       # widget test dialog aggiornamento
+│   ├── converter/{models,providers}/
+│   ├── meal_planner/{models,providers,widgets}/ + qr_test.dart
+│   └── shopping_list/{models,providers,widgets}/
+└── shared/{services,widgets}/
 ```
 
 ## Build APK
 
 ```bash
-bash docker/build/build.sh           # debug  → dist/biteplan-debug.apk
-bash docker/build/build.sh --release # release → dist/biteplan-release.apk
+bash docker/build.sh                        # debug   → dist/biteplan-debug.apk
+export BITEPLAN_KEYSTORE_PASS=password      # richiesto solo per --release
+bash docker/build.sh --release              # release → dist/biteplan-release.apk
 ```
 
-Vedi [docker/README.md](docker/README.md) per i requisiti della firma release.
+Vedi [docker/README.md](docker/README.md) per i requisiti della firma release (keystore).
+
+## Contribuire
+
+Progetto personale mantenuto da un singolo autore, senza processo di contribuzione formale.
+Segnalazioni di bug e proposte sono benvenute via [Issues](https://github.com/davide3011/biteplan/issues);
+per modifiche più ampie apri prima una issue di discussione prima di lavorare a una PR.
 
 ## Documentazione
 
 - [Guida utente](docs/guida-utente.md)
+- [Architettura](docs/architettura.md)
 - [Fonti e documentazione conversioni](docs/conversioni.md)
+- [Emulatore Android — installazione e uso](docs/emulatore.md)
+- [Test — cosa è coperto e come lanciarli](docs/testing.md)
 - [Changelog](CHANGELOG.md)
 
-## Licenza
+## Stato e licenza
 
-[EUPL v1.2](LICENSE) — Davide Grilli
+Versione corrente: vedi [pubspec.yaml](pubspec.yaml) e [CHANGELOG.md](CHANGELOG.md).
+Distribuito come APK firmato tramite le [release GitHub](https://github.com/davide3011/biteplan/releases);
+l'app verifica automaticamente la disponibilità di aggiornamenti all'avvio.
+
+Rilasciato sotto licenza [EUPL v1.2](LICENSE) — Davide Grilli.

db_prodotti/README.md

@@ -0,0 +1,81 @@
+# db_prodotti — catalogo prodotti aldi.it
+
+Dump del catalogo pubblico su [aldi.it/prodotti](https://www.aldi.it/prodotti), raccolto con
+uno scraper (`scrape_aldi.py`) perché il sito non espone un'API pubblica ed è protetto da
+bot-detection (Akamai) che blocca le richieste HTTP dirette — servono un browser reale
+(Playwright + Chromium headless).
+
+**Non fa parte dell'app BitePlan** (non è collegato a `lib/` né alla build Flutter): è un
+dataset a sé, generato una tantum, da usare come riferimento offline (es. prezzi/prodotti per
+alimentare in futuro il convertitore o la lista spesa).
+
+## File
+
+- `aldi_prodotti.db` — SQLite, tabelle `prodotti`, `categorie`, `prodotto_categorie` (join, un prodotto può comparire in più categorie foglia), `metadata` (data di generazione, fonte). Generato, non versionato (vedi `.gitignore`) — rigenerabile con lo script.
+- `scrape_aldi.py` — script di generazione (Playwright + BeautifulSoup)
+- `viewer.html` — UI statica per sfogliare il db nel browser (nessun server/dipendenza da installare)
+
+## Schema SQLite
+
+```
+prodotti(sku PK, nome, marca, prezzo_testo, prezzo_scontato, unita_misura,
+          prezzo_comparativo, descrizione, immagine_url, url_prodotto)
+categorie(slug PK, nome, breadcrumb)
+prodotto_categorie(sku, categoria_slug)
+```
+
+`prezzo_testo` e `prezzo_comparativo` sono stringhe italiane così come mostrate sul sito
+(es. `"0,75 €"`, `"(1,50 €/1 kg)"`) — non convertite in numero per evitare ambiguità di
+parsing su formati misti (kg/100g/pezzo).
+
+## Copertura e limiti
+
+- **674 prodotti unici**, 90 categorie foglia (su 92 individuate; 2 risultate vuote),
+  generato il 2026-09-20. Include sia alimentari sia non-food (abbigliamento, casa, pet
+  care, elettronica, ecc.) perché il catalogo online ALDI Italia li espone tutti sotto
+  `/prodotti`.
+- Il catalogo online ALDI Italia è un **volantino digitale**, non un e-commerce completo:
+  le pagine di dettaglio prodotto **non hanno quasi mai** ingredienti, valori nutrizionali o
+  codice EAN. Il campo `descrizione` è popolato solo per ~38% dei prodotti (376/674 vuoti),
+  più spesso su non-food (taglie, materiali) che su alimentari.
+- I prezzi sono uno snapshot del giorno di generazione: ALDI aggiorna il volantino/le offerte
+  periodicamente, quindi il dato invecchia — va rigenerato se serve aggiornato.
+
+## Rigenerare il db
+
+```bash
+pip install --break-system-packages playwright beautifulsoup4
+python3 scrape_aldi.py              # scraping completo (~20-30 min)
+python3 scrape_aldi.py --no-detail  # salta il dettaglio prodotto (solo elenco, ~2 min)
+```
+
+Usa il Chromium di sistema (`/snap/bin/chromium`) via Playwright, nessun download di
+browser aggiuntivo. Include una pausa (`DELAY` in `scrape_aldi.py`) fra le richieste di
+listing e fetch in parallelo (`DETAIL_CONCURRENCY = 8`, in `scrape_aldi.py`) per le pagine
+di dettaglio, il collo di bottiglia principale.
+
+Ogni run è **riproducibile**: `write_sqlite()` cancella `aldi_prodotti.db` se già esiste
+(`db_path.unlink()`) e lo ricrea da zero con lo schema e i dati appena raccolti — nessun
+merge/append tra run, il file rispecchia sempre solo l'ultimo scraping. `metadata.generato_il`
+viene sovrascritto ad ogni rigenerazione con il timestamp del run corrente.
+
+## Visualizzare il db (`viewer.html`)
+
+Pagina statica (HTML + JS, [sql.js](https://sql.js.org) via CDN) che legge `aldi_prodotti.db`
+direttamente nel browser, senza installazione né build:
+
+- tabella con miniatura, nome, marca, prezzo (con eventuale prezzo scontato), formato/unità
+  di misura e categorie di appartenenza
+- ricerca live per nome/marca
+- filtro per categoria (dropdown popolato dalla tabella `categorie`)
+- colonne ordinabili al click sull'intestazione (stesso click inverte la direzione)
+- riepilogo in testa con data/ora di generazione e fonte, letti da `metadata`
+
+Va **servita via HTTP** (il fetch del `.db` fallisce se apri il file con doppio click /
+`file://`, per le restrizioni CORS del browser):
+
+```bash
+cd db_prodotti
+python3 -m http.server 8000
+# poi apri http://localhost:8000/viewer.html
+```

db_prodotti/scrape_aldi.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""Scraper del catalogo prodotti aldi.it -> sqlite (aldi_prodotti.db) + JSON (aldi_prodotti.json).
+
+Uso:
+    python3 scrape_aldi.py                 # scraping completo (categorie + elenco prodotti + dettaglio)
+    python3 scrape_aldi.py --no-detail      # salta il fetch delle pagine di dettaglio prodotto
+
+Richiede: playwright (pip install playwright), un browser chromium disponibile
+(usa /snap/bin/chromium di sistema via executable_path, nessun download extra).
+"""
+import argparse
+import asyncio
+import re
+import sqlite3
+import sys
+import time
+from pathlib import Path
+from urllib.parse import urljoin
+
+from bs4 import BeautifulSoup
+from playwright.async_api import async_playwright
+from playwright.sync_api import sync_playwright
+
+BASE = "https://www.aldi.it"
+UA = ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+      "(KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36")
+OUT_DIR = Path(__file__).parent
+DELAY = 0.4  # pausa fra le richieste di listing, per non martellare il sito
+DETAIL_CONCURRENCY = 8  # pagine di dettaglio in parallelo
+
+
+def slug_to_label(slug: str) -> str:
+    return slug.replace("-", " ").strip().capitalize()
+
+
+def find_leaf_categories(page) -> list[dict]:
+    page.goto(f"{BASE}/prodotti", timeout=30000)
+    page.wait_for_load_state("networkidle", timeout=15000)
+    soup = BeautifulSoup(page.content(), "html.parser")
+    hrefs = sorted({a["href"] for a in soup.find_all("a", href=True)
+                    if re.match(r"^/prodotti/.+/k/\d+$", a["href"])})
+    paths = [h.split("/k/")[0] for h in hrefs]
+    leaves = []
+    for h, p in zip(hrefs, paths):
+        is_leaf = not any(p2 != p and p2.startswith(p + "/") for p2 in paths)
+        if is_leaf:
+            slugs = p.strip("/").split("/")[1:]  # rimuove "prodotti"
+            leaves.append({
+                "url": urljoin(BASE, h),
+                "slug_path": "/".join(slugs),
+                "breadcrumb": " > ".join(slug_to_label(s) for s in slugs),
+                "categoria_slug": slugs[-1],
+                "categoria_nome": slug_to_label(slugs[-1]),
+            })
+    return leaves
+
+
+def parse_product_tiles(html: str) -> list[dict]:
+    soup = BeautifulSoup(html, "html.parser")
+    products = []
+    for tile_wrap in soup.select('[id^="product-tile-"]'):
+        sku = tile_wrap["id"].replace("product-tile-", "")
+        tile = tile_wrap.select_one(".product-tile")
+        if tile is None:
+            continue
+        name_el = tile.select_one(".product-tile__name p")
+        brand_el = tile.select_one(".product-tile__brandname p")
+        price_el = tile.select_one(".base-price__regular span")
+        old_price_el = tile.select_one(".base-price__discount-tag__wrapper")
+        unit_el = tile.select_one('[data-test="product-tile__unit-of-measurement"]')
+        comp_price_el = tile.select_one('[data-test="product-tile__comparison-price"]')
+        link_el = tile.select_one("a.product-tile__link")
+        img_el = tile.select_one("img")
+
+        products.append({
+            "sku": sku,
+            "nome": name_el.get_text(strip=True) if name_el else tile.get("title"),
+            "marca": brand_el.get_text(strip=True).rstrip(",") if brand_el else None,
+            "prezzo_testo": price_el.get_text(strip=True) if price_el else None,
+            "prezzo_scontato": bool(old_price_el and old_price_el.get_text(strip=True)),
+            "unita_misura": unit_el.get_text(strip=True) if unit_el else None,
+            "prezzo_comparativo": comp_price_el.get_text(strip=True) if comp_price_el else None,
+            "url_prodotto": urljoin(BASE, link_el["href"]) if link_el else None,
+            "immagine_url": img_el["src"] if img_el and img_el.get("src") else None,
+        })
+    return products
+
+
+def max_page(html: str) -> int:
+    soup = BeautifulSoup(html, "html.parser")
+    pages = [int(a.get_text(strip=True)) for a in soup.select(".base-pagination__count")
+             if a.get_text(strip=True).isdigit()]
+    return max(pages) if pages else 1
+
+
+def scrape_listing(page, leaves: list[dict]) -> dict:
+    """Ritorna {sku: prodotto} con le categorie aggregate."""
+    products: dict[str, dict] = {}
+    for i, cat in enumerate(leaves, 1):
+        print(f"[{i}/{len(leaves)}] {cat['breadcrumb']}", file=sys.stderr)
+        page.goto(cat["url"], timeout=30000)
+        try:
+            page.wait_for_selector('[id^="product-tile-"], .product-listing-viewer', timeout=15000)
+        except Exception:
+            pass
+        html = page.content()
+        n_pages = max_page(html)
+        all_tiles = parse_product_tiles(html)
+        for p in range(2, n_pages + 1):
+            time.sleep(DELAY)
+            page.goto(f"{cat['url']}?page={p}", timeout=30000)
+            page.wait_for_selector('[id^="product-tile-"]', timeout=15000)
+            all_tiles.extend(parse_product_tiles(page.content()))
+
+        for t in all_tiles:
+            existing = products.get(t["sku"])
+            if existing is None:
+                t["categorie"] = [{"slug": cat["categoria_slug"], "nome": cat["categoria_nome"],
+                                    "breadcrumb": cat["breadcrumb"]}]
+                products[t["sku"]] = t
+            else:
+                if not any(c["slug"] == cat["categoria_slug"] for c in existing["categorie"]):
+                    existing["categorie"].append({"slug": cat["categoria_slug"],
+                                                    "nome": cat["categoria_nome"],
+                                                    "breadcrumb": cat["breadcrumb"]})
+        time.sleep(DELAY)
+    return products
+
+
+async def _scrape_detail_one(context, product: dict, sem: asyncio.Semaphore,
+                              progress: list, total: int) -> None:
+    async with sem:
+        page = await context.new_page()
+        try:
+            await page.goto(product["url_prodotto"], timeout=30000)
+            await page.wait_for_load_state("networkidle", timeout=15000)
+            soup = BeautifulSoup(await page.content(), "html.parser")
+            desc_el = soup.select_one(".product-details__information .show-more__content")
+            product["descrizione"] = desc_el.get_text(strip=True) if desc_el else None
+        except Exception as e:
+            print(f"  errore su {product['url_prodotto']}: {e}", file=sys.stderr)
+            product["descrizione"] = None
+        finally:
+            await page.close()
+        progress.append(1)
+        print(f"[dettaglio {len(progress)}/{total}] {product['nome']}", file=sys.stderr)
+
+
+async def scrape_detail_async(products: dict) -> None:
+    """Fetch delle pagine di dettaglio in parallelo (DETAIL_CONCURRENCY schede alla volta)."""
+    items = [p for p in products.values() if p.get("url_prodotto")]
+    sem = asyncio.Semaphore(DETAIL_CONCURRENCY)
+    progress: list = []
+
+    async with async_playwright() as pw:
+        browser = await pw.chromium.launch(executable_path="/snap/bin/chromium", headless=True,
+                                            args=["--no-sandbox", "--disable-gpu"])
+        context = await browser.new_context(user_agent=UA)
+        await asyncio.gather(*(_scrape_detail_one(context, p, sem, progress, len(items))
+                                for p in items))
+        await browser.close()
+
+
+def scrape_detail(products: dict) -> None:
+    asyncio.run(scrape_detail_async(products))
+
+
+def write_sqlite(products: dict, db_path: Path) -> None:
+    if db_path.exists():
+        db_path.unlink()
+    conn = sqlite3.connect(db_path)
+    conn.executescript("""
+        CREATE TABLE categorie (
+            slug TEXT PRIMARY KEY,
+            nome TEXT NOT NULL,
+            breadcrumb TEXT NOT NULL
+        );
+        CREATE TABLE prodotti (
+            sku TEXT PRIMARY KEY,
+            nome TEXT NOT NULL,
+            marca TEXT,
+            prezzo_testo TEXT,
+            prezzo_scontato INTEGER NOT NULL DEFAULT 0,
+            unita_misura TEXT,
+            prezzo_comparativo TEXT,
+            descrizione TEXT,
+            immagine_url TEXT,
+            url_prodotto TEXT
+        );
+        CREATE TABLE prodotto_categorie (
+            sku TEXT NOT NULL REFERENCES prodotti(sku),
+            categoria_slug TEXT NOT NULL REFERENCES categorie(slug),
+            PRIMARY KEY (sku, categoria_slug)
+        );
+        CREATE TABLE metadata (
+            chiave TEXT PRIMARY KEY,
+            valore TEXT NOT NULL
+        );
+    """)
+    conn.execute("INSERT INTO metadata (chiave, valore) VALUES ('generato_il', ?)",
+                 (time.strftime("%Y-%m-%dT%H:%M:%S%z"),))
+    conn.execute("INSERT INTO metadata (chiave, valore) VALUES ('fonte', ?)",
+                 (f"{BASE}/prodotti",))
+    seen_cat = set()
+    for p in products.values():
+        conn.execute(
+            "INSERT INTO prodotti (sku, nome, marca, prezzo_testo, prezzo_scontato, "
+            "unita_misura, prezzo_comparativo, descrizione, immagine_url, url_prodotto) "
+            "VALUES (?,?,?,?,?,?,?,?,?,?)",
+            (p["sku"], p["nome"], p.get("marca"), p.get("prezzo_testo"),
+             int(p.get("prezzo_scontato", False)), p.get("unita_misura"),
+             p.get("prezzo_comparativo"), p.get("descrizione"), p.get("immagine_url"),
+             p.get("url_prodotto")),
+        )
+        for c in p["categorie"]:
+            if c["slug"] not in seen_cat:
+                conn.execute("INSERT INTO categorie (slug, nome, breadcrumb) VALUES (?,?,?)",
+                             (c["slug"], c["nome"], c["breadcrumb"]))
+                seen_cat.add(c["slug"])
+            conn.execute("INSERT OR IGNORE INTO prodotto_categorie (sku, categoria_slug) VALUES (?,?)",
+                         (p["sku"], c["slug"]))
+    conn.commit()
+    conn.close()
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--no-detail", action="store_true", help="salta il fetch delle pagine di dettaglio")
+    args = ap.parse_args()
+
+    with sync_playwright() as pw:
+        browser = pw.chromium.launch(executable_path="/snap/bin/chromium", headless=True,
+                                      args=["--no-sandbox", "--disable-gpu"])
+        page = browser.new_page(user_agent=UA)
+
+        leaves = find_leaf_categories(page)
+        print(f"{len(leaves)} categorie foglia trovate", file=sys.stderr)
+
+        products = scrape_listing(page, leaves)
+        print(f"{len(products)} prodotti unici trovati", file=sys.stderr)
+
+        browser.close()
+
+    if not args.no_detail:
+        scrape_detail(products)  # fase separata: usa l'API async per il fetch in parallelo
+
+    write_sqlite(products, OUT_DIR / "aldi_prodotti.db")
+    print("Fatto: aldi_prodotti.db", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

db_prodotti/viewer.html

@@ -0,0 +1,160 @@
+<!doctype html>
+<html lang="it">
+<head>
+<meta charset="utf-8">
+<title>Catalogo ALDI — visualizzatore</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { font-family: system-ui, sans-serif; margin: 0; padding: 1.5rem; background: #f7f7f5; color: #1a1a1a; }
+  h1 { font-size: 1.25rem; margin: 0 0 0.25rem; }
+  #meta { color: #666; font-size: 0.85rem; margin-bottom: 1rem; }
+  #controls { display: flex; gap: 0.75rem; flex-wrap: wrap; margin-bottom: 1rem; }
+  input, select { padding: 0.4rem 0.6rem; font-size: 0.9rem; border: 1px solid #ccc; border-radius: 6px; }
+  input[type="search"] { flex: 1; min-width: 200px; }
+  #count { font-size: 0.85rem; color: #666; margin-bottom: 0.5rem; }
+  #table-wrap { overflow-x: auto; background: #fff; border-radius: 8px; }
+  table { width: 100%; min-width: 780px; border-collapse: collapse; }
+  th, td { text-align: left; padding: 0.5rem 0.6rem; border-bottom: 1px solid #eee; font-size: 0.9rem; vertical-align: middle; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 260px; }
+  th:nth-child(2), td:nth-child(2) { min-width: 220px; }
+  th:nth-child(6), td:nth-child(6) { white-space: normal; }
+  th { background: #eee; cursor: pointer; user-select: none; position: sticky; top: 0; }
+  th:hover { background: #e2e2e2; }
+  img.thumb { width: 40px; height: 40px; object-fit: contain; border-radius: 4px; background: #f0f0f0; display: block; }
+  tr:hover { background: #fafafa; }
+  a { color: #2d6a4f; }
+  #error { color: #b00020; white-space: pre-wrap; }
+</style>
+</head>
+<body>
+<h1>Catalogo ALDI — visualizzatore</h1>
+<div id="meta">caricamento...</div>
+<div id="controls">
+  <input type="search" id="q" placeholder="Cerca per nome o marca...">
+  <select id="categoria"><option value="">Tutte le categorie</option></select>
+</div>
+<div id="count"></div>
+<div id="error"></div>
+<div id="table-wrap">
+<table id="tabella">
+  <thead>
+    <tr>
+      <th></th>
+      <th data-key="nome">Nome</th>
+      <th data-key="marca">Marca</th>
+      <th data-key="prezzo_num">Prezzo</th>
+      <th data-key="unita_misura">Formato</th>
+      <th data-key="categorie">Categorie</th>
+    </tr>
+  </thead>
+  <tbody></tbody>
+</table>
+</div>
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/sql-wasm.js"></script>
+<script>
+let allRows = [];
+let sortKey = null, sortDir = 1;
+
+function parsePrezzo(testo) {
+  if (!testo) return null;
+  const n = testo.replace(/[^\d,]/g, "").replace(",", ".");
+  return n ? parseFloat(n) : null;
+}
+
+async function main() {
+  const errEl = document.getElementById("error");
+  try {
+    const SQL = await initSqlJs({ locateFile: f => `https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/${f}` });
+    const buf = await (await fetch("aldi_prodotti.db")).arrayBuffer();
+    const db = new SQL.Database(new Uint8Array(buf));
+
+    const meta = {};
+    db.exec("SELECT chiave, valore FROM metadata")[0]?.values.forEach(([k, v]) => meta[k] = v);
+    const generatoIl = meta.generato_il
+      ? new Date(meta.generato_il).toLocaleString("it-IT", { dateStyle: "long", timeStyle: "short" })
+      : "?";
+    document.getElementById("meta").textContent =
+      `Generato il ${generatoIl} — fonte: ${meta.fonte ?? "?"}`;
+
+    const catStmt = db.exec("SELECT slug, breadcrumb FROM categorie ORDER BY breadcrumb");
+    const catSel = document.getElementById("categoria");
+    (catStmt[0]?.values ?? []).forEach(([slug, breadcrumb]) => {
+      const opt = document.createElement("option");
+      opt.value = slug;
+      opt.textContent = breadcrumb;
+      catSel.appendChild(opt);
+    });
+
+    const res = db.exec(`
+      SELECT p.sku, p.nome, p.marca, p.prezzo_testo, p.unita_misura, p.immagine_url,
+             p.url_prodotto,
+             (SELECT group_concat(c.nome, ', ') FROM prodotto_categorie pc
+              JOIN categorie c ON c.slug = pc.categoria_slug WHERE pc.sku = p.sku) AS categorie,
+             (SELECT group_concat(pc.categoria_slug, ',') FROM prodotto_categorie pc
+              WHERE pc.sku = p.sku) AS categoria_slugs
+      FROM prodotti p
+    `);
+    const cols = res[0].columns;
+    allRows = res[0].values.map(row => {
+      const o = Object.fromEntries(cols.map((c, i) => [c, row[i]]));
+      o.prezzo_num = parsePrezzo(o.prezzo_testo);
+      return o;
+    });
+
+    document.getElementById("q").addEventListener("input", render);
+    catSel.addEventListener("change", render);
+    document.querySelectorAll("th[data-key]").forEach(th => {
+      th.addEventListener("click", () => {
+        const key = th.dataset.key;
+        sortDir = (sortKey === key) ? -sortDir : 1;
+        sortKey = key;
+        render();
+      });
+    });
+
+    render();
+  } catch (e) {
+    errEl.textContent = "Errore nel caricamento del database: " + e.message +
+      "\n\nSe hai aperto questo file direttamente (file://), il browser blocca il fetch " +
+      "del .db per motivi di sicurezza. Avvialo invece con:\n" +
+      "  cd db_prodotti && python3 -m http.server 8000\n" +
+      "e apri http://localhost:8000/viewer.html";
+    document.getElementById("meta").textContent = "";
+  }
+}
+
+function render() {
+  const q = document.getElementById("q").value.trim().toLowerCase();
+  const cat = document.getElementById("categoria").value;
+  let rows = allRows.filter(r =>
+    (!q || (r.nome ?? "").toLowerCase().includes(q) || (r.marca ?? "").toLowerCase().includes(q)) &&
+    (!cat || (r.categoria_slugs ?? "").split(",").includes(cat))
+  );
+  if (sortKey) {
+    rows = rows.slice().sort((a, b) => {
+      const av = a[sortKey] ?? "", bv = b[sortKey] ?? "";
+      return av < bv ? -sortDir : av > bv ? sortDir : 0;
+    });
+  }
+  document.getElementById("count").textContent = `${rows.length} / ${allRows.length} prodotti`;
+
+  const tbody = document.querySelector("#tabella tbody");
+  tbody.innerHTML = "";
+  for (const r of rows) {
+    const tr = document.createElement("tr");
+    tr.innerHTML = `
+      <td>${r.immagine_url ? `<img class="thumb" src="${r.immagine_url}" loading="lazy" alt="">` : ""}</td>
+      <td><a href="${r.url_prodotto ?? "#"}" target="_blank" rel="noopener">${r.nome ?? ""}</a></td>
+      <td>${r.marca ?? ""}</td>
+      <td>${r.prezzo_testo ?? ""}</td>
+      <td>${r.unita_misura ?? ""}</td>
+      <td>${r.categorie ?? ""}</td>
+    `;
+    tbody.appendChild(tr);
+  }
+}
+
+main();
+</script>
+</body>
+</html>

docker/README.md

@@ -1,39 +1,12 @@
 # Docker — BitePlan
 
-Due container distinti: uno per lo sviluppo con hot reload, uno per la build APK headless.
+Un solo container, usato per test riproducibili e build APK headless.
+Lo sviluppo (hot reload) avviene sull'host con Flutter + emulatore Android — vedi `CLAUDE.md`.
 Tutti i comandi vanno eseguiti dalla **root del progetto** (`~/biteplan`), non da `docker/`.
 
 ---
 
-## Container dev (`docker/dev/`)
-
-Avvia un web server Flutter accessibile dal browser, con hot reload.
-
-```bash
-cd docker/dev
-docker compose up
-```
-
-Apri **http://localhost:5173** nel browser.
-
-### Hot reload
-
-Con il container attivo, in un altro terminale:
-
-```bash
-docker compose attach dev
-# r → hot reload  |  R → hot restart  |  q → esci
-```
-
-Le modifiche ai file `.dart` sull'host sono visibili subito nel container grazie al volume
-montato — basta premere `r` per ricaricare.
-
-> Prima esecuzione: scarica l'immagine Flutter (~500 MB), richiede 5-10 minuti.
-> Le successive usano la cache Docker e sono molto più rapide.
-
----
-
-## Container build (`docker/build/`)
+## Container build (`docker/`)
 
 Build headless riproducibile per generare l'APK Android.
 
@@ -42,7 +15,7 @@ Build headless riproducibile per generare l'APK Android.
 APK firmato con il debug keystore di Android — adatto per installazione diretta sul dispositivo.
 
 ```bash
-bash docker/build/build.sh
+bash docker/build.sh
 # → dist/biteplan-debug.apk
 ```
 
@@ -83,7 +56,7 @@ aggiungila a `~/.bashrc` o `~/.zshrc`.
 **3. Esegui la build release**
 
 ```bash
-bash docker/build/build.sh --release
+bash docker/build.sh --release
 # → dist/biteplan-release.apk
 ```
 
@@ -107,8 +80,7 @@ adb install dist/biteplan-debug.apk
 
 ## Test
 
-I test non richiedono il container dev — usano l'immagine `biteplan-build`, creata
-automaticamente al primo `bash docker/build/build.sh`.
+I test usano l'immagine `biteplan-build`, creata automaticamente al primo `bash docker/build.sh`.
 
 ```bash
 # Tutti i test (110 test — unit + widget)
@@ -137,17 +109,17 @@ avere Flutter installato sull'host.
 ## Flusso completo
 
 ```
-# 1. Sviluppo
-cd docker/dev && docker compose up
-→ http://localhost:5173   (hot reload con 'r')
+# 1. Sviluppo (host, no Docker — vedi CLAUDE.md)
+emulator -avd biteplan &
+flutter run
 
 # 2. Test
 docker run --rm -v "$(pwd):/workspace" -w /workspace biteplan-build \
   bash -c "flutter pub get && flutter test"
 
 # 3. Build
-bash docker/build/build.sh             # → dist/biteplan-debug.apk
-bash docker/build/build.sh --release   # → dist/biteplan-release.apk
+bash docker/build.sh             # → dist/biteplan-debug.apk
+bash docker/build.sh --release   # → dist/biteplan-release.apk
 
 # 4. Installazione
 adb install dist/biteplan-debug.apk
@@ -157,7 +129,7 @@ adb install dist/biteplan-debug.apk
 
 ## Note
 
-- App ID: `com.biteplan.biteplan`
+- App ID: `com.davide.biteplan`
 - Android target: API 34
 - Il keystore non viene mai copiato nell'immagine Docker (volume read-only)
 - `dist/` è in `.gitignore`

docs/architettura.md

@@ -0,0 +1,83 @@
+# Architettura — BitePlan
+
+Documento tecnico per chi sviluppa o mantiene l'app: come sono strutturati i dati e come
+scorrono tra UI, provider e persistenza. Per l'elenco file per file vedi [CLAUDE.md](../CLAUDE.md);
+per l'uso dell'app vedi [guida-utente.md](guida-utente.md).
+
+## Pattern generale
+
+Ogni feature (`meal_planner`, `converter`, `shopping_list`) segue lo stesso schema:
+
+```
+Widget (presentation/) → Provider (ChangeNotifier) → StorageService / asset → SharedPreferences
+        ↑____________________________notifyListeners()____________________________|
+```
+
+Ogni provider espone metodi che mutano lo stato immutabile in memoria, chiamano
+`notifyListeners()` e poi salvano in modo fire-and-forget (senza `await`, l'UI non aspetta
+la scrittura su disco). `load()` va chiamato una volta all'avvio (in `main.dart`) prima di
+usare il provider.
+
+## Piano pasti (`meal_planner`)
+
+- **Modello**: `MealPlan` è una mappa `dayId → DayPlan`; `DayPlan` ha tre liste di stringhe
+  (`colazione`, `pranzo`, `cena`). Entrambi sono immutabili: ogni modifica passa da
+  `copyWith`/`withUpdatedDay` e ricostruisce l'oggetto.
+- **Provider**: `MealPlannerProvider` tiene `_plan` in memoria, la inizializza vuota con
+  `MealPlan.empty(kDayIds)`, la carica da `StorageService` (chiave `meals`, JSON via
+  `toJsonString`/`fromJsonString`). Se il JSON salvato è corrotto, torna a un piano vuoto
+  invece di lanciare un'eccezione.
+- **Condivisione QR** (`qr_codec.dart`): `buildQrPayload` serializza il piano come
+  `{ "v": 1, "meals": {...} }` e restituisce `null` se supera 2953 byte (capienza QR con error
+  correction L) — la UI mostra un errore in quel caso. `parseMealPlanFromQr` valida
+  struttura e versione prima di ricostruire il `MealPlan`, per non far crashare l'app su un
+  QR malformato o generato da una versione futura.
+- **Generazione lista spesa**: la pagina piano pasti legge `plan.allItems` e chiama
+  `ShoppingListProvider.addAll(...)` — l'aggregazione duplicati avviene lì, non nel meal
+  planner.
+
+## Convertitore crudo/cotto (`converter`)
+
+- **Dati**: `assets/data/conversions.json` è una mappa `alimento → metodo → { yield }`,
+  caricata una sola volta in `ConverterProvider.loadDb()` e appiattita in una lista di
+  `ConversionEntry { food, method, yieldFactor }`.
+- **Calcolo**: `rawToCooked = raw * yieldFactor`, `cookedToRaw = cooked / yieldFactor`.
+  Il provider arrotonda il risultato a un decimale (`(v * 10).roundToDouble() / 10`).
+- **Ricerca**: `search(query)` filtra `_db` per sottostringa case-insensitive sul nome
+  alimento; non c'è persistenza, lo stato (`selected`, `grams`, `rawToCooked`) vive solo in
+  memoria e si azzera con `reset()`.
+- I coefficienti e le fonti sono documentati in [conversioni.md](conversioni.md) — per
+  aggiungerne di nuovi si modifica solo il JSON, non serve toccare il provider.
+
+## Lista della spesa (`shopping_list`)
+
+- **Modello**: `ShoppingItem { id, name, checked, quantity }`. `id` è generato come
+  `timestamp_contatore` (non un vero UUID) per garantire unicità anche ad aggiunte multiple
+  nello stesso millisecondo.
+- **Provider**: `ShoppingListProvider` persiste su chiave `shopping_list` come lista JSON.
+  `pendingItems`/`checkedItems` sono getter derivati, non stato separato.
+- **`addAll(names)`**: raggruppa i nomi per confronto case-insensitive, somma le occorrenze
+  in `quantity` e salta quelli già presenti nella lista (case-insensitive anche lì) — è il
+  meccanismo dietro "zucchine (x2)" e dietro il "senza duplicati" della generazione lista
+  dal piano pasti.
+
+## Controllo aggiornamenti
+
+`UpdateService.checkUpdate()` (chiamato da `app.dart` in `initState`) interroga
+`GET /repos/davide3011/biteplan/releases/latest` su GitHub con `dart:io HttpClient`
+(nessun package HTTP aggiuntivo), timeout 5s su connessione e risposta. Confronta il
+`tag_name` (spogliato del prefisso `v`) con `kAppVersion` via confronto semver a tre
+componenti (`isNewer`); qualsiasi errore di rete, parsing o timeout fa fallire silenziosamente
+il controllo (ritorna `null`, nessun dialog). Disabilitato su web (`kIsWeb`).
+
+`kAppVersion` in `app_constants.dart` **non** è sincronizzato automaticamente con
+`pubspec.yaml` — va aggiornato a mano ad ogni release, altrimenti il confronto versione è
+sbagliato.
+
+## MethodChannel nativo
+
+Il bottone "Scarica" del dialog di aggiornamento e altri link esterni passano da
+`UrlLauncherService`, che invoca il canale nativo `com.davide.biteplan/launcher`
+implementato in Kotlin (`android/app/src/main/kotlin/com/davide/biteplan/MainActivity.kt`)
+con un `Intent.ACTION_VIEW` — scelta per evitare di aggiungere il package `url_launcher`
+per un solo caso d'uso.

docs/emulatore.md

@@ -0,0 +1,121 @@
+# Emulatore Android — installazione e uso (Ubuntu)
+
+Guida per chi sviluppa BitePlan su Ubuntu (nativo o WSL2) e deve installare ed usare
+l'emulatore Android in locale. Per i requisiti generali del progetto vedi [README](../README.md);
+per la build via Docker vedi [CLAUDE.md](../CLAUDE.md).
+
+## 1. Prerequisiti
+
+- **KVM** per l'accelerazione hardware: senza, l'emulatore è troppo lento per essere usabile.
+
+  ```bash
+  ls /dev/kvm          # deve esistere
+  groups | grep kvm    # il tuo utente deve essere nel gruppo kvm
+  ```
+
+  Se il gruppo manca:
+
+  ```bash
+  sudo usermod -aG kvm $USER
+  # poi rilogin (o riavvia la sessione) perché il gruppo sia effettivo
+  ```
+
+  Su **WSL2** serve un kernel con KVM abilitato (le versioni recenti lo hanno di serie).
+  La finestra dell'emulatore compare tramite WSLg.
+
+- **Java 17+**: `sudo apt install openjdk-21-jdk`
+- Strumenti di base: `git curl unzip`, e ~15 GB di spazio libero per SDK + system image.
+
+## 2. Installare Android SDK command-line tools
+
+```bash
+mkdir -p ~/android-sdk/cmdline-tools
+cd ~/android-sdk/cmdline-tools
+curl -O https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip
+unzip commandlinetools-linux-11076708_latest.zip && mv cmdline-tools latest
+rm commandlinetools-linux-11076708_latest.zip
+
+cat >> ~/.bashrc <<'EOF'
+export ANDROID_HOME="$HOME/android-sdk"
+export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$PATH"
+EOF
+source ~/.bashrc
+```
+
+## 3. Installare i pacchetti SDK e accettare le licenze
+
+```bash
+sdkmanager "platform-tools" "emulator" \
+  "platforms;android-34" "build-tools;34.0.0" \
+  "system-images;android-34;google_apis;x86_64"
+yes | sdkmanager --licenses
+```
+
+## 4. Creare l'AVD `biteplan`
+
+Il progetto usa un AVD dedicato (Pixel 6, Android 14, `google_apis`/x86_64) — non riusare
+AVD di altri progetti.
+
+```bash
+echo "no" | avdmanager create avd -n biteplan \
+  -k "system-images;android-34;google_apis;x86_64" -d pixel_6
+```
+
+Verifica che tutto sia a posto con `flutter doctor` (la voce "Android toolchain" deve
+risultare ✓).
+
+## 5. Avviare l'emulatore
+
+```bash
+emulator -avd biteplan &
+```
+
+Il primo boot richiede 1-2 minuti; quelli successivi sono più veloci grazie allo snapshot
+automatico dello stato. Per lo sviluppo con hot reload, dalla root del progetto:
+
+```bash
+flutter run     # r = hot reload, R = hot restart
+```
+
+### Opzioni utili
+
+```bash
+emulator -list-avds              # elenca gli AVD disponibili
+emulator -avd biteplan -no-snapshot-load   # forza un cold boot (ignora lo stato salvato)
+emulator -avd biteplan -wipe-data          # resetta l'AVD allo stato di fabbrica
+```
+
+## 6. Comandi `adb` quotidiani
+
+```bash
+adb devices                      # emulatori/device collegati
+adb wait-for-device               # attende che l'emulatore sia raggiungibile
+adb shell 'while [ "$(getprop sys.boot_completed)" != "1" ]; do sleep 1; done'  # attende il boot completo
+
+adb install -r dist/biteplan-debug.apk   # installa/reinstalla un APK già buildato
+adb shell monkey -p com.davide.biteplan -c android.intent.category.LAUNCHER 1  # avvia l'app
+
+adb logcat --pid=$(adb shell pidof -s com.davide.biteplan)   # log in tempo reale dell'app
+
+adb uninstall com.davide.biteplan   # disinstalla
+```
+
+> Per lo sviluppo iterativo usa `flutter run` (hot reload); la sequenza `adb install` sopra
+> serve a validare l'APK esatto che verrà distribuito, senza passare da `flutter run`.
+
+## 7. Chiudere l'emulatore
+
+```bash
+adb -s emulator-5554 emu kill    # spegnimento pulito (salva lo snapshot)
+# oppure chiudi la finestra dell'emulatore
+```
+
+## Troubleshooting
+
+| Sintomo | Causa probabile | Soluzione |
+|---|---|---|
+| `emulator: ERROR: x86_64 emulation currently requires hardware acceleration` | KVM non accessibile | Verifica `/dev/kvm` e l'appartenenza al gruppo `kvm` (§1) |
+| Emulatore lentissimo, UI a scatti | KVM non attivo, o system image ARM su host x86_64 | Usa una system image `x86_64` come da §3, verifica KVM |
+| Boot bloccato su logo Android per minuti | Cold boot dopo `-wipe-data`, oppure macchina sotto carico | Attendi, è normale al primo avvio; se persiste prova `-no-snapshot-load` |
+| Finestra emulatore non compare su WSL2 | WSLg non attivo o kernel senza supporto grafico | Aggiorna WSL (`wsl --update`), verifica `echo $DISPLAY` |
+| `adb: no devices/emulators found` | Emulatore non ancora avviato o non ancora bootato | `adb wait-for-device`, poi ricontrolla con `adb devices` |

docs/testing.md

@@ -0,0 +1,78 @@
+# Test — BitePlan
+
+Cosa copre la suite di test, cosa no, e come lanciarla. Per l'architettura del codice
+testato vedi [architettura.md](architettura.md).
+
+## Come lanciare i test
+
+```bash
+flutter test                                            # tutta la suite unit + widget (host)
+flutter test test/features/meal_planner/qr_test.dart    # singolo file
+
+# versione riproducibile via Docker (immagine biteplan-build, creata da bash docker/build.sh)
+docker run --rm -v "$(pwd):/workspace" -w /workspace biteplan-build \
+  bash -c "flutter pub get --enforce-lockfile && flutter test"
+
+# integration test — richiede un emulatore avviato (vedi docs/emulatore.md)
+flutter test integration_test/app_test.dart
+```
+
+## Struttura
+
+```text
+test/
+├── coverage_helper_test.dart             # importa tutta lib/ perché lcov copra anche i file non testati
+├── helpers/pump_app.dart                 # estensione pumpApp per i widget test
+├── features/
+│   ├── converter/{models,pages,providers}/
+│   ├── meal_planner/{models,pages,providers,widgets}/ + qr_test.dart
+│   ├── shopping_list/{models,pages,providers,widgets}/
+│   └── guide/{pages,widgets}/
+└── shared/{services,widgets}/
+```
+
+184 test unit + widget, coverage ~93% su `lib/`, più `integration_test/app_test.dart`
+(navigazione tra tab, flussi end-to-end su un emulatore/device reale).
+
+## Cosa è coperto
+
+- **Modelli**: serializzazione/deserializzazione, `copyWith`, edge case (`MealPlan`,
+  `DayPlan`, `ConversionEntry`, `ShoppingItem`).
+- **Provider**: mutazioni di stato, persistenza (fire-and-forget) tramite
+  `StorageService` con `SharedPreferences.setMockInitialValues({})` isolato per test.
+- **Conversione crudo/cotto**: `rawToCooked`/`cookedToRaw` in `ConversionEntry`.
+- **QR**: `buildQrPayload`/`parseMealPlanFromQr` in `qr_codec.dart` (payload valido,
+  troppo grande, malformato).
+- **Update checker**: `isNewer()`, `parseTagName()` (`@visibleForTesting`), dialog di
+  aggiornamento con `MethodChannel` mockato.
+- **Widget/pagine**: rendering, interazioni utente (tap, form) via `pumpApp`, per tutte
+  le feature (meal_planner, converter, shopping_list, guide).
+- **Integration test**: navigazione fra i tab e flussi che attraversano più feature,
+  su un device/emulatore reale (non richiesto per lo sviluppo quotidiano).
+
+## Cosa NON è coperto (per scelta)
+
+- **`main.dart`**: bootstrap dell'app (setup provider, `runApp`), poco valore nel
+  testarlo isolatamente — è coperto indirettamente dall'integration test.
+- **Percorso camera di `qr_scan_page`**: l'uso reale della fotocamera per scansionare un
+  QR richiede hardware/permessi non simulabili in un widget test; la logica di parsing
+  (`qr_codec.dart`) è invece testata a parte.
+- **`UrlLauncherService`**: wrapper sottile sul `MethodChannel` nativo
+  (`com.davide.biteplan/launcher`) che apre un URL nel browser — l'effetto (apertura
+  browser) non è verificabile senza un device reale.
+
+## Insidie note
+
+- **Non chiamare `loadDb()`/`load()` dei provider nel body di `testWidgets`**: l'async
+  reale eseguito nella zona `FakeAsync` di `flutter_test` può bloccare la suite (timeout
+  10 min). Vanno chiamati nel `setUp()` — vedi
+  [test/features/converter/pages/converter_page_test.dart](../test/features/converter/pages/converter_page_test.dart).
+- **Storage isolato**: ogni test che tocca `StorageService`/i provider deve chiamare
+  `SharedPreferences.setMockInitialValues({})` prima di caricare lo stato, altrimenti i
+  test si influenzano a vicenda.
+- **MethodChannel nei test**: va mockato con
+  `TestDefaultBinaryMessengerBinding.instance.defaultBinaryMessenger.setMockMethodCallHandler`
+  — vedi [test/shared/widgets/update_dialog_test.dart](../test/shared/widgets/update_dialog_test.dart).
+- **Nuovi file in `lib/`**: aggiungerli all'import di
+  [test/coverage_helper_test.dart](../test/coverage_helper_test.dart), altrimenti lcov
+  li esclude dal report di coverage anche se non hanno bisogno di test dedicati.

sop.md

@@ -1,177 +0,0 @@
-# SOP — BitePlan (Flutter → Android APK)
-
-## Scope
-
-App mobile Android con tre funzionalità:
-
-1. **Meal Planner** — pianificazione settimanale (7 giorni × 3 pasti: colazione, pranzo, cena). Ogni pasto contiene una lista di voci testuali liberamente modificabili.
-2. **Conversione crudo/cotto** — calcolo del peso cotto a partire dal peso crudo (e viceversa) tramite coefficienti di resa definiti in un asset JSON interno.
-3. **Lista della spesa** — checklist con aggiunta, spunta e rimozione elementi.
-
----
-
-## Stack tecnologico
-
-| Livello | Scelta |
-|---|---|
-| Framework | Flutter (Dart) |
-| Stato | Provider o Riverpod |
-| Persistenza | shared_preferences |
-| UI | Material 3, mobile-first |
-| Build APK | Docker (container build) |
-| Sviluppo | Docker + noVNC (container dev con GUI) |
-
----
-
-## Struttura progetto
-
-```
-lib/
-├── main.dart
-├── app.dart                    # MaterialApp, routing, BottomNavigationBar
-├── pages/
-│   ├── meal_planner_page.dart
-│   ├── converter_page.dart
-│   └── shopping_list_page.dart
-├── widgets/
-│   ├── meal_card.dart          # Accordion giorno
-│   └── checkbox_item.dart
-├── models/
-│   ├── meal_plan.dart
-│   └── shopping_item.dart
-├── services/
-│   ├── storage_service.dart    # Wrapper shared_preferences
-│   └── conversion_service.dart # rawToCooked / cookedToRaw
-└── data/
-    └── conversions.json        # Asset: 50+ alimenti × metodi cottura
-
-docker/
-├── dev/
-│   ├── Dockerfile              # Flutter SDK + Android SDK + Xvfb + noVNC
-│   └── docker-compose.yml      # Porta 6080 → noVNC, volume su ./
-├── build/
-│   ├── Dockerfile              # Flutter SDK + Android SDK headless
-│   └── build.sh                # flutter build apk --release + firma
-pubspec.yaml
-```
-
----
-
-## Container dev (noVNC)
-
-Il container di sviluppo espone un desktop virtuale via browser, utile per eseguire l'emulatore Android o Android Studio senza installare nulla sull'host.
-
-**Stack interno**: Ubuntu + Flutter SDK + Android SDK + Xvfb + noVNC + websockify.
-
-```bash
-# Avvio
-cd docker/dev
-docker compose up
-
-# Accesso GUI
-# → http://localhost:6080 (noVNC, nessuna password)
-```
-
-Il volume mappa `./` (root del progetto) in `/workspace` nel container, quindi le modifiche ai file sono bidirezionali in tempo reale.
-
-**Workflow nel container**:
-1. Aprire un terminale nel desktop noVNC
-2. `cd /workspace && flutter pub get`
-3. Avviare l'emulatore o collegare device via ADB
-4. `flutter run`
-
----
-
-## Container build (APK)
-
-Build headless riproducibile, senza GUI.
-
-```bash
-# Debug
-bash docker/build/build.sh
-
-# Release firmato
-bash docker/build/build.sh --release
-```
-
-Pipeline interna:
-1. `flutter pub get`
-2. `flutter build apk --release` → `build/app/outputs/flutter-apk/app-release.apk`
-3. Firma con `apksigner` (keystore montato come volume o secret)
-4. `zipalign`
-
-L'APK firmato viene copiato in `dist/` nella root del progetto.
-
----
-
-## Modello dati
-
-**Meal Plan**
-```dart
-class MealPlan {
-  final Map<String, DayPlan> days; // 'lunedi' … 'domenica'
-}
-
-class DayPlan {
-  final List<String> colazione;
-  final List<String> pranzo;
-  final List<String> cena;
-}
-```
-
-**Shopping Item**
-```dart
-class ShoppingItem {
-  final String id;
-  final String name;
-  bool checked;
-}
-```
-
----
-
-## Conversione crudo/cotto
-
-**Asset** — `lib/data/conversions.json`
-```json
-{
-  "pollo": { "forno": { "yield": 0.75 }, "padella": { "yield": 0.70 } },
-  "riso basmati": { "bollitura": { "yield": 3.00 } }
-}
-```
-
-`yield = peso_cotto / peso_crudo`
-
-**Service** — `lib/services/conversion_service.dart`
-```dart
-double rawToCooked(double raw, double yield) => raw * yield;
-double cookedToRaw(double cooked, double yield) => cooked / yield;
-```
-
-UX: ricerca testuale → selezione alimento + metodo → input grammi → risultato in tempo reale.
-
----
-
-## Persistenza
-
-`StorageService` wrappa `shared_preferences`:
-- Meal plan serializzato come JSON stringa sotto chiave `meals`
-- Lista spesa serializzata come JSON stringa sotto chiave `shopping_list`
-
----
-
-## UI
-
-- `BottomNavigationBar` con 3 tab: Pasti | Converti | Spesa
-- Material 3, `ColorScheme.fromSeed(seedColor: Color(0xFF2d6a4f))`
-- Target touch minimo 48×48 dp (Material baseline)
-- Orientamento bloccato in portrait (`SystemChrome.setPreferredOrientations`)
-
----
-
-## Fasi future
-
-- Modifica coefficienti di conversione in-app
-- Calcolo kcal
-- Condivisione piano via QR code
-- Sync cloud

test/app_test.dart

@@ -0,0 +1,80 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:provider/provider.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:biteplan/app.dart';
+import 'package:biteplan/core/constants/app_constants.dart';
+import 'package:biteplan/features/converter/providers/converter_provider.dart';
+import 'package:biteplan/features/meal_planner/providers/meal_planner_provider.dart';
+import 'package:biteplan/features/shopping_list/providers/shopping_list_provider.dart';
+
+late MealPlannerProvider _meals;
+late ConverterProvider _converter;
+late ShoppingListProvider _shopping;
+
+Future<void> _pumpApp(WidgetTester tester) async {
+  await tester.binding.setSurfaceSize(const Size(800, 1600));
+  addTearDown(() => tester.binding.setSurfaceSize(null));
+  await tester.pumpWidget(
+    MultiProvider(
+      providers: [
+        ChangeNotifierProvider.value(value: _meals),
+        ChangeNotifierProvider.value(value: _converter),
+        ChangeNotifierProvider.value(value: _shopping),
+      ],
+      child: const BitePlanApp(),
+    ),
+  );
+  await tester.pumpAndSettle();
+}
+
+Finder _appBarTitle(String text) => find.descendant(
+    of: find.byType(AppBar), matching: find.text(text));
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  // I provider sono creati e caricati nel setUp (fuori dalla zona FakeAsync
+  // di testWidgets): il caricamento async dentro il body può bloccare la suite.
+  setUp(() async {
+    SharedPreferences.setMockInitialValues({});
+    _meals = MealPlannerProvider();
+    _converter = ConverterProvider();
+    _shopping = ShoppingListProvider();
+    await _meals.load();
+    await _converter.loadDb();
+    await _shopping.load();
+  });
+
+  group('BitePlanApp', () {
+    testWidgets('parte sul tab Piano Pasti', (tester) async {
+      await _pumpApp(tester);
+      expect(_appBarTitle('Piano Pasti'), findsOneWidget);
+      expect(find.byType(NavigationBar), findsOneWidget);
+    });
+
+    testWidgets('naviga al tab Convertitore', (tester) async {
+      await _pumpApp(tester);
+      await tester.tap(find.text('Converti'));
+      await tester.pumpAndSettle();
+      expect(_appBarTitle('Convertitore'), findsOneWidget);
+      expect(find.text('Cerca un alimento per iniziare'), findsOneWidget);
+    });
+
+    testWidgets('naviga al tab Lista della spesa', (tester) async {
+      await _pumpApp(tester);
+      await tester.tap(find.text('Spesa'));
+      await tester.pumpAndSettle();
+      expect(_appBarTitle('Lista della spesa'), findsOneWidget);
+      expect(find.text('Lista vuota'), findsOneWidget);
+    });
+
+    testWidgets('il bottone info apre il bottom sheet informazioni',
+        (tester) async {
+      await _pumpApp(tester);
+      await tester.tap(find.byIcon(Icons.info_outline));
+      await tester.pumpAndSettle();
+      expect(find.text('Versione $kAppVersion'), findsOneWidget);
+    });
+  });
+}

test/coverage_helper_test.dart

@@ -0,0 +1,35 @@
+// Importa tutti i file di lib/ così il report di coverage include anche
+// i file non toccati da alcun test (altrimenti lcov li ignora del tutto).
+// ignore_for_file: unused_import
+import 'package:biteplan/app.dart';
+import 'package:biteplan/core/constants/app_constants.dart';
+import 'package:biteplan/core/theme/app_theme.dart';
+import 'package:biteplan/features/converter/models/conversion_entry.dart';
+import 'package:biteplan/features/converter/presentation/pages/converter_page.dart';
+import 'package:biteplan/features/converter/providers/converter_provider.dart';
+import 'package:biteplan/features/guide/presentation/pages/guide_page.dart';
+import 'package:biteplan/features/guide/presentation/widgets/info_bottom_sheet.dart';
+import 'package:biteplan/features/meal_planner/models/meal_plan.dart';
+import 'package:biteplan/features/meal_planner/presentation/pages/meal_planner_page.dart';
+import 'package:biteplan/features/meal_planner/presentation/pages/qr_scan_page.dart';
+import 'package:biteplan/features/meal_planner/presentation/widgets/meal_card.dart';
+import 'package:biteplan/features/meal_planner/presentation/widgets/qr_share_sheet.dart';
+import 'package:biteplan/features/meal_planner/providers/meal_planner_provider.dart';
+import 'package:biteplan/features/meal_planner/qr_codec.dart';
+import 'package:biteplan/features/shopping_list/models/shopping_item.dart';
+import 'package:biteplan/features/shopping_list/presentation/pages/shopping_list_page.dart';
+import 'package:biteplan/features/shopping_list/presentation/widgets/shopping_item_tile.dart';
+import 'package:biteplan/features/shopping_list/providers/shopping_list_provider.dart';
+import 'package:biteplan/main.dart';
+import 'package:biteplan/shared/services/storage_service.dart';
+import 'package:biteplan/shared/services/update_service.dart';
+import 'package:biteplan/shared/services/url_launcher_service.dart';
+import 'package:biteplan/shared/widgets/empty_state.dart';
+import 'package:biteplan/shared/widgets/update_dialog.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  test('coverage helper', () {
+    expect(true, isTrue);
+  });
+}

test/features/converter/pages/converter_page_test.dart

@@ -0,0 +1,104 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:provider/provider.dart';
+import 'package:biteplan/features/converter/models/conversion_entry.dart';
+import 'package:biteplan/features/converter/presentation/pages/converter_page.dart';
+import 'package:biteplan/features/converter/providers/converter_provider.dart';
+import '../../../helpers/pump_app.dart';
+
+Widget _page(ConverterProvider provider) => ChangeNotifierProvider.value(
+      value: provider,
+      child: const Scaffold(body: ConverterPage()),
+    );
+
+const _riso =
+    ConversionEntry(food: 'riso', method: 'bollitura', yieldFactor: 3.0);
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+  late ConverterProvider provider;
+
+  // loadDb nel setUp (fuori dalla zona FakeAsync di testWidgets):
+  // caricarlo dentro il body del test può bloccare la suite.
+  setUp(() async {
+    provider = ConverterProvider();
+    await provider.loadDb();
+  });
+
+  group('ConverterPage — ricerca', () {
+    testWidgets('mostra lo stato vuoto iniziale', (tester) async {
+      await tester.pumpApp(_page(provider));
+      expect(find.text('Cerca un alimento per iniziare'), findsOneWidget);
+    });
+
+    testWidgets('la ricerca mostra risultati dal database', (tester) async {
+      await tester.pumpApp(_page(provider));
+      await tester.enterText(find.byType(TextField), 'riso');
+      await tester.pump();
+      expect(find.byType(ListTile), findsWidgets);
+    });
+
+    testWidgets('ricerca senza corrispondenze mostra "Nessun risultato"',
+        (tester) async {
+      await tester.pumpApp(_page(provider));
+      await tester.enterText(find.byType(TextField), 'xyzabc');
+      await tester.pump();
+      expect(find.text('Nessun risultato'), findsOneWidget);
+    });
+
+    testWidgets('tap su un risultato apre la card di conversione',
+        (tester) async {
+      await tester.pumpApp(_page(provider));
+      await tester.enterText(find.byType(TextField), 'riso');
+      await tester.pump();
+      await tester.tap(find.byType(ListTile).first);
+      await tester.pump();
+      expect(find.text('Cambia'), findsOneWidget);
+      expect(find.text('CRUDO'), findsOneWidget);
+      expect(find.text('COTTO'), findsOneWidget);
+    });
+  });
+
+  group('ConverterPage — card di conversione', () {
+    testWidgets('calcola e mostra il risultato formattato', (tester) async {
+      provider.select(_riso);
+      await tester.pumpApp(_page(provider));
+      await tester.enterText(find.byType(TextField), '100');
+      await tester.pump();
+      // 100 * 3.0 = 300, intero → senza decimali
+      expect(find.text('300'), findsOneWidget);
+      expect(find.textContaining('fattore di resa 3.0'), findsOneWidget);
+    });
+
+    testWidgets('input non numerico mostra il placeholder —', (tester) async {
+      provider.select(_riso);
+      await tester.pumpApp(_page(provider));
+      await tester.enterText(find.byType(TextField), 'abc');
+      await tester.pump();
+      expect(find.text('—'), findsOneWidget);
+    });
+
+    testWidgets('swap inverte la direzione e azzera il risultato',
+        (tester) async {
+      provider.select(_riso);
+      await tester.pumpApp(_page(provider));
+      await tester.enterText(find.byType(TextField), '100');
+      await tester.pump();
+      expect(find.text('300'), findsOneWidget);
+
+      await tester.tap(find.byIcon(Icons.swap_horiz));
+      await tester.pump();
+      expect(provider.rawToCooked, isFalse);
+      expect(find.text('300'), findsNothing);
+    });
+
+    testWidgets('"Cambia" torna alla ricerca', (tester) async {
+      provider.select(_riso);
+      await tester.pumpApp(_page(provider));
+      await tester.tap(find.text('Cambia'));
+      await tester.pump();
+      expect(find.text('Cerca un alimento per iniziare'), findsOneWidget);
+      expect(provider.selected, isNull);
+    });
+  });
+}

test/features/converter/providers/converter_provider_test.dart

@@ -1,8 +1,12 @@
+import 'dart:convert';
+
+import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:biteplan/features/converter/providers/converter_provider.dart';
 import 'package:biteplan/features/converter/models/conversion_entry.dart';
 
 void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
   group('ConverterProvider', () {
     late ConverterProvider provider;
 
@@ -187,5 +191,45 @@ void main() {
         expect(notified, true);
       });
     });
+
+    group('loadDb()', () {
+      test('carica il database e la ricerca trova alimenti noti', () async {
+        await provider.loadDb();
+        provider.search('riso');
+        expect(provider.results, isNotEmpty);
+        provider.search('pollo');
+        expect(provider.results, isNotEmpty);
+      });
+
+      test('la ricerca è case-insensitive', () async {
+        await provider.loadDb();
+        provider.search('RISO');
+        expect(provider.results, isNotEmpty);
+      });
+
+      test('notifica i listener', () async {
+        var notified = false;
+        provider.addListener(() => notified = true);
+        await provider.loadDb();
+        expect(notified, true);
+      });
+    });
+  });
+
+  group('conversions.json', () {
+    test('ogni metodo di ogni alimento ha uno yield positivo', () async {
+      final raw =
+          await rootBundle.loadString('assets/data/conversions.json');
+      final json = jsonDecode(raw) as Map<String, dynamic>;
+      expect(json, isNotEmpty);
+      json.forEach((food, methods) {
+        (methods as Map).forEach((method, data) {
+          final yield_ = (data as Map)['yield'];
+          expect(yield_, isA<num>(), reason: '$food/$method');
+          expect((yield_ as num).toDouble(), greaterThan(0),
+              reason: '$food/$method');
+        });
+      });
+    });
   });
 }

test/features/guide/pages/guide_page_test.dart

@@ -0,0 +1,37 @@
+import 'package:flutter_test/flutter_test.dart';
+import 'package:biteplan/features/guide/presentation/pages/guide_page.dart';
+import '../../../helpers/pump_app.dart';
+
+void main() {
+  group('GuidePage', () {
+    testWidgets('mostra titolo e le tre tab', (tester) async {
+      await tester.pumpApp(const GuidePage());
+      expect(find.text('Guida'), findsOneWidget);
+      expect(find.text('Pasti'), findsOneWidget);
+      expect(find.text('Converti'), findsOneWidget);
+      expect(find.text('Spesa'), findsOneWidget);
+    });
+
+    // _DocCard rende i titoli con toUpperCase()
+    testWidgets('la tab iniziale è Pasti', (tester) async {
+      await tester.pumpApp(const GuidePage());
+      expect(find.text('AGGIUNGERE UN ALIMENTO'), findsOneWidget);
+    });
+
+    testWidgets('la tab Converti mostra i suoi contenuti', (tester) async {
+      await tester.pumpApp(const GuidePage());
+      await tester.tap(find.text('Converti'));
+      await tester.pumpAndSettle();
+      expect(find.text('COME USARLO'), findsOneWidget);
+      expect(find.text('ALIMENTI DISPONIBILI'), findsOneWidget);
+    });
+
+    testWidgets('la tab Spesa mostra i suoi contenuti', (tester) async {
+      await tester.pumpApp(const GuidePage());
+      await tester.tap(find.text('Spesa'));
+      await tester.pumpAndSettle();
+      expect(find.text('AGGIUNGERE UN ELEMENTO'), findsOneWidget);
+      expect(find.text('SPUNTARE UN ELEMENTO'), findsOneWidget);
+    });
+  });
+}

test/features/guide/widgets/info_bottom_sheet_test.dart

@@ -0,0 +1,41 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:biteplan/core/constants/app_constants.dart';
+import 'package:biteplan/features/guide/presentation/widgets/info_bottom_sheet.dart';
+import '../../../helpers/pump_app.dart';
+
+Future<void> _openSheet(WidgetTester tester) async {
+  await tester.pumpApp(Scaffold(
+    body: Builder(
+      builder: (context) => Center(
+        child: FilledButton(
+          onPressed: () => showInfoBottomSheet(context),
+          child: const Text('apri'),
+        ),
+      ),
+    ),
+  ));
+  await tester.tap(find.text('apri'));
+  await tester.pumpAndSettle();
+}
+
+void main() {
+  group('InfoBottomSheet', () {
+    testWidgets('mostra nome app, versione, autore e licenza',
+        (tester) async {
+      await _openSheet(tester);
+      expect(find.text('BitePlan'), findsOneWidget);
+      expect(find.text('Versione $kAppVersion'), findsOneWidget);
+      expect(find.text('Autore'), findsOneWidget);
+      expect(find.text('Licenza'), findsOneWidget);
+    });
+
+    testWidgets('"Apri" sulla riga Guida naviga alla GuidePage',
+        (tester) async {
+      await _openSheet(tester);
+      await tester.tap(find.text('Apri'));
+      await tester.pumpAndSettle();
+      expect(find.text('AGGIUNGERE UN ALIMENTO'), findsOneWidget);
+    });
+  });
+}

test/features/meal_planner/pages/meal_planner_page_test.dart

@@ -0,0 +1,134 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:provider/provider.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:biteplan/features/meal_planner/presentation/pages/meal_planner_page.dart';
+import 'package:biteplan/features/meal_planner/presentation/widgets/meal_card.dart';
+import 'package:biteplan/features/meal_planner/providers/meal_planner_provider.dart';
+import 'package:biteplan/features/shopping_list/providers/shopping_list_provider.dart';
+import '../../../helpers/pump_app.dart';
+
+Widget _page({
+  required MealPlannerProvider meals,
+  required ShoppingListProvider shopping,
+  VoidCallback? onGoShopping,
+}) =>
+    MultiProvider(
+      providers: [
+        ChangeNotifierProvider.value(value: meals),
+        ChangeNotifierProvider.value(value: shopping),
+      ],
+      child: Scaffold(
+        body: MealPlannerPage(onGoShopping: onGoShopping ?? () {}),
+      ),
+    );
+
+String get _todayId {
+  const ids = [
+    '',
+    'lunedi',
+    'martedi',
+    'mercoledi',
+    'giovedi',
+    'venerdi',
+    'sabato',
+    'domenica',
+  ];
+  return ids[DateTime.now().weekday];
+}
+
+void main() {
+  late MealPlannerProvider meals;
+  late ShoppingListProvider shopping;
+
+  setUp(() async {
+    SharedPreferences.setMockInitialValues({});
+    meals = MealPlannerProvider();
+    shopping = ShoppingListProvider();
+    await meals.load();
+    await shopping.load();
+  });
+
+  Future<void> pumpPage(WidgetTester tester, {VoidCallback? onGoShopping}) async {
+    await tester.binding.setSurfaceSize(const Size(800, 1800));
+    addTearDown(() => tester.binding.setSurfaceSize(null));
+    await tester.pumpApp(
+        _page(meals: meals, shopping: shopping, onGoShopping: onGoShopping));
+  }
+
+  group('MealPlannerPage', () {
+    testWidgets('mostra le 7 card dei giorni', (tester) async {
+      await pumpPage(tester);
+      expect(find.byType(MealCard), findsNWidgets(7));
+    });
+
+    testWidgets('solo la card di oggi è inizialmente espansa', (tester) async {
+      await pumpPage(tester);
+      for (final card in
+          tester.widgetList<MealCard>(find.byType(MealCard))) {
+        expect(card.initiallyExpanded, card.dayId == _todayId,
+            reason: card.dayId);
+      }
+    });
+
+    testWidgets('"Condividi" è disabilitato con piano vuoto', (tester) async {
+      await pumpPage(tester);
+      final button = tester.widget<OutlinedButton>(
+          find.widgetWithText(OutlinedButton, 'Condividi'));
+      expect(button.onPressed, isNull);
+    });
+
+    testWidgets('"Condividi" è abilitato con almeno un pasto', (tester) async {
+      meals.addItem('lunedi', 'pranzo', 'pasta');
+      await pumpPage(tester);
+      final button = tester.widget<OutlinedButton>(
+          find.widgetWithText(OutlinedButton, 'Condividi'));
+      expect(button.onPressed, isNotNull);
+    });
+
+    testWidgets('"Svuota piano" appare solo con pasti presenti',
+        (tester) async {
+      await pumpPage(tester);
+      expect(find.text('Svuota piano'), findsNothing);
+
+      meals.addItem('lunedi', 'pranzo', 'pasta');
+      await tester.pump();
+      expect(find.text('Svuota piano'), findsOneWidget);
+    });
+
+    testWidgets('"Genera lista" popola la spesa e chiama onGoShopping',
+        (tester) async {
+      meals.addItem('lunedi', 'pranzo', 'pasta');
+      meals.addItem('martedi', 'cena', 'pollo');
+      var navigated = false;
+      await pumpPage(tester, onGoShopping: () => navigated = true);
+
+      await tester.tap(find.text('Genera lista della spesa'));
+      await tester.pump();
+
+      expect(navigated, isTrue);
+      expect(shopping.items.map((i) => i.name),
+          containsAll(['pasta', 'pollo']));
+    });
+
+    testWidgets('"Svuota piano" con Annulla mantiene i pasti', (tester) async {
+      meals.addItem('lunedi', 'pranzo', 'pasta');
+      await pumpPage(tester);
+      await tester.tap(find.widgetWithText(OutlinedButton, 'Svuota piano'));
+      await tester.pumpAndSettle();
+      await tester.tap(find.text('Annulla'));
+      await tester.pumpAndSettle();
+      expect(meals.plan.hasAnyMeal, isTrue);
+    });
+
+    testWidgets('"Svuota piano" con Svuota azzera il piano', (tester) async {
+      meals.addItem('lunedi', 'pranzo', 'pasta');
+      await pumpPage(tester);
+      await tester.tap(find.widgetWithText(OutlinedButton, 'Svuota piano'));
+      await tester.pumpAndSettle();
+      await tester.tap(find.text('Svuota'));
+      await tester.pumpAndSettle();
+      expect(meals.plan.hasAnyMeal, isFalse);
+    });
+  });
+}

test/features/meal_planner/providers/meal_planner_provider_test.dart

@@ -60,6 +60,24 @@ void main() {
       expect(provider.plan.days['lunedi']!.pranzo, ['pasta', 'frutta']);
     });
 
+    test('removeItem rimuove dallo slot colazione', () async {
+      final provider = MealPlannerProvider();
+      await provider.load();
+      provider.addItem('lunedi', 'colazione', 'latte');
+      provider.addItem('lunedi', 'colazione', 'caffè');
+      provider.removeItem('lunedi', 'colazione', 0);
+      expect(provider.plan.days['lunedi']!.colazione, ['caffè']);
+    });
+
+    test('removeItem rimuove dallo slot cena', () async {
+      final provider = MealPlannerProvider();
+      await provider.load();
+      provider.addItem('lunedi', 'cena', 'pollo');
+      provider.addItem('lunedi', 'cena', 'verdure');
+      provider.removeItem('lunedi', 'cena', 1);
+      expect(provider.plan.days['lunedi']!.cena, ['pollo']);
+    });
+
     test('clearAll svuota tutti i giorni', () async {
       final provider = MealPlannerProvider();
       await provider.load();

test/features/meal_planner/widgets/qr_share_sheet_test.dart

@@ -0,0 +1,66 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:qr_flutter/qr_flutter.dart';
+import 'package:biteplan/core/constants/app_constants.dart';
+import 'package:biteplan/features/meal_planner/models/meal_plan.dart';
+import 'package:biteplan/features/meal_planner/presentation/widgets/qr_share_sheet.dart';
+import '../../../helpers/pump_app.dart';
+
+MealPlan _planWith(Map<String, DayPlan> overrides) => MealPlan({
+      ...Map.fromEntries(kDayIds.map((d) => MapEntry(d, DayPlan()))),
+      ...overrides,
+    });
+
+Future<void> _openSheet(WidgetTester tester, MealPlan plan) async {
+  await tester.pumpApp(Scaffold(
+    body: Builder(
+      builder: (context) => Center(
+        child: FilledButton(
+          onPressed: () => showQrShareSheet(context, plan),
+          child: const Text('apri'),
+        ),
+      ),
+    ),
+  ));
+  await tester.tap(find.text('apri'));
+  await tester.pumpAndSettle();
+}
+
+void main() {
+  group('QrShareSheet', () {
+    testWidgets('piano valido mostra il QR code', (tester) async {
+      final plan = _planWith({
+        'lunedi': DayPlan(pranzo: ['pasta'])
+      });
+      await _openSheet(tester, plan);
+      expect(find.text('Condividi piano'), findsOneWidget);
+      expect(find.byType(QrImageView), findsOneWidget);
+    });
+
+    testWidgets('piano troppo grande mostra il messaggio di errore',
+        (tester) async {
+      final plan = _planWith({
+        for (final d in kDayIds)
+          d: DayPlan(
+            colazione: List.generate(
+                30, (i) => 'alimento molto lungo numero $i della colazione'),
+            pranzo: List.generate(
+                30, (i) => 'alimento molto lungo numero $i del pranzo'),
+          ),
+      });
+      await _openSheet(tester, plan);
+      expect(find.textContaining('Dati troppo grandi'), findsOneWidget);
+      expect(find.byType(QrImageView), findsNothing);
+    });
+
+    testWidgets('il pulsante chiudi fa scomparire il foglio', (tester) async {
+      final plan = _planWith({
+        'lunedi': DayPlan(pranzo: ['pasta'])
+      });
+      await _openSheet(tester, plan);
+      await tester.tap(find.byIcon(Icons.close));
+      await tester.pumpAndSettle();
+      expect(find.text('Condividi piano'), findsNothing);
+    });
+  });
+}

test/features/shopping_list/pages/shopping_list_page_test.dart

@@ -0,0 +1,108 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:provider/provider.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:biteplan/features/shopping_list/presentation/pages/shopping_list_page.dart';
+import 'package:biteplan/features/shopping_list/providers/shopping_list_provider.dart';
+import '../../../helpers/pump_app.dart';
+
+Widget _page(ShoppingListProvider provider) => ChangeNotifierProvider.value(
+      value: provider,
+      child: const Scaffold(body: ShoppingListPage()),
+    );
+
+void main() {
+  late ShoppingListProvider provider;
+
+  setUp(() async {
+    SharedPreferences.setMockInitialValues({});
+    provider = ShoppingListProvider();
+    await provider.load();
+  });
+
+  group('ShoppingListPage', () {
+    testWidgets('lista vuota mostra EmptyState', (tester) async {
+      await tester.pumpApp(_page(provider));
+      expect(find.text('Lista vuota'), findsOneWidget);
+    });
+
+    testWidgets('aggiunge un elemento con il pulsante +', (tester) async {
+      await tester.pumpApp(_page(provider));
+      await tester.enterText(find.byType(TextField), 'pane');
+      await tester.tap(find.byIcon(Icons.add));
+      await tester.pump();
+      expect(find.text('pane'), findsOneWidget);
+      expect(provider.items, hasLength(1));
+    });
+
+    testWidgets('aggiunge un elemento con Invio', (tester) async {
+      await tester.pumpApp(_page(provider));
+      await tester.enterText(find.byType(TextField), 'latte');
+      await tester.testTextInput.receiveAction(TextInputAction.done);
+      await tester.pump();
+      expect(find.text('latte'), findsOneWidget);
+    });
+
+    testWidgets('testo vuoto o solo spazi non aggiunge nulla', (tester) async {
+      await tester.pumpApp(_page(provider));
+      await tester.enterText(find.byType(TextField), '   ');
+      await tester.tap(find.byIcon(Icons.add));
+      await tester.pump();
+      expect(find.text('Lista vuota'), findsOneWidget);
+      expect(provider.items, isEmpty);
+    });
+
+    testWidgets('il contatore usa il singolare con 1 completato',
+        (tester) async {
+      provider.add('pane');
+      provider.add('latte');
+      provider.toggle(provider.items.first.id);
+      await tester.pumpApp(_page(provider));
+      expect(find.text('1 / 2 completato'), findsOneWidget);
+    });
+
+    testWidgets('il contatore usa il plurale con più completati',
+        (tester) async {
+      provider.add('pane');
+      provider.add('latte');
+      for (final item in [...provider.items]) {
+        provider.toggle(item.id);
+      }
+      await tester.pumpApp(_page(provider));
+      expect(find.text('2 / 2 completati'), findsOneWidget);
+    });
+
+    testWidgets('la sezione COMPLETATI appare solo con elementi spuntati',
+        (tester) async {
+      provider.add('pane');
+      await tester.pumpApp(_page(provider));
+      expect(find.textContaining('COMPLETATI'), findsNothing);
+
+      provider.toggle(provider.items.first.id);
+      await tester.pump();
+      expect(find.text('COMPLETATI (1)'), findsOneWidget);
+    });
+
+    testWidgets('"Svuota lista" con Annulla non svuota', (tester) async {
+      provider.add('pane');
+      await tester.pumpApp(_page(provider));
+      await tester.tap(find.widgetWithText(OutlinedButton, 'Svuota lista'));
+      await tester.pumpAndSettle();
+      await tester.tap(find.text('Annulla'));
+      await tester.pumpAndSettle();
+      expect(provider.items, hasLength(1));
+      expect(find.text('pane'), findsOneWidget);
+    });
+
+    testWidgets('"Svuota lista" con Svuota svuota tutto', (tester) async {
+      provider.add('pane');
+      await tester.pumpApp(_page(provider));
+      await tester.tap(find.widgetWithText(OutlinedButton, 'Svuota lista'));
+      await tester.pumpAndSettle();
+      await tester.tap(find.text('Svuota'));
+      await tester.pumpAndSettle();
+      expect(provider.items, isEmpty);
+      expect(find.text('Lista vuota'), findsOneWidget);
+    });
+  });
+}

test/shared/services/update_service_test.dart

@@ -1,7 +1,50 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:io';
+
 import 'package:flutter_test/flutter_test.dart';
+import 'package:biteplan/core/constants/app_constants.dart';
 import 'package:biteplan/shared/services/update_service.dart';
 
 void main() {
+  group('UpdateService.checkUpdate', () {
+    tearDown(() => HttpOverrides.global = null);
+
+    test('ritorna la versione quando il tag remoto è più recente', () async {
+      HttpOverrides.global =
+          _FakeHttpOverrides(body: '{"tag_name":"v99.0.0"}');
+      expect(await UpdateService.checkUpdate(), '99.0.0');
+    });
+
+    test('ritorna null quando il tag remoto è uguale alla versione corrente',
+        () async {
+      HttpOverrides.global =
+          _FakeHttpOverrides(body: '{"tag_name":"v$kAppVersion"}');
+      expect(await UpdateService.checkUpdate(), isNull);
+    });
+
+    test('ritorna null quando il tag remoto è più vecchio', () async {
+      HttpOverrides.global = _FakeHttpOverrides(body: '{"tag_name":"v0.0.1"}');
+      expect(await UpdateService.checkUpdate(), isNull);
+    });
+
+    test('ritorna null con status diverso da 200', () async {
+      HttpOverrides.global = _FakeHttpOverrides(
+          statusCode: 404, body: '{"message":"Not Found"}');
+      expect(await UpdateService.checkUpdate(), isNull);
+    });
+
+    test('ritorna null con body malformato', () async {
+      HttpOverrides.global = _FakeHttpOverrides(body: 'non json');
+      expect(await UpdateService.checkUpdate(), isNull);
+    });
+
+    test('ritorna null se la connessione fallisce', () async {
+      HttpOverrides.global = _FakeHttpOverrides(fail: true);
+      expect(await UpdateService.checkUpdate(), isNull);
+    });
+  });
+
   group('UpdateService.parseTagName', () {
     test('strips v prefix from tag_name', () {
       expect(UpdateService.parseTagName('{"tag_name":"v2.1.0"}'), '2.1.0');
@@ -71,3 +114,66 @@ void main() {
     });
   });
 }
+
+// ── Fake HTTP per checkUpdate ────────────────────────────────────────────────
+
+class _FakeHttpOverrides extends HttpOverrides {
+  _FakeHttpOverrides({this.statusCode = 200, this.body = '', this.fail = false});
+  final int statusCode;
+  final String body;
+  final bool fail;
+
+  @override
+  HttpClient createHttpClient(SecurityContext? context) =>
+      _FakeHttpClient(statusCode: statusCode, body: body, fail: fail);
+}
+
+class _FakeHttpClient extends Fake implements HttpClient {
+  _FakeHttpClient(
+      {required this.statusCode, required this.body, required this.fail});
+  final int statusCode;
+  final String body;
+  final bool fail;
+
+  @override
+  set connectionTimeout(Duration? value) {}
+
+  @override
+  Future<HttpClientRequest> getUrl(Uri url) async {
+    if (fail) throw const SocketException('rete assente');
+    return _FakeHttpClientRequest(statusCode: statusCode, body: body);
+  }
+
+  @override
+  void close({bool force = false}) {}
+}
+
+class _FakeHttpClientRequest extends Fake implements HttpClientRequest {
+  _FakeHttpClientRequest({required this.statusCode, required this.body});
+  final int statusCode;
+  final String body;
+
+  @override
+  HttpHeaders get headers => _FakeHttpHeaders();
+
+  @override
+  Future<HttpClientResponse> close() async =>
+      _FakeHttpClientResponse(statusCode: statusCode, body: body);
+}
+
+class _FakeHttpHeaders extends Fake implements HttpHeaders {
+  @override
+  void set(String name, Object value, {bool preserveHeaderCase = false}) {}
+}
+
+class _FakeHttpClientResponse extends Fake implements HttpClientResponse {
+  _FakeHttpClientResponse({required this.statusCode, required this.body});
+
+  @override
+  final int statusCode;
+  final String body;
+
+  @override
+  Stream<S> transform<S>(StreamTransformer<List<int>, S> streamTransformer) =>
+      Stream<List<int>>.value(utf8.encode(body)).transform(streamTransformer);
+}

test/shared/widgets/empty_state_test.dart

@@ -0,0 +1,34 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:biteplan/shared/widgets/empty_state.dart';
+import '../../helpers/pump_app.dart';
+
+void main() {
+  group('EmptyState', () {
+    testWidgets('mostra icona e titolo', (tester) async {
+      await tester.pumpApp(const Scaffold(
+        body: EmptyState(icon: Icons.search, title: 'Nessun elemento'),
+      ));
+      expect(find.byIcon(Icons.search), findsOneWidget);
+      expect(find.text('Nessun elemento'), findsOneWidget);
+    });
+
+    testWidgets('mostra il sottotitolo quando presente', (tester) async {
+      await tester.pumpApp(const Scaffold(
+        body: EmptyState(
+          icon: Icons.search,
+          title: 'Titolo',
+          subtitle: 'Sottotitolo di prova',
+        ),
+      ));
+      expect(find.text('Sottotitolo di prova'), findsOneWidget);
+    });
+
+    testWidgets('nessun sottotitolo quando assente', (tester) async {
+      await tester.pumpApp(const Scaffold(
+        body: EmptyState(icon: Icons.search, title: 'Titolo'),
+      ));
+      expect(find.byType(Text), findsOneWidget);
+    });
+  });
+}