make client_test and heartbeat_test compatible with client properties class

Author: mdumandag

tests/client_test.py

@@ -1,7 +1,7 @@
 import time
 
 from tests.base import HazelcastTestCase
-from hazelcast.config import ClientConfig, PROPERTY_HEARTBEAT_INTERVAL
+from hazelcast.config import ClientConfig, ClientProperties
 from hazelcast.client import HazelcastClient
 from hazelcast.lifecycle import LIFECYCLE_STATE_DISCONNECTED
 
@@ -22,7 +22,7 @@ def test_client_only_listens(self):
         member = cluster.start_member()
 
         client_config = ClientConfig()
-        client_config._properties[PROPERTY_HEARTBEAT_INTERVAL] = 1000
+        client_config.set_property(ClientProperties.HEARTBEAT_INTERVAL.name, 1000)
 
         client1 = HazelcastClient(client_config)
 

tests/heartbeat_test.py

@@ -1,7 +1,7 @@
 from hazelcast import HazelcastClient
 from hazelcast.core import Address
 from tests.base import HazelcastTestCase
-from hazelcast.config import ClientConfig, PROPERTY_HEARTBEAT_INTERVAL, PROPERTY_HEARTBEAT_TIMEOUT
+from hazelcast.config import ClientConfig, ClientProperties
 from tests.util import configure_logging
 
 
@@ -20,8 +20,8 @@ def setUp(self):
         self.member = self.rc.startMember(self.cluster.id)
         self.config = ClientConfig()
 
-        self.config._properties[PROPERTY_HEARTBEAT_INTERVAL] = 500
-        self.config._properties[PROPERTY_HEARTBEAT_TIMEOUT] = 2000
+        self.config.set_property(ClientProperties.HEARTBEAT_INTERVAL.name, 500)
+        self.config.set_property(ClientProperties.HEARTBEAT_TIMEOUT.name, 2000)
 
         self.client = HazelcastClient(self.config)
 
@@ -31,7 +31,14 @@ def tearDown(self):
 
     def test_heartbeat_stopped(self):
 
-        self.client.cluster.add_listener(member_added=lambda m: self.client.connection_manager.get_or_connect(m.address))
+        def member_added_func(m):
+            def connection_callback(f):
+                conn = f.result()
+                self.simulate_heartbeat_lost(self.client, Address(conn._address[0], conn._address[1]), 2)
+
+            self.client.connection_manager.get_or_connect(m.address).add_done_callback(connection_callback)
+
+        self.client.cluster.add_listener(member_added=member_added_func)
 
         def heartbeat_stopped_collector():
             connections = []
@@ -42,32 +49,6 @@ def connection_collector(c):
             connection_collector.connections = connections
             return connection_collector
 
-        collector = heartbeat_stopped_collector()
-
-        self.client.heartbeat.add_listener(on_heartbeat_stopped=collector)
-
-        member2 = self.rc.startMember(self.cluster.id)
-        self.simulate_heartbeat_lost(self.client, Address(member2.host, member2.port), 2)
-
-        def assert_heartbeat_stopped():
-            self.assertEqual(1, len(collector.connections))
-            connection = collector.connections[0]
-            self.assertEqual(connection._address, (member2.host, member2.port))
-
-        self.assertTrueEventually(assert_heartbeat_stopped)
-
-    def test_heartbeat_restored(self):
-
-        def member_added_func(m):
-
-            def connection_callback(f):
-                conn = f.result()
-                self.simulate_heartbeat_lost(self.client, Address(conn._address[0], conn._address[1]), 2)
-
-            self.client.connection_manager.get_or_connect(m.address).add_done_callback(connection_callback)
-
-        self.client.cluster.add_listener(member_added=member_added_func)
-
         def heartbeat_restored_collector():
             connections = []
 
@@ -77,18 +58,23 @@ def connection_collector(c):
             connection_collector.connections = connections
             return connection_collector
 
-        collector = heartbeat_restored_collector()
+        stopped_collector = heartbeat_stopped_collector()
+        restored_collector = heartbeat_restored_collector()
 
-        self.client.heartbeat.add_listener(on_heartbeat_restored=collector)
+        self.client.heartbeat.add_listener(on_heartbeat_stopped=stopped_collector,
+                                           on_heartbeat_restored=restored_collector)
 
         member2 = self.rc.startMember(self.cluster.id)
 
-        def assert_heartbeat_restored():
-            self.assertEqual(1, len(collector.connections))
-            connection = collector.connections[0]
-            self.assertEqual(connection._address, (member2.host, member2.port))
+        def assert_heartbeat_stopped_and_restored():
+            self.assertEqual(1, len(stopped_collector.connections))
+            self.assertEqual(1, len(restored_collector.connections))
+            connection_stopped = stopped_collector.connections[0]
+            connection_restored = restored_collector.connections[0]
+            self.assertEqual(connection_stopped._address, (member2.host, member2.port))
+            self.assertEqual(connection_restored._address, (member2.host, member2.port))
 
-        self.assertTrueEventually(assert_heartbeat_restored)
+        self.assertTrueEventually(assert_heartbeat_stopped_and_restored)
 
     @staticmethod
     def simulate_heartbeat_lost(client, address, timeout):