JSON RPC request class refactor (#368)

Consolidated logic into new Request class and improved PEP8 compliance.

Author: Elliot Boschwitz

mssqlcli/jsonrpc/contracts/__init__.py

@@ -2,32 +2,5 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License. See License.txt in the project root for license information.
 # --------------------------------------------------------------------------------------------
-import abc
 
-ABC = abc.ABCMeta('ABC', (object,), {})  # compatibile with Python 2 *and* 3.
-
-
-class Request(ABC):
-    """
-        Abstract request class.
-    """
-    @abc.abstractmethod
-    def execute(self):
-        """
-            Executes the request.
-        """
-        pass
-
-    @abc.abstractmethod
-    def get_response(self):
-        """
-            Retrieves expected response.
-        """
-        pass
-
-    @abc.abstractmethod
-    def completed(self):
-        """
-            Return state of request.
-        """
-        pass
+from mssqlcli.jsonrpc.contracts.request import Request

mssqlcli/jsonrpc/contracts/connectionservice.py

@@ -1,83 +1,46 @@
 # pylint: disable=too-many-instance-attributes
 # pylint: disable=too-few-public-methods
 
-import logging
 from mssqlcli.jsonrpc.contracts import Request
 
 
-logger = logging.getLogger(u'mssqlcli.connectionservice')
-
-
 class ConnectionRequest(Request):
     """
         SqlToolsService Connection request.
     """
-    METHOD_NAME = u'connection/connect'
 
     def __init__(self, request_id, owner_uri, json_rpc_client, parameters):
-        self.request_id = request_id
-        self.owner_uri = owner_uri
-        self.finished = False
-        self.json_rpc_client = json_rpc_client
-        self.params = ConnectionParams(parameters)
-
-    def execute(self):
-        self.json_rpc_client.submit_request(
-            self.METHOD_NAME, self.params.format(), self.request_id)
-
-    def get_response(self):
-        """
-            Get latest response, event or exception if it occured.
-        """
-        try:
-            response = self.json_rpc_client.get_response(self.request_id, self.owner_uri)
-            decoded_response = None
-            if response:
-                logger.debug(response)
-                decoded_response = self.decode_response(response)
-
-            if isinstance(decoded_response, ConnectionCompleteEvent):
-                self.finished = True
-                self.json_rpc_client.request_finished(self.request_id)
-                self.json_rpc_client.request_finished(self.owner_uri)
-
-            return decoded_response
-
-        except Exception as error:  # pylint: disable=broad-except
-            logger.info(str(error))
-            self.finished = True
-            self.json_rpc_client.request_finished(self.request_id)
-            self.json_rpc_client.request_finished(self.owner_uri)
-            return ConnectionCompleteEvent({
-                u'params': {
-                    u'ownerUri': self.owner_uri,
-                    u'connectionId': None,
-                    u'messages': str(error),
-                    u'errorMessage': u'Connection request encountered an exception',
-                    u'errorNumber': None
-                }
-            })
-
-    def completed(self):
-        """
-            Get current request state.
-        """
-        return self.finished
+        super(ConnectionRequest, self).__init__(request_id, owner_uri, json_rpc_client,
+                                                ConnectionParams(parameters),
+                                                u'connection/connect',
+                                                ConnectionCompleteEvent)
+
+    @classmethod
+    def response_error(cls, error):
+        return ConnectionCompleteEvent({
+            u'params': {
+                u'ownerUri': cls.owner_uri,
+                u'connectionId': None,
+                u'messages': str(error),
+                u'errorMessage': u'Connection request encountered an exception',
+                u'errorNumber': None
+            }
+        })
 
     @staticmethod
-    def decode_response(obj):
+    def decode_response(response):
         """
             Decode response dictionary into a Connection parameter type.
         """
 
-        if u'result' in obj:
-            return ConnectionResponse(obj)
+        if u'result' in response:
+            return ConnectionResponse(response)
 
-        if 'method' in obj and obj['method'] == 'connection/complete':
-            return ConnectionCompleteEvent(obj)
+        if 'method' in response and response['method'] == 'connection/complete':
+            return ConnectionCompleteEvent(response)
 
         # Could not decode return st
-        return obj
+        return response
 
 
 class ConnectionDetails:

mssqlcli/jsonrpc/contracts/queryexecutestringservice.py

@@ -12,51 +12,18 @@ class QueryExecuteStringRequest(Request):
         Uses SQL Tools Service query/executeString method.
     """
 
-    METHOD_NAME = u'query/executeString'
-
     def __init__(self, request_id, owner_uri, json_rpc_client, parameters):
-        self.request_id = request_id
-        self.owner_uri = owner_uri
-        self.finished = False
-        self.json_rpc_client = json_rpc_client
-        self.params = QueryExecuteStringParams(parameters)
-
-    def get_response(self):
-        """
-            Get latest response, event or exception if occured.
-        """
-        try:
-            response = self.json_rpc_client.get_response(self.request_id, self.owner_uri)
-
-            decoded_response = None
-            if response:
-                decoded_response = QueryExecuteStringRequest.decode_response(response)
-
-            if isinstance(decoded_response,
-                          (QueryCompleteEvent, QueryExecuteErrorResponseEvent)):
-                self.finished = True
-                self.json_rpc_client.request_finished(self.request_id)
-                self.json_rpc_client.request_finished(self.owner_uri)
-
-            return decoded_response
-
-        except Exception as error:  # pylint: disable=broad-except
-            self.finished = True
-            self.json_rpc_client.request_finished(self.request_id)
-            self.json_rpc_client.request_finished(self.owner_uri)
-            return QueryCompleteEvent(
-                {u'params': None}, exception_message=str(error)
-            )
-
-    def execute(self):
-        self.json_rpc_client.submit_request(
-            self.METHOD_NAME, self.params.format(), self.request_id)
-
-    def completed(self):
-        """
-            Get current request state.
-        """
-        return self.finished
+        super(QueryExecuteStringRequest, self).__init__(request_id, owner_uri, json_rpc_client,
+                                                        QueryExecuteStringParams(parameters),
+                                                        u'query/executeString',
+                                                        (QueryCompleteEvent,
+                                                         QueryExecuteErrorResponseEvent))
+
+    @classmethod
+    def response_error(cls, error):
+        return QueryCompleteEvent(
+            {u'params': None}, exception_message=str(error)
+        )
 
     @staticmethod
     def decode_response(response):
@@ -140,44 +107,14 @@ class QuerySubsetRequest(Request):
         SqlToolsService QuerySubset Request.
     """
 
-    METHOD_NAME = u'query/subset'
-
     def __init__(self, request_id, owner_uri, json_rpc_client, parameters):
-        self.request_id = request_id
-        self.owner_uri = owner_uri
-        self.finished = False
-        self.json_rpc_client = json_rpc_client
-        self.params = QuerySubsetParams(parameters)
-
-    def completed(self):
-        """
-            Get current request state.
-        """
-        return self.finished
-
-    def get_response(self):
-        try:
-            response = self.json_rpc_client.get_response(self.request_id, self.owner_uri)
-            decoded_response = None
-            if response:
-                decoded_response = QuerySubsetRequest.decode_response(response)
-
-            if isinstance(decoded_response, ResultSubset):
-                self.finished = True
-                self.json_rpc_client.request_finished(self.request_id)
-                self.json_rpc_client.request_finished(self.owner_uri)
-
-            return decoded_response
-
-        except Exception as error:      # pylint: disable=broad-except
-            self.finished = True
-            self.json_rpc_client.request_finished(self.request_id)
-            self.json_rpc_client.request_finished(self.owner_uri)
-            return ResultSubset(None, error_message=str(error))
-
-    def execute(self):
-        self.json_rpc_client.submit_request(
-            self.METHOD_NAME, self.params.format(), self.request_id)
+        super(QuerySubsetRequest, self).__init__(request_id, owner_uri, json_rpc_client,
+                                                 QuerySubsetParams(parameters),
+                                                 u'query/subset', ResultSubset)
+
+    @classmethod
+    def response_error(cls, error):
+        return ResultSubset(None, error_message=str(error))
 
     @staticmethod
     def decode_response(response):

mssqlcli/jsonrpc/contracts/request.py

@@ -0,0 +1,73 @@
+# pylint: disable=too-many-arguments
+import logging
+import abc
+
+ABC = abc.ABCMeta('ABC', (object,), {})  # compatibile with Python 2 *and* 3.
+logger = logging.getLogger(u'mssqlcli.connectionservice')
+
+class Request(ABC):
+    """
+        Abstract request class.
+    """
+
+    def __init__(self, request_id, owner_uri, json_rpc_client, parameters,
+                 method_name, connectionCompleteEvent):
+        self.request_id = request_id
+        self.owner_uri = owner_uri
+        self.json_rpc_client = json_rpc_client
+        self.params = parameters
+        self.method_name = method_name
+        self.connectionCompleteEvent = connectionCompleteEvent
+        self.finished = False
+
+    @staticmethod
+    @abc.abstractmethod
+    def decode_response(response):
+        """
+            Returns decoded response.
+        """
+        pass
+
+    @classmethod
+    @abc.abstractmethod
+    def response_error(cls, error):
+        """
+            Returns object when response fails.
+        """
+        pass
+
+    def execute(self):
+        """
+            Executes the request.
+        """
+        self.json_rpc_client.submit_request(
+            self.method_name, self.params.format(), self.request_id)
+
+    def get_response(self):
+        """
+            Get latest response, event or exception if it occured.
+        """
+        try:
+            response = self.json_rpc_client.get_response(self.request_id, self.owner_uri)
+            decoded_response = None
+            if response:
+                logger.debug(response)
+                decoded_response = self.decode_response(response)
+
+            if isinstance(decoded_response, self.connectionCompleteEvent):
+                self.finished = True
+                self.json_rpc_client.request_finished(self.request_id)
+                self.json_rpc_client.request_finished(self.owner_uri)
+            return decoded_response
+        except Exception as error:  # pylint: disable=broad-except
+            logger.info(str(error))
+            self.finished = True
+            self.json_rpc_client.request_finished(self.request_id)
+            self.json_rpc_client.request_finished(self.owner_uri)
+            return self.response_error(error)
+
+    def completed(self):
+        """
+            Return state of request.
+        """
+        return self.finished

tests/jsonrpc/__init__.py

@@ -0,0 +1,8 @@
+BASELINE_REQUEST = {
+    u'jsonrpc': u'2.0',
+    u'params': {
+        u'Key': u'Value'
+    },
+    u'method': u'testMethod/DoThis',
+    u'id': 1
+}

tests/jsonrpc/test_jsonrpc.py

@@ -6,7 +6,7 @@
 import io
 import unittest
 import mssqlcli.jsonrpc.jsonrpcclient as jsonrpc
-
+from jsonrpc import BASELINE_REQUEST
 
 class JsonRpcTest(unittest.TestCase):
     """
@@ -42,12 +42,7 @@ def test_basic_request(self):
         test_stream.seek(0)
         json_rpc_reader = jsonrpc.JsonRpcReader(test_stream)
         response = json_rpc_reader.read_response()
-        baseline = {
-            u'jsonrpc': u'2.0',
-            u'params': {
-                u'Key': u'Value'},
-            u'method': u'testMethod/DoThis',
-            u'id': 1}
+        baseline = BASELINE_REQUEST
         self.assertEqual(response, baseline)
 
         json_rpc_reader.close()

tests/jsonrpc/test_jsonrpcclient.py

@@ -4,7 +4,7 @@
 import threading
 import pytest
 import mssqlcli.jsonrpc.jsonrpcclient as json_rpc_client
-
+from jsonrpc import BASELINE_REQUEST
 
 class JsonRpcClientTests(unittest.TestCase):
     """
@@ -306,12 +306,7 @@ def test_get_response_with_id(self):
         # Sleeping to give background threads a chance to process response.
         time.sleep(1)
 
-        baseline = {
-            u'jsonrpc': u'2.0',
-            u'params': {
-                u'Key': u'Value'},
-            u'method': u'testMethod/DoThis',
-            u'id': 1}
+        baseline = BASELINE_REQUEST
         response = test_client.get_response(request_id=1)
         self.assertEqual(response, baseline)
         test_client.shutdown()