diff --git a/main.py b/main.py
index acc276a..078fa91 100644
--- a/main.py
+++ b/main.py
@@ -1,90 +1,132 @@
-import requests
-from typing import Any, Dict
-from bs4 import BeautifulSoup
-import json
+from sys import stderr
+from typing import cast
+from requests import Response, Session
+from bs4 import BeautifulSoup, Tag
+from json import JSONDecodeError, loads
 
 
 class Scraper:
     """
     Scraper est une classe qui permet de gerer
     de façon dynamique des requetes uniquement
-    sur le serveur https de Millesina
+    sur le serveur https de Millesima
     """
 
-    def __init__(self, subdir: str = None):
+    def __init__(self) -> None:
         """
-        Initialise la session de scraping et récupère la page d'accueil.
+        Initialise la session de scraping.
         """
+        self._url: str = "https://www.millesima.fr/"
         # Très utile pour éviter de renvoyer toujours les mêmes handshake
         # TCP et d'avoir toujours une connexion constante avec le server
-        self._session: requests.Session = requests.Session()
-        self._url: str = "https://www.millesima.fr/"
-        self._soup = self.getsoup(subdir)
+        self._session: Session = Session()
+        # Système de cache pour éviter de solliciter le serveur inutilement
+        self._latest_request: tuple[(str, Response | None)] = ("", None)
 
-    def _request(
-            self, subdir: str, use_cache: bool = True
-    ) -> requests.Response | requests.HTTPError:
+    def _request(self, subdir: str) -> Response:
         """
         Effectue une requête GET sur le serveur Millesima.
-        :param subdir: Le sous-répertoire ou chemin de l'URL (ex: "/vins").
-        :param use_cache: Si True, retourne la réponse précédente si l'URL est
-        identique.
-        :return: requests.Response: L'objet réponse de la requête.
-        :rtype: requests.HTTPError: Si le serveur renvoie un code d'erreur
-        (4xx, 5xx).
+
+        Args:
+            subdir (str): Le sous-répertoire ou chemin de l'URL (ex: "/vins").
+
+        Returns:
+            Response: L'objet réponse de la requête.
+
+        Raise:
+            HTTPError: Si le serveur renvoie un code d'erreur (4xx, 5xx).
         """
+        target_url: str = self._url + subdir.lstrip("/")
+        response: Response = self._session.get(url=target_url, timeout=10)
+        response.raise_for_status()
+        return response
 
-        target_url: str = f"{self._url}{subdir.lstrip('/')}" if subdir is \
-            not None else self._url
-        # Éviter un max possible de faire des requetes au servers même
-        # en ayant un tunnel tcp avec le paramètre `use_cache` que si
-        # activer, va comparer l'url avec l'url précédant
-        if use_cache and hasattr(self, "_response") \
-                and self._response is not None:
-            if self._response.url == target_url:
-                return self._response
-
-        self._response: requests.Response = self._session.get(
-            target_url, timeout=10)
-        self._response.raise_for_status()
-
-        return self._response
-
-    def getsoup(self, subdir: str = None
-                ) -> BeautifulSoup | requests.HTTPError:
+    def getresponse(self, subdir: str = "") -> Response:
         """
-        Récupère le contenu HTML d'une page et le transforme en objet
-        BeautifulSoup.
+        Récupère la réponse d'une page, en utilisant le cache si possible.
 
-        :param subdir: Le chemin de la page. Si None, retourne la soupe
-        actuelle.
-        :return: BeautifulSoup: L'objet parsé pour extraction de données.
-        :rtype: BeautifulSoup
-        """
-        if not hasattr(self, "_soup") or subdir is not None:
-            self._request(subdir)
-            self._soup = BeautifulSoup(self._response.text, "html.parser")
-        return self._soup
+        Args:
+            subdir (str, optional): Le chemin de la page.
 
-    def get_json_data(self) -> Dict[str, Any]:
+        Returns:
+            Response: L'objet réponse (cache ou nouvelle requête).
+
+        Raise:
+            HTTPError: Si le serveur renvoie un code d'erreur (4xx, 5xx).
         """
-        Extrait les données JSON contenues dans la balise __NEXT_DATA__ du
-        site.
+        rq_subdir, rq_response = self._latest_request
+
+        if rq_response is None or subdir != rq_subdir:
+            request: Response = self._request(subdir)
+            self._latest_request = (subdir, request)
+            return request
+
+        return rq_response
+
+    def getsoup(self, subdir: str = "") -> BeautifulSoup:
+        """
+        Récupère le contenu HTML d'une page et le transforme en objet BeautifulSoup.
+
+        Args:
+            subdir (str, optional): Le chemin de la page.
+
+        Returns:
+            BeautifulSoup: L'objet parsé pour extraction de données.
+
+        Raise:
+            HTTPError: Si le serveur renvoie un code d'erreur (4xx, 5xx).
+        """
+        markup: str = self.getresponse(subdir).text
+        return BeautifulSoup(markup, features="html.parser")
+
+    def getjsondata(
+        self, subdir: str = "", id: str = "__NEXT_DATA__"
+    ) -> dict[str, object]:
+        """
+        Extrait les données JSON contenues dans la balise __NEXT_DATA__ du site.
         Beaucoup de sites modernes (Next.js) stockent leur état initial dans
         une balise <script> pour l'hydratation côté client.
 
