Skip to content

armgit / meet

Public Imported from GitHub
0

Open source video conferencing app powered by LiveKit. Built with Django and React.

12.3 KB
Raw Blame
"""Integration tests for the V2 task API endpoints."""

from datetime import datetime
from unittest.mock import ANY, MagicMock, patch

import pytest

from summary.core.exceptions import CleanedValidationError


class TestTasksV2:
    """Tests for the /v2/async-jobs-jobs endpoints."""

    @patch(
        "summary.api.route.tasks_v2.process_audio_transcribe_v2_task.apply_async",
        return_value=MagicMock(id="transcribe-task-id-abc"),
    )
    def test_create_transcribe_task_v2_returns_task_id(self, mock_apply_async, client):
        """POST /async-jobs/transcribe creates a task and injects tenant_id."""
        response = client.post(
            "/api/v2/async-jobs/transcribe",
            headers={"Authorization": "Bearer test-api-token"},
            json={
                "user_sub": "remote-001",
                "cloud_storage_url": "https://example.com/audio.mp3",
                "language": "en",
                "context_language": "fr",
            },
        )

        assert response.status_code == 200
        assert response.json() == {
            "job_id": "transcribe-task-id-abc",
            "type": "transcript",
            "status": "pending",
        }

        args = mock_apply_async.call_args.kwargs["args"]
        received_at = args[0].pop("received_at")
        assert isinstance(received_at, datetime)
        assert args == [
            {
                "user_sub": "remote-001",
                "cloud_storage_url": "https://example.com/audio.mp3",
                "language": "en",
                "context_language": "fr",
                "tenant_id": "test-tenant",
                "user_email": None,
                "metadata": None,
                "push_to_docs_config": None,
            }
        ]

    @patch(
        "summary.api.route.tasks_v2.summarize_v2_task.apply_async",
        return_value=MagicMock(id="summarize-task-id-abc"),
    )
    def test_create_summarize_task_v2_returns_task_id(self, mock_apply_async, client):
        """POST /async-jobs/summarize creates a task and injects tenant_id."""
        response = client.post(
            "/api/v2/async-jobs/summarize",
            headers={"Authorization": "Bearer test-api-token"},
            json={
                "user_sub": "remote-002",
                "content": "This is a long meeting transcript to summarize.",
            },
        )

        assert response.status_code == 200
        assert response.json() == {
            "job_id": "summarize-task-id-abc",
            "type": "summary",
            "status": "pending",
        }

        args = mock_apply_async.call_args.kwargs["args"]
        received_at = args[0].pop("received_at")
        assert isinstance(received_at, datetime)
        assert args == [
            {
                "user_sub": "remote-002",
                "content": "This is a long meeting transcript to summarize.",
                "tenant_id": "test-tenant",
                "user_email": None,
            }
        ]

    @patch("summary.api.route.tasks_v2.celery")
    @patch("summary.api.route.tasks_v2.AsyncResult")
    def test_get_transcribe_task_status_returns_status_for_same_tenant(
        self, mock_async_result, mock_celery, client
    ):
        """GET /async-jobs/transcribe/{id} returns status when tenant matches."""
        mock_celery.backend.client.exists.return_value = True
        mock_async_result.return_value = MagicMock(
            status="PENDING",
            args=[{"tenant_id": "test-tenant"}],
        )

        response = client.get(
            "/api/v2/async-jobs/transcribe/task-id-abc",
            headers={"Authorization": "Bearer test-api-token"},
        )

        assert response.status_code == 200
        assert response.json() == {
            "job_id": "task-id-abc",
            "type": "transcript",
            "status": "pending",
        }

        mock_async_result.assert_called_once_with("task-id-abc", app=ANY)

    @patch("summary.api.route.tasks_v2.celery")
    @patch("summary.api.route.tasks_v2.AsyncResult")
    def test_get_summarize_task_status_returns_status_for_same_tenant(
        self, mock_async_result, mock_celery, client
    ):
        """GET /async-jobs/summarize/{id} returns status when tenant matches."""
        mock_celery.backend.client.exists.return_value = True
        mock_async_result.return_value = MagicMock(
            status="SUCCESS",
            args=[{"tenant_id": "test-tenant"}],
            result={
                "job_id": "task-id-abc",
                "summary_data_url": "https://example.com/summary.json",
            },
        )

        response = client.get(
            "/api/v2/async-jobs/summarize/task-id-abc",
            headers={"Authorization": "Bearer test-api-token"},
        )

        assert response.status_code == 200
        assert response.json() == {
            "job_id": "task-id-abc",
            "type": "summary",
            "status": "success",
            "summary_data_url": "https://example.com/summary.json",
        }

        mock_async_result.assert_called_once_with("task-id-abc", app=ANY)

    @patch("summary.api.route.tasks_v2.celery")
    @patch("summary.api.route.tasks_v2.AsyncResult")
    def test_get_task_status_returns_404_when_job_does_not_exist(
        self, mock_async_result, mock_celery, client
    ):
        """GET /async-jobs/.../{id} returns 404 when task key is not in Redis."""
        mock_celery.backend.client.exists.return_value = False

        response = client.get(
            "/api/v2/async-jobs/transcribe/task-id-abc",
            headers={"Authorization": "Bearer test-api-token"},
        )

        assert response.status_code == 404
        assert response.json() == {"detail": "Not found"}
        mock_async_result.assert_not_called()

    @patch("summary.api.route.tasks_v2.celery")
    @patch("summary.api.route.tasks_v2.AsyncResult")
    def test_get_task_status_returns_403_for_other_tenant(
        self, mock_async_result, mock_celery, client
    ):
        """GET /async-jobs/.../{id} returns 403 when task belongs to another tenant."""
        mock_celery.backend.client.exists.return_value = True
        mock_async_result.return_value = MagicMock(
            status="PENDING",
            args=[{"tenant_id": "another-tenant"}],
        )

        response = client.get(
            "/api/v2/async-jobs/summarize/task-id-abc",
            headers={"Authorization": "Bearer test-api-token"},
        )

        assert response.status_code == 403
        assert response.json() == {"detail": "Forbidden"}


