def tearDown(self):
assert_event_handlers_empty()
clear_event_handlers()
try:
del os.environ["DB_URI"]
except KeyError:
pass
def tearDown(self):
assert_event_handlers_empty()
try:
del (os.environ['DB_URI'])
except KeyError:
pass
def tearDown(self):
self.datastore.drop_tables()
self.datastore.drop_connection()
if self.policy is not None:
self.policy.close()
super(TestEventPlayer, self).tearDown()
assert_event_handlers_empty()
def setUp(self):
assert_event_handlers_empty()
contract_valuation_repo = MagicMock(spec=ContractValuationRepository)
contract_valuation_repo.__getitem__.return_value = Mock(
spec=ContractValuation)
market_simulation_repo = MagicMock(spec=MarketSimulationRepository)
market_simulation_repo.__getitem__.return_value = Mock(
spec=MarketSimulation)
call_leafs_repo = MagicMock(spec=CallLeafsRepository)
call_leafs_repo.__getitem__.return_value = Mock(spec=CallLeafs)
call_dependents_repo = MagicMock(spec=CallDependentsRepository)
perturbation_dependencies_repo = MagicMock(
spec=PerturbationDependenciesRepo)
simulated_price_requirements_repo = MagicMock(
spec=SimulatedPriceRequirementsRepo)
self.evaluation_subscriber = EvaluationSubscriber(
contract_valuation_repo=contract_valuation_repo,
call_link_repo=MagicMock(spec=CallLinkRepository),
call_dependencies_repo=MagicMock(spec=CallDependenciesRepository),
call_requirement_repo=MagicMock(spec=CallRequirementRepository),
call_result_repo=MagicMock(spec=CallResultRepository),
simulated_price_repo=MagicMock(spec=SimulatedPriceRepository),
market_simulation_repo=market_simulation_repo,
call_leafs_repo=call_leafs_repo,
call_evaluation_queue=None,
call_dependents_repo=call_dependents_repo,
perturbation_dependencies_repo=perturbation_dependencies_repo,
simulated_price_requirements_repo=simulated_price_requirements_repo
)
def setUp(self):
assert_event_handlers_empty()
# Setup the repo, and a persistence subscriber.
stored_event_repo = PythonObjectsStoredEventRepository()
event_store = EventStore(stored_event_repo=stored_event_repo)
self.repo = CollectionRepo(event_store=event_store)
self.ps = PersistenceSubscriber(event_store=event_store)
def setUp(self):
assert_event_handlers_empty()
# Setup the repo, and a persistence subscriber.
stored_event_repo = PythonObjectsStoredEventRepository()
event_store = EventStore(stored_event_repo=stored_event_repo)
self.repo = CollectionRepo(event_store=event_store)
self.ps = PersistenceSubscriber(event_store=event_store)
def setUp(self):
assert_event_handlers_empty()
market_simulation_repo = MagicMock(spec=MarketSimulationRepository)
market_calibration_repo = MagicMock(spec=MarketCalibrationRepository)
simulated_price_repo = MagicMock(spec=SimulatedPriceRepository)
self.simulation_subscriber = SimulationSubscriber(
market_calibration_repo, market_simulation_repo,
simulated_price_repo)
def setUp(self):
if not self.skip_assert_event_handers_empty:
assert_event_handlers_empty()
# super(ContractValuationTestCase, self).setUp()
scipy.random.seed(1354802735)
self.setup_application()
def tearDown(self):
self.app.terminate()
sleep(1)
self.app.kill()
sleep(1)
self.app.wait()
super(TestFlaskApp, self).tearDown()
assert_event_handlers_empty()
def tearDown(self):
self.app.terminate()
sleep(1)
self.app.kill()
sleep(1)
self.app.wait()
super(TestFlaskApp, self).tearDown()
assert_event_handlers_empty()
def tearDown(self):
# Close the persistence subscriber.
self.persistence_subscriber.close()
super(LogTestCase, self).tearDown()
# Check we finished clean, event handler-wise.
assert_event_handlers_empty()
def tearDown(self):
# Close the persistence subscriber.
self.persistence_subscriber.close()
super(LogTestCase, self).tearDown()
# Check we finished clean, event handler-wise.
assert_event_handlers_empty()
def tearDown(self):
try:
del (os.environ['DB_URI'])
except KeyError:
pass
try:
assert_event_handlers_empty()
finally:
clear_event_handlers()
def tearDown(self):
self.datastore.drop_tables()
self.datastore.drop_connection()
if self.entity_persistence_policy is not None:
self.entity_persistence_policy.close()
if self.snapshot_persistence_policy is not None:
self.snapshot_persistence_policy.close()
super(TestEventPlayer, self).tearDown()
assert_event_handlers_empty()
def setUp(self):
assert_event_handlers_empty()
market_simulation_repo = MagicMock(spec=MarketSimulationRepository)
market_calibration_repo = MagicMock(spec=MarketCalibrationRepository)
simulated_price_repo = MagicMock(spec=SimulatedPriceRepository)
self.simulation_subscriber = SimulationSubscriber(
market_calibration_repo,
market_simulation_repo,
simulated_price_repo
)
def setUp(self):
assert_event_handlers_empty()
self.es = EventStore(PythonObjectsStoredEventRepository())
self.ps = PersistenceSubscriber(self.es)
# self.call_result_repo = CallResultRepo(self.es)
self.call_result_repo = {}
self.call_dependencies_repo = CallDependenciesRepo(self.es)
self.call_dependents_repo = CallDependentsRepo(self.es)
self.call_requirement_repo = CallRequirementRepo(self.es)
self.policy = CallResultPolicy(call_result_repo=self.call_result_repo)
def tearDown(self):
# Unset environment.
try:
del os.environ["DB_URI"]
except KeyError:
pass
try:
assert_event_handlers_empty()
finally:
clear_event_handlers()
def setUp(self):
super(LogTestCase, self).setUp()
# Check we're starting clean, event handler-wise.
assert_event_handlers_empty()
# Setup the persistence subscriber.
self.event_store = EventStore(self.stored_event_repo)
self.persistence_subscriber = PersistenceSubscriber(event_store=self.event_store)
self.log_repo = LogRepo(self.event_store)
def test_subscribe_to_decorator(self):
entity_id1 = uuid4()
event1 = Example.Created(
originator_id=entity_id1,
originator_topic=get_topic(Example),
a=1, b=2
)
event2 = Example.Discarded(
originator_id=entity_id1,
originator_version=1,
)
handler = mock.Mock()
# Check we can assert there are no event handlers subscribed.
assert_event_handlers_empty()
@subscribe_to(Example.Created)
def test_handler(e):
"""Doc string"""
handler(e)
# Check the decorator doesn't mess with the function doc string.
self.assertEqual('Doc string', test_handler.__doc__)
# Check can fail to assert event handlers empty.
self.assertRaises(EventHandlersNotEmptyError, assert_event_handlers_empty)
# Check event is received when published individually.
publish(event1)
handler.assert_called_once_with(event1)
# Check event of wrong type is not received.
handler.reset_mock()
publish(event2)
self.assertFalse(handler.call_count)
# Check a list of events can be filtered.
handler.reset_mock()
publish([event1, event2])
handler.assert_called_once_with(event1)
handler.reset_mock()
publish([event1, event1])
self.assertEqual(2, handler.call_count)
handler.reset_mock()
publish([event2, event2])
self.assertEqual(0, handler.call_count)
_event_handlers.clear()
def tearDown(self):
# Unset environment.
try:
del os.environ["DB_URI"]
except KeyError:
pass
try:
# Shutdown base actor system.
shutdown_actor_system()
finally:
# Clear event handlers.
try:
assert_event_handlers_empty()
finally:
clear_event_handlers()
def test_subscribe_to_decorator(self):
entity_id1 = uuid4()
event = Example.Created(originator_id=entity_id1, a=1, b=2)
handler = mock.Mock()
# Check we can assert there are no event handlers subscribed.
assert_event_handlers_empty()
@subscribe_to(Example.Created)
def test_handler(e):
handler(e)
# Check we can assert there are event handlers subscribed.
self.assertRaises(EventHandlersNotEmptyError, assert_event_handlers_empty)
# Check what happens when an event is published.
publish(event)
handler.assert_called_once_with(event)
def test_subscribe_to_decorator(self):
entity_id1 = uuid4()
event = Example.Created(originator_id=entity_id1, a=1, b=2)
handler = mock.Mock()
# Check we can assert there are no event handlers subscribed.
assert_event_handlers_empty()
@subscribe_to(Example.Created)
def test_handler(e):
handler(e)
# Check we can assert there are event handlers subscribed.
self.assertRaises(EventHandlersNotEmptyError,
assert_event_handlers_empty)
# Check what happens when an event is published.
publish(event)
handler.assert_called_once_with(event)
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 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 test_publish_subscribe_unsubscribe(self):
# Check subscribing event handlers with predicates.
# - when predicate is True, handler should be called
event = mock.Mock()
predicate = mock.Mock()
handler = mock.Mock()
# Check we can assert there are no event handlers subscribed.
assert_event_handlers_empty()
# When predicate is True, handler should be called ONCE.
subscribe(handler=handler, predicate=predicate)
# Check we can assert there are event handlers subscribed.
self.assertRaises(EventHandlersNotEmptyError,
assert_event_handlers_empty)
# Check what happens when an event is published.
publish(event)
predicate.assert_called_once_with(event)
handler.assert_called_once_with(event)
# When predicate is True, after unsubscribing, handler should NOT be called again.
unsubscribe(handler=handler, predicate=predicate)
publish(event)
predicate.assert_called_once_with(event)
handler.assert_called_once_with(event)
# Check we can assert there are no event handlers subscribed.
assert_event_handlers_empty()
# When predicate is False, handler should NOT be called.
predicate = lambda x: False
handler = mock.Mock()
subscribe(handler=handler, predicate=predicate)
publish(event)
self.assertEqual(0, handler.call_count)
# Unsubscribe.
unsubscribe(handler=handler, predicate=predicate)
# Check we can assert there are no event handlers subscribed.
assert_event_handlers_empty()
def test_publish_subscribe_unsubscribe(self):
# Check subscribing event handlers with predicates.
# - when predicate is True, handler should be called
event = mock.Mock()
predicate = mock.Mock()
handler = mock.Mock()
# Check we can assert there are no event handlers subscribed.
assert_event_handlers_empty()
# When predicate is True, handler should be called ONCE.
subscribe(handler=handler, predicate=predicate)
# Check we can assert there are event handlers subscribed.
self.assertRaises(EventHandlersNotEmptyError, assert_event_handlers_empty)
# Check what happens when an event is published.
publish(event)
predicate.assert_called_once_with(event)
handler.assert_called_once_with(event)
# When predicate is True, after unsubscribing, handler should NOT be called again.
unsubscribe(handler=handler, predicate=predicate)
publish(event)
predicate.assert_called_once_with(event)
handler.assert_called_once_with(event)
# Check we can assert there are no event handlers subscribed.
assert_event_handlers_empty()
# When predicate is False, handler should NOT be called.
predicate = lambda x: False
handler = mock.Mock()
subscribe(handler=handler, predicate=predicate)
publish(event)
self.assertEqual(0, handler.call_count)
# Unsubscribe.
unsubscribe(handler=handler, predicate=predicate)
# Check we can assert there are no event handlers subscribed.
assert_event_handlers_empty()
def setUp(self):
assert_event_handlers_empty()
super(ApplicationTestCase, self).setUp()
self.app = get_app()
numpy.random.seed(1354802735)
def setUp(self):
assert_event_handlers_empty()
super(TestFlaskApp, self).setUp()
self.app = self.start_app()
def tearDown(self):
if self.app is not None:
self.app.close()
if not self.skip_assert_event_handers_empty:
assert_event_handlers_empty()
def tearDown(self):
self.simulation_subscriber.close()
assert_event_handlers_empty()
def tearDown(self):
super(ApplicationTestCase, self).tearDown()
self.app.close()
assert_event_handlers_empty()
def setUp(self):
assert_event_handlers_empty()
self.ps = None
def tearDown(self):
self.evaluation_subscriber.close()
assert_event_handlers_empty()
def tearDown(self):
assert_event_handlers_empty()
def tearDown(self):
try:
assert_event_handlers_empty()
except EventHandlersNotEmptyError:
clear_event_handlers()
raise
def setUp(self):
assert_event_handlers_empty()
self.published_events = []
self.subscription = (lambda x: True, lambda x: self.published_events.append(x))
subscribe(*self.subscription)
def tearDown(self):
assert_event_handlers_empty()
def tearDown(self):
self.persistence_subscriber.close()
assert_event_handlers_empty()
def tearDown(self):
if self.ps is not None:
self.ps.close()
assert_event_handlers_empty()
def tearDown(self) -> None:
self.app.close()
super(TestExampleAggregateRoot, self).tearDown()
assert_event_handlers_empty()
def setUp(self):
assert_event_handlers_empty()
super(TestFlaskApp, self).setUp()
self.app = self.start_app()
def test_subscribe_to_decorator(self):
entity_id1 = uuid4()
event1 = Example.Created(originator_id=entity_id1,
originator_topic=get_topic(Example),
a=1,
b=2)
event2 = Example.Discarded(originator_id=entity_id1,
originator_version=1)
handler1 = mock.Mock()
handler2 = mock.Mock()
handler3 = mock.Mock()
# Check we can assert there are no event handlers subscribed.
assert_event_handlers_empty()
# Original style (one event class arg).
@subscribe_to(Example.Created)
def test_handler1(e):
"""Doc string"""
handler1(e)
# Naked style (not called).
@subscribe_to
def test_handler2(e):
"""Doc string"""
handler2(e)
# Multi-event style (many event class args).
@subscribe_to((Example.Created, Example.Discarded))
def test_handler3(e):
"""Doc string"""
handler3(e)
# Check the decorator doesn't mess with the function doc string.
self.assertEqual("Doc string", test_handler1.__doc__)
self.assertEqual("Doc string", test_handler2.__doc__)
self.assertEqual("Doc string", test_handler3.__doc__)
# Check can fail to assert event handlers empty.
self.assertRaises(EventHandlersNotEmptyError,
assert_event_handlers_empty)
# Check event is received when published individually.
publish([event1])
handler1.assert_called_once_with(event1)
handler2.assert_called_once_with(event1)
handler3.assert_called_once_with(event1)
# Check event of wrong type is not received.
handler1.reset_mock()
handler2.reset_mock()
handler3.reset_mock()
publish([event2])
self.assertFalse(handler1.call_count)
handler2.assert_called_once_with(event2)
handler3.assert_called_once_with(event2)
# Check a list of events can be filtered.
handler1.reset_mock()
handler2.reset_mock()
handler3.reset_mock()
publish([event1, event2])
handler1.assert_called_once_with(event1)
self.assertEqual(handler2.call_count, 2)
self.assertEqual(handler3.call_count, 2)
handler1.reset_mock()
handler2.reset_mock()
handler3.reset_mock()
publish([event1, event1])
self.assertEqual(2, handler1.call_count)
self.assertEqual(2, handler2.call_count)
self.assertEqual(2, handler3.call_count)
handler1.reset_mock()
handler2.reset_mock()
handler3.reset_mock()
publish([event2, event2])
self.assertEqual(0, handler1.call_count)
self.assertEqual(2, handler2.call_count)
self.assertEqual(2, handler3.call_count)
clear_event_handlers()
def setUp(self):
assert_event_handlers_empty()
self.ps = None
def tearDown(self):
unsubscribe(*self.subscription)
assert_event_handlers_empty()
def setUp(self) -> None:
assert_event_handlers_empty()
super(TestExampleAggregateRoot, self).setUp()
self.app: ExampleDDDApplication = ExampleDDDApplication(self.datastore)
def tearDown(self):
if self.ps is not None:
self.ps.close()
assert_event_handlers_empty()
def setUp(self) -> None:
assert_event_handlers_empty()
def tearDown(self):
self.ps.close()
assert_event_handlers_empty()