-        :return Dict[str, Any]: Un dictionnaire contenant les props de la page,
-                           ou un dictionnaire vide en cas d'erreur ou
-                           d'absence.
+        Args:
+            subdir (str, optional): Le chemin de la page.
+            id (str, optional): L'identifiant de la balise script (par défaut __NEXT_DATA__).
+
+        Raises:
+            HTTPError: Soulevée par `getresponse` si le serveur renvoie un code d'erreur (4xx, 5xx).
+            JSONDecodeError: Soulevée par `loads` si le contenu de la balise n'est pas un JSON valide.
+            ValueError: Soulevée manuellement si l'une des clés attendues (props, pageProps, etc.) 
+                        est absente de la structure JSON.
+
+        Returns:
+            dict[str, object]: Un dictionnaire contenant les données utiles
+                                 ou un dictionnaire vide en cas d'erreur.
         """
-        script = self._soup.find("script", id="__NEXT_DATA__")
-        if script and script.string:
+        soup: BeautifulSoup = self.getsoup(subdir)
+        script: Tag | None = soup.find("script", id=id)
+
+        if isinstance(script, Tag) and script.string:
             try:
-                data: dict[str, Any] = json.loads(script.string)
-                for element in ['props', 'pageProps', 'initialReduxState',
-                                'product', 'content']:
-                    data = data[element]
-                return data
-            except json.decoder.JSONDecodeError:
-                pass
+                current_data: object = loads(script.string)
+                # tout le chemin à parcourir pour arriver au données
+                # (plein d'information inutile)
+                keys: list[str] = [
+                    "props",
+                    "pageProps",
+                    "initialReduxState",
+                    "product",
+                    "content",
+                ]
+                for key in keys:
+                    # si current_data est bien un dictionnaire et que la clé
+                    # est bien dedans
+                    if isinstance(current_data, dict) and key in current_data:
+                        current_data = current_data[key]
+                    else:
+                        raise ValueError(f"Clé manquante dans le JSON : {key}")
+
+                if isinstance(current_data, dict):
+                    return cast(dict[str, object], current_data)
+
+            except (JSONDecodeError, ValueError) as e:
+                print(f"Erreur lors de l'extraction JSON : {e}", file=stderr)
         return {}
diff --git a/requirements.txt b/requirements.txt
index f7b4ad1..ab2cd33 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,4 @@
 requests>=2.32.5
-beautifulsoup4>=4.14.3
\ No newline at end of file
+requests-mock>=1.12.1
+beautifulsoup4>=4.14.3
+    
\ No newline at end of file
diff --git a/test_main.py b/test_main.py
index 6b4a7ce..3d6b355 100644
--- a/test_main.py
+++ b/test_main.py
@@ -1,11 +1,107 @@
+from json import dumps
+from bs4 import Tag
+import pytest
+from requests_mock import Mocker
 from main import Scraper
 
 
-def test_soup():
-    assert Scraper().getsoup().find('h1')\
-        .text[3:12] == "MILLESIMA"
+@pytest.fixture(autouse=True)
+def mock_site():
+    with Mocker() as m:
+        m.get(
+            "https://www.millesima.fr/",
+            text="<html><body><h1>MILLESIMA</h1></body></html>",
+        )
+
+        json_data = {
+            "props": {
+                "pageProps": {
+                    "initialReduxState": {
+                        "product": {
+                            "content": {
+                                "_id": "J4131/22-11652",
+                                "partnumber": "J4131/22",
+                                "productName": "Nino Negri : 5 Stelle Sfursat 2022",
+                                "productNameForSearch": "Nino Negri : 5 Stelle Sfursat 2022",
+                                "storeId": "11652",
+                                "longdesc": "<h2>Caractéristiques et conseils de dégustation du 5 Stelle Sfursat 2022 de Nino Negri</h2><p><strong>Dégustation</strong></p><p><em>Robe</em></p><p>La robe dévoile une couleur grenat d'intensité moyenne.</p><p><em>Nez</em></p><p>Le nez révèle des arômes singuliers de fruits mûrs accompagnés de notes d'épices douces.</p><p><em>Bouche</em></p><p>En bouche, ce vin séduit par son équilibre remarquable, sa richesse et son caractère corsé. La dégustation dévoile une concentration intense et vigoureuse, portée par un fond aristocratique de mûre bien mûre et d'épices. La finale se distingue par sa longueur et sa persistance.</p><p><strong>Accords mets et vins</strong></p><p>Ce vin de caractère accompagne parfaitement les viandes rouges braisées, le gibier en sauce ou encore les fromages affinés à pâte dure.</p><p><strong>Service et garde</strong></p><p>Le 5 Stelle Sfursat 2022 gagnera à être servi à une température comprise entre 16 et 18°C.</p><h2>Un Sforzato di Valtellina d'exception élaboré par la Maison Nino Negri</h2><p><strong>La propriété</strong></p><p>Fondée en 1897 par Nino Negri à Chiuro en Valteline, cette Maison lombarde représente aujourd'hui la plus importante cave de la région. Propriété du Gruppo Italiano Vini depuis 1986, elle cultive 38 hectares de vignobles en terrasses sur des pentes alpines aux sols granitiques et calcaires. Sous la houlette de l'œnologue Danilo Drocco, <a href=\"/producteur-nino-negri.html\">Nino Negri</a> perpétue l'excellence du nebbiolo valtelin, notamment à travers son emblématique Sforzato élaboré selon la méthode traditionnelle d'appassimento.</p><p><strong>Le vignoble</strong></p><p>Le 5 Stelle Sfursat est issu de l'appellation <a href=\"/sforzato-di-valtellina.html\">Sforzato di Valtellina</a> DOCG, territoire d'exception où le nebbiolo s'épanouit sur des terrasses alpines escarpées. Les raisins proviennent de vignobles implantés sur des pentes granitiques et calcaires, bénéficiant d'une exposition optimale permettant une maturation idéale du nebbiolo.</p><p><strong>Vinification et élevage</strong></p><p>Le 5 Stelle Sfursat 2022 est produit uniquement lors des saisons les plus favorables. Les raisins sont récoltés manuellement et disposés en couche unique dans des caisses de 4 kg. Ils sont ensuite soumis à un séchage naturel dans un grenier pendant environ trois mois avant la vinification, selon la méthode traditionnelle de l'appassimento. Ce processus permet aux baies de perdre près de 30 % de leur poids, concentrant ainsi les arômes et les sucres naturels.</p><p><strong>Cépage</strong></p><p>Ce <a href=\"/lombardie.html\">vin de Lombardie</a> est un 100 % nebbiolo</p>", 
+                                "image": "J4131_2022NM_c.png",
+                                "seoKeyword": "nino-negri-5-stelle-sfursat-2022.html",
+                                "title": "Nino Negri : 5 Stelle Sfursat 2022",
+                                "metaDesc": "Nino Negri : 5 Stelle Sfursat 2022 : Vente en ligne, Grand vin d'origine garantie en provenance directe de la propriété - ✅ Qualité de stockage",
+                                "items": [
+                                    {
+                                        "_id": "J4131/22/C/CC/6-11652",
+                                        "partnumber": "J4131/22/C/CC/6",
+                                        "taxRate": "H",
+                                        "listPrice": 390,
+                                        "offerPrice": 390,
+                                        "seoKeyword": "nino-negri-5-stelle-sfursat-2022-c-cc-6.html",
+                                        "shortdesc": "Un carton de 6 Bouteilles (75cl)",
+                                        "attributes": {
+                                            "promotion_o_n": {
+                                                "valueId": "0",
+                                                "name": "En promotion",
+                                                "value": "Non",
+                                                "sequence": 80,
+                                                "displayable": "false",
+                                                "type": "CHECKBOX",
+                                                "isSpirit": False,
+                                            },
+                                            "in_stock": {
+                                                "valueId": "L",
+                                                "name": "En stock",
+                                                "value": "Livrable",
+                                                "sequence": 65,
+                                                "displayable": "true",
+                                                "type": "CHECKBOX",
+                                                "isSpirit": False,
+                                            },
+                                        },
+                                        "stock": 12,
+                                        "availability": "2026-02-05",
+                                        "isCustomizable": False,
+                                        "gtin_cond": "",
+                                        "gtin_unit": "",
+                                        "stockOrigin": "EUR",
+                                        "isPrevSale": False,
+                                    }
+                                ], 
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        html_product = f"""
+        <html>
+            <script id="__NEXT_DATA__" type="application/json">
+                {dumps(json_data)}
+            </script>
+        </body>
+        </html>
+        """
+        m.get("https://www.millesima.fr/nino-negri-5-stelle-sfursat-2022.html", text=html_product)
+
+        # on return m sans fermer le server qui simule la page
+        yield m
 
 
-def test_getProductName():
-    assert Scraper("chateau-gloria-2016.html").get_json_data()['productName']\
-        == "Château Gloria 2016"
+@pytest.fixture
+def scraper() -> Scraper:
+    return Scraper()
+
+
+def test_soup(scraper: Scraper):
+    h1: Tag | None = scraper.getsoup().find("h1")
+
+    assert isinstance(h1, Tag)
+    assert h1.text == "MILLESIMA"
+
+
+def test_getProductName(scraper: Scraper):
+    jsondata = scraper.getjsondata("nino-negri-5-stelle-sfursat-2022.html")
+    assert jsondata["productName"] == "Nino Negri : 5 Stelle Sfursat 2022"
+    assert len(jsondata["items"]) > 0
+    assert jsondata["items"][0]["offerPrice"] == 390
\ No newline at end of file