pyrelukko 0.1.0__tar.gz → 0.2.0__tar.gz

pyrelukko-0.2.0/.pylintrc.toml

@@ -0,0 +1,9 @@
+[tool.pylint.main]
+# Files or directories to be skipped. They should be base names, not paths.
+ignore = ["LICENSE", "pyproject.toml", "version.py",
+          "README.md", "demo.py", "conftest.py"]
+
+# Files or directories matching the regular expression patterns are skipped. The
+# regex matches against base names, not paths. The default value ignores Emacs
+# file locks
+ignore-patterns = ["^\\.#", "^test_"]

{pyrelukko-0.1.0 → pyrelukko-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyrelukko
-Version: 0.1.0
+Version: 0.2.0
 Summary: Relukko client.
 Author-email: Reto Zingg <g.d0b3rm4n@gmail.com>
 Requires-Python: >=3.12

{pyrelukko-0.1.0 → pyrelukko-0.2.0}/pyproject.toml

@@ -29,3 +29,11 @@ Issues = "https://gitlab.com/relukko/pyrelukko/-/issues"
 [build-system]
 requires = ["flit_core >=3.2,<4", "semantic-version >= 2.10"]
 build-backend = "flit_core.buildapi"
+
+[tool.pytest.ini_options]
+testpaths = [
+    "tests",
+]
+pythonpath = [
+    "src",
+]

{pyrelukko-0.1.0 → pyrelukko-0.2.0}/src/pyrelukko/pyrelukko.py

@@ -2,22 +2,20 @@
 TBD
 """
 import asyncio
+import json
 import logging
 import os
-import json
-import threading
 import ssl
+import threading
 import time
-
 from datetime import datetime
-from typing import Dict, List, Union
 from pathlib import Path
-from urllib3.util import Url, parse_url
-from urllib3.util.retry import Retry
+from typing import Dict, List, Union
 
 import requests
+from urllib3.util import Url, parse_url
+from urllib3.util.retry import Retry
 from websockets import ConnectionClosed as WsConnectionClosed
-
 from websockets.asyncio.client import connect as ws_connect
 
 from .retry import retry
@@ -30,6 +28,14 @@ SSL_KWARGS = [
     'options',
 ]
 
+RETRY_KWARGS = [
+    'tries',
+    'delay',
+    'backoff',
+    'max_delay',
+    'exceptions'
+]
+
 logger = logging.getLogger(__name__)
 
 
@@ -50,12 +56,21 @@ class RelukkoClient:
         """
         self.session = requests.Session()
         self.api_key = api_key
+        self.tries=4
+        self.delay=5
+        self.backoff=2.0
+        self.max_delay=None
+        self.exceptions = (
+            requests.ConnectionError,
+            RelukkoDoRetry,
+        )
         self._setup_session(api_key, **kwargs)
         self._setup_http_adapters_retry(**kwargs)
+        self._setup_pyrelukko_retry(**kwargs)
 
         self.base_url = self._setup_base_url(base_url)
         self.ws_url = self._setup_ws_url(str(self.base_url))
-        self.ssl_ctx = None
+        self.ssl_ctx: ssl.SSLContext = None
         self._setup_ssl_ctx(**kwargs)
 
         # event for websocket thread to signal it got a message
@@ -75,6 +90,15 @@ class RelukkoClient:
         self.base_url = self._setup_base_url(base_url or self.base_url)
         self.ws_url = self._setup_ws_url(str(self.base_url))
         self._setup_ssl_ctx(**kwargs)
+        self._setup_pyrelukko_retry(**kwargs)
+
+    def _setup_pyrelukko_retry(self, **kwargs):
+        for kwarg in RETRY_KWARGS:
+            setattr(
+                self,
+                kwarg,
+                kwargs.get(kwarg, getattr(self, kwarg))
+            )
 
     def _setup_http_adapters_retry(self, **kwargs):
         for _, http_adapter in self.session.adapters.items():
@@ -85,7 +109,7 @@ class RelukkoClient:
             http_adapter.max_retries = http_retry
 
     def _setup_session(self, api_key: str, **kwargs):
-        self.session.headers = {'X-api-Key': api_key}
+        self.session.headers['X-api-Key'] = api_key
         for key, value in kwargs.items():
             if hasattr(self.session, key):
                 setattr(self.session, key, value)
@@ -116,7 +140,7 @@ class RelukkoClient:
 
             # values from kwargs take precedence env vars
             ca_file = kwargs.get('cafile', ca_bundle_file)
-            ca_path = kwargs.get('capath', ca_bundle_path)
+            ca_path = kwargs.get('capath', f"{ca_bundle_path}/")
             ca_data = kwargs.get('cadata')
 
             if ca_file or ca_path or ca_data:
@@ -196,7 +220,7 @@ class RelukkoClient:
 
     def _check_response(self, response: requests.Response):
         match response.status_code:
-            case 200 | 201 | 404:
+            case 200 | 201 | 404 | 422:
                 return response.json()
             case 400 | 403:
                 err = response.json()
@@ -207,10 +231,12 @@ class RelukkoClient:
                 logger.info(err.get('status'), err.get('message'))
                 return None
             case 500 | 502 | 503 | 504:
-                logger.warning(response.status_code, response.text)
+                logger.warning("[%d](%s) %s",
+                    response.status_code, response.reason, response.text)
                 raise RelukkoDoRetry()
             case _:
-                logger.warning(response.status_code, response.text)
+                logger.warning("[%d](%s) %s",
+                    response.status_code, response.reason, response.text)
                 raise RuntimeError()
 
     def _make_request(
@@ -219,12 +245,10 @@ class RelukkoClient:
             method: str,
             payload: Dict=None) -> requests.Response:
 
-        excpetions = (
-            requests.ConnectionError,
-            RelukkoDoRetry,
-        )
 
-        @retry(logger, exceptions=excpetions, delay=10)
+        @retry(logger, exceptions=self.exceptions, tries=self.tries,
+               delay=self.delay, backoff=self.backoff,
+               max_delay=self.max_delay)
         def _do_request():
             response = self.session.request(
                 method=method,
@@ -274,13 +298,14 @@ class RelukkoClient:
         url = f"{self.base_url}/v1/locks/"
         return self._make_request(url, "GET")
 
-    def update_relukko(self, lock_id: str, creator: str, expires_at: datetime):
+    def update_relukko(
+            self, lock_id: str, creator: str=None, expires_at: datetime=None):
         """
         TBD
         """
         if isinstance(expires_at, datetime):
             expires_at = expires_at.isoformat()
-        else:
+        elif expires_at is not None:
             raise ValueError("has to be datetime!")
 
         payload = {
@@ -288,7 +313,7 @@ class RelukkoClient:
             "expires_at": expires_at,
         }
         url = f"{self.base_url}/v1/locks/{lock_id}"
-        return self._make_request(url, "POST", payload)
+        return self._make_request(url, "PUT", payload)
 
     def delete_relukko(self, lock_id: str):
         """

{pyrelukko-0.1.0 → pyrelukko-0.2.0}/src/pyrelukko/version.py

@@ -1,2 +1,2 @@
 # pylint: disable=all
-__version__ = "0.1.0"
+__version__ = "0.2.0"

pyrelukko-0.2.0/tests/cert/47615cfb.0

@@ -0,0 +1 @@
+rootCA.crt

pyrelukko-0.2.0/tests/cert/README.md

@@ -0,0 +1,8 @@
+# How To
+```
+openssl req -x509 -sha256 -days 7300 -noenc -newkey rsa:2048 -keyout rootCA.key -out rootCA.crt
+ln -s rootCA.crt "$(openssl x509 -hash -noout -in rootCA.crt)"
+openssl req -newkey rsa:2048 -noenc -keyout relukko.key -out relukko.csr
+openssl x509 -req -CA rootCA.crt -CAkey rootCA.key -in relukko.csr -out relukko.crt -days 7299 -CAcreateserial
+openssl x509 -inform PEM -in rootCA.crt  -outform DER -out rootCA.der
+```

pyrelukko-0.2.0/tests/cert/relukko.crt

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDeDCCAmCgAwIBAgIUIG2mO1IxfM3wqiLLFCO+6ubGdHswDQYJKoZIhvcNAQEL
+BQAwVDELMAkGA1UEBhMCWFgxFTATBgNVBAcMDERlZmF1bHQgQ2l0eTEcMBoGA1UE
+CgwTRGVmYXVsdCBDb21wYW55IEx0ZDEQMA4GA1UEAwwHUmVsdWtrbzAeFw0yNDEx
+MTMxNTQxNTdaFw00NDExMDcxNTQxNTdaMFQxCzAJBgNVBAYTAlhYMRUwEwYDVQQH
+DAxEZWZhdWx0IENpdHkxHDAaBgNVBAoME0RlZmF1bHQgQ29tcGFueSBMdGQxEDAO
+BgNVBAMMB3JlbHVra28wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCr
+89++zNQs+MG5opoCTWq/QxAJsr9Uul598XoQFXn1N/d/JOeSosy8BNvb1RXsr5sp
+sNJbJEun6OPFtUoVczUtivS99XNchWPjEQ18w22aiLcwl/uOrdfxWj04yEfKmejN
+ZXFrShhAWRGfc3fi2hD0Y5mtbS7T5iqaYzm4U5UDVFizVPnSgPFXMAiat/VQGvBF
+cv5IpBjXOJGkLZTzmFlW61T6m+MJGXF59CLC6vL6QJCqQpSUWG9UM00R8L2pQ1b8
+HLKYUuJ+vp4WVYwYyz769BNG4OG3IkdqIHKDFWBXFVmKaUkX9aAul4BOitKy4XFc
+8eu653lbkVnRHb01RaP7AgMBAAGjQjBAMB0GA1UdDgQWBBSEFybZBM4O7khSofZl
+0oAT+CSXEjAfBgNVHSMEGDAWgBRAo64Da82emF0q53wCdj4wbFTmMDANBgkqhkiG
+9w0BAQsFAAOCAQEAs+zaKt8VqLoVT0OT24Oxyzc+/A0h4BYq3kYD11BaUJ6oKqQu
+57FRKi0ZWxNSNCbzrwi6W+qNgIXtvSHWk4+BKxzqDVG6LCIuNn4bbvlQMGuTWctY
+ndArPxdKvN9AXeCvam+5XKcA5OJY/naoho7fSoGh2Zgkq9HS7DlKxfBW2GEY0mp8
+jeuxvBvh4xw/YuESVFbKedglaoNFf+aP44zL47Wn9QJcLqByGpTV472j238ObUFi
+k47o+v4Qt7nkJDOcx7ic//uLTcb/1rv1SppYpKr3YJ5fLspzMMPpTQbkt2H8hLiZ
++1jj5GIoDgLi+/uxBgYQs78jEOIKkWO6EjwGUw==
+-----END CERTIFICATE-----

pyrelukko-0.2.0/tests/cert/relukko.csr

@@ -0,0 +1,16 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIICmTCCAYECAQAwVDELMAkGA1UEBhMCWFgxFTATBgNVBAcMDERlZmF1bHQgQ2l0
+eTEcMBoGA1UECgwTRGVmYXVsdCBDb21wYW55IEx0ZDEQMA4GA1UEAwwHcmVsdWtr
+bzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKvz377M1Cz4wbmimgJN
+ar9DEAmyv1S6Xn3xehAVefU3938k55KizLwE29vVFeyvmymw0lskS6fo48W1ShVz
+NS2K9L31c1yFY+MRDXzDbZqItzCX+46t1/FaPTjIR8qZ6M1lcWtKGEBZEZ9zd+La
+EPRjma1tLtPmKppjObhTlQNUWLNU+dKA8VcwCJq39VAa8EVy/kikGNc4kaQtlPOY
+WVbrVPqb4wkZcXn0IsLq8vpAkKpClJRYb1QzTRHwvalDVvwcsphS4n6+nhZVjBjL
+Pvr0E0bg4bciR2ogcoMVYFcVWYppSRf1oC6XgE6K0rLhcVzx67rneVuRWdEdvTVF
+o/sCAwEAAaAAMA0GCSqGSIb3DQEBCwUAA4IBAQCHkmw8bBBI9pOrlCrJ2u3sGdlx
+3ZbW/+kGdsQ8Odb/pIHkLLKpu5yNLEey/U4EZyWSNewYDUKfS2FIyMN2c38QAex6
+1Y9qPK74RzUB68ki7XKtp+GAGqVb0axxRe0IuBwc9d5jl6zjltcpdutAIIgXcJgg
+8QPnfpz7Skhjjm/duTVp0rurWsPztQdDpkrcY3c49vuTLA5uKwfa//cPAOmVGwqq
+TMICj+0M2S+bgg9Ksph1IsDxxuIm1aa2EFnF5XRbJn9aOSdyfBkKoZz9ttgu1hP4
++hPe8S3ekUyJiZAglSI1qJOkpyw14EDIhwJvE9FG5eN/mU8wS1/GU+vhZWKN
+-----END CERTIFICATE REQUEST-----

pyrelukko-0.2.0/tests/cert/relukko.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQCr89++zNQs+MG5
+opoCTWq/QxAJsr9Uul598XoQFXn1N/d/JOeSosy8BNvb1RXsr5spsNJbJEun6OPF
+tUoVczUtivS99XNchWPjEQ18w22aiLcwl/uOrdfxWj04yEfKmejNZXFrShhAWRGf
+c3fi2hD0Y5mtbS7T5iqaYzm4U5UDVFizVPnSgPFXMAiat/VQGvBFcv5IpBjXOJGk
+LZTzmFlW61T6m+MJGXF59CLC6vL6QJCqQpSUWG9UM00R8L2pQ1b8HLKYUuJ+vp4W
+VYwYyz769BNG4OG3IkdqIHKDFWBXFVmKaUkX9aAul4BOitKy4XFc8eu653lbkVnR
+Hb01RaP7AgMBAAECggEAF22KShjmkwavf7HfnDmyYMMWhSO//XTJBA1/DSrylg5d
+NQsGVsxslZ9vLyP4sT9PJjPWbUmO2fPuo1TVy6y0jZ3K8Qi8rNnrEphpBzB/Qe38
++5dxfu6WUebIGZucFca42SdITTm9VSMYNhU0O98XLp0AEV4jYlvlPmoPhrAzSM50
+lEIuriNhqHuqZhXN0jPYI1jZDS5JVi2PlbgyO1125BBMsCMLfhW+wcme/Y/VAySc
+pNkvK3aHeWJUXEeVKuNfn5878PqeD6ZPjl9Hyq3lj6yOauIO/PCdIwm+2qjzrYsy
+IBhjFFEoMGofgz+KV7olZu9by38ZzhW7nZGGe+zbgQKBgQDmFyzzxz3/BF7FKTXL
+v6uVNkGpMGH8EQE1H+YJXTiSaqf/3ZrsXyBsbA6YBanKBXcY/F0PhQ7e/rjtqaGU
+OtekNTHSgosdbJgVX88EjfIa4/rbZPUsX6qRJBuDVOCcCZC1PyFBT2ehKYlIPHS0
+klbXo57pYzgDnzrYPr6UWbCZewKBgQC/UMGNvqJXszYZe3hjd9Ek9oSJMThfpfXn
+opNhCNHKZ8+xqry602TqIwyStYc7elB57R547ZR4kttT8iM1E7ZOoLRPP0r/FjOS
+scpCAk5ouVG9RZaUvTIbvzdEifEOt1Vf0RgIG3Y4DBqtotNoymqyT5wzuxyJQm1E
+683UVIbXgQKBgQCLPJ0UTI7kwtVCxIRsbum7WuDzLHcvHW84obwIEKSKXgaaHJWC
+0rIBSoauUkcEHLiMozMBkEiGg2iPUaaY197k3NfwhtT+kleaH6dcHzXSNgH5QCfp
+mV7ThCEuIW/mnRc3xyMtrYqNiWAtGYCaQTBSQA6LN2KPNo1ajOWxSnFG/wKBgQC2
+9rBksq/nV4ihjidwWSI3S1stKVlUgA9QW3a/EgQwol9K9pJPyeN019gqZljSVQOp
+10+RLwUS2r/O5H8vP47WW3KVZ1593emsnUNlJXd/R9wYOvjrfpTxXEmqzpEvFb4c
+SIfHGRxSNaE99b5hNVQc+23TO1rrGhAOHcVXDw92AQKBgQDCMEcIcwHx+ahVZbEb
+bAyWLwYxQFRStmYKbYBtEMFW39atRmc0wdAG0my/0cUyHUIfWbHvP5oTfyAthV9G
+8G0qBk5fPhh6hfNRFMb2j1AqnZ3CadoBZq2HelTTUqt4UgU9Y4iDco+4ew34Uw76
+2ki1bKXiJKkJYlk14AMrzckDUQ==
+-----END PRIVATE KEY-----

pyrelukko-0.2.0/tests/cert/rootCA.crt

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDiTCCAnGgAwIBAgIUeLTh5JgTZlG0dbwtCICijkg1MWwwDQYJKoZIhvcNAQEL
+BQAwVDELMAkGA1UEBhMCWFgxFTATBgNVBAcMDERlZmF1bHQgQ2l0eTEcMBoGA1UE
+CgwTRGVmYXVsdCBDb21wYW55IEx0ZDEQMA4GA1UEAwwHUmVsdWtrbzAeFw0yNDEx
+MTMxNTM3MDBaFw00NDExMDgxNTM3MDBaMFQxCzAJBgNVBAYTAlhYMRUwEwYDVQQH
+DAxEZWZhdWx0IENpdHkxHDAaBgNVBAoME0RlZmF1bHQgQ29tcGFueSBMdGQxEDAO
+BgNVBAMMB1JlbHVra28wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQD4
+PWQPjCCXOvZYUDpYhZHR4Nw0ErkZEZWtPMyoBnyGkYwqK1SrHCcIYQL8C22dN1rn
+VdFvCVH13fQHz1SJ/v3jkS+9IiOUDenXpZP/G0pprTbLGh33aaQU53EqvO1T2CAA
+zIAVdme0cihOB+KL2A5bDzP9fu+c0ddn+N++ZgcqBHMYmZKIGJv5QZ+i+/1xrGqQ
+/znwV7RuBGms8fxA3x4Y4ELUzIHMpbXbQn95qC9u7ee4odQ5KjR1M0oocPKOYBGa
+/Dqnhd3Wx0lHR3No8HgC4TBfxruhs+NZtRyInOTFr99TWbBx+zrDvxecM/5j/AnH
+WHka8xMQSxJUeoXtlFT/AgMBAAGjUzBRMB0GA1UdDgQWBBRAo64Da82emF0q53wC
+dj4wbFTmMDAfBgNVHSMEGDAWgBRAo64Da82emF0q53wCdj4wbFTmMDAPBgNVHRMB
+Af8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQACdVeJ/CnXpY4t568bQRxIr+t3
+IqeIqJVg1nt6OaB/EJPJil/lvJD8bjO5W5uXAnbkv26i0Q89KFZH3xKFHRmL/zR+
+0YPcbi3LmQ+NY6LtH1GtBlRiobROfSp8/GxTrGxqMGHHxBdY+v8lPiK1LHTE99ik
+cl8qF+DQMGeliPQcg9rLgXagymEc9oS3OgxjL7Al4/P8bLkdC/hxk+cEUFCXUX4v
+z/PAFnHwEeJPiiNYG+hpQQRloVncynEwhBr/pGGMdLGaFBje41kn9Ss2anc+YaiW
+DyoDLuQkCcRrUvc2dCGMZs0KaCv8i61QWGNy8suGq6nrXW9A57JhS7ak8xg9
+-----END CERTIFICATE-----

pyrelukko-0.2.0/tests/cert/rootCA.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQD4PWQPjCCXOvZY
+UDpYhZHR4Nw0ErkZEZWtPMyoBnyGkYwqK1SrHCcIYQL8C22dN1rnVdFvCVH13fQH
+z1SJ/v3jkS+9IiOUDenXpZP/G0pprTbLGh33aaQU53EqvO1T2CAAzIAVdme0cihO
+B+KL2A5bDzP9fu+c0ddn+N++ZgcqBHMYmZKIGJv5QZ+i+/1xrGqQ/znwV7RuBGms
+8fxA3x4Y4ELUzIHMpbXbQn95qC9u7ee4odQ5KjR1M0oocPKOYBGa/Dqnhd3Wx0lH
+R3No8HgC4TBfxruhs+NZtRyInOTFr99TWbBx+zrDvxecM/5j/AnHWHka8xMQSxJU
+eoXtlFT/AgMBAAECggEAeQhprIDsdP/dE4MOZ5G8XsHNa6BDWlsuCLivqi77cRsu
+5XKaBhGkYFv4eg5SZAiUzF0Vz5cSPJf6vwISHHRUsqtbxNIL2ciM3sVO6t+SAQNg
+x1cVDEgYJc8QaL+T0UD7nZgXzR8dgif0ydLjXL67hR9dAHhu+J2BcqKv6KPTU2LB
+KWbCcLkY4PdCGwSNuvyPokc3Fo8U40Lm8tcWQ6sFV/+bv6+ShWhsb5Dx7sfVoijf
+YikzFc7sEHb//nH2+C/FoCqneDPYl8lVH9zKYis4xWcA68bNwyfWpaQLXo32DKYq
+rZxnwnawtU5b+t+TVp1DcCjOM3vaodeKI3Gqq5SjBQKBgQD/Sy33WOK+qelkvJxb
+IcyP3U/ijNpWP3UidYGmmpTBP5UdaXyObX1G4nmfQjDad080jPpP/r350Tr0Xi2s
+6wZBw0HoTZrZw5MQQKRQyh0Hg5VHHoHbD97UuLGGZ+Yc/hSWWfuDQHeV5Ami+VXD
+TCYZGhtsjY9lUfUWYcsdcOA1fQKBgQD47TcVSC+3/8zKd2AAJeYrpx6wL/5X/4Zn
+U0VeBxfF6MjQlu3avnwi6MxjkuB4KJAgWVHvJspJaS8ilIJN5qBsivphtfD0RV+d
+UW9DCzoDUlU/AmNMD+stylgziSWoG9rzcY7P71izRE1tGGsgOXvZS5xUHzqWBwg6
+MtYB4EQNKwKBgQCTUBVpKmBE9xTXbUKoD5vT1Df5mZ+PrzRvOvEiawa1cHQiMbGP
+Gjz0/1CBBpfcKIaK42K5cFy9X++t/P5MTp4gqoRIgSd+yyz8buCiQc54fIRSMpdq
+CgFiLGU8Eo4lYrQMgkXw2e1nj9vDsC698B331CnI/PKm26EaVjn3dh/anQKBgGxB
+FWRu+TmmyBQA6EIIOVogmqr6pDz2xienQhKLOR57huGX0acAkhHIdiKTnIUE9vDq
+h0Re9TgJw1LhjO1976RkqFDYBArnJJbQ9HcOqdMJ+kKlsjNA9QD773GyIitCueyH
+JRluuH91o8pfBS+FcEPmqvy2fA8EzeIpe4JjWpTzAoGAQHoipuzDbhb02XMqioc+
+UCsa6erj3kGrBUiFcvNutTG+oVq3qXOebOc9bCZcGHwsm0fgX5zk1XgY+IRfCWJY
+X14DQfLMBi/vObDXH9BaoVvc50EPSBW0V5k2aXavJ6XelbBXSI33bzGb+5wAltI/
+CFKf5ePEAi3jE69yYnTwbdc=
+-----END PRIVATE KEY-----

pyrelukko-0.2.0/tests/cert/rootCA.srl

@@ -0,0 +1 @@
+206DA63B52317CCDF0AA22CB1423BEEAE6C6747B

pyrelukko-0.2.0/tests/conftest.py

@@ -0,0 +1,129 @@
+import socket
+import ssl
+import threading
+from pathlib import Path
+from typing import List
+
+import pytest
+from testcontainers.core.network import Network
+from testcontainers.core.waiting_utils import wait_container_is_ready
+from testcontainers.generic import ServerContainer
+from testcontainers.postgres import PostgresContainer
+
+from pyrelukko import RelukkoClient
+
+SCRIPT_DIR = Path(__file__).parent.absolute()
+INITDB_DIR = SCRIPT_DIR / "initdb.d"
+
+
+class RelukkoContainer(ServerContainer):
+    def __init__(self, net: Network,
+                 image="registry.gitlab.com/relukko/relukko:0.9.0", db_url=None):
+        self.db_url = db_url
+        self.net = net
+        super(RelukkoContainer, self).__init__(image=image, port=3000)
+
+    def _configure(self):
+        self.with_env("DATABASE_URL", self.db_url)
+        self.with_env("RELUKKO_API_KEY", "somekey")
+        self.with_env("RELUKKO_USER", "relukko")
+        self.with_env("RELUKKO_PASSWORD", "relukko")
+        self.with_env("RELUKKO_BIND_ADDR", "0.0.0.0")
+        self.with_network(self.net)
+
+    def get_api_url(self) -> str:
+        return f"http://localhost:{self.get_exposed_port(3000)}"
+
+    def _create_connection_url(self) -> str:
+        return f"{self.get_api_url()}/healthchecker"
+
+
+class RelukkoDbContainer(PostgresContainer):
+    def __init__(self, net: Network, image: str = "postgres:latest", port: int = 5432, username: str | None = None, password: str | None = None, dbname: str | None = None, driver: str | None = "psycopg2", **kwargs) -> None:
+        self.net = net
+        super().__init__(image, port, username, password, dbname, driver, **kwargs)
+
+    def _configure(self) -> None:
+        self.with_volume_mapping(INITDB_DIR, "/docker-entrypoint-initdb.d", "Z")
+        self.with_env("POSTGRES_USER", "relukko")
+        self.with_env("POSTGRES_PASSWORD", "relukko")
+        self.with_env("POSTGRES_DB", "relukko")
+        self.with_network(self.net)
+
+    @wait_container_is_ready()
+    def _connect(self) -> None:
+        packet = bytes([
+            0x00, 0x00, 0x00, 0x52, 0x00, 0x03, 0x00, 0x00, 
+            0x75, 0x73, 0x65, 0x72, 0x00, 0x72, 0x65, 0x6c, 
+            0x75, 0x6b, 0x6b, 0x6f, 0x00, 0x64, 0x61, 0x74, 
+            0x61, 0x62, 0x61, 0x73, 0x65, 0x00, 0x72, 0x65, 
+            0x6c, 0x75, 0x6b, 0x6b, 0x6f, 0x00, 0x61, 0x70, 
+            0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 
+            0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x00, 0x70, 
+            0x73, 0x71, 0x6c, 0x00, 0x63, 0x6c, 0x69, 0x65, 
+            0x6e, 0x74, 0x5f, 0x65, 0x6e, 0x63, 0x6f, 0x64, 
+            0x69, 0x6e, 0x67, 0x00, 0x55, 0x54, 0x46, 0x38, 
+            0x00, 0x00
+        ])
+        port = self.get_exposed_port(self.port)
+        with socket.create_connection(("localhost", port)) as sock:
+            sock.send(packet)
+            buf = sock.recv(40)
+            if len(buf) == 0 and "SCRAM-SHA" not in buf:
+                raise ConnectionError
+
+
+@pytest.fixture(scope="session")
+def relukko_backend():
+    with Network() as rl_net:
+        with RelukkoDbContainer(net=rl_net,
+            image="postgres:16", hostname="relukkodb") as _db:
+            db_url = "postgresql://relukko:relukko@relukkodb/relukko"
+            with RelukkoContainer(rl_net, db_url=db_url) as backend:
+                relukko = RelukkoClient(
+                    base_url=backend.get_api_url(), api_key="somekey")
+                yield relukko, backend
+
+@pytest.fixture(scope="function")
+def tls_listener():
+
+    certfile = SCRIPT_DIR / "cert" / "relukko.crt"
+    keyfile = SCRIPT_DIR / "cert" / "relukko.key"
+
+    def run_server(port_info: List, keep_running: threading.Event):
+        # Create a TCP socket
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0) as sock:
+            sock.bind(("127.0.0.1", 0))
+            sock.listen(5)  # Listen for incoming connections
+
+            _, assigned_port = sock.getsockname()
+            port_info.append(assigned_port)
+
+            # Wrap the socket with TLS
+            context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+            context.load_cert_chain(certfile=certfile, keyfile=keyfile)
+            with context.wrap_socket(sock, server_side=True) as ssock:
+
+                ssock.settimeout(1)
+
+                while keep_running.is_set():
+                    try:
+                        client_socket, _ = ssock.accept()
+                        client_socket.sendall(b"Hello, TLS Client!")
+                        client_socket.close()
+                    except Exception as _:
+                        continue
+
+    port_info = []
+    keep_running = threading.Event()
+    keep_running.set()
+    thread = threading.Thread(target=run_server, args=(port_info, keep_running))
+    thread.start()
+
+    while not port_info:
+        pass
+
+    yield thread, port_info[0]
+
+    keep_running.clear()
+    thread.join()

pyrelukko-0.2.0/tests/initdb.d/20240930160154_init.up.sql

@@ -0,0 +1,19 @@
+-- Add up migration script here
+CREATE EXTENSION moddatetime;
+
+CREATE TABLE locks (
+    id uuid DEFAULT gen_random_uuid(),
+    lock_name VARCHAR NOT NULL,
+    creator VARCHAR,
+    ip INET,
+    expires_at TIMESTAMPTZ NOT NULL DEFAULT NOW() + (10 ||' minutes')::interval ,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (id),
+    UNIQUE(lock_name)
+);
+
+CREATE TRIGGER locks_moddatetime
+    BEFORE UPDATE ON locks
+    FOR EACH ROW
+    EXECUTE PROCEDURE moddatetime (updated_at);

pyrelukko-0.2.0/tests/test_relukko.py

@@ -0,0 +1,470 @@
+import logging
+import time
+import ssl
+import socket
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict
+
+import pytest
+import requests
+from requests.adapters import HTTPAdapter
+from requests.cookies import cookiejar_from_dict
+from urllib3.util import parse_url
+
+from pyrelukko import RelukkoClient
+from pyrelukko.pyrelukko import RelukkoDoRetry
+from pyrelukko.retry import retry
+
+
+SCRIPT_DIR = Path(__file__).parent.absolute()
+
+logger = logging.getLogger(__name__)
+
+
+@retry(None, ConnectionRefusedError)
+def _check_tls(ssl_ctx: ssl.SSLContext, port):
+    with socket.create_connection(("127.0.0.1", port)) as sock:
+        with ssl_ctx.wrap_socket(sock, server_hostname="relukko") as ssock:
+            response = ssock.recv(20)
+            assert response == b"Hello, TLS Client!"
+
+
+def _check_has_serial_no(ssl_ctx: ssl.SSLContext):
+    serial_numbers = [x["serialNumber"] for x in ssl_ctx.get_ca_certs()]
+    assert "78B4E1E498136651B475BC2D0880A28E4835316C" in serial_numbers
+
+
+def test_init_relukko_client():
+    relukko = RelukkoClient(base_url="", api_key="")
+
+    assert isinstance(relukko, RelukkoClient)
+    assert relukko.session.trust_env == True
+    assert relukko.session.cookies._cookies == {}
+    assert relukko.ssl_ctx is None
+    http_adapter: HTTPAdapter = relukko.session.adapters.get("http://")
+    assert http_adapter.max_retries.total == 0
+    assert http_adapter.max_retries.connect is None
+    assert http_adapter.max_retries.read == False
+    assert http_adapter.max_retries.redirect is None
+    assert http_adapter.max_retries.status is None
+    assert http_adapter.max_retries.other is None
+    assert http_adapter.max_retries.backoff_factor == 0
+    assert http_adapter.max_retries.backoff_max == 120
+    assert http_adapter.max_retries.backoff_jitter == 0.0
+    assert http_adapter.max_retries.raise_on_redirect == True
+    assert http_adapter.max_retries.raise_on_status == True
+    assert relukko.tries == 4
+    assert relukko.delay == 5
+    assert relukko.backoff == 2.0
+    assert relukko.max_delay is None
+    assert relukko.exceptions == (requests.ConnectionError, RelukkoDoRetry)
+
+    with pytest.raises(ValueError):
+        RelukkoClient(base_url=1000, api_key="")
+
+def test_init_relukko_client_with_env_var(tls_listener):
+    _, port = tls_listener
+
+    capath = SCRIPT_DIR / "cert"
+    cafile = capath / "rootCA.crt"
+
+    pytest.MonkeyPatch().setenv("REQUESTS_CA_BUNDLE", str(cafile.absolute()))
+    relukko = RelukkoClient(base_url="https://relukko", api_key="")
+    pytest.MonkeyPatch().delenv("REQUESTS_CA_BUNDLE")
+    _check_tls(relukko.ssl_ctx, port)
+    _check_has_serial_no(relukko.ssl_ctx)
+
+    pytest.MonkeyPatch().setenv("CURL_CA_BUNDLE", str(cafile.absolute()))
+    relukko2 = RelukkoClient(base_url="https://relukko", api_key="")
+    pytest.MonkeyPatch().delenv("CURL_CA_BUNDLE")
+    _check_tls(relukko2.ssl_ctx, port)
+    _check_has_serial_no(relukko2.ssl_ctx)
+
+    pytest.MonkeyPatch().setenv("REQUESTS_CA_BUNDLE", str(capath.absolute()))
+    relukko3 = RelukkoClient(base_url="https://relukko", api_key="")
+    pytest.MonkeyPatch().delenv("REQUESTS_CA_BUNDLE")
+    _check_tls(relukko3.ssl_ctx, port)
+    _check_has_serial_no(relukko3.ssl_ctx)
+
+    pytest.MonkeyPatch().setenv("CURL_CA_BUNDLE", str(capath.absolute()))
+    relukko4 = RelukkoClient(base_url="https://relukko", api_key="")
+    pytest.MonkeyPatch().delenv("CURL_CA_BUNDLE")
+    _check_tls(relukko4.ssl_ctx, port)
+    _check_has_serial_no(relukko4.ssl_ctx)
+
+
+def test_init_relukko_client_with_cafile(tls_listener):
+    _, port = tls_listener
+
+    cafile = SCRIPT_DIR / "cert" / "rootCA.crt"
+
+    relukko = RelukkoClient(
+        base_url="https://relukko", api_key="", cafile=cafile)
+    _check_tls(relukko.ssl_ctx, port)
+    _check_has_serial_no(relukko.ssl_ctx)
+
+
+def test_init_relukko_client_with_capath(tls_listener):
+    _, port = tls_listener
+
+    capath = SCRIPT_DIR / "cert"
+
+    relukko = RelukkoClient(
+        base_url="https://relukko", api_key="", capath=capath)
+    _check_tls(relukko.ssl_ctx, port)
+    _check_has_serial_no(relukko.ssl_ctx)
+
+
+def test_init_relukko_client_with_cadata(tls_listener):
+    _, port = tls_listener
+
+    cafile = SCRIPT_DIR / "cert" / "rootCA.crt"
+    cadata = cafile.read_text()
+
+    relukko = RelukkoClient(
+        base_url="https://relukko", api_key="", cadata=cadata)
+    _check_tls(relukko.ssl_ctx, port)
+    _check_has_serial_no(relukko.ssl_ctx)
+
+    cader = SCRIPT_DIR / "cert" / "rootCA.der"
+    cadata = cader.read_bytes()
+
+    relukko2 = RelukkoClient(
+        base_url="https://relukko", api_key="", cadata=cadata)
+    _check_tls(relukko2.ssl_ctx, port)
+    _check_has_serial_no(relukko2.ssl_ctx)
+
+
+def test_check_tls_throws_error(tls_listener):
+    _, port = tls_listener
+
+    relukko = RelukkoClient(
+        base_url="https://relukko", api_key="")
+    with pytest.raises(ssl.SSLCertVerificationError):
+        _check_tls(relukko.ssl_ctx, port)
+
+
+def test_reconfigure_relukko_client():
+    relukko = RelukkoClient(base_url="", api_key="")
+
+    relukko.reconfigure_relukko(
+        "https://relukko", api_key="secret-key")
+
+    assert relukko.base_url == parse_url("https://relukko")
+    assert relukko.ws_url == parse_url("wss://relukko/deletions")
+    assert relukko.session.headers['X-api-Key'] == "secret-key"
+
+    default_ctx = ssl.create_default_context()
+    assert relukko.ssl_ctx.check_hostname == default_ctx.check_hostname
+    assert relukko.ssl_ctx.hostname_checks_common_name == \
+        default_ctx.hostname_checks_common_name
+    assert relukko.ssl_ctx.keylog_filename == default_ctx.keylog_filename
+    assert relukko.ssl_ctx.sni_callback == default_ctx.sni_callback
+    assert relukko.ssl_ctx.verify_flags == default_ctx.verify_flags
+    assert relukko.ssl_ctx.verify_mode == default_ctx.verify_mode
+    assert relukko.ssl_ctx.options == default_ctx.options
+    assert relukko.tries == 4
+    assert relukko.delay == 5
+    assert relukko.backoff == 2.0
+    assert relukko.max_delay is None
+    assert relukko.exceptions == (requests.ConnectionError, RelukkoDoRetry)
+
+
+def test_reconfigure_relukko_client_extended():
+    relukko = RelukkoClient(base_url="", api_key="")
+
+    cookies = cookiejar_from_dict({"cookie1": "value1"})
+    verify_mode = ssl.VerifyMode.CERT_NONE
+    verify_flags = ssl.VerifyFlags.VERIFY_DEFAULT
+    options = ssl.Options.OP_ALL
+
+    relukko.reconfigure_relukko(
+        base_url="https://relukko", api_key="my-API-key", trust_env=False,
+        cookies=cookies, total=100, connect=99, read=98, redirect=97,
+        status=96, other=95, backoff_factor=94, backoff_max=1000,
+        backoff_jitter=93, raise_on_redirect=False, raise_on_status=False,
+        check_hostname=False, hostname_checks_common_name=False,
+        verify_mode=verify_mode, verify_flags=verify_flags, options=options
+    )
+
+    assert relukko.session.trust_env == False
+    assert relukko.session.cookies == cookies
+    assert relukko.base_url == parse_url("https://relukko")
+    assert relukko.ws_url == parse_url("wss://relukko/deletions")
+    assert relukko.session.headers['X-api-Key'] == "my-API-key"
+    http_adapter: HTTPAdapter = relukko.session.adapters.get("http://")
+    assert http_adapter.max_retries.total == 100
+    assert http_adapter.max_retries.connect == 99
+    assert http_adapter.max_retries.read == 98
+    assert http_adapter.max_retries.redirect == 97
+    assert http_adapter.max_retries.status == 96
+    assert http_adapter.max_retries.other == 95
+    assert http_adapter.max_retries.backoff_factor == 94.0
+    assert http_adapter.max_retries.backoff_max == 1000.0
+    assert http_adapter.max_retries.backoff_jitter == 93.0
+    assert http_adapter.max_retries.raise_on_redirect == False
+    assert http_adapter.max_retries.raise_on_status == False
+    assert isinstance(relukko.ssl_ctx, ssl.SSLContext)
+    assert relukko.ssl_ctx.check_hostname == False
+    assert relukko.ssl_ctx.hostname_checks_common_name == False
+    assert relukko.ssl_ctx.keylog_filename is None
+    assert relukko.ssl_ctx.sni_callback is None
+    assert relukko.ssl_ctx.verify_flags == verify_flags
+    assert relukko.ssl_ctx.verify_mode == verify_mode
+    assert relukko.ssl_ctx.options == options
+    assert relukko.tries == 4
+    assert relukko.delay == 5
+    assert relukko.backoff == 2.0
+    assert relukko.max_delay is None
+    assert relukko.exceptions == (requests.ConnectionError, RelukkoDoRetry)
+
+
+def test_init_relukko_client_extented():
+    cookies = cookiejar_from_dict({"cookie1": "value1"})
+
+    relukko = RelukkoClient(
+        base_url="http://relukko", api_key="my-API-key", trust_env=False,
+        cookies=cookies, total=100, connect=99, read=98, redirect=97,
+        status=96, other=95, backoff_factor=94, backoff_max=1000,
+        backoff_jitter=93, raise_on_redirect=False, raise_on_status=False,
+    )
+
+    assert relukko.session.trust_env == False
+    assert relukko.session.cookies == cookies
+    assert relukko.base_url == parse_url("http://relukko")
+    assert relukko.ws_url == parse_url("ws://relukko/deletions")
+    assert relukko.session.headers['X-api-Key'] == "my-API-key"
+    assert relukko.ssl_ctx is None
+    http_adapter: HTTPAdapter = relukko.session.adapters.get("http://")
+    assert http_adapter.max_retries.total == 100
+    assert http_adapter.max_retries.connect == 99
+    assert http_adapter.max_retries.read == 98
+    assert http_adapter.max_retries.redirect == 97
+    assert http_adapter.max_retries.status == 96
+    assert http_adapter.max_retries.other == 95
+    assert http_adapter.max_retries.backoff_factor == 94.0
+    assert http_adapter.max_retries.backoff_max == 1000.0
+    assert http_adapter.max_retries.backoff_jitter == 93.0
+    assert http_adapter.max_retries.raise_on_redirect == False
+    assert http_adapter.max_retries.raise_on_status == False
+    assert relukko.tries == 4
+    assert relukko.delay == 5
+    assert relukko.backoff == 2.0
+    assert relukko.max_delay is None
+    assert relukko.exceptions == (requests.ConnectionError, RelukkoDoRetry)
+
+
+def test_init_relukko_client_ssl_ctx():
+    relukko = RelukkoClient(
+        base_url="https://relukko", api_key="my-API-key",
+    )
+
+    default_ctx = ssl.create_default_context()
+
+    assert isinstance(relukko.ssl_ctx, ssl.SSLContext)
+    assert relukko.ssl_ctx.check_hostname == default_ctx.check_hostname
+    assert relukko.ssl_ctx.hostname_checks_common_name == \
+        default_ctx.hostname_checks_common_name
+    assert relukko.ssl_ctx.keylog_filename == default_ctx.keylog_filename
+    assert relukko.ssl_ctx.sni_callback == default_ctx.sni_callback
+    assert relukko.ssl_ctx.verify_flags == default_ctx.verify_flags
+    assert relukko.ssl_ctx.verify_mode == default_ctx.verify_mode
+    assert relukko.ssl_ctx.options == default_ctx.options
+    assert relukko.tries == 4
+    assert relukko.delay == 5
+    assert relukko.backoff == 2.0
+    assert relukko.max_delay is None
+    assert relukko.exceptions == (requests.ConnectionError, RelukkoDoRetry)
+
+
+def test_init_relukko_client_ssl_ctx_extended():
+    verify_mode = ssl.VerifyMode.CERT_NONE
+    verify_flags = ssl.VerifyFlags.VERIFY_DEFAULT
+    options = ssl.Options.OP_ALL
+
+    relukko = RelukkoClient(
+        base_url="https://relukko", api_key="my-API-key", check_hostname=False,
+        hostname_checks_common_name=False, verify_mode=verify_mode,
+        verify_flags=verify_flags, options=options
+    )
+    assert isinstance(relukko.ssl_ctx, ssl.SSLContext)
+    assert relukko.ssl_ctx.check_hostname == False
+    assert relukko.ssl_ctx.hostname_checks_common_name == False
+    assert relukko.ssl_ctx.keylog_filename is None
+    assert relukko.ssl_ctx.sni_callback is None
+    assert relukko.ssl_ctx.verify_flags == verify_flags
+    assert relukko.ssl_ctx.verify_mode == verify_mode
+    assert relukko.ssl_ctx.options == options
+    assert relukko.tries == 4
+    assert relukko.delay == 5
+    assert relukko.backoff == 2.0
+    assert relukko.max_delay is None
+    assert relukko.exceptions == (requests.ConnectionError, RelukkoDoRetry)
+
+
+def test_init_relukko_client_retry():
+
+    exceptions = (
+        ValueError,
+        ConnectionRefusedError,
+        ConnectionResetError,
+    )
+
+    relukko = RelukkoClient(
+        base_url="", api_key="", tries=100, delay=99, backoff=98.7,
+        max_delay=97, exceptions=exceptions)
+
+    assert relukko.tries == 100
+    assert relukko.delay == 99
+    assert relukko.backoff == 98.7
+    assert relukko.max_delay == 97
+    assert relukko.exceptions == exceptions
+
+
+def test_reconfigre_relukko_client_retry():
+    relukko = RelukkoClient(base_url="", api_key="")
+
+    exceptions = (
+        ValueError,
+        ConnectionRefusedError,
+        ConnectionResetError,
+    )
+
+    relukko.reconfigure_relukko(
+        tries=100, delay=99, backoff=98.7,
+        max_delay=97, exceptions=exceptions)
+
+    assert relukko.tries == 100
+    assert relukko.delay == 99
+    assert relukko.backoff == 98.7
+    assert relukko.max_delay == 97
+    assert relukko.exceptions == exceptions
+
+
+def test_acquire_relukko(relukko_backend):
+    relukko, _ = relukko_backend
+
+    lock = relukko.acquire_relukko("pylock", "pytest", 10)
+    assert isinstance(lock, Dict)
+    start_time = time.time()
+    lock = relukko.acquire_relukko("pylock", "pytest", 30)
+    end_time = time.time()
+    assert lock is None
+    assert 29 < end_time - start_time < 34
+
+
+def test_delete_relukko(relukko_backend):
+    relukko, _ = relukko_backend
+
+    lock = relukko.acquire_relukko("del_lock", "pytest", 10)
+    del_lock = relukko.delete_relukko(lock['id'])
+    assert lock == del_lock
+
+    get_lock = relukko.get_lock(lock['id'])
+    assert get_lock['status'] == 422
+
+    locks = relukko.get_locks()
+    assert lock not in locks
+
+
+def test_get_relukko(relukko_backend):
+    relukko, _ = relukko_backend
+
+    lock = relukko.acquire_relukko("get_lock", "pytest", 10)
+    assert isinstance(lock, Dict)
+
+    get_lock = relukko.get_lock(lock['id'])
+    assert get_lock == lock
+
+    locks = relukko.get_locks()
+    assert lock in locks
+
+
+def test_update_relukko_creator(relukko_backend):
+    relukko, _ = relukko_backend
+
+    lock = relukko.acquire_relukko("update_lock", "pytest", 10)
+    assert lock['creator'] == "pytest"
+
+    upd_lock = relukko.update_relukko(lock['id'], creator="tsetyp")
+    assert upd_lock['creator'] == "tsetyp"
+
+    get_lock = relukko.get_lock(lock['id'])
+    assert get_lock['creator'] == "tsetyp"
+
+
+def test_update_relukko_expires_at(relukko_backend):
+    relukko, _ = relukko_backend
+
+    lock = relukko.acquire_relukko("update_lock_exp", "pytest", 10)
+    id = lock['id']
+
+    expires_at = datetime.fromisoformat("2099-12-31T12:34:56.789Z")
+    upd_lock = relukko.update_relukko(id, expires_at=expires_at)
+    assert upd_lock['expires_at'] == "2099-12-31T12:34:56.789Z"
+
+    with pytest.raises(ValueError):
+        relukko.update_relukko(id, expires_at="2099-12-01T23:12Z")
+
+
+def test_keep_relukko_alive(relukko_backend):
+    relukko, _ = relukko_backend
+
+    lock = relukko.acquire_relukko("keep_me", "pytest", 10)
+    id = lock['id']
+
+    start_time = datetime.now(timezone.utc)
+    keep_lock = relukko.keep_relukko_alive(id)
+    assert lock['expires_at'] is not keep_lock['expires_at']
+
+    expires_at = datetime.fromisoformat(keep_lock['expires_at'])
+
+    expires_diff = expires_at - start_time
+    assert 295 < expires_diff.seconds < 305
+
+
+def test_keep_relukko_alive_put(relukko_backend):
+    relukko, _ = relukko_backend
+
+    lock = relukko.acquire_relukko("keep_me_more", "pytest", 10)
+    id = lock['id']
+
+    start_time = datetime.now(timezone.utc)
+    keep_lock = relukko.keep_relukko_alive_put(id, 3600)
+    assert lock['expires_at'] is not keep_lock['expires_at']
+
+    expires_at = datetime.fromisoformat(keep_lock['expires_at'])
+
+    expires_diff = expires_at - start_time
+    assert 3595 < expires_diff.seconds < 3605
+
+
+def test_add_to_expires_at_time(relukko_backend):
+    relukko, _ = relukko_backend
+    lock = relukko.acquire_relukko("add_me_up", "pytest", 10)
+    id = lock['id']
+    start_expires_at = datetime.fromisoformat(lock['expires_at'])
+
+    add_lock = relukko.add_to_expires_at_time(id)
+    assert lock['expires_at'] is not add_lock['expires_at']
+
+    add_expires_at = datetime.fromisoformat(add_lock['expires_at'])
+
+    expires_diff = add_expires_at - start_expires_at
+    assert expires_diff.seconds == 300
+
+
+def test_add_to_expires_at_time_put(relukko_backend):
+    relukko, _ = relukko_backend
+    lock = relukko.acquire_relukko("add_me_up_more", "pytest", 10)
+    id = lock['id']
+    start_expires_at = datetime.fromisoformat(lock['expires_at'])
+
+    add_lock = relukko.add_to_expires_at_time_put(id, 3600)
+    assert lock['expires_at'] is not add_lock['expires_at']
+
+    add_expires_at = datetime.fromisoformat(add_lock['expires_at'])
+
+    expires_diff = add_expires_at - start_expires_at
+    assert expires_diff.seconds == 3600

pyrelukko-0.1.0/.pylintrc.toml

@@ -1,4 +0,0 @@
-[tool.pylint.main]
-# Files or directories to be skipped. They should be base names, not paths.
-ignore = ["LICENSE", "pyproject.toml", "version.py",
-          "README.md", "demo.py",]