def test_workflow_workflow_get_version():
global v1_hits, v2_hits
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
worker.register_workflow_implementation_type(TestWorkflowGetVersionImplV1)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestWorkflowGetVersion = client.new_workflow_stub(
TestWorkflowGetVersion)
client.start(workflow.get_greetings)
while v1_hits == 0:
print(".", end="")
sleep(2)
worker.register_workflow_implementation_type(TestWorkflowGetVersionImplV2)
while not v2_done:
print(".", end="")
sleep(2)
assert v1_hits == 1
assert v2_hits == 1
assert version_found_in_v2_step_1_0 == DEFAULT_VERSION
assert version_found_in_v2_step_1_1 == DEFAULT_VERSION
assert version_found_in_v2_step_2_0 == DEFAULT_VERSION
assert version_found_in_v2_step_2_1 == DEFAULT_VERSION
# TODO: Assert that there are no markers recorded
print("Stopping workers")
worker.stop(background=True)
def test_query_workflow():
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
worker.register_workflow_implementation_type(TestQueryWorkflowImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestQueryWorkflow = client.new_workflow_stub(TestQueryWorkflow)
workflow_ec = WorkflowClient.start(workflow.get_greetings)
assert workflow.get_message() == "initial-message"
workflow.put_message("second-message")
assert workflow.get_message() == "second-message"
with pytest.raises(QueryFailureException) as exc_info:
workflow.get_message_fail()
ex = exc_info.value
assert isinstance(ex.__cause__, GreetingException)
workflow.put_message("done")
client.wait_for_close(workflow_ec)
assert workflow.get_message() == "done"
print("Stopping workers")
worker.stop()
def test_current_time():
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
worker.register_workflow_implementation_type(TestCurrentTimeImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestCurrentTime = client.new_workflow_stub(TestCurrentTime)
workflow.get_greetings()
assert len(timestamps["checkpoint-1"]) >= 3
assert len(timestamps["checkpoint-2"]) >= 2
assert len(timestamps["checkpoint-3"]) >= 1
for checkpoint, values in timestamps.items():
assert all(v == values[0] for v in values)
assert (timestamps["checkpoint-2"][0] -
timestamps["checkpoint-1"][0]).total_seconds() > 20
assert (timestamps["checkpoint-3"][0] -
timestamps["checkpoint-2"][0]).total_seconds() > 30
print("Stopping workers")
worker.stop()
def test_workflow_logger():
reset_counter_filter_counter()
logging.config.dictConfig(LOGGING)
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
worker.register_workflow_implementation_type(TestWorkflowLoggerImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestWorkflowLogger = client.new_workflow_stub(TestWorkflowLogger)
workflow.get_greetings()
assert get_counter_filter_counter() == 5
print("Stopping workers")
worker.stop()
def test_sleep_workflow():
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
worker.register_workflow_implementation_type(TestSleepWorkflowImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestSleepWorkflow = client.new_workflow_stub(TestSleepWorkflow)
start_time = time.time()
workflow.get_greetings()
end_time = time.time()
assert end_time - start_time > 50
print("Stopping workers")
worker.stop()
def test_heartbeat_workflow():
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
activities_impl = GreetingActivitiesImpl()
worker.register_activities_implementation(activities_impl, "GreetingActivities")
worker.register_workflow_implementation_type(TestHeartbeatWorkflowImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestHeartbeatWorkflow = client.new_workflow_stub(TestHeartbeatWorkflow)
workflow.get_greetings("Bob")
assert activities_impl.details == [None, 1, 2]
assert activities_impl.invocation_count == 3
print("Stopping workers")
worker.stop()
def test_signal_workflow():
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
worker.register_workflow_implementation_type(TestSignalWorkflowImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestSignalWorkflow = client.new_workflow_stub(TestSignalWorkflow)
execution = WorkflowClient.start(workflow.get_greetings)
sleep(randint(0, 20))
workflow.wait_for_name("Bob")
sleep(randint(0, 20))
workflow.exit()
sleep(randint(0, 20))
result = client.wait_for_close(execution)
worker.stop()
assert result == ["Hello Bob!"]
def test_register_workflow_implementation_type(self):
factory = WorkerFactory("localhost", 7933, "sample")
worker: Worker = factory.new_worker("python-tasklist")
worker.register_workflow_implementation_type(DummyWorkflowImpl)
self.assertIn("DummyWorkflow::method_annotated_plain",
worker.workflow_methods)
self.assertIn("DummyWorkflow::methodAnnotatedPlain",
worker.workflow_methods)
self.assertIn("DummyWorkflow::method_annotated_decorator_call",
worker.workflow_methods)
self.assertIn("DummyWorkflow::methodAnnotatedDecoratorCall",
worker.workflow_methods)
self.assertIn("NAME", worker.workflow_methods)
(cls, fn) = worker.workflow_methods.get(
"DummyWorkflow::method_annotated_plain")
self.assertEqual(DummyWorkflowImpl, cls)
self.assertEqual(fn, DummyWorkflowImpl.method_annotated_plain)
def test_workflow_workflow_get_version_single():
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
worker.register_workflow_implementation_type(TestWorkflowGetVersionSingleImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestWorkflowGetVersionSingle = client.new_workflow_stub(TestWorkflowGetVersionSingle)
workflow.get_greetings()
assert version_found_in_step_1_0 == 2
assert version_found_in_step_1_1 == 2
assert version_found_in_step_2_0 == 2
assert version_found_in_step_2_1 == 2
# TODO: Assert that there is only a single marker recorded
print("Stopping workers")
worker.stop(background=True)
def test_workflow_activity_exception():
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
activities_impl = GreetingActivitiesImpl()
worker.register_activities_implementation(activities_impl, "GreetingActivities")
worker.register_workflow_implementation_type(TestActivityExceptionWorkflowImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestActivityExceptionWorkflow = client.new_workflow_stub(TestActivityExceptionWorkflow)
workflow_ex = None
try:
workflow.get_greetings("Bob")
except Exception as ex:
workflow_ex = ex
assert isinstance(workflow_ex, WorkflowFailureException)
assert isinstance(workflow_ex.__cause__, ActivityFailureException)
assert isinstance(workflow_ex.__cause__.__cause__, ComposeGreetingException)
assert exception_caught
assert isinstance(exception_caught, ActivityFailureException)
assert isinstance(exception_caught.get_cause(), ComposeGreetingException)
exception_caught.set_cause()
cause = exception_caught.__cause__
assert isinstance(cause, ComposeGreetingException)
assert cause.args == ("Failed to compose greeting",)
tb = "".join(traceback.format_exception(type(cause), cause, cause.__traceback__))
assert "SOURCE OF EXCEPTION" in tb
tb = "".join(traceback.format_exception(type(exception_caught), exception_caught, exception_caught.__traceback__))
assert "SOURCE OF EXCEPTION" in tb
assert "WORKFLOW METHOD INVOKING ACTIVITY" in tb
tb = "".join(traceback.format_exception(type(workflow_ex), workflow_ex, workflow_ex.__traceback__))
assert "SOURCE OF EXCEPTION" in tb
assert "WORKFLOW METHOD INVOKING ACTIVITY" in tb
print("Stopping workers")
worker.stop()
def test_await_condition_no_timeout():
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
worker.register_workflow_implementation_type(TestAwaitTimeoutWorkflowImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestAwaitTimeoutWorkflow = client.new_workflow_stub(
TestAwaitTimeoutWorkflow)
execution = WorkflowClient.start(workflow.get_greetings_no_timeout)
time.sleep(10)
workflow.wait_for_name("Bob")
result = client.wait_for_close(execution)
assert result is True
print("Stopping workers")
worker.stop()
def test_stub_workflow_id():
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
worker.register_workflow_implementation_type(TestStubWorkflowIdImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestStubWorkflowId = client.new_workflow_stub(TestStubWorkflowId)
context = WorkflowClient.start(workflow.get_greetings)
stub: TestStubWorkflowId = client.new_workflow_stub_from_workflow_id(
TestStubWorkflowId, workflow_id=context.workflow_execution.workflow_id)
stub.put_message("abc")
assert stub.get_message() == "abc"
stub.put_message("done")
assert client.wait_for_close_with_workflow_id(
context.workflow_execution.workflow_id) == "finished"
print("Stopping workers")
worker.stop()
def test_workflow_random():
checkpoint_values.clear()
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
worker.register_workflow_implementation_type(TestRandomWorkflowImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestRandomWorkflow = client.new_workflow_stub(TestRandomWorkflow)
workflow.get_greetings()
# Verify that the value is always the same at each checkpoint
for checkpoint, values in checkpoint_values.items():
assert all(v == values[0] for v in values)
# Verify that each checkpoint produced a unique value
values = [v[0] for k, v in checkpoint_values.items()]
assert len(set(values)) == 9
print("Stopping workers")
worker.stop()
def test_activity_context():
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
worker.register_activities_implementation(GreetingActivitiesImpl(),
"GreetingActivities")
worker.register_workflow_implementation_type(TestActivityContextImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
workflow: TestActivityContext = client.new_workflow_stub(
TestActivityContext)
workflow.get_greetings("Bob")
global task_token, workflow_execution, domain
assert task_token is not None
assert workflow_execution is not None
assert workflow_execution.workflow_id is not None
assert workflow_execution.run_id is not None
assert domain is not None
assert domain == DOMAIN
print("Stopping workers")
worker.stop()
async def get_greeting(self, name: str) -> str:
raise NotImplementedError
# Workflow Implementation
class GreetingWorkflowImpl(GreetingWorkflow):
def __init__(self):
self.greeting_activities: GreetingActivities = Workflow.new_activity_stub(
GreetingActivities)
async def get_greeting(self, name):
return await self.greeting_activities.compose_greeting("Hello", name)
if __name__ == '__main__':
factory = WorkerFactory("localhost", 7933, DOMAIN)
worker = factory.new_worker(TASK_LIST)
worker.register_activities_implementation(GreetingActivitiesImpl(),
"GreetingActivities")
worker.register_workflow_implementation_type(GreetingWorkflowImpl)
factory.start()
client = WorkflowClient.new_client(domain=DOMAIN)
greeting_workflow: GreetingWorkflow = client.new_workflow_stub(
GreetingWorkflow)
result = greeting_workflow.get_greeting("Python")
print(result)
print("Stopping workers....")
worker.stop()
print("Workers stopped...")
import logging
from cadence.workerfactory import WorkerFactory
logging.basicConfig(level=logging.DEBUG)
class GreetingActivitiesImpl:
def compose_greeting(self, greeting: str, name: str):
# raise Exception("Error from Python")
return greeting + " " + name + "!"
if __name__ == "__main__":
factory = WorkerFactory("localhost", 7933, "sample")
worker = factory.new_worker("python-tasklist")
worker.register_activities_implementation(GreetingActivitiesImpl(),
"GreetingActivities")
factory.start()
