Merge pull request #15 from alma/auth/configurable-credentials

olance · web-flow · commit 6fcfac6eee61 · 2020-09-01T12:18:56.000+02:00
Auth/configurable credentials
diff --git a/alma/client.py b/alma/client.py
@@ -1,25 +1,95 @@
 import logging
 import platform
+from typing import Optional
 
 from . import endpoints
 from .api_modes import ApiModes
 from .context import Context
+from .credentials import (
+    MerchantIdCredentials,
+    AlmaSessionCredentials,
+    ApiKeyCredentials,
+    Credentials,
+)
 from .version import __version__ as alma_version
 
 
 class Client:
     SANDBOX_API_URL = "https://api.sandbox.getalma.eu"
     LIVE_API_URL = "https://api.getalma.eu"
 
-    def __init__(self, api_key, **options):
-        if not api_key:
-            raise ValueError("An API key is required to instantiate a new Client")
+    @classmethod
+    def with_api_key(cls, api_key: str, **options):
+        return cls(credentials=ApiKeyCredentials(api_key), **options)
+
+    @classmethod
+    def with_merchant_id(cls, merchant_id: str, mode: ApiModes = ApiModes.LIVE, **options):
+        return cls(credentials=MerchantIdCredentials(mode, merchant_id), **options)
+
+    @classmethod
+    def with_alma_session(
+        cls,
+        session_id: str,
+        cookie_name: str = "alma_sess",
+        mode: ApiModes = ApiModes.LIVE,
+        **options
+    ):
+        return cls(credentials=AlmaSessionCredentials(mode, session_id, cookie_name), **options)
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        credentials: Optional[Credentials] = None,
+        mode: Optional[ApiModes] = None,
+        **kwargs
+    ):
+        """
+        Create a new instance of the Alma API Client.
+
+        It is recommended to use one the convenience methods instead of the default constructor:
+        - Client.with_api_key
+        - Client.with_merchant_id
+        - Client.with_alma_session
+
+        :param  api_key:    Deprecated - use Client.with_api_key("<api_key>") instead
+        :type   api_key:    str
+
+        :param      credentials   A `Credentials` instance to be used to configure requests made to
+                                the API. This would typically be set by one of the convenience
+                                methods mentioned above.
+        :type       credentials Credentials
+
+        :param      mode        Deprecated. Use `mode` param of convenience methods above
+                                API mode to be used: either ApiModes.LIVE or ApiModes.TEST
+        :type       mode        ApiModes
+
+        :keyword    logger      A logger instance to be used instead of the default one
+        :keyword    api_root    root URL(s) to call Alma's API at.
+                                You probably don't want to change it!
+
+                                Expected types:
+                                -------------
+                                str: the provided URL will be used for both LIVE and TEST modes
+                                dict: must have two keys, ApiModes.LIVE and ApiModes.TEST, each
+                                      value must be the URL to be used for each mode
+
+        """
+        if isinstance(credentials, ApiKeyCredentials):
+            api_key = credentials.api_key
+
+        if not credentials:
+            if not api_key:
+                raise ValueError("Valid credentials are required to instantiate a new Client")
+
+            # Backward compatibility with the older init method
+            credentials = ApiKeyCredentials(api_key)
 
         options = {
             "api_root": {ApiModes.TEST: self.SANDBOX_API_URL, ApiModes.LIVE: self.LIVE_API_URL},
-            "mode": ApiModes.LIVE if api_key.startswith("sk_live") else ApiModes.TEST,
+            "mode": mode if mode is not None else credentials.mode,
             "logger": logging.getLogger("alma-python-client"),
-            **options,
+            "credentials": credentials,
+            **kwargs,
         }
 
         if type(options["api_root"]) is str:
@@ -37,10 +107,9 @@ def __init__(self, api_key, **options):
                 )
             )
 
-        self.context = Context(api_key, options)
-
+        self.context = Context(options)
         self.init_user_agent()
-        self._endpoints = {}
+        self._endpoints = {}  # type: ignore
 
     def add_user_agent_component(self, component, version):
         self.context.add_user_agent_component(component, version)
diff --git a/alma/context.py b/alma/context.py
@@ -1,6 +1,5 @@
 class Context:
-    def __init__(self, api_key, options):
-        self.api_key = api_key
+    def __init__(self, options):
         self.options = options
 
         self.user_agent_components = []
@@ -17,6 +16,10 @@ def api_root(self):
     def mode(self):
         return self.options["mode"]
 
+    @property
+    def credentials(self):
+        return self.options["credentials"]
+
     def url_for(self, path):
         root = self.api_root[self.mode].rstrip("/")
 
