def test_returns_zero_when_max_number_of_jobs_are_running(
self, job_poller: JobPoller):
for _ in range(job_poller.task.config.max_running_jobs):
job = random_job()
job_poller.task_state.add(job)
max_jobs_to_activate = job_poller.calculate_max_jobs_to_activate()
assert max_jobs_to_activate == 0
async def test_returns_correct_amount_of_jobs(self,
grpc_servicer: GatewayMock,
task: Task):
active_jobs_count = randint(4, 100)
for _ in range(0, active_jobs_count):
job = random_job(task)
grpc_servicer.active_jobs[job.key] = job
jobs = self.activate_jobs(task_type=task.type)
assert len([job async for job in jobs]) == active_jobs_count
def create_random_task_and_activate(grpc_servicer,
task_type: str = None) -> str:
if task_type:
mock_task_type = task_type
else:
mock_task_type = str(uuid4())
task = Task(task_type=mock_task_type,
task_handler=lambda x: x,
exception_handler=lambda x: x)
job = random_job(task)
grpc_servicer.active_jobs[job.key] = job
return mock_task_type
def test_calculate_max_jobs_to_activate(self, job_poller: JobPoller,
active_jobs: int,
max_running_jobs: int,
max_jobs_to_activate_on_task: int,
expected: int):
job_poller.task.config.max_running_jobs = max_running_jobs
job_poller.task.config.max_jobs_to_activate = max_jobs_to_activate_on_task
for _ in range(active_jobs):
job = random_job()
job_poller.task_state.add(job)
max_jobs_to_activate = job_poller.calculate_max_jobs_to_activate()
assert max_jobs_to_activate == expected
def test_add_after_plus_constructor():
def constructor_decorator(x):
return x
def function_decorator(x):
return x
job = random_job()
assert constructor_decorator(job) == job
assert function_decorator(job) == job
base_decorator = ZeebeDecoratorBase(after=[constructor_decorator])
base_decorator.after(function_decorator)
assert len(base_decorator._after) == 2
assert base_decorator._after == [constructor_decorator, function_decorator]
def CreateProcessInstance(self, request, context):
if request.bpmnProcessId in self.deployed_processes.keys():
for task in self.deployed_processes[
request.bpmnProcessId]["tasks"]:
job = random_job(task)
self.active_jobs[job.key] = job
process_instance_key = randint(0, RANDOM_RANGE)
self.active_processes[process_instance_key] = request.bpmnProcessId
return CreateProcessInstanceResponse(
processDefinitionKey=randint(0, RANDOM_RANGE),
bpmnProcessId=request.bpmnProcessId,
version=request.version,
processInstanceKey=process_instance_key)
else:
context.set_code(grpc.StatusCode.NOT_FOUND)
return CreateProcessInstanceResponse()
def test_add_before_plus_constructor():
def constructor_decorator(x):
return x
def function_decorator(x):
return x
job = random_job()
assert constructor_decorator(job) == job
assert function_decorator(job) == job
base_decorator = ZeebeDecoratorBase(before=[constructor_decorator])
base_decorator.before(function_decorator)
assert len(base_decorator._before) == 2
assert base_decorator._before == [
constructor_decorator, function_decorator
]
def CreateWorkflowInstance(self, request, context):
if request.bpmnProcessId in self.deployed_workflows.keys():
for task in self.deployed_workflows[
request.bpmnProcessId]["tasks"]:
job = random_job(task)
self.active_jobs[job.key] = job
workflow_instance_key = randint(0, RANDOM_RANGE)
self.active_workflows[
workflow_instance_key] = request.bpmnProcessId
return CreateWorkflowInstanceResponse(
workflowKey=randint(0, RANDOM_RANGE),
bpmnProcessId=request.bpmnProcessId,
version=request.version,
workflowInstanceKey=workflow_instance_key)
else:
context.set_code(grpc.StatusCode.NOT_FOUND)
return CreateWorkflowInstanceResponse()
def job_from_task(task):
job = random_job(task)
job.variables = dict(x=str(uuid4()))
return job
def job_without_adapter():
return random_job()
def job_with_adapter(zeebe_adapter):
return random_job(zeebe_adapter=zeebe_adapter)