def test_validation_preserves_ordinary_input(client):
    """Validation errors keep input values that are not SecretStr."""
    canary = "private-meeting-content"
    response = client.post(
        "/api/v2/async-jobs/summarize",
        headers={"Authorization": "Bearer test-api-token"},
        json={"user_sub": "user", "content": {"unexpected": canary}},
    )
    assert response.status_code == 422
    assert canary in response.text
    assert response.json()["detail"] == [
        {
            "type": "string_type",
            "loc": ["body", "content"],
            "msg": "Input should be a valid string",
            "input": {"unexpected": canary},
        }
    ]


def test_validation_preserves_context(client):
    """Validator errors retain location, message and serializable context."""
    canary = "private-invalid-url-signature"
    response = client.post(
        "/api/v2/async-jobs/transcribe",
        headers={"Authorization": "Bearer test-api-token"},
        json={
            "user_sub": "user",
            "language": "en",
            "cloud_storage_url": f"invalid-url?signature={canary}",
        },
    )
    assert response.status_code == 422
    assert canary not in response.text
    assert response.json()["detail"] == [
        {
            "type": "url_parsing",
            "loc": ["body", "cloud_storage_url"],
            "msg": "Input should be a valid URL, relative URL without a base",
            "input": "[redacted]",
            "ctx": {"error": "relative URL without a base"},
        }
    ]


