def server(domain_path, test_mode):
"""Run Async Background Server"""
# FIXME Accept MAX_WORKERS as command-line input as well
from protean.server import Engine
domain = derive_domain(domain_path)
if not domain:
raise NoDomainException(
"Could not locate a Protean domain. You should provide a domain in"
'"PROTEAN_DOMAIN" environment variable or pass a domain file in options '
'and a "domain.py" module was not found in the current directory.')
engine = Engine(domain, test_mode=test_mode)
engine.run()
async def test_that_an_event_handler_can_be_associated_with_an_all_stream(test_domain):
test_domain.register(User)
test_domain.register(Registered)
test_domain.register(UserEventHandler, aggregate_cls=User)
identifier = str(uuid4())
user = User(
id=identifier,
email="*****@*****.**",
name="John Doe",
password_hash="hash",
)
event = Registered(
id=identifier,
email="*****@*****.**",
name="John Doe",
password_hash="hash",
)
message = Message.to_aggregate_event_message(user, event)
engine = Engine(domain=test_domain, test_mode=True)
await engine.handle_message(UserEventHandler, message)
global counter
assert counter == 1
async def test_that_subscription_invokes_engine_handler_on_message(
mock_handle_message, test_domain):
test_domain.register(User)
test_domain.register(UserEventHandler, aggregate_cls=User)
identifier = str(uuid4())
user = User(
id=identifier,
email="*****@*****.**",
name="John Doe",
password_hash="hash",
)
event = Registered(
id=identifier,
email="*****@*****.**",
name="John Doe",
password_hash="hash",
)
current_domain.event_store.store.append_aggregate_event(user, event)
engine = Engine(test_domain, test_mode=True)
subscription = Subscription(engine, fully_qualified_name(UserEventHandler),
"user", UserEventHandler)
await subscription.poll()
mock_handle_message.assert_called_once_with(UserEventHandler,
TypeMatcher(Message))
async def test_that_any_message_can_be_handled_with_any_handler(test_domain):
test_domain.register(User)
test_domain.register(Registered)
test_domain.register(Post)
test_domain.register(Created)
test_domain.register(SystemMetrics)
identifier = str(uuid4())
registered = Registered(
id=identifier,
email="*****@*****.**",
name="John Doe",
password_hash="hash",
)
user = User(**registered.to_dict())
message1 = Message.to_aggregate_event_message(user, registered)
post_identifier = str(uuid4())
created = Created(id=post_identifier, topic="Foo", content="Bar")
post = Post(**created.to_dict())
test_domain.event_store.store.append_aggregate_event(post, created)
message2 = Message.to_aggregate_event_message(post, created)
engine = Engine(domain=test_domain, test_mode=True)
await engine.handle_message(SystemMetrics, message1)
await engine.handle_message(SystemMetrics, message2)
global counter
assert counter == 2
def test_event_subscriptions(test_domain):
test_domain.register(UserEventHandler, aggregate_cls=User)
engine = Engine(test_domain, test_mode=True)
assert len(engine._subscriptions) == 1
assert fqn(UserEventHandler) in engine._subscriptions
assert engine._subscriptions[fqn(UserEventHandler)].stream_name == "user"
def test_origin_stream_name_in_subscription(test_domain):
test_domain.register(EmailEventHandler,
aggregate_cls=User,
source_stream="email")
engine = Engine(test_domain, test_mode=True)
assert len(engine._subscriptions) == 1
assert engine._subscriptions[fqn(EmailEventHandler)].stream_name == "user"
assert engine._subscriptions[fqn(
EmailEventHandler)].origin_stream_name == "email"
def test_that_stream_name_overrides_the_derived_stream_name_from_aggregate_cls(
test_domain, ):
test_domain.register(
EmailEventHandler,
aggregate_cls=User,
stream_name="identity",
source_stream="email",
)
engine = Engine(test_domain, test_mode=True)
assert len(engine._subscriptions) == 1
assert engine._subscriptions[fqn(
EmailEventHandler)].stream_name == "identity"
assert engine._subscriptions[fqn(
EmailEventHandler)].origin_stream_name == "email"
async def test_handler_invocation(test_domain):
test_domain.register(User)
test_domain.register(Register)
test_domain.register(Activate)
test_domain.register(UserCommandHandler, aggregate_cls=User)
identifier = str(uuid4())
command = Register(
user_id=identifier,
email="*****@*****.**",
)
message = Message.to_command_message(command)
engine = Engine(domain=test_domain, test_mode=True)
await engine.handle_message(UserCommandHandler, message)
global counter
assert counter == 1
async def test_message_filtering_for_event_handlers_with_defined_origin_stream(
test_domain, ):
test_domain.register(UserEventHandler, aggregate_cls=User)
test_domain.register(EmailEventHandler,
stream_name="email",
source_stream="user")
engine = Engine(test_domain, test_mode=True)
email_event_handler_subscription = engine._subscriptions[fqn(
EmailEventHandler)]
identifier = str(uuid4())
user = User(id=identifier, email="*****@*****.**", name="John Doe")
email = Email(id=identifier, email="*****@*****.**")
# Construct 3 dummy messages and modify Sent message to have originated from the user stream
messages = [
Message.to_aggregate_event_message(
user,
Registered(id=identifier,
email="*****@*****.**",
name="John Doe")),
Message.to_aggregate_event_message(
user, Activated(id=identifier, activated_at=datetime.utcnow())),
Message.to_aggregate_event_message(
email, Sent(email="*****@*****.**",
sent_at=datetime.utcnow())),
]
messages[2].metadata.origin_stream_name = f"user-{identifier}"
# Mock `read` method and have it return the 3 messages
mock_store_read = mock.Mock()
mock_store_read.return_value = messages
email_event_handler_subscription.store.read = mock_store_read
filtered_messages = (
await email_event_handler_subscription.get_next_batch_of_messages())
assert len(filtered_messages) == 1
assert filtered_messages[0].type == fqn(Sent)
def engine(test_domain):
return Engine(test_domain, test_mode=True)