Lint tests

pyproject.toml

@@ -15,6 +15,5 @@ exclude = '''
 
   | benchmarks
   | hazelcast/protocol/codec
-  | tests
 )/
 '''

tests/__init__.py

@@ -2,12 +2,15 @@
 import subprocess
 
 try:
-    output = subprocess.check_output(["git", "show", "-s", "--format=\"%h\""]).decode()
-    commit_id = output.strip().replace("\"", "").replace("'", "")
+    output = subprocess.check_output(["git", "show", "-s", '--format="%h"']).decode()
+    commit_id = output.strip().replace('"', "").replace("'", "")
 except:
     commit_id = ""
 
 logging.basicConfig(
-    format='%(asctime)s%(msecs)03d [' + commit_id + '][%(threadName)s][%(name)s] %(levelname)s: %(message)s',
-    datefmt="%H:%M:%S,")
+    format="%(asctime)s%(msecs)03d ["
+    + commit_id
+    + "][%(threadName)s][%(name)s] %(levelname)s: %(message)s",
+    datefmt="%H:%M:%S,",
+)
 logging.getLogger().setLevel(logging.INFO)

tests/address_test.py

@@ -18,7 +18,9 @@ def test_v4_address_without_port(self):
         self._validate_without_port(self.v4_address, self.v4_address)
 
     def test_v6_address_with_port(self):
-        self._validate_with_port("[" + self.v6_address + "]:" + str(self.port), self.v6_address, self.port)
+        self._validate_with_port(
+            "[" + self.v6_address + "]:" + str(self.port), self.v6_address, self.port
+        )
 
     def test_v6_address_without_port(self):
         self._validate_without_port(self.v6_address, self.v6_address)

tests/base.py

@@ -39,7 +39,7 @@ def __init__(self, methodName):
 
     @staticmethod
     def create_rc():
-        return HzRemoteController('127.0.0.1', 9701)
+        return HzRemoteController("127.0.0.1", 9701)
 
     @classmethod
     def create_cluster(cls, rc, config=None):
@@ -79,8 +79,16 @@ def assertSetEventually(self, event, timeout=5):
         is_set = event.wait(timeout)
         self.assertTrue(is_set, "Event was not set within %d seconds" % timeout)
 
-    def assertEntryEvent(self, event, event_type, key=None, value=None, old_value=None, merging_value=None,
-                         number_of_affected_entries=1):
+    def assertEntryEvent(
+        self,
+        event,
+        event_type,
+        key=None,
+        value=None,
+        old_value=None,
+        merging_value=None,
+        number_of_affected_entries=1,
+    ):
 
         self.assertEqual(event.key, key)
         self.assertEqual(event.event_type, event_type)
@@ -107,6 +115,7 @@ class SingleMemberTestCase(HazelcastTestCase):
     """
     Test cases where a single member - client combination is needed
     """
+
     rc = None
     client = None
 

tests/client_message_test.py

@@ -6,9 +6,21 @@
 from hazelcast.connection import _Reader
 from hazelcast.errors import _ErrorsCodec
 from hazelcast.protocol import ErrorHolder
-from hazelcast.protocol.builtin import CodecUtil, FixSizedTypesCodec, ByteArrayCodec, DataCodec, EntryListCodec, \
-    StringCodec, EntryListUUIDListIntegerCodec, EntryListUUIDLongCodec, ListMultiFrameCodec, ListIntegerCodec, \
-    ListLongCodec, ListUUIDCodec, MapCodec
+from hazelcast.protocol.builtin import (
+    CodecUtil,
+    FixSizedTypesCodec,
+    ByteArrayCodec,
+    DataCodec,
+    EntryListCodec,
+    StringCodec,
+    EntryListUUIDListIntegerCodec,
+    EntryListUUIDLongCodec,
+    ListMultiFrameCodec,
+    ListIntegerCodec,
+    ListLongCodec,
+    ListUUIDCodec,
+    MapCodec,
+)
 from hazelcast.protocol.client_message import *
 from hazelcast.protocol.codec import client_authentication_codec
 from hazelcast.protocol.codec.custom.error_holder_codec import ErrorHolderCodec
