nodda-client 1.2.0__tar.gz

nodda_client-1.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nodda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nodda_client-1.2.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: nodda-client
+Version: 1.2.0
+Summary: Cliente oficial de la API de Nodda para emitir y consultar facturas VERI*FACTU (AEAT).
+Author-email: Nodda <soporte@nodda.es>
+License: MIT
+Project-URL: Documentacion, https://app.nodda.es/developers/introduccion
+Project-URL: Repositorio, https://gitlab.com/Bitfx/nodda-facturacion/nodda-cliente
+Keywords: verifactu,aeat,facturacion,factura,nodda
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# nodda-client (Python)
+
+Cliente oficial de la API de [Nodda](https://nodda.es) para emitir y consultar facturas **VERI\*FACTU** de la Agencia Tributaria (AEAT) desde tu propio programa (ERP, tienda online, TPV…).
+
+Nodda se encarga de la firma con tu certificado, del XML, de la cadena de huellas y del envío a la AEAT: tú solo mandas los datos de la factura en JSON.
+
+## Instalación
+
+```bash
+pip install nodda-client
+```
+
+Requisitos: Python 3.8 o superior. Sin dependencias (solo la librería estándar).
+
+## Antes de empezar
+
+1. Crea tu cuenta en el portal de Nodda y da de alta tu empresa (NIF y certificado digital).
+2. Genera tu **clave API** en el portal → *API keys*.
+3. Usa la dirección del entorno con su clave:
+
+| Entorno | Dirección | Uso |
+|---|---|---|
+| Pruebas | `https://sandbox.nodda.es` | Envía al entorno de pruebas de la AEAT, sin validez fiscal |
+| Producción | `https://api.nodda.es` | Facturas reales |
+
+La clave de pruebas no sirve en producción, ni al revés.
+
+## Uso
+
+```python
+import os
+from nodda_client import NoddaClient
+
+nodda = NoddaClient("https://sandbox.nodda.es", os.environ["NODDA_API_KEY"])
+
+r = nodda.crear_factura({
+    "series": "2026", "issueDate": "2026-11-03", "invoiceType": "F1",
+    "description": "Servicios de consultoría", "taxRegimeKey": "01", "operationQualification": "S1",
+    "taxBase": "100.00", "taxRate": "21", "taxAmount": "21.00", "totalAmount": "121.00",
+    "recipients": [{"nif": "B12345674", "name": "Cliente Demo SL"}],
+})
+# r["status"] == "queued": la API responde al momento; la AEAT, unos segundos después.
+
+estado = nodda.consultar_estado(r["id"])  # queued, sent, accepted_with_errors o permanently_failed
+```
+
+Si tu clave da acceso a varias empresas (NIF), indica cuál en el parámetro `nif` de cada método. Puedes asociar la factura a un centro de coste enviando `costCenterId` en los datos.
+
+## Métodos
+
+| Método | Endpoint |
+|---|---|
+| `crear_factura(datos, nif=None)` | `POST /v1/invoices` |
+| `consultar_estado(id, nif=None)` | `GET /v1/invoices/{id}` |
+| `listar_facturas(filtros=None, nif=None)` | `GET /v1/invoices` |
+| `cancelar_factura(id, datos=None, nif=None)` | `POST /v1/invoices/{id}/cancel` |
+| `reintentar_factura(id, tipo=None, nif=None)` | `POST /v1/invoices/{id}/retry` |
+| `obtener_url_qr(id)` / `obtener_imagen_qr(id)` | `GET /v1/invoices/{id}/qr` |
+| `estado_sistema(nif=None)` | `GET /v1/status` |
+| `obtener_perfil()` | `GET /v1/client` |
+| `configurar_webhook(url, nif=None)` / `quitar_webhook(nif=None)` | `PUT` / `DELETE /v1/webhooks` |
+| `NoddaClient.verificar_firma_webhook(cuerpo, firma, secreto)` | Comprueba la firma de un aviso |
+
+## Avisos (webhooks)
+
+En lugar de consultar el estado de cada factura, Nodda puede avisar a tu servidor cuando la AEAT responde. Configura la URL con `configurar_webhook(url)` (la respuesta trae el `secreto` **una sola vez**: guárdalo) y, en tu endpoint, comprueba la firma antes de confiar en el aviso:
+
+```python
+# cuerpo: bytes tal cual llegan; firma: cabecera X-Nodda-Signature
+if not NoddaClient.verificar_firma_webhook(cuerpo, firma, os.environ["NODDA_WEBHOOK_SECRET"]):
+    return 401
+```
+
+El cuerpo trae `id` (número de factura), `status` (`sent`, `accepted_with_errors` o `permanently_failed`), `razon`, `eventId` y los datos del acuse de la AEAT. Responde con un código 2xx; si no, Nodda lo reintenta.
+
+## Errores
+
+Si la API responde con un error, se lanza `NoddaApiException` con el código HTTP y un código estable (por ejemplo `invalid_request`, `business_rule_violation`, `certificate_not_configured`). Si no hubo respuesta (fallo de red), se lanza `NoddaException`: puedes reintentar la misma petición.
+
+## Documentación
+
+Guía completa, campos de cada petición y códigos de error: <https://app.nodda.es/developers/introduccion>
+Referencia OpenAPI: <https://api.nodda.es/openapi.json>
+
+Soporte: soporte@nodda.es
+
+## Licencia
+
+MIT

nodda_client-1.2.0/README.md

@@ -0,0 +1,89 @@
+# nodda-client (Python)
+
+Cliente oficial de la API de [Nodda](https://nodda.es) para emitir y consultar facturas **VERI\*FACTU** de la Agencia Tributaria (AEAT) desde tu propio programa (ERP, tienda online, TPV…).
+
+Nodda se encarga de la firma con tu certificado, del XML, de la cadena de huellas y del envío a la AEAT: tú solo mandas los datos de la factura en JSON.
+
+## Instalación
+
+```bash
+pip install nodda-client
+```
+
+Requisitos: Python 3.8 o superior. Sin dependencias (solo la librería estándar).
+
+## Antes de empezar
+
+1. Crea tu cuenta en el portal de Nodda y da de alta tu empresa (NIF y certificado digital).
+2. Genera tu **clave API** en el portal → *API keys*.
+3. Usa la dirección del entorno con su clave:
+
+| Entorno | Dirección | Uso |
+|---|---|---|
+| Pruebas | `https://sandbox.nodda.es` | Envía al entorno de pruebas de la AEAT, sin validez fiscal |
+| Producción | `https://api.nodda.es` | Facturas reales |
+
+La clave de pruebas no sirve en producción, ni al revés.
+
+## Uso
+
+```python
+import os
+from nodda_client import NoddaClient
+
+nodda = NoddaClient("https://sandbox.nodda.es", os.environ["NODDA_API_KEY"])
+
+r = nodda.crear_factura({
+    "series": "2026", "issueDate": "2026-11-03", "invoiceType": "F1",
+    "description": "Servicios de consultoría", "taxRegimeKey": "01", "operationQualification": "S1",
+    "taxBase": "100.00", "taxRate": "21", "taxAmount": "21.00", "totalAmount": "121.00",
+    "recipients": [{"nif": "B12345674", "name": "Cliente Demo SL"}],
+})
+# r["status"] == "queued": la API responde al momento; la AEAT, unos segundos después.
+
+estado = nodda.consultar_estado(r["id"])  # queued, sent, accepted_with_errors o permanently_failed
+```
+
+Si tu clave da acceso a varias empresas (NIF), indica cuál en el parámetro `nif` de cada método. Puedes asociar la factura a un centro de coste enviando `costCenterId` en los datos.
+
+## Métodos
+
+| Método | Endpoint |
+|---|---|
+| `crear_factura(datos, nif=None)` | `POST /v1/invoices` |
+| `consultar_estado(id, nif=None)` | `GET /v1/invoices/{id}` |
+| `listar_facturas(filtros=None, nif=None)` | `GET /v1/invoices` |
+| `cancelar_factura(id, datos=None, nif=None)` | `POST /v1/invoices/{id}/cancel` |
+| `reintentar_factura(id, tipo=None, nif=None)` | `POST /v1/invoices/{id}/retry` |
+| `obtener_url_qr(id)` / `obtener_imagen_qr(id)` | `GET /v1/invoices/{id}/qr` |
+| `estado_sistema(nif=None)` | `GET /v1/status` |
+| `obtener_perfil()` | `GET /v1/client` |
+| `configurar_webhook(url, nif=None)` / `quitar_webhook(nif=None)` | `PUT` / `DELETE /v1/webhooks` |
+| `NoddaClient.verificar_firma_webhook(cuerpo, firma, secreto)` | Comprueba la firma de un aviso |
+
+## Avisos (webhooks)
+
+En lugar de consultar el estado de cada factura, Nodda puede avisar a tu servidor cuando la AEAT responde. Configura la URL con `configurar_webhook(url)` (la respuesta trae el `secreto` **una sola vez**: guárdalo) y, en tu endpoint, comprueba la firma antes de confiar en el aviso:
+
+```python
+# cuerpo: bytes tal cual llegan; firma: cabecera X-Nodda-Signature
+if not NoddaClient.verificar_firma_webhook(cuerpo, firma, os.environ["NODDA_WEBHOOK_SECRET"]):
+    return 401
+```
+
+El cuerpo trae `id` (número de factura), `status` (`sent`, `accepted_with_errors` o `permanently_failed`), `razon`, `eventId` y los datos del acuse de la AEAT. Responde con un código 2xx; si no, Nodda lo reintenta.
+
+## Errores
+
+Si la API responde con un error, se lanza `NoddaApiException` con el código HTTP y un código estable (por ejemplo `invalid_request`, `business_rule_violation`, `certificate_not_configured`). Si no hubo respuesta (fallo de red), se lanza `NoddaException`: puedes reintentar la misma petición.
+
+## Documentación
+
+Guía completa, campos de cada petición y códigos de error: <https://app.nodda.es/developers/introduccion>
+Referencia OpenAPI: <https://api.nodda.es/openapi.json>
+
+Soporte: soporte@nodda.es
+
+## Licencia
+
+MIT

nodda_client-1.2.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nodda-client"
+version = "1.2.0"
+description = "Cliente oficial de la API de Nodda para emitir y consultar facturas VERI*FACTU (AEAT)."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Nodda", email = "soporte@nodda.es" }]
+keywords = ["verifactu", "aeat", "facturacion", "factura", "nodda"]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+dependencies = []
+
+[project.urls]
+Documentacion = "https://app.nodda.es/developers/introduccion"
+Repositorio = "https://gitlab.com/Bitfx/nodda-facturacion/nodda-cliente"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"

nodda_client-1.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nodda_client-1.2.0/src/nodda_client/__init__.py

@@ -0,0 +1,18 @@
+"""SDK publico de Nodda -- capa 3. Cliente HTTP delgado, sin conocimiento
+de AEAT, certificados, ni logica de negocio.
+"""
+
+from .client import NoddaClient
+from .exceptions import NoddaApiException, NoddaException
+from .http_transport import HttpTransport, RespuestaHttp, UrllibHttpTransport
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "NoddaClient",
+    "NoddaException",
+    "NoddaApiException",
+    "HttpTransport",
+    "RespuestaHttp",
+    "UrllibHttpTransport",
+]

nodda_client-1.2.0/src/nodda_client/client.py

@@ -0,0 +1,229 @@
+"""Cliente del SDK publico de Nodda (capa 3)."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import secrets
+from urllib.parse import quote, urlencode
+
+from .exceptions import NoddaApiException, NoddaException
+from .http_transport import HttpTransport, RespuestaHttp, UrllibHttpTransport
+
+
+class NoddaClient:
+    """SDK publico de Nodda -- capa 3 de la arquitectura::
+
+        Este SDK -> API propia -> Core Engine -> AEAT
+
+    A proposito NO sabe nada de AEAT, certificados, XML, ni hash -- solo
+    habla HTTP/JSON con la API propia. Cualquier logica de negocio
+    (validaciones, reglas de VERI*FACTU) vive del lado de la API/Core
+    Engine, nunca aqui.
+
+    Multi-NIF: un token puede autorizar varios NIF ("1 cuenta principal,
+    varias empresas"). Por eso cada metodo que habla con una factura
+    especifica acepta un ``nif`` OPCIONAL -- si tu token solo tiene 1 NIF
+    autorizado, puedes seguir sin pasarlo.
+    """
+
+    def __init__(self, base_url: str, api_key: str, http: HttpTransport | None = None) -> None:
+        self._base_url = base_url
+        self._api_key = api_key
+        self._http: HttpTransport = http or UrllibHttpTransport()
+        self._ultimo_correlation_id: str | None = None
+        self._ultimo_cupo_restante: int | None = None
+
+    def crear_factura(self, datos: dict, nif: str | None = None) -> dict:
+        """POST /v1/invoices -- registra una factura. Siempre devuelve de
+        inmediato con status "queued"; usa consultar_estado() despues para
+        saber el resultado real.
+        """
+        if nif is not None:
+            datos = {**datos, "nif": nif}
+        return self._peticion("POST", "/v1/invoices", datos)
+
+    def consultar_estado(self, id: str, nif: str | None = None) -> dict:
+        """GET /v1/invoices/{id} -- estado real de una factura ya emitida."""
+        return self._peticion("GET", f"/v1/invoices/{id}{self._query_nif(nif)}")
+
+    def cancelar_factura(self, id: str, datos: dict | None = None, nif: str | None = None) -> dict:
+        """POST /v1/invoices/{id}/cancel -- anula una factura. VERI*FACTU no
+        permite borrar, solo anular con un registro nuevo.
+        """
+        datos = dict(datos or {})
+        if nif is not None:
+            datos["nif"] = nif
+        return self._peticion("POST", f"/v1/invoices/{id}/cancel", datos)
+
+    def obtener_url_qr(self, id: str, nif: str | None = None) -> str:
+        """GET /v1/invoices/{id}/qr?format=url -- la URL del codigo QR."""
+        query = f"?format=url&nif={quote(nif)}" if nif is not None else "?format=url"
+        respuesta = self._peticion("GET", f"/v1/invoices/{id}/qr{query}")
+        return str(respuesta["url"])
+
+    def obtener_imagen_qr(self, id: str, nif: str | None = None) -> bytes:
+        """GET /v1/invoices/{id}/qr -- la imagen PNG del codigo QR, en
+        binario crudo (bytes, listo para guardar a archivo o incrustar en
+        un PDF).
+        """
+        respuesta = self._http.request(
+            "GET",
+            self._url_completa(f"/v1/invoices/{id}/qr{self._query_nif(nif)}"),
+            self._headers(),
+        )
+        if respuesta.status >= 400:
+            self._lanzar_error_desde_json(respuesta)
+        return respuesta.body
+
+    def estado_sistema(self, nif: str | None = None) -> dict:
+        """GET /v1/status -- si se puede enviar ahora o hay que esperar
+        (control de flujo de AEAT). El tiempo de espera es por certificado,
+        no por token.
+        """
+        return self._peticion("GET", f"/v1/status{self._query_nif(nif)}")
+
+    def listar_facturas(self, filtros: dict | None = None, nif: str | None = None) -> dict:
+        """GET /v1/invoices -- lista las facturas propias, con filtros
+        opcionales (status, type, from, to, limit, offset).
+        """
+        filtros = dict(filtros or {})
+        if nif is not None:
+            filtros["nif"] = nif
+        query = f"?{urlencode(filtros)}" if filtros else ""
+        return self._peticion("GET", f"/v1/invoices{query}")
+
+    def reintentar_factura(self, id: str, tipo: str | None = None, nif: str | None = None) -> dict:
+        """POST /v1/invoices/{id}/retry -- fuerza un reintento manual, sin
+        esperar el ciclo automatico. ``tipo`` es 'alta' o 'anulacion'.
+        """
+        parametros: dict[str, str] = {}
+        if tipo is not None:
+            parametros["type"] = tipo
+        if nif is not None:
+            parametros["nif"] = nif
+        query = f"?{urlencode(parametros)}" if parametros else ""
+        return self._peticion("POST", f"/v1/invoices/{id}/retry{query}")
+
+    def obtener_perfil(self) -> dict:
+        """GET /v1/client -- los NIF autorizados para este token."""
+        return self._peticion("GET", "/v1/client")
+
+    def configurar_webhook(self, url: str, nif: str | None = None) -> dict:
+        """PUT /v1/webhooks -- configura la URL (https) a la que Nodda avisa cuando la AEAT responde.
+        La respuesta trae el ``secreto`` de firma UNA sola vez: guardalo para verificar_firma_webhook()."""
+        return self._peticion("PUT", f"/v1/webhooks{self._query_nif(nif)}", {"url": url})
+
+    def quitar_webhook(self, nif: str | None = None) -> dict:
+        """DELETE /v1/webhooks -- deja de enviar avisos."""
+        return self._peticion("DELETE", f"/v1/webhooks{self._query_nif(nif)}")
+
+    @staticmethod
+    def verificar_firma_webhook(cuerpo: bytes | str, firma: str | None, secreto: str) -> bool:
+        """Comprueba que un aviso viene de Nodda: X-Nodda-Signature es el HMAC-SHA256 (hex) del cuerpo EXACTO
+        recibido, con tu secreto. Usa el cuerpo sin decodificar."""
+        if not firma or not secreto:
+            return False
+        datos = cuerpo.encode("utf-8") if isinstance(cuerpo, str) else cuerpo
+        esperada = hmac.new(secreto.encode("utf-8"), datos, hashlib.sha256).hexdigest()
+        return hmac.compare_digest(esperada, firma.strip().lower())
+
+    def ultimo_correlation_id(self) -> str | None:
+        """El X-Correlation-Id enviado en la ultima peticion, o None."""
+        return self._ultimo_correlation_id
+
+    def ultimo_cupo_restante(self) -> int | None:
+        """Cuantas facturas gratuitas le quedan al cliente segun el ultimo
+        crear_factura() -- None si el NIF no esta sujeto a cupo (plan de
+        pago) o si el servidor no mando el encabezado. No hace su propia
+        peticion -- solo lee el encabezado de la ULTIMA respuesta.
+        """
+        return self._ultimo_cupo_restante
+
+    @staticmethod
+    def registrar_cuenta(
+        base_url: str,
+        email: str,
+        nif: str,
+        nombre_emisor: str,
+        telefono: str | None = None,
+        http: HttpTransport | None = None,
+    ) -> dict:
+        """POST /v1/cuentas -- registro publico, SIN necesitar una API Key
+        previa (por eso es estatico y no manda Authorization). Devuelve una
+        API Key nueva -- guardala de inmediato, el servidor no la vuelve a
+        mostrar.
+        """
+        http = http or UrllibHttpTransport()
+        datos = {"email": email, "nif": nif, "nombreEmisor": nombre_emisor}
+        if telefono is not None:
+            datos["telefono"] = telefono
+
+        respuesta = http.request(
+            "POST",
+            f"{base_url.rstrip('/')}/v1/cuentas",
+            {"Content-Type": "application/json"},
+            json.dumps(datos),
+        )
+        if respuesta.status >= 400:
+            NoddaClient._lanzar_error_estatico(respuesta)
+        decodificado = NoddaClient._intentar_json(respuesta.body)
+        if decodificado is None:
+            raise NoddaException(
+                f"La API devolvio una respuesta que no es JSON valido: {respuesta.body.decode('utf-8', 'replace')}"
+            )
+        return decodificado
+
+    # -- internos -----------------------------------------------------------
+
+    @staticmethod
+    def _query_nif(nif: str | None) -> str:
+        return f"?nif={quote(nif)}" if nif is not None else ""
+
+    def _peticion(self, metodo: str, ruta: str, datos: dict | None = None) -> dict:
+        cuerpo = json.dumps(datos) if datos is not None else None
+        respuesta = self._http.request(metodo, self._url_completa(ruta), self._headers(), cuerpo)
+
+        if respuesta.status >= 400:
+            self._lanzar_error_desde_json(respuesta)
+
+        valor = respuesta.headers.get("X-Nodda-Quota-Remaining")
+        self._ultimo_cupo_restante = int(valor) if valor is not None else None
+
+        decodificado = self._intentar_json(respuesta.body)
+        if decodificado is None:
+            raise NoddaException(
+                f"La API devolvio una respuesta que no es JSON valido: {respuesta.body.decode('utf-8', 'replace')}"
+            )
+        return decodificado
+
+    def _lanzar_error_desde_json(self, respuesta: RespuestaHttp) -> None:
+        self._lanzar_error_estatico(respuesta)
+
+    @staticmethod
+    def _lanzar_error_estatico(respuesta: RespuestaHttp) -> None:
+        decodificado = NoddaClient._intentar_json(respuesta.body) or {}
+        error = decodificado.get("error", {}) if isinstance(decodificado, dict) else {}
+        mensaje = error.get("message") or f"La API respondio con el codigo HTTP {respuesta.status}."
+        codigo = error.get("code")
+        raise NoddaApiException(mensaje, respuesta.status, codigo)
+
+    def _url_completa(self, ruta: str) -> str:
+        return self._base_url.rstrip("/") + ruta
+
+    def _headers(self) -> dict[str, str]:
+        self._ultimo_correlation_id = secrets.token_hex(16)
+        return {
+            "Authorization": f"Bearer {self._api_key}",
+            "Content-Type": "application/json",
+            "X-Correlation-Id": self._ultimo_correlation_id,
+        }
+
+    @staticmethod
+    def _intentar_json(body: bytes):
+        try:
+            valor = json.loads(body.decode("utf-8"))
+        except (ValueError, UnicodeDecodeError):
+            return None
+        return valor if isinstance(valor, (dict, list)) else None

nodda_client-1.2.0/src/nodda_client/exceptions.py

@@ -0,0 +1,26 @@
+"""Excepciones del SDK publico de Nodda."""
+
+from __future__ import annotations
+
+
+class NoddaException(Exception):
+    """Excepcion generica de comunicacion (red, timeout).
+
+    Para errores que la API devuelve con codigo HTTP de error (422, 404,
+    etc.), ver NoddaApiException -- son cosas distintas: esta es "no se
+    pudo ni hablar con la API", la otra es "la API respondio, pero con un
+    error".
+    """
+
+
+class NoddaApiException(NoddaException):
+    """Se lanza cuando la API de Nodda SI respondio, pero con un codigo de
+    error (422 = dato invalido o regla de negocio, 404 = no encontrado,
+    500 = error interno). Distinta de NoddaException (esa es cuando ni
+    siquiera hubo respuesta -- problema de red).
+    """
+
+    def __init__(self, mensaje: str, status_code: int, codigo_error: str | None) -> None:
+        super().__init__(mensaje)
+        self.status_code = status_code
+        self.codigo_error = codigo_error

nodda_client-1.2.0/src/nodda_client/http_transport.py

@@ -0,0 +1,91 @@
+"""Transporte HTTP del SDK: interfaz + implementacion real con urllib."""
+
+from __future__ import annotations
+
+import urllib.error
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Protocol
+
+from .exceptions import NoddaException
+
+
+@dataclass
+class RespuestaHttp:
+    """Respuesta cruda del transporte.
+
+    body son bytes (texto JSON o imagen PNG); headers tiene el nombre del
+    encabezado en Title-Case.
+    """
+
+    status: int
+    body: bytes
+    headers: dict[str, str] = field(default_factory=dict)
+
+
+class HttpTransport(Protocol):
+    """Abstrae el transporte HTTP -- misma razon que HttpClientInterface en
+    el SDK de PHP: sin esto no se puede probar NoddaClient con un doble de
+    prueba en vez de la conexion real. La implementacion real es
+    UrllibHttpTransport.
+    """
+
+    def request(
+        self,
+        metodo: str,
+        url: str,
+        headers: dict[str, str] | None = None,
+        cuerpo: str | None = None,
+    ) -> RespuestaHttp:
+        ...
+
+
+class UrllibHttpTransport:
+    """Implementacion real usando urllib de la biblioteca estandar -- sin
+    requests ni ninguna otra libreria HTTP, mismo criterio que el SDK de
+    PHP (curl crudo, sin Guzzle): mantener el SDK publico con el minimo de
+    dependencias posible, ya que lo va a instalar gente externa.
+    """
+
+    _TIEMPO_LIMITE = 30
+
+    def request(
+        self,
+        metodo: str,
+        url: str,
+        headers: dict[str, str] | None = None,
+        cuerpo: str | None = None,
+    ) -> RespuestaHttp:
+        headers = headers or {}
+        datos = cuerpo.encode("utf-8") if cuerpo is not None else None
+        peticion = urllib.request.Request(url=url, data=datos, headers=headers, method=metodo.upper())
+
+        try:
+            with urllib.request.urlopen(peticion, timeout=self._TIEMPO_LIMITE) as respuesta:
+                return RespuestaHttp(
+                    status=respuesta.status,
+                    body=respuesta.read(),
+                    headers=self._normalizar(respuesta.headers.items()),
+                )
+        except urllib.error.HTTPError as e:
+            # La API respondio con un codigo de error (>= 400); no es un
+            # fallo de red -- se devuelve como respuesta normal para que
+            # NoddaClient lo traduzca a NoddaApiException.
+            return RespuestaHttp(
+                status=e.code,
+                body=e.read(),
+                headers=self._normalizar(e.headers.items() if e.headers else []),
+            )
+        except urllib.error.URLError as e:
+            raise NoddaException(f"Fallo de comunicacion con la API de Nodda: {e.reason}") from e
+
+    @staticmethod
+    def _normalizar(items) -> dict[str, str]:
+        # HTTP/2 manda los nombres en minusculas; se normalizan a Title-Case
+        # para que el resto del codigo pueda buscar por un nombre fijo
+        # (p. ej. "X-Nodda-Quota-Remaining").
+        encabezados: dict[str, str] = {}
+        for nombre, valor in items:
+            titulo = "-".join(p[:1].upper() + p[1:] for p in nombre.split("-"))
+            encabezados[titulo] = valor
+        return encabezados

nodda_client-1.2.0/src/nodda_client.egg-info/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: nodda-client
+Version: 1.2.0
+Summary: Cliente oficial de la API de Nodda para emitir y consultar facturas VERI*FACTU (AEAT).
+Author-email: Nodda <soporte@nodda.es>
+License: MIT
+Project-URL: Documentacion, https://app.nodda.es/developers/introduccion
+Project-URL: Repositorio, https://gitlab.com/Bitfx/nodda-facturacion/nodda-cliente
+Keywords: verifactu,aeat,facturacion,factura,nodda
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# nodda-client (Python)
+
+Cliente oficial de la API de [Nodda](https://nodda.es) para emitir y consultar facturas **VERI\*FACTU** de la Agencia Tributaria (AEAT) desde tu propio programa (ERP, tienda online, TPV…).
+
+Nodda se encarga de la firma con tu certificado, del XML, de la cadena de huellas y del envío a la AEAT: tú solo mandas los datos de la factura en JSON.
+
+## Instalación
+
+```bash
+pip install nodda-client
+```
+
+Requisitos: Python 3.8 o superior. Sin dependencias (solo la librería estándar).
+
+## Antes de empezar
+
+1. Crea tu cuenta en el portal de Nodda y da de alta tu empresa (NIF y certificado digital).
+2. Genera tu **clave API** en el portal → *API keys*.
+3. Usa la dirección del entorno con su clave:
+
+| Entorno | Dirección | Uso |
+|---|---|---|
+| Pruebas | `https://sandbox.nodda.es` | Envía al entorno de pruebas de la AEAT, sin validez fiscal |
+| Producción | `https://api.nodda.es` | Facturas reales |
+
+La clave de pruebas no sirve en producción, ni al revés.
+
+## Uso
+
+```python
+import os
+from nodda_client import NoddaClient
+
+nodda = NoddaClient("https://sandbox.nodda.es", os.environ["NODDA_API_KEY"])
+
+r = nodda.crear_factura({
+    "series": "2026", "issueDate": "2026-11-03", "invoiceType": "F1",
+    "description": "Servicios de consultoría", "taxRegimeKey": "01", "operationQualification": "S1",
+    "taxBase": "100.00", "taxRate": "21", "taxAmount": "21.00", "totalAmount": "121.00",
+    "recipients": [{"nif": "B12345674", "name": "Cliente Demo SL"}],
+})
+# r["status"] == "queued": la API responde al momento; la AEAT, unos segundos después.
+
+estado = nodda.consultar_estado(r["id"])  # queued, sent, accepted_with_errors o permanently_failed
+```
+
+Si tu clave da acceso a varias empresas (NIF), indica cuál en el parámetro `nif` de cada método. Puedes asociar la factura a un centro de coste enviando `costCenterId` en los datos.
+
+## Métodos
+
+| Método | Endpoint |
+|---|---|
+| `crear_factura(datos, nif=None)` | `POST /v1/invoices` |
+| `consultar_estado(id, nif=None)` | `GET /v1/invoices/{id}` |
+| `listar_facturas(filtros=None, nif=None)` | `GET /v1/invoices` |
+| `cancelar_factura(id, datos=None, nif=None)` | `POST /v1/invoices/{id}/cancel` |
+| `reintentar_factura(id, tipo=None, nif=None)` | `POST /v1/invoices/{id}/retry` |
+| `obtener_url_qr(id)` / `obtener_imagen_qr(id)` | `GET /v1/invoices/{id}/qr` |
+| `estado_sistema(nif=None)` | `GET /v1/status` |
+| `obtener_perfil()` | `GET /v1/client` |
+| `configurar_webhook(url, nif=None)` / `quitar_webhook(nif=None)` | `PUT` / `DELETE /v1/webhooks` |
+| `NoddaClient.verificar_firma_webhook(cuerpo, firma, secreto)` | Comprueba la firma de un aviso |
+
+## Avisos (webhooks)
+
+En lugar de consultar el estado de cada factura, Nodda puede avisar a tu servidor cuando la AEAT responde. Configura la URL con `configurar_webhook(url)` (la respuesta trae el `secreto` **una sola vez**: guárdalo) y, en tu endpoint, comprueba la firma antes de confiar en el aviso:
+
+```python
+# cuerpo: bytes tal cual llegan; firma: cabecera X-Nodda-Signature
+if not NoddaClient.verificar_firma_webhook(cuerpo, firma, os.environ["NODDA_WEBHOOK_SECRET"]):
+    return 401
+```
+
+El cuerpo trae `id` (número de factura), `status` (`sent`, `accepted_with_errors` o `permanently_failed`), `razon`, `eventId` y los datos del acuse de la AEAT. Responde con un código 2xx; si no, Nodda lo reintenta.
+
+## Errores
+
+Si la API responde con un error, se lanza `NoddaApiException` con el código HTTP y un código estable (por ejemplo `invalid_request`, `business_rule_violation`, `certificate_not_configured`). Si no hubo respuesta (fallo de red), se lanza `NoddaException`: puedes reintentar la misma petición.
+
+## Documentación
+
+Guía completa, campos de cada petición y códigos de error: <https://app.nodda.es/developers/introduccion>
+Referencia OpenAPI: <https://api.nodda.es/openapi.json>
+
+Soporte: soporte@nodda.es
+
+## Licencia
+
+MIT

nodda_client-1.2.0/src/nodda_client.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/nodda_client/__init__.py
+src/nodda_client/client.py
+src/nodda_client/exceptions.py
+src/nodda_client/http_transport.py
+src/nodda_client.egg-info/PKG-INFO
+src/nodda_client.egg-info/SOURCES.txt
+src/nodda_client.egg-info/dependency_links.txt
+src/nodda_client.egg-info/top_level.txt
+tests/test_nodda_client.py

nodda_client-1.2.0/src/nodda_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nodda_client-1.2.0/src/nodda_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+nodda_client

nodda_client-1.2.0/tests/test_nodda_client.py

@@ -0,0 +1,283 @@
+import json
+import unittest
+
+from nodda_client import NoddaApiException, NoddaClient
+from tests.fake_http_transport import FakeHttpTransport
+
+
+class NoddaClientTest(unittest.TestCase):
+    def test_crear_factura_manda_metodo_y_ruta_correctos(self):
+        fake = FakeHttpTransport.que_responde(202, '{"id":"A-0001","status":"queued"}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY_DE_PRUEBA", fake)
+
+        resultado = client.crear_factura({"series": "A", "number": "0001"})
+
+        self.assertEqual("A-0001", resultado["id"])
+        self.assertEqual("queued", resultado["status"])
+        self.assertEqual(1, len(fake.peticiones_recibidas))
+        metodo, url, headers, cuerpo = fake.peticiones_recibidas[0]
+        self.assertEqual("POST", metodo)
+        self.assertEqual("https://api.nodda.test/v1/invoices", url)
+        self.assertEqual("Bearer API_KEY_DE_PRUEBA", headers["Authorization"])
+        self.assertEqual({"series": "A", "number": "0001"}, json.loads(cuerpo))
+
+    def test_consultar_estado_manda_get_a_la_ruta_correcta(self):
+        fake = FakeHttpTransport.que_responde(200, '{"id":"A-0001","status":"sent"}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        resultado = client.consultar_estado("A-0001")
+
+        self.assertEqual("sent", resultado["status"])
+        metodo, url, _, _ = fake.peticiones_recibidas[0]
+        self.assertEqual("GET", metodo)
+        self.assertEqual("https://api.nodda.test/v1/invoices/A-0001", url)
+
+    def test_cancelar_factura_manda_post_a_la_ruta_de_cancel(self):
+        fake = FakeHttpTransport.que_responde(202, '{"id":"A-0001","status":"queued"}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.cancelar_factura("A-0001", {"generatedBy": "E"})
+
+        metodo, url, _, _ = fake.peticiones_recibidas[0]
+        self.assertEqual("POST", metodo)
+        self.assertEqual("https://api.nodda.test/v1/invoices/A-0001/cancel", url)
+
+    def test_obtener_url_qr_pide_formato_url_y_devuelve_solo_la_url(self):
+        fake = FakeHttpTransport.que_responde(
+            200, '{"url":"https://www2.agenciatributaria.es/wlpl/TIKE-CONT/ValidarQR?nif=B12345678"}'
+        )
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        url = client.obtener_url_qr("A-0001")
+
+        self.assertEqual("https://www2.agenciatributaria.es/wlpl/TIKE-CONT/ValidarQR?nif=B12345678", url)
+        _, url_pedida, _, _ = fake.peticiones_recibidas[0]
+        self.assertIn("format=url", url_pedida)
+
+    def test_obtener_imagen_qr_devuelve_el_binario_crudo_sin_decodificar(self):
+        bytes_falsos = bytes([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 1, 2, 3])
+        fake = FakeHttpTransport.que_responde(200, bytes_falsos)
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        imagen = client.obtener_imagen_qr("A-0001")
+
+        self.assertIsInstance(imagen, bytes)
+        self.assertEqual(bytes_falsos, imagen)
+
+    def test_obtener_imagen_qr_con_error_lanza_nodda_api_exception(self):
+        fake = FakeHttpTransport.que_responde(404, '{"error":{"code":"not_found","message":"No existe esa factura"}}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        with self.assertRaises(NoddaApiException) as ctx:
+            client.obtener_imagen_qr("NUNCA-EXISTIO")
+        self.assertEqual(404, ctx.exception.status_code)
+        self.assertEqual("not_found", ctx.exception.codigo_error)
+
+    def test_estado_sistema_manda_get_a_status(self):
+        fake = FakeHttpTransport.que_responde(200, '{"canSendNow":true,"nextAllowedSendAt":null}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        resultado = client.estado_sistema()
+
+        self.assertTrue(resultado["canSendNow"])
+        _, url, _, _ = fake.peticiones_recibidas[0]
+        self.assertEqual("https://api.nodda.test/v1/status", url)
+
+    def test_listar_facturas_sin_filtros_manda_get_sin_query(self):
+        fake = FakeHttpTransport.que_responde(200, '{"invoices":[],"pagination":{"total":0,"limit":20,"offset":0}}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.listar_facturas()
+
+        metodo, url, _, _ = fake.peticiones_recibidas[0]
+        self.assertEqual("GET", metodo)
+        self.assertEqual("https://api.nodda.test/v1/invoices", url)
+
+    def test_listar_facturas_con_filtros_los_incluye_en_la_query(self):
+        fake = FakeHttpTransport.que_responde(200, '{"invoices":[],"pagination":{"total":0,"limit":20,"offset":0}}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.listar_facturas({"status": "permanently_failed", "limit": "5"})
+
+        _, url, _, _ = fake.peticiones_recibidas[0]
+        self.assertIn("status=permanently_failed", url)
+        self.assertIn("limit=5", url)
+
+    def test_reintentar_factura_sin_tipo_manda_post_sin_query(self):
+        fake = FakeHttpTransport.que_responde(202, '{"id":"A-0001","status":"queued"}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.reintentar_factura("A-0001")
+
+        metodo, url, _, _ = fake.peticiones_recibidas[0]
+        self.assertEqual("POST", metodo)
+        self.assertEqual("https://api.nodda.test/v1/invoices/A-0001/retry", url)
+
+    def test_reintentar_factura_con_tipo_lo_incluye_en_la_query(self):
+        fake = FakeHttpTransport.que_responde(202, '{"id":"A-0001","status":"queued"}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.reintentar_factura("A-0001", "anulacion")
+
+        _, url, _, _ = fake.peticiones_recibidas[0]
+        self.assertEqual("https://api.nodda.test/v1/invoices/A-0001/retry?type=anulacion", url)
+
+    def test_obtener_perfil_manda_get_a_la_ruta_correcta(self):
+        fake = FakeHttpTransport.que_responde(200, '{"nifs":[{"nif":"B12345678","nombreEmisor":"Empresa Demo SL"}]}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        resultado = client.obtener_perfil()
+
+        self.assertEqual("B12345678", resultado["nifs"][0]["nif"])
+        metodo, url, _, _ = fake.peticiones_recibidas[0]
+        self.assertEqual("GET", metodo)
+        self.assertEqual("https://api.nodda.test/v1/client", url)
+
+    def test_crear_factura_con_nif_lo_incluye_en_el_cuerpo(self):
+        fake = FakeHttpTransport.que_responde(202, '{"id":"A-0001","status":"queued"}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.crear_factura({"series": "A", "number": "0001"}, "B22222222")
+
+        _, _, _, cuerpo = fake.peticiones_recibidas[0]
+        self.assertEqual({"series": "A", "number": "0001", "nif": "B22222222"}, json.loads(cuerpo))
+
+    def test_crear_factura_sin_nif_no_lo_incluye_en_el_cuerpo(self):
+        fake = FakeHttpTransport.que_responde(202, '{"id":"A-0001","status":"queued"}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.crear_factura({"series": "A", "number": "0001"})
+
+        _, _, _, cuerpo = fake.peticiones_recibidas[0]
+        self.assertNotIn("nif", cuerpo)
+
+    def test_listar_facturas_con_nif_lo_incluye_en_la_url(self):
+        fake = FakeHttpTransport.que_responde(200, '{"invoices":[],"pagination":{"total":0,"limit":20,"offset":0}}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.listar_facturas({"status": "permanently_failed"}, "B33333333")
+
+        _, url, _, _ = fake.peticiones_recibidas[0]
+        self.assertIn("nif=B33333333", url)
+        self.assertIn("status=permanently_failed", url)
+
+    def test_estado_sistema_con_nif_lo_incluye_en_la_url(self):
+        fake = FakeHttpTransport.que_responde(200, '{"canSendNow":true,"nextAllowedSendAt":null}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.estado_sistema("B11111111")
+
+        _, url, _, _ = fake.peticiones_recibidas[0]
+        self.assertEqual("https://api.nodda.test/v1/status?nif=B11111111", url)
+
+    def test_un_error_de_la_api_lanza_nodda_api_exception_con_el_detalle(self):
+        fake = FakeHttpTransport.que_responde(422, '{"error":{"code":"business_rule_violation","message":"Fecha invalida"}}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        with self.assertRaises(NoddaApiException) as ctx:
+            client.crear_factura({"series": "A"})
+        self.assertEqual(422, ctx.exception.status_code)
+        self.assertEqual("business_rule_violation", ctx.exception.codigo_error)
+        self.assertEqual("Fecha invalida", str(ctx.exception))
+
+    def test_un_error_sin_cuerpo_json_valido_no_rompe_el_manejo_de_errores(self):
+        fake = FakeHttpTransport.que_responde(500, "esto no es json")
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        with self.assertRaises(NoddaApiException) as ctx:
+            client.consultar_estado("A-0001")
+        self.assertEqual(500, ctx.exception.status_code)
+        self.assertIsNone(ctx.exception.codigo_error)
+
+    def test_la_api_key_viaja_en_el_header_authorization(self):
+        fake = FakeHttpTransport.que_responde(200, '{"canSendNow":true,"nextAllowedSendAt":null}')
+        client = NoddaClient("https://api.nodda.test", "MI_API_KEY_SECRETA", fake)
+
+        client.estado_sistema()
+
+        _, _, headers, _ = fake.peticiones_recibidas[0]
+        self.assertEqual("Bearer MI_API_KEY_SECRETA", headers["Authorization"])
+
+    def test_cada_peticion_manda_un_correlation_id_distinto(self):
+        fake = FakeHttpTransport.que_responde(200, '{"canSendNow":true,"nextAllowedSendAt":null}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.estado_sistema()
+        _, _, primeros, _ = fake.peticiones_recibidas[0]
+        client.estado_sistema()
+        _, _, segundos, _ = fake.peticiones_recibidas[1]
+
+        self.assertIn("X-Correlation-Id", primeros)
+        self.assertNotEqual(primeros["X-Correlation-Id"], segundos["X-Correlation-Id"])
+
+    def test_ultimo_correlation_id_coincide_con_el_mandado(self):
+        fake = FakeHttpTransport.que_responde(200, '{"canSendNow":true,"nextAllowedSendAt":null}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.estado_sistema()
+        _, _, headers, _ = fake.peticiones_recibidas[0]
+
+        self.assertEqual(headers["X-Correlation-Id"], client.ultimo_correlation_id())
+
+    def test_ultimo_cupo_restante_lee_el_encabezado(self):
+        fake = FakeHttpTransport.que_responde_con_encabezados(
+            202, '{"id":"A-0001","status":"queued"}', {"X-Nodda-Quota-Remaining": "7"}
+        )
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.crear_factura({"series": "A", "number": "0001"})
+
+        self.assertEqual(7, client.ultimo_cupo_restante())
+
+    def test_ultimo_cupo_restante_es_none_cuando_no_viene_el_encabezado(self):
+        fake = FakeHttpTransport.que_responde(202, '{"id":"A-0001","status":"queued"}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+
+        client.crear_factura({"series": "A", "number": "0001"})
+
+        self.assertIsNone(client.ultimo_cupo_restante())
+
+    def test_registrar_cuenta_manda_post_a_cuentas_sin_authorization(self):
+        fake = FakeHttpTransport.que_responde(201, '{"cuentaId":"c1","nifId":"n1","apiKey":"KEY_NUEVA","aviso":"guardala"}')
+
+        resultado = NoddaClient.registrar_cuenta(
+            "https://api.nodda.test", "a@b.com", "B12345674", "Empresa SL", None, fake
+        )
+
+        self.assertEqual("KEY_NUEVA", resultado["apiKey"])
+        metodo, url, headers, _ = fake.peticiones_recibidas[0]
+        self.assertEqual("POST", metodo)
+        self.assertEqual("https://api.nodda.test/v1/cuentas", url)
+        self.assertNotIn("Authorization", headers)
+
+
+
+    def test_configurar_webhook_manda_put_con_la_url(self):
+        fake = FakeHttpTransport.que_responde(200, '{"nif":"B1","url":"https://x.es/h","secreto":"abc"}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+        r = client.configurar_webhook("https://x.es/h", "B1")
+        self.assertEqual("abc", r["secreto"])
+        metodo, url, _, cuerpo = fake.peticiones_recibidas[0]
+        self.assertEqual("PUT", metodo)
+        self.assertEqual("https://api.nodda.test/v1/webhooks?nif=B1", url)
+        self.assertEqual({"url": "https://x.es/h"}, json.loads(cuerpo))
+
+    def test_quitar_webhook_manda_delete(self):
+        fake = FakeHttpTransport.que_responde(200, '{"nif":"B1","eliminado":true}')
+        client = NoddaClient("https://api.nodda.test", "API_KEY", fake)
+        client.quitar_webhook()
+        metodo, url, _, _ = fake.peticiones_recibidas[0]
+        self.assertEqual("DELETE", metodo)
+        self.assertEqual("https://api.nodda.test/v1/webhooks", url)
+
+    def test_verificar_firma_webhook(self):
+        cuerpo = '{"id":"2026-0001","status":"sent"}'
+        self.assertTrue(NoddaClient.verificar_firma_webhook(cuerpo, "17c2185e12eeb103aecf6c824b4719e2808bd202f743ad5c6109051803261fc8", "s3cr3t"))
+        self.assertTrue(NoddaClient.verificar_firma_webhook(cuerpo.encode(), "17c2185e12eeb103aecf6c824b4719e2808bd202f743ad5c6109051803261fc8".upper(), "s3cr3t"))
+        self.assertFalse(NoddaClient.verificar_firma_webhook(cuerpo + " ", "17c2185e12eeb103aecf6c824b4719e2808bd202f743ad5c6109051803261fc8", "s3cr3t"))
+        self.assertFalse(NoddaClient.verificar_firma_webhook(cuerpo, "17c2185e12eeb103aecf6c824b4719e2808bd202f743ad5c6109051803261fc8", "otro"))
+        self.assertFalse(NoddaClient.verificar_firma_webhook(cuerpo, None, "s3cr3t"))
+
+
+if __name__ == "__main__":
+    unittest.main()