diff --git a/alma/credentials/__init__.py b/alma/credentials/__init__.py
@@ -0,0 +1,6 @@
+# flake8: noqa
+
+from .base import Credentials
+from .alma_session import AlmaSessionCredentials
+from .api_key import ApiKeyCredentials
+from .merchant_id import MerchantIdCredentials
diff --git a/alma/credentials/alma_session.py b/alma/credentials/alma_session.py
@@ -0,0 +1,12 @@
+from . import Credentials
+from .. import ApiModes
+
+
+class AlmaSessionCredentials(Credentials):
+    def __init__(self, mode: ApiModes, session_id: str, cookie_name: str):
+        super().__init__(mode)
+        self.session_id = session_id
+        self.cookie_name = cookie_name
+
+    def configure(self, request):
+        request.cookies[self.cookie_name] = self.session_id
diff --git a/alma/credentials/api_key.py b/alma/credentials/api_key.py
@@ -0,0 +1,15 @@
+from . import Credentials
+from .. import ApiModes
+
+
+class ApiKeyCredentials(Credentials):
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        super().__init__(self.mode)
+
+    def configure(self, request):
+        request.headers["Authorization"] = "Alma-Auth {api_key}".format(api_key=self.api_key)
+
+    @property
+    def mode(self):
+        return ApiModes.LIVE if self.api_key.startswith("sk_live") else ApiModes.TEST
diff --git a/alma/credentials/base.py b/alma/credentials/base.py
@@ -0,0 +1,14 @@
+from alma import ApiModes
+from alma.request import Request
+
+
+class Credentials:
+    def __init__(self, mode: ApiModes):
+        self._mode = mode
+
+    def configure(self, request: Request):
+        raise NotImplementedError()
+
+    @property
+    def mode(self):
+        return self._mode
diff --git a/alma/credentials/merchant_id.py b/alma/credentials/merchant_id.py
@@ -0,0 +1,13 @@
+from . import Credentials
+from .. import ApiModes
+
+
+class MerchantIdCredentials(Credentials):
+    def __init__(self, mode: ApiModes, merchant_id: str):
+        super().__init__(mode)
+        self.merchant_id = merchant_id
+
+    def configure(self, request):
+        request.headers["Authorization"] = "Alma-Merchant-Auth {merchant_id}".format(
+            merchant_id=self.merchant_id
+        )
diff --git a/alma/endpoints/__init__.py b/alma/endpoints/__init__.py
@@ -4,4 +4,4 @@
 from .merchants import Merchants
 from .orders import Orders
 from .exports import Exports
-from .payments import Payments
+from .payments import Payments
diff --git a/alma/request.py b/alma/request.py
@@ -1,8 +1,22 @@
+from functools import wraps
+
 import requests
 
 from .response import Response
 
 
+def configure_credentials(func):
+    def decorator(f):
+        @wraps(f)
+        def decorated(request, *args, **kwargs):
+            request.context.credentials.configure(request)
+            return f(request, *args, **kwargs)
+
+        return decorated
+
+    return decorator(func)
+
+
 class RequestError(Exception):
     def __init__(self, error, url, response):
         self.error = error
@@ -17,11 +31,9 @@ def __init__(self, context, url):
 
         self.headers = {
             "User-Agent": self.context.user_agent_string(),
-            "Authorization": "Alma-Auth {context_api_key}".format(
-                context_api_key=self.context.api_key
-            ),
             "Accept": "application/json",
         }
+        self.cookies = {}
         self.params = {}
         self.body = None
 
@@ -35,16 +47,19 @@ def set_query_params(self, params):
         self.params = params
         return self
 
+    @configure_credentials
     def get(self):
-        res = requests.get(self.url, self.params, headers=self.headers)
+        res = requests.get(self.url, self.params, headers=self.headers, cookies=self.cookies)
         return self._process_response(res)
 
+    @configure_credentials
     def post(self):
-        res = requests.post(self.url, json=self.body, headers=self.headers)
+        res = requests.post(self.url, json=self.body, headers=self.headers, cookies=self.cookies)
         return self._process_response(res)
 
+    @configure_credentials
     def put(self):
-        res = requests.put(self.url, json=self.body, headers=self.headers)
+        res = requests.put(self.url, json=self.body, headers=self.headers, cookies=self.cookies)
         return self._process_response(res)
 
     def _process_response(self, resp):
diff --git a/pyproject.toml b/pyproject.toml
@@ -6,5 +6,6 @@ exclude = '''
 /(
     \.git
   | tmp
+  | .venv
 )/
 '''
diff --git a/tests/test_client.py b/tests/test_client.py
@@ -1,24 +1,21 @@
-import platform
+import pytest
 from unittest import TestCase
 
