async def test_deprecate_transformation_revision_from_component_dto(
async_test_client, clean_test_db_engine
):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
ComponentRevisionFrontendDto(
**dto_json_component_2
).to_transformation_revision()
)
async with async_test_client as ac:
response = await ac.put(
"/api/components/" + str(get_uuid_from_seed("component 2")),
json=dto_json_component_2_deprecate,
)
assert response.status_code == 201
assert response.json()["state"] == "DISABLED"
assert response.json()["name"] != "new name"
assert response.json()["category"] != "Test"
assert len(response.json()["inputs"]) == 0
assert "new comment" not in response.json()["code"]
assert "disabled_timestamp" in response.json()["code"]
assert "released_timestamp" in response.json()["code"]
async def test_update_transformation_revision_with_invalid_name_workflow(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
TransformationRevision(**tr_json_workflow_2))
tr_json_workflow_2_update_invalid_name = deepcopy(
tr_json_workflow_2_update)
tr_json_workflow_2_update_invalid_name["name"] = "'"
async with async_test_client as ac:
response = await ac.put(
posix_urljoin("/api/transformations/",
str(get_uuid_from_seed("workflow 2"))),
json=tr_json_workflow_2_update_invalid_name,
)
print(response.json())
assert response.status_code == 422
assert "string does not match regex" in response.json(
)["detail"][0]["msg"]
assert "name" in response.json()["detail"][0]["loc"]
def test_updating(clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
tr_uuid = get_uuid_from_seed("test_updating")
tr_object = TransformationRevision(
id=tr_uuid,
revision_group_id=tr_uuid,
name="Test",
description="Test description",
version_tag="1.0.0",
category="Test category",
state=State.DRAFT,
type=Type.COMPONENT,
content="code",
io_interface=IOInterface(),
test_wiring=WorkflowWiring(),
documentation="",
)
store_single_transformation_revision(tr_object)
tr_object.name = "Test Update"
update_or_create_single_transformation_revision(tr_object)
received_tr_object = read_single_transformation_revision(tr_uuid)
assert tr_object == received_tr_object
async def test_execute_for_workflow_dto(async_test_client,
clean_test_db_engine):
patched_session = sessionmaker(clean_test_db_engine)
with mock.patch(
"hetdesrun.persistence.dbservice.nesting.Session",
patched_session,
):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
patched_session,
):
component_dto = ComponentRevisionFrontendDto(
**dto_json_component_1)
tr_component = component_dto.to_transformation_revision()
tr_component.content = update_code(tr_component)
store_single_transformation_revision(tr_component)
tr_workflow_2 = WorkflowRevisionFrontendDto(
**dto_json_workflow_2_update).to_transformation_revision()
tr_workflow_2.content.inputs[0].name = "wf_input"
tr_workflow_2.content.outputs[0].name = "wf_output"
tr_workflow_2.content.links.append(
Link(
start=Vertex(
operator=None,
connector=Connector.from_io(
tr_workflow_2.content.inputs[0]),
),
end=Vertex(
operator=tr_workflow_2.content.operators[0].id,
connector=tr_workflow_2.content.operators[0].inputs[0],
),
))
tr_workflow_2.content.links.append(
Link(
start=Vertex(
operator=tr_workflow_2.content.operators[0].id,
connector=tr_workflow_2.content.operators[0].
outputs[0],
),
end=Vertex(
operator=None,
connector=Connector.from_io(
tr_workflow_2.content.outputs[0]),
),
))
tr_workflow_2.io_interface.inputs[0].name = "wf_input"
tr_workflow_2.io_interface.outputs[0].name = "wf_output"
store_single_transformation_revision(tr_workflow_2)
update_or_create_nesting(tr_workflow_2)
async with async_test_client as ac:
response = await ac.post(
"/api/workflows/" + str(get_uuid_from_seed("workflow 2")) +
"/execute",
json=dto_json_wiring,
)
assert response.status_code == 200
assert "output_types_by_output_name" in response.json()
async def create_transformation_revision(
transformation_revision: TransformationRevision,
) -> TransformationRevision:
"""Store a transformation revision in the data base."""
logger.info("create transformation revision %s", transformation_revision.id)
if transformation_revision.type == Type.COMPONENT:
logger.debug("transformation revision has type %s", Type.COMPONENT)
transformation_revision.content = update_code(transformation_revision)
logger.debug("generated code:\n%s", transformation_revision.content)
try:
store_single_transformation_revision(transformation_revision)
logger.info("created transformation revision")
except DBIntegrityError as e:
raise HTTPException(status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e)) from e
try:
persisted_transformation_revision = read_single_transformation_revision(
transformation_revision.id
)
except DBNotFoundError as e:
raise HTTPException(status.HTTP_404_NOT_FOUND, detail=str(e)) from e
logger.debug(persisted_transformation_revision.json())
return persisted_transformation_revision
async def test_publish_transformation_revision_from_workflow_dto(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
WorkflowRevisionFrontendDto(**dto_json_workflow_2_publishable).
to_transformation_revision())
dto_json_workflow_2_publish = deepcopy(dto_json_workflow_2_publishable)
dto_json_workflow_2_publish["state"] = "RELEASED"
# print("json inputs",dto_json_workflow_2_publish["inputs"])
# print("json outputs",dto_json_workflow_2_publish["outputs"])
print()
async with async_test_client as ac:
response = await ac.put(
"/api/workflows/" + str(get_uuid_from_seed("workflow 2")),
json=dto_json_workflow_2_publish,
)
assert response.status_code == 201
assert response.json()["state"] == "RELEASED"
assert response.json()["name"] != "new name"
async def test_update_transformation_revision_from_component_dto(
async_test_client, clean_test_db_engine
):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
ComponentRevisionFrontendDto(
**dto_json_component_1
).to_transformation_revision()
)
async with async_test_client as ac:
response = await ac.put(
"/api/components/" + str(get_uuid_from_seed("component 1")),
json=dto_json_component_1_update,
)
assert response.status_code == 201
assert response.json()["name"] == "new name"
assert response.json()["category"] == "Test"
assert response.json()["inputs"][0]["id"] == str(
get_uuid_from_seed("new input")
)
print(response.json()["code"])
assert "new_input" in response.json()["code"]
async def test_deprecate_base_item_of_type_component(async_test_client,
clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
TransformationRevisionFrontendDto(
**tr_dto_json_component_2).to_transformation_revision())
async with async_test_client as ac:
response = await ac.put(
"/api/base-items/" + str(tr_dto_json_component_2["id"]),
json=tr_dto_json_component_2_deprecate,
)
assert response.status_code == 201
assert response.json()["state"] == "DISABLED"
assert response.json()["name"] != "new name"
assert response.json()["category"] != "Test"
assert len(response.json()["inputs"]) == 0
tr_component_2 = read_single_transformation_revision(
tr_dto_json_component_2["id"])
assert tr_component_2.state.value == "DISABLED"
assert tr_component_2.name != "new name"
assert "disabled_timestamp" in tr_component_2.content
assert "released_timestamp" in tr_component_2.content
async def test_execute_for_component_without_hetdesrun_imports(
async_test_client, clean_test_db_engine
):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
path = (
"./tests/data/components/"
"alerts-from-score_100_38f168ef-cb06-d89c-79b3-0cd823f32e9d"
".json"
)
component_tr_json = load_json(path)
wiring_json = {
"id": "38f168ef-cb06-d89c-79b3-0cd823f32e9d",
"name": "STANDARD-WIRING",
"inputWirings": [
{
"id": "8c249f92-4b81-457e-9371-24204d6b373b",
"workflowInputName": "scores",
"adapterId": "direct_provisioning",
"filters": {
"value": (
"{\n"
' "2020-01-03T08:20:03.000Z": 18.7,\n'
' "2020-01-01T01:15:27.000Z": 42.2,\n'
' "2020-01-03T08:20:04.000Z": 25.9\n'
"}"
)
},
},
{
"id": "0f0f97f7-1f5d-4f5d-be11-7c7b78d02129",
"workflowInputName": "threshold",
"adapterId": "direct_provisioning",
"filters": {"value": "30"},
},
],
"outputWirings": [],
}
tr = TransformationRevision(**component_tr_json)
tr.content = update_code(tr)
assert "COMPONENT_INFO" in tr.content
store_single_transformation_revision(tr)
async with async_test_client as ac:
response = await ac.post(
"/api/components/" + component_tr_json["id"] + "/execute",
json=wiring_json,
)
assert response.status_code == 200
assert "output_types_by_output_name" in response.json()
async def test_get_documentation(async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(component_tr_1)
async with async_test_client as ac:
response = await ac.get("/api/documentations/" +
str(get_uuid_from_seed("component 1")))
assert response.status_code == 200
assert response.json()["document"] == "documentation"
def test_deleting(clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
tr_draft_uuid = get_uuid_from_seed("draft")
tr_draft_object = TransformationRevision(
id=tr_draft_uuid,
revision_group_id=tr_draft_uuid,
name="Test",
description="Test description",
version_tag="1.0.0",
category="Test category",
state=State.DRAFT,
type=Type.COMPONENT,
content="code",
io_interface=IOInterface(),
test_wiring=WorkflowWiring(),
documentation="",
)
tr_released_uuid = get_uuid_from_seed("released")
tr_released_object = TransformationRevision(
id=tr_released_uuid,
revision_group_id=tr_released_uuid,
name="Test",
description="Test description",
version_tag="1.0.0",
category="Test category",
released_timestamp="2021-12-24 00:00",
state=State.RELEASED,
type=Type.COMPONENT,
content="code",
io_interface=IOInterface(),
test_wiring=WorkflowWiring(),
documentation="",
)
store_single_transformation_revision(tr_draft_object)
store_single_transformation_revision(tr_released_object)
delete_single_transformation_revision(tr_draft_uuid)
with pytest.raises(DBNotFoundError):
read_single_transformation_revision(tr_draft_uuid)
with pytest.raises(DBBadRequestError):
delete_single_transformation_revision(tr_released_uuid)
async def test_get_all_base_items_with_specified_type_and_state(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
TransformationRevisionFrontendDto(
**tr_dto_json_component_1 # DRAFT
).to_transformation_revision())
store_single_transformation_revision(
TransformationRevisionFrontendDto(
**tr_dto_json_component_2 # RELEASED
).to_transformation_revision())
store_single_transformation_revision(
TransformationRevisionFrontendDto(**tr_dto_json_workflow_1 # DRAFT
).to_transformation_revision())
store_single_transformation_revision(
TransformationRevisionFrontendDto(**tr_dto_json_workflow_2 # DRAFT
).to_transformation_revision())
async with async_test_client as ac:
response_released_component = await ac.get(
"/api/base-items/?type=COMPONENT&state=RELEASED")
response_draft_workflow = await ac.get(
"/api/base-items/?type=WORKFLOW&state=DRAFT")
assert response_released_component.status_code == 200
assert len(response_released_component.json()) == 1
assert response_released_component.json()[0] == tr_dto_json_component_2
assert response_draft_workflow.status_code == 200
assert len(response_draft_workflow.json()) == 2
assert response_draft_workflow.json()[0] == tr_dto_json_workflow_1
assert response_draft_workflow.json()[1] == tr_dto_json_workflow_2
async def test_get_transformation_revision_by_id_with_component(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
TransformationRevision(**tr_json_component_1))
async with async_test_client as ac:
response = await ac.get(
posix_urljoin("/api/transformations/",
str(get_uuid_from_seed("component 1"))))
assert response.status_code == 200
assert response.json() == tr_json_component_1
async def test_get_transformation_revision_by_id_with_workflow(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
TransformationRevisionFrontendDto(
**tr_dto_json_workflow_1).to_transformation_revision())
async with async_test_client as ac:
response = await ac.get("/api/base-items/" +
str(get_uuid_from_seed("workflow 1")))
assert response.status_code == 200
assert response.json() == tr_dto_json_workflow_1
async def test_delete_transformation_revision_from_workflow_dto(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
WorkflowRevisionFrontendDto(
**dto_json_workflow_2).to_transformation_revision())
async with async_test_client as ac:
response = await ac.delete(
"/api/workflows/" + str(get_uuid_from_seed("workflow 2")), )
assert response.status_code == 204
async def test_update_transformation_revision_from_released_component_dto(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
TransformationRevisionFrontendDto(
**tr_dto_json_component_2).to_transformation_revision())
async with async_test_client as ac:
response = await ac.put(
"/api/base-items/" + str(get_uuid_from_seed("component 2")),
json=tr_dto_json_component_2_update,
)
assert response.status_code == 403
async def test_get_all_worfklow_revisions_with_valid_db_entries(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
WorkflowRevisionFrontendDto(
**dto_json_workflow_1).to_transformation_revision())
store_single_transformation_revision(
WorkflowRevisionFrontendDto(
**dto_json_workflow_2).to_transformation_revision())
async with async_test_client as ac:
response = await ac.get("/api/workflows/")
assert response.status_code == 200
assert response.json()[0] == dto_json_workflow_1
assert response.json()[1] == dto_json_workflow_2
async def test_deprecate_transformation_revision_from_workflow_dto(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
WorkflowRevisionFrontendDto(
**dto_json_workflow_1).to_transformation_revision())
async with async_test_client as ac:
response = await ac.put(
"/api/workflows/" + str(get_uuid_from_seed("workflow 1")),
json=dto_json_workflow_1_deprecate,
)
assert response.status_code == 201
assert response.json()["state"] == "DISABLED"
assert response.json()["name"] != "new name"
async def test_get_component_revision_by_id_with_valid_component(
async_test_client, clean_test_db_engine
):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
ComponentRevisionFrontendDto(
**dto_json_component_1
).to_transformation_revision()
)
async with async_test_client as ac:
response = await ac.get(
"/api/components/" + str(get_uuid_from_seed("component 1"))
)
assert response.status_code == 200
assert response.json() == dto_json_component_1
async def test_execute_latest_for_transformation_revision_works(
async_test_client, clean_test_db_engine):
patched_session = sessionmaker(clean_test_db_engine)
with mock.patch(
"hetdesrun.persistence.dbservice.nesting.Session",
patched_session,
):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
patched_session,
):
tr_component_1 = TransformationRevision(**tr_json_component_1)
tr_component_1.content = update_code(tr_component_1)
store_single_transformation_revision(tr_component_1)
tr_component_1_new_revision = TransformationRevision(
**tr_json_component_1_new_revision)
tr_component_1_new_revision.content = update_code(
tr_component_1_new_revision)
tr_component_1_new_revision.release()
store_single_transformation_revision(tr_component_1_new_revision)
exec_latest_by_group_id_input = ExecLatestByGroupIdInput(
revision_group_id=tr_component_1.revision_group_id,
wiring=tr_component_1.test_wiring,
job_id=UUID("1270547c-b224-461d-9387-e9d9d465bbe1"),
)
async with async_test_client as ac:
response = await ac.post(
"/api/transformations/execute-latest",
json=json.loads(exec_latest_by_group_id_input.json()),
)
assert response.status_code == 200
resp_data = response.json()
assert "output_types_by_output_name" in resp_data
assert (resp_data["output_types_by_output_name"]["operator_output"]
== "STRING")
assert "job_id" in resp_data
assert UUID(resp_data["job_id"]) == UUID(
"1270547c-b224-461d-9387-e9d9d465bbe1")
async def create_component_revision(
component_dto: ComponentRevisionFrontendDto,
) -> ComponentRevisionFrontendDto:
"""Store a transformation revision of type component in the data base.
This endpoint is deprecated and will be removed soon,
use POST /api/transformations/ instead.
"""
logger.info("create new component")
try:
transformation_revision = component_dto.to_transformation_revision(
documentation=("# New Component/Workflow\n"
"## Description\n"
"## Inputs\n"
"## Outputs\n"
"## Details\n"
"## Examples\n"))
except ValidationError as e:
raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY,
detail=str(e)) from e
logger.debug("generate code")
transformation_revision.content = update_code(transformation_revision)
logger.debug("generated code:\n%s", component_dto.code)
try:
store_single_transformation_revision(transformation_revision)
logger.info("created new component")
except DBIntegrityError as e:
raise HTTPException(status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=str(e)) from e
persisted_transformation_revision = read_single_transformation_revision(
transformation_revision.id)
persisted_component_dto = ComponentRevisionFrontendDto.from_transformation_revision(
persisted_transformation_revision)
logger.debug(persisted_component_dto.json())
return persisted_component_dto
async def test_update_transformation_revision_with_released_component_and_allow_overwrite_flag(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
TransformationRevision(**tr_json_component_2))
async with async_test_client as ac:
response = await ac.put(
posix_urljoin("/api/transformations/",
str(get_uuid_from_seed("component 2"))) +
"?allow_overwrite_released=true",
json=tr_json_component_2_update,
)
assert response.status_code == 201
assert response.json()["name"] == "new name"
assert response.json()["category"] == "Test"
async def test_execute_for_component_dto(async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
ComponentRevisionFrontendDto(
**valid_component_dto_dict
).to_transformation_revision()
)
async with async_test_client as ac:
response = await ac.post(
"/api/components/" + valid_component_dto_dict["id"] + "/execute",
json=valid_component_dto_dict["wirings"][0],
)
assert response.status_code == 200
assert "output_types_by_output_name" in response.json()
async def create_workflow_revision(
workflow_dto: WorkflowRevisionFrontendDto,
) -> WorkflowRevisionFrontendDto:
"""Store a transformation revision of type workflow in the data base.
This endpoint is deprecated and will be removed soon,
use POST /api/transformations/ instead.
"""
logger.info("create a new workflow")
try:
transformation_revision = workflow_dto.to_transformation_revision(
documentation=("# New Component/Workflow\n"
"## Description\n"
"## Inputs\n"
"## Outputs\n"
"## Details\n"
"## Examples\n"))
except ValidationError as e:
raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY,
detail=str(e)) from e
try:
store_single_transformation_revision(transformation_revision)
logger.info("created new workflow")
except DBIntegrityError as e:
raise HTTPException(status.HTTP_500_INTERNAL_SERVER_ERROR,
detail=str(e)) from e
try:
persisted_transformation_revision = read_single_transformation_revision(
transformation_revision.id)
except DBNotFoundError as e:
raise HTTPException(status.HTTP_404_NOT_FOUND, detail=str(e)) from e
persisted_workflow_dto = WorkflowRevisionFrontendDto.from_transformation_revision(
persisted_transformation_revision)
logger.debug(persisted_workflow_dto.json())
return persisted_workflow_dto
async def test_deprecate_transformation_revision_with_component(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
TransformationRevision(**tr_json_component_2))
async with async_test_client as ac:
response = await ac.put(
posix_urljoin("/api/transformations/",
str(get_uuid_from_seed("component 2"))),
json=tr_json_component_2_deprecate,
)
assert response.status_code == 201
assert response.json()["name"] != "new name"
assert response.json()["category"] != "Test"
assert "disabled_timestamp" in response.json()["content"]
assert "released_timestamp" in response.json()["content"]
async def test_update_transformation_revision_from_workflow_dto(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
WorkflowRevisionFrontendDto(
**dto_json_workflow_2).to_transformation_revision())
async with async_test_client as ac:
response = await ac.put(
"/api/workflows/" + str(get_uuid_from_seed("workflow 2")),
json=dto_json_workflow_2_update,
)
assert response.status_code == 201
assert response.json()["operators"][0]["id"] == str(
get_uuid_from_seed("operator"))
assert "name" not in response.json()["inputs"][0]
assert "name" not in response.json()["outputs"][0]
async def test_update_wiring(async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
WorkflowRevisionFrontendDto(
**dto_json_workflow_2_update).to_transformation_revision())
async with async_test_client as ac:
response = await ac.put(
"/api/wirings/" + str(get_uuid_from_seed("workflow 2")),
json=dto_json_wiring,
)
assert response.status_code == 200
assert len(response.json()["inputWirings"]) == len(
dto_json_wiring["inputWirings"])
assert len(response.json()["outputWirings"]) == len(
dto_json_wiring["outputWirings"])
async def test_update_transformation_revision_with_workflow(
async_test_client, clean_test_db_engine):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
TransformationRevision(**tr_json_workflow_2))
async with async_test_client as ac:
response = await ac.put(
posix_urljoin("/api/transformations/",
str(get_uuid_from_seed("workflow 2"))),
json=tr_json_workflow_2_update,
)
workflow_tr_in_db = read_single_transformation_revision(
get_uuid_from_seed("workflow 2"))
assert response.status_code == 201
assert response.json()["name"] == "new name"
assert len(workflow_tr_in_db.content.links) == 2
async def test_publish_transformation_revision_from_component_dto(
async_test_client, clean_test_db_engine
):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
sessionmaker(clean_test_db_engine),
):
store_single_transformation_revision(
ComponentRevisionFrontendDto(
**dto_json_component_1
).to_transformation_revision()
)
async with async_test_client as ac:
response = await ac.put(
"/api/components/" + str(get_uuid_from_seed("component 1")),
json=dto_json_component_1_publish,
)
assert response.status_code == 201
assert response.json()["state"] == "RELEASED"
assert "released_timestamp" in response.json()["code"]
async def test_execute_for_transformation_revision(async_test_client,
clean_test_db_engine):
patched_session = sessionmaker(clean_test_db_engine)
with mock.patch(
"hetdesrun.persistence.dbservice.nesting.Session",
patched_session,
):
with mock.patch(
"hetdesrun.persistence.dbservice.revision.Session",
patched_session,
):
tr_component_1 = TransformationRevision(**tr_json_component_1)
tr_component_1.content = update_code(tr_component_1)
store_single_transformation_revision(tr_component_1)
tr_workflow_2 = TransformationRevision(**tr_json_workflow_2_update)
store_single_transformation_revision(tr_workflow_2)
update_or_create_nesting(tr_workflow_2)
exec_by_id_input = ExecByIdInput(
id=tr_workflow_2.id,
wiring=tr_workflow_2.test_wiring,
job_id=UUID("1270547c-b224-461d-9387-e9d9d465bbe1"),
)
async with async_test_client as ac:
response = await ac.post(
"/api/transformations/execute",
json=json.loads(exec_by_id_input.json()),
)
assert response.status_code == 200
resp_data = response.json()
assert "output_types_by_output_name" in resp_data
assert "job_id" in resp_data
assert UUID(resp_data["job_id"]) == UUID(
"1270547c-b224-461d-9387-e9d9d465bbe1")
