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, topic_from_domain_class(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 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, topic_from_domain_class(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 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, topic_from_domain_class(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)
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 = decimaltimestamp()
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 = decimaltimestamp()
# Check to_sequenced_item() method results in a sequenced item.
sequenced_item = mapper.item_from_event(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.state)
# 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,
state=sequenced_item.state,
)
# Check from_sequenced_item() returns an event.
domain_event = mapper.event_from_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)
def setUp(self):
super(WithPersistencePolicies, self).setUp()
# Setup the persistence subscriber.
self.entity_event_store = EventStore(
record_manager=self.entity_record_manager,
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='originator_version'
)
)
self.log_event_store = EventStore(
record_manager=self.log_record_manager,
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='timestamp'
)
)
self.snapshot_store = EventStore(
record_manager=self.snapshot_record_manager,
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='originator_version'
)
)
self.integer_sequenced_event_policy = None
if self.entity_event_store is not None:
self.integer_sequenced_event_policy = PersistencePolicy(
event_store=self.entity_event_store,
event_type=VersionedEntity.Event,
)
self.timestamp_sequenced_event_policy = None
if self.log_event_store is not None:
self.timestamp_sequenced_event_policy = PersistencePolicy(
event_store=self.log_event_store,
event_type=Logged,
)
self.snapshot_policy = None
if self.snapshot_store is not None:
self.snapshot_policy = PersistencePolicy(
event_store=self.snapshot_store,
event_type=Snapshot,
)
def test_errors(self):
# Setup the mapper, and create an event.
mapper = SequencedItemMapper(sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='a')
# Create an event with dates and datetimes.
event3 = Event3(
originator_id='entity3',
originator_version=303,
a=Decimal(1.0),
)
# Check to_sequenced_item() method results in a sequenced item.
with self.assertRaises(TypeError):
mapper.to_sequenced_item(event3)
def construct_sqlalchemy_eventstore(
session,
sequenced_item_class=None,
sequence_id_attr_name=None,
position_attr_name=None,
json_encoder_class=None,
json_decoder_class=None,
cipher=None,
record_class=None,
contiguous_record_ids=False,
):
sequenced_item_class = sequenced_item_class or StoredEvent
sequenced_item_mapper = SequencedItemMapper(
sequenced_item_class=sequenced_item_class,
sequence_id_attr_name=sequence_id_attr_name,
position_attr_name=position_attr_name,
json_encoder_class=json_encoder_class,
json_decoder_class=json_decoder_class,
cipher=cipher,
)
factory = SQLAlchemyInfrastructureFactory(
session=session,
integer_sequenced_record_class=record_class or StoredEventRecord,
sequenced_item_class=sequenced_item_class,
contiguous_record_ids=contiguous_record_ids,
)
record_manager = factory.construct_integer_sequenced_record_manager()
event_store = EventStore(
record_manager=record_manager,
sequenced_item_mapper=sequenced_item_mapper,
)
return event_store
def construct_sqlalchemy_eventstore(
session,
sequenced_item_class=StoredEvent,
sequence_id_attr_name=None,
position_attr_name=None,
json_encoder_class=ObjectJSONEncoder,
json_decoder_class=ObjectJSONDecoder,
always_encrypt=False,
cipher=None,
active_record_class=StoredEventRecord,
):
sequenced_item_mapper = SequencedItemMapper(
sequenced_item_class=sequenced_item_class,
sequence_id_attr_name=sequence_id_attr_name,
position_attr_name=position_attr_name,
json_encoder_class=json_encoder_class,
json_decoder_class=json_decoder_class,
always_encrypt=always_encrypt,
cipher=cipher,
)
active_record_strategy = SQLAlchemyActiveRecordStrategy(
session=session,
active_record_class=active_record_class,
sequenced_item_class=sequenced_item_class,
)
event_store = EventStore(
active_record_strategy=active_record_strategy,
sequenced_item_mapper=sequenced_item_mapper,
)
return event_store
def construct_event_store(self):
event_store = EventStore(record_manager=self.factory.
construct_integer_sequenced_record_manager(),
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='originator_version'))
return event_store
def test_errors(self):
# Setup the mapper, and create an event.
mapper = SequencedItemMapper(
sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='a'
)
# Create an event with dates and datetimes.
event3 = Event3(
originator_id='entity3',
originator_version=303,
a=Decimal(1.0),
)
# Check to_sequenced_item() method results in a sequenced item.
with self.assertRaises(TypeError):
mapper.to_sequenced_item(event3)
def test_with_different_types_of_event_attributes(self):
# Setup the mapper, and create an event.
mapper = SequencedItemMapper(
sequenced_item_class=SequencedItem,
sequence_id_attr_name="originator_id",
position_attr_name="a",
)
# Check value objects can be compared ok.
self.assertEqual(ValueObject1("value1"), ValueObject1("value1"))
self.assertNotEqual(ValueObject1("value1"), ValueObject1("value2"))
# Create an event with dates and datetimes.
event3 = Event3(
originator_id="entity3",
originator_version=303,
a=datetime.datetime(2017, 3, 22, 9, 12, 14),
b=datetime.date(2017, 3, 22),
c=uuid4(),
# d=Decimal(1.1),
e=ValueObject1("value1"),
)
# Check to_sequenced_item() method results in a sequenced item.
sequenced_item = mapper.item_from_event(event3)
# 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,
state=sequenced_item.state,
)
# Check from_sequenced_item() returns an event.
domain_event = mapper.event_from_item(sequenced_item_copy)
self.assertIsInstance(domain_event, Event3)
self.assertEqual(domain_event.originator_id, event3.originator_id)
self.assertEqual(domain_event.a, event3.a)
self.assertEqual(domain_event.b, event3.b)
self.assertEqual(domain_event.c, event3.c)
# self.assertEqual(domain_event.d, event3.d)
self.assertEqual(domain_event.e, event3.e)
def construct_event_store(self):
event_store = EventStore(
active_record_strategy=
construct_integer_sequenced_active_record_strategy(
datastore=self.datastore, ),
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='originator_version'))
return event_store
def setup_event_store(self):
super(SnapshottingApplication, self).setup_event_store()
# Setup snapshot store, using datastore session, and SnapshotRecord class.
# Todo: Refactor this into a new create_sqlalchemy_snapshotstore() function.
self.snapshot_store = EventStore(
SQLAlchemyRecordManager(session=self.datastore.session,
record_class=self.snapshot_record_class
or SnapshotRecord),
SequencedItemMapper(sequence_id_attr_name='originator_id',
position_attr_name='originator_version'))
def __init__(self):
self.event_store = EventStore(
record_manager=CassandraRecordManager(
record_class=StoredEventRecord,
sequenced_item_class=StoredEvent),
event_mapper=SequencedItemMapper(sequenced_item_class=StoredEvent,
other_attr_names=()),
)
self.repository = ExampleRepository(event_store=self.event_store)
self.persistence_policy = PersistencePolicy(
event_store=self.event_store, persist_event_type=DomainEvent)
def construct_event_store(self):
event_store = EventStore(
active_record_strategy=
construct_integer_sequenced_active_record_strategy(
datastore=self.datastore, ),
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
event_sequence_id_attr='entity_id',
event_position_attr='entity_version',
))
return event_store
def create_event_store(db) -> EventStore:
record_manager = SQLAlchemyRecordManager(session=db.session,
sequenced_item_class=StoredEvent,
record_class=StoredEventRecord,
application_name="CompanyApp",
contiguous_record_ids=True)
event_mapper = SequencedItemMapper(sequenced_item_class=StoredEvent,
cipher=cipher)
event_store = EventStore(record_manager=record_manager,
event_mapper=event_mapper)
return event_store
def __init__(self):
self.event_store = EventStore(
active_record_strategy=CassandraActiveRecordStrategy(
active_record_class=StoredEventRecord,
sequenced_item_class=StoredEvent,
),
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=StoredEvent,
other_attr_names=(),
))
self.repository = ExampleRepository(event_store=self.event_store, )
self.persistence_policy = PersistencePolicy(self.event_store)
def setUp(self):
super(WithPersistencePolicy, self).setUp()
# Setup the persistence subscriber.
self.versioned_entity_event_store = EventStore(
active_record_strategy=self.
integer_sequence_active_record_strategy,
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
event_sequence_id_attr='entity_id',
event_position_attr='entity_version'))
self.timestamped_entity_event_store = EventStore(
active_record_strategy=self.
timestamp_sequence_active_record_strategy,
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
event_sequence_id_attr='entity_id',
event_position_attr='timestamp'))
self.persistence_policy = CombinedPersistencePolicy(
versioned_entity_event_store=self.versioned_entity_event_store,
timestamped_entity_event_store=self.timestamped_entity_event_store,
)
def construct_sequenced_item_mapper(self, sequenced_item_class, event_sequence_id_attr, event_position_attr,
json_encoder_class=ObjectJSONEncoder, json_decoder_class=ObjectJSONDecoder,
always_encrypt=False, cipher=None):
return SequencedItemMapper(
sequenced_item_class=sequenced_item_class,
sequence_id_attr_name=event_sequence_id_attr,
position_attr_name=event_position_attr,
json_encoder_class=json_encoder_class,
json_decoder_class=json_decoder_class,
always_encrypt=always_encrypt,
cipher=cipher
)
def test_with_different_types_of_event_attributes(self):
# Setup the mapper, and create an event.
mapper = SequencedItemMapper(
sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='a'
)
# Create an event with dates and datetimes.
event3 = Event3(
originator_id='entity3',
originator_version=303,
a=datetime.datetime(2017, 3, 22, 9, 12, 14),
b=datetime.date(2017, 3, 22),
c=uuid4(),
# d=Decimal(1.1),
e=ValueObject1('value1'),
)
# Check to_sequenced_item() method results in a sequenced item.
sequenced_item = mapper.to_sequenced_item(event3)
# 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, Event3)
self.assertEqual(domain_event.originator_id, event3.originator_id)
self.assertEqual(domain_event.a, event3.a)
self.assertEqual(domain_event.b, event3.b)
self.assertEqual(domain_event.c, event3.c)
# self.assertEqual(domain_event.d, event3.d)
self.assertEqual(domain_event.e, event3.e)
def __init__(self):
self.event_store = EventStore(
record_manager=CassandraRecordManager(
record_class=TimeuuidSequencedRecord,
sequenced_item_class=SequencedItem),
event_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
sequence_id_attr_name="originator_id",
position_attr_name="event_id",
),
)
self.repository = EventSourcedRepository(event_store=self.event_store)
self.persistence_policy = PersistencePolicy(
event_store=self.event_store, persist_event_type=DomainEvent)
def __init__(self, datastore):
event_store = EventStore(
record_manager=SQLAlchemyRecordManager(
session=datastore.session,
record_class=IntegerSequencedNoIDRecord),
event_mapper=SequencedItemMapper(
sequence_id_attr_name="originator_id",
position_attr_name="originator_version",
),
)
self.repository = EventSourcedRepository(event_store=event_store)
self.persistence_policy = PersistencePolicy(
persist_event_type=ExampleAggregateRoot.Event,
event_store=event_store)
def __init__(self, datastore):
self.event_store = EventStore(
active_record_strategy=SQLAlchemyActiveRecordStrategy(
datastore=datastore,
active_record_class=SqlStoredEvent,
sequenced_item_class=StoredEvent,
),
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=StoredEvent,
event_sequence_id_attr='entity_id',
event_position_attr='entity_version',
))
self.repository = ExampleRepository(event_store=self.event_store, )
self.persistence_policy = PersistencePolicy(self.event_store)
def __init__(self, session):
self.event_store = EventStore(
record_manager=SQLAlchemyRecordManager(
session=session,
record_class=StoredEventRecord,
sequenced_item_class=StoredEvent,
),
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=StoredEvent,
sequence_id_attr_name='originator_id',
position_attr_name='originator_version',
))
self.repository = ExampleRepository(event_store=self.event_store, )
self.persistence_policy = PersistencePolicy(self.event_store)
def test_with_different_types_of_event_attributes(self):
# Setup the mapper, and create an event.
mapper = SequencedItemMapper(sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='a')
# Create an event with dates and datetimes.
event3 = Event3(
originator_id='entity3',
originator_version=303,
a=datetime.datetime(2017, 3, 22, 9, 12, 14),
b=datetime.date(2017, 3, 22),
c=uuid4(),
# d=Decimal(1.1),
e=ValueObject1('value1'),
)
# Check to_sequenced_item() method results in a sequenced item.
sequenced_item = mapper.to_sequenced_item(event3)
# 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, Event3)
self.assertEqual(domain_event.originator_id, event3.originator_id)
self.assertEqual(domain_event.a, event3.a)
self.assertEqual(domain_event.b, event3.b)
self.assertEqual(domain_event.c, event3.c)
# self.assertEqual(domain_event.d, event3.d)
self.assertEqual(domain_event.e, event3.e)
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, topic_from_domain_class(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)
def setUp(self):
assert_event_handlers_empty()
super(TestEventPlayer, self).setUp()
self.datastore.setup_connection()
self.datastore.setup_tables()
# Setup an event store for version entity events.
self.version_entity_event_store = EventStore(
active_record_strategy=SQLAlchemyActiveRecordStrategy(
datastore=self.datastore,
active_record_class=SqlIntegerSequencedItem,
sequenced_item_class=SequencedItem,
),
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
event_sequence_id_attr='entity_id',
event_position_attr='entity_version',
),
)
# Setup an event store for timestamp entity events.
self.timestamp_entity_event_store = EventStore(
active_record_strategy=SQLAlchemyActiveRecordStrategy(
datastore=self.datastore,
active_record_class=SqlTimestampSequencedItem,
sequenced_item_class=SequencedItem,
),
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
event_sequence_id_attr='entity_id',
event_position_attr='timestamp',
),
)
self.policy = None
def setUp(self):
assert_event_handlers_empty()
super(TestEventPlayer, self).setUp()
self.datastore.setup_connection()
self.datastore.setup_tables()
# Setup an event store for versioned entity events.
self.entity_event_store = EventStore(
active_record_strategy=SQLAlchemyActiveRecordStrategy(
session=self.datastore.session,
active_record_class=IntegerSequencedItemRecord,
sequenced_item_class=SequencedItem,
),
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='originator_version',
),
)
# Setup an event store for snapshots.
self.snapshot_store = EventStore(
active_record_strategy=SQLAlchemyActiveRecordStrategy(
session=self.datastore.session,
active_record_class=SnapshotRecord,
sequenced_item_class=SequencedItem,
),
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='originator_version',
),
)
self.entity_persistence_policy = None
self.snapshot_persistence_policy = None
def __init__(self):
self.event_store = EventStore(
record_manager=CassandraRecordManager(
record_class=TimeuuidSequencedRecord,
sequenced_item_class=SequencedItem,
),
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
sequence_id_attr_name='originator_id',
position_attr_name='event_id',
)
)
self.repository = EventSourcedRepository(
event_store=self.event_store,
)
self.persistence_policy = PersistencePolicy(self.event_store)
def __init__(self, datastore):
event_store = EventStore(
record_manager=SQLAlchemyRecordManager(
session=datastore.session, record_class=IntegerSequencedNoIDRecord
),
event_mapper=SequencedItemMapper(
sequence_id_attr_name="originator_id",
position_attr_name="originator_version",
),
)
# Todo: Remove having two repositories, because they are identical.
self.aggregate1_repository = AggregateRepository(event_store=event_store)
self.aggregate2_repository = AggregateRepository(event_store=event_store)
self.persistence_policy = PersistencePolicy(
persist_event_type=ExampleAggregateRoot.Event, event_store=event_store
)
def __init__(self):
self.event_store = EventStore(
active_record_strategy=CassandraActiveRecordStrategy(
active_record_class=CqlTimeuuidSequencedItem,
sequenced_item_class=SequencedItem,
),
sequenced_item_mapper=SequencedItemMapper(
sequenced_item_class=SequencedItem,
event_sequence_id_attr='entity_id',
event_position_attr='event_id',
))
self.repository = EventSourcedRepository(
mutator=ExampleEntity.mutate,
event_store=self.event_store,
)
self.persistence_policy = PersistencePolicy(self.event_store)
def __init__(self, datastore):
event_store = EventStore(record_manager=SQLAlchemyRecordManager(
session=datastore.session,
record_class=IntegerSequencedNoIDRecord,
),
sequenced_item_mapper=SequencedItemMapper(
sequence_id_attr_name='originator_id',
position_attr_name='originator_version',
))
self.aggregate1_repository = AggregateRepository(
event_store=event_store, )
self.aggregate2_repository = AggregateRepository(
event_store=event_store, )
self.persistence_policy = PersistencePolicy(
event_type=ExampleAggregateRoot.Event,
event_store=event_store,
)
def __init__(self, datastore):
event_store = EventStore(
active_record_strategy=SQLAlchemyActiveRecordStrategy(
session=datastore.session,
active_record_class=IntegerSequencedItemRecord,
),
sequenced_item_mapper=SequencedItemMapper(
sequence_id_attr_name='originator_id',
position_attr_name='originator_version',
))
self.aggregate_repository = EventSourcedRepository(
mutator=ExampleAggregateRoot._mutate,
event_store=event_store,
)
self.persistence_policy = PersistencePolicy(
event_type=ExampleAggregateRoot.Event,
event_store=event_store,
)
import uuid
from eventsourcing.infrastructure.sequenceditemmapper import SequencedItemMapper
from eventsourcing.infrastructure.eventsourcedrepository import EventSourcedRepository
from eventsourcing.infrastructure.eventstore import EventStore
from eventsourcing.infrastructure.sequenceditem import StoredEvent
from eventsourcing.infrastructure.sqlalchemy.datastore import SQLAlchemyDatastore, SQLAlchemySettings
from eventsourcing.infrastructure.sqlalchemy.manager import SQLAlchemyRecordManager
from eventsourcing.infrastructure.sqlalchemy.records import StoredEventRecord
datastore = SQLAlchemyDatastore(
tables=(StoredEventRecord, ),
settings=SQLAlchemySettings(uri='sqlite:///mydatabase'))
datastore.setup_connection()
datastore.setup_tables()
recordmanager = SQLAlchemyRecordManager(session=datastore.session,
record_class=StoredEventRecord,
application_name=uuid.uuid4().hex,
contiguous_record_ids=True,
sequenced_item_class=StoredEvent)
sequenceitemmapper = SequencedItemMapper(sequenced_item_class=StoredEvent)
eventstore = EventStore(record_manager=recordmanager,
sequenced_item_mapper=sequenceitemmapper)
repository = EventSourcedRepository(event_store=eventstore)