bdlg2023-sms-back/app/tests/test_template.py

from uuid import uuid4
from httpx import AsyncClient
import pytest
from sqlalchemy import select
from sqlalchemy.orm import Session

from app.main import app
from app.models import Project, Slot, SlotTemplate
from app.tests.conftest import default_slot_id, default_template_id, default_tag_id


async def test_create_template_fail(
    client: AsyncClient,
    default_user_headers: dict,
    session: Session,
    default_public_project: Project,
):
    url = app.url_path_for("create_template", project_id=default_public_project.id)
    response = await client.post(url, json={"title": "1st template"})
    assert response.status_code == 401
    response = await client.post(url, json={}, headers=default_user_headers)
    assert response.status_code == 422

    url = app.url_path_for("create_template", project_id=uuid4())
    response = await client.post(
        url, json={"title": "1st template"}, headers=default_user_headers
    )
    assert response.status_code == 404


@pytest.mark.parametrize(
    "payload",
    [
        {"title": "1st template"},
        {"title": "1𝖘ҭ ṥ٥ι𝙪𝓉ìóη", "place": "echo"},
        {"title": "1st template", "responsible_contact": "echo"},
        {"title": "1st template", "description": "&é'(-è_çecho"},
        {"title": "1st template", "place": "3", "description": "&é'(-è_çecho"},
        {"title": "1st template", "comment": "55"},
    ],
)
async def test_create_template(
    client: AsyncClient,
    default_user_headers: dict,
    session: Session,
    default_public_project: Project,
    payload: dict,
):
    url = app.url_path_for("create_template", project_id=default_public_project.id)
    response = await client.post(url, json=payload, headers=default_user_headers)
    assert response.status_code == 200
    template = session.get(SlotTemplate, response.json()["id"])
    assert template is not None
    for k in ["title", "description", "place", "responsible_contact"]:
        val = template.__getattribute__(k)
        if k in payload:
            assert val == payload[k]
        else:
            assert val == ""


async def test_update_template_fail(
    client: AsyncClient,
    default_user_headers: dict,
    session: Session,
    default_public_project: Project,
):
    payload = {"title": "1st template"}
    project = session.get(Project, default_public_project.id)
    assert project is not None
    template_id = project.templates[0].id
    url = app.url_path_for(
        "update_template", project_id=default_public_project.id, template_id="12"
    )
    response = await client.post(url, json=payload)
    assert response.status_code == 401
    response = await client.post(url, json=payload, headers=default_user_headers)
    assert response.status_code == 422
    url = app.url_path_for(
        "update_template", project_id=default_public_project.id, template_id=uuid4()
    )
    response = await client.post(url, json=payload, headers=default_user_headers)
    assert response.status_code == 404

    url = app.url_path_for(
        "update_template", project_id=uuid4(), template_id=template_id
    )
    response = await client.post(url, json=payload, headers=default_user_headers)
    assert response.status_code == 404


@pytest.mark.parametrize(
    "code,payload",
    [
        (422, {"title": [1.001, 2]}),
        (422, {"responsible_contact": {"t": None}}),
        (422, {"place": [1, 2]}),
        (422, {"tags": ["1", "2"]}),
        # (422, {"slots": "1"}),
        (400, {"tags": [default_slot_id]}),
        (422, {"comment": 1235}),
    ],
)
async def test_update_template_fail_payload_validation(
    client: AsyncClient,
    default_user_headers: dict,
    session: Session,
    default_public_project: Project,
    payload: dict,
    code: int,
):
    url = app.url_path_for(
        "update_template",
        project_id=default_public_project.id,
        template_id=default_template_id,
    )
    response = await client.post(url, json=payload, headers=default_user_headers)
    assert response.status_code == code


