Format review on tests

Author: tcalmant

tests/test_cgi.py

@@ -17,8 +17,8 @@
 try:
     from http.server import HTTPServer, CGIHTTPRequestHandler
 except ImportError:
-    from BaseHTTPServer import HTTPServer
-    from CGIHTTPServer import CGIHTTPRequestHandler
+    from BaseHTTPServer import HTTPServer  # type: ignore
+    from CGIHTTPServer import CGIHTTPRequestHandler  # type: ignore
 
 # JSON-RPC library
 from jsonrpclib import ServerProxy
@@ -57,9 +57,9 @@ def test_server(self):
 
             # Check call
             for _ in range(2):
-                a, b = random.random(), random.random()
-                result = client.add(a, b)
-                self.assertEqual(result, a + b)
+                rand1, rand2 = random.random(), random.random()
+                result = client.add(rand1, rand2)
+                self.assertEqual(result, rand1 + rand2)
 
             # Close server
             server.shutdown()

tests/test_compatibility.py

@@ -6,15 +6,15 @@
 :license: Apache License 2.0
 """
 
-# Tests utilities
-from tests.utilities import UtilityServer
+# Standard library
+import json
+import unittest
 
 # JSON-RPC library
 import jsonrpclib
 
-# Standard library
-import json
-import unittest
+# Tests utilities
+from tests.utilities import UtilityServer
 
 # ------------------------------------------------------------------------------
 
@@ -23,18 +23,20 @@ class TestCompatibility(unittest.TestCase):
     """
     Tests JSON-RPC compatibility
     """
+
     def setUp(self):
         """
         Pre-test set up
         """
         # Set up the server
-        self.server = UtilityServer().start('', 0)
+        self.server = UtilityServer().start("", 0)
         self.port = self.server.get_port()
 
         # Set up the client
         self.history = jsonrpclib.history.History()
         self.client = jsonrpclib.ServerProxy(
-            'http://localhost:{0}'.format(self.port), history=self.history)
+            "http://localhost:{0}".format(self.port), history=self.history
+        )
 
     def tearDown(self):
         """
@@ -56,12 +58,12 @@ def test_positional(self):
         request = json.loads(self.history.request)
         response = json.loads(self.history.response)
         verify_request = {
-            "jsonrpc": "2.0", "method": "subtract",
-            "params": [42, 23], "id": request['id']
-        }
-        verify_response = {
-            "jsonrpc": "2.0", "result": 19, "id": request['id']
+            "jsonrpc": "2.0",
+            "method": "subtract",
+            "params": [42, 23],
+            "id": request["id"],
         }
+        verify_response = {"jsonrpc": "2.0", "result": 19, "id": request["id"]}
         self.assertTrue(request == verify_request)
         self.assertTrue(response == verify_response)
 
@@ -74,13 +76,12 @@ def test_named(self):
         request = json.loads(self.history.request)
         response = json.loads(self.history.response)
         verify_request = {
-            "jsonrpc": "2.0", "method": "subtract",
+            "jsonrpc": "2.0",
+            "method": "subtract",
             "params": {"subtrahend": 23, "minuend": 42},
-            "id": request['id']
-        }
-        verify_response = {
-            "jsonrpc": "2.0", "result": 19, "id": request['id']
+            "id": request["id"],
         }
+        verify_response = {"jsonrpc": "2.0", "result": 19, "id": request["id"]}
         self.assertTrue(request == verify_request)
         self.assertTrue(response == verify_response)
 
@@ -91,106 +92,123 @@ def test_notification(self):
         request = json.loads(self.history.request)
         response = self.history.response
         verify_request = {
-            "jsonrpc": "2.0", "method": "update", "params": [1, 2, 3, 4, 5]
+            "jsonrpc": "2.0",
+            "method": "update",
+            "params": [1, 2, 3, 4, 5],
         }
-        verify_response = ''
+        verify_response = ""
         self.assertTrue(request == verify_request)
         self.assertTrue(response == verify_response)
 
     def test_non_existent_method(self):
+        """ Testing behaviour when calling a non-existent method """
         self.assertRaises(jsonrpclib.ProtocolError, self.client.foobar)
         request = json.loads(self.history.request)
         response = json.loads(self.history.response)
         verify_request = {
-            "jsonrpc": "2.0", "method": "foobar", "id": request['id']
+            "jsonrpc": "2.0",
+            "method": "foobar",
+            "id": request["id"],
         }
         verify_response = {
             "jsonrpc": "2.0",
-            "error":
-                {"code": -32601, "message": response['error']['message']},
-            "id": request['id']
+            "error": {"code": -32601, "message": response["error"]["message"]},
+            "id": request["id"],
         }
         self.assertTrue(request == verify_request)
         self.assertTrue(response == verify_response)
 
     def test_special_method(self):
