certapi 0.5.0__tar.gz → 0.6.0__tar.gz

{certapi-0.5.0/src/certapi.egg-info → certapi-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: certapi
-Version: 0.5.0
+Version: 0.6.0
 Summary: Python Package for managing keys, request SSL certificates from ACME.
 Home-page: https://github.com/mesudip/certapi
 Author: Sudip Bhattarai
@@ -10,6 +10,17 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
+Requires-Dist: cryptography
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # CertApi
 

{certapi-0.5.0 → certapi-0.6.0}/pyproject.toml

@@ -9,7 +9,6 @@ testpaths = [
 ]
 env_files =[".env", ".test.env"]
 pythonpath = "src"
-timeout = 10
 
 [build-system]
 requires = ["setuptools>=42"]

{certapi-0.5.0 → certapi-0.6.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="certapi",
-    version="0.5.0",
+    version="0.6.0",
     packages=find_packages(where="src"),
     package_dir={"": "src"},
     install_requires=[

{certapi-0.5.0 → certapi-0.6.0}/src/certapi/acme/AcmeError.py

@@ -61,30 +61,36 @@ class AcmeHttpError(AcmeError, requests.HTTPError):
                             message = err_detail
                     else:
                         validation_record = validation_record[0]
-                        error["hostname"] = validation_record["hostname"]
+                        error["hostname"] = validation_record.get("hostname", "unknown")
                         error["dns"] = {
-                            "resolved": validation_record["addressesResolved"],
-                            "used": validation_record["addressUsed"],
+                            "resolved": validation_record.get("addressesResolved"),
+                            "used": validation_record.get("addressUsed"),
                         }
                         if err_type == "urn:ietf:params:acme:error:connection":
                             if "Timeout during connect" in err_detail:
                                 error["connect"] = {"error": "Timeout"}
+                                address_used = validation_record.get("addressUsed", "unknown")
+                                port = str(validation_record.get("port", "unknown"))
+                                hostname = error.get("hostname", "unknown")
                                 message = (
-                                    error["hostname"]
+                                    str(hostname)
                                     + "["
-                                    + validation_record["addressUsed"]
+                                    + address_used
                                     + ":"
-                                    + validation_record["port"]
+                                    + port
                                     + "] Connect Timeout (Maybe firewall reasons)"
                                 )
                             elif err_detail.endswith("Connection refused"):
                                 error["connect"] = {"error": "connection refused"}
+                                address_used = validation_record.get("addressUsed", "unknown")
+                                port = str(validation_record.get("port", "unknown"))
+                                hostname = error.get("hostname", "unknown")
                                 message = (
-                                    error["hostname"]
+                                    str(hostname)
                                     + "["
-                                    + validation_record["addressUsed"]
+                                    + address_used
                                     + ":"
-                                    + validation_record["port"]
+                                    + port
                                     + "] Connection Refused (Is http server running?)"
                                 )
                             elif err_detail:
@@ -98,11 +104,13 @@ class AcmeHttpError(AcmeError, requests.HTTPError):
 
                             if match:
                                 error["response"] = (match.group(1) if match is not None else err_detail,)
-                                error["status_code"] = (error["status"],)
+                                error["status_code"] = (error.get("status"),)
+                                hostname = error.get("hostname", "unknown")
+                                status = error.get("status", "unknown")
                                 message = (
-                                    error["hostname"]
+                                    str(hostname)
                                     + " Status="
-                                    + error["status"]
+                                    + str(status)
                                     + ": Invalid response in challenge url"
                                 )
                             else:
@@ -131,7 +139,8 @@ class AcmeInvaliOrderError(AcmeHttpError):
         super().__init__(response, step)
 
 
-class AcmeInvaliNonceError(AcmeHttpError):
+class AcmeInvalidNonceError(AcmeHttpError):
     def __init__(self, response: requests.Response, step: str):
         super().__init__(response, step)
         self.can_retry = True
+        self.response=0

{certapi-0.5.0 → certapi-0.6.0}/src/certapi/acme/http.py

@@ -34,7 +34,7 @@ def request(method, step: str, url: str, json=None, headers=None, throw=True) ->
         if json_data and json_data.get("type"):
             errorType = json_data["type"]
             if errorType == "urn:ietf:params:acme:error:badNonce":
-                raise AcmeInvaliNonceError(res, step=step)
+                raise AcmeInvalidNonceError(res, step=step)
 
         if throw:
             raise AcmeHttpError(res, step=step)

{certapi-0.5.0 → certapi-0.6.0}/src/certapi/errors.py

@@ -12,6 +12,7 @@ class CertApiException(Exception):
         self.detail = detail if detail is not None else {}
         self.step = step
         self.can_retry = False
+        self.retry_delay = 4  # Default retry delay in seconds
 
     def json_obj(self) -> dict:
         return {"name": self.__class__.__name__, "message": self.message, "step": self.step, "detail": self.detail}

{certapi-0.5.0 → certapi-0.6.0}/src/certapi/http/HttpClientBase.py

@@ -24,7 +24,7 @@ class HttpClientBase(object):
         try:
             res = self.session.request(method, url, json=json_data, data=data, params=params, timeout=timeout)
         except requests.exceptions.ConnectionError as e:
-            print("Request [" + str(res.status_code) + "] : " + method + " " + url + " step=" + str(step))
+            print("Request [Connection Error] : " + method + " " + url + " step=" + str(step))
             raise NetworkError(
                 request=e.request,
                 message=f"Network connection error: {e}",
@@ -32,7 +32,7 @@ class HttpClientBase(object):
                 step=f"HTTP Request ({method} {url})" if step is None else step,
             ) from e
         except requests.exceptions.Timeout as e:
-            print("Request [" + str(res.status_code) + "] : " + method + " " + url + " step=" + str(step))
+            print("Request [Timeout] : " + method + " " + url + " step=" + str(step))
             raise NetworkError(
                 request=e.request,
                 message=f"Request timed out: {e}",
@@ -40,7 +40,7 @@ class HttpClientBase(object):
                 step=f"HTTP Request ({method} {url})" if step is None else step,
             ) from e
         except requests.exceptions.RequestException as e:
-            print("Request [" + str(res.status_code) + "] : " + method + " " + url + " step=" + str(step))
+            print("Request [Request Exception] : " + method + " " + url + " step=" + str(step))
             raise NetworkError(
                 request=e.request,
                 message=f"An unexpected network error occurred: {e}",
@@ -80,8 +80,9 @@ class HttpClientBase(object):
                 return self._req(method, url, step, json_data, data, params, timeout)
             except CertApiException as e:
                 if e.can_retry and i < retries:
-                    print(f"Retrying {method} {url} in {delay} seconds due to retryable error: {e.message}")
-                    time.sleep(delay)
+                    retry_delay = e.retry_delay if hasattr(e, 'retry_delay') else delay
+                    print(f"Retrying {method} {url} in {retry_delay} seconds due to retryable error: {e.message}")
+                    time.sleep(retry_delay)
                 else:
                     e.can_retry = False
                     raise

{certapi-0.5.0 → certapi-0.6.0}/src/certapi/manager/acme_cert_manager.py

@@ -1,5 +1,6 @@
 import time
 from typing import List, Literal, Optional, Tuple, Union, Dict
+from datetime import datetime, timezone, timedelta
 
 from certapi import crypto
 from ..acme import Challenge
@@ -76,8 +77,11 @@ class AcmeCertManager:
             result = self.key_store.find_key_and_cert_by_domain(h)
             if result is not None:
                 # result is (domain_id, key, cert_list)
-                existing[h] = result  # Store the certificate list
-
+                cert=result[2][0]
+                invalid_date = cert.not_valid_after_utc
+                # Check if the certificate is still valid for at least 30 days
+                if invalid_date > datetime.now(timezone.utc) + timedelta(days=6):
+                    existing[h] = result
         missing = [h for h in hosts if h not in existing]
         if len(missing) > 0:
             issued_certs_list = []

{certapi-0.5.0 → certapi-0.6.0/src/certapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: certapi
-Version: 0.5.0
+Version: 0.6.0
 Summary: Python Package for managing keys, request SSL certificates from ACME.
 Home-page: https://github.com/mesudip/certapi
 Author: Sudip Bhattarai
@@ -10,6 +10,17 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
+Requires-Dist: cryptography
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # CertApi
 

{certapi-0.5.0 → certapi-0.6.0}/src/certapi.egg-info/SOURCES.txt

@@ -51,4 +51,8 @@ src/certapi/manager/acme_cert_manager.py
 src/certapi/server/__init__.py
 src/certapi/server/api.py
 src/certapi/server/cert_api.py
-src/certapi/server/key_api.py
+src/certapi/server/key_api.py
+tests/test_cert_issuer_generic.py
+tests/test_certs_with_key_types.py
+tests/test_http_error_handling.py
+tests/test_keystores.py

certapi-0.6.0/tests/test_cert_issuer_generic.py

@@ -0,0 +1,202 @@
+import pytest
+from datetime import UTC, datetime, timedelta, timezone
+from cryptography import x509
+from cryptography.x509.oid import NameOID, ExtensionOID
+from certapi import Key, SelfCertIssuer, Certificate, CertificateSigningRequest, CertificateSigningRequestBuilder
+from certapi.issuers.abstract_certissuer import CertIssuer
+
+
+@pytest.fixture(scope="module")
+def self_cert_issuer_instance():
+    """Fixture to provide a SelfCertIssuer instance for testing."""
+    ca_key = Key.generate("rsa")
+    issuer = SelfCertIssuer(
+        ca_key,
+        country="US",
+        state="California",
+        locality="Los Angeles",
+        organization="TestOrg",
+        common_name="testca.local",
+    )
+    return issuer
+
+
+@pytest.mark.parametrize("key_type", ["rsa", "ecdsa", "ed25519"])
+def test_generate_key_and_cert(self_cert_issuer_instance: SelfCertIssuer, key_type: str):
+    """
+    Test the generate_key_and_cert method of CertIssuer using SelfCertIssuer.
+    """
+    domain = "example.com"
+    alt_names = ["www.example.com", "mail.example.com"]
+    expiry_days = 30
+
+    new_key, cert = self_cert_issuer_instance.generate_key_and_cert(
+        domain=domain,
+        alt_names=alt_names,
+        key_type=key_type,
+        expiry_days=expiry_days,
+    )
+
+    assert isinstance(new_key, Key)
+    assert isinstance(cert, x509.Certificate)
+
+    # Verify subject and issuer
+    assert cert.subject.get_attributes_for_oid(NameOID.COMMON_NAME)[0].value == domain
+    assert cert.issuer == self_cert_issuer_instance.issuer
+
+    # Verify SAN extension
+    san_extension = cert.extensions.get_extension_for_oid(ExtensionOID.SUBJECT_ALTERNATIVE_NAME)
+    san_values = san_extension.value.get_values_for_type(x509.DNSName)
+    expected_sans = [domain] + alt_names
+    # The domain is now always included in SAN by create_csr, so ensure it's unique and first
+    unique_expected_sans = []
+    seen = set()
+    for name in expected_sans:
+        if name not in seen:
+            seen.add(name)
+            unique_expected_sans.append(name)
+    assert set(san_values) == set(unique_expected_sans)
+
+    # Verify expiry
+    now_utc = datetime.now(UTC)
+    # Ensure certificate validity dates are timezone-aware UTC for comparison
+    cert_not_valid_before_utc = cert.not_valid_before_utc.astimezone(timezone.utc)
+    cert_not_valid_after_utc = cert.not_valid_after_utc.astimezone(timezone.utc)
+
+    assert cert_not_valid_before_utc <= now_utc
+    assert cert_not_valid_after_utc >= now_utc + timedelta(days=expiry_days - 1)  # Allow for slight time difference
+
+
+@pytest.mark.parametrize("key_type", ["rsa", "ecdsa", "ed25519"])
+def test_generate_key_and_cert_no_alt_names(self_cert_issuer_instance: SelfCertIssuer, key_type: str):
+    """
+    Test generate_key_and_cert with no alt_names provided.
+    """
+    domain = "no-alt-names.example.com"
+    new_key, cert = self_cert_issuer_instance.generate_key_and_cert(
+        domain=domain,
+        alt_names=[],
+        key_type=key_type,
+    )
+    assert isinstance(new_key, Key)
+    assert isinstance(cert, x509.Certificate)
+    assert cert.subject.get_attributes_for_oid(NameOID.COMMON_NAME)[0].value == domain
+    san_extension = cert.extensions.get_extension_for_oid(ExtensionOID.SUBJECT_ALTERNATIVE_NAME)
+    san_values = san_extension.value.get_values_for_type(x509.DNSName)
+    assert set(san_values) == {domain}
+
+
+@pytest.mark.parametrize("key_type", ["rsa", "ecdsa", "ed25519"])
+def test_generate_key_and_cert_with_custom_fields(self_cert_issuer_instance: SelfCertIssuer, key_type: str):
+    """
+    Test generate_key_and_cert with custom country, state, locality, organization, and user_id.
+    """
+    domain = "custom.example.com"
+    country = "CA"
+    state = "Ontario"
+    locality = "Toronto"
+    organization = "CustomOrg"
+    user_id = "custom_user_id"
+
+    new_key, cert = self_cert_issuer_instance.generate_key_and_cert(
+        domain=domain,
+        key_type=key_type,
+        country=country,
+        state=state,
+        locality=locality,
+        organization=organization,
+        user_id=user_id,
+    )
+
+    assert isinstance(new_key, Key)
+    assert isinstance(cert, x509.Certificate)
+    assert cert.subject.get_attributes_for_oid(NameOID.COMMON_NAME)[0].value == domain
+    assert cert.subject.get_attributes_for_oid(NameOID.COUNTRY_NAME)[0].value == country
+    assert cert.subject.get_attributes_for_oid(NameOID.STATE_OR_PROVINCE_NAME)[0].value == state
+    assert cert.subject.get_attributes_for_oid(NameOID.LOCALITY_NAME)[0].value == locality
+    assert cert.subject.get_attributes_for_oid(NameOID.ORGANIZATION_NAME)[0].value == organization
+    assert cert.subject.get_attributes_for_oid(NameOID.USER_ID)[0].value == user_id
+
+
+@pytest.mark.parametrize("key_type", ["rsa", "ecdsa", "ed25519"])
+def test_generate_key_and_cert_for_domain(self_cert_issuer_instance: SelfCertIssuer, key_type: str):
+    """
+    Test the generate_key_and_cert_for_domain method.
+    """
+    domain = "single.example.com"
+    new_key, cert = self_cert_issuer_instance.generate_key_and_cert_for_domain(
+        host=domain,
+        key_type=key_type,
+    )
+
+    assert isinstance(new_key, Key)
+    assert isinstance(cert, x509.Certificate)
+    assert cert.subject.get_attributes_for_oid(NameOID.COMMON_NAME)[0].value == domain
+    san_extension = cert.extensions.get_extension_for_oid(ExtensionOID.SUBJECT_ALTERNATIVE_NAME)
+    san_values = san_extension.value.get_values_for_type(x509.DNSName)
+    assert set(san_values) == {domain}  # Now domain should always be in SAN
+
+
+@pytest.mark.parametrize("key_type", ["rsa", "ecdsa", "ed25519"])
+def test_generate_key_and_cert_for_domains(self_cert_issuer_instance: SelfCertIssuer, key_type: str):
+    """
+    Test the generate_key_and_cert_for_domains method.
+    """
+    hosts = ["multi.example.com", "sub.multi.example.com"]
+    new_key, cert = self_cert_issuer_instance.generate_key_and_cert_for_domains(
+        hosts=hosts,
+        key_type=key_type,
+    )
+
+    assert isinstance(new_key, Key)
+    assert isinstance(cert, x509.Certificate)
+    assert cert.subject.get_attributes_for_oid(NameOID.COMMON_NAME)[0].value == hosts[0]
+    san_extension = cert.extensions.get_extension_for_oid(ExtensionOID.SUBJECT_ALTERNATIVE_NAME)
+    san_values = san_extension.value.get_values_for_type(x509.DNSName)
+    assert set(san_values) == set(hosts)
+
+
+def test_generate_key_and_cert_for_domains_empty_hosts(self_cert_issuer_instance: SelfCertIssuer):
+    """
+    Test generate_key_and_cert_for_domains with an empty hosts list.
+    """
+    with pytest.raises(ValueError, match="empty hosts array provided"):
+        self_cert_issuer_instance.generate_key_and_cert_for_domains(hosts=[])
+
+
+def test_generate_key_and_cert_unsupported_key_type(self_cert_issuer_instance: SelfCertIssuer):
+    """
+    Test generate_key_and_cert with an unsupported key type.
+    """
+    with pytest.raises(ValueError, match="Unsupported key type. Use 'rsa' or 'ecdsa'"):
+        self_cert_issuer_instance.generate_key_and_cert(
+            domain="invalid.example.com",
+            key_type="unsupported",  # type: ignore
+        )
+
+
+def test_get_csr_hostnames():
+    """
+    Test the static method get_csr_hostnames.
+    """
+    # Case 1: CSR with CN and SAN
+    key = Key.generate("rsa")
+    csr = key.create_csr(domain="cn.test.com", alt_names=["san1.test.com", "san2.test.com"])
+    hostnames = CertIssuer.get_csr_hostnames(csr)
+    assert set(hostnames) == {"cn.test.com", "san1.test.com", "san2.test.com"}
+    assert hostnames[0] == "cn.test.com"  # CN should be first if not already in SAN
+
+    # Case 2: CSR with only CN (and it will be added to SAN by create_csr)
+    key_cn_only = Key.generate("ecdsa")
+    csr_cn_only = key_cn_only.create_csr(domain="onlycn.test.com")
+    hostnames_cn_only = CertIssuer.get_csr_hostnames(csr_cn_only)
+    assert hostnames_cn_only == ["onlycn.test.com"]
+
+    # Case 3: CN is also in SAN (handled by unique_alt_names logic in create_csr)
+    key_cn_in_san = Key.generate("ecdsa")
+    csr_cn_in_san = key_cn_in_san.create_csr(
+        domain="duplicate.test.com", alt_names=["duplicate.test.com", "another.test.com"]
+    )
+    hostnames_cn_in_san = CertIssuer.get_csr_hostnames(csr_cn_in_san)
+    assert set(hostnames_cn_in_san) == {"duplicate.test.com", "another.test.com"}
+    assert hostnames_cn_in_san[0] == "duplicate.test.com"  # CN should still be first and unique

certapi-0.6.0/tests/test_certs_with_key_types.py

@@ -0,0 +1,41 @@
+import pytest
+from datetime import datetime
+from cryptography import x509
+from certapi import Key, SelfCertIssuer
+
+
+@pytest.mark.parametrize("ca_key_type", ["rsa", "ecdsa", "ed25519"])
+@pytest.mark.parametrize("csr_key_type", ["rsa", "ecdsa", "ed25519"])
+def test_ca_and_leaf_cert_all_key_pairs(ca_key_type, csr_key_type):
+    # Generate CA key and CA instance
+    ca_key = Key.generate(ca_key_type)
+    ca: SelfCertIssuer = SelfCertIssuer(
+        ca_key,
+        country="US",
+        state="California",
+        locality="Los Angeles",
+        organization="TestOrg",
+        common_name="testca.local",
+    )
+    ca_cert = ca.get_ca_cert()
+
+    # Generate leaf/CSR key
+    leaf_key = Key.generate(csr_key_type)
+    csr = leaf_key.create_csr("example.com")
+
+    # Sign CSR with CA key
+    leaf_cert = ca.sign_csr(csr, expiry_days=30)
+
+    # Assertions
+    assert isinstance(ca_cert, x509.Certificate)
+    assert ca_cert.subject == ca_cert.issuer  # Self-signed
+    assert isinstance(ca_cert.not_valid_before_utc, datetime)
+    assert isinstance(ca_cert.not_valid_after_utc, datetime)
+    assert ca_cert.issuer.get_attributes_for_oid(x509.oid.NameOID.COMMON_NAME)[0].value == "testca.local"
+
+    assert isinstance(leaf_cert, x509.Certificate)
+    assert leaf_cert.not_valid_after_utc > leaf_cert.not_valid_before_utc
+    assert leaf_cert.subject.get_attributes_for_oid(x509.oid.NameOID.COMMON_NAME)[0].value == "example.com"
+
+    # Check issuer consistency
+    assert leaf_cert.issuer == ca_cert.subject

certapi-0.6.0/tests/test_http_error_handling.py

@@ -0,0 +1,140 @@
+import pytest
+from unittest.mock import Mock, patch
+import requests
+from certapi.http.HttpClientBase import HttpClientBase
+from certapi.errors import NetworkError, CertApiException
+
+
+class TestHttpErrorHandling:
+    """Test suite for HTTP error handling in HttpClientBase"""
+
+    @pytest.fixture
+    def http_client(self):
+        """Create a basic HttpClientBase instance for testing"""
+        return HttpClientBase(
+            base_url="https://example.com",
+            headers={"Content-Type": "application/json"},
+            auto_retry=True
+        )
+
+    def test_connection_reset_error_handling(self, http_client):
+        """Test that ConnectionResetError is properly caught and converted to NetworkError"""
+        with patch.object(http_client.session, 'request') as mock_request:
+            # Simulate a ConnectionResetError wrapped in requests.exceptions.ConnectionError
+            connection_reset = ConnectionResetError(104, 'Connection reset by peer')
+            mock_request.side_effect = requests.exceptions.ConnectionError(
+                connection_reset
+            )
+            
+            with pytest.raises(NetworkError) as exc_info:
+                http_client._req("GET", "https://example.com/test", "Test Step")
+            
+            # Verify the NetworkError is properly created
+            error = exc_info.value
+            assert error.can_retry is True
+            assert "Network connection error" in error.message
+            assert error.detail["errorType"] == "ConnectionError"
+
+    def test_connection_error_is_retriable(self, http_client):
+        """Test that connection errors are marked as retriable"""
+        with patch.object(http_client.session, 'request') as mock_request:
+            mock_request.side_effect = requests.exceptions.ConnectionError("Connection failed")
+            
+            with pytest.raises(NetworkError) as exc_info:
+                http_client._req("GET", "https://example.com/test", "Test Step")
+            
+            error = exc_info.value
+            assert error.can_retry is True
+            assert hasattr(error, 'retry_delay')
+            assert error.retry_delay == 4  # Default retry delay
+
+    def test_timeout_error_is_retriable(self, http_client):
+        """Test that timeout errors are marked as retriable"""
+        with patch.object(http_client.session, 'request') as mock_request:
+            mock_request.side_effect = requests.exceptions.Timeout("Request timed out")
+            
+            with pytest.raises(NetworkError) as exc_info:
+                http_client._req("GET", "https://example.com/test", "Test Step")
+            
+            error = exc_info.value
+            assert error.can_retry is True
+            assert hasattr(error, 'retry_delay')
+
+    def test_retry_uses_exception_delay(self, http_client):
+        """Test that retry mechanism uses the delay from the exception"""
+        call_count = 0
+        
+        def side_effect(*args, **kwargs):
+            nonlocal call_count
+            call_count += 1
+            if call_count < 3:  # Fail first 2 times
+                raise requests.exceptions.ConnectionError("Connection failed")
+            # Success on 3rd attempt
+            mock_response = Mock()
+            mock_response.status_code = 200
+            return mock_response
+        
+        with patch.object(http_client.session, 'request', side_effect=side_effect):
+            with patch('time.sleep') as mock_sleep:
+                result = http_client._req_with_retry(
+                    "GET", "https://example.com/test", "Test Step", retries=2
+                )
+                
+                assert result.status_code == 200
+                # Should have slept twice (after 1st and 2nd failures)
+                assert mock_sleep.call_count == 2
+                # Should use default delay of 4 seconds
+                mock_sleep.assert_called_with(4)
+
+    def test_retry_exhausted_marks_non_retriable(self, http_client):
+        """Test that after exhausting retries, error is marked as non-retriable"""
+        with patch.object(http_client.session, 'request') as mock_request:
+            mock_request.side_effect = requests.exceptions.ConnectionError("Connection failed")
+            
+            with pytest.raises(NetworkError) as exc_info:
+                http_client._req_with_retry(
+                    "GET", "https://example.com/test", "Test Step", retries=1
+                )
+            
+            error = exc_info.value
+            # After retries are exhausted, can_retry should be False
+            assert error.can_retry is False
+
+    def test_no_retry_when_auto_retry_false(self, http_client):
+        """Test that retry doesn't happen when auto_retry is False"""
+        http_client.auto_retry = False
+        call_count = 0
+        
+        def side_effect(*args, **kwargs):
+            nonlocal call_count
+            call_count += 1
+            raise requests.exceptions.ConnectionError("Connection failed")
+        
+        with patch.object(http_client.session, 'request', side_effect=side_effect):
+            with pytest.raises(NetworkError):
+                http_client._req_with_retry(
+                    "GET", "https://example.com/test", "Test Step", retries=2
+                )
+            
+            # Should only be called once (no retries)
+            assert call_count == 1
+
+    def test_successful_request_no_error(self, http_client):
+        """Test that successful requests don't raise errors"""
+        with patch.object(http_client.session, 'request') as mock_request:
+            mock_response = Mock()
+            mock_response.status_code = 200
+            mock_request.return_value = mock_response
+            
+            result = http_client._req("GET", "https://example.com/test", "Test Step")
+            
+            assert result.status_code == 200
+
+    def test_custom_retry_delay(self):
+        """Test that custom retry delay can be set on exception"""
+        exception = CertApiException("Test error")
+        exception.retry_delay = 10
+        exception.can_retry = True
+        
+        assert exception.retry_delay == 10
+        assert exception.can_retry is True

certapi-0.6.0/tests/test_keystores.py

@@ -0,0 +1,181 @@
+from time import timezone
+import pytest
+import os
+import psycopg2  # Added for PostgreSQL database creation
+from psycopg2.extensions import ISOLATION_LEVEL_AUTOCOMMIT  # Added for PostgreSQL database creation
+
+from certapi import Key, Certificate
+from certapi.crypto.crypto import cert_to_pem, certs_to_pem
+from certapi.keystore import SqliteKeyStore, FileSystemKeyStore, PostgresKeyStore
+from typing import List, Tuple, Union
+from datetime import UTC, datetime, timedelta
+from certapi import KeyStore, Certificate, Key
+
+from cryptography import x509
+from cryptography.hazmat.primitives import hashes
+from datetime import datetime, timedelta
+
+
+@pytest.fixture(scope="session")
+def ca_key():
+    return Key.generate("ecdsa")
+
+
+@pytest.fixture(params=["sqlite", "filesystem", "postgresql"])
+def keystore(request, tmp_path):
+    if request.param == "sqlite":
+        db_path = tmp_path / "test.db"
+        store = SqliteKeyStore(db_path=str(db_path))
+        yield store
+        # Clean up after test
+        if os.path.exists(db_path):
+            os.remove(db_path)
+    elif request.param == "filesystem":
+        base_dir = tmp_path / "keystore_fs"
+        store = FileSystemKeyStore(base_dir=str(base_dir))
+        yield store
+        # Clean up after test
+        import shutil
+
+        if os.path.exists(base_dir):
+            shutil.rmtree(base_dir)
+    elif request.param == "postgresql":
+        db_url = "postgresql://localhost/test_db"
+        try:
+            conn_no_db = psycopg2.connect("postgresql://localhost/postgres")
+            conn_no_db.set_isolation_level(ISOLATION_LEVEL_AUTOCOMMIT)
+            cur_no_db = conn_no_db.cursor()
+            cur_no_db.execute("SELECT 1 FROM pg_database WHERE datname = 'test_db'")
+            exists = cur_no_db.fetchone()
+            if not exists:
+                cur_no_db.execute("CREATE DATABASE test_db")
+            cur_no_db.close()
+            conn_no_db.close()
+        except psycopg2.OperationalError as e:
+            pytest.skip(f"Could not connect to PostgreSQL to create test_db: {e}")
+
+        store = PostgresKeyStore(db_url=db_url)
+        yield store
+        # Clean up after test: drop tables
+        with store.get_connection() as conn:
+            cur = conn.cursor()
+            cur.execute("DROP TABLE IF EXISTS ssl_wildcards;")
+            cur.execute("DROP TABLE IF EXISTS ssl_domains;")
+            cur.execute("DROP TABLE IF EXISTS certificates;")
+            cur.execute("DROP TABLE IF EXISTS private_keys;")
+            conn.commit()
+            cur.close()
+
+
+def test_save_and_find_key(keystore: KeyStore):
+    key = Key.generate("rsa")
+    key_id = keystore.save_key(key, "test_key")
+    assert key_id is not None
+
+    found_key = keystore.find_key_by_name("test_key")
+    assert found_key is not None
+    assert found_key.to_pem() == key.to_pem()
+
+
+def test_save_and_find_cert(keystore: KeyStore, ca_key: Key):
+    key = Key.generate("rsa")
+    key_id = keystore.save_key(key, "cert_key")
+
+    csr = key.create_csr(domain="example.com", alt_names=["example.com"])
+
+    cert = sign_csr(csr, ca_key, 7)
+
+    cert_id = keystore.save_cert(key_id, cert, ["example.com"], "test_cert")
+    assert cert_id is not None
+
+    found_cert_tuple = keystore.find_key_and_cert_by_domain("example.com")
+    assert found_cert_tuple is not None
+    found_id, found_key, found_certs = found_cert_tuple
+    if not isinstance(keystore, FileSystemKeyStore):
+        assert found_id == cert_id
+    assert found_key.to_pem() == key.to_pem()
+    assert len(found_certs) == 1
+    assert cert_to_pem(found_certs[0]) == cert_to_pem(cert)
+
+
+def test_get_non_existent_key(keystore: KeyStore):
+    found_key = keystore.find_key_by_name("non_existent_key")
+    assert found_key is None
+
+
+def test_get_non_existent_cert(keystore: KeyStore):
+    found_cert = keystore.find_key_and_cert_by_domain("nonexistent.com")
+    assert found_cert is None
+
+
+def test_save_key_with_int_id(keystore: KeyStore):
+    key = Key.generate("ecdsa")
+    key_id = keystore.save_key(key, 123)
+    assert key_id == 123 or key_id == "123"
+
+    found_key = keystore.find_key_by_id(123)
+    assert found_key is not None
+    assert found_key.to_pem() == key.to_pem()
+
+
+def test_save_cert_with_list_of_certs(keystore, ca_key: Key):
+    key = Key.generate("rsa")
+    key_id = keystore.save_key(key, "cert_list_key")
+
+    csr1 = key.create_csr(domain="cert1.example.com", alt_names=["cert1.example.com"])
+    cert1 = sign_csr(csr1, ca_key, 1)
+
+    csr2 = key.create_csr(domain="cert2.example.com", alt_names=["cert2.example.com"])
+    cert2 = sign_csr(csr2, ca_key, 1)
+
+    certs_list = [cert1, cert2]
+    cert_id = keystore.save_cert(key_id, certs_list, ["cert1.example.com", "cert2.example.com"], "test_certs_list")
+    assert cert_id is not None
+
+    found_cert_tuple = keystore.find_key_and_cert_by_domain("cert1.example.com")
+    assert found_cert_tuple is not None
+    found_id, found_key, found_certs = found_cert_tuple
+    if not isinstance(keystore, FileSystemKeyStore):
+        assert found_id == cert_id
+    assert found_key.to_pem() == key.to_pem()
+    assert len(found_certs) == 2
+    assert cert_to_pem(found_certs[0]) == cert_to_pem(cert1)
+    assert cert_to_pem(found_certs[1]) == cert_to_pem(cert2)
+
+
+def test_get_cert_by_id(keystore: KeyStore, ca_key: Key):
+    key = Key.generate("rsa")
+    domain = "example.com"
+
+    key_id = keystore.save_key(key, domain)
+
+    csr = key.create_csr(domain=domain, alt_names=[domain])
+    cert = sign_csr(csr, ca_key, 1)
+
+    cert_id = keystore.save_cert(key_id, cert, [domain], domain)
+    assert cert_id is not None
+
+    found_cert_tuple = keystore.find_key_and_cert_by_cert_id(cert_id)
+    assert found_cert_tuple is not None
+    found_key, found_certs = found_cert_tuple
+    assert found_key.to_pem() == key.to_pem()
+    assert len(found_certs) == 1
+    assert cert_to_pem(found_certs[0]) == cert_to_pem(cert)
+
+
+def sign_csr(csr: x509.CertificateSigningRequest, issuer_key: Key, days_valid=365) -> Certificate:
+    now = datetime.now(UTC)
+    builder = (
+        x509.CertificateBuilder()
+        .subject_name(csr.subject)
+        .issuer_name(x509.Name([x509.NameAttribute(x509.NameOID.COMMON_NAME, "certapi.pytest.com")]))
+        .public_key(csr.public_key())
+        .serial_number(x509.random_serial_number())
+        .not_valid_before(now)
+        .not_valid_after(now+ timedelta(days=days_valid))
+    )
+
+    # Optionally copy extensions from CSR
+    for ext in csr.extensions:
+        builder = builder.add_extension(ext.value, ext.critical)
+    return issuer_key.sign_csr(builder)