@pytest.mark.parametrize(
    "payload",
    [
        {"title": "1st template"},
        {"title": "1st template", "place": "echo"},
        {"title": "1st template", "responsible_contact": "echo"},
        {"title": "1st template", "description": "&é'(-è_çecho"},
        {
            "title": "1st template",
            "place": "Ḽơᶉëᶆ ȋṕšᶙṁ",
            "description": "&é'(-è_çecho",
        },
        {"title": "1st template", "place": "3", "description": "&é'(-è_çecho"},
        {"title": "1st template", "comment": "&é'(-è_çecho"},
    ],
)
async def test_update_template(
    client: AsyncClient,
    default_user_headers: dict,
    session: Session,
    default_public_project: Project,
    payload: dict,
):
    url = app.url_path_for(
        "update_template",
        project_id=default_public_project.id,
        template_id=default_template_id,
    )
    response = await client.post(url, json=payload, headers=default_user_headers)
    assert response.status_code == 200
    template = session.get(SlotTemplate, default_template_id)
    assert template is not None
    for k in ["title", "description", "place", "responsible_contact", "comment"]:
        val = template.__getattribute__(k)
        if k in payload:
            assert val == payload[k]
        else:
            assert val == ""


async def test_update_template_lists(
    client: AsyncClient,
    default_user_headers: dict,
    session: Session,
    default_public_project: Project,
):
    url = app.url_path_for(
        "update_template",
        project_id=default_public_project.id,
        template_id=default_template_id,
    )
    payload = {"tags": [default_tag_id]}
    response = await client.post(url, json=payload, headers=default_user_headers)
    assert response.status_code == 200
    template = session.get(SlotTemplate, default_template_id)
    assert template is not None
    assert len(template.tags) == 1
    assert template.tags[0].id == default_tag_id
    response = await client.post(url, json={"tags": []}, headers=default_user_headers)
    assert response.status_code == 200
    session.refresh(template)
    assert len(template.tags) == 0


async def test_delete_template_fail(
    client: AsyncClient,
    default_user_headers: dict,
    session: Session,
    default_public_project: Project,
):
    # Proper deletion
    project_id = default_public_project.id
    # no authent
    url = app.url_path_for(
        "delete_template", project_id=project_id, template_id=default_template_id
    )
    response = await client.delete(url)
    assert response.status_code == 401
    # invalid tag
    url = app.url_path_for(
        "delete_template", project_id=project_id, template_id="default_tag_id"
    )
    response = await client.delete(url, headers=default_user_headers)
    assert response.status_code == 422

    # invalid project_id
    url = app.url_path_for(
        "delete_template", project_id="ded", template_id=default_template_id
    )
    response = await client.delete(url, headers=default_user_headers)
    assert response.status_code == 422


async def test_delete_template(
    client: AsyncClient,
    default_user_headers: dict,
    session: Session,
    default_public_project: Project,
):
    # Proper deletion
    url = app.url_path_for(
        "delete_template",
        project_id=default_public_project.id,
        template_id=default_template_id,
    )
    response = await client.delete(url, headers=default_user_headers)
    assert response.status_code == 200
    result = session.execute(
        select(SlotTemplate).where(SlotTemplate.id == default_tag_id)
    )
    slot = result.scalars().first()
    assert slot is None

    # can delete random uuid
    url = app.url_path_for(
        "delete_tag", project_id=default_public_project.id, tag_id=uuid4()
    )
    response = await client.delete(url, headers=default_user_headers)
    assert response.status_code == 200


async def test_delete_template_not_slot(
    client: AsyncClient,
    default_user_headers: dict,
    session: Session,
    default_public_project: Project,
):
    # Proper deletion
    url = app.url_path_for(
        "delete_template",
        project_id=default_public_project.id,
        template_id=default_template_id,
    )
    slot = session.get(Slot, default_slot_id)
    assert slot is not None
    slot.template_id = default_template_id
    session.commit()

    response = await client.delete(url, headers=default_user_headers)
    assert response.status_code == 200
    slot = session.get(Slot, default_slot_id)
    assert slot is not None