def test_client_receives_when_server_publish_messages(self): skip_if_client_version_older_than(self, "4.2.1") topic_name = random_string() topic = self.get_topic(topic_name) received_message_count = [0] def listener(message): self.assertIsNotNone(message.member) received_message_count[0] += 1 topic.add_listener(listener) message_count = 10 script = """ var topic = instance_0.getReliableTopic("%s"); for (var i = 0; i < %d; i++) { topic.publish(i); } """ % ( topic_name, message_count, ) self.rc.executeOnController(self.cluster.id, script, Lang.JAVASCRIPT) self.assertTrueEventually( lambda: self.assertEqual(message_count, received_message_count[0]))
def test_big_decimal_from_server(self): skip_if_client_version_older_than(self, "5.0") self.assertTrue( self.set_on_server('new java.math.BigDecimal("12.12")')) self.assertEqual(decimal.Decimal("12.12"), self.map.get("key")) self.assertTrue( self.set_on_server('new java.math.BigDecimal("-13.13")')) self.assertEqual(decimal.Decimal("-13.13"), self.map.get("key")) self.assertTrue( self.set_on_server( 'new java.math.BigDecimal("1234567890123456789012345678901234567890.123456789")' )) self.assertEqual( decimal.Decimal( "1234567890123456789012345678901234567890.123456789"), self.map.get("key"), ) self.assertTrue( self.set_on_server( 'new java.math.BigDecimal("-1234567890123456789012345678901234567890.123456789")' )) self.assertEqual( decimal.Decimal( "-1234567890123456789012345678901234567890.123456789"), self.map.get("key"), )
def test_when_member_started_with_the_same_address(self): skip_if_client_version_older_than(self, "4.2") old_member = self.cluster.start_member() self.client = HazelcastClient(cluster_name=self.cluster.id) members_added = [] members_removed = [] self.client.cluster_service.add_listener( lambda m: members_added.append(m), lambda m: members_removed.append(m)) self.rc.shutdownMember(self.cluster.id, old_member.uuid) new_member = self.cluster.start_member() def assertion(): self.assertEqual(1, len(members_added)) self.assertEqual(new_member.uuid, str(members_added[0].uuid)) self.assertEqual(1, len(members_removed)) self.assertEqual(old_member.uuid, str(members_removed[0].uuid)) self.assertTrueEventually(assertion) members = self.client.cluster_service.get_members() self.assertEqual(1, len(members)) self.assertEqual(new_member.uuid, str(members[0].uuid))
def test_lazy_deserialization(self): skip_if_client_version_older_than(self, "5.0") # Using a Portable that is not defined on the client-side. self._create_mapping_for_portable(666, 1, {}) script = (""" var m = instance_0.getMap("%s"); m.put(1, new com.hazelcast.client.test.Employee(1, "Joe")); """ % self.map_name) res = self.rc.executeOnController(self.cluster.id, script, Lang.JAVASCRIPT) self.assertTrue(res.success) with self.execute('SELECT __key, this FROM "%s"' % self.map_name) as result: rows = list(result) self.assertEqual(1, len(rows)) row = rows[0] # We should be able to deserialize parts of the response self.assertEqual(1, row.get_object("__key")) # We should throw lazily when we try to access the columns # that are not deserializable with self.assertRaises(HazelcastSqlError): row.get_object("this")
def test_datetime_date(self): skip_if_client_version_older_than(self, "5.0") skip_if_server_version_older_than(self, self.client, "5.0") value = datetime.datetime.now().date() self.map.set("key", value) self.assertEqual(value, self.map.get("key")) response = self.get_from_server() self.assertEqual(response, value.strftime("%Y-%m-%d"))
def test_decimal(self): skip_if_client_version_older_than(self, "5.0") decimal_value = "1234567890123456789012345678901234567890.987654321" value = decimal.Decimal(decimal_value) self.map.set("key", value) self.assertEqual(value, self.map.get("key")) response = self.get_from_server() self.assertEqual(decimal_value, response)
def test_local_date_time_from_server(self): skip_if_client_version_older_than(self, "5.0") skip_if_server_version_older_than(self, self.client, "5.0") self.assertTrue( self.set_on_server( "java.time.LocalDateTime.of(2021, 8, 24, 0, 59, 55, 987654000)" )) self.assertEqual(datetime.datetime(2021, 8, 24, 0, 59, 55, 987654), self.map.get("key"))
def test_put_get_large_payload(self): # The fix for reading large payloads is introduced in 4.2.1 # See https://github.com/hazelcast/hazelcast-python-client/pull/436 skip_if_client_version_older_than(self, "4.2.1") payload = bytearray(os.urandom(16 * 1024 * 1024)) start = get_current_timestamp() self.assertIsNone(self.map.put("key", payload)) self.assertEqual(self.map.get("key"), payload) self.assertLessEqual(get_current_timestamp() - start, 5)
def test_offset_date_time_from_server(self): skip_if_client_version_older_than(self, "5.0") skip_if_server_version_older_than(self, self.client, "5.0") self.assertTrue( self.set_on_server( "java.time.OffsetDateTime.of(2021, 8, 24, 0, 59, 55, 987654000, " "java.time.ZoneOffset.ofTotalSeconds(2400))")) self.assertEqual( datetime.datetime( 2021, 8, 24, 0, 59, 55, 987654, datetime.timezone(datetime.timedelta(seconds=2400))), self.map.get("key"), )
def test_remove_interceptor(self): skip_if_client_version_older_than(self, "5.0") interceptor = MapGetInterceptor(":") registration_id = self.map.add_interceptor(interceptor) self.assertIsNotNone(registration_id) self.assertTrue(self.map.remove_interceptor(registration_id)) # Unknown registration id should return False self.assertFalse(self.map.remove_interceptor(registration_id)) # Make sure that the interceptor is indeed removed self.map.set(1, ")") value = self.map.get(1) self.assertEqual(")", value)
def test_rows_as_dict_or_list(self): skip_if_client_version_older_than(self, "5.0") self._create_mapping("VARCHAR") entry_count = 20 def value_factory(v): return "value-%s" % v self._populate_map(entry_count, value_factory) expected = [(i, value_factory(i)) for i in range(entry_count)] with self.execute('SELECT __key, this FROM "%s"' % self.map_name) as result: # Verify that both row[integer] and row[string] works self.assertCountEqual(expected, [(row[0], row["this"]) for row in result])
def test_metrics_blob(self): skip_if_client_version_older_than(self, "4.2.1") map_name = random_string() client = HazelcastClient( cluster_name=self.cluster.id, cluster_connect_timeout=30.0, statistics_enabled=True, statistics_period=self.STATS_PERIOD, near_caches={ map_name: {}, }, ) client_uuid = client._connection_manager.client_uuid client.get_map(map_name).blocking() time.sleep(2 * self.STATS_PERIOD) response = self.wait_for_statistics_collection(client_uuid, get_metric_blob=True) result = bytearray(response.result) # We will try to decompress the blob according to its contract # to verify we have sent something that make sense pos = 2 # Skip the version dict_buf_size = BE_INT.unpack_from(result, pos)[0] pos += INT_SIZE_IN_BYTES dict_buf = result[pos:pos + dict_buf_size] self.assertTrue(len(dict_buf) > 0) pos += dict_buf_size pos += INT_SIZE_IN_BYTES # Skip metric count metrics_buf = result[pos:] self.assertTrue(len(metrics_buf) > 0) # If we are able to decompress it, we count the blob # as valid. zlib.decompress(dict_buf) zlib.decompress(metrics_buf) client.shutdown()
def test_provided_suggestions(self): skip_if_client_version_older_than(self, "5.0") skip_if_server_version_older_than(self, self.client, "5.0") # We don't create a mapping intentionally to get suggestions self.map.put(1, "value-1") select_all_query = 'SELECT * FROM "%s"' % self.map_name with self.assertRaises(HazelcastSqlError) as cm: self.execute(select_all_query) self.execute(cm.exception.suggestion) with self.execute(select_all_query) as result: self.assertEqual( [(1, "value-1")], [(r.get_object("__key"), r.get_object("this")) for r in result], )
def test_datetime_time(self): skip_if_client_version_older_than(self, "5.0") skip_if_server_version_older_than(self, self.client, "5.0") value = datetime.datetime.now() if value.microsecond % 1000 == 0: # A little hack for Windows. Time is precise to the # milliseconds there. If we send the microseconds # we have now, due to trailing zeros, get_from_server() # call below will return the string representation with # 3 digits for the microseconds. But, Python always expects # 6 digits. So, the assertion will fail. To fix that, # we add 1 microseconds to the value, so that in the Java # side, nanoseconds representation will only have 3 trailing # zeros, and will send the data as we want. value = value + datetime.timedelta(microseconds=1) value = value.time() self.map.set("key", value) self.assertEqual(value, self.map.get("key")) response = self.get_from_server() self.assertEqual(response, value.strftime("%H:%M:%S.%f"))
def test_local_time_from_server(self): skip_if_client_version_older_than(self, "5.0") skip_if_server_version_older_than(self, self.client, "5.0") self.assertTrue( self.set_on_server("java.time.LocalTime.of(18, 3, 35)")) self.assertEqual(datetime.time(18, 3, 35), self.map.get("key"))
def test_local_date_from_server(self): skip_if_client_version_older_than(self, "5.0") skip_if_server_version_older_than(self, self.client, "5.0") self.assertTrue( self.set_on_server("java.time.LocalDate.of(2000, 12, 15)")) self.assertEqual(datetime.date(2000, 12, 15), self.map.get("key"))