@@ -144,9 +156,15 @@ def test_entry_list(self):
         EntryListCodec.encode_nullable(self.buf, None, StringCodec.encode, StringCodec.encode, True)
         message = self.write_and_decode()
         message.next_frame()  # initial frame
-        self.assertEqual(entries, EntryListCodec.decode(message, StringCodec.decode, StringCodec.decode))
-        self.assertEqual(entries, EntryListCodec.decode_nullable(message, StringCodec.decode, StringCodec.decode))
-        self.assertIsNone(EntryListCodec.decode_nullable(message, StringCodec.decode, StringCodec.decode))
+        self.assertEqual(
+            entries, EntryListCodec.decode(message, StringCodec.decode, StringCodec.decode)
+        )
+        self.assertEqual(
+            entries, EntryListCodec.decode_nullable(message, StringCodec.decode, StringCodec.decode)
+        )
+        self.assertIsNone(
+            EntryListCodec.decode_nullable(message, StringCodec.decode, StringCodec.decode)
+        )
 
     def test_uuid_integer_list_entry_list(self):
         self.mark_initial_frame_as_non_final()
@@ -200,8 +218,12 @@ def test_list(self):
         self.assertEqual(l, ListMultiFrameCodec.decode(message, StringCodec.decode))
         self.assertEqual(l, ListMultiFrameCodec.decode_nullable(message, StringCodec.decode))
         self.assertIsNone(ListMultiFrameCodec.decode_nullable(message, StringCodec.decode))
-        self.assertEqual(l, ListMultiFrameCodec.decode_contains_nullable(message, StringCodec.decode))
-        self.assertEqual([None], ListMultiFrameCodec.decode_contains_nullable(message, StringCodec.decode))
+        self.assertEqual(
+            l, ListMultiFrameCodec.decode_contains_nullable(message, StringCodec.decode)
+        )
+        self.assertEqual(
+            [None], ListMultiFrameCodec.decode_contains_nullable(message, StringCodec.decode)
+        )
 
     def test_uuid_list(self):
         self.mark_initial_frame_as_non_final()
@@ -223,7 +245,9 @@ def test_map(self):
         message = self.write_and_decode()
         message.next_frame()  # initial frame
         self.assertEqual(m, MapCodec.decode(message, StringCodec.decode, StringCodec.decode))
-        self.assertEqual(m, MapCodec.decode_nullable(message, StringCodec.decode, StringCodec.decode))
+        self.assertEqual(
+            m, MapCodec.decode_nullable(message, StringCodec.decode, StringCodec.decode)
+        )
         self.assertIsNone(MapCodec.decode_nullable(message, StringCodec.decode, StringCodec.decode))
 
     def test_string(self):
@@ -262,8 +286,9 @@ def setUp(self):
         self.builder = ClientMessageBuilder(lambda m: self.counter.increment())
 
     def test_unfragmented_message(self):
-        request = client_authentication_codec.encode_request("dev", "user", "pass", uuid.uuid4(),
-                                                             "PYH", 1, "4.0", "python", [])
+        request = client_authentication_codec.encode_request(
+            "dev", "user", "pass", uuid.uuid4(), "PYH", 1, "4.0", "python", []
+        )
         self.reader.read(request.buf)
         message = self.reader._read_message()
         self.builder.on_message(message)

tests/client_test.py

@@ -11,14 +11,18 @@ def test_client_only_listens(self):
         rc = self.create_rc()
         client_heartbeat_seconds = 8
 
-        cluster_config = """<hazelcast xmlns="http://www.hazelcast.com/schema/config"
+        cluster_config = (
+            """
+        <hazelcast xmlns="http://www.hazelcast.com/schema/config"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://www.hazelcast.com/schema/config
            http://www.hazelcast.com/schema/config/hazelcast-config-4.0.xsd">
             <properties>
                 <property name="hazelcast.client.max.no.heartbeat.seconds">%s</property>
             </properties>
