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"))
