Add middleware (deriv-com#10)

* Added middleware support, and fixed some small problems

* refactor MiddleWares

* add doc

* remove unused line

Author: chylli-deriv

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.1.2
+
+Added middleware support
+
 ## 0.1.1
 
 ### Fixed:

deriv_api/deriv_api.py

@@ -20,10 +20,9 @@
 from deriv_api.in_memory import InMemory
 from deriv_api.subscription_manager import SubscriptionManager
 from deriv_api.utils import is_valid_url
+from deriv_api.middlewares import MiddleWares
 
 # TODO NEXT subscribe is not calling deriv_api_calls. that's , args not verified. can we improve it ?
-# TODO list these features missed
-# middleware is missed
 
 logging.basicConfig(
     format="%(asctime)s %(message)s",
@@ -39,7 +38,7 @@
     'deriv_api.deriv_api.DerivAPI.disconnect': False,
     'deriv_api.deriv_api.DerivAPI.send': False,
     'deriv_api.deriv_api.DerivAPI.wsconnection': False,
-    'deriv_api.deriv_api.DerivAPI.storage': False
+    'deriv_api.deriv_api.DerivAPI.storage': False,
 }
 
 
@@ -70,10 +69,13 @@ class DerivAPI(DerivAPICalls):
                 Language of the API communication
             brand : String
                 Brand name
-            middleware : String
-                A middleware to call on certain API actions
+            middleware : MiddleWares
+                middlewares to call on certain API actions. Now two middlewares are supported: sendWillBeCalled and
+                sendIsCalled
     Properties
     ----------
+    cache: Cache
+        Temporary cache default to InMemory
     storage : Cache
         If specified, uses a more persistent cache (local storage, etc.)
     events: Observable
@@ -88,6 +90,7 @@ def __init__(self, **options: str) -> None:
         brand = options.get('brand', '')
         cache = options.get('cache', InMemory())
         storage: any = options.get('storage')
+        self.middlewares: MiddleWares = options.get('middlewares', MiddleWares())
         self.wsconnection: Optional[WebSocketClientProtocol] = None
         self.wsconnection_from_inside = True
         self.shouldReconnect = False
@@ -251,15 +254,23 @@ async def send(self, request: dict) -> dict:
             API response
         """
 
+        send_will_be_called = self.middlewares.call('sendWillBeCalled', {'request': request})
+        if send_will_be_called:
+            return send_will_be_called
+
         self.events.on_next({'name': 'send', 'data': request})
         response_future = self.send_and_get_source(request).pipe(op.first(), op.to_future())
 
         response = await response_future
         self.cache.set(request, response)
         if self.storage:
             self.storage.set(request, response)
+        send_is_called = self.middlewares.call('sendIsCalled', {'response': response, 'request': request})
+        if send_is_called:
+            return send_is_called
         return response
 
+
     def send_and_get_source(self, request: dict) -> Subject:
         """
         Send message and returns Subject

deriv_api/middlewares.py

@@ -0,0 +1,65 @@
+from typing import Callable, Union
+
+_implemented_middlewares = ['sendWillBeCalled', 'sendIsCalled']
+
+
+class MiddleWares:
+    """
+    A class that help to manage middlewares
+
+    Examples:
+        middlewares = MiddleWares()
+        middlewares.add('sendWillBeCalled', lanmbda req: print(req))
+        middlewares = Middlewares({'sendWillBeCalled': lambda req: print(req)})
+        middleware->call('sendWillBeCalled', arg1, arg2)
+
+    Parameters:
+        options:
+            dict with following key value pairs
+            key: string, middleware name
+            value: function, middleware code
+    """
+
+    def __init__(self, middlewares: dict = {}):
+        self.middlewares = {}
+        for name in middlewares.keys():
+            self.add(name, middlewares[name])
+
+    def add(self, name: str, code: Callable[..., bool]) -> None:
+        """
+        Add middleware
+
+        Parameters:
+            name: Str
+                middleware name
+            code: function
+                middleware code
+        """
+        if not isinstance(name, str):
+            raise Exception(f"name {name} should be a string")
+        if not isinstance(code, Callable):
+            raise Exception(f"code {code} should be a Callable object")
+        if name in _implemented_middlewares:
+            self.middlewares[name] = code
+        else:
+            raise Exception(f"{name} is not supported in middleware")
+
+    def call(self, name: str, args: dict) -> Union[None, dict]:
+        """
+        Call middleware and return the result if there is such middleware
+
+        Parameters
+        ----------
+        name: string
+        args: list
+            the args that will feed to middleware
+
+        Returns
+        -------
+            If there is such middleware, then return the result of middleware
+            else return None
+        """
+
+        if name not in self.middlewares:
+            return None
+        return self.middlewares[name](args)

pytest.ini

@@ -1,2 +1,3 @@
 [pytest]
 testpaths = tests
+asyncio_mode=auto

setup.py

@@ -3,7 +3,7 @@
 setup(
     name='python_deriv_api',
     packages=find_packages(include=['deriv_api']),
-    version='0.1.1',
+    version='0.1.2',
     description='Python bindings for deriv.com websocket API',
     author='Deriv Group Services Ltd',
     author_email='learning+python@deriv.com',

tests/test_deriv_api.py

@@ -1,6 +1,4 @@
 import asyncio
-import sys
-import traceback
 import pytest
 import pytest_mock
 import reactivex
@@ -15,6 +13,9 @@
 import json
 from websockets.exceptions import ConnectionClosedOK, ConnectionClosedError
 
+from deriv_api.middlewares import MiddleWares
+
+
 class MockedWs:
     def __init__(self):
         self.data = []
@@ -154,6 +155,55 @@ async def test_simple_send():
     wsconnection.clear()
     await api.clear()
 
+@pytest.mark.asyncio
+async def test_middleware():
+    wsconnection = MockedWs()
+    send_will_be_called_args = None
+    send_is_called_args = None
+    send_will_be_called_return = None
+    send_is_called_return = None
+    def send_will_be_called(args):
+        nonlocal send_will_be_called_args
+        send_will_be_called_args = args
+        nonlocal send_will_be_called_return
+        return send_will_be_called_return
+
+    def send_is_called(args):
+        nonlocal send_is_called_args
+        send_is_called_args = args
+        nonlocal send_is_called_return
+        return send_is_called_return
+
+    api = deriv_api.DerivAPI(connection = wsconnection, middlewares = MiddleWares({'sendWillBeCalled': send_will_be_called, 'sendIsCalled': send_is_called}))
+    req1 = {"ping": 2}
+
+    # test sendWillBeCalled return true value, sendIsCalled will be not called and the request will not be sent to ws
+    data1 = {"echo_req":req1,"msg_type": "ping", "pong": 1,}
+    wsconnection.add_data(data1)
+    send_will_be_called_return = {'value': 1} # middleware sendWillBeCalled will return a dict
+    response = await api.send(req1)
+    assert response == send_will_be_called_return # api will return the value of sendWillBeCalled returned
+    assert send_will_be_called_args == {'request': req1}
+    assert len(wsconnection.called['send']) == 0 # ws send is not called
+
+    # test sendWillBeCalled return false value, ws send will be called and sendIsCalled will be called
+    send_will_be_called_return = None
+    send_is_called_return = None # middleware sendIsCalled will return false
+    response = await api.send(req1)
+    expected_response = data1.copy()
+    expected_response['req_id'] = 1
+    assert response == expected_response # response is the value that ws returned
+    assert send_is_called_args == {'response': expected_response, 'request': req1}
+
+    # test sendWillBeCalled return false , and sendIsCalled return a true value
+    send_is_called_return = {'value': 2}
+    wsconnection.add_data(data1)
+    response = await api.send(req1)
+    assert response == {'value': 2} # will get what sendIsCalled return
+
+    wsconnection.clear()
+    await api.clear()
+
 @pytest.mark.asyncio
 async def test_subscription():
     wsconnection = MockedWs()
@@ -383,18 +433,13 @@ async def recv(self):
     api.wsconnection_from_inside = True
     last_error = api.sanity_errors.pipe(op.first(), op.to_future())
     await asyncio.sleep(0.1) # waiting for init finished
-    print("here 382")
     await api.disconnect() # it will set connected as 'Closed by disconnect', and cause MockedWs2 raising `test disconnect`
-    print("here 384")
     assert isinstance((await last_error), ConnectionClosedOK), 'sanity error get errors'
-    print("here 386")
     with pytest.raises(ConnectionClosedOK, match='Closed by disconnect'):
         await api.send({'ping': 1})  # send will get same error
-    print("here 389")
     with pytest.raises(ConnectionClosedOK, match='Closed by disconnect'):
         await api.connected # send will get same error
     wsconnection.clear()
-    print("here 391")
     await api.clear()
 
     # closed by remote

tests/test_middlewares.py

@@ -0,0 +1,24 @@
+import pytest
+import re
+from deriv_api.middlewares import MiddleWares
+
+def test_middlewares():
+    middlewares = MiddleWares()
+    isinstance(middlewares, MiddleWares)
+
+    with pytest.raises(Exception, match = r"should be a string") as err:
+       MiddleWares({123: lambda i: i+1})
+
+    with pytest.raises(Exception, match = r"should be a Callable") as err:
+       MiddleWares({"name": 123})
+
+    with pytest.raises(Exception, match = r"not supported"):
+        MiddleWares({"hello": lambda i: i})
+
+    call_args = []
+    def send_will_be_called(*args):
+        nonlocal call_args
+        call_args = args
+    middlewares.add('sendWillBeCalled', send_will_be_called)
+    middlewares.call('sendWillBeCalled', 123)
+    assert call_args == (123,)