-import pytest
 from alma import ApiModes, Client
-from alma.version import __version__ as alma_version
+from alma.credentials import ApiKeyCredentials, MerchantIdCredentials, AlmaSessionCredentials
 
 
 class ClientTest(TestCase):
-    def test_client_raises_with_no_api_key_arguments(self):
-        with pytest.raises(
-            TypeError, match=r"__init__\(\) missing 1 required positional argument: 'api_key'"
-        ):
+    def test_client_raises_with_no_api_key_arguments_nor_credentials(self):
+        with pytest.raises(ValueError, match=r"Valid credentials are required"):
             Client()
 
     def test_client_raises_with_empty_api_key_value(self):
-        with pytest.raises(ValueError, match=r"An API key is required"):
+        with pytest.raises(ValueError, match=r"Valid credentials are required"):
             Client(api_key="")
 
     def test_client_raises_with_empty_api_key_set_to_None(self):
-        with pytest.raises(ValueError, match=r"An API key is required"):
+        with pytest.raises(ValueError, match=r"Valid credentials are required"):
             Client(api_key=None)
 
     def test_client_detects_mode_with_regards_to_the_suggested_key(self):
@@ -27,6 +24,39 @@ def test_client_detects_mode_with_regards_to_the_suggested_key(self):
         alma_client = Client(api_key="sk_test_l6C92m3mqmS0aWcscEw62Xk4")
         assert alma_client.context.options["mode"] == ApiModes.TEST
 
+    def test_client_inits_api_key_credentials_with_legacy_constructor(self):
+        api_key = "sk_live_3geNR4OVI0gQGCAKgcYqQs2I"
+        alma_client = Client(api_key=api_key)
+        assert alma_client.context.credentials
+        assert isinstance(alma_client.context.credentials, ApiKeyCredentials)
+        assert alma_client.context.credentials.api_key == api_key
+
+    def test_client_inits_api_key_credentials(self):
+        api_key = "sk_live_3geNR4OVI0gQGCAKgcYqQs2I"
+        alma_client = Client.with_api_key(api_key)
+
+        assert alma_client.context.credentials
+        assert isinstance(alma_client.context.credentials, ApiKeyCredentials)
+        assert alma_client.context.credentials.api_key == api_key
+
+    def test_client_inits_merchant_id_credentials(self):
+        merchant_id = "merchant"
+        alma_client = Client.with_merchant_id(merchant_id)
+
+        assert alma_client.context.credentials
+        assert isinstance(alma_client.context.credentials, MerchantIdCredentials)
+        assert alma_client.context.credentials.merchant_id == merchant_id
+
+    def test_client_inits_merchant_id_credentials(self):
+        session_id = "merchant"
+        cookie_name = "session_cookie"
+        alma_client = Client.with_alma_session(session_id=session_id, cookie_name=cookie_name)
+
+        assert alma_client.context.credentials
+        assert isinstance(alma_client.context.credentials, AlmaSessionCredentials)
+        assert alma_client.context.credentials.session_id == session_id
+        assert alma_client.context.credentials.cookie_name == cookie_name
+
     def test_client_can_override_api_root_with_a_string(self):
         api_root = "http://localhost"
         alma_client = Client(api_key="sk_live_3geNR4OVI0gQGCAKgcYqQs2I", api_root=api_root)
@@ -60,27 +90,3 @@ def test_client_expose_endpoints(self):
 
         # Exposed but empty
         assert alma_client.merchants
-
-
-class ContextTest(TestCase):
-    def setUp(self):
-        client = Client(api_key="sk_live_3geNR4OVI0gQGCAKgcYqQs2I")
-        self.context = client.context
-
-    def test_context_expose_logger(self):
-        assert self.context.logger.name == "alma-python-client"
-        assert self.context.logger.level == 0
-
-    def test_context_expose_api_root_and_mode(self):
-        assert self.context.api_root == self.context.options["api_root"]
-        assert self.context.mode == self.context.options["mode"]
-
-    def test_context_expose_url_for(self):
-        assert self.context.url_for("/path/test") == "https://api.getalma.eu/path/test"
-
-    def test_context_expose_user_agent_string(self):
-        assert self.context.user_agent_string().startswith(
-            "alma-client/{alma_version}; Python/{python_version}".format(
-                alma_version=alma_version, python_version=platform.python_version()
-            )
-        )
diff --git a/tests/test_context.py b/tests/test_context.py
diff --git a/tests/test_credentials.py b/tests/test_credentials.py
diff --git a/tests/test_request.py b/tests/test_request.py

-Original file line number
+Diff line change
 /(
     \.git
   | tmp
 +  | .venv
 )/
 '''