class TimestampSequencedItemTestCase(ActiveRecordStrategyTestCase):
EXAMPLE_EVENT_TOPIC1 = get_topic(TimestampedEventExample1)
EXAMPLE_EVENT_TOPIC2 = get_topic(TimestampedEventExample2)
def construct_positions(self):
t1 = time()
return t1, t1 + 0.00001, t1 + 0.00002
def construct_item_args(self, domain_event):
"""
Constructs attributes of a sequenced item from the given domain event.
"""
# Construct the topic from the event class.
topic = get_topic(domain_event.__class__)
# Copy the state of the event.
event_attrs = domain_event.__dict__.copy()
# Pop the sequence ID.
sequence_id = event_attrs.pop(self.sequence_id_attr_name)
# Pop the position in the sequence.
position = event_attrs.pop(self.position_attr_name)
# Decide if this event will be encrypted.
is_encrypted = self.is_encrypted(domain_event.__class__)
# Serialise the remaining event attribute values.
data = self.serialize_event_attrs(event_attrs,
is_encrypted=is_encrypted)
# Get the 'other' args.
other_args = tuple(
(getattr(domain_event, name) for name in self.other_attr_names))
return (sequence_id, position, topic, data) + other_args
def test_with_versioned_entity_event(self):
# Setup the mapper, and create an event.
mapper = SequencedItemMapper(sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='originator_version')
entity_id1 = uuid4()
event1 = Event1(originator_id=entity_id1, originator_version=101)
# Check to_sequenced_item() method results in a sequenced item.
sequenced_item = mapper.to_sequenced_item(event1)
self.assertIsInstance(sequenced_item, SequencedItem)
self.assertEqual(sequenced_item.position, 101)
self.assertEqual(sequenced_item.sequence_id, entity_id1)
self.assertEqual(sequenced_item.topic, get_topic(Event1))
self.assertTrue(sequenced_item.data)
# Use the returned values to create a new sequenced item.
sequenced_item_copy = SequencedItem(
sequence_id=sequenced_item.sequence_id,
position=sequenced_item.position,
topic=sequenced_item.topic,
data=sequenced_item.data,
)
# Check from_sequenced_item() returns an event.
domain_event = mapper.from_sequenced_item(sequenced_item_copy)
self.assertIsInstance(domain_event, Event1)
self.assertEqual(domain_event.originator_id, event1.originator_id)
self.assertEqual(domain_event.originator_version,
event1.originator_version)
def take_snapshot(self, entity_id, entity, last_event_version):
"""
Takes a snapshot by instantiating and publishing a Snapshot domain event.
:rtype: Snapshot
"""
# Create the snapshot event.
snapshot = Snapshot(
originator_id=entity_id,
originator_version=last_event_version,
topic=get_topic(entity.__class__),
state=None if entity is None else deepcopy(entity.__dict__))
# Publish the snapshot event.
publish(snapshot)
# Return the snapshot event.
return snapshot
def default(self, obj):
if isinstance(obj, datetime.datetime):
return {'ISO8601_datetime': obj.strftime('%Y-%m-%dT%H:%M:%S.%f%z')}
elif isinstance(obj, datetime.date):
return {'ISO8601_date': obj.isoformat()}
elif isinstance(obj, UUID):
return {'UUID': obj.hex}
elif hasattr(obj, '__class__') and hasattr(obj, '__dict__'):
topic = get_topic(obj.__class__)
state = obj.__dict__.copy()
return {
'__class__': {
'topic': topic,
'state': state,
}
}
# Let the base class default method raise the TypeError.
return JSONEncoder.default(self, obj)
def test_with_timestamped_entity_event(self):
# Setup the mapper, and create an event.
mapper = SequencedItemMapper(sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='timestamp')
before = time()
sleep(
0.000001
) # Avoid test failing due to timestamp having limited precision.
event2 = Event2(originator_id='entity2')
sleep(
0.000001
) # Avoid test failing due to timestamp having limited precision.
after = time()
# Check to_sequenced_item() method results in a sequenced item.
sequenced_item = mapper.to_sequenced_item(event2)
self.assertIsInstance(sequenced_item, SequencedItem)
self.assertGreater(sequenced_item.position, before)
self.assertLess(sequenced_item.position, after)
self.assertEqual(sequenced_item.sequence_id, 'entity2')
self.assertEqual(sequenced_item.topic, get_topic(Event2))
self.assertTrue(sequenced_item.data)
# Use the returned values to create a new sequenced item.
sequenced_item_copy = SequencedItem(
sequence_id=sequenced_item.sequence_id,
position=sequenced_item.position,
topic=sequenced_item.topic,
data=sequenced_item.data,
)
# Check from_sequenced_item() returns an event.
domain_event = mapper.from_sequenced_item(sequenced_item_copy)
self.assertIsInstance(domain_event, Event2)
self.assertEqual(domain_event.originator_id, event2.originator_id)
self.assertEqual(domain_event.timestamp, event2.timestamp)
class IntegerSequencedItemTestCase(ActiveRecordStrategyTestCase):
EXAMPLE_EVENT_TOPIC1 = get_topic(VersionedEventExample1)
EXAMPLE_EVENT_TOPIC2 = get_topic(VersionedEventExample2)
def construct_positions(self):
return 0, 1, 2