示例#1
0
def test_flow_run_view_from_flow_run_id_where_clause(monkeypatch):
    post = MagicMock(return_value={"data": {"flow_run": [FLOW_RUN_DATA_1]}})
    monkeypatch.setattr("prefect.client.client.Client.post", post)

    FlowRunView.from_flow_run_id(flow_run_id="id-1", load_static_tasks=False)

    assert ('flow_run(where: { id: { _eq: "id-1" } })'
            in post.call_args[1]["params"]["query"])
示例#2
0
def test_flow_run_view_from_returns_instance_with_loaded_static_tasks(
    patch_posts, ):
    patch_posts([
        {
            "data": {
                "flow_run": [FLOW_RUN_DATA_1]
            }
        },
        {
            "data": {
                "task_run": [TASK_RUN_DATA_FINISHED, TASK_RUN_DATA_RUNNING]
            }
        },
    ])

    flow_run = FlowRunView.from_flow_run_id("id-1", load_static_tasks=True)

    assert flow_run.flow_run_id == "id-1"
    assert flow_run.name == "name-1"
    assert flow_run.flow_id == "flow_id-1"
    # This state is deserialized at initialization
    assert flow_run.state == Success(message="state-1")

    # Only the finished task is cached
    assert len(flow_run._cached_task_runs) == 1
    assert flow_run._cached_task_runs[
        "task-run-id-1"] == TaskRunView._from_task_run_data(
            TASK_RUN_DATA_FINISHED)
示例#3
0
def test_flow_run_view_get_all_task_runs(patch_post, patch_posts):
    patch_posts([
        {
            "data": {
                "flow_run": [FLOW_RUN_DATA_1]
            }
        },
        {
            "data": {
                "task_run": [TASK_RUN_DATA_FINISHED]
            }
        },
    ])
    flow_run = FlowRunView.from_flow_run_id("fake-id")

    patch_post({
        "data": {
            "task_run": [TASK_RUN_DATA_FINISHED, TASK_RUN_DATA_RUNNING]
        }
    })
    tr = flow_run.get_all_task_runs()
    assert len(flow_run._cached_task_runs) == 1
    assert len(tr) == 2

    patch_post({"data": {"task_run": [TASK_RUN_DATA_RUNNING_NOW_FINISHED]}})
    tr = flow_run.get_all_task_runs()
    assert len(flow_run._cached_task_runs) == 2
    assert len(tr) == 2
示例#4
0
def test_flow_run_view_from_returns_instance(patch_post, from_method):
    patch_post({"data": {"flow_run": [FLOW_RUN_DATA_1]}})

    if from_method == "flow_run_id":
        flow_run = FlowRunView.from_flow_run_id("id-1",
                                                load_static_tasks=False)
    elif from_method == "flow_run_data":
        # Note the post patch will not be used since there is no query here
        flow_run = FlowRunView._from_flow_run_data(FLOW_RUN_DATA_1)

    assert flow_run.flow_run_id == "id-1"
    assert flow_run.name == "name-1"
    assert flow_run.flow_id == "flow_id-1"
    assert flow_run.parameters == {"param": "value"}
    assert flow_run.context == {"foo": "bar"}
    assert flow_run.labels == ["label"]
    assert isinstance(flow_run.run_config, UniversalRun)
    assert isinstance(flow_run.updated_at, pendulum.DateTime)
    # This state is deserialized at initialization
    assert flow_run.state == Success(message="state-1")
    # Assert that past states are in timestamp sorted order and deserialized
    assert flow_run.states[0].is_submitted()
    assert flow_run.states[1].is_running()
    for state in flow_run.states:
        assert isinstance(state.timestamp, pendulum.DateTime)
        assert state.message == "past-state"
    # There are no cached tasks
    assert flow_run._cached_task_runs == {}
示例#5
0
def test_flow_run_view_get_latest_returns_new_instance(patch_post,
                                                       patch_posts):
    patch_posts([
        {
            "data": {
                "flow_run": [FLOW_RUN_DATA_1]
            }
        },
        {
            "data": {
                "task_run": [TASK_RUN_DATA_FINISHED, TASK_RUN_DATA_RUNNING]
            }
        },
    ])

    flow_run = FlowRunView.from_flow_run_id("fake-id", load_static_tasks=True)

    patch_post({"data": {"flow_run": [FLOW_RUN_DATA_2]}})

    flow_run_2 = flow_run.get_latest()

    # Assert we have not mutated the original flow run object
    assert flow_run.flow_run_id == "id-1"
    assert flow_run.name == "name-1"
    assert flow_run.flow_id == "flow_id-1"
    assert flow_run.state == Success(message="state-1")
    assert flow_run.parameters == {"param": "value"}
    assert flow_run.context == {"foo": "bar"}
    assert flow_run.labels == ["label"]
    assert isinstance(flow_run.updated_at, pendulum.DateTime)
    assert len(flow_run._cached_task_runs) == 1
    assert flow_run._cached_task_runs[
        "task-run-id-1"] == TaskRunView._from_task_run_data(
            TASK_RUN_DATA_FINISHED)

    # Assert the new object has the data returned by the query
    # In reality, the flow run ids and such would match because that's how the lookup
    # is done
    assert flow_run_2.flow_run_id == "id-2"
    assert flow_run_2.name == "name-2"
    assert flow_run_2.flow_id == "flow_id-2"
    assert flow_run_2.state == Success(message="state-2")
    assert flow_run_2.parameters == {"param": "value2"}
    assert flow_run_2.context == {"bar": "foo"}
    assert flow_run_2.labels == ["label2"]

    # Cached task runs are transferred
    assert len(flow_run._cached_task_runs) == 1
    assert flow_run._cached_task_runs[
        "task-run-id-1"] == TaskRunView._from_task_run_data(
            TASK_RUN_DATA_FINISHED)