@patch(
    "summary.api.route.tasks_v2.process_audio_transcribe_v2_task.apply_async",
    return_value=MagicMock(id="transcribe-job"),
)
def test_signed_urls_are_unwrapped_for_task_submission(mock_apply_async, client):
    """API input secrets reach Celery intact, including nested metadata URLs."""
    signed_url = "https://storage.example.com/file?signature=deterministic-signature"
    response = client.post(
        "/api/v2/async-jobs/transcribe",
        headers={"Authorization": "Bearer test-api-token"},
        json={
            "user_sub": "user",
            "language": "en",
            "cloud_storage_url": signed_url,
            "metadata": {
                "cloud_storage_url": signed_url,
                "started_at": "2026-01-01T10:00:00Z",
                "ended_at": "2026-01-01T11:00:00Z",
            },
        },
    )
    assert response.status_code == 200
    payload = mock_apply_async.call_args.kwargs["args"][0]
    assert payload["cloud_storage_url"] == signed_url
    assert payload["metadata"]["cloud_storage_url"] == signed_url


@pytest.mark.parametrize(
    "case",
    [
        ("transcribe", "transcript", "transcription_data_url"),
        ("summarize", "summary", "summary_data_url"),
    ],
)
@patch("summary.api.route.tasks_v2.celery")
@patch("summary.api.route.tasks_v2.AsyncResult")
def test_success_status_returns_usable_signed_url(
    mock_async_result, mock_celery, client, case
):
    """Success responses explicitly reveal result URLs for authorized clients."""
    job_type, payload_type, url_field = case
    signed_url = "https://storage.example.com/result?signature=deterministic-signature"
    mock_celery.backend.client.exists.return_value = True
    mock_async_result.return_value = MagicMock(
        status="SUCCESS",
        args=[{"tenant_id": "test-tenant"}],
        result={"job_id": "job", url_field: signed_url},
    )
    response = client.get(
        f"/api/v2/async-jobs/{job_type}/job",
        headers={"Authorization": "Bearer test-api-token"},
    )
    assert response.status_code == 200
    assert response.json() == {
        "job_id": "job",
        "type": payload_type,
        "status": "success",
        url_field: signed_url,
    }


@pytest.mark.parametrize(
    "case",
    [
        ("transcribe", "transcription_data_url"),
        ("summarize", "summary_data_url"),
    ],
)
@patch("summary.api.route.tasks_v2.celery")
@patch("summary.api.route.tasks_v2.AsyncResult")
def test_invalid_success_result_hides_revealed_url(
    mock_async_result, mock_celery, client, case
):
    """Missing result fields cannot retain a raw signed URL in error details."""
    job_type, url_field = case
    canary = "private-result-signature"
    mock_celery.backend.client.exists.return_value = True
    mock_async_result.return_value = MagicMock(
        status="SUCCESS",
        args=[{"tenant_id": "test-tenant"}],
        result={url_field: f"https://storage.example.com/result?signature={canary}"},
    )
    with pytest.raises(CleanedValidationError) as exc:
        client.get(
            f"/api/v2/async-jobs/{job_type}/job",
            headers={"Authorization": "Bearer test-api-token"},
        )
    assert exc.value.errors()[0]["type"] == "missing"
    assert exc.value.errors()[0]["loc"] == ("job_id",)
    assert exc.value.errors()[0]["input"] == "[redacted]"
    assert canary not in str(exc.value)
    assert canary not in exc.value.json()


@pytest.mark.parametrize("nested_error", [False, True])
def test_missing_field_errors_preserve_raw_json_strings(client, nested_error):
    """Raw JSON input is retained when it has not been converted to SecretStr."""
    canary = "private-validation-signature"
    signed_url = f"https://storage.example.com/recording?signature={canary}"
    payload = {"language": "en", "cloud_storage_url": signed_url}
    if nested_error:
        payload["user_sub"] = "user"
        payload["metadata"] = {"cloud_storage_url": signed_url}
    response = client.post(
        "/api/v2/async-jobs/transcribe",
        headers={"Authorization": "Bearer test-api-token"},
        json=payload,
    )
    assert response.status_code == 422
    assert canary in response.text
    assert all(error["type"] == "missing" for error in response.json()["detail"])
    expected_input = payload["metadata"] if nested_error else payload
    assert all(error["input"] == expected_input for error in response.json()["detail"])