def test_no_external_object(self) -> None:
task = f.task(external=None)
stage, context = self.manager.get_current_stage(task)
expected_context = _ExternalDataWorkflowGetStageContext(
external=External(None, {}), workflows={})
self.assertIsNone(stage)
self.assertEqual(expected_context, context)
def set_stage(self, task: Task, client: Client,
context: _ExternalDataWorkflowSetStageContext) -> None:
new_external_data = {
**(context.external.data or {}),
"workflows": {
**context.workflows, self._name: context.stage_name
},
}
new_external = External(context.external.gid, new_external_data)
client.set_external(task, new_external)
def get_current_stage(
self, task: Task
) -> Tuple[Optional[WorkflowStage], _ExternalDataWorkflowGetStageContext]:
external = task.external or External(None, {})
workflows = (external.data or {}).get("workflows", {})
stage_name = workflows.get(self._name)
return (
find_by_name(self._stages, stage_name),
_ExternalDataWorkflowGetStageContext(external, workflows),
)
def expect_set(self, original_workflow_data: Mapping[str, str]) -> None:
external = f.external(data={"workflows": original_workflow_data})
task = f.task(external=external)
client = create_autospec(Client)
context = _ExternalDataWorkflowSetStageContext(external,
original_workflow_data,
"new stage name")
client.set_external.return_value = None
self.manager.set_stage(task, client, context)
client.set_external.assert_called_once_with(
task,
External(
context.external.gid,
{
"workflows": {
"External workflow": "new stage name",
"other workflow": "other stage name",
}
},
),
)
def test_json(self) -> None:
serialized_data = """
{
"string": "abc",
"integer": 1,
"float": 2.3,
"array": [1,2,3],
"object": {"key": "value"}
}
"""
external = External.from_dict({"data": serialized_data})
expected = {
"string": "abc",
"integer": 1,
"float": 2.3,
"array": [1, 2, 3],
"object": {
"key": "value"
},
}
self.assertIsNotNone(external.data)
self.assertDictEqual(external.data, expected) # type: ignore
def test_none(self) -> None:
external = External.from_dict({})
self.assertDictEqual(external.data, {}) # type: ignore
def test_unstructure(self) -> None:
external = External(gid=None, data={})
self.assertDictEqual(external.to_dict(), {"gid": None, "data": "{}"})
def test_missing(self) -> None:
external = External.from_dict({"data": None})
self.assertDictEqual(external.data, {}) # type: ignore
def external(gid: Optional[str] = None,
data: Optional[Mapping[str, Any]] = None) -> External:
return External(gid=gid, data=data or {})
def set_external(self, task: Task, external: External) -> None:
_logger.debug(f"Setting external data to {external} on {task}")
self._client.tasks.update(task.gid, {"external": external.to_dict()})