def test_publish_a_message_to_a_queue(self):
backend = a_backend()
registry = SerializerRegistry(serializer_settings)
sut = QueuePublisher(backend=backend, serializer_registry=registry)
sut.publish("queue", {"some_content": "12345"})
assert_that(backend.publish_to_queue, called().times(1))
def test_inmemory_messaging_backend():
consumer_1 = Consumer(
lambda message: print(f"Hello {message['message']}!"))
consumer_2 = Consumer(
lambda message: print(f"Hello {message['message']} 2!"))
backend = InMemoryMessagingBackend()
registry = SerializerRegistry(serializer_settings)
link_synchronously("somequeue", [consumer_1, consumer_2], registry,
backend)
registry = SerializerRegistry(serializer_settings)
publisher = QueuePublisher(registry, backend=backend)
publisher.publish("somequeue", {"message": "Mary"})
def test_async_consumer(request):
# We'll use the ElasticMQ as backend since it works like a real SQS queue
backend = LocalSQSBackend(host=os.environ.get("SQSHOST"),
port=os.environ.get("SQSPORT"))
queue_name = "testqueue"
# Initialize the queue
queue = MessagingBackendFactory(backend).init_queue(queue_name)
# Delete the queue upon finishing the execution of the test
def teardown():
backend.delete_queue(queue)
request.addfinalizer(teardown)
# Create a consumer that, upon receiving a message, will set
# the variable "value set" to later assert that this value
# has, indeed, been set by the consumer that is running on another thread
state = State()
def set_state(message: Dict) -> None:
state.value_set = message["value"]
consumer = Consumer(on_message=set_state)
registry = SerializerRegistry(serializer_settings)
handler = SimpleMessageDispatcher(consumer, registry, backend=backend)
# Start the consumer loop thread to run the consumer loop in the background
threading.Thread(target=lambda: handler.consume_loop(queue_name),
daemon=True).start()
# Publish a message and...
publisher = QueuePublisher(registry, backend)
publisher.publish(queue_name, {"value": 1})
# ...wait until the value is set
probe = StateProbe(state)
probe.wait()
assert_that(state.value_set, is_(1))
from melange import MessageDispatcher, QueuePublisher
from melange.backends import LocalSQSBackend
from melange.examples.payment_service.consumer import PaymentConsumer
from melange.examples.payment_service.publisher import PaymentPublisher
from melange.examples.payment_service.repository import PaymentRepository
from melange.examples.payment_service.service import PaymentService
from melange.examples.shared import serializer_registry
from melange.serializers import PickleSerializer
if __name__ == "__main__":
serializer = PickleSerializer()
backend = LocalSQSBackend(host=os.environ.get("SQSHOST"),
port=os.environ.get("SQSPORT"))
dispatcher = MessageDispatcher(
serializer_registry,
backend=backend,
)
payment_consumer = PaymentConsumer(
PaymentService(
PaymentRepository(),
PaymentPublisher(
QueuePublisher(serializer_registry, backend=backend)),
))
dispatcher.attach_consumer(payment_consumer)
print("Consuming...")
dispatcher.consume_loop("payment-updates")
import argparse
import os
import uuid
from melange import QueuePublisher
from melange.backends import LocalSQSBackend
from melange.examples.payment_service.events import OrderResponse
from melange.examples.shared import serializer_registry
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description="Triggers an order event for the payment service to collect"
)
parser.add_argument("reference",
type=str,
help="The reference number of the order")
args = parser.parse_args()
order_reponse = OrderResponse(id=str(uuid.uuid4()),
reference=args.reference)
backend = LocalSQSBackend(host=os.environ.get("SQSHOST"),
port=os.environ.get("SQSPORT"))
QueuePublisher(serializer_registry,
backend=backend).publish("payment-updates", order_reponse)
print(f"Order with reference {args.reference} sent.")
from simple_cqrs.domain_event import DomainEvent
from melange import QueuePublisher
from melange.backends import LocalSQSBackend
from melange.serializers import PickleSerializer, SerializerRegistry
class MyTestMessage:
def __init__(self, message: str) -> None:
self.message = message
if __name__ == "__main__":
serializer_settings = {
"serializers": {"pickle": PickleSerializer},
"serializer_bindings": {DomainEvent: "pickle"},
}
serializer_registry = SerializerRegistry(serializer_settings)
backend = LocalSQSBackend(host="localhost", port=9324)
publisher = QueuePublisher(serializer_registry, backend)
message = MyTestMessage("Hello World!")
publisher.publish("melangetutorial-queue", message)
print("Message sent successfully!")