-        </hazelcast>""" % client_heartbeat_seconds
+        </hazelcast>"""
+            % client_heartbeat_seconds
+        )
         cluster = self.create_cluster(rc, cluster_config)
         cluster.start_member()
 
@@ -45,7 +49,7 @@ def event_collector(e):
 
         def message_listener(_):
             pass
-        
+
         topic.add_listener(message_listener)
 
         topic2 = client2.get_topic(key)
@@ -77,29 +81,32 @@ def tearDown(self):
         self.shutdown_all_clients()
 
     def test_default_config(self):
-        client = self.create_client({
-            "cluster_name": self.cluster.id
-        })
+        client = self.create_client({"cluster_name": self.cluster.id})
         self.assertIsNone(self.get_labels_from_member(client._connection_manager.client_uuid))
 
     def test_provided_labels_are_received(self):
-        client = self.create_client({
-            "cluster_name": self.cluster.id,
-            "labels": [
-                "test-label",
-            ]
-        })
-        self.assertEqual(b"test-label", self.get_labels_from_member(client._connection_manager.client_uuid))
+        client = self.create_client(
+            {
+                "cluster_name": self.cluster.id,
+                "labels": [
+                    "test-label",
+                ],
+            }
+        )
+        self.assertEqual(
+            b"test-label", self.get_labels_from_member(client._connection_manager.client_uuid)
+        )
 
     def get_labels_from_member(self, client_uuid):
-        script = """var clients = instance_0.getClientService().getConnectedClients().toArray();
+        script = """
+        var clients = instance_0.getClientService().getConnectedClients().toArray();
         for (i=0; i < clients.length; i++) {
             var client = clients[i];
             if ("%s".equals(client.getUuid().toString())) {
                 result = client.getLabels().iterator().next();
                 break;
             }
-        }
-        """ % str(client_uuid)
+        }""" % str(
+            client_uuid
+        )
         return self.rc.executeOnController(self.cluster.id, script, Lang.JAVASCRIPT).result
-

tests/cluster_test.py

@@ -32,9 +32,7 @@ def member_added(m):
             events.append(m)
 
         config = self.create_config()
-        config["membership_listeners"] = [
-            (member_added, None)
-        ]
+        config["membership_listeners"] = [(member_added, None)]
 
         member = self.cluster.start_member()
 
@@ -109,9 +107,7 @@ def listener(_):
             raise RuntimeError("error")
 
         config = self.create_config()
-        config["membership_listeners"] = [
-            (listener, listener)
-        ]
+        config["membership_listeners"] = [(listener, listener)]
         self.cluster.start_member()
         self.create_client(config)
 
@@ -127,7 +123,9 @@ def test_cluster_service_get_members_with_selector(self):
         config = self.create_config()
         client = self.create_client(config)
 
-        self.assertEqual(0, len(client.cluster_service.get_members(lambda m: member.address != m.address)))
+        self.assertEqual(
+            0, len(client.cluster_service.get_members(lambda m: member.address != m.address))
+        )
 
 
 class _MockClusterService(object):
@@ -237,7 +235,9 @@ def test_when_member_started_with_another_port_and_the_same_uuid(self):
         added_listener = event_collector()
         removed_listener = event_collector()
 
-        self.client.cluster_service.add_listener(member_added=added_listener, member_removed=removed_listener)
+        self.client.cluster_service.add_listener(
+            member_added=added_listener, member_removed=removed_listener
+        )
 
         self.rc.shutdownCluster(self.cluster.id)
         # now stop cluster, restart it with the same name and then start member with port 5702
@@ -267,4 +267,7 @@ def _get_config(self, port):
             <hot-restart-persistence enabled="true">
                 <base-dir>%s</base-dir>
             </hot-restart-persistence>
-        </hazelcast>""" % (port, self.tmp_dir)
+        </hazelcast>""" % (
+            port,
+            self.tmp_dir,
+        )