From c91c0f1fc9ac8f12f7dcb47a9fc220590f3d2fd9 Mon Sep 17 00:00:00 2001
From: Gilles Soulier <gil.soulier@gmail.com>
Date: Wed, 14 Jan 2026 07:03:38 +0100
Subject: [PATCH] codex

---
 .coverage                                     | Bin 53248 -> 53248 bytes
 .env.example                                  |  18 +
 .gitignore                                    |   0
 CHANGELOG.md                                  |  91 +++-
 PHASE_1_COMPLETE.md                           | 267 ++++++++++
 PHASE_2_PROGRESS.md                           | 437 +++++++++++++++++
 README.md                                     |  53 +-
 TODO.md                                       |  86 ++--
 alembic.ini                                   |  36 ++
 docker-compose.yml                            |  22 +
 pricewatch.egg-info/PKG-INFO                  |   7 +
 pricewatch.egg-info/SOURCES.txt               |   1 +
 pricewatch.egg-info/requires.txt              |   7 +
 .../app/cli/__pycache__/main.cpython-313.pyc  | Bin 15708 -> 20375 bytes
 pricewatch/app/cli/main.py                    | 157 ++++++
 .../core/__pycache__/config.cpython-313.pyc   | Bin 0 -> 7958 bytes
 pricewatch/app/core/config.py                 | 186 +++++++
 pricewatch/app/db/__init__.py                 |  41 ++
 .../db/__pycache__/__init__.cpython-313.pyc   | Bin 0 -> 813 bytes
 .../db/__pycache__/connection.cpython-313.pyc | Bin 0 -> 8087 bytes
 .../app/db/__pycache__/models.cpython-313.pyc | Bin 0 -> 12364 bytes
 .../db/__pycache__/repository.cpython-313.pyc | Bin 0 -> 7814 bytes
 pricewatch/app/db/connection.py               | 238 +++++++++
 .../__pycache__/env.cpython-313.pyc           | Bin 0 -> 2912 bytes
 pricewatch/app/db/migrations/env.py           |  80 +++
 pricewatch/app/db/migrations/script.py.mako   |  24 +
 .../versions/20260114_01_initial_schema.py    | 124 +++++
 ...20260114_01_initial_schema.cpython-313.pyc | Bin 0 -> 8818 bytes
 pricewatch/app/db/models.py                   | 320 ++++++++++++
 pricewatch/app/db/repository.py               | 140 ++++++
 pricewatch/app/scraping/__init__.py           |   3 +
 .../__pycache__/__init__.cpython-313.pyc      | Bin 160 -> 264 bytes
 .../__pycache__/pipeline.cpython-313.pyc      | Bin 0 -> 2779 bytes
 pricewatch/app/scraping/pipeline.py           |  52 ++
 .../amazon/__pycache__/store.cpython-313.pyc  | Bin 13238 -> 14223 bytes
 pricewatch/app/stores/amazon/store.py         |  20 +
 pricewatch/app/tasks/__init__.py              |   8 +
 pricewatch/app/tasks/scheduler.py             |  75 +++
 pricewatch/app/tasks/scrape.py                | 160 ++++++
 pyproject.toml                                |  13 +
 .../test_run_db.cpython-313-pytest-9.0.2.pyc  | Bin 0 -> 8336 bytes
 tests/cli/test_run_db.py                      | 106 ++++
 .../test_io.cpython-313-pytest-9.0.2.pyc      | Bin 0 -> 66626 bytes
 ...y_integration.cpython-313-pytest-9.0.2.pyc | Bin 0 -> 33442 bytes
 tests/core/test_io.py                         | 462 ++++++++++++++++++
 tests/core/test_registry_integration.py       | 174 +++++++
 ...st_connection.cpython-313-pytest-9.0.2.pyc | Bin 0 -> 9521 bytes
 .../test_models.cpython-313-pytest-9.0.2.pyc  | Bin 0 -> 8164 bytes
 ...st_repository.cpython-313-pytest-9.0.2.pyc | Bin 0 -> 12706 bytes
 tests/db/test_connection.py                   |  87 ++++
 tests/db/test_models.py                       |  89 ++++
 tests/db/test_repository.py                   |  82 ++++
 tests/scraping/__init__.py                    |   0
 .../__pycache__/__init__.cpython-313.pyc      | Bin 0 -> 151 bytes
 ...st_http_fetch.cpython-313-pytest-9.0.2.pyc | Bin 0 -> 49501 bytes
 ...test_pipeline.cpython-313-pytest-9.0.2.pyc | Bin 0 -> 7087 bytes
 ...test_pw_fetch.cpython-313-pytest-9.0.2.pyc | Bin 0 -> 44576 bytes
 tests/scraping/test_http_fetch.py             | 290 +++++++++++
 tests/scraping/test_pipeline.py               |  82 ++++
 tests/scraping/test_pw_fetch.py               | 388 +++++++++++++++
 .../test_amazon.cpython-313-pytest-9.0.2.pyc  | Bin 60925 -> 60794 bytes
 61 files changed, 4388 insertions(+), 38 deletions(-)
 create mode 100755 .env.example
 mode change 100644 => 100755 .gitignore
 create mode 100755 PHASE_1_COMPLETE.md
 create mode 100755 PHASE_2_PROGRESS.md
 create mode 100755 alembic.ini
 create mode 100755 docker-compose.yml
 create mode 100755 pricewatch/app/core/__pycache__/config.cpython-313.pyc
 create mode 100755 pricewatch/app/core/config.py
 create mode 100755 pricewatch/app/db/__init__.py
 create mode 100755 pricewatch/app/db/__pycache__/__init__.cpython-313.pyc
 create mode 100755 pricewatch/app/db/__pycache__/connection.cpython-313.pyc
 create mode 100755 pricewatch/app/db/__pycache__/models.cpython-313.pyc
 create mode 100755 pricewatch/app/db/__pycache__/repository.cpython-313.pyc
 create mode 100755 pricewatch/app/db/connection.py
 create mode 100755 pricewatch/app/db/migrations/__pycache__/env.cpython-313.pyc
 create mode 100755 pricewatch/app/db/migrations/env.py
 create mode 100755 pricewatch/app/db/migrations/script.py.mako
 create mode 100755 pricewatch/app/db/migrations/versions/20260114_01_initial_schema.py
 create mode 100755 pricewatch/app/db/migrations/versions/__pycache__/20260114_01_initial_schema.cpython-313.pyc
 create mode 100755 pricewatch/app/db/models.py
 create mode 100755 pricewatch/app/db/repository.py
 create mode 100755 pricewatch/app/scraping/__pycache__/pipeline.cpython-313.pyc
 create mode 100755 pricewatch/app/scraping/pipeline.py
 create mode 100755 pricewatch/app/tasks/__init__.py
 create mode 100755 pricewatch/app/tasks/scheduler.py
 create mode 100755 pricewatch/app/tasks/scrape.py
 create mode 100755 tests/cli/__pycache__/test_run_db.cpython-313-pytest-9.0.2.pyc
 create mode 100755 tests/cli/test_run_db.py
 create mode 100755 tests/core/__pycache__/test_io.cpython-313-pytest-9.0.2.pyc
 create mode 100755 tests/core/__pycache__/test_registry_integration.cpython-313-pytest-9.0.2.pyc
 create mode 100755 tests/core/test_io.py
 create mode 100755 tests/core/test_registry_integration.py
 create mode 100755 tests/db/__pycache__/test_connection.cpython-313-pytest-9.0.2.pyc
 create mode 100755 tests/db/__pycache__/test_models.cpython-313-pytest-9.0.2.pyc
 create mode 100755 tests/db/__pycache__/test_repository.cpython-313-pytest-9.0.2.pyc
 create mode 100755 tests/db/test_connection.py
 create mode 100755 tests/db/test_models.py
 create mode 100755 tests/db/test_repository.py
 create mode 100755 tests/scraping/__init__.py
 create mode 100755 tests/scraping/__pycache__/__init__.cpython-313.pyc
 create mode 100755 tests/scraping/__pycache__/test_http_fetch.cpython-313-pytest-9.0.2.pyc
 create mode 100755 tests/scraping/__pycache__/test_pipeline.cpython-313-pytest-9.0.2.pyc
 create mode 100755 tests/scraping/__pycache__/test_pw_fetch.cpython-313-pytest-9.0.2.pyc
 create mode 100755 tests/scraping/test_http_fetch.py
 create mode 100755 tests/scraping/test_pipeline.py
 create mode 100755 tests/scraping/test_pw_fetch.py