-        self.assertRaises(AttributeError, getattr, self.client, '__special_method__')
+        """ Tests behaviour on dunder methods """
+        self.assertRaises(
+            AttributeError, getattr, self.client, "__special_method__"
+        )
         self.assertIsNone(self.history.request)
 
     def test_invalid_json(self):
-        invalid_json = '{"jsonrpc": "2.0", "method": "foobar, ' + \
-            '"params": "bar", "baz]'
+        """ Tests behaviour on invalid JSON request """
+        invalid_json = (
+            '{"jsonrpc": "2.0", "method": "foobar, ' + '"params": "bar", "baz]'
+        )
         self.client._run_request(invalid_json)
         response = json.loads(self.history.response)
         verify_response = json.loads(
-            '{"jsonrpc": "2.0", "error": {"code": -32700,' +
-            ' "message": "Parse error."}, "id": null}'
+            '{"jsonrpc": "2.0", "error": {"code": -32700,'
+            + ' "message": "Parse error."}, "id": null}'
         )
-        verify_response['error']['message'] = response['error']['message']
+        verify_response["error"]["message"] = response["error"]["message"]
         self.assertTrue(response == verify_response)
 
     def test_invalid_request(self):
+        """ Tests incomplete request """
         invalid_request = '{"jsonrpc": "2.0", "method": 1, "params": "bar"}'
         self.client._run_request(invalid_request)
         response = json.loads(self.history.response)
         verify_response = json.loads(
-            '{"jsonrpc": "2.0", "error": {"code": -32600, ' +
-            '"message": "Invalid Request."}, "id": null}'
+            '{"jsonrpc": "2.0", "error": {"code": -32600, '
+            + '"message": "Invalid Request."}, "id": null}'
         )
-        verify_response['error']['message'] = response['error']['message']
+        verify_response["error"]["message"] = response["error"]["message"]
         self.assertTrue(response == verify_response)
 
     def test_batch_invalid_json(self):
-        invalid_request = '[ {"jsonrpc": "2.0", "method": "sum", ' + \
-            '"params": [1,2,4], "id": "1"},{"jsonrpc": "2.0", "method" ]'
+        """ Tests invalid JSON request on batch call """
+        invalid_request = (
+            '[ {"jsonrpc": "2.0", "method": "sum", '
+            + '"params": [1,2,4], "id": "1"},{"jsonrpc": "2.0", "method" ]'
+        )
         self.client._run_request(invalid_request)
         response = json.loads(self.history.response)
         verify_response = json.loads(
-            '{"jsonrpc": "2.0", "error": {"code": -32700,' +
-            '"message": "Parse error."}, "id": null}'
+            '{"jsonrpc": "2.0", "error": {"code": -32700,'
+            + '"message": "Parse error."}, "id": null}'
         )
-        verify_response['error']['message'] = response['error']['message']
+        verify_response["error"]["message"] = response["error"]["message"]
         self.assertTrue(response == verify_response)
 
     def test_empty_array(self):
-        invalid_request = '[]'
+        """ Tests empty array as request """
+        invalid_request = "[]"
         self.client._run_request(invalid_request)
         response = json.loads(self.history.response)
         verify_response = json.loads(
-            '{"jsonrpc": "2.0", "error": {"code": -32600, ' +
-            '"message": "Invalid Request."}, "id": null}'
+            '{"jsonrpc": "2.0", "error": {"code": -32600, '
+            + '"message": "Invalid Request."}, "id": null}'
         )
-        verify_response['error']['message'] = response['error']['message']
+        verify_response["error"]["message"] = response["error"]["message"]
         self.assertTrue(response == verify_response)
 
     def test_nonempty_array(self):
-        invalid_request = '[1,2]'
+        """ Tests array as request """
+        invalid_request = "[1,2]"
         request_obj = json.loads(invalid_request)
         self.client._run_request(invalid_request)
         response = json.loads(self.history.response)
         self.assertTrue(len(response) == len(request_obj))
         for resp in response:
             verify_resp = json.loads(
-                '{"jsonrpc": "2.0", "error": {"code": -32600, ' +
-                '"message": "Invalid Request."}, "id": null}'
+                '{"jsonrpc": "2.0", "error": {"code": -32600, '
+                + '"message": "Invalid Request."}, "id": null}'
             )
