Skip to content

Self-improving AI Employees for everyone

8.4 KB
Raw Blame
"""Execution-correlation contracts shared by workflow entry points."""

from __future__ import annotations

import asyncio
import time
from types import MethodType, SimpleNamespace
from unittest.mock import AsyncMock

import pytest

from services.workflow import WorkflowService


@pytest.mark.asyncio
async def test_sequential_workflow_uses_one_generated_id_for_every_node():
    service = WorkflowService.__new__(WorkflowService)
    service._settings = {"stop_on_error": False}

    observed: list[tuple[str, str]] = []

    async def fake_execute_node(self, **kwargs):
        observed.append((kwargs["execution_id"], kwargs["user_id"]))
        return {"success": True, "result": {"node_id": kwargs["node_id"]}}

    service.execute_node = MethodType(fake_execute_node, service)
    nodes = [
        {"id": "start-1", "type": "start", "data": {}},
        {"id": "console-1", "type": "console", "data": {}},
    ]
    edges = [{"source": "start-1", "target": "console-1"}]

    result = await service._execute_sequential(
        nodes,
        edges,
        "session-1",
        None,
        time.time(),
        "workflow-1",
    )

    assert result["execution_id"]
    assert observed == [
        (result["execution_id"], "owner"),
        (result["execution_id"], "owner"),
    ]


@pytest.mark.asyncio
async def test_sequential_workflow_preserves_authenticated_user():
    service = WorkflowService.__new__(WorkflowService)
    service._settings = {"stop_on_error": False}
    observed: list[str] = []

    async def fake_execute_node(self, **kwargs):
        observed.append(kwargs["user_id"])
        return {"success": True, "result": {}}

    service.execute_node = MethodType(fake_execute_node, service)
    await service._execute_sequential(
        [{"id": "start-1", "type": "start", "data": {}}],
        [],
        "session-1",
        None,
        time.time(),
        "workflow-1",
        "account-7",
    )

    assert observed == ["account-7"]


@pytest.mark.asyncio
async def test_parallel_workflows_isolate_authenticated_users():
    service = WorkflowService.__new__(WorkflowService)
    observed: dict[str, str] = {}

    async def fake_execute_node(self, **kwargs):
        observed[kwargs["workflow_id"]] = kwargs["user_id"]
        return {"success": True, "result": {}}

    service.execute_node = MethodType(fake_execute_node, service)

    class _Executor:
        async def execute_workflow(
            self,
            *,
            workflow_id,
            nodes,
            edges,
            session_id,
            enable_caching,
        ):
            await asyncio.sleep(0)
            await service._execute_node_adapter(
                "node-1",
                "console",
                {},
                {
                    "workflow_id": workflow_id,
                    "session_id": session_id,
                    "nodes": nodes,
                    "edges": edges,
                },
            )
            return {
                "success": True,
                "execution_id": workflow_id,
                "nodes_executed": ["node-1"],
                "outputs": {},
                "errors": [],
            }

    executor = _Executor()
    service._get_workflow_executor = lambda _callback=None: executor

    await asyncio.gather(
        service._execute_parallel(
            [],
            [],
            "session-a",
            None,
            time.time(),
            "workflow-a",
            "account-a",
        ),
        service._execute_parallel(
            [],
            [],
            "session-b",
            None,
            time.time(),
            "workflow-b",
            "account-b",
        ),
    )

    assert observed == {
        "workflow-a": "account-a",
        "workflow-b": "account-b",
    }


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("supplied", "expected"),
    [("account-9", "account-9"), ("", "owner")],
)
async def test_execute_node_builds_user_scoped_context(
    supplied,
    expected,
):
    service = WorkflowService.__new__(WorkflowService)
    service._get_workspace_dir = lambda _slug: "workspace"
    service._node_executor = SimpleNamespace(
        execute=AsyncMock(return_value={"success": True}),
    )
    service._param_resolver = SimpleNamespace(resolve=AsyncMock())

    await service.execute_node(
        node_id="node-1",
        node_type="console",
        parameters={},
        workflow_slug="workflow",
        user_id=supplied,
    )

    context = service._node_executor.execute.await_args.kwargs["context"]
    assert context["user_id"] == expected