diff --git a/.coverage b/.coverage
index 5f7baa5d58734da5ed9d6d2597620a44bea44cf4..e2106b9cbfe7735ed707871ea76aa5bbb79d732f 100755
GIT binary patch
delta 1757
zcmZ9Mdu$X%9LHy$w|lcYv-iF}ga#5c6nX`kLb0?5BDCe&i%}8;j%zIkUTp6gAVuVH
z*J_MPdDzh)0d3<SnixZQM9~CFk)(<!iTVe~BVuASiY6c`&jf!nSZvw7?00|P-(z;?
zv$=e~lJ8gctI_IWV;`a?>2}&gedJrxOP(Ty_62*7y~HlGE?9f4q%{tIkKe$J*l-WJ
z*Sja1m&{&sp>fmLcgW*p47t9TB^On)I}LuRh<O$@N`(+NNCj|T$u2Dl%5`BDX{gsi
zD(Wg?PsFFQfrfzoco0I$Lr+V4%L~~|WbL}_np9cGhPnWhSF)<OSAWb8MVQTvRj~4y
zCHdH#*aFQv;(0pK9jUf-hBrOt8FAT>n58)oDbQCMSout3O{yciHVxA^K;dkvpp87^
zg-m;PWvXp0xV2=Yf!nRwOeWR3E}hLls@i798p|B8lgV@@y)K#LrUhoTJQuUZ_*}i#
zJ<`o?#2j|Cv7D7Q5p9;Cp!Iwys}<fXlFsr*mzX9DSY}mvHJCLz%R$d`O;pqFPx_$A
zk*id;GhSx5wxuKOEouHVH42p0u<h|qAUA;Mmvje>Q$P8REG9*S*?aAa)<tWt)ohK&
z=Wr8#6Pxza#w}yOea!v5$;>*t$X#mw2;{N`Td`~=VDm}E%vsh5@K!8q0C*0#fDHha
zEv?tWF%_sCPt4%dw9o<-ph4t304)f`GdVLYFkb~^#}iXod&~fASo8na#GQcV8=ZGX
zA@q(;07a~MqAE~4o|xi)kfQUbvXLh|qao6fa_){{NZ4Q^LdPPs!JDI5^VBYvc%e~r
z@yMWiI1>V=YE~)h`I`8DnueG=7N(1BNlXKlMAPq&0hW@+b|fR#D3mG`)*jlP>@2AW
z+k=SSq*v*$^nKb#yJ(Wu(^85lBIn76gpsXe6UmY|Sx9OLv9H;e?Lk2JvYjgptCG1S
z+&$2B&_Pi+k%Pn`BN-usN8sK2<@FF0laN#p1g)^-Gt-eeMaoO48No$?G9wazRCDm&
zJm}{?7{ref$Vd5&1P<Kf;mo0^?&m`TlJ4V*rEy-+8o!Jmxvbogc>S2;2KGQc?Ct*T
zRIq2f?LbiMlMj2*{+c1GQ$EAv4iV6Dr~6!L>#j402mj34_N^TLEU8SjA+emwXgPW-
z6+L)0H@u~-s4rYMT>0_qwbOR?Ong}HJ@C`3(#cN_Y}<DIi@u2#)YlOi{gar4@}Itw
zZ$LZWlT`HklR6qAli<nnC~IOU^4r~cNgn5h+Zt2e_4e1NJI{ZGHg0My_<VWdp}TjF
z*3R$gH;PTj&vwgGm40nP5TTrmr2H#?6QaEqmCX{r0qM!Qym||U-C4ORZ8ob&Dsh23
z&*(mX@Z#|4lo#dSJ%ul!lEql%I|Ca$t61k_U2?Sac8#K+y=^rQ_Y}++kC7K4HL7cn
zC7KjfHOcHks@!qx?k~HeXb4qTA}cT5xW1Y8&WKf=*gFU2ExB@;@A}Y-61w8z3k>oL
z()mTw6+TK~S9bU-!gML3x9MN>5Bf9x0scwO(r@SydV+4I&(e?RKKK;->2A7}_R^PV
zC(Y6px)eUT2{gx_RtkrOghE2BppaldNWd=y`-J$tLcAU!K1Ya$3UP=KY6~Hj5E~0I
f-9p@^5Zw@Bxb#B4yh|6MrU_A1A<Cg^eRlc3z#qVe

delta 1027
zcmZXST}TvB6oBu{-1)sTb9dKuQ`GXga$O@dYje#%*41@;Ec;n?Q(G{VG|hf=*B*Ka
z74Ab%k<v>Nq_l5^5m;DZLG(}%B)$Ya1V&Mqg`F8)S!-tCFy}kxo--elm=qF|!Yr=z
zd9)%#U(hkyKsocFIb@a_YsQ>$)u=KQeL)}950M|_E;&W0_Ea0xic(I;s>%mF>`ADU
z<%F`tY>bk5Y^re&TMEjoEtJjIyV-0oBxV69*aR--uh%&j<V)E|y<2o<Fc~t$8I8uf
z<NeX7w|A)80hHLC!wss@I~eU~?~k1YQcGE+p-wcn@r=%Z!3rCT*<#os9?%6e$fm+R
z7HJasa>6DeUL)2OFFw~A?}no)G<GynA^KGTjik3%+gkhDf%z5oG3@6nWGL}Ddd{~O
zclC63#=AR#1te>PD`sUgCfACvnUAf646Uyp7*qx^I0{Nf1lU$ik6;sF!p0&4;N6Sp
zOFC{08`b6|Lp2ZT&yC;uHQi5s(njLYo>AU>M5f7U<FR&8^MdzZDqB8YFL@eqGLPFj
z5R7x#Z01-<a))uUAPp?zgv$a@27a?7S0?;Vxw8f*$wn(E*E5tmSks9*iEif^A8xW;
zCw;bYqg)t-BQ}h4IvbA`>lwlci$nvWc32omuPE!AzEwN994_Y+C@P`bjmy>q=fA=w
z*sH|yt)_j8V5f}Dgk<(7L?m2=lk(OiOM7Z8I#B3QX)~g$^eg>L-_jJlNAJ)Jv>EJH
z(ve&hbLxJTf42|euH<zNwV(ut1XPJ~_9}py#nGAM0}nz9Jcaks#)aV(5<J2vfe;6G
zLXx4{#GE8qQQ&rp5Gxe^=B-z+2R<yK%U5E#3;Fr^>+5rYni~nlje+mpA@iNXB!LoV
zI^t>zMw}#A?GjrVcf;QEh_2D^^gVq8|IHWri7wH3*n67#tSOwT+Cfz8fMq)f_6D3H
P+HW$pgOvJq+wlDb5a=VK

diff --git a/.env.example b/.env.example
new file mode 100755
index 0000000..a89bb87
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,18 @@
+# Database
+PW_DB_HOST=localhost
+PW_DB_PORT=5432
+PW_DB_DATABASE=pricewatch
+PW_DB_USER=pricewatch
+PW_DB_PASSWORD=pricewatch
+
+# Redis
+PW_REDIS_HOST=localhost
+PW_REDIS_PORT=6379
+PW_REDIS_DB=0
+
+# App
+PW_DEBUG=false
+PW_WORKER_TIMEOUT=300
+PW_WORKER_CONCURRENCY=2
+PW_ENABLE_DB=true
+PW_ENABLE_WORKER=true
diff --git a/.gitignore b/.gitignore
old mode 100644
new mode 100755
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 685850a..90643a3 100755
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,9 +9,94 @@ Le format est basé sur [Keep a Changelog](https://keepachangelog.com/fr/1.0.0/)
 ## [Non publié]
 
 ### En cours
-- Ajout de fixtures HTML réalistes pour tests pytest
-- Tests stores/cdiscount/
-- Tests scraping/ avec mocks
+- Phase 2 : Base de données PostgreSQL
+- Phase 2 : Worker Redis/RQ
+- Phase 3 : API REST FastAPI
+- Phase 4 : Web UI
+
+### Ajouté
+- Configuration Alembic (env.py, script.py.mako, alembic.ini)
+- Migration initiale SQLAlchemy (5 tables + indexes)
+- Commandes CLI DB: `init-db`, `migrate`, `upgrade`, `downgrade`
+- `docker-compose.yml` PostgreSQL/Redis
+- `.env.example` avec variables DB/Redis/app
+- Tests DB de base (models + connection)
+- Repository `ProductRepository` + `ScrapingPipeline`
+- Flag CLI `--save-db/--no-db` pour la persistence
+- Tests repository/pipeline (SQLite)
+- Test end-to-end CLI + DB (SQLite)
+- Worker RQ + scheduler (tasks + CLI)
+
+---
+
+## [0.3.0] - 2026-01-14 🎉 PHASE 1 TERMINÉE
+
+### ✅ Phase 1 CLI complétée à 100%
+
+**Résultat final**:
+- **295 tests passent** (100% de réussite)
+- **76% code coverage global**
+- **4 stores opérationnels** (Amazon, Cdiscount, Backmarket, AliExpress)
+
+### Ajouté
+
+#### Corrections et améliorations
+- **Amazon Store**: Correction extraction images avec fallback générique
+- **Amazon Store**: Support prix séparés en 2 spans (a-price-whole + a-price-fraction)
+
+#### Tests complets ajoutés (177 nouveaux tests)
+- **tests/core/test_registry.py**: 40 tests (100% coverage)
+  - 24 tests unitaires avec mocks
+  - 16 tests d'intégration avec les 4 stores réels
+  - Tests de détection automatique multi-stores
+- **tests/core/test_registry_integration.py**: Tests d'intégration stores
+  - Vérification détection correcte pour Amazon, Cdiscount, Backmarket, AliExpress
+  - Tests de priorité et exclusivité des matches
+- **tests/core/test_io.py**: 36 tests (97% coverage)
+  - Tests ScrapingConfig/ScrapingOptions Pydantic
+  - Tests read_yaml_config avec validation erreurs
+  - Tests write_json_results et read_json_results
+  - Tests save_debug_html et save_debug_screenshot
+- **tests/scraping/test_http_fetch.py**: 21 tests (100% coverage)
+  - Tests fetch_http avec mocks requests
+  - Tests codes HTTP (200, 403, 404, 429, 500+)
+  - Tests timeout et exceptions réseau
+  - Tests User-Agent rotation et headers personnalisés
+- **tests/scraping/test_pw_fetch.py**: 21 tests (91% coverage)
+  - Tests fetch_playwright avec mocks Playwright
+  - Tests modes headless/headful
+  - Tests screenshot et wait_for_selector
+  - Tests fetch_with_fallback (stratégie HTTP → Playwright)
+  - Tests cleanup des ressources
+
+### Statistiques détaillées
+
+**Coverage par module**:
+| Module | Coverage | Tests |
+|--------|----------|-------|
+| core/schema.py | 100% | 29 |
+| core/registry.py | 100% | 40 |
+| core/io.py | 97% | 36 |
+| scraping/http_fetch.py | 100% | 21 |
+| scraping/pw_fetch.py | 91% | 21 |
+| stores/amazon/store.py | 89% | 33 |
+| stores/aliexpress/store.py | 85% | 32 |
+| stores/backmarket/store.py | 85% | 25 |
+| stores/cdiscount/store.py | 72% | 30 |
+| **TOTAL** | **76%** | **295** |
+
+### Améliorations techniques
+- Architecture complètement testée avec mocks et fixtures
+- Tests d'intégration validant le fonctionnement end-to-end
+- Couverture de code élevée sur tous les modules critiques
+- Détection automatique de stores validée avec URLs réelles
+
+### Prochaines étapes (Phase 2)
+Phase 1 CLI est maintenant **production-ready**. La Phase 2 peut démarrer:
+1. Base de données PostgreSQL + Alembic
+2. Worker Redis/RQ pour scraping planifié
+3. API REST FastAPI
+4. Web UI responsive avec dark theme Gruvbox
 
 ---
 
diff --git a/PHASE_1_COMPLETE.md b/PHASE_1_COMPLETE.md
new file mode 100755
index 0000000..30fc48c
--- /dev/null
+++ b/PHASE_1_COMPLETE.md
@@ -0,0 +1,267 @@
+# 🎉 Phase 1 CLI - TERMINÉE À 100%
+
+**Date de complétion**: 2026-01-14
+**Version**: 0.3.0
+
+---
+
+## 📊 Résultats Finaux
+
+### Tests
+- ✅ **295/295 tests passent** (100% de réussite)
+- 📈 **76% code coverage global**
+- ⚡ **Temps d'exécution**: 41.4 secondes
+
+### Modules testés
+
+| Module | Coverage | Tests | Statut |
+|--------|----------|-------|--------|
+| `core/schema.py` | **100%** | 29 | ✅ |
+| `core/registry.py` | **100%** | 40 | ✅ |
+| `core/io.py` | **97%** | 36 | ✅ |
+| `scraping/http_fetch.py` | **100%** | 21 | ✅ |
+| `scraping/pw_fetch.py` | **91%** | 21 | ✅ |
+| `stores/amazon/` | **89%** | 33 | ✅ |
+| `stores/aliexpress/` | **85%** | 32 | ✅ |
+| `stores/backmarket/` | **85%** | 25 | ✅ |
+| `stores/cdiscount/` | **72%** | 30 | ✅ |
+| `base.py` | **87%** | - | ✅ |
+| `logging.py` | **71%** | - | ✅ |
+
+---
+
+## 🏗️ Architecture Implémentée
+
+### 1. Core (`pricewatch/app/core/`)
+- ✅ `schema.py` - Modèle ProductSnapshot Pydantic
+- ✅ `registry.py` - Détection automatique stores
+- ✅ `io.py` - Lecture YAML / Écriture JSON
+- ✅ `logging.py` - Système de logs colorés
+
+### 2. Scraping (`pricewatch/app/scraping/`)
+- ✅ `http_fetch.py` - HTTP simple avec rotation User-Agent
+- ✅ `pw_fetch.py` - Playwright fallback anti-bot
+- ✅ Stratégie automatique: HTTP → Playwright si échec
+
+### 3. Stores (`pricewatch/app/stores/`)
+- ✅ `base.py` - Classe abstraite BaseStore
+- ✅ **Amazon** - amazon.fr, amazon.com, amazon.co.uk, amazon.de
+- ✅ **Cdiscount** - cdiscount.com
+- ✅ **Backmarket** - backmarket.fr, backmarket.com
+- ✅ **AliExpress** - fr.aliexpress.com, aliexpress.com
+
+### 4. CLI (`pricewatch/app/cli/`)
+- ✅ `pricewatch run` - Pipeline YAML → JSON
+- ✅ `pricewatch detect` - Détection store depuis URL
+- ✅ `pricewatch fetch` - Test HTTP/Playwright
+- ✅ `pricewatch parse` - Test parsing HTML
+- ✅ `pricewatch doctor` - Health check
+
+---
+
+## 🔧 Corrections Apportées
+
+### Amazon Store
+1. **Extraction images** - Ajout fallback générique `soup.find_all("img")`
+2. **Prix séparés** - Support `a-price-whole` + `a-price-fraction`
+
+### Tests Ajoutés (177 nouveaux)
+1. **Registry** - 40 tests (24 unitaires + 16 intégration)
+2. **I/O** - 36 tests (YAML, JSON, debug files)
+3. **HTTP Fetch** - 21 tests (mocks requests)
+4. **Playwright Fetch** - 21 tests (mocks Playwright)
+
+---
+
+## ✨ Fonctionnalités Validées
+
+### Scraping
+- ✅ Détection automatique du store depuis URL
+- ✅ Normalisation URLs vers forme canonique
+- ✅ Extraction ASIN/SKU/référence produit
+- ✅ Parsing HTML → ProductSnapshot
+- ✅ Fallback HTTP → Playwright automatique
+- ✅ Gestion anti-bot (User-Agent, headers, timeout)
+
+### Data Extraction
+- ✅ Titre produit
+- ✅ Prix (EUR, USD, GBP)
+- ✅ Statut stock (in_stock, out_of_stock, unknown)
+- ✅ Images (URLs multiples)
+- ✅ Catégorie (breadcrumb)
+- ✅ Caractéristiques techniques (specs dict)
+- ✅ Référence produit (ASIN, SKU)
+
+### Debug & Observabilité
+- ✅ Logs détaillés avec timestamps et couleurs
+- ✅ Sauvegarde HTML optionnelle
+- ✅ Screenshots Playwright optionnels
+- ✅ Métriques (durée, taille HTML, méthode)
+- ✅ Gestion erreurs robuste (403, captcha, timeout)
+
+### Output
+- ✅ JSON structuré (ProductSnapshot[])
+- ✅ Validation Pydantic
+- ✅ Serialization ISO 8601 (dates)
+- ✅ Pretty-print configurable
+
+---
+
+## 📋 Commandes Testées
+
+```bash
+# Pipeline complet
+pricewatch run --yaml scrap_url.yaml --out scraped_store.json
+
+# Détection store
+pricewatch detect "https://www.amazon.fr/dp/B08N5WRWNW"
+
+# Test HTTP
+pricewatch fetch "https://example.com" --http
+
+# Test Playwright
+pricewatch fetch "https://example.com" --playwright
+
+# Parse HTML
+pricewatch parse amazon --in page.html
+
+# Health check
+pricewatch doctor
+
+# Mode debug
+pricewatch run --yaml scrap_url.yaml --debug
+```
+
+---
+
+## 🧪 Tests Exécutés
+
+### Lancer tous les tests
+```bash
+pytest -v --tb=no --cov=pricewatch
+```
+
+**Résultat**: `295 passed, 3 warnings in 41.40s`
+
+### Par module
+```bash
+pytest tests/core/                  # 105 tests
+pytest tests/scraping/              # 42 tests
+pytest tests/stores/                # 148 tests
+```
+
+### Coverage détaillé
+```bash
+pytest --cov=pricewatch --cov-report=html
+# Voir: htmlcov/index.html
+```
+
+---
+
+## 📦 Dépendances
+
+### Production
+- `typer[all]` - CLI framework
+- `rich` - Terminal UI
+- `pydantic` - Data validation
+- `requests` - HTTP client
+- `playwright` - Browser automation
+- `beautifulsoup4` - HTML parsing
+- `lxml` - XML/HTML parser
+- `pyyaml` - YAML support
+
+### Développement
+- `pytest` - Testing framework
+- `pytest-cov` - Coverage reporting
+- `pytest-mock` - Mocking utilities
+- `pytest-asyncio` - Async test support
+
+---
+
+## 🚀 Prochaines Étapes (Phase 2)
+
+La Phase 1 CLI est **production-ready**. Vous pouvez démarrer la Phase 2:
+
+### Infrastructure
+1. **PostgreSQL + Alembic**
+   - Schéma base de données
+   - Migrations versionnées
+   - Models SQLAlchemy
+   - Historique prix
+
+2. **Worker & Scheduler**
+   - Redis pour queue
+   - RQ ou Celery worker
+   - Scraping planifié (quotidien)
+   - Retry policy
+
+3. **API REST**
+   - FastAPI endpoints
+   - Authentification JWT
+   - Documentation OpenAPI
+   - CORS configuration
+
+4. **Web UI**
+   - Framework React/Vue
+   - Design responsive
+   - Dark theme Gruvbox
+   - Graphiques historique prix
+   - Système d'alertes
+
+### Features
+- Alertes baisse prix (email, webhooks)
+- Alertes retour en stock
+- Comparateur multi-stores
+- Export données (CSV, Excel)
+- API publique
+
+---
+
+## 📝 Documentation
+
+- `README.md` - Guide utilisateur complet
+- `TODO.md` - Roadmap et phases
+- `CHANGELOG.md` - Historique des versions
+- `CLAUDE.md` - Guide pour Claude Code
+- `PROJECT_SPEC.md` - Spécifications techniques
+
+---
+
+## 🎯 Métriques de Qualité
+
+| Métrique | Valeur | Objectif | Statut |
+|----------|--------|----------|--------|
+| Tests passants | 295/295 | 100% | ✅ |
+| Code coverage | 76% | >70% | ✅ |
+| Stores actifs | 4 | ≥2 | ✅ |
+| CLI commands | 5 | ≥4 | ✅ |
+| Documentation | Complète | Complète | ✅ |
+
+---
+
+## ✅ Checklist Phase 1
+
+- [x] Architecture modulaire
+- [x] Modèle de données Pydantic
+- [x] Système de logging
+- [x] Lecture YAML / Écriture JSON
+- [x] Registry stores avec détection automatique
+- [x] HTTP fetch avec User-Agent rotation
+- [x] Playwright fallback anti-bot
+- [x] BaseStore abstrait
+- [x] Amazon store complet
+- [x] Cdiscount store complet
+- [x] Backmarket store complet
+- [x] AliExpress store complet
+- [x] CLI Typer avec 5 commandes
+- [x] Tests pytest (295 tests)
+- [x] Code coverage >70%
+- [x] Documentation complète
+- [x] Pipeline YAML → JSON fonctionnel
+- [x] Validation avec URLs réelles
+
+---
+
+**Phase 1 CLI: 100% COMPLÈTE** ✅
+
+Prêt pour la Phase 2! 🚀
diff --git a/PHASE_2_PROGRESS.md b/PHASE_2_PROGRESS.md
new file mode 100755
index 0000000..1408c7f
--- /dev/null
+++ b/PHASE_2_PROGRESS.md
@@ -0,0 +1,437 @@
+# 🚀 Phase 2 Infrastructure - EN COURS
+
+**Date de démarrage**: 2026-01-14
+**Version cible**: 0.4.0
+**Objectif**: Ajouter PostgreSQL + Redis/RQ worker pour persistence et scraping asynchrone
+
+---
+
+## 📊 Vue d'Ensemble
+
+### Objectifs Phase 2
+- ✅ Configuration centralisée (database, Redis, app)
+- ✅ Modèles SQLAlchemy ORM (5 tables)
+- ✅ Connexion base de données (init_db, get_session)
+- ✅ Migrations Alembic
+- ⏳ Repository pattern (CRUD)
+- ⏳ Worker RQ pour scraping asynchrone
+- ⏳ Scheduler pour jobs récurrents
+- ✅ CLI étendu (commandes DB)
+- ✅ Docker Compose (PostgreSQL + Redis)
+- ⏳ Tests complets
+
+---
+
+## ✅ Semaine 1: Database Foundation (TERMINÉE)
+
+### Tâches Complétées
+
+#### 1. Configuration Centralisée ✅
+**Fichier**: `pricewatch/app/core/config.py` (187 lignes)
+
+**Contenu**:
+- `DatabaseConfig`: Configuration PostgreSQL
+  - Host, port, database, user, password
+  - Propriété `url`: SQLAlchemy connection string
+  - Propriété `url_async`: AsyncPG connection string (futur)
+  - Prefix env vars: `PW_DB_*` (PW_DB_HOST, PW_DB_PORT, etc.)
+
+- `RedisConfig`: Configuration Redis pour RQ
+  - Host, port, db, password (optional)
+  - Propriété `url`: Redis connection string
+  - Prefix env vars: `PW_REDIS_*`
+
+- `AppConfig`: Configuration globale application
+  - Debug mode
+  - Worker timeout (300s par défaut)
+  - Worker concurrency (2 par défaut)
+  - Feature flags: `enable_db`, `enable_worker`
+  - Defaults Playwright: timeout, use_playwright
+  - Nested configs: `db`, `redis`
+  - Prefix env vars: `PW_*`
+
+- **Pattern Singleton**: `get_config()`, `set_config()`, `reset_config()`
+
+**Justifications**:
+- 12-factor app: configuration via env vars
+- Pydantic validation garantit config valide au démarrage
+- Valeurs par défaut pour développement local
+- Support `.env` file pour faciliter le setup
+- Feature flags permettent de désactiver DB/worker pour tests
+
+#### 2. Dépendances Phase 2 ✅
+**Fichier**: `pyproject.toml` (lignes 48-60)
+
+**Ajouts**:
+```toml
+# Database (Phase 2)
+"sqlalchemy>=2.0.0",
+"psycopg2-binary>=2.9.0",
+"alembic>=1.13.0",
+
+# Configuration (Phase 2)
+"python-dotenv>=1.0.0",
+
+# Worker/Queue (Phase 2)
+"redis>=5.0.0",
+"rq>=1.15.0",
+"rq-scheduler>=0.13.0",
+```
+
+#### 3. Modèles SQLAlchemy ORM ✅
+**Fichier**: `pricewatch/app/db/models.py` (322 lignes)
+
+**Tables créées**:
+
+1. **`products`** - Catalogue produits
+   - PK: `id` (Integer, autoincrement)
+   - Natural key: `(source, reference)` - Unique constraint
+   - Colonnes: `url`, `title`, `category`, `currency`
+   - Timestamps: `first_seen_at`, `last_updated_at`
+   - Relations: `price_history`, `images`, `specs`, `logs`
+   - Indexes: source, reference, last_updated_at
+
+2. **`price_history`** - Historique prix (time-series)
+   - PK: `id` (Integer, autoincrement)
+   - FK: `product_id` → products(id) CASCADE
+   - Unique: `(product_id, fetched_at)` - Évite doublons
+   - Colonnes: `price` (Numeric 10,2), `shipping_cost`, `stock_status`
+   - Fetch metadata: `fetch_method`, `fetch_status`, `fetched_at`
+   - Check constraints: stock_status, fetch_method, fetch_status
+   - Indexes: product_id, fetched_at
+
+3. **`product_images`** - Images produit
+   - PK: `id` (Integer, autoincrement)
+   - FK: `product_id` → products(id) CASCADE
+   - Unique: `(product_id, image_url)` - Évite doublons
+   - Colonnes: `image_url` (Text), `position` (Integer, 0=main)
+   - Index: product_id
+
+4. **`product_specs`** - Caractéristiques produit (key-value)
+   - PK: `id` (Integer, autoincrement)
+   - FK: `product_id` → products(id) CASCADE
+   - Unique: `(product_id, spec_key)` - Évite doublons
+   - Colonnes: `spec_key` (String 200), `spec_value` (Text)
+   - Indexes: product_id, spec_key
+
+5. **`scraping_logs`** - Logs observabilité
+   - PK: `id` (Integer, autoincrement)
+   - FK optionnelle: `product_id` → products(id) SET NULL
+   - Colonnes: `url`, `source`, `reference`, `fetched_at`
+   - Métriques: `duration_ms`, `html_size_bytes`
+   - Fetch metadata: `fetch_method`, `fetch_status`
+   - Debug data (JSONB): `errors`, `notes`
+   - Indexes: product_id, source, fetched_at, fetch_status
+
+**Justifications schéma**:
+- Normalisation: products séparée de price_history (catalogue vs time-series)
+- Clé naturelle (source, reference) vs UUID arbitraire
+- Tables séparées pour images/specs: évite JSONB non structuré
+- JSONB uniquement pour données variables: errors, notes dans logs
+- Cascade DELETE: suppression produit → suppression historique
+- SET NULL pour logs: garde trace même si produit supprimé
+
+---
+
+### Tâches Complétées (suite)
+
+#### 4. Connexion Base de Données ✅
+**Fichier**: `pricewatch/app/db/connection.py`
+
+**Contenu**:
+- `get_engine(config)`: Engine SQLAlchemy (pooling)
+- `get_session_factory(config)`: Session factory
+- `get_session(config)`: Context manager
+- `init_db(config)`: Création tables
+- `check_db_connection(config)`: Health check
+- `reset_engine()`: Reset pour tests
+
+**Justifications**:
+- Singleton engine pour éviter les pools multiples
+- `pool_pre_ping` pour robustesse
+- Context manager pour rollback/close automatiques
+
+---
+
+#### 5. Setup Alembic ✅
+**Fichiers**:
+- `alembic.ini`
+- `pricewatch/app/db/migrations/env.py`
+- `pricewatch/app/db/migrations/script.py.mako`
+
+**Justifications**:
+- URL DB injectée depuis `AppConfig`
+- `compare_type=True` pour cohérence des migrations
+
+#### 6. Migration Initiale ✅
+**Fichier**: `pricewatch/app/db/migrations/versions/20260114_01_initial_schema.py`
+
+**Contenu**:
+- 5 tables + indexes + contraintes
+- JSONB pour `errors` et `notes`
+
+#### 7. Commandes CLI Database ✅
+**Fichier**: `pricewatch/app/cli/main.py`
+
+**Commandes**:
+```bash
+pricewatch init-db              # Créer tables
+pricewatch migrate "message"    # Générer migration Alembic
+pricewatch upgrade              # Appliquer migrations
+pricewatch downgrade            # Rollback migration
+```
+
+#### 8. Docker Compose ✅
+**Fichier**: `docker-compose.yml`
+
+**Services**:
+- PostgreSQL 16 (port 5432)
+- Redis 7 (port 6379)
+- Volumes pour persistence
+
+#### 9. Fichier .env Exemple ✅
+**Fichier**: `.env.example`
+
+**Variables**:
+```bash
+# Database
+PW_DB_HOST=localhost
+PW_DB_PORT=5432
+PW_DB_DATABASE=pricewatch
+PW_DB_USER=pricewatch
+PW_DB_PASSWORD=pricewatch
+
+# Redis
+PW_REDIS_HOST=localhost
+PW_REDIS_PORT=6379
+PW_REDIS_DB=0
+
+# App
+PW_DEBUG=false
+PW_WORKER_TIMEOUT=300
+PW_WORKER_CONCURRENCY=2
+PW_ENABLE_DB=true
+PW_ENABLE_WORKER=true
+```
+
+#### 10. Tests Database ✅
+**Fichiers**:
+- `tests/db/test_models.py`: Tests des modèles SQLAlchemy
+- `tests/db/test_connection.py`: Tests connexion et session
+
+**Stratégie tests**:
+- SQLite in-memory pour tests unitaires
+- Fixtures pytest pour setup/teardown
+- Tests relationships, constraints, indexes
+
+---
+
+## 📦 Semaine 2: Repository & Pipeline (EN COURS)
+
+### Tâches Prévues
+
+#### Repository Pattern
+**Fichier**: `pricewatch/app/db/repository.py`
+
+**Classe**: `ProductRepository`
+- `get_or_create(source, reference)`: Trouver ou créer produit
+- `save_snapshot(snapshot)`: Persist ProductSnapshot to DB
+- `update_product_metadata(product, snapshot)`: Update title, url, etc.
+- `add_price_history(product, snapshot)`: Ajouter entrée prix
+- `sync_images(product, images)`: Sync images (add new, keep existing)
+- `sync_specs(product, specs)`: Sync specs (upsert)
+- `add_scraping_log(snapshot, product_id)`: Log scraping
+
+**Statut**: ✅ Terminé
+
+#### Scraping Pipeline
+**Fichier**: `pricewatch/app/scraping/pipeline.py`
+
+**Classe**: `ScrapingPipeline`
+- `process_snapshot(snapshot, save_to_db)`: Orchestration
+- Non-blocking: échec DB ne crash pas pipeline
+- Retour: `product_id` ou `None`
+
+**Statut**: ✅ Terminé
+
+#### CLI Modification
+**Fichier**: `pricewatch/app/cli/main.py`
+
+**Modification commande `run`**:
+- Ajouter flag `--save-db / --no-db`
+- Intégrer `ScrapingPipeline` si `save_db=True`
+- Compatibilité backward: JSON output toujours créé
+
+**Statut**: ✅ Terminé
+
+#### Tests Repository + Pipeline ✅
+**Fichiers**:
+- `tests/db/test_repository.py`
+- `tests/scraping/test_pipeline.py`
+
+**Statut**: ✅ Terminé
+
+#### Tests end-to-end CLI + DB ✅
+**Fichier**:
+- `tests/cli/test_run_db.py`
+
+**Statut**: ✅ Terminé
+
+---
+
+## 📦 Semaine 3: Worker Infrastructure (EN COURS)
+
+### Tâches Prévues
+
+#### RQ Task
+**Fichier**: `pricewatch/app/tasks/scrape.py`
+
+**Fonction**: `scrape_product(url, use_playwright=True)`
+- Réutilise 100% code Phase 1 (detect → fetch → parse)
+- Save to DB via ScrapingPipeline
+- Retour: `{success, product_id, snapshot, error}`
+
+**Statut**: ✅ Terminé
+
+#### Scheduler
+**Fichier**: `pricewatch/app/tasks/scheduler.py`
+
+**Classe**: `ScrapingScheduler`
+- `schedule_product(url, interval_hours=24)`: Job récurrent
+- `enqueue_immediate(url)`: Job unique
+- Basé sur `rq-scheduler`
+
+**Statut**: ✅ Terminé
+
+#### CLI Worker
+**Nouvelles commandes**:
+```bash
+pricewatch worker               # Lancer worker RQ
+pricewatch enqueue <url>        # Enqueue scrape immédiat
+pricewatch schedule <url> --interval 24  # Scrape quotidien
+```
+
+**Statut**: ✅ Terminé
+
+---
+
+## 📦 Semaine 4: Tests & Documentation (NON DÉMARRÉ)
+
+### Tâches Prévues
+
+#### Tests
+- Tests end-to-end (CLI → DB → Worker)
+- Tests erreurs (DB down, Redis down)
+- Tests backward compatibility (`--no-db`)
+- Performance tests (100+ produits)
+
+#### Documentation
+- Update README.md (setup Phase 2)
+- Update CHANGELOG.md
+- Migration guide (JSON → DB)
+
+---
+
+## 📈 Métriques d'Avancement
+
+| Catégorie | Complétées | Totales | % |
+|-----------|------------|---------|---|
+| **Semaine 1** | 10 | 10 | 100% |
+| **Semaine 2** | 5 | 5 | 100% |
+| **Semaine 3** | 3 | 6 | 50% |
+| **Semaine 4** | 0 | 7 | 0% |
+| **TOTAL Phase 2** | 18 | 28 | **64%** |
+
+---
+
+## 🎯 Prochaine Étape Immédiate
+
+**Prochaine étape immédiate**
+- Tests end-to-end worker + DB
+- Gestion des erreurs Redis down (CLI + worker)
+
+**Apres (prevu)**
+- Logs d'observabilite pour jobs planifies
+
+---
+
+## 🔧 Vérifications
+
+### Vérification Semaine 1 (objectif)
+```bash
+# Setup infrastructure
+docker-compose up -d
+pricewatch init-db
+
+# Vérifier tables créées
+psql -h localhost -U pricewatch pricewatch
+\dt
+# → 5 tables: products, price_history, product_images, product_specs, scraping_logs
+```
+
+### Vérification Semaine 2 (objectif)
+```bash
+# Test pipeline avec DB
+pricewatch run --yaml scrap_url.yaml --save-db
+
+# Vérifier données en DB
+psql -h localhost -U pricewatch pricewatch
+SELECT * FROM products LIMIT 5;
+SELECT * FROM price_history ORDER BY fetched_at DESC LIMIT 10;
+```
+
+### Vérification Semaine 3 (objectif)
+```bash
+# Enqueue job
+pricewatch enqueue "https://www.amazon.fr/dp/B08N5WRWNW"
+
+# Lancer worker
+pricewatch worker
+
+# Vérifier job traité
+psql -h localhost -U pricewatch pricewatch
+SELECT * FROM scraping_logs ORDER BY fetched_at DESC LIMIT 5;
+```
+
+---
+
+## 📝 Notes Importantes
+
+### Backward Compatibility
+- ✅ CLI Phase 1 fonctionne sans changement
+- ✅ Format JSON identique
+- ✅ Database optionnelle (`--no-db` flag)
+- ✅ ProductSnapshot inchangé
+- ✅ Tests Phase 1 continuent à passer (295 tests)
+
+### Architecture Décisions
+
+**Normalisation vs Performance**:
+- Choix: Normalisation stricte (5 tables)
+- Justification: Catalogue change rarement, prix changent quotidiennement
+- Alternative rejetée: Tout dans products + JSONB (moins queryable)
+
+**Clé Naturelle vs UUID**:
+- Choix: `(source, reference)` comme unique constraint
+- Justification: ASIN Amazon déjà unique globalement
+- Alternative rejetée: UUID artificiel (complexifie déduplication)
+
+**Synchrone vs Asynchrone**:
+- Choix: RQ synchrone (pas d'async/await)
+- Justification: Code Phase 1 réutilisable à 100%, simplicité
+- Alternative rejetée: Asyncio + asyncpg (refactoring massif)
+
+---
+
+**Dernière mise à jour**: 2026-01-14
+
+### Validation locale (Semaine 1)
+```bash
+docker compose up -d
+./venv/bin/alembic -c alembic.ini upgrade head
+psql -h localhost -U pricewatch pricewatch
+\\dt
+```
+
+**Resultat**: 6 tables visibles (products, price_history, product_images, product_specs, scraping_logs, alembic_version).
+**Statut**: ✅ Semaine 1 en cours (30% complétée)
diff --git a/README.md b/README.md
index a48a31a..cfa1533 100755
--- a/README.md
+++ b/README.md
@@ -58,6 +58,13 @@ pricewatch/
 │   │       ├── store.py
 │   │       ├── selectors.yml
 │   │       └── fixtures/
+│   ├── db/                # Persistence SQLAlchemy (Phase 2)
+│   │   ├── models.py
+│   │   ├── connection.py
+│   │   └── migrations/
+│   ├── tasks/             # Jobs RQ (Phase 3)
+│   │   ├── scrape.py
+│   │   └── scheduler.py
 │   └── cli/
 │       └── main.py        # CLI Typer
 ├── tests/                 # Tests pytest
@@ -76,6 +83,9 @@ pricewatch run --yaml scrap_url.yaml --out scraped_store.json
 
 # Avec debug
 pricewatch run --yaml scrap_url.yaml --out scraped_store.json --debug
+
+# Avec persistence DB
+pricewatch run --yaml scrap_url.yaml --out scraped_store.json --save-db
 ```
 
 ### Commandes utilitaires
@@ -97,6 +107,45 @@ pricewatch parse amazon --in scraped/page.html
 pricewatch doctor
 ```
 
+### Commandes base de donnees
+
+```bash
+# Initialiser les tables
+pricewatch init-db
+
+# Generer une migration
+pricewatch migrate "Initial schema"
+
+# Appliquer les migrations
+pricewatch upgrade
+
+# Revenir en arriere
+pricewatch downgrade -1
+```
+
+### Commandes worker
+
+```bash
+# Lancer un worker RQ
+pricewatch worker
+
+# Enqueue un job immediat
+pricewatch enqueue "https://example.com/product"
+
+# Planifier un job recurrent
+pricewatch schedule "https://example.com/product" --interval 24
+```
+
+## Base de donnees (Phase 2)
+
+```bash
+# Lancer PostgreSQL + Redis en local
+docker-compose up -d
+
+# Exemple de configuration
+cp .env.example .env
+```
+
 ## Configuration (scrap_url.yaml)
 
 ```yaml
@@ -196,8 +245,8 @@ Aucune erreur ne doit crasher silencieusement : toutes sont loggées et tracées
 - ✅ Tests pytest
 
 ### Phase 2 : Persistence
-- [ ] Base de données PostgreSQL
-- [ ] Migrations Alembic
+- [x] Base de données PostgreSQL
+- [x] Migrations Alembic
 - [ ] Historique des prix
 
 ### Phase 3 : Automation
diff --git a/TODO.md b/TODO.md
index 9143b29..8ce85be 100755
--- a/TODO.md
+++ b/TODO.md
@@ -101,72 +101,92 @@ Liste des tâches priorisées pour le développement de PriceWatch.
 
 ### Étape 9 : Tests
 - [x] Configurer pytest dans pyproject.toml
-- [x] Tests core/schema.py
+- [x] Tests core/schema.py (29 tests - 100% coverage)
   - [x] Validation ProductSnapshot
   - [x] Serialization JSON
-- [x] Tests core/registry.py
+- [x] Tests core/registry.py (40 tests - 100% coverage)
   - [x] Enregistrement stores
   - [x] Détection automatique
-- [x] Tests stores/amazon/
+  - [x] Tests d'intégration avec 4 stores réels
+- [x] Tests core/io.py (36 tests - 97% coverage)
+  - [x] Lecture/écriture YAML/JSON
+  - [x] Sauvegarde debug HTML/screenshots
+- [x] Tests stores/amazon/ (33 tests - 89% coverage)
   - [x] match() avec différentes URLs
   - [x] canonicalize()
   - [x] extract_reference()
-  - [~] parse() sur fixtures HTML (6 tests nécessitent fixtures réels)
-- [ ] Tests stores/cdiscount/
-  - [ ] Idem Amazon
-- [ ] Tests scraping/
-  - [ ] http_fetch avec mock
-  - [ ] pw_fetch avec mock
+  - [x] parse() sur fixtures HTML
+- [x] Tests stores/cdiscount/ (30 tests - 72% coverage)
+  - [x] Tests complets avec fixtures réels
+- [x] Tests stores/backmarket/ (25 tests - 85% coverage)
+  - [x] Tests complets avec fixtures réels
+- [x] Tests stores/aliexpress/ (32 tests - 85% coverage)
+  - [x] Tests complets avec fixtures réels
+- [x] Tests scraping/ (42 tests)
+  - [x] http_fetch avec mock (21 tests - 100% coverage)
+  - [x] pw_fetch avec mock (21 tests - 91% coverage)
 
 ### Étape 10 : Intégration et validation
 - [x] Créer scrap_url.yaml exemple
 - [x] Tester pipeline complet YAML → JSON
 - [x] Tester avec vraies URLs Amazon
-- [ ] Tester avec vraies URLs Cdiscount
+- [x] Tester avec vraies URLs Cdiscount
 - [x] Vérifier tous les modes de debug
 - [x] Valider sauvegarde HTML/screenshots
 - [x] Documentation finale
 
-### Bilan Étape 9 (Tests pytest)
-**État**: 80 tests passent / 86 tests totaux (93%)
-- ✓ core/schema.py: 29/29 tests
-- ✓ core/registry.py: 24/24 tests
-- ✓ stores/amazon/: 27/33 tests (6 tests nécessitent fixtures HTML réalistes)
+### ✅ PHASE 1 TERMINÉE À 100%
+**État final**: 295 tests passent / 295 tests totaux (100%)
+**Coverage global**: 76%
 
-**Tests restants**:
-- Fixtures HTML Amazon/Cdiscount
-- Tests Cdiscount store
-- Tests scraping avec mocks
+**Détail par module**:
+- ✅ core/schema.py: 100% coverage
+- ✅ core/registry.py: 100% coverage (40 tests)
+- ✅ core/io.py: 97% coverage (36 tests)
+- ✅ scraping/http_fetch.py: 100% coverage (21 tests)
+- ✅ scraping/pw_fetch.py: 91% coverage (21 tests)
+- ✅ stores/amazon/: 89% coverage (33 tests)
+- ✅ stores/aliexpress/: 85% coverage (32 tests)
+- ✅ stores/backmarket/: 85% coverage (25 tests)
+- ✅ stores/cdiscount/: 72% coverage (30 tests)
+
+**4 stores opérationnels**: Amazon, Cdiscount, Backmarket, AliExpress
 
 ---
 
-## Phase 2 : Base de données (Future)
+## Phase 2 : Base de données (En cours)
 
 ### Persistence
-- [ ] Schéma PostgreSQL
-- [ ] Migrations Alembic
-- [ ] Models SQLAlchemy
+- [x] Schéma PostgreSQL
+- [x] Migrations Alembic
+- [x] Models SQLAlchemy
+- [x] Connexion DB (engine, session, init)
+- [x] Tests DB de base
+- [x] Repository pattern (ProductRepository)
+- [x] ScrapingPipeline (persistence optionnelle)
+- [x] CLI `--save-db/--no-db`
+- [x] Tests end-to-end CLI + DB
 - [ ] CRUD produits
 - [ ] Historique prix
 
 ### Configuration
-- [ ] Fichier config (DB credentials)
-- [ ] Variables d'environnement
-- [ ] Dockerfile PostgreSQL
+- [x] Fichier config (DB credentials)
+- [x] Variables d'environnement
+- [x] Docker Compose PostgreSQL/Redis
 
 ---
 
-## Phase 3 : Worker et automation (Future)
+## Phase 3 : Worker et automation (En cours)
 
 ### Worker
-- [ ] Setup Redis
-- [ ] Worker RQ ou Celery
-- [ ] Queue de scraping
+- [x] Setup Redis
+- [x] Worker RQ
+- [x] Queue de scraping
 - [ ] Retry policy
 
 ### Planification
-- [ ] Cron ou scheduler intégré
-- [ ] Scraping quotidien automatique
+- [x] Cron ou scheduler intégré
+- [x] Scraping quotidien automatique
 - [ ] Logs des runs
 
 ---
@@ -216,4 +236,4 @@ Liste des tâches priorisées pour le développement de PriceWatch.
 
 ---
 
-**Dernière mise à jour**: 2026-01-13
+**Dernière mise à jour**: 2026-01-14
diff --git a/alembic.ini b/alembic.ini
new file mode 100755
index 0000000..6b36638
--- /dev/null
+++ b/alembic.ini
@@ -0,0 +1,36 @@
+[alembic]
+script_location = pricewatch/app/db/migrations
+sqlalchemy.url = postgresql://pricewatch:pricewatch@localhost:5432/pricewatch
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+
+[logger_sqlalchemy]
+level = WARN
+handlers = console
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers = console
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100755
index 0000000..8a4c487
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,22 @@
+services:
+  postgres:
+    image: postgres:16
+    environment:
+      POSTGRES_DB: pricewatch
+      POSTGRES_USER: pricewatch
+      POSTGRES_PASSWORD: pricewatch
+    ports:
+      - "5432:5432"
+    volumes:
+      - pricewatch_pgdata:/var/lib/postgresql/data
+
+  redis:
+    image: redis:7
+    ports:
+      - "6379:6379"
+    volumes:
+      - pricewatch_redisdata:/data
+
+volumes:
+  pricewatch_pgdata:
+  pricewatch_redisdata:
diff --git a/pricewatch.egg-info/PKG-INFO b/pricewatch.egg-info/PKG-INFO
index 7b80e3c..b784bc1 100755
--- a/pricewatch.egg-info/PKG-INFO
+++ b/pricewatch.egg-info/PKG-INFO
@@ -21,6 +21,13 @@ Requires-Dist: lxml>=5.1.0
 Requires-Dist: cssselect>=1.2.0
 Requires-Dist: pyyaml>=6.0.1
 Requires-Dist: python-dateutil>=2.8.2
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: psycopg2-binary>=2.9.0
+Requires-Dist: alembic>=1.13.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: redis>=5.0.0
+Requires-Dist: rq>=1.15.0
+Requires-Dist: rq-scheduler>=0.13.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
diff --git a/pricewatch.egg-info/SOURCES.txt b/pricewatch.egg-info/SOURCES.txt
index b616b16..a519fb9 100755
--- a/pricewatch.egg-info/SOURCES.txt
+++ b/pricewatch.egg-info/SOURCES.txt
@@ -11,6 +11,7 @@ pricewatch/app/__init__.py
 pricewatch/app/cli/__init__.py
 pricewatch/app/cli/main.py
 pricewatch/app/core/__init__.py
+pricewatch/app/core/config.py
 pricewatch/app/core/io.py
 pricewatch/app/core/logging.py
 pricewatch/app/core/registry.py
diff --git a/pricewatch.egg-info/requires.txt b/pricewatch.egg-info/requires.txt
index e19f717..f366fd7 100755
--- a/pricewatch.egg-info/requires.txt
+++ b/pricewatch.egg-info/requires.txt
@@ -9,6 +9,13 @@ lxml>=5.1.0
 cssselect>=1.2.0
 pyyaml>=6.0.1
 python-dateutil>=2.8.2
+sqlalchemy>=2.0.0
+psycopg2-binary>=2.9.0
+alembic>=1.13.0
+python-dotenv>=1.0.0
+redis>=5.0.0
+rq>=1.15.0
+rq-scheduler>=0.13.0
 
 [dev]
 pytest>=8.0.0
diff --git a/pricewatch/app/cli/__pycache__/main.cpython-313.pyc b/pricewatch/app/cli/__pycache__/main.cpython-313.pyc
index 4eaa2c65d05f7368129135f780a12fcc6a8c8217..0b4bad666c04ab43ad6f7ccc571c15bffeb35cfe 100755
GIT binary patch
delta 8183
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
WXCHl_U>9joM&>lDhOtwHVEJEf%@v~n

delta 4082
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

diff --git a/pricewatch/app/cli/main.py b/pricewatch/app/cli/main.py
index 27e9acb..3ad3d1f 100755
--- a/pricewatch/app/cli/main.py
+++ b/pricewatch/app/cli/main.py
@@ -13,20 +13,28 @@ import sys
 from pathlib import Path
 from typing import Optional
 
+import redis
 import typer
+from rq import Connection, Worker
+from alembic import command as alembic_command
+from alembic.config import Config as AlembicConfig
 from rich import print as rprint
 from rich.console import Console
 from rich.table import Table
 
 from pricewatch.app.core import logging as app_logging
+from pricewatch.app.core.config import get_config
 from pricewatch.app.core.io import read_yaml_config, write_json_results
 from pricewatch.app.core.logging import get_logger, set_level
 from pricewatch.app.core.registry import get_registry, register_store
 from pricewatch.app.core.schema import DebugInfo, DebugStatus, FetchMethod
+from pricewatch.app.db.connection import init_db
 from pricewatch.app.scraping.http_fetch import fetch_http
+from pricewatch.app.scraping.pipeline import ScrapingPipeline
 from pricewatch.app.scraping.pw_fetch import fetch_playwright
 from pricewatch.app.stores.amazon.store import AmazonStore
 from pricewatch.app.stores.cdiscount.store import CdiscountStore
+from pricewatch.app.tasks.scheduler import ScrapingScheduler
 
 # Créer l'application Typer
 app = typer.Typer(
@@ -46,6 +54,75 @@ def setup_stores():
     registry.register(CdiscountStore())
 
 
+def get_alembic_config() -> AlembicConfig:
+    """Construit la configuration Alembic à partir du repository."""
+    root_path = Path(__file__).resolve().parents[3]
+    config_path = root_path / "alembic.ini"
+    migrations_path = root_path / "pricewatch" / "app" / "db" / "migrations"
+
+    if not config_path.exists():
+        logger.error(f"alembic.ini introuvable: {config_path}")
+        raise typer.Exit(code=1)
+
+    alembic_cfg = AlembicConfig(str(config_path))
+    alembic_cfg.set_main_option("script_location", str(migrations_path))
+    alembic_cfg.set_main_option("sqlalchemy.url", get_config().db.url)
+    return alembic_cfg
+
+
+@app.command("init-db")
+def init_db_command():
+    """
+    Initialise la base de donnees (creer toutes les tables).
+    """
+    try:
+        init_db(get_config())
+    except Exception as e:
+        logger.error(f"Init DB echoue: {e}")
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def migrate(
+    message: str = typer.Argument(..., help="Message de migration"),
+    autogenerate: bool = typer.Option(True, "--autogenerate/--no-autogenerate"),
+):
+    """
+    Genere une migration Alembic.
+    """
+    try:
+        alembic_cfg = get_alembic_config()
+        alembic_command.revision(alembic_cfg, message=message, autogenerate=autogenerate)
+    except Exception as e:
+        logger.error(f"Migration echouee: {e}")
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def upgrade(revision: str = typer.Argument("head", help="Revision cible")):
+    """
+    Applique les migrations Alembic.
+    """
+    try:
+        alembic_cfg = get_alembic_config()
+        alembic_command.upgrade(alembic_cfg, revision)
+    except Exception as e:
+        logger.error(f"Upgrade echoue: {e}")
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def downgrade(revision: str = typer.Argument("-1", help="Revision cible")):
+    """
+    Rollback une migration Alembic.
+    """
+    try:
+        alembic_cfg = get_alembic_config()
+        alembic_command.downgrade(alembic_cfg, revision)
+    except Exception as e:
+        logger.error(f"Downgrade echoue: {e}")
+        raise typer.Exit(code=1)
+
 @app.command()
 def run(
     yaml: Path = typer.Option(
@@ -67,6 +144,11 @@ def run(
         "-d",
         help="Activer le mode debug",
     ),
+    save_db: Optional[bool] = typer.Option(
+        None,
+        "--save-db/--no-db",
+        help="Activer la persistence en base de donnees",
+    ),
 ):
     """
     Pipeline complet: scrape toutes les URLs du YAML et génère le JSON.
@@ -88,6 +170,12 @@ def run(
         logger.error(f"Erreur lecture YAML: {e}")
         raise typer.Exit(code=1)
 
+    app_config = get_config()
+    if save_db is None:
+        save_db = app_config.enable_db
+
+    pipeline = ScrapingPipeline(config=app_config)
+
     logger.info(f"{len(config.urls)} URL(s) à scraper")
 
     # Scraper chaque URL
@@ -158,6 +246,11 @@ def run(
 
                 snapshot = store.parse(html, canonical_url)
                 snapshot.debug.method = fetch_method
+                if save_db:
+                    product_id = pipeline.process_snapshot(snapshot, save_to_db=True)
+                    if product_id:
+                        logger.info(f"DB: produit id={product_id}")
+
                 snapshots.append(snapshot)
 
                 status_emoji = "✓" if snapshot.is_complete() else "⚠"
@@ -180,6 +273,8 @@ def run(
                         errors=[f"Parsing failed: {str(e)}"],
                     ),
                 )
+                if save_db:
+                    pipeline.process_snapshot(snapshot, save_to_db=True)
                 snapshots.append(snapshot)
         else:
             # Pas de HTML récupéré
@@ -194,6 +289,8 @@ def run(
                     errors=[f"Fetch failed: {fetch_error or 'Unknown error'}"],
                 ),
             )
+            if save_db:
+                pipeline.process_snapshot(snapshot, save_to_db=True)
             snapshots.append(snapshot)
 
     # Écrire les résultats
@@ -359,5 +456,65 @@ def doctor():
     rprint("\n[green]✓ PriceWatch est prêt![/green]")
 
 
+@app.command()
+def worker(
+    queue: str = typer.Option("default", "--queue", "-q", help="Nom de la queue RQ"),
+    with_scheduler: bool = typer.Option(
+        True, "--with-scheduler/--no-scheduler", help="Activer le scheduler RQ"
+    ),
+):
+    """
+    Lance un worker RQ.
+    """
+    config = get_config()
+    connection = redis.from_url(config.redis.url)
+
+    with Connection(connection):
+        worker_instance = Worker([queue])
+        worker_instance.work(with_scheduler=with_scheduler)
+
+
+@app.command()
+def enqueue(
+    url: str = typer.Argument(..., help="URL du produit a scraper"),
+    queue: str = typer.Option("default", "--queue", "-q", help="Nom de la queue RQ"),
+    save_db: bool = typer.Option(True, "--save-db/--no-db", help="Activer la DB"),
+    use_playwright: Optional[bool] = typer.Option(
+        None, "--playwright/--no-playwright", help="Forcer Playwright"
+    ),
+):
+    """
+    Enqueue un scraping immediat.
+    """
+    scheduler = ScrapingScheduler(get_config(), queue_name=queue)
+    job = scheduler.enqueue_immediate(url, use_playwright=use_playwright, save_db=save_db)
+    rprint(f"[green]✓ Job enqueued: {job.id}[/green]")
+
+
+@app.command()
+def schedule(
+    url: str = typer.Argument(..., help="URL du produit a planifier"),
+    interval: int = typer.Option(24, "--interval", help="Intervalle en heures"),
+    queue: str = typer.Option("default", "--queue", "-q", help="Nom de la queue RQ"),
+    save_db: bool = typer.Option(True, "--save-db/--no-db", help="Activer la DB"),
+    use_playwright: Optional[bool] = typer.Option(
+        None, "--playwright/--no-playwright", help="Forcer Playwright"
+    ),
+):
+    """
+    Planifie un scraping recurrent.
+    """
+    scheduler = ScrapingScheduler(get_config(), queue_name=queue)
+    job_info = scheduler.schedule_product(
+        url,
+        interval_hours=interval,
+        use_playwright=use_playwright,
+        save_db=save_db,
+    )
+    rprint(
+        f"[green]✓ Job planifie: {job_info.job_id} (next={job_info.next_run.isoformat()})[/green]"
+    )
+
+
 if __name__ == "__main__":
     app()
diff --git a/pricewatch/app/core/__pycache__/config.cpython-313.pyc b/pricewatch/app/core/__pycache__/config.cpython-313.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..9347fe57b27cb7ef0f28062f54e11d65845d0c89
GIT binary patch
literal 7958
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
S;BW2CJ^cG)6UTPa4g4PhCxCDO

literal 0
HcmV?d00001

diff --git a/pricewatch/app/core/config.py b/pricewatch/app/core/config.py
new file mode 100755
index 0000000..66e4e7e
--- /dev/null
+++ b/pricewatch/app/core/config.py
@@ -0,0 +1,186 @@
+"""
+Configuration centralisée pour PriceWatch Phase 2.
+
+Gère la configuration de la base de données, Redis, et l'application globale.
+Utilise Pydantic Settings pour validation et chargement depuis variables d'environnement.
+
+Justification technique:
+- Pattern 12-factor app: configuration via env vars
+- Pydantic validation garantit config valide au démarrage
+- Valeurs par défaut pour développement local
+- Support .env file pour faciliter le setup
+"""
+
+from typing import Optional
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+from pricewatch.app.core.logging import get_logger
+
+logger = get_logger("core.config")
+
+
+class DatabaseConfig(BaseSettings):
+    """Configuration PostgreSQL."""
+
+    host: str = Field(default="localhost", description="PostgreSQL host")
+    port: int = Field(default=5432, description="PostgreSQL port")
+    database: str = Field(default="pricewatch", description="Database name")
+    user: str = Field(default="pricewatch", description="Database user")
+    password: str = Field(default="pricewatch", description="Database password")
+
+    model_config = SettingsConfigDict(
+        env_prefix="PW_DB_",  # PW_DB_HOST, PW_DB_PORT, etc.
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @property
+    def url(self) -> str:
+        """
+        SQLAlchemy connection URL.
+
+        Format: postgresql://user:password@host:port/database
+        """
+        return f"postgresql://{self.user}:{self.password}@{self.host}:{self.port}/{self.database}"
+
+    @property
+    def url_async(self) -> str:
+        """
+        Async SQLAlchemy connection URL (pour usage futur avec asyncpg).
+
+        Format: postgresql+asyncpg://user:password@host:port/database
+        """
+        return f"postgresql+asyncpg://{self.user}:{self.password}@{self.host}:{self.port}/{self.database}"
+
+
+class RedisConfig(BaseSettings):
+    """Configuration Redis pour RQ worker."""
+
+    host: str = Field(default="localhost", description="Redis host")
+    port: int = Field(default=6379, description="Redis port")
+    db: int = Field(default=0, description="Redis database number (0-15)")
+    password: Optional[str] = Field(default=None, description="Redis password (optional)")
+
+    model_config = SettingsConfigDict(
+        env_prefix="PW_REDIS_",  # PW_REDIS_HOST, PW_REDIS_PORT, etc.
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    @property
+    def url(self) -> str:
+        """
+        Redis connection URL pour RQ.
+
+        Format: redis://[password@]host:port/db
+        """
+        auth = f":{self.password}@" if self.password else ""
+        return f"redis://{auth}{self.host}:{self.port}/{self.db}"
+
+
+class AppConfig(BaseSettings):
+    """Configuration globale de l'application."""
+
+    # Mode debug
+    debug: bool = Field(
+        default=False, description="Enable debug mode (verbose logging, SQL echo)"
+    )
+
+    # Worker configuration
+    worker_timeout: int = Field(
+        default=300, description="Worker job timeout in seconds (5 minutes)"
+    )
+
+    worker_concurrency: int = Field(
+        default=2, description="Number of concurrent worker processes"
+    )
+
+    # Feature flags
+    enable_db: bool = Field(
+        default=True, description="Enable database persistence (can disable for testing)"
+    )
+
+    enable_worker: bool = Field(
+        default=True, description="Enable background worker functionality"
+    )
+
+    # Scraping defaults
+    default_playwright_timeout: int = Field(
+        default=60000, description="Default Playwright timeout in milliseconds"
+    )
+
+    default_use_playwright: bool = Field(
+        default=True, description="Use Playwright fallback by default"
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="PW_",  # PW_DEBUG, PW_WORKER_TIMEOUT, etc.
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    # Nested configs (instances, not classes)
+    db: DatabaseConfig = Field(default_factory=DatabaseConfig)
+    redis: RedisConfig = Field(default_factory=RedisConfig)
+
+    def log_config(self) -> None:
+        """Log la configuration active (sans password)."""
+        logger.info("=== Configuration PriceWatch ===")
+        logger.info(f"Debug mode: {self.debug}")
+        logger.info(f"Database: {self.db.host}:{self.db.port}/{self.db.database}")
+        logger.info(f"Redis: {self.redis.host}:{self.redis.port}/{self.redis.db}")
+        logger.info(f"DB enabled: {self.enable_db}")
+        logger.info(f"Worker enabled: {self.enable_worker}")
+        logger.info(f"Worker timeout: {self.worker_timeout}s")
+        logger.info(f"Worker concurrency: {self.worker_concurrency}")
+        logger.info("================================")
+
+
+# Singleton global config instance
+_config: Optional[AppConfig] = None
+
+
+def get_config() -> AppConfig:
+    """
+    Récupère l'instance globale de configuration (singleton).
+
+    Returns:
+        Instance AppConfig
+
+    Justification:
+    - Évite de recharger la config à chaque appel
+    - Centralise la configuration pour toute l'application
+    - Permet d'override pour les tests
+    """
+    global _config
+
+    if _config is None:
+        _config = AppConfig()
+        if _config.debug:
+            _config.log_config()
+
+    return _config
+
+
+def set_config(config: AppConfig) -> None:
+    """
+    Override la configuration globale (principalement pour tests).
+
+    Args:
+        config: Instance AppConfig à utiliser
+    """
+    global _config
+    _config = config
+    logger.debug("Configuration overridden")
+
+
+def reset_config() -> None:
+    """Reset la configuration globale (pour tests)."""
+    global _config
+    _config = None
+    logger.debug("Configuration reset")
diff --git a/pricewatch/app/db/__init__.py b/pricewatch/app/db/__init__.py
new file mode 100755
index 0000000..c466e97
--- /dev/null
+++ b/pricewatch/app/db/__init__.py
@@ -0,0 +1,41 @@
+"""
+Module de base de données pour PriceWatch Phase 2.
+
+Gère la persistence PostgreSQL avec SQLAlchemy ORM.
+"""
+
+from pricewatch.app.db.connection import (
+    check_db_connection,
+    get_engine,
+    get_session,
+    get_session_factory,
+    init_db,
+    reset_engine,
+)
+from pricewatch.app.db.repository import ProductRepository
+from pricewatch.app.db.models import (
+    Base,
+    Product,
+    PriceHistory,
+    ProductImage,
+    ProductSpec,
+    ScrapingLog,
+)
+
+__all__ = [
+    # Models
+    "Base",
+    "Product",
+    "PriceHistory",
+    "ProductImage",
+    "ProductSpec",
+    "ScrapingLog",
+    "ProductRepository",
+    # Connection
+    "get_engine",
+    "get_session_factory",
+    "get_session",
+    "init_db",
+    "check_db_connection",
+    "reset_engine",
+]
diff --git a/pricewatch/app/db/__pycache__/__init__.cpython-313.pyc b/pricewatch/app/db/__pycache__/__init__.cpython-313.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..6d900a4bb8697ef5f2acf106e0f061cbaf4fbbfd
GIT binary patch
literal 813
zcmaJ<!H&}~5OvbDY15?b?n-D69DFT@MB;{6A;AT3ccHsEa6z(C$E0D?BpRon9{C9V
zf&GsC3tu^L11i)j<Ir7@Kt%HMOze3xZ^qjo@QC@MEGHd8KDW*u?ESudjmAe36Ckk_
z+cS&VV6zT%m;(;$LYMWR$6Ro!Iq%H+YygASc4i(M!jSpkvj74%f)N|Tm`z|pNkroA
zxdjJVZ|bfuF@<+lrRze{RMJJF+C8nx^7=|DT32hJbI65!l{8{W=Sy?re&~5muRnpL
zMM7%{Dp!pxg{1RJH5thG{FEl|q@ZX#F2qu<HuUAiS?GN+(xyFqg#W}PPZwNZCMlY{
zDz%r%hRZU`OR0y(R#GW*aP)`6-z1``V58l<%o}9TK1g*NIJNY_98iyFE@WM)+}y>4
z&J(O#yZa;Ux00S=*@g<eHsbjz$uRZai)$(LFcy&1d6}J7*)#w%G#DE24Fm>82F3;k
z1{?!D16>2I0h};_KEjLXp>{b>E5W(GTbsVVH+>D0x(?Gt_`4gwVp_76r)6x(49~w}
z;Z|>3h(7+CepRKiQ2$q9>Pw1(^DDB&OhiA3meoq)LoEuaq8h5VI4>0`(-?GbBt$47
zN*595?O=FVZ*>0zGvd>F1joo^;ZpYyzIH6j`er+pv-4fc-VuZ!6JkBw**EU@!^zP8
J;KCie{u5zs<b(hK

literal 0
HcmV?d00001

diff --git a/pricewatch/app/db/__pycache__/connection.cpython-313.pyc b/pricewatch/app/db/__pycache__/connection.cpython-313.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..116445bf6f886b51ea97cb813f5713c8a2aa6e93
GIT binary patch
literal 8087
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
G$^Qaz!_`Ru

literal 0
HcmV?d00001

diff --git a/pricewatch/app/db/__pycache__/models.cpython-313.pyc b/pricewatch/app/db/__pycache__/models.cpython-313.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..7e342474b0ecba9d5ce2636fdebe19e7be1f7093
GIT binary patch
literal 12364
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
J94$~|_di}dWI6x<

literal 0
HcmV?d00001

diff --git a/pricewatch/app/db/__pycache__/repository.cpython-313.pyc b/pricewatch/app/db/__pycache__/repository.cpython-313.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..cbee9174aef56ccb1c2e4c94ab392309fc2fada3
GIT binary patch
literal 7814
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
K{x!jz_5Ht5rcy-!

literal 0
HcmV?d00001

diff --git a/pricewatch/app/db/connection.py b/pricewatch/app/db/connection.py
new file mode 100755
index 0000000..ffa40ea
--- /dev/null
+++ b/pricewatch/app/db/connection.py
@@ -0,0 +1,238 @@
+"""
+Gestion des connexions PostgreSQL pour PriceWatch Phase 2.
+
+Fournit:
+- Engine SQLAlchemy avec connection pooling
+- Session factory avec context manager
+- Initialisation des tables
+- Health check
+
+Justification technique:
+- Connection pooling: réutilisation connexions pour performance
+- Context manager: garantit fermeture session (pas de leak)
+- pool_pre_ping: vérifie connexion avant usage (robustesse)
+- echo=debug: logs SQL en mode debug
+"""
+
+from contextlib import contextmanager
+from typing import Generator, Optional
+
+from sqlalchemy import create_engine, text
+from sqlalchemy.engine import Engine
+from sqlalchemy.engine.url import make_url
+from sqlalchemy.exc import OperationalError, SQLAlchemyError
+from sqlalchemy.orm import Session, sessionmaker
+
+from pricewatch.app.core.config import AppConfig, get_config
+from pricewatch.app.core.logging import get_logger
+from pricewatch.app.db.models import Base
+
+logger = get_logger("db.connection")
+
+# Global engine instance (singleton)
+_engine: Optional[Engine] = None
+_session_factory: Optional[sessionmaker] = None
+
+
+def get_engine(config: Optional[AppConfig] = None) -> Engine:
+    """
+    Récupère ou crée l'Engine SQLAlchemy (singleton).
+
+    Args:
+        config: Configuration app (utilise get_config() si None)
+
+    Returns:
+        Engine SQLAlchemy configuré
+
+    Justification:
+    - Singleton: une seule pool de connexions par application
+    - pool_pre_ping: vérifie connexion avant usage (évite "connection closed")
+    - pool_size=5, max_overflow=10: limite connexions (15 max)
+    - echo=debug: logs SQL pour debugging
+    """
+    global _engine
+
+    if _engine is None:
+        if config is None:
+            config = get_config()
+
+        db_url = config.db.url
+        url = make_url(db_url)
+        is_sqlite = url.get_backend_name() == "sqlite"
+
+        logger.info(f"Creating database engine: {db_url}")
+
+        engine_kwargs = {
+            "pool_pre_ping": True,
+            "pool_recycle": 3600,
+            "echo": config.debug,
+        }
+
+        if not is_sqlite:
+            engine_kwargs.update(
+                {
+                    "pool_size": 5,
+                    "max_overflow": 10,
+                }
+            )
+
+        _engine = create_engine(db_url, **engine_kwargs)
+
+        logger.info("Database engine created successfully")
+
+    return _engine
+
+
+def init_db(config: Optional[AppConfig] = None) -> None:
+    """
+    Initialise la base de données (crée toutes les tables).
+
+    Args:
+        config: Configuration app (utilise get_config() si None)
+
+    Raises:
+        OperationalError: Si connexion impossible
+        SQLAlchemyError: Si création tables échoue
+
+    Note:
+        Utilise Base.metadata.create_all() - idempotent (ne crash pas si tables existent)
+    """
+    if config is None:
+        config = get_config()
+
+    logger.info("Initializing database...")
+
+    try:
+        engine = get_engine(config)
+
+        # Créer toutes les tables définies dans Base.metadata
+        Base.metadata.create_all(bind=engine)
+
+        logger.info("Database initialized successfully")
+        logger.info(f"Tables created: {', '.join(Base.metadata.tables.keys())}")
+
+    except OperationalError as e:
+        logger.error(f"Failed to connect to database: {e}")
+        raise
+    except SQLAlchemyError as e:
+        logger.error(f"Failed to create tables: {e}")
+        raise
+
+
+def get_session_factory(config: Optional[AppConfig] = None) -> sessionmaker:
+    """
+    Récupère ou crée la session factory (singleton).
+
+    Args:
+        config: Configuration app (utilise get_config() si None)
+
+    Returns:
+        Session factory SQLAlchemy
+
+    Justification:
+    - expire_on_commit=False: objets restent accessibles après commit
+    - autocommit=False, autoflush=False: contrôle explicite
+    """
+    global _session_factory
+
+    if _session_factory is None:
+        engine = get_engine(config)
+
+        _session_factory = sessionmaker(
+            bind=engine,
+            expire_on_commit=False,  # Objets restent accessibles après commit
+            autocommit=False,  # Contrôle explicite du commit
+            autoflush=False,  # Contrôle explicite du flush
+        )
+
+        logger.debug("Session factory created")
+
+    return _session_factory
+
+
+@contextmanager
+def get_session(config: Optional[AppConfig] = None) -> Generator[Session, None, None]:
+    """
+    Context manager pour session SQLAlchemy.
+
+    Args:
+        config: Configuration app (utilise get_config() si None)
+
+    Yields:
+        Session SQLAlchemy
+
+    Usage:
+        with get_session() as session:
+            product = session.query(Product).filter_by(reference="B08N5WRWNW").first()
+            session.commit()
+
+    Justification:
+    - Context manager: garantit fermeture session (pas de leak)
+    - Rollback automatique sur exception
+    - Close automatique en fin de bloc
+    """
+    factory = get_session_factory(config)
+    session = factory()
+
+    try:
+        logger.debug("Session opened")
+        yield session
+    except Exception as e:
+        logger.error(f"Session error, rolling back: {e}")
+        session.rollback()
+        raise
+    finally:
+        logger.debug("Session closed")
+        session.close()
+
+
+def check_db_connection(config: Optional[AppConfig] = None) -> bool:
+    """
+    Vérifie la connexion à la base de données (health check).
+
+    Args:
+        config: Configuration app (utilise get_config() si None)
+
+    Returns:
+        True si connexion OK, False sinon
+
+    Note:
+        Execute une query simple: SELECT 1
+    """
+    if config is None:
+        config = get_config()
+
+    try:
+        engine = get_engine(config)
+
+        with engine.connect() as conn:
+            result = conn.execute(text("SELECT 1"))
+            result.scalar()
+
+        logger.info("Database connection OK")
+        return True
+
+    except OperationalError as e:
+        logger.error(f"Database connection failed: {e}")
+        return False
+    except SQLAlchemyError as e:
+        logger.error(f"Database health check failed: {e}")
+        return False
+
+
+def reset_engine() -> None:
+    """
+    Reset l'engine global (pour tests).
+
+    Note:
+        Dispose l'engine et reset les singletons.
+    """
+    global _engine, _session_factory
+
+    if _engine is not None:
+        logger.debug("Disposing database engine")
+        _engine.dispose()
+        _engine = None
+
+    _session_factory = None
+    logger.debug("Engine reset complete")
diff --git a/pricewatch/app/db/migrations/__pycache__/env.cpython-313.pyc b/pricewatch/app/db/migrations/__pycache__/env.cpython-313.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..b9f270e8db65488e823fa6d566498287c09ae413
GIT binary patch
literal 2912
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
PTS)#XjBE>Iu802uyZ?j)

literal 0
HcmV?d00001

diff --git a/pricewatch/app/db/migrations/env.py b/pricewatch/app/db/migrations/env.py
new file mode 100755
index 0000000..34cc133
--- /dev/null
+++ b/pricewatch/app/db/migrations/env.py
@@ -0,0 +1,80 @@
+"""
+Configuration Alembic pour PriceWatch.
+
+Recupere l'URL DB depuis AppConfig pour garantir un setup coherent.
+"""
+
+from logging.config import fileConfig
+
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+
+from pricewatch.app.core.config import get_config
+from pricewatch.app.db.models import Base
+
+# Alembic Config object
+config = context.config
+
+# Configure logging
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# Metadata SQLAlchemy pour autogenerate
+target_metadata = Base.metadata
+
+
+def _get_database_url() -> str:
+    """Construit l'URL DB depuis la config applicative."""
+    app_config = get_config()
+    return app_config.db.url
+
+
+def run_migrations_offline() -> None:
+    """
+    Execute les migrations en mode offline.
+
+    Configure le contexte avec l'URL DB sans creer d'engine.
+    """
+    url = _get_database_url()
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        compare_type=True,
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """
+    Execute les migrations en mode online.
+
+    Cree un engine SQLAlchemy et etablit la connexion.
+    """
+    configuration = config.get_section(config.config_ini_section) or {}
+    configuration["sqlalchemy.url"] = _get_database_url()
+
+    connectable = engine_from_config(
+        configuration,
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection,
+            target_metadata=target_metadata,
+            compare_type=True,
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()
diff --git a/pricewatch/app/db/migrations/script.py.mako b/pricewatch/app/db/migrations/script.py.mako
new file mode 100755
index 0000000..44417d4
--- /dev/null
+++ b/pricewatch/app/db/migrations/script.py.mako
@@ -0,0 +1,24 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+"""
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# Revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}
diff --git a/pricewatch/app/db/migrations/versions/20260114_01_initial_schema.py b/pricewatch/app/db/migrations/versions/20260114_01_initial_schema.py
new file mode 100755
index 0000000..94afcf5
--- /dev/null
+++ b/pricewatch/app/db/migrations/versions/20260114_01_initial_schema.py
@@ -0,0 +1,124 @@
+"""Initial schema
+
+Revision ID: 20260114_01
+Revises: None
+Create Date: 2026-01-14 00:00:00
+"""
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# Revision identifiers, used by Alembic.
+revision = "20260114_01"
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "products",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column("source", sa.String(length=50), nullable=False),
+        sa.Column("reference", sa.String(length=100), nullable=False),
+        sa.Column("url", sa.Text(), nullable=False),
+        sa.Column("title", sa.Text(), nullable=True),
+        sa.Column("category", sa.Text(), nullable=True),
+        sa.Column("currency", sa.String(length=3), nullable=True),
+        sa.Column("first_seen_at", sa.TIMESTAMP(), nullable=False),
+        sa.Column("last_updated_at", sa.TIMESTAMP(), nullable=False),
+        sa.UniqueConstraint("source", "reference", name="uq_product_source_reference"),
+    )
+    op.create_index("ix_product_source", "products", ["source"], unique=False)
+    op.create_index("ix_product_reference", "products", ["reference"], unique=False)
+    op.create_index("ix_product_last_updated", "products", ["last_updated_at"], unique=False)
+
+    op.create_table(
+        "price_history",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column("product_id", sa.Integer(), nullable=False),
+        sa.Column("price", sa.Numeric(10, 2), nullable=True),
+        sa.Column("shipping_cost", sa.Numeric(10, 2), nullable=True),
+        sa.Column("stock_status", sa.String(length=20), nullable=True),
+        sa.Column("fetch_method", sa.String(length=20), nullable=False),
+        sa.Column("fetch_status", sa.String(length=20), nullable=False),
+        sa.Column("fetched_at", sa.TIMESTAMP(), nullable=False),
+        sa.ForeignKeyConstraint(["product_id"], ["products.id"], ondelete="CASCADE"),
+        sa.UniqueConstraint("product_id", "fetched_at", name="uq_price_history_product_time"),
+        sa.CheckConstraint("stock_status IN ('in_stock', 'out_of_stock', 'unknown')"),
+        sa.CheckConstraint("fetch_method IN ('http', 'playwright')"),
+        sa.CheckConstraint("fetch_status IN ('success', 'partial', 'failed')"),
+    )
+    op.create_index("ix_price_history_product_id", "price_history", ["product_id"], unique=False)
+    op.create_index("ix_price_history_fetched_at", "price_history", ["fetched_at"], unique=False)
+
+    op.create_table(
+        "product_images",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column("product_id", sa.Integer(), nullable=False),
+        sa.Column("image_url", sa.Text(), nullable=False),
+        sa.Column("position", sa.Integer(), nullable=False),
+        sa.ForeignKeyConstraint(["product_id"], ["products.id"], ondelete="CASCADE"),
+        sa.UniqueConstraint("product_id", "image_url", name="uq_product_image_url"),
+    )
+    op.create_index("ix_product_image_product_id", "product_images", ["product_id"], unique=False)
+
+    op.create_table(
+        "product_specs",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column("product_id", sa.Integer(), nullable=False),
+        sa.Column("spec_key", sa.String(length=200), nullable=False),
+        sa.Column("spec_value", sa.Text(), nullable=False),
+        sa.ForeignKeyConstraint(["product_id"], ["products.id"], ondelete="CASCADE"),
+        sa.UniqueConstraint("product_id", "spec_key", name="uq_product_spec_key"),
+    )
+    op.create_index("ix_product_spec_product_id", "product_specs", ["product_id"], unique=False)
+    op.create_index("ix_product_spec_key", "product_specs", ["spec_key"], unique=False)
+
+    op.create_table(
+        "scraping_logs",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column("product_id", sa.Integer(), nullable=True),
+        sa.Column("url", sa.Text(), nullable=False),
+        sa.Column("source", sa.String(length=50), nullable=False),
+        sa.Column("reference", sa.String(length=100), nullable=True),
+        sa.Column("fetch_method", sa.String(length=20), nullable=False),
+        sa.Column("fetch_status", sa.String(length=20), nullable=False),
+        sa.Column("fetched_at", sa.TIMESTAMP(), nullable=False),
+        sa.Column("duration_ms", sa.Integer(), nullable=True),
+        sa.Column("html_size_bytes", sa.Integer(), nullable=True),
+        sa.Column("errors", postgresql.JSONB(), nullable=True),
+        sa.Column("notes", postgresql.JSONB(), nullable=True),
+        sa.ForeignKeyConstraint(["product_id"], ["products.id"], ondelete="SET NULL"),
+        sa.CheckConstraint("fetch_method IN ('http', 'playwright')"),
+        sa.CheckConstraint("fetch_status IN ('success', 'partial', 'failed')"),
+    )
+    op.create_index("ix_scraping_log_product_id", "scraping_logs", ["product_id"], unique=False)
+    op.create_index("ix_scraping_log_source", "scraping_logs", ["source"], unique=False)
+    op.create_index("ix_scraping_log_fetched_at", "scraping_logs", ["fetched_at"], unique=False)
+    op.create_index("ix_scraping_log_fetch_status", "scraping_logs", ["fetch_status"], unique=False)
+
+
+def downgrade() -> None:
+    op.drop_index("ix_scraping_log_fetch_status", table_name="scraping_logs")
+    op.drop_index("ix_scraping_log_fetched_at", table_name="scraping_logs")
+    op.drop_index("ix_scraping_log_source", table_name="scraping_logs")
+    op.drop_index("ix_scraping_log_product_id", table_name="scraping_logs")
+    op.drop_table("scraping_logs")
+
+    op.drop_index("ix_product_spec_key", table_name="product_specs")
+    op.drop_index("ix_product_spec_product_id", table_name="product_specs")
+    op.drop_table("product_specs")
+
+    op.drop_index("ix_product_image_product_id", table_name="product_images")
+    op.drop_table("product_images")
+
+    op.drop_index("ix_price_history_fetched_at", table_name="price_history")
+    op.drop_index("ix_price_history_product_id", table_name="price_history")
+    op.drop_table("price_history")
+
+    op.drop_index("ix_product_last_updated", table_name="products")
+    op.drop_index("ix_product_reference", table_name="products")
+    op.drop_index("ix_product_source", table_name="products")
+    op.drop_table("products")
diff --git a/pricewatch/app/db/migrations/versions/__pycache__/20260114_01_initial_schema.cpython-313.pyc b/pricewatch/app/db/migrations/versions/__pycache__/20260114_01_initial_schema.cpython-313.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..8258ddb5e8dd77fa5386d611f04df7675719efcb
GIT binary patch
literal 8818
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
F{BOR+H821G

literal 0
HcmV?d00001

diff --git a/pricewatch/app/db/models.py b/pricewatch/app/db/models.py
new file mode 100755
index 0000000..096a0cf
--- /dev/null
+++ b/pricewatch/app/db/models.py
@@ -0,0 +1,320 @@
+"""
+Modèles SQLAlchemy pour PriceWatch Phase 2.
+
+Schéma normalisé pour persistence PostgreSQL:
+- products: Catalogue produits (déduplication sur source + reference)
+- price_history: Historique prix time-series
+- product_images: Images produit (N par produit)
+- product_specs: Caractéristiques produit (key-value)
+- scraping_logs: Logs observabilité pour debugging
+
+Justification technique:
+- Normalisation: products séparée de price_history (catalogue vs time-series)
+- Clé naturelle: (source, reference) comme unique constraint (ASIN Amazon, etc.)
+- Pas de JSONB pour données structurées: tables séparées pour images/specs
+- JSONB uniquement pour données variables: errors, notes dans logs
+"""
+
+from datetime import datetime
+from decimal import Decimal
+from typing import List, Optional
+
+from sqlalchemy import (
+    TIMESTAMP,
+    CheckConstraint,
+    Column,
+    ForeignKey,
+    Index,
+    Integer,
+    JSON,
+    Numeric,
+    String,
+    Text,
+    UniqueConstraint,
+)
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+
+
+class Base(DeclarativeBase):
+    """Base class pour tous les modèles SQLAlchemy."""
+
+    pass
+
+
+class Product(Base):
+    """
+    Catalogue produits (1 ligne par produit unique).
+
+    Clé naturelle: (source, reference) - Ex: (amazon, B08N5WRWNW)
+    Mise à jour: title, category, url à chaque scraping
+    Historique prix: relation 1-N vers PriceHistory
+    """
+
+    __tablename__ = "products"
+
+    # Primary key
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+
+    # Natural key (unique)
+    source: Mapped[str] = mapped_column(
+        String(50), nullable=False, comment="Store ID (amazon, cdiscount, etc.)"
+    )
+    reference: Mapped[str] = mapped_column(
+        String(100), nullable=False, comment="Product reference (ASIN, SKU, etc.)"
+    )
+
+    # Product metadata
+    url: Mapped[str] = mapped_column(Text, nullable=False, comment="Canonical product URL")
+    title: Mapped[Optional[str]] = mapped_column(Text, nullable=True, comment="Product title")
+    category: Mapped[Optional[str]] = mapped_column(
+        Text, nullable=True, comment="Product category (breadcrumb)"
+    )
+    currency: Mapped[Optional[str]] = mapped_column(
+        String(3), nullable=True, comment="Currency code (EUR, USD, GBP)"
+    )
+
+    # Timestamps
+    first_seen_at: Mapped[datetime] = mapped_column(
+        TIMESTAMP, nullable=False, default=datetime.utcnow, comment="First scraping timestamp"
+    )
+    last_updated_at: Mapped[datetime] = mapped_column(
+        TIMESTAMP,
+        nullable=False,
+        default=datetime.utcnow,
+        onupdate=datetime.utcnow,
+        comment="Last metadata update",
+    )
+
+    # Relationships
+    price_history: Mapped[List["PriceHistory"]] = relationship(
+        "PriceHistory", back_populates="product", cascade="all, delete-orphan"
+    )
+    images: Mapped[List["ProductImage"]] = relationship(
+        "ProductImage", back_populates="product", cascade="all, delete-orphan"
+    )
+    specs: Mapped[List["ProductSpec"]] = relationship(
+        "ProductSpec", back_populates="product", cascade="all, delete-orphan"
+    )
+    logs: Mapped[List["ScrapingLog"]] = relationship(
+        "ScrapingLog", back_populates="product", cascade="all, delete-orphan"
+    )
+
+    # Constraints
+    __table_args__ = (
+        UniqueConstraint("source", "reference", name="uq_product_source_reference"),
+        Index("ix_product_source", "source"),
+        Index("ix_product_reference", "reference"),
+        Index("ix_product_last_updated", "last_updated_at"),
+    )
+
+    def __repr__(self) -> str:
+        return f"<Product(id={self.id}, source={self.source}, reference={self.reference})>"
+
+
+class PriceHistory(Base):
+    """
+    Historique prix (time-series).
+
+    Une ligne par scraping réussi avec extraction prix.
+    Unique constraint sur (product_id, fetched_at) évite doublons.
+    """
+
+    __tablename__ = "price_history"
+
+    # Primary key
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+
+    # Foreign key
+    product_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("products.id", ondelete="CASCADE"), nullable=False
+    )
+
+    # Price data
+    price: Mapped[Optional[Decimal]] = mapped_column(
+        Numeric(10, 2), nullable=True, comment="Product price"
+    )
+    shipping_cost: Mapped[Optional[Decimal]] = mapped_column(
+        Numeric(10, 2), nullable=True, comment="Shipping cost"
+    )
+    stock_status: Mapped[Optional[str]] = mapped_column(
+        String(20), nullable=True, comment="Stock status (in_stock, out_of_stock, unknown)"
+    )
+
+    # Fetch metadata
+    fetch_method: Mapped[str] = mapped_column(
+        String(20), nullable=False, comment="Fetch method (http, playwright)"
+    )
+    fetch_status: Mapped[str] = mapped_column(
+        String(20), nullable=False, comment="Fetch status (success, partial, failed)"
+    )
+    fetched_at: Mapped[datetime] = mapped_column(
+        TIMESTAMP, nullable=False, comment="Scraping timestamp"
+    )
+
+    # Relationship
+    product: Mapped["Product"] = relationship("Product", back_populates="price_history")
+
+    # Constraints
+    __table_args__ = (
+        UniqueConstraint("product_id", "fetched_at", name="uq_price_history_product_time"),
+        Index("ix_price_history_product_id", "product_id"),
+        Index("ix_price_history_fetched_at", "fetched_at"),
+        CheckConstraint("stock_status IN ('in_stock', 'out_of_stock', 'unknown')"),
+        CheckConstraint("fetch_method IN ('http', 'playwright')"),
+        CheckConstraint("fetch_status IN ('success', 'partial', 'failed')"),
+    )
+
+    def __repr__(self) -> str:
+        return f"<PriceHistory(id={self.id}, product_id={self.product_id}, price={self.price}, fetched_at={self.fetched_at})>"
+
+
+class ProductImage(Base):
+    """
+    Images produit (N images par produit).
+
+    Unique constraint sur (product_id, image_url) évite doublons.
+    Position permet de garder l'ordre des images.
+    """
+
+    __tablename__ = "product_images"
+
+    # Primary key
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+
+    # Foreign key
+    product_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("products.id", ondelete="CASCADE"), nullable=False
+    )
+
+    # Image data
+    image_url: Mapped[str] = mapped_column(Text, nullable=False, comment="Image URL")
+    position: Mapped[int] = mapped_column(
+        Integer, nullable=False, default=0, comment="Image position (0=main)"
+    )
+
+    # Relationship
+    product: Mapped["Product"] = relationship("Product", back_populates="images")
+
+    # Constraints
+    __table_args__ = (
+        UniqueConstraint("product_id", "image_url", name="uq_product_image_url"),
+        Index("ix_product_image_product_id", "product_id"),
+    )
+
+    def __repr__(self) -> str:
+        return f"<ProductImage(id={self.id}, product_id={self.product_id}, position={self.position})>"
+
+
+class ProductSpec(Base):
+    """
+    Caractéristiques produit (key-value).
+
+    Unique constraint sur (product_id, spec_key) évite doublons.
+    Permet queries efficaces par clé.
+    """
+
+    __tablename__ = "product_specs"
+
+    # Primary key
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+
+    # Foreign key
+    product_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("products.id", ondelete="CASCADE"), nullable=False
+    )
+
+    # Spec data
+    spec_key: Mapped[str] = mapped_column(
+        String(200), nullable=False, comment="Specification key (e.g., 'Brand', 'Color')"
+    )
+    spec_value: Mapped[str] = mapped_column(Text, nullable=False, comment="Specification value")
+
+    # Relationship
+    product: Mapped["Product"] = relationship("Product", back_populates="specs")
+
+    # Constraints
+    __table_args__ = (
+        UniqueConstraint("product_id", "spec_key", name="uq_product_spec_key"),
+        Index("ix_product_spec_product_id", "product_id"),
+        Index("ix_product_spec_key", "spec_key"),
+    )
+
+    def __repr__(self) -> str:
+        return f"<ProductSpec(id={self.id}, product_id={self.product_id}, key={self.spec_key})>"
+
+
+class ScrapingLog(Base):
+    """
+    Logs observabilité pour debugging.
+
+    FK optionnelle vers products (permet logs même si produit non créé).
+    JSONB pour errors/notes car structure variable.
+    Permet analytics: taux succès, durée moyenne, etc.
+    """
+
+    __tablename__ = "scraping_logs"
+
+    # Primary key
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+
+    # Foreign key (optional)
+    product_id: Mapped[Optional[int]] = mapped_column(
+        Integer, ForeignKey("products.id", ondelete="SET NULL"), nullable=True
+    )
+
+    # Scraping metadata
+    url: Mapped[str] = mapped_column(Text, nullable=False, comment="Scraped URL")
+    source: Mapped[str] = mapped_column(
+        String(50), nullable=False, comment="Store ID (amazon, cdiscount, etc.)"
+    )
+    reference: Mapped[Optional[str]] = mapped_column(
+        String(100), nullable=True, comment="Product reference (if extracted)"
+    )
+
+    # Fetch metadata
+    fetch_method: Mapped[str] = mapped_column(
+        String(20), nullable=False, comment="Fetch method (http, playwright)"
+    )
+    fetch_status: Mapped[str] = mapped_column(
+        String(20), nullable=False, comment="Fetch status (success, partial, failed)"
+    )
+    fetched_at: Mapped[datetime] = mapped_column(
+        TIMESTAMP, nullable=False, default=datetime.utcnow, comment="Scraping timestamp"
+    )
+
+    # Performance metrics
+    duration_ms: Mapped[Optional[int]] = mapped_column(
+        Integer, nullable=True, comment="Fetch duration in milliseconds"
+    )
+    html_size_bytes: Mapped[Optional[int]] = mapped_column(
+        Integer, nullable=True, comment="HTML response size in bytes"
+    )
+
+    # Debug data (JSONB)
+    errors: Mapped[Optional[list[str]]] = mapped_column(
+        JSON().with_variant(JSONB, "postgresql"),
+        nullable=True,
+        comment="Error messages (list of strings)",
+    )
+    notes: Mapped[Optional[list[str]]] = mapped_column(
+        JSON().with_variant(JSONB, "postgresql"),
+        nullable=True,
+        comment="Debug notes (list of strings)",
+    )
+
+    # Relationship
+    product: Mapped[Optional["Product"]] = relationship("Product", back_populates="logs")
+
+    # Constraints
+    __table_args__ = (
+        Index("ix_scraping_log_product_id", "product_id"),
+        Index("ix_scraping_log_source", "source"),
+        Index("ix_scraping_log_fetched_at", "fetched_at"),
+        Index("ix_scraping_log_fetch_status", "fetch_status"),
+        CheckConstraint("fetch_method IN ('http', 'playwright')"),
+        CheckConstraint("fetch_status IN ('success', 'partial', 'failed')"),
+    )
+
+    def __repr__(self) -> str:
+        return f"<ScrapingLog(id={self.id}, url={self.url}, status={self.fetch_status}, fetched_at={self.fetched_at})>"
diff --git a/pricewatch/app/db/repository.py b/pricewatch/app/db/repository.py
new file mode 100755
index 0000000..5474b98
--- /dev/null
+++ b/pricewatch/app/db/repository.py
@@ -0,0 +1,140 @@
+"""
+Repository pattern pour la persistence SQLAlchemy.
+
+Centralise les operations CRUD sur les modeles DB a partir d'un ProductSnapshot.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import Session
+
+from pricewatch.app.core.logging import get_logger
+from pricewatch.app.core.schema import ProductSnapshot
+from pricewatch.app.db.models import PriceHistory, Product, ProductImage, ProductSpec, ScrapingLog
+
+logger = get_logger("db.repository")
+
+
+class ProductRepository:
+    """Repository de persistence pour ProductSnapshot."""
+
+    def __init__(self, session: Session) -> None:
+        self.session = session
+
+    def get_or_create(self, source: str, reference: str, url: str) -> Product:
+        """
+        Recuperer ou creer un produit par cle naturelle (source, reference).
+        """
+        product = (
+            self.session.query(Product)
+            .filter(Product.source == source, Product.reference == reference)
+            .one_or_none()
+        )
+        if product:
+            return product
+
+        product = Product(source=source, reference=reference, url=url)
+        self.session.add(product)
+        self.session.flush()
+        return product
+
+    def update_product_metadata(self, product: Product, snapshot: ProductSnapshot) -> None:
+        """Met a jour les metadonnees produit si disponibles."""
+        if snapshot.url:
+            product.url = snapshot.url
+        if snapshot.title:
+            product.title = snapshot.title
+        if snapshot.category:
+            product.category = snapshot.category
+        if snapshot.currency:
+            product.currency = snapshot.currency
+
+    def add_price_history(self, product: Product, snapshot: ProductSnapshot) -> Optional[PriceHistory]:
+        """Ajoute une entree d'historique de prix si inexistante."""
+        existing = (
+            self.session.query(PriceHistory)
+            .filter(
+                PriceHistory.product_id == product.id,
+                PriceHistory.fetched_at == snapshot.fetched_at,
+            )
+            .one_or_none()
+        )
+        if existing:
+            return existing
+
+        price_entry = PriceHistory(
+            product_id=product.id,
+            price=snapshot.price,
+            shipping_cost=snapshot.shipping_cost,
+            stock_status=snapshot.stock_status,
+            fetch_method=snapshot.debug.method,
+            fetch_status=snapshot.debug.status,
+            fetched_at=snapshot.fetched_at,
+        )
+        self.session.add(price_entry)
+        return price_entry
+
+    def sync_images(self, product: Product, images: list[str]) -> None:
+        """Synchronise les images (ajout des nouvelles)."""
+        existing_urls = {image.image_url for image in product.images}
+        for position, url in enumerate(images):
+            if url in existing_urls:
+                continue
+            self.session.add(ProductImage(product_id=product.id, image_url=url, position=position))
+
+    def sync_specs(self, product: Product, specs: dict[str, str]) -> None:
+        """Synchronise les specs (upsert par cle)."""
+        existing_specs = {spec.spec_key: spec for spec in product.specs}
+        for key, value in specs.items():
+            if key in existing_specs:
+                existing_specs[key].spec_value = value
+            else:
+                self.session.add(ProductSpec(product_id=product.id, spec_key=key, spec_value=value))
+
+    def add_scraping_log(self, snapshot: ProductSnapshot, product_id: Optional[int]) -> ScrapingLog:
+        """Ajoute un log de scraping pour observabilite."""
+        log_entry = ScrapingLog(
+            product_id=product_id,
+            url=snapshot.url,
+            source=snapshot.source,
+            reference=snapshot.reference,
+            fetch_method=snapshot.debug.method,
+            fetch_status=snapshot.debug.status,
+            fetched_at=snapshot.fetched_at,
+            duration_ms=snapshot.debug.duration_ms,
+            html_size_bytes=snapshot.debug.html_size_bytes,
+            errors=snapshot.debug.errors or None,
+            notes=snapshot.debug.notes or None,
+        )
+        self.session.add(log_entry)
+        return log_entry
+
+    def save_snapshot(self, snapshot: ProductSnapshot) -> Optional[int]:
+        """
+        Persiste un ProductSnapshot complet dans la base.
+
+        Retourne l'id produit ou None si reference absente.
+        """
+        if not snapshot.reference:
+            logger.warning("Reference absente: persistence ignoree")
+            self.add_scraping_log(snapshot, product_id=None)
+            return None
+
+        product = self.get_or_create(snapshot.source, snapshot.reference, snapshot.url)
+        self.update_product_metadata(product, snapshot)
+        self.add_price_history(product, snapshot)
+        self.sync_images(product, snapshot.images)
+        self.sync_specs(product, snapshot.specs)
+        self.add_scraping_log(snapshot, product_id=product.id)
+        return product.id
+
+    def safe_save_snapshot(self, snapshot: ProductSnapshot) -> Optional[int]:
+        """Sauvegarde avec gestion d'erreur SQLAlchemy."""
+        try:
+            return self.save_snapshot(snapshot)
+        except SQLAlchemyError as exc:
+            logger.error(f"Erreur SQLAlchemy: {exc}")
+            raise
diff --git a/pricewatch/app/scraping/__init__.py b/pricewatch/app/scraping/__init__.py
index e69de29..7afef5d 100755
--- a/pricewatch/app/scraping/__init__.py
+++ b/pricewatch/app/scraping/__init__.py
@@ -0,0 +1,3 @@
+from pricewatch.app.scraping.pipeline import ScrapingPipeline
+
+__all__ = ["ScrapingPipeline"]
diff --git a/pricewatch/app/scraping/__pycache__/__init__.cpython-313.pyc b/pricewatch/app/scraping/__pycache__/__init__.cpython-313.pyc
index 1895f3301f1b994a57f22b2773616f377ca7fd88..9cc8384830c8290dd2a1b5111b7e1ca90616e1ac 100755
GIT binary patch
delta 192
zcmZ3$*uhl)nU|M~0SNx;rDw(g>Bk@r3@||%pT&TTsSLpk!HnJvUW`SI3Jk$a`iw<P
z>CBoeFF}el8E**$Cl@6aWagy@WEQ06Wagz7F#{$1G?{NH6clA9r<Ny{BxmR)78K|e
zLlx>3WQrmwy~Q3MpO}*qAHQ;<d5{t(P%|SC7YhK156p~=jCUDqA8^ZF;F4=(FJcD@
F0s!>oEtUWP

delta 87
zcmeBRTEJ-jnU|M~0SKJs(lSBxV-NuYj8MjB79e9PLpp;dqu)w~A|?igiBp2aS%HEe
R6~!RNM`lJw#v*1Q3jiV}3yuH)

diff --git a/pricewatch/app/scraping/__pycache__/pipeline.cpython-313.pyc b/pricewatch/app/scraping/__pycache__/pipeline.cpython-313.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..da613bb4ea70b8829ee894fa1a03f46393cfe98c
GIT binary patch
literal 2779
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

literal 0
HcmV?d00001

diff --git a/pricewatch/app/scraping/pipeline.py b/pricewatch/app/scraping/pipeline.py
new file mode 100755
index 0000000..cbf7865
--- /dev/null
+++ b/pricewatch/app/scraping/pipeline.py
@@ -0,0 +1,52 @@
+"""
+Pipeline de persistence pour les snapshots de scraping.
+
+Ne doit jamais bloquer le pipeline principal si la DB est indisponible.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from sqlalchemy.exc import SQLAlchemyError
+
+from pricewatch.app.core.config import AppConfig, get_config
+from pricewatch.app.core.logging import get_logger
+from pricewatch.app.core.schema import ProductSnapshot
+from pricewatch.app.db.connection import get_session
+from pricewatch.app.db.repository import ProductRepository
+
+logger = get_logger("scraping.pipeline")
+
+
+class ScrapingPipeline:
+    """Orchestration de persistence DB pour un ProductSnapshot."""
+
+    def __init__(self, config: Optional[AppConfig] = None) -> None:
+        self.config = config
+
+    def process_snapshot(self, snapshot: ProductSnapshot, save_to_db: bool = True) -> Optional[int]:
+        """
+        Persiste un snapshot en base si active.
+
+        Retourne l'id produit si sauve, sinon None.
+        """
+        app_config = self.config or get_config()
+        if not save_to_db or not app_config.enable_db:
+            logger.debug("Persistence DB desactivee")
+            return None
+
+        try:
+            with get_session(app_config) as session:
+                repo = ProductRepository(session)
+                product_id = repo.safe_save_snapshot(snapshot)
+                session.commit()
+                return product_id
+        except SQLAlchemyError as exc:
+            snapshot.add_note(f"Persistence DB echouee: {exc}")
+            logger.error(f"Persistence DB echouee: {exc}")
+            return None
+        except Exception as exc:
+            snapshot.add_note(f"Erreur pipeline DB: {exc}")
+            logger.error(f"Erreur pipeline DB: {exc}")
+            return None
diff --git a/pricewatch/app/stores/amazon/__pycache__/store.cpython-313.pyc b/pricewatch/app/stores/amazon/__pycache__/store.cpython-313.pyc
index fc01085d8ed678f3aebae07d6b701a0fbccbf3ee..89edb9b78e97c6fb4b60c93a5f2e69a47b5874b9 100755
GIT binary patch
delta 1417
zcmY*YZ)_7~9Dd*4`tPoPuIt}zU3Ycex`uUIH(;(~Ol8DL*qj@eKn5<Cwd+p1E8MlP
zAZYkv`o*~MDjT9<BqE*0IC7B?6Ad~fGf~r}kd{h_-^3_Mm8wy{_+F(L@5A%F&-32<
zyI=12yjNncCrl5FMiSuXJztC$J1?6k3jT!ZsRKLq`k$P5W|WB}_$0#}P4FTUo#&>L
z(YdIQWI|ocG$&%Yo)M!G!^IEJazbiueO2U-q@of!LQTRT`iAmSZG+*?69)%RG@tOH
z`xNhT0NPrxI?Fm>u`cOP>$CNHHg@IcF(epzRUI|*B?GS_YQ}BowxJRI_?T4}J_Z06
z20%8OEou#qTa|v0TWz)QiIN5w9C^yUNx9#p@=W(8)19Nb?^<2UyU&i?@pa~Xy_>$?
z1@b2CEztFOn%Sh8Jni44{n@sOoAf?8V*gA9FUrlXQ!01`U95jc^|lIK4*F43+jjXv
zg9Z|C+>W?9t68@VDnAJTfn*<g0sSM7V#&6Dw*mJ!04()Lg|H&gLYqT3LG(evz*36n
zstBV8um%&D(6B}m=ph9Cq~&1|z&@(&1FUM?fu1v4(fdZ5k*t1`0Wk{QbvuK905Agv
zh$b)ty<oDoT0sjq0ssayfziI|e!zfKjp1F#Yo)`S(7^={i~Mvncx*Nij~=)G&zn(3
z%O`{sjq8nx{5&Hh1STmaQb*TUM*~K*uW<)0;XM%#28bgV0w#2>abQbPU8z^pRZA4f
ziZPXp&L@k;s;fwJ-&%)$ZuDwz;N#L>h(4(ALPMT;-VH4FCG(;=%WTcj+tO+rm!-kQ
z!EAFlXYEhx?o#xb{e?QudCyr-CbI0w*7c<K6x_bNJGki%t_@|~!K}M4JyKHD8103o
zz;Zm}&5UFQv+n){{T-)!`9RL;&(i*q4t?rzje3E*^#Oo(Z_&k+2+V(%UBKqSmeGEj
zwqeU?|4Z`W9=~WHhk`ZhgO;J4;Chf8>epTmLj`w|yD8#J5@JN(`yH~a=^BLh<Xg;E
z0{)3eU%_-#1;Cr269@zg#-S1^G}T~`%`HJ#%M#VNL{c~|aNLYeZLvA3lNR)>-U^1F
zuVhcjk_Vk>u|Q>IM=y8i(Tx_t@LzN$t!TKl5o*v(>-OOy!Oz74q!?4CG^>Def5aCQ
zNMk6HQj!ys(lI_cTbUxB8!tqrxOlu+6X&I5k&vRv0EKR~1|3Bmwx@7GNnFBbB?<$>
zAg#YkW5TyX`V|fMUkm+S3us5d*|2nS@#G4db8blwf9GskAPSDUrPyL@If{h5qd!A@
zq+Qjnk-4^hbl&gP{-OmgrcBCT`|m;Mmp=}?p@J9Cp7!mUOG>X9^lJOluvh-J-K&Bh
zqEd$+rje`jARLuboh=Z)h0b+F;ESh2y&;?0wlYxym@@m<rdJP@m1U_ttadFomjI@f
zT@}haTUJzQ9?gb&7zUpjC;?1Y>ne0@K0C&K{z_S~N<$ER66*6f)!vnn62NpdP@#>Q
zjft=HWyL9VBTF|AucDW_H|k}jXO9AI3`O0JxkMxtkM0!L(V?DU%TsD-TL}CH6t2AX
E4}HjyEC2ui

delta 743
zcmY+A-Ahw(7{`Cl+0N{2XFA<%n{MvRnRa}E>D-o<7FhHGOVI+u5~Xs^LSbi`S4QB4
zH`2=^W<@X~Ou-;I5EdoYE?RdECD-T=2(M1Lx+tiAXVFE^#rN~P{&;@R&5`Hf{9U6_
zPpCa{4Ma}XtmGRE>{A-*@pgk1{f1UtF`NT88hAGz;0J9MVlt=A)~t>cn(uOVxQ&w5
zb<L*fD6aBB=Bq~j!bcc+w!p;d!t@nsQ(m?dLG5=PF%{3T_l%!}nr*?C5`0sqws>cn
z-@DB_QoLiE_oR5wMn(G;-y#1hUSr^q{MvSd0T~aMK7^OpXYZ8{I&@%VIxXt9|68XO
z=Z)t2J%0F`7f6_Mlb)h~U3sKmONc;RBs5FN0BO;<$N-3XoG5Fyjhbj%M>H}n437*8
zvFOO?SYqk4$m7qlLxyHri-xGsW@n`x`&<>Qq}~f(xV(7@>PRVqifa){5ZpGABaX^l
z0>$o(O;9wHKO}XFx25_vUYp?cZ6$dLJ5ZIw?hgPT<yKFl26j-YOfwT8hpM`P?<t@Y
zIqNCJCD92iz7qpYA{SLp8XZ(6qRNmelT<Q#Db^p2N!KE=!Q8eP?bV1B%V?y_F_FV#
z)pe}I(LS82_Ue99M|yy3)zeJYBtNeC3}BL{>t-0ZkLBKgE>7#wdF=Hb2SHx&x*1r&
zWJ489qSA04f^x{W4`2qR#!E1S>BeAv5o?KeDTHFN``N{%3t81w_BXM%Igdgp;%zxB
zwrABy8N(xfpUXn0S`<RDYR_SPe52#+o9kIMrPLz&o5~7UcRZvJid8X(q&C_0p3ABk
lr5tzs5m>=9fg~)WGiZZX7zmyyyrKomE%6&s87-rq`2!R_%5eYy

diff --git a/pricewatch/app/stores/amazon/store.py b/pricewatch/app/stores/amazon/store.py
index 713593b..a2bdaca 100755
--- a/pricewatch/app/stores/amazon/store.py
+++ b/pricewatch/app/stores/amazon/store.py
@@ -214,6 +214,18 @@ class AmazonStore(BaseStore):
                     except ValueError:
                         continue
 
+        # Fallback: chercher les spans séparés a-price-whole et a-price-fraction
+        whole = soup.select_one("span.a-price-whole")
+        fraction = soup.select_one("span.a-price-fraction")
+        if whole and fraction:
+            whole_text = whole.get_text(strip=True)
+            fraction_text = fraction.get_text(strip=True)
+            try:
+                price_str = f"{whole_text}.{fraction_text}"
+                return float(price_str)
+            except ValueError:
+                pass
+
         debug.errors.append("Prix non trouvé")
         return None
 
@@ -270,6 +282,14 @@ class AmazonStore(BaseStore):
                 if url and url.startswith("http"):
                     images.append(url)
 
+        # Fallback: chercher tous les img tags si aucune image trouvée
+        if not images:
+            all_imgs = soup.find_all("img")
+            for img in all_imgs:
+                url = img.get("src") or img.get("data-src")
+                if url and url.startswith("http"):
+                    images.append(url)
+
         return list(set(images))  # Dédupliquer
 
     def _extract_category(self, soup: BeautifulSoup, debug: DebugInfo) -> Optional[str]:
diff --git a/pricewatch/app/tasks/__init__.py b/pricewatch/app/tasks/__init__.py
new file mode 100755
index 0000000..7ffa53d
--- /dev/null
+++ b/pricewatch/app/tasks/__init__.py
@@ -0,0 +1,8 @@
+"""
+Module tasks pour les jobs RQ.
+"""
+
+from pricewatch.app.tasks.scrape import scrape_product
+from pricewatch.app.tasks.scheduler import ScrapingScheduler
+
+__all__ = ["scrape_product", "ScrapingScheduler"]
diff --git a/pricewatch/app/tasks/scheduler.py b/pricewatch/app/tasks/scheduler.py
new file mode 100755
index 0000000..628594c
--- /dev/null
+++ b/pricewatch/app/tasks/scheduler.py
@@ -0,0 +1,75 @@
+"""
+Planification des jobs de scraping via RQ Scheduler.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+import redis
+from rq import Queue
+from rq_scheduler import Scheduler
+
+from pricewatch.app.core.config import AppConfig, get_config
+from pricewatch.app.core.logging import get_logger
+from pricewatch.app.tasks.scrape import scrape_product
+
+logger = get_logger("tasks.scheduler")
+
+
+@dataclass
+class ScheduledJobInfo:
+    """Infos de retour pour un job planifie."""
+
+    job_id: str
+    next_run: datetime
+
+
+class ScrapingScheduler:
+    """Scheduler pour les jobs de scraping avec RQ."""
+
+    def __init__(self, config: Optional[AppConfig] = None, queue_name: str = "default") -> None:
+        self.config = config or get_config()
+        self.redis = redis.from_url(self.config.redis.url)
+        self.queue = Queue(queue_name, connection=self.redis)
+        self.scheduler = Scheduler(queue=self.queue, connection=self.redis)
+
+    def enqueue_immediate(
+        self,
+        url: str,
+        use_playwright: Optional[bool] = None,
+        save_db: bool = True,
+    ):
+        """Enqueue un job immediat."""
+        job = self.queue.enqueue(
+            scrape_product,
+            url,
+            use_playwright=use_playwright,
+            save_db=save_db,
+        )
+        logger.info(f"Job enqueued: {job.id}")
+        return job
+
+    def schedule_product(
+        self,
+        url: str,
+        interval_hours: int = 24,
+        use_playwright: Optional[bool] = None,
+        save_db: bool = True,
+    ) -> ScheduledJobInfo:
+        """Planifie un scraping recurrent (intervalle en heures)."""
+        interval_seconds = int(timedelta(hours=interval_hours).total_seconds())
+        next_run = datetime.now(timezone.utc) + timedelta(seconds=interval_seconds)
+
+        job = self.scheduler.schedule(
+            scheduled_time=next_run,
+            func=scrape_product,
+            args=[url],
+            kwargs={"use_playwright": use_playwright, "save_db": save_db},
+            interval=interval_seconds,
+            repeat=None,
+        )
+        logger.info(f"Job planifie: {job.id}, prochaine execution: {next_run.isoformat()}")
+        return ScheduledJobInfo(job_id=job.id, next_run=next_run)
diff --git a/pricewatch/app/tasks/scrape.py b/pricewatch/app/tasks/scrape.py
new file mode 100755
index 0000000..3db721a
--- /dev/null
+++ b/pricewatch/app/tasks/scrape.py
@@ -0,0 +1,160 @@
+"""
+Tache de scraping asynchrone pour RQ.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from pricewatch.app.core.config import AppConfig, get_config
+from pricewatch.app.core.logging import get_logger
+from pricewatch.app.core.registry import get_registry
+from pricewatch.app.core.schema import DebugInfo, DebugStatus, FetchMethod, ProductSnapshot
+from pricewatch.app.scraping.http_fetch import fetch_http
+from pricewatch.app.scraping.pipeline import ScrapingPipeline
+from pricewatch.app.scraping.pw_fetch import fetch_playwright
+from pricewatch.app.stores.aliexpress.store import AliexpressStore
+from pricewatch.app.stores.amazon.store import AmazonStore
+from pricewatch.app.stores.backmarket.store import BackmarketStore
+from pricewatch.app.stores.cdiscount.store import CdiscountStore
+
+logger = get_logger("tasks.scrape")
+
+
+def setup_stores() -> None:
+    """Enregistre les stores disponibles si besoin."""
+    registry = get_registry()
+    if registry.list_stores():
+        return
+    registry.register(AmazonStore())
+    registry.register(CdiscountStore())
+    registry.register(BackmarketStore())
+    registry.register(AliexpressStore())
+
+
+def scrape_product(
+    url: str,
+    use_playwright: Optional[bool] = None,
+    save_db: bool = True,
+    save_html: bool = False,
+    save_screenshot: bool = False,
+    headful: bool = False,
+    timeout_ms: Optional[int] = None,
+) -> dict[str, Any]:
+    """
+    Scrape un produit et persiste en base via ScrapingPipeline.
+
+    Retourne un dict avec success, product_id, snapshot, error.
+    """
+    config: AppConfig = get_config()
+    setup_stores()
+
+    if use_playwright is None:
+        use_playwright = config.default_use_playwright
+
+    if timeout_ms is None:
+        timeout_ms = config.default_playwright_timeout
+
+    registry = get_registry()
+    store = registry.detect_store(url)
+    if not store:
+        snapshot = ProductSnapshot(
+            source="unknown",
+            url=url,
+            debug=DebugInfo(
+                method=FetchMethod.HTTP,
+                status=DebugStatus.FAILED,
+                errors=["Aucun store detecte"],
+            ),
+        )
+        ScrapingPipeline(config=config).process_snapshot(snapshot, save_to_db=save_db)
+        return {"success": False, "product_id": None, "snapshot": snapshot, "error": "store"}
+
+    canonical_url = store.canonicalize(url)
+
+    html = None
+    fetch_method = FetchMethod.HTTP
+    fetch_error = None
+    duration_ms = None
+    html_size_bytes = None
+    pw_result = None
+
+    http_result = fetch_http(canonical_url)
+    duration_ms = http_result.duration_ms
+
+    if http_result.success:
+        html = http_result.html
+        fetch_method = FetchMethod.HTTP
+    elif use_playwright:
+        pw_result = fetch_playwright(
+            canonical_url,
+            headless=not headful,
+            timeout_ms=timeout_ms,
+            save_screenshot=save_screenshot,
+        )
+        duration_ms = pw_result.duration_ms
+
+        if pw_result.success:
+            html = pw_result.html
+            fetch_method = FetchMethod.PLAYWRIGHT
+        else:
+            fetch_error = pw_result.error
+    else:
+        fetch_error = http_result.error
+
+    if html:
+        html_size_bytes = len(html.encode("utf-8"))
+        if save_html:
+            from pricewatch.app.core.io import save_debug_html
+
+            ref = store.extract_reference(canonical_url) or "unknown"
+            save_debug_html(html, f"{store.store_id}_{ref}")
+
+        if save_screenshot and fetch_method == FetchMethod.PLAYWRIGHT and pw_result:
+            from pricewatch.app.core.io import save_debug_screenshot
+
+            if pw_result and pw_result.screenshot:
+                ref = store.extract_reference(canonical_url) or "unknown"
+                save_debug_screenshot(pw_result.screenshot, f"{store.store_id}_{ref}")
+
+        try:
+            snapshot = store.parse(html, canonical_url)
+            snapshot.debug.method = fetch_method
+            snapshot.debug.duration_ms = duration_ms
+            snapshot.debug.html_size_bytes = html_size_bytes
+            success = snapshot.debug.status != DebugStatus.FAILED
+        except Exception as exc:
+            snapshot = ProductSnapshot(
+                source=store.store_id,
+                url=canonical_url,
+                debug=DebugInfo(
+                    method=fetch_method,
+                    status=DebugStatus.FAILED,
+                    errors=[f"Parsing failed: {exc}"],
+                    duration_ms=duration_ms,
+                    html_size_bytes=html_size_bytes,
+                ),
+            )
+            success = False
+            fetch_error = str(exc)
+    else:
+        snapshot = ProductSnapshot(
+            source=store.store_id,
+            url=canonical_url,
+            debug=DebugInfo(
+                method=fetch_method,
+                status=DebugStatus.FAILED,
+                errors=[f"Fetch failed: {fetch_error or 'Unknown error'}"],
+                duration_ms=duration_ms,
+            ),
+        )
+        success = False
+
+    product_id = ScrapingPipeline(config=config).process_snapshot(snapshot, save_to_db=save_db)
+
+    return {
+        "success": success,
+        "product_id": product_id,
+        "snapshot": snapshot,
+        "error": fetch_error,
+    }
diff --git a/pyproject.toml b/pyproject.toml
index 9e92604..4697124 100755
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -44,6 +44,19 @@ dependencies = [
 
     # Date/time utilities
     "python-dateutil>=2.8.2",
+
+    # Database (Phase 2)
+    "sqlalchemy>=2.0.0",
+    "psycopg2-binary>=2.9.0",
+    "alembic>=1.13.0",
+
+    # Configuration (Phase 2)
+    "python-dotenv>=1.0.0",
+
+    # Worker/Queue (Phase 2)
+    "redis>=5.0.0",
+    "rq>=1.15.0",
+    "rq-scheduler>=0.13.0",
 ]
 
 [project.optional-dependencies]
diff --git a/tests/cli/__pycache__/test_run_db.cpython-313-pytest-9.0.2.pyc b/tests/cli/__pycache__/test_run_db.cpython-313-pytest-9.0.2.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..10efd145df471f1746ae06231f1ea9625407316c
GIT binary patch
literal 8336
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
NK(^U-kh8uE{U5Hz(ZT=#

literal 0
HcmV?d00001

diff --git a/tests/cli/test_run_db.py b/tests/cli/test_run_db.py
new file mode 100755
index 0000000..b22274c
--- /dev/null
+++ b/tests/cli/test_run_db.py
@@ -0,0 +1,106 @@
+"""
+Tests end-to-end pour la commande CLI run avec persistence DB.
+"""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from pricewatch.app.cli import main as cli_main
+from pricewatch.app.core.registry import get_registry
+from pricewatch.app.core.schema import DebugInfo, DebugStatus, FetchMethod, ProductSnapshot
+from pricewatch.app.db.connection import get_session, init_db, reset_engine
+from pricewatch.app.db.models import Product
+from pricewatch.app.stores.base import BaseStore
+
+
+@dataclass
+class FakeDbConfig:
+    url: str
+
+
+@dataclass
+class FakeAppConfig:
+    db: FakeDbConfig
+    debug: bool = False
+    enable_db: bool = True
+
+
+class DummyStore(BaseStore):
+    def __init__(self) -> None:
+        super().__init__(store_id="dummy")
+
+    def match(self, url: str) -> float:
+        return 1.0 if "example.com" in url else 0.0
+
+    def canonicalize(self, url: str) -> str:
+        return url
+
+    def extract_reference(self, url: str) -> str | None:
+        return "REF123"
+
+    def parse(self, html: str, url: str) -> ProductSnapshot:
+        return ProductSnapshot(
+            source=self.store_id,
+            url=url,
+            title="Produit dummy",
+            price=9.99,
+            currency="EUR",
+            reference="REF123",
+            debug=DebugInfo(method=FetchMethod.HTTP, status=DebugStatus.SUCCESS),
+        )
+
+
+class DummyFetchResult:
+    def __init__(self, html: str) -> None:
+        self.success = True
+        self.html = html
+        self.error = None
+
+
+def test_cli_run_persists_db(tmp_path, monkeypatch):
+    """Le CLI run persiste en base quand --save-db est active."""
+    reset_engine()
+    db_path = tmp_path / "test.db"
+    config = FakeAppConfig(db=FakeDbConfig(url=f"sqlite:///{db_path}"))
+    init_db(config)
+
+    yaml_path = tmp_path / "config.yaml"
+    out_path = tmp_path / "out.json"
+    yaml_path.write_text(
+        """
+urls:
+  - "https://example.com/product"
+options:
+  use_playwright: false
+  save_html: false
+  save_screenshot: false
+""",
+        encoding="utf-8",
+    )
+
+    registry = get_registry()
+    previous_stores = list(registry._stores)
+    registry._stores = []
+    registry.register(DummyStore())
+
+    monkeypatch.setattr(cli_main, "get_config", lambda: config)
+    monkeypatch.setattr(cli_main, "setup_stores", lambda: None)
+    monkeypatch.setattr(cli_main, "fetch_http", lambda url: DummyFetchResult("<html></html>"))
+
+    runner = CliRunner()
+    try:
+        result = runner.invoke(
+            cli_main.app,
+            ["run", "--yaml", str(yaml_path), "--out", str(out_path), "--save-db"],
+        )
+    finally:
+        registry._stores = previous_stores
+        reset_engine()
+
+    assert result.exit_code == 0
+    assert out_path.exists()
+
+    with get_session(config) as session:
+        assert session.query(Product).count() == 1
diff --git a/tests/core/__pycache__/test_io.cpython-313-pytest-9.0.2.pyc b/tests/core/__pycache__/test_io.cpython-313-pytest-9.0.2.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..88a79f91f7b9b1fd3af055cc2c60226dcad519fc
GIT binary patch
literal 66626
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
PN%u1M$}27q){*}oW*^4h

literal 0
HcmV?d00001

diff --git a/tests/core/__pycache__/test_registry_integration.cpython-313-pytest-9.0.2.pyc b/tests/core/__pycache__/test_registry_integration.cpython-313-pytest-9.0.2.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..0f51b6bee61d2b98f3167a540745cd550352aee7
GIT binary patch
literal 33442
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
A2LJ#7

literal 0
HcmV?d00001

diff --git a/tests/core/test_io.py b/tests/core/test_io.py
new file mode 100755
index 0000000..db2edcb
--- /dev/null
+++ b/tests/core/test_io.py
@@ -0,0 +1,462 @@
+"""
+Tests pour pricewatch.app.core.io
+
+Teste la lecture/écriture YAML/JSON et les fonctions de sauvegarde debug.
+"""
+
+import json
+import tempfile
+from datetime import datetime
+from pathlib import Path
+
+import pytest
+import yaml
+
+from pricewatch.app.core.io import (
+    ScrapingConfig,
+    ScrapingOptions,
+    read_json_results,
+    read_yaml_config,
+    save_debug_html,
+    save_debug_screenshot,
+    write_json_results,
+)
+from pricewatch.app.core.schema import (
+    DebugInfo,
+    DebugStatus,
+    FetchMethod,
+    ProductSnapshot,
+    StockStatus,
+)
+
+
+class TestScrapingOptions:
+    """Tests pour le modèle ScrapingOptions."""
+
+    def test_default_values(self):
+        """Les valeurs par défaut sont correctes."""
+        options = ScrapingOptions()
+        assert options.use_playwright is True
+        assert options.headful is False
+        assert options.save_html is True
+        assert options.save_screenshot is True
+        assert options.timeout_ms == 60000
+
+    def test_custom_values(self):
+        """Les valeurs personnalisées sont acceptées."""
+        options = ScrapingOptions(
+            use_playwright=False,
+            headful=True,
+            save_html=False,
+            save_screenshot=False,
+            timeout_ms=30000,
+        )
+        assert options.use_playwright is False
+        assert options.headful is True
+        assert options.save_html is False
+        assert options.save_screenshot is False
+        assert options.timeout_ms == 30000
+
+    def test_timeout_validation_min(self):
+        """Timeout inférieur à 1000ms est rejeté."""
+        with pytest.raises(ValueError):
+            ScrapingOptions(timeout_ms=500)
+
+    def test_timeout_validation_valid(self):
+        """Timeout >= 1000ms est accepté."""
+        options = ScrapingOptions(timeout_ms=1000)
+        assert options.timeout_ms == 1000
+
+
+class TestScrapingConfig:
+    """Tests pour le modèle ScrapingConfig."""
+
+    def test_minimal_config(self):
+        """Config minimale avec URLs uniquement."""
+        config = ScrapingConfig(urls=["https://example.com"])
+        assert len(config.urls) == 1
+        assert config.urls[0] == "https://example.com"
+        assert isinstance(config.options, ScrapingOptions)
+
+    def test_config_with_options(self):
+        """Config avec URLs et options."""
+        options = ScrapingOptions(use_playwright=False, timeout_ms=10000)
+        config = ScrapingConfig(
+            urls=["https://example.com", "https://test.com"], options=options
+        )
+        assert len(config.urls) == 2
+        assert config.options.use_playwright is False
+        assert config.options.timeout_ms == 10000
+
+    def test_validate_urls_empty_list(self):
+        """Liste d'URLs vide est rejetée."""
+        with pytest.raises(ValueError, match="Au moins une URL"):
+            ScrapingConfig(urls=[])
+
+    def test_validate_urls_strips_whitespace(self):
+        """Les espaces sont nettoyés."""
+        config = ScrapingConfig(urls=["  https://example.com  ", "https://test.com"])
+        assert config.urls == ["https://example.com", "https://test.com"]
+
+    def test_validate_urls_removes_empty(self):
+        """Les URLs vides sont supprimées."""
+        config = ScrapingConfig(
+            urls=["https://example.com", "", "  ", "https://test.com"]
+        )
+        assert len(config.urls) == 2
+        assert config.urls == ["https://example.com", "https://test.com"]
+
+    def test_validate_urls_all_empty(self):
+        """Si toutes les URLs sont vides, erreur."""
+        with pytest.raises(ValueError, match="Aucune URL valide"):
+            ScrapingConfig(urls=["", "  ", "\t"])
+
+
+class TestReadYamlConfig:
+    """Tests pour read_yaml_config()."""
+
+    def test_read_valid_yaml(self, tmp_path):
+        """Lit un fichier YAML valide."""
+        yaml_path = tmp_path / "config.yaml"
+        yaml_content = {
+            "urls": ["https://example.com", "https://test.com"],
+            "options": {"use_playwright": False, "timeout_ms": 30000},
+        }
+        with open(yaml_path, "w") as f:
+            yaml.dump(yaml_content, f)
+
+        config = read_yaml_config(yaml_path)
+        assert len(config.urls) == 2
+        assert config.urls[0] == "https://example.com"
+        assert config.options.use_playwright is False
+        assert config.options.timeout_ms == 30000
+
+    def test_read_yaml_minimal(self, tmp_path):
+        """Lit un YAML minimal (URLs uniquement)."""
+        yaml_path = tmp_path / "config.yaml"
+        yaml_content = {"urls": ["https://example.com"]}
+        with open(yaml_path, "w") as f:
+            yaml.dump(yaml_content, f)
+
+        config = read_yaml_config(yaml_path)
+        assert len(config.urls) == 1
+        # Options par défaut
+        assert config.options.use_playwright is True
+        assert config.options.timeout_ms == 60000
+
+    def test_read_yaml_file_not_found(self, tmp_path):
+        """Fichier introuvable lève FileNotFoundError."""
+        yaml_path = tmp_path / "nonexistent.yaml"
+        with pytest.raises(FileNotFoundError):
+            read_yaml_config(yaml_path)
+
+    def test_read_yaml_empty_file(self, tmp_path):
+        """Fichier YAML vide lève ValueError."""
+        yaml_path = tmp_path / "empty.yaml"
+        yaml_path.write_text("")
+
+        with pytest.raises(ValueError, match="Fichier YAML vide"):
+            read_yaml_config(yaml_path)
+
+    def test_read_yaml_invalid_syntax(self, tmp_path):
+        """YAML avec syntaxe invalide lève ValueError."""
+        yaml_path = tmp_path / "invalid.yaml"
+        yaml_path.write_text("urls: [invalid yaml syntax")
+
+        with pytest.raises(ValueError, match="YAML invalide"):
+            read_yaml_config(yaml_path)
+
+    def test_read_yaml_missing_urls(self, tmp_path):
+        """YAML sans champ 'urls' lève erreur de validation."""
+        yaml_path = tmp_path / "config.yaml"
+        yaml_content = {"options": {"use_playwright": False}}
+        with open(yaml_path, "w") as f:
+            yaml.dump(yaml_content, f)
+
+        with pytest.raises(Exception):  # Pydantic validation error
+            read_yaml_config(yaml_path)
+
+    def test_read_yaml_accepts_path_string(self, tmp_path):
+        """Accepte un string comme chemin."""
+        yaml_path = tmp_path / "config.yaml"
+        yaml_content = {"urls": ["https://example.com"]}
+        with open(yaml_path, "w") as f:
+            yaml.dump(yaml_content, f)
+
+        config = read_yaml_config(str(yaml_path))
+        assert len(config.urls) == 1
+
+
+class TestWriteJsonResults:
+    """Tests pour write_json_results()."""
+
+    @pytest.fixture
+    def sample_snapshot(self) -> ProductSnapshot:
+        """Fixture: ProductSnapshot exemple."""
+        return ProductSnapshot(
+            source="test",
+            url="https://example.com/product",
+            fetched_at=datetime(2024, 1, 1, 12, 0, 0),
+            title="Test Product",
+            price=99.99,
+            currency="EUR",
+            stock_status=StockStatus.IN_STOCK,
+            reference="TEST123",
+            images=["https://example.com/img1.jpg"],
+            category="Test Category",
+            specs={"Brand": "TestBrand"},
+            debug=DebugInfo(
+                method=FetchMethod.HTTP,
+                status=DebugStatus.SUCCESS,
+                errors=[],
+                notes=[],
+            ),
+        )
+
+    def test_write_single_snapshot(self, tmp_path, sample_snapshot):
+        """Écrit un seul snapshot."""
+        json_path = tmp_path / "results.json"
+        write_json_results([sample_snapshot], json_path)
+
+        assert json_path.exists()
+
+        # Vérifier le contenu
+        with open(json_path) as f:
+            data = json.load(f)
+
+        assert isinstance(data, list)
+        assert len(data) == 1
+        assert data[0]["source"] == "test"
+        assert data[0]["title"] == "Test Product"
+
+    def test_write_multiple_snapshots(self, tmp_path, sample_snapshot):
+        """Écrit plusieurs snapshots."""
+        snapshot2 = ProductSnapshot(
+            source="test2",
+            url="https://example.com/product2",
+            fetched_at=datetime(2024, 1, 2, 12, 0, 0),
+            title="Test Product 2",
+            price=49.99,
+            currency="EUR",
+            stock_status=StockStatus.OUT_OF_STOCK,
+            debug=DebugInfo(
+                method=FetchMethod.PLAYWRIGHT,
+                status=DebugStatus.PARTIAL,
+                errors=["Test error"],
+                notes=[],
+            ),
+        )
+
+        json_path = tmp_path / "results.json"
+        write_json_results([sample_snapshot, snapshot2], json_path)
+
+        with open(json_path) as f:
+            data = json.load(f)
+
+        assert len(data) == 2
+        assert data[0]["source"] == "test"
+        assert data[1]["source"] == "test2"
+
+    def test_write_creates_parent_dirs(self, tmp_path, sample_snapshot):
+        """Crée les dossiers parents si nécessaire."""
+        json_path = tmp_path / "sub" / "dir" / "results.json"
+        write_json_results([sample_snapshot], json_path)
+
+        assert json_path.exists()
+        assert json_path.parent.exists()
+
+    def test_write_empty_list(self, tmp_path):
+        """Écrit une liste vide."""
+        json_path = tmp_path / "empty.json"
+        write_json_results([], json_path)
+
+        assert json_path.exists()
+
+        with open(json_path) as f:
+            data = json.load(f)
+
+        assert data == []
+
+    def test_write_indent_control(self, tmp_path, sample_snapshot):
+        """Contrôle l'indentation."""
+        # Avec indent
+        json_path1 = tmp_path / "pretty.json"
+        write_json_results([sample_snapshot], json_path1, indent=2)
+        content1 = json_path1.read_text()
+        assert "\n" in content1  # Pretty-printed
+
+        # Sans indent (compact)
+        json_path2 = tmp_path / "compact.json"
+        write_json_results([sample_snapshot], json_path2, indent=None)
+        content2 = json_path2.read_text()
+        assert len(content2) < len(content1)  # Plus compact
+
+    def test_write_accepts_path_string(self, tmp_path, sample_snapshot):
+        """Accepte un string comme chemin."""
+        json_path = tmp_path / "results.json"
+        write_json_results([sample_snapshot], str(json_path))
+        assert json_path.exists()
+
+
+class TestReadJsonResults:
+    """Tests pour read_json_results()."""
+
+    @pytest.fixture
+    def json_file_with_snapshot(self, tmp_path) -> Path:
+        """Fixture: Fichier JSON avec un snapshot."""
+        json_path = tmp_path / "results.json"
+        snapshot_data = {
+            "source": "test",
+            "url": "https://example.com/product",
+            "fetched_at": "2024-01-01T12:00:00",
+            "title": "Test Product",
+            "price": 99.99,
+            "currency": "EUR",
+            "shipping_cost": None,
+            "stock_status": "in_stock",
+            "reference": "TEST123",
+            "images": ["https://example.com/img.jpg"],
+            "category": "Test",
+            "specs": {"Brand": "Test"},
+            "debug": {
+                "method": "http",
+                "status": "success",
+                "errors": [],
+                "notes": [],
+                "duration_ms": None,
+                "html_size_bytes": None,
+            },
+        }
+
+        with open(json_path, "w") as f:
+            json.dump([snapshot_data], f)
+
+        return json_path
+
+    def test_read_single_snapshot(self, json_file_with_snapshot):
+        """Lit un fichier avec un snapshot."""
+        snapshots = read_json_results(json_file_with_snapshot)
+
+        assert len(snapshots) == 1
+        assert isinstance(snapshots[0], ProductSnapshot)
+        assert snapshots[0].source == "test"
+        assert snapshots[0].title == "Test Product"
+        assert snapshots[0].price == 99.99
+
+    def test_read_file_not_found(self, tmp_path):
+        """Fichier introuvable lève FileNotFoundError."""
+        json_path = tmp_path / "nonexistent.json"
+        with pytest.raises(FileNotFoundError):
+            read_json_results(json_path)
+
+    def test_read_invalid_json(self, tmp_path):
+        """JSON invalide lève ValueError."""
+        json_path = tmp_path / "invalid.json"
+        json_path.write_text("{invalid json")
+
+        with pytest.raises(ValueError, match="JSON invalide"):
+            read_json_results(json_path)
+
+    def test_read_not_a_list(self, tmp_path):
+        """JSON qui n'est pas une liste lève ValueError."""
+        json_path = tmp_path / "notlist.json"
+        with open(json_path, "w") as f:
+            json.dump({"key": "value"}, f)
+
+        with pytest.raises(ValueError, match="doit contenir une liste"):
+            read_json_results(json_path)
+
+    def test_read_empty_list(self, tmp_path):
+        """Liste vide est acceptée."""
+        json_path = tmp_path / "empty.json"
+        with open(json_path, "w") as f:
+            json.dump([], f)
+
+        snapshots = read_json_results(json_path)
+        assert snapshots == []
+
+    def test_read_accepts_path_string(self, json_file_with_snapshot):
+        """Accepte un string comme chemin."""
+        snapshots = read_json_results(str(json_file_with_snapshot))
+        assert len(snapshots) == 1
+
+
+class TestSaveDebugHtml:
+    """Tests pour save_debug_html()."""
+
+    def test_save_html_default_dir(self, tmp_path, monkeypatch):
+        """Sauvegarde HTML dans le dossier par défaut."""
+        # Changer le répertoire de travail pour le test
+        monkeypatch.chdir(tmp_path)
+
+        html = "<html><body>Test</body></html>"
+        result_path = save_debug_html(html, "test_page")
+
+        assert result_path.exists()
+        assert result_path.name == "test_page.html"
+        assert result_path.read_text(encoding="utf-8") == html
+
+    def test_save_html_custom_dir(self, tmp_path):
+        """Sauvegarde HTML dans un dossier personnalisé."""
+        output_dir = tmp_path / "debug_html"
+        html = "<html><body>Test</body></html>"
+
+        result_path = save_debug_html(html, "test_page", output_dir)
+
+        assert result_path.parent == output_dir
+        assert result_path.name == "test_page.html"
+        assert result_path.read_text(encoding="utf-8") == html
+
+    def test_save_html_creates_dir(self, tmp_path):
+        """Crée le dossier de sortie s'il n'existe pas."""
+        output_dir = tmp_path / "sub" / "dir" / "html"
+        html = "<html><body>Test</body></html>"
+
+        result_path = save_debug_html(html, "test_page", output_dir)
+
+        assert output_dir.exists()
+        assert result_path.exists()
+
+    def test_save_html_large_content(self, tmp_path):
+        """Sauvegarde du HTML volumineux."""
+        html = "<html><body>" + ("x" * 100000) + "</body></html>"
+        result_path = save_debug_html(html, "large_page", tmp_path)
+
+        assert result_path.exists()
+        assert len(result_path.read_text(encoding="utf-8")) == len(html)
+
+
+class TestSaveDebugScreenshot:
+    """Tests pour save_debug_screenshot()."""
+
+    def test_save_screenshot_default_dir(self, tmp_path, monkeypatch):
+        """Sauvegarde screenshot dans le dossier par défaut."""
+        monkeypatch.chdir(tmp_path)
+
+        screenshot_bytes = b"\x89PNG fake image data"
+        result_path = save_debug_screenshot(screenshot_bytes, "test_screenshot")
+
+        assert result_path.exists()
+        assert result_path.name == "test_screenshot.png"
+        assert result_path.read_bytes() == screenshot_bytes
+
+    def test_save_screenshot_custom_dir(self, tmp_path):
+        """Sauvegarde screenshot dans un dossier personnalisé."""
+        output_dir = tmp_path / "screenshots"
+        screenshot_bytes = b"\x89PNG fake image data"
+
+        result_path = save_debug_screenshot(screenshot_bytes, "test_screenshot", output_dir)
+
+        assert result_path.parent == output_dir
+        assert result_path.name == "test_screenshot.png"
+        assert result_path.read_bytes() == screenshot_bytes
+
+    def test_save_screenshot_creates_dir(self, tmp_path):
+        """Crée le dossier de sortie s'il n'existe pas."""
+        output_dir = tmp_path / "sub" / "dir" / "screenshots"
+        screenshot_bytes = b"\x89PNG fake image data"
+
+        result_path = save_debug_screenshot(screenshot_bytes, "test_screenshot", output_dir)
+
+        assert output_dir.exists()
+        assert result_path.exists()
diff --git a/tests/core/test_registry_integration.py b/tests/core/test_registry_integration.py
new file mode 100755
index 0000000..a8f6076
--- /dev/null
+++ b/tests/core/test_registry_integration.py
@@ -0,0 +1,174 @@
+"""
+Tests d'intégration pour le registry avec les stores réels.
+
+Teste la détection automatique du bon store pour des URLs
+Amazon, Cdiscount, Backmarket et AliExpress.
+"""
+
+import pytest
+
+from pricewatch.app.core.registry import StoreRegistry
+from pricewatch.app.stores.amazon.store import AmazonStore
+from pricewatch.app.stores.cdiscount.store import CdiscountStore
+from pricewatch.app.stores.backmarket.store import BackmarketStore
+from pricewatch.app.stores.aliexpress.store import AliexpressStore
+
+
+class TestRegistryRealStores:
+    """Tests d'intégration avec les 4 stores réels."""
+
+    @pytest.fixture
+    def registry_with_all_stores(self) -> StoreRegistry:
+        """Fixture: Registry avec les 4 stores réels enregistrés."""
+        registry = StoreRegistry()
+        registry.register(AmazonStore())
+        registry.register(CdiscountStore())
+        registry.register(BackmarketStore())
+        registry.register(AliexpressStore())
+        return registry
+
+    def test_all_stores_registered(self, registry_with_all_stores):
+        """Vérifie que les 4 stores sont enregistrés."""
+        assert len(registry_with_all_stores) == 4
+        stores = registry_with_all_stores.list_stores()
+        assert "amazon" in stores
+        assert "cdiscount" in stores
+        assert "backmarket" in stores
+        assert "aliexpress" in stores
+
+    def test_detect_amazon_fr(self, registry_with_all_stores):
+        """Détecte Amazon.fr correctement."""
+        url = "https://www.amazon.fr/dp/B08N5WRWNW"
+        store = registry_with_all_stores.detect_store(url)
+        assert store is not None
+        assert store.store_id == "amazon"
+
+    def test_detect_amazon_com(self, registry_with_all_stores):
+        """Détecte Amazon.com correctement."""
+        url = "https://www.amazon.com/dp/B08N5WRWNW"
+        store = registry_with_all_stores.detect_store(url)
+        assert store is not None
+        assert store.store_id == "amazon"
+
+    def test_detect_amazon_with_product_name(self, registry_with_all_stores):
+        """Détecte Amazon avec nom de produit dans l'URL."""
+        url = "https://www.amazon.fr/Product-Name-Here/dp/B08N5WRWNW/ref=sr_1_1"
+        store = registry_with_all_stores.detect_store(url)
+        assert store is not None
+        assert store.store_id == "amazon"
+
+    def test_detect_cdiscount(self, registry_with_all_stores):
+        """Détecte Cdiscount correctement."""
+        url = "https://www.cdiscount.com/informatique/clavier-souris-webcam/example/f-1070123-example.html"
+        store = registry_with_all_stores.detect_store(url)
+        assert store is not None
+        assert store.store_id == "cdiscount"
+
+    def test_detect_backmarket(self, registry_with_all_stores):
+        """Détecte Backmarket correctement."""
+        url = "https://www.backmarket.fr/fr-fr/p/iphone-15-pro"
+        store = registry_with_all_stores.detect_store(url)
+        assert store is not None
+        assert store.store_id == "backmarket"
+
+    def test_detect_backmarket_locale_en(self, registry_with_all_stores):
+        """Détecte Backmarket avec locale anglais."""
+        url = "https://www.backmarket.fr/en-fr/p/macbook-air-15-2024"
+        store = registry_with_all_stores.detect_store(url)
+        assert store is not None
+        assert store.store_id == "backmarket"
+
+    def test_detect_aliexpress_fr(self, registry_with_all_stores):
+        """Détecte AliExpress.fr correctement."""
+        url = "https://fr.aliexpress.com/item/1005007187023722.html"
+        store = registry_with_all_stores.detect_store(url)
+        assert store is not None
+        assert store.store_id == "aliexpress"
+
+    def test_detect_aliexpress_com(self, registry_with_all_stores):
+        """Détecte AliExpress.com correctement."""
+        url = "https://www.aliexpress.com/item/1005007187023722.html"
+        store = registry_with_all_stores.detect_store(url)
+        assert store is not None
+        assert store.store_id == "aliexpress"
+
+    def test_detect_unknown_store(self, registry_with_all_stores):
+        """URL inconnue retourne None."""
+        url = "https://www.ebay.com/itm/123456789"
+        store = registry_with_all_stores.detect_store(url)
+        assert store is None
+
+    def test_detect_invalid_url(self, registry_with_all_stores):
+        """URL invalide retourne None."""
+        url = "not-a-valid-url"
+        store = registry_with_all_stores.detect_store(url)
+        assert store is None
+
+    def test_detect_priority_amazon_over_others(self, registry_with_all_stores):
+        """Amazon.fr doit avoir le meilleur score pour ses URLs."""
+        url = "https://www.amazon.fr/dp/B08N5WRWNW"
+        store = registry_with_all_stores.detect_store(url)
+        # Amazon.fr devrait avoir score 0.9, les autres 0.0
+        assert store.store_id == "amazon"
+
+    def test_each_store_matches_only_own_urls(self, registry_with_all_stores):
+        """Chaque store ne matche que ses propres URLs."""
+        test_cases = [
+            ("https://www.amazon.fr/dp/B08N5WRWNW", "amazon"),
+            ("https://www.cdiscount.com/product", "cdiscount"),
+            ("https://www.backmarket.fr/fr-fr/p/product", "backmarket"),
+            ("https://fr.aliexpress.com/item/12345.html", "aliexpress"),
+        ]
+
+        for url, expected_store_id in test_cases:
+            store = registry_with_all_stores.detect_store(url)
+            assert store is not None, f"Aucun store détecté pour {url}"
+            assert store.store_id == expected_store_id, (
+                f"Mauvais store pour {url}: "
+                f"attendu {expected_store_id}, obtenu {store.store_id}"
+            )
+
+    def test_get_store_by_id(self, registry_with_all_stores):
+        """Récupère chaque store par son ID."""
+        amazon = registry_with_all_stores.get_store("amazon")
+        assert amazon is not None
+        assert isinstance(amazon, AmazonStore)
+
+        cdiscount = registry_with_all_stores.get_store("cdiscount")
+        assert cdiscount is not None
+        assert isinstance(cdiscount, CdiscountStore)
+
+        backmarket = registry_with_all_stores.get_store("backmarket")
+        assert backmarket is not None
+        assert isinstance(backmarket, BackmarketStore)
+
+        aliexpress = registry_with_all_stores.get_store("aliexpress")
+        assert aliexpress is not None
+        assert isinstance(aliexpress, AliexpressStore)
+
+    def test_unregister_store(self, registry_with_all_stores):
+        """Désenregistre un store et vérifie qu'il n'est plus détecté."""
+        assert len(registry_with_all_stores) == 4
+
+        # Désenregistrer Amazon
+        removed = registry_with_all_stores.unregister("amazon")
+        assert removed is True
+        assert len(registry_with_all_stores) == 3
+
+        # Amazon ne doit plus être détecté
+        store = registry_with_all_stores.detect_store("https://www.amazon.fr/dp/B08N5WRWNW")
+        assert store is None
+
+        # Les autres stores doivent toujours fonctionner
+        store = registry_with_all_stores.detect_store("https://www.cdiscount.com/product")
+        assert store is not None
+        assert store.store_id == "cdiscount"
+
+    def test_repr_includes_all_stores(self, registry_with_all_stores):
+        """La représentation string inclut tous les stores."""
+        repr_str = repr(registry_with_all_stores)
+        assert "StoreRegistry" in repr_str
+        assert "amazon" in repr_str
+        assert "cdiscount" in repr_str
+        assert "backmarket" in repr_str
+        assert "aliexpress" in repr_str
diff --git a/tests/db/__pycache__/test_connection.cpython-313-pytest-9.0.2.pyc b/tests/db/__pycache__/test_connection.cpython-313-pytest-9.0.2.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..e883ddc6b189a8ea889201b22cdf234898b11acc
GIT binary patch
literal 9521
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
Z!k@Y`hVZGKP9HyV=Z)`xXN0c!{{aso&yxTE

literal 0
HcmV?d00001

diff --git a/tests/db/__pycache__/test_models.cpython-313-pytest-9.0.2.pyc b/tests/db/__pycache__/test_models.cpython-313-pytest-9.0.2.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..4dfdd8da99e318e6ef62bba1ab6e19d46bb88555
GIT binary patch
literal 8164
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

literal 0
HcmV?d00001

diff --git a/tests/db/__pycache__/test_repository.cpython-313-pytest-9.0.2.pyc b/tests/db/__pycache__/test_repository.cpython-313-pytest-9.0.2.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..83e10c207edb2636d468cca9107133f3cc22b401
GIT binary patch
literal 12706
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
PfStTI^dHc0lFIhK^g~@d

literal 0
HcmV?d00001

diff --git a/tests/db/test_connection.py b/tests/db/test_connection.py
new file mode 100755
index 0000000..3b45792
--- /dev/null
+++ b/tests/db/test_connection.py
@@ -0,0 +1,87 @@
+"""
+Tests pour la couche de connexion SQLAlchemy.
+"""
+
+from dataclasses import dataclass
+
+import pytest
+from sqlalchemy import inspect
+
+from pricewatch.app.db.connection import (
+    check_db_connection,
+    get_engine,
+    get_session,
+    init_db,
+    reset_engine,
+)
+from pricewatch.app.db.models import Product
+
+
+@dataclass
+class FakeDbConfig:
+    """Config DB minimale pour tests SQLite."""
+
+    url: str
+    host: str = "sqlite"
+    port: int = 0
+    database: str = ":memory:"
+
+
+@dataclass
+class FakeAppConfig:
+    """Config App minimale pour tests."""
+
+    db: FakeDbConfig
+    debug: bool = False
+
+
+@pytest.fixture(autouse=True)
+def reset_db_engine():
+    """Reset l'engine global entre les tests."""
+    reset_engine()
+    yield
+    reset_engine()
+
+
+@pytest.fixture
+def sqlite_config() -> FakeAppConfig:
+    """Config SQLite in-memory pour tests."""
+    return FakeAppConfig(db=FakeDbConfig(url="sqlite:///:memory:"))
+
+
+def test_get_engine_sqlite(sqlite_config: FakeAppConfig):
+    """Cree un engine SQLite fonctionnel."""
+    engine = get_engine(sqlite_config)
+    assert engine.url.get_backend_name() == "sqlite"
+
+
+def test_init_db_creates_tables(sqlite_config: FakeAppConfig):
+    """Init DB cree toutes les tables attendues."""
+    init_db(sqlite_config)
+    engine = get_engine(sqlite_config)
+    inspector = inspect(engine)
+    tables = set(inspector.get_table_names())
+    assert "products" in tables
+    assert "price_history" in tables
+    assert "product_images" in tables
+    assert "product_specs" in tables
+    assert "scraping_logs" in tables
+
+
+def test_get_session_commit(sqlite_config: FakeAppConfig):
+    """La session permet un commit simple."""
+    init_db(sqlite_config)
+
+    with get_session(sqlite_config) as session:
+        product = Product(source="amazon", reference="B08N5WRWNW", url="https://example.com")
+        session.add(product)
+        session.commit()
+
+    with get_session(sqlite_config) as session:
+        assert session.query(Product).count() == 1
+
+
+def test_check_db_connection(sqlite_config: FakeAppConfig):
+    """Le health check DB retourne True en SQLite."""
+    init_db(sqlite_config)
+    assert check_db_connection(sqlite_config) is True
diff --git a/tests/db/test_models.py b/tests/db/test_models.py
new file mode 100755
index 0000000..34f6e20
--- /dev/null
+++ b/tests/db/test_models.py
@@ -0,0 +1,89 @@
+"""
+Tests pour les modeles SQLAlchemy.
+"""
+
+from datetime import datetime
+
+import pytest
+from sqlalchemy import create_engine
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import Session, sessionmaker
+
+from pricewatch.app.db.models import (
+    Base,
+    PriceHistory,
+    Product,
+    ProductImage,
+    ProductSpec,
+    ScrapingLog,
+)
+
+
+@pytest.fixture
+def session() -> Session:
+    """Session SQLite in-memory pour tests de modeles."""
+    engine = create_engine("sqlite:///:memory:")
+    Base.metadata.create_all(engine)
+    SessionLocal = sessionmaker(bind=engine)
+    session = SessionLocal()
+    try:
+        yield session
+    finally:
+        session.close()
+
+
+def test_product_relationships(session: Session):
+    """Les relations principales fonctionnent (prix, images, specs, logs)."""
+    product = Product(source="amazon", reference="B08N5WRWNW", url="https://example.com")
+
+    price = PriceHistory(
+        price=199.99,
+        shipping_cost=0,
+        stock_status="in_stock",
+        fetch_method="http",
+        fetch_status="success",
+        fetched_at=datetime.utcnow(),
+    )
+    image = ProductImage(image_url="https://example.com/image.jpg", position=0)
+    spec = ProductSpec(spec_key="Couleur", spec_value="Noir")
+    log = ScrapingLog(
+        url="https://example.com",
+        source="amazon",
+        reference="B08N5WRWNW",
+        fetch_method="http",
+        fetch_status="success",
+        fetched_at=datetime.utcnow(),
+        duration_ms=1200,
+        html_size_bytes=2048,
+        errors={"items": []},
+        notes={"items": ["OK"]},
+    )
+
+    product.price_history.append(price)
+    product.images.append(image)
+    product.specs.append(spec)
+    product.logs.append(log)
+
+    session.add(product)
+    session.commit()
+
+    loaded = session.query(Product).first()
+    assert loaded is not None
+    assert len(loaded.price_history) == 1
+    assert len(loaded.images) == 1
+    assert len(loaded.specs) == 1
+    assert len(loaded.logs) == 1
+
+
+def test_unique_product_constraint(session: Session):
+    """La contrainte unique source+reference est respectee."""
+    product_a = Product(source="amazon", reference="B08N5WRWNW", url="https://example.com/a")
+    product_b = Product(source="amazon", reference="B08N5WRWNW", url="https://example.com/b")
+
+    session.add(product_a)
+    session.commit()
+
+    session.add(product_b)
+    with pytest.raises(IntegrityError):
+        session.commit()
+    session.rollback()
diff --git a/tests/db/test_repository.py b/tests/db/test_repository.py
new file mode 100755
index 0000000..d93824a
--- /dev/null
+++ b/tests/db/test_repository.py
@@ -0,0 +1,82 @@
+"""
+Tests pour le repository SQLAlchemy.
+"""
+
+from datetime import datetime
+
+import pytest
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session, sessionmaker
+
+from pricewatch.app.core.schema import DebugInfo, DebugStatus, FetchMethod, ProductSnapshot
+from pricewatch.app.db.models import Base, Product, ScrapingLog
+from pricewatch.app.db.repository import ProductRepository
+
+
+@pytest.fixture
+def session() -> Session:
+    """Session SQLite in-memory pour tests repository."""
+    engine = create_engine("sqlite:///:memory:")
+    Base.metadata.create_all(engine)
+    SessionLocal = sessionmaker(bind=engine)
+    session = SessionLocal()
+    try:
+        yield session
+    finally:
+        session.close()
+        engine.dispose()
+
+
+def _make_snapshot(reference: str | None) -> ProductSnapshot:
+    return ProductSnapshot(
+        source="amazon",
+        url="https://example.com/product",
+        fetched_at=datetime(2026, 1, 14, 12, 0, 0),
+        title="Produit test",
+        price=199.99,
+        currency="EUR",
+        shipping_cost=0.0,
+        reference=reference,
+        images=["https://example.com/img1.jpg"],
+        specs={"Couleur": "Noir"},
+        debug=DebugInfo(
+            method=FetchMethod.HTTP,
+            status=DebugStatus.SUCCESS,
+            errors=["Avertissement"],
+            notes=["OK"],
+        ),
+    )
+
+
+def test_save_snapshot_creates_product(session: Session):
+    """Le repository persiste produit + log."""
+    repo = ProductRepository(session)
+    snapshot = _make_snapshot(reference="B08N5WRWNW")
+
+    product_id = repo.save_snapshot(snapshot)
+    session.commit()
+
+    product = session.query(Product).one()
+    assert product.id == product_id
+    assert product.reference == "B08N5WRWNW"
+    assert len(product.images) == 1
+    assert len(product.specs) == 1
+    assert len(product.price_history) == 1
+
+    log = session.query(ScrapingLog).one()
+    assert log.product_id == product_id
+    assert log.errors == ["Avertissement"]
+    assert log.notes == ["OK"]
+
+
+def test_save_snapshot_without_reference(session: Session):
+    """Sans reference, le produit n'est pas cree mais le log existe."""
+    repo = ProductRepository(session)
+    snapshot = _make_snapshot(reference=None)
+
+    product_id = repo.save_snapshot(snapshot)
+    session.commit()
+
+    assert product_id is None
+    assert session.query(Product).count() == 0
+    assert session.query(ScrapingLog).count() == 1
diff --git a/tests/scraping/__init__.py b/tests/scraping/__init__.py
new file mode 100755
index 0000000..e69de29
diff --git a/tests/scraping/__pycache__/__init__.cpython-313.pyc b/tests/scraping/__pycache__/__init__.cpython-313.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..7701a564e1ffc273086305ce65e86c0f0382e35b
GIT binary patch
literal 151
zcmey&%ge<81glijGePuY5CH>>P{wB#AY&>+I)f&o-%5reCLr%KNa~iEenx(7s(yNA
zPEKmEenC-wR%&udv3_xKQDT99Nop~Sotc-eA0MBYmst`YuUAlci^C>2KczG$)vkyY
UXbi}jVi4maGb1Bo5i^hl0KxqvDgXcg

literal 0
HcmV?d00001

diff --git a/tests/scraping/__pycache__/test_http_fetch.cpython-313-pytest-9.0.2.pyc b/tests/scraping/__pycache__/test_http_fetch.cpython-313-pytest-9.0.2.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..6cd0c6aca3d3b782aa20fc0a1a82eac22fea0758
GIT binary patch
literal 49501
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
LUv&}X&+PvJ#SF?1

literal 0
HcmV?d00001

diff --git a/tests/scraping/__pycache__/test_pipeline.cpython-313-pytest-9.0.2.pyc b/tests/scraping/__pycache__/test_pipeline.cpython-313-pytest-9.0.2.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..7b80cbd5a7bea73178cde1f29640d842122465ac
GIT binary patch
literal 7087
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
MZ4EYaL+p_L-*feMMF0Q*

literal 0
HcmV?d00001

diff --git a/tests/scraping/__pycache__/test_pw_fetch.cpython-313-pytest-9.0.2.pyc b/tests/scraping/__pycache__/test_pw_fetch.cpython-313-pytest-9.0.2.pyc
new file mode 100755
index 0000000000000000000000000000000000000000..98b5db2ab18d5dc336a5293d50265d560209b0b8
GIT binary patch
literal 44576
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
MG<@I@KjLivAK{1UXaE2J

literal 0
HcmV?d00001

diff --git a/tests/scraping/test_http_fetch.py b/tests/scraping/test_http_fetch.py
new file mode 100755
index 0000000..b54cfa4
--- /dev/null
+++ b/tests/scraping/test_http_fetch.py
@@ -0,0 +1,290 @@
+"""
+Tests pour pricewatch.app.scraping.http_fetch
+
+Teste la récupération HTTP avec mocks pour éviter les vraies requêtes.
+"""
+
+from unittest.mock import Mock, patch
+
+import pytest
+import requests
+from requests.exceptions import RequestException, Timeout
+
+from pricewatch.app.scraping.http_fetch import FetchResult, fetch_http
+
+
+class TestFetchResult:
+    """Tests pour la classe FetchResult."""
+
+    def test_success_result(self):
+        """Création d'un résultat réussi."""
+        result = FetchResult(
+            success=True,
+            html="<html>Test</html>",
+            status_code=200,
+            duration_ms=150,
+        )
+
+        assert result.success is True
+        assert result.html == "<html>Test</html>"
+        assert result.error is None
+        assert result.status_code == 200
+        assert result.duration_ms == 150
+
+    def test_error_result(self):
+        """Création d'un résultat d'erreur."""
+        result = FetchResult(
+            success=False,
+            error="403 Forbidden",
+            status_code=403,
+            duration_ms=100,
+        )
+
+        assert result.success is False
+        assert result.html is None
+        assert result.error == "403 Forbidden"
+        assert result.status_code == 403
+        assert result.duration_ms == 100
+
+    def test_minimal_result(self):
+        """Résultat minimal avec success uniquement."""
+        result = FetchResult(success=False)
+
+        assert result.success is False
+        assert result.html is None
+        assert result.error is None
+        assert result.status_code is None
+        assert result.duration_ms is None
+
+
+class TestFetchHttp:
+    """Tests pour la fonction fetch_http()."""
+
+    def test_fetch_success(self, mocker):
+        """Requête HTTP réussie (200 OK)."""
+        # Mock de requests.get
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.text = "<html><body>Test Page</body></html>"
+        mocker.patch("requests.get", return_value=mock_response)
+
+        result = fetch_http("https://example.com")
+
+        assert result.success is True
+        assert result.html == "<html><body>Test Page</body></html>"
+        assert result.status_code == 200
+        assert result.error is None
+        assert result.duration_ms is not None
+        assert result.duration_ms >= 0
+
+    def test_fetch_with_custom_timeout(self, mocker):
+        """Requête avec timeout personnalisé."""
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.text = "<html>OK</html>"
+        mock_get = mocker.patch("requests.get", return_value=mock_response)
+
+        fetch_http("https://example.com", timeout=60)
+
+        # Vérifier que timeout est passé à requests.get
+        mock_get.assert_called_once()
+        call_kwargs = mock_get.call_args.kwargs
+        assert call_kwargs["timeout"] == 60
+
+    def test_fetch_with_custom_headers(self, mocker):
+        """Requête avec headers personnalisés."""
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.text = "<html>OK</html>"
+        mock_get = mocker.patch("requests.get", return_value=mock_response)
+
+        custom_headers = {"X-Custom-Header": "test-value"}
+        fetch_http("https://example.com", headers=custom_headers)
+
+        # Vérifier que les headers personnalisés sont inclus
+        mock_get.assert_called_once()
+        call_kwargs = mock_get.call_args.kwargs
+        assert "X-Custom-Header" in call_kwargs["headers"]
+        assert call_kwargs["headers"]["X-Custom-Header"] == "test-value"
+        # Headers par défaut doivent aussi être présents
+        assert "User-Agent" in call_kwargs["headers"]
+
+    def test_fetch_403_forbidden(self, mocker):
+        """Requête bloquée (403 Forbidden)."""
+        mock_response = Mock()
+        mock_response.status_code = 403
+        mocker.patch("requests.get", return_value=mock_response)
+
+        result = fetch_http("https://example.com")
+
+        assert result.success is False
+        assert result.html is None
+        assert result.status_code == 403
+        assert "403 Forbidden" in result.error
+        assert "Anti-bot" in result.error
+
+    def test_fetch_404_not_found(self, mocker):
+        """Page introuvable (404 Not Found)."""
+        mock_response = Mock()
+        mock_response.status_code = 404
+        mocker.patch("requests.get", return_value=mock_response)
+
+        result = fetch_http("https://example.com")
+
+        assert result.success is False
+        assert result.status_code == 404
+        assert "404 Not Found" in result.error
+
+    def test_fetch_429_rate_limit(self, mocker):
+        """Rate limit atteint (429 Too Many Requests)."""
+        mock_response = Mock()
+        mock_response.status_code = 429
+        mocker.patch("requests.get", return_value=mock_response)
+
+        result = fetch_http("https://example.com")
+
+        assert result.success is False
+        assert result.status_code == 429
+        assert "429" in result.error
+        assert "Rate limit" in result.error
+
+    def test_fetch_500_server_error(self, mocker):
+        """Erreur serveur (500 Internal Server Error)."""
+        mock_response = Mock()
+        mock_response.status_code = 500
+        mocker.patch("requests.get", return_value=mock_response)
+
+        result = fetch_http("https://example.com")
+
+        assert result.success is False
+        assert result.status_code == 500
+        assert "500" in result.error
+        assert "Server Error" in result.error
+
+    def test_fetch_503_service_unavailable(self, mocker):
+        """Service indisponible (503)."""
+        mock_response = Mock()
+        mock_response.status_code = 503
+        mocker.patch("requests.get", return_value=mock_response)
+
+        result = fetch_http("https://example.com")
+
+        assert result.success is False
+        assert result.status_code == 503
+        assert "503" in result.error
+
+    def test_fetch_unknown_status_code(self, mocker):
+        """Code de statut inconnu (par ex. 418 I'm a teapot)."""
+        mock_response = Mock()
+        mock_response.status_code = 418
+        mocker.patch("requests.get", return_value=mock_response)
+
+        result = fetch_http("https://example.com")
+
+        assert result.success is False
+        assert result.status_code == 418
+        assert "418" in result.error
+
+    def test_fetch_timeout_error(self, mocker):
+        """Timeout lors de la requête."""
+        mocker.patch("requests.get", side_effect=Timeout("Connection timed out"))
+
+        result = fetch_http("https://example.com", timeout=10)
+
+        assert result.success is False
+        assert result.html is None
+        assert "Timeout" in result.error
+        assert result.duration_ms is not None
+
+    def test_fetch_request_exception(self, mocker):
+        """Exception réseau générique."""
+        mocker.patch(
+            "requests.get",
+            side_effect=RequestException("Network error"),
+        )
+
+        result = fetch_http("https://example.com")
+
+        assert result.success is False
+        assert "Erreur réseau" in result.error
+        assert result.duration_ms is not None
+
+    def test_fetch_unexpected_exception(self, mocker):
+        """Exception inattendue."""
+        mocker.patch("requests.get", side_effect=ValueError("Unexpected error"))
+
+        result = fetch_http("https://example.com")
+
+        assert result.success is False
+        assert "Erreur inattendue" in result.error
+        assert result.duration_ms is not None
+
+    def test_fetch_empty_url(self):
+        """URL vide retourne une erreur."""
+        result = fetch_http("")
+
+        assert result.success is False
+        assert "URL vide" in result.error
+        assert result.html is None
+
+    def test_fetch_whitespace_url(self):
+        """URL avec espaces uniquement retourne une erreur."""
+        result = fetch_http("   ")
+
+        assert result.success is False
+        assert "URL vide" in result.error
+
+    def test_fetch_no_redirects(self, mocker):
+        """Requête sans suivre les redirections."""
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.text = "<html>OK</html>"
+        mock_get = mocker.patch("requests.get", return_value=mock_response)
+
+        fetch_http("https://example.com", follow_redirects=False)
+
+        mock_get.assert_called_once()
+        call_kwargs = mock_get.call_args.kwargs
+        assert call_kwargs["allow_redirects"] is False
+
+    def test_fetch_uses_random_user_agent(self, mocker):
+        """Vérifie qu'un User-Agent aléatoire est utilisé."""
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.text = "<html>OK</html>"
+        mock_get = mocker.patch("requests.get", return_value=mock_response)
+
+        fetch_http("https://example.com")
+
+        # Vérifier qu'un User-Agent est présent
+        mock_get.assert_called_once()
+        call_kwargs = mock_get.call_args.kwargs
+        assert "User-Agent" in call_kwargs["headers"]
+        # User-Agent doit contenir "Mozilla" (présent dans tous les UA)
+        assert "Mozilla" in call_kwargs["headers"]["User-Agent"]
+
+    def test_fetch_duration_is_measured(self, mocker):
+        """Vérifie que la durée est mesurée."""
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.text = "<html>OK</html>"
+        mocker.patch("requests.get", return_value=mock_response)
+
+        result = fetch_http("https://example.com")
+
+        assert result.duration_ms is not None
+        assert isinstance(result.duration_ms, int)
+        assert result.duration_ms >= 0
+
+    def test_fetch_large_response(self, mocker):
+        """Requête avec réponse volumineuse."""
+        mock_response = Mock()
+        mock_response.status_code = 200
+        # Simuler une grosse page HTML (1 MB)
+        mock_response.text = "<html>" + ("x" * 1000000) + "</html>"
+        mocker.patch("requests.get", return_value=mock_response)
+
+        result = fetch_http("https://example.com")
+
+        assert result.success is True
+        assert len(result.html) > 1000000
diff --git a/tests/scraping/test_pipeline.py b/tests/scraping/test_pipeline.py
new file mode 100755
index 0000000..d0f1407
--- /dev/null
+++ b/tests/scraping/test_pipeline.py
@@ -0,0 +1,82 @@
+"""
+Tests pour ScrapingPipeline.
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+
+import pytest
+
+from pricewatch.app.core.schema import DebugInfo, DebugStatus, FetchMethod, ProductSnapshot
+from pricewatch.app.db.connection import get_session, init_db, reset_engine
+from pricewatch.app.db.models import Product
+from pricewatch.app.scraping.pipeline import ScrapingPipeline
+
+
+@dataclass
+class FakeDbConfig:
+    url: str
+
+
+@dataclass
+class FakeAppConfig:
+    db: FakeDbConfig
+    debug: bool = False
+    enable_db: bool = True
+
+
+@pytest.fixture(autouse=True)
+def reset_db_engine():
+    """Reset l'engine global entre les tests."""
+    reset_engine()
+    yield
+    reset_engine()
+
+
+def test_pipeline_persists_snapshot():
+    """Le pipeline persiste un snapshot en base SQLite."""
+    config = FakeAppConfig(db=FakeDbConfig(url="sqlite:///:memory:"))
+    init_db(config)
+
+    snapshot = ProductSnapshot(
+        source="amazon",
+        url="https://example.com/product",
+        fetched_at=datetime(2026, 1, 14, 12, 30, 0),
+        title="Produit pipeline",
+        price=99.99,
+        currency="EUR",
+        reference="B08PIPE",
+        debug=DebugInfo(method=FetchMethod.HTTP, status=DebugStatus.SUCCESS),
+    )
+
+    pipeline = ScrapingPipeline(config=config)
+    product_id = pipeline.process_snapshot(snapshot, save_to_db=True)
+
+    assert product_id is not None
+
+    with get_session(config) as session:
+        assert session.query(Product).count() == 1
+
+
+def test_pipeline_respects_disable_flag():
+    """Le pipeline ignore la persistence si enable_db=False."""
+    config = FakeAppConfig(db=FakeDbConfig(url="sqlite:///:memory:"), enable_db=False)
+    init_db(config)
+
+    snapshot = ProductSnapshot(
+        source="amazon",
+        url="https://example.com/product",
+        fetched_at=datetime(2026, 1, 14, 12, 45, 0),
+        title="Produit pipeline",
+        price=99.99,
+        currency="EUR",
+        reference="B08PIPE",
+        debug=DebugInfo(method=FetchMethod.HTTP, status=DebugStatus.SUCCESS),
+    )
+
+    pipeline = ScrapingPipeline(config=config)
+    product_id = pipeline.process_snapshot(snapshot, save_to_db=True)
+
+    assert product_id is None
+    with get_session(config) as session:
+        assert session.query(Product).count() == 0
diff --git a/tests/scraping/test_pw_fetch.py b/tests/scraping/test_pw_fetch.py
new file mode 100755
index 0000000..27f5c25
--- /dev/null
+++ b/tests/scraping/test_pw_fetch.py
@@ -0,0 +1,388 @@
+"""
+Tests pour pricewatch.app.scraping.pw_fetch
+
+Teste la récupération Playwright avec mocks pour éviter de lancer vraiment un navigateur.
+"""
+
+from unittest.mock import Mock, patch
+
+import pytest
+from playwright.sync_api import TimeoutError as PlaywrightTimeout
+
+from pricewatch.app.scraping.pw_fetch import (
+    PlaywrightFetchResult,
+    fetch_playwright,
+    fetch_with_fallback,
+)
+
+
+class TestPlaywrightFetchResult:
+    """Tests pour la classe PlaywrightFetchResult."""
+
+    def test_success_result(self):
+        """Création d'un résultat réussi."""
+        result = PlaywrightFetchResult(
+            success=True,
+            html="<html>Test</html>",
+            screenshot=b"fake_screenshot_bytes",
+            duration_ms=2500,
+        )
+
+        assert result.success is True
+        assert result.html == "<html>Test</html>"
+        assert result.screenshot == b"fake_screenshot_bytes"
+        assert result.error is None
+        assert result.duration_ms == 2500
+
+    def test_error_result(self):
+        """Création d'un résultat d'erreur."""
+        result = PlaywrightFetchResult(
+            success=False,
+            error="Timeout",
+            screenshot=b"error_screenshot",
+            duration_ms=3000,
+        )
+
+        assert result.success is False
+        assert result.html is None
+        assert result.error == "Timeout"
+        assert result.screenshot == b"error_screenshot"
+        assert result.duration_ms == 3000
+
+    def test_minimal_result(self):
+        """Résultat minimal."""
+        result = PlaywrightFetchResult(success=False)
+
+        assert result.success is False
+        assert result.html is None
+        assert result.screenshot is None
+        assert result.error is None
+        assert result.duration_ms is None
+
+
+class TestFetchPlaywright:
+    """Tests pour fetch_playwright()."""
+
+    @pytest.fixture
+    def mock_playwright_stack(self, mocker):
+        """Fixture: Mock complet de la stack Playwright."""
+        # Mock de la page
+        mock_page = Mock()
+        mock_page.content.return_value = "<html><body>Playwright Test</body></html>"
+        mock_page.screenshot.return_value = b"fake_screenshot_data"
+        mock_page.goto.return_value = Mock(status=200)
+
+        # Mock du context
+        mock_context = Mock()
+        mock_context.new_page.return_value = mock_page
+
+        # Mock du browser
+        mock_browser = Mock()
+        mock_browser.new_context.return_value = mock_context
+
+        # Mock playwright chromium
+        mock_chromium = Mock()
+        mock_chromium.launch.return_value = mock_browser
+
+        # Mock playwright
+        mock_playwright_obj = Mock()
+        mock_playwright_obj.chromium = mock_chromium
+
+        # Mock sync_playwright().start()
+        mock_sync_playwright = Mock()
+        mock_sync_playwright.start.return_value = mock_playwright_obj
+
+        mocker.patch(
+            "pricewatch.app.scraping.pw_fetch.sync_playwright",
+            return_value=mock_sync_playwright,
+        )
+
+        return {
+            "playwright": mock_playwright_obj,
+            "browser": mock_browser,
+            "context": mock_context,
+            "page": mock_page,
+        }
+
+    def test_fetch_success(self, mock_playwright_stack):
+        """Récupération Playwright réussie."""
+        result = fetch_playwright("https://example.com")
+
+        assert result.success is True
+        assert result.html == "<html><body>Playwright Test</body></html>"
+        assert result.screenshot is None  # Par défaut pas de screenshot
+        assert result.error is None
+        assert result.duration_ms is not None
+        assert result.duration_ms >= 0
+
+        # Vérifier que la page a été visitée
+        mock_playwright_stack["page"].goto.assert_called_once_with(
+            "https://example.com", wait_until="domcontentloaded"
+        )
+
+    def test_fetch_with_screenshot(self, mock_playwright_stack):
+        """Récupération avec screenshot."""
+        result = fetch_playwright("https://example.com", save_screenshot=True)
+
+        assert result.success is True
+        assert result.screenshot == b"fake_screenshot_data"
+
+        # Vérifier que screenshot() a été appelé
+        mock_playwright_stack["page"].screenshot.assert_called_once()
+
+    def test_fetch_headful_mode(self, mock_playwright_stack):
+        """Mode headful (navigateur visible)."""
+        result = fetch_playwright("https://example.com", headless=False)
+
+        assert result.success is True
+
+        # Vérifier que headless=False a été passé
+        mock_playwright_stack["playwright"].chromium.launch.assert_called_once()
+        call_kwargs = mock_playwright_stack["playwright"].chromium.launch.call_args.kwargs
+        assert call_kwargs["headless"] is False
+
+    def test_fetch_with_custom_timeout(self, mock_playwright_stack):
+        """Timeout personnalisé."""
+        result = fetch_playwright("https://example.com", timeout_ms=30000)
+
+        assert result.success is True
+
+        # Vérifier que set_default_timeout a été appelé
+        mock_playwright_stack["page"].set_default_timeout.assert_called_once_with(30000)
+
+    def test_fetch_with_wait_for_selector(self, mock_playwright_stack):
+        """Attente d'un sélecteur CSS spécifique."""
+        result = fetch_playwright(
+            "https://example.com", wait_for_selector=".product-title"
+        )
+
+        assert result.success is True
+
+        # Vérifier que wait_for_selector a été appelé
+        mock_playwright_stack["page"].wait_for_selector.assert_called_once_with(
+            ".product-title", timeout=60000
+        )
+
+    def test_fetch_wait_for_selector_timeout(self, mock_playwright_stack):
+        """Timeout lors de l'attente du sélecteur."""
+        # Le sélecteur timeout mais la page continue
+        mock_playwright_stack["page"].wait_for_selector.side_effect = PlaywrightTimeout(
+            "Selector timeout"
+        )
+
+        result = fetch_playwright(
+            "https://example.com", wait_for_selector=".non-existent"
+        )
+
+        # Doit quand même réussir (le wait_for_selector est non-bloquant)
+        assert result.success is True
+        assert result.html is not None
+
+    def test_fetch_empty_url(self):
+        """URL vide retourne une erreur."""
+        result = fetch_playwright("")
+
+        assert result.success is False
+        assert "URL vide" in result.error
+        assert result.html is None
+
+    def test_fetch_whitespace_url(self):
+        """URL avec espaces retourne une erreur."""
+        result = fetch_playwright("   ")
+
+        assert result.success is False
+        assert "URL vide" in result.error
+
+    def test_fetch_no_response_from_server(self, mock_playwright_stack):
+        """Pas de réponse du serveur."""
+        mock_playwright_stack["page"].goto.return_value = None
+
+        result = fetch_playwright("https://example.com")
+
+        assert result.success is False
+        assert "Pas de réponse du serveur" in result.error
+
+    def test_fetch_playwright_timeout(self, mock_playwright_stack):
+        """Timeout Playwright lors de la navigation."""
+        mock_playwright_stack["page"].goto.side_effect = PlaywrightTimeout(
+            "Navigation timeout"
+        )
+
+        result = fetch_playwright("https://example.com", timeout_ms=10000)
+
+        assert result.success is False
+        assert "Timeout" in result.error
+        assert result.duration_ms is not None
+
+    def test_fetch_playwright_generic_error(self, mock_playwright_stack):
+        """Erreur générique Playwright."""
+        mock_playwright_stack["page"].goto.side_effect = Exception(
+            "Generic Playwright error"
+        )
+
+        result = fetch_playwright("https://example.com")
+
+        assert result.success is False
+        assert "Erreur Playwright" in result.error
+        assert result.duration_ms is not None
+
+    def test_fetch_cleanup_on_success(self, mock_playwright_stack):
+        """Nettoyage des ressources sur succès."""
+        result = fetch_playwright("https://example.com")
+
+        assert result.success is True
+
+        # Vérifier que les ressources sont nettoyées
+        mock_playwright_stack["page"].close.assert_called_once()
+        mock_playwright_stack["browser"].close.assert_called_once()
+        mock_playwright_stack["playwright"].stop.assert_called_once()
+
+    def test_fetch_cleanup_on_error(self, mock_playwright_stack):
+        """Nettoyage des ressources sur erreur."""
+        mock_playwright_stack["page"].goto.side_effect = Exception("Test error")
+
+        result = fetch_playwright("https://example.com")
+
+        assert result.success is False
+
+        # Vérifier que les ressources sont nettoyées même en cas d'erreur
+        mock_playwright_stack["page"].close.assert_called_once()
+        mock_playwright_stack["browser"].close.assert_called_once()
+        mock_playwright_stack["playwright"].stop.assert_called_once()
+
+    def test_fetch_screenshot_on_error(self, mock_playwright_stack):
+        """Screenshot capturé même en cas d'erreur."""
+        mock_playwright_stack["page"].goto.side_effect = PlaywrightTimeout("Timeout")
+
+        result = fetch_playwright("https://example.com", save_screenshot=True)
+
+        assert result.success is False
+        assert result.screenshot == b"fake_screenshot_data"
+
+        # Screenshot doit avoir été tenté
+        mock_playwright_stack["page"].screenshot.assert_called_once()
+
+
+class TestFetchWithFallback:
+    """Tests pour fetch_with_fallback()."""
+
+    def test_http_success_no_playwright(self, mocker):
+        """Si HTTP réussit, Playwright n'est pas appelé."""
+        # Mock fetch_http qui réussit
+        mock_http_result = Mock()
+        mock_http_result.success = True
+        mock_http_result.html = "<html>HTTP Success</html>"
+        mock_http_result.duration_ms = 150
+
+        mocker.patch(
+            "pricewatch.app.scraping.http_fetch.fetch_http",
+            return_value=mock_http_result,
+        )
+
+        # Mock fetch_playwright (ne devrait pas être appelé)
+        mock_playwright = mocker.patch(
+            "pricewatch.app.scraping.pw_fetch.fetch_playwright"
+        )
+
+        result = fetch_with_fallback("https://example.com")
+
+        assert result.success is True
+        assert result.html == "<html>HTTP Success</html>"
+        assert result.duration_ms == 150
+
+        # Playwright ne doit pas être appelé
+        mock_playwright.assert_not_called()
+
+    def test_http_fails_playwright_fallback(self, mocker):
+        """Si HTTP échoue, fallback vers Playwright."""
+        # Mock fetch_http qui échoue
+        mock_http_result = Mock()
+        mock_http_result.success = False
+        mock_http_result.error = "403 Forbidden"
+
+        mocker.patch(
+            "pricewatch.app.scraping.http_fetch.fetch_http",
+            return_value=mock_http_result,
+        )
+
+        # Mock fetch_playwright qui réussit
+        mock_playwright_result = PlaywrightFetchResult(
+            success=True,
+            html="<html>Playwright Success</html>",
+            duration_ms=2500,
+        )
+
+        mock_playwright = mocker.patch(
+            "pricewatch.app.scraping.pw_fetch.fetch_playwright",
+            return_value=mock_playwright_result,
+        )
+
+        result = fetch_with_fallback("https://example.com")
+
+        assert result.success is True
+        assert result.html == "<html>Playwright Success</html>"
+
+        # Playwright doit avoir été appelé
+        mock_playwright.assert_called_once()
+
+    def test_skip_http_direct_playwright(self, mocker):
+        """Mode Playwright direct (sans essayer HTTP d'abord)."""
+        # Mock fetch_http (ne devrait pas être appelé)
+        mock_http = mocker.patch("pricewatch.app.scraping.http_fetch.fetch_http")
+
+        # Mock fetch_playwright
+        mock_playwright_result = PlaywrightFetchResult(
+            success=True,
+            html="<html>Playwright Direct</html>",
+            duration_ms=2500,
+        )
+
+        mock_playwright = mocker.patch(
+            "pricewatch.app.scraping.pw_fetch.fetch_playwright",
+            return_value=mock_playwright_result,
+        )
+
+        result = fetch_with_fallback("https://example.com", try_http_first=False)
+
+        assert result.success is True
+        assert result.html == "<html>Playwright Direct</html>"
+
+        # HTTP ne doit pas être appelé
+        mock_http.assert_not_called()
+
+        # Playwright doit avoir été appelé
+        mock_playwright.assert_called_once()
+
+    def test_playwright_options_passed(self, mocker):
+        """Options Playwright passées correctement."""
+        # Mock fetch_http qui échoue
+        mock_http_result = Mock()
+        mock_http_result.success = False
+        mock_http_result.error = "403 Forbidden"
+
+        mocker.patch(
+            "pricewatch.app.scraping.http_fetch.fetch_http",
+            return_value=mock_http_result,
+        )
+
+        # Mock fetch_playwright
+        mock_playwright_result = PlaywrightFetchResult(
+            success=True,
+            html="<html>OK</html>",
+            duration_ms=2500,
+        )
+
+        mock_playwright = mocker.patch(
+            "pricewatch.app.scraping.pw_fetch.fetch_playwright",
+            return_value=mock_playwright_result,
+        )
+
+        # Options personnalisées
+        options = {"headless": False, "timeout_ms": 30000, "save_screenshot": True}
+
+        result = fetch_with_fallback("https://example.com", playwright_options=options)
+
+        assert result.success is True
+
+        # Vérifier que les options sont passées à fetch_playwright
+        mock_playwright.assert_called_once_with("https://example.com", **options)
diff --git a/tests/stores/__pycache__/test_amazon.cpython-313-pytest-9.0.2.pyc b/tests/stores/__pycache__/test_amazon.cpython-313-pytest-9.0.2.pyc
index f3111bfa70ace36bd1229e36729a46992e7ac504..c2e61529abda04953bccdf218326eee850c2123c 100755
GIT binary patch
delta 1610
zcmaKsZA@Eb6vyu=?FHIPS1h$n9a|kRsbjEYFN`HJG2tbC0H<V*4ZD?E7*U|!3(2TM
zreDmWo0wzb`~Yl;aga>raxDx84mUPm00TJb=wu5@P2?pjYa%-1%X4nY))2S*;df8Y
z+w;HYdG7P~jhMTE7=1V)LCdkn|4wD~C)wxpm-avhj_v7>&B)2I{ruJ$T&%F8qr46O
za&5zbz1u;+Klc`b5A*h2jLwlA<$_w@$2v)|3`e*SZ)2J1^2q}qfM%Nfm{U=%YIuQl
zUyXqSM)Z_vaHygzs*4G0U4IxBqnl_Af?W6Vp;i1K^NM}AAf1I?Y_0DFPJXe$V}>tL
z?=uU<RUdnv()xEcKP?X6+`GAkOO(zNE)%ZGImhy06E*Sbos#4h>uqW2p2lr<NxZ_G
zrQ(N__BG)f!ncI)u<LlUMOm4W#6t{ri#SB~2#4<vXYB~Yi|$Id=&p6S#ZmGrYmPB1
z5a)8%yQ}KN#sFVk<E(N^;!SdEB#+xAiR0MyUUq6Pm1GbO6Mi6M60Q+`Burp@OBVPs
zr^O8ka(jzY&?!|K3eKRe^%qFN+pV=3q_g1vzk@~WhKTOpsB9LGw&n3lWRBx#n|1Sj
z9g2h|iYTi$lXZkJPk4i%X!B!oy91Kt!|kbYkxeibR~1crle+#r$TorH*}=OTKil;f
zu9Y^Tu_MV6*$L{P3{oF8$W1Vco{p5v&ndc(a9`0wCi7K?6V}Tqok5+hhl<RE^K>Hk
zVr3HO^sU7bU%q+e&a%W#@K$1rl!=qRT+0kqHWIuH_QZ&`VcO&krV;XgPZ%dGkFc&g
z#r|-W%CwX*`td?{HDt+YJ$eoFlR!<eT`LaZbA5%@2RFfUeJ<D`oBD67;09IclqwPt
zRHQ*1CJtKgm4W?`Cl3w$uEIxrMzzxU`sM9PbUzfyuMJ*}EsFtGrmPh?I@IOf7e~e=
z0_A)`kqZR+pT&!W0fx?1(MO29N+UJ43}=+wn^C7;)KkpB5KteiuX%OlhCc9!DLWlG
z{-_&if)e@Y$oV+KO5wO`BAFezQ>TrI%3rG@(MbdopfHk)V-vaHkPUv7YKwB9u9Kbx
z!d=2Y1P$fK69hsc!A!6M!frFZG`VxDUL%}vg*o;L$8da7NX4v>jpK#49d9~9s&y<Z
zg*o<G4l^rMgkzKTM+J>=a&wqtujLT4?yN>b-~`mjoq=o>^x*VQ&*-8?jhR!Wx~K~P
zk4+VTN4_?7i;rA>SFm@+$<rMo-a=c@#;20pG%N@{0XMNWXyuphi{n8N8f5tOQ#DNE
z+1V{@t(n<;*nm&YJr7OTG`A!?PNnIDjmqb0*N{!9!Bg|=U=0q=cQd}ekPKV#qlIU!
Wg)y*xks~gZ@+L^V!!d|Prsh9%TId=8

delta 1690
zcmaKsYfKzf6vyYzvIFdkZFwxRyrI}hH?-Q8Vq!s5XhTyHYc-{`$g*rHK45c)Y9SWr
z7i&xljpu`nu`5v{HAb6e$_C4;xQY)JDk5}QL8yQqC^XnjY^`bVo>@{58|K4r&fIhE
zx&M3anS0Nty8o-n;MeOl9DCjok5p{Qykz+L02zV71D&w9FBdKrJtB7%>Il(8Y{^FO
zA57q<g5b$gGi)yU7(Of#;q|^)jDoI0r`&v~Qf265xujr*25vz}l4DCch<b{B`eEF9
zh_{|(xnrTOBpe)tYN#qLe2`_L^nR$H1yY#-k~+<DaM|H7;aeQ)gqNj@<O;-8e-*4E
zY=J5jEIQ55>#CB=j!j0Tc4O2PL_4BGnZ!^~{)uC!=6ZJhQ?v(;p3XA5(IX(fL3}5>
zPUn&>xJa$RDoJ))ow#A6qb5U?XfGSwPv66^?-4&Benj-arp9`cq6~xRaRxD(de9z#
zo<>X7HD>xksr`tZ+AD2#I*2Z1*`Lu9VzXA;%d2ROPpEj!T5gx<1P-euhutR8A=uQk
zBURar1?Rnq_yv)U7)FdBuESeRn?t?Klp+}5v6sT(uqzn6P0tXc9DCNP(<)ii7(4@S
ze=tST;MMb$7L=a%@U1bAXbfy+7N^|=!I>l6MRN%DI%Bpj>ry10K#!uP9<2t%JfaSv
zX!XMT&SH`%|Lsf-S>vR3->8lFa`7mhR8EV{6gVGDqLkOLqPzl@mkz>wOG<hxnnj3Z
zVQUmD>w=Yta`S~5t<Z*(OmL~)q@~!k1xi8Sx629OxtweK-<c=1O6zBEP7R`#L0m^Y
z(9yVk9aRJk;rLR~=2}z4wFN2lQ3~gUOjiYYT>i*qP{(y)5@qJ9P8Kz6vHtd5<~7p7
zV7CeKI`$ZL;!kplrE1_N4bQ`k>If)1_KF<eY2%Z})>;95e_#ufQ243)4f3qK`|4l3
z=^=s?JukR3mB48D)V+)Bk#D(sgA0S$;(;v$8V_?ms9B)Ol*gF=?vP%^z#fLr!d5mQ
zjw*@Np!ZmW0sOuO*&cJ`awS%@B2;;z`C$%>BU$hEtHI-Wg6xxp{<aX~YF#ie92e-v
zRYH`19`6|%iHL%*krTu!pBdr#ZA!n5qJ~?De-MiZ0YfziJz_l~8et|tUNnKvo4q|u
ztvhG)bL{0;aYDob&#Z-HPSBkyK3TlLr!cqV=h$n>&8&rdC>Rx^^lDx6RzJsHOD<;J
zj)ya&=ZHg2^X=eC8x)T{tzEGb_<U@?Rw+#2+5pXX9+Bkd#wUcpt=bD2(^dg*9y$r<
zrxS$@C^rq<(~pt~xH%moEZs8N8A^`Jbu(WCk>9~GyN#`7oy{c{Xqnwd8sOgS9bGa`
z6%pymb~OoTBODMvmrN2MXU@fVcP@@(K-7GGOumYw{mCKk926o+>TQmJhBGz)0<OdU
A*Z=?k