hazelcast-python-client/tests/unit/serialization/serializers_test.py at ef76da2a8b1c4a26db617c20ef548461f1b3c2c6 · hazelcast/hazelcast-python-client · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
# coding=utf-8
import datetime
import decimal
import unittest
import uuid

from hazelcast.core import HazelcastJsonValue
from hazelcast.config import Config
from hazelcast.errors import HazelcastSerializationError
from hazelcast.serialization import BE_INT
from hazelcast.predicate import *
from hazelcast.serialization.service import SerializationServiceV1


class A:
    def __init__(self, x):
        self.x = x

    def __eq__(self, other):
        return isinstance(other, A) and self.x == other.x

    def __ne__(self, other):
        return not self.__eq__(other)


class SerializersTest(unittest.TestCase):
    def setUp(self):
        self.service = SerializationServiceV1(Config())

    def tearDown(self):
        self.service.destroy()

    def test_integer(self):
        self.validate(14)
        self.validate(-14)

    def test_float(self):
        self.validate(545.3)
        self.validate(-545.3)

    def test_large_int_raises(self):
        with self.assertRaises(HazelcastSerializationError):
            self.validate(1 << 63)

    def test_bool(self):
        self.validate(True)
        self.validate(False)

    def test_string(self):
        self.validate("")
        self.validate("client")
        self.validate("1⚐中💦2😭‍🙆😔5")
        self.validate("Iñtërnâtiônàlizætiøn")
        self.validate("\u0040\u0041\u01df\u06a0\u12e0\u1d30")

    def test_bytearray(self):
        self.validate(bytearray("abc".encode()))

    def test_none(self):
        self.validate(None)

    def test_hazelcast_json_value(self):
        self.validate(HazelcastJsonValue('{"abc": "abc", "five": 5}'))

    def test_uuid(self):
        self.validate(uuid.uuid4())

    def test_datetime_datetime(self):
        d = datetime.datetime.now(tz=datetime.timezone(datetime.timedelta(hours=-15)))
        serialized = self.service.to_data(d)
        deserialized = self.service.to_object(serialized)
        self.assertEqual(d, deserialized)

    def test_datetime_date(self):
        d = datetime.datetime.now().date()
        serialized = self.service.to_data(d)
        deserialized = self.service.to_object(serialized)
        self.assertEqual(d, deserialized)

    def test_datetime_time(self):
        d = datetime.datetime.now().time()
        serialized = self.service.to_data(d)
        deserialized = self.service.to_object(serialized)
        self.assertEqual(d, deserialized)

    def test_decimal(self):
        d = decimal.Decimal("-123456.789")
        serialized = self.service.to_data(d)
        deserialized = self.service.to_object(serialized)
        self.assertEqual(d, deserialized)

    def test_list(self):
        self.validate([1, 2.0, "a", None, bytearray("abc".encode()), [], [1, 2, 3]])

    def test_python_object(self):
        self.validate(A(123))

    def test_predicates(self):
        self.validate_predicate(sql("test"))
        self.validate_predicate(and_(true(), true()))
        self.validate_predicate(between("this", 0, 1))
        self.validate_predicate(equal("this", 10))
        self.validate_predicate(greater("this", 10))
        self.validate_predicate(greater_or_equal("this", 10))
        self.validate_predicate(less("this", 10))
        self.validate_predicate(less_or_equal("this", 10))
        self.validate_predicate(like("this", "*"))
        self.validate_predicate(ilike("this", "*"))
        self.validate_predicate(in_("this", 10, 11, 12))
        self.validate_predicate(instance_of("java.lang.Serializable"))
        self.validate_predicate(not_equal("this", 10))
        self.validate_predicate(not_(true()))
        self.validate_predicate(or_(true(), true()))
        self.validate_predicate(regex("this", "/abc/"))
        self.validate_predicate(true())
        self.validate_predicate(false())

    def validate(self, value):
        serialized = self.service.to_data(value)
        deserialized = self.service.to_object(serialized)
        self.assertEqual(value, deserialized)

    def validate_predicate(self, predicate):
        serialized = self.service.to_data(predicate)
        self.assertEqual(-2, serialized.get_type())  # Identified
        b = serialized.buffer
        # 4(partition hash) + 4(serializer type) + 1(is_identified) + 4(factory id) + 4(class id) + payload(if any)
        self.assertTrue(len(b) >= 17)
        self.assertEqual(predicate.get_factory_id(), BE_INT.unpack_from(b, 9)[0])
        self.assertEqual(predicate.get_class_id(), BE_INT.unpack_from(b, 13)[0])