@pytest.mark.asyncio
async def test_temporal_workflow_preserves_authenticated_user():
    service = WorkflowService.__new__(WorkflowService)
    service._resolve_workflow_slug = AsyncMock(return_value="workflow")
    service._temporal_executor = SimpleNamespace(
        execute_workflow=AsyncMock(
            return_value={
                "success": True,
                "execution_id": "run-1",
                "nodes_executed": [],
                "outputs": {},
                "errors": [],
            }
        )
    )

    await service._execute_temporal(
        [],
        [],
        "session",
        None,
        time.time(),
        "workflow-1",
        2,
        1,
        "account-11",
    )

    kwargs = service._temporal_executor.execute_workflow.await_args.kwargs
    assert kwargs["user_id"] == "account-11"


@pytest.mark.asyncio
async def test_deploy_workflow_preserves_authenticated_user():
    service = WorkflowService.__new__(WorkflowService)
    manager = SimpleNamespace(
        deploy=AsyncMock(return_value={"success": True}),
    )
    service._get_deployment_manager = lambda: manager

    await service.deploy_workflow(
        [],
        [],
        workflow_id="workflow-1",
        graph_version=2,
        generation=1,
        user_id="account-12",
    )

    assert manager.deploy.await_args.kwargs["user_id"] == "account-12"


@pytest.mark.asyncio
@pytest.mark.parametrize("parallel", [False, True])
async def test_old_native_generation_fallback_keeps_runtime_and_frozen_configuration(parallel):
    from services.workflow import _fallback_execution_scope

    service = WorkflowService.__new__(WorkflowService)
    service.settings = SimpleNamespace(temporal_enabled=False, redis_enabled=parallel,
        coding_pi_admissions_enabled=False)
    service._settings = {"stop_on_error": True}
    service._temporal_executor = None
    service.database = SimpleNamespace(get_latest_workflow_control=AsyncMock(return_value=
        SimpleNamespace(generation=5, resource_manifest={"execution_control_version": 1})))
    service.clear_all_outputs = AsyncMock()
    service._resolve_workflow_slug = AsyncMock(return_value="saved")
    service._get_workspace_dir = lambda _slug: "managed-workspace"
    service._node_executor = SimpleNamespace(execute=AsyncMock(return_value={"success": True, "result": {}}))
    service._param_resolver = SimpleNamespace(resolve=AsyncMock())
    nodes = [{"id": "start", "type": "start", "data": {}},
             {"id": "coding", "type": "coding_agent", "data": {}}]
    edges = [{"source": "start", "target": "coding"}]

    class Executor:
        async def execute_workflow(self, *, workflow_id, nodes, edges, session_id, enable_caching):
            # The existing parallel executor passes no generation/manifest.
            await asyncio.sleep(0)
            await service._execute_node_adapter("coding", "coding_agent", {},
                {"workflow_id": workflow_id, "session_id": session_id, "nodes": nodes,
                 "edges": edges, "execution_id": "parallel-run"})
            return {"success": True, "execution_id": "parallel-run", "nodes_executed": ["coding"], "outputs": {}}

    service._get_workflow_executor = lambda _callback: Executor()
    snapshot = {"coding": {"model": "admitted-model", "prompt": "frozen native request"}}
    result = await service.execute_workflow(nodes, edges, workflow_id="graph", generation=5,
        graph_version=8, parameter_snapshot=snapshot, user_id="alice", use_parallel=parallel,
        use_temporal=False)
    assert result["success"]
    context = service._node_executor.execute.await_args.kwargs["context"]
    assert context["generation"] == 5 and context["graphVersion"] == 8
    assert context["parameter_snapshot"] == snapshot
    assert context["coding_native_version"] == 1 and "pi_harness_version" not in context
    assert context["user_id"] == "alice"
    assert _fallback_execution_scope.get() is None