-            verify_resp['error']['message'] = resp['error']['message']
+            verify_resp["error"]["message"] = resp["error"]["message"]
             self.assertTrue(resp == verify_resp)
 
     def test_batch(self):
+        """ Tests batch call """
         multicall = jsonrpclib.MultiCall(self.client)
         multicall.sum(1, 2, 4)
         multicall._notify.notify_hello(7)
         multicall.subtract(42, 23)
-        multicall.foo.get(name='myself')
+        multicall.foo.get(name="myself")
         multicall.get_data()
         job_requests = [j.request() for j in multicall._job_list]
         job_requests.insert(3, '{"foo": "boo"}')
-        json_requests = '[%s]' % ','.join(job_requests)
+        json_requests = "[%s]" % ",".join(job_requests)
         requests = json.loads(json_requests)
         responses = self.client._run_request(json_requests)
 
-        verify_requests = json.loads("""[
+        verify_requests = json.loads(
+            """[
             {"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"},
             {"jsonrpc": "2.0", "method": "notify_hello", "params": [7]},
             {"jsonrpc": "2.0", "method": "subtract",
@@ -199,10 +217,12 @@ def test_batch(self):
             {"jsonrpc": "2.0", "method": "foo.get",
              "params": {"name": "myself"}, "id": "5"},
             {"jsonrpc": "2.0", "method": "get_data", "id": "9"}
-        ]""")
+        ]"""
+        )
 
         # Thankfully, these are in order so testing is pretty simple.
-        verify_responses = json.loads("""[
+        verify_responses = json.loads(
+            """[
             {"jsonrpc": "2.0", "result": 7, "id": "1"},
             {"jsonrpc": "2.0", "result": 19, "id": "2"},
             {"jsonrpc": "2.0",
@@ -212,51 +232,50 @@ def test_batch(self):
              "error": {"code": -32601, "message": "Method not found."},
              "id": "5"},
             {"jsonrpc": "2.0", "result": ["hello", 5], "id": "9"}
-        ]""")
+        ]"""
+        )
 
         self.assertTrue(len(requests) == len(verify_requests))
         self.assertTrue(len(responses) == len(verify_responses))
 
         responses_by_id = {}
         response_i = 0
 
-        for i in range(len(requests)):
-            verify_request = verify_requests[i]
-            request = requests[i]
+        for verify_request, request in zip(verify_requests, requests):
             response = None
-            if request.get('method') != 'notify_hello':
-                req_id = request.get('id')
-                if 'id' in verify_request:
-                    verify_request['id'] = req_id
+            if request.get("method") != "notify_hello":
+                req_id = request.get("id")
+                if "id" in verify_request:
+                    verify_request["id"] = req_id
                 verify_response = verify_responses[response_i]
-                verify_response['id'] = req_id
+                verify_response["id"] = req_id
                 responses_by_id[req_id] = verify_response
                 response_i += 1
                 response = verify_response
             self.assertTrue(request == verify_request)
 
         for response in responses:
-            verify_response = responses_by_id.get(response.get('id'))
-            if 'error' in verify_response:
-                verify_response['error']['message'] = \
-                    response['error']['message']
+            verify_response = responses_by_id.get(response.get("id"))
+            if "error" in verify_response:
+                verify_response["error"]["message"] = response["error"][
+                    "message"
+                ]
             self.assertTrue(response == verify_response)
 
     def test_batch_notifications(self):
+        """ Tests batch notifications """
         multicall = jsonrpclib.MultiCall(self.client)
         multicall._notify.notify_sum(1, 2, 4)
         multicall._notify.notify_hello(7)
         result = multicall()
         self.assertTrue(len(result) == 0)
         valid_request = json.loads(
-            '[{"jsonrpc": "2.0", "method": "notify_sum", ' +
-            '"params": [1,2,4]},{"jsonrpc": "2.0", ' +
-            '"method": "notify_hello", "params": [7]}]'
+            '[{"jsonrpc": "2.0", "method": "notify_sum", '
+            + '"params": [1,2,4]},{"jsonrpc": "2.0", '
+            + '"method": "notify_hello", "params": [7]}]'
         )
         request = json.loads(self.history.request)
         self.assertTrue(len(request) == len(valid_request))
-        for i in range(len(request)):
-            req = request[i]
-            valid_req = valid_request[i]
+        for req, valid_req in zip(request, valid_request):
             self.assertTrue(req == valid_req)
-        self.assertTrue(self.history.response == '')
+        self.assertTrue(self.history.response == "")