def test_memoryview_defines_hash(valid_bytes_128):
"""
Assert that the `hash` representation of a :class:`~ulid.ulid.MemoryView` is equal to the
hash result of the underlying :class:`~memoryview.`
"""
mv = ulid.MemoryView(valid_bytes_128)
assert hash(mv) == hash(mv.memory)
def test_memoryview_supports_getstate(valid_bytes_128):
"""
Assert that the `__getstate__` representation of a :class:`~ulid.ulid.MemoryView` is equal to the
str result of the underlying :class:`~memoryview.`
"""
mv = ulid.MemoryView(valid_bytes_128)
assert mv.__getstate__() == mv.str
def test_memoryview_supports_float(valid_bytes_128):
"""
Assert that the `float` representation of a :class:`~ulid.ulid.MemoryView` is equal to the
result of the :meth:`~ulid.ulid.MemoryView.float` method.
"""
mv = ulid.MemoryView(valid_bytes_128)
assert float(mv) == mv.float
def test_memoryview_ne_false_with_unsupported_type(
valid_bytes_128, unsupported_comparison_type):
"""
Assert that :class:`~ulid.ulid.MemoryView` returns `True` on "not equal" comparisons
against unsupported types.
"""
assert ulid.MemoryView(valid_bytes_128) != unsupported_comparison_type()
def test_memoryview_supports_index(valid_bytes_128):
"""
Assert that the `__index__` representation of a :class:`~ulid.ulid.MemoryView` is equal to the
int value of the underlying :class:`~memoryview.`
"""
mv = ulid.MemoryView(valid_bytes_128)
assert mv.__index__() == mv.int
def test_memoryview_supports_copy(valid_bytes_128):
"""
Assert that instances of :class:`~ulid.ulid.MemoryView` can be copied using
:func:`~copy.copy`.
"""
mv = ulid.MemoryView(valid_bytes_128)
copied = copy.copy(mv)
assert copied == mv
def test_memoryview_unorderble_with_unsupported_type(valid_bytes_128, unsupported_comparison_type):
"""
Assert that :class:`~ulid.ulid.MemoryView` returns `False` on "less than" comparisons
against unsupported types.
"""
mv = ulid.MemoryView(valid_bytes_128)
for op in (operator.lt, operator.gt, operator.le, operator.ge):
with pytest.raises(TypeError):
op(mv, unsupported_comparison_type())
def test_memoryview_supports_deepcopy(valid_bytes_128):
"""
Assert that instances of :class:`~ulid.ulid.MemoryView` can be copied using
:func:`~copy.deepcopy`.
"""
mv = ulid.MemoryView(valid_bytes_128)
data = dict(a=dict(b=dict(c=mv)))
copied = copy.deepcopy(data)
assert copied == data
def test_model_supports_ge_with_expected_types(model_with_ordered_bytes):
"""
Assert that any of the model types support "greater than or equal" comparisons against expected types.
"""
model_type, less_than_bytes, greater_than_bytes = model_with_ordered_bytes
model = model_type(greater_than_bytes)
assert model >= ulid.MemoryView(greater_than_bytes)
assert model >= bytes(greater_than_bytes)
assert model >= bytearray(greater_than_bytes)
assert model >= memoryview(greater_than_bytes)
assert model >= int.from_bytes(greater_than_bytes, byteorder='big')
assert model >= base32.encode(greater_than_bytes)
assert model >= ulid.MemoryView(less_than_bytes)
assert model >= bytes(less_than_bytes)
assert model >= bytearray(less_than_bytes)
assert model >= memoryview(less_than_bytes)
assert model >= int.from_bytes(less_than_bytes, byteorder='big')
assert model >= base32.encode(less_than_bytes)
def test_memoryview_supports_pickle(valid_bytes_128):
"""
Assert that instances of :class:`~ulid.ulid.MemoryView` can be pickled and use the
the str result of the underlying :class:`~memoryview.` as the serialized value.
"""
mv = ulid.MemoryView(valid_bytes_128)
serialized = pickle.dumps(mv)
assert serialized is not None
assert isinstance(serialized, bytes)
deserialized = pickle.loads(serialized)
assert deserialized == mv.str
def test_model_supports_ne_with_expected_types(model_with_ne_bytes):
"""
Assert that any of the model types supports "not equal" comparisons against expected types.
"""
model_type, equal_bytes, not_equal_bytes = model_with_ne_bytes
model = model_type(equal_bytes)
assert model != ulid.MemoryView(not_equal_bytes)
assert model != bytes(not_equal_bytes)
assert model != bytearray(not_equal_bytes)
assert model != memoryview(not_equal_bytes)
assert model != int.from_bytes(not_equal_bytes, byteorder='big')
assert model != base32.encode(not_equal_bytes)
def test_model_supports_lt_with_expected_types(model_with_ordered_bytes):
"""
Assert that any of the model types support "less than" comparisons against expected types.
"""
model_type, less_than_bytes, greater_than_bytes = model_with_ordered_bytes
model = model_type(less_than_bytes)
assert model < ulid.MemoryView(greater_than_bytes)
assert model < bytes(greater_than_bytes)
assert model < bytearray(greater_than_bytes)
assert model < memoryview(greater_than_bytes)
assert model < int.from_bytes(greater_than_bytes, byteorder='big')
assert model < float(int.from_bytes(greater_than_bytes, byteorder='big'))
assert model < base32.encode(greater_than_bytes)
