canvas 0.32.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

canvas_sdk/effects/protocol_card/tests.py

@@ -1,191 +0,0 @@
-from typing import Any
-
-import pytest
-from pydantic import ValidationError
-
-from canvas_sdk.commands import (
-    AssessCommand,
-    DiagnoseCommand,
-    GoalCommand,
-    HistoryOfPresentIllnessCommand,
-    MedicationStatementCommand,
-    PlanCommand,
-    PrescribeCommand,
-    QuestionnaireCommand,
-    ReasonForVisitCommand,
-    StopMedicationCommand,
-    UpdateGoalCommand,
-)
-from canvas_sdk.commands.base import _BaseCommand
-from canvas_sdk.effects.protocol_card import ProtocolCard, Recommendation
-
-
-def test_apply_method_succeeds_with_patient_id_and_key() -> None:
-    """Test that the apply method succeeds with all required fields."""
-    p = ProtocolCard(patient_id="uuid", key="something-unique")
-    applied = p.apply()
-    assert (
-        applied.payload
-        == '{"patient": "uuid", "patient_filter": null, "key": "something-unique", "data": {"title": "", "narrative": "", "recommendations": [], "status": "due", "feedback_enabled": false, "due_in": -1}}'
-    )
-
-
-def test_apply_method_raises_error_without_patient_id_and_key() -> None:
-    """Test that the apply method raises an error when missing required fields."""
-    p = ProtocolCard()
-
-    with pytest.raises(ValidationError) as e:
-        p.apply()
-    err_msg = repr(e.value)
-
-    assert "2 validation errors for ProtocolCard" in err_msg
-    assert (
-        "Field 'patient_id' or 'patient_filter' is required to apply a ProtocolCard [type=missing, input_value=None, input_type=NoneType]"
-        in err_msg
-    )
-    assert (
-        "Field 'key' is required to apply a ProtocolCard [type=missing, input_value=None, input_type=NoneType]"
-        in err_msg
-    )
-
-
-@pytest.mark.parametrize(
-    "init_params,rec1_params,rec2_params",
-    [
-        (
-            {
-                "key": "link_rec",
-                "patient_id": "patientuuid",
-                "title": "This is a test!",
-                "narrative": "we should only expect a link and a button",
-            },
-            {
-                "title": "this is a link",
-                "button": "click this",
-                "href": "https://canvasmedical.com/",
-            },
-            {"title": "second link", "button": "don't click this", "href": "https://google.com/"},
-        ),
-        (
-            {
-                "key": "command_rec",
-                "patient_id": "patientuuid",
-                "title": "This is a test for command recommendations!",
-                "narrative": "we should only expect buttons to insert commands",
-            },
-            {
-                "title": "this is a command",
-                "button": "click this",
-                "command": "updategoal",
-                "context": {"progress": "none"},
-            },
-            {
-                "title": "another command",
-                "button": "hypertension",
-                "command": "diagnose",
-                "context": {"background": "stuff"},
-            },
-        ),
-        (
-            {
-                "patient_id": "patientuuid",
-                "key": "command_rec_with_coding_filter",
-                "title": "This is a test for command recommendations with coding filters!",
-                "narrative": "we should only expect buttons to insert commands",
-            },
-            {
-                "title": "hypertension",
-                "button": "diagnose",
-                "command": "diagnose",
-                "context": {"background": "hey", "icd10_code": "I10"},
-            },
-            {
-                "title": "fake medication",
-                "button": "prescribe",
-                "command": "prescribe",
-                "context": {"sig": "1pobid"},
-            },
-        ),
-    ],
-)
-def test_add_recommendations(
-    init_params: dict[Any, Any], rec1_params: dict[Any, Any], rec2_params: dict[Any, Any]
-) -> None:
-    """Test that the add_recommendation method adds recommendations to the ProtocolCard."""
-    p = ProtocolCard(**init_params)
-    p.add_recommendation(**rec1_params)
-    p.recommendations.append(Recommendation(**rec2_params))
-    assert p.values == {
-        "title": init_params["title"],
-        "narrative": init_params["narrative"],
-        "recommendations": [
-            {
-                "title": rec1_params.get("title"),
-                "button": rec1_params.get("button"),
-                "href": rec1_params.get("href"),
-                "command": {"type": rec1_params["command"]} if "command" in rec1_params else {},
-                "context": rec1_params.get("context", {}),
-                "key": 0,
-            },
-            {
-                "title": rec2_params.get("title"),
-                "button": rec2_params.get("button"),
-                "href": rec2_params.get("href"),
-                "command": {"type": rec2_params["command"]} if "command" in rec2_params else {},
-                "context": rec2_params.get("context", {}),
-                "key": 1,
-            },
-        ],
-        "status": "due",
-        "due_in": -1,
-        "feedback_enabled": False,
-    }
-
-
-@pytest.mark.parametrize(
-    "Command,init_params",
-    [
-        (AssessCommand, {}),
-        (DiagnoseCommand, {"icd10_code": "I10"}),
-        (GoalCommand, {}),
-        (HistoryOfPresentIllnessCommand, {}),
-        (MedicationStatementCommand, {"fdb_code": "fakeroo"}),
-        (PlanCommand, {}),
-        (PrescribeCommand, {"fdb_code": "fake"}),
-        (QuestionnaireCommand, {}),
-        (ReasonForVisitCommand, {}),
-        (StopMedicationCommand, {}),
-        (UpdateGoalCommand, {}),
-    ],
-)
-def test_add_recommendations_from_commands(
-    Command: type[_BaseCommand], init_params: dict[str, str]
-) -> None:
-    """Test that the add_recommendation method adds recommendations from commands to the ProtocolCard."""
-    cmd = Command(**init_params)
-    p = ProtocolCard(patient_id="uuid", key="commands")
-    p.recommendations.append(cmd.recommend())
-    p.recommendations.append(cmd.recommend(title="hello", button="click"))
-    p.add_recommendation(
-        title="yeehaw", button="click here", command=cmd.Meta.key.lower(), context=init_params
-    )
-
-    rec1, rec2, rec3 = p.values["recommendations"]
-    assert rec1["title"] == ""
-    assert rec1["button"] == cmd.constantized_key().lower().replace("_", " ")
-    assert rec1["href"] is None
-    assert rec1["context"] == cmd.values
-    assert rec1["command"]["type"] == cmd.Meta.key.lower()
-
-    assert rec2["title"] == "hello"
-    assert rec2["button"] == "click"
-    assert rec2["href"] is None
-    assert rec2["context"] == cmd.values
-    assert rec2["command"]["type"] == cmd.Meta.key.lower()
-
-    assert rec3["title"] == "yeehaw"
-    assert rec3["button"] == "click here"
-    assert rec3["href"] is None
-    assert rec3["command"]["type"] == cmd.Meta.key.lower()
-    for k, v in init_params.items():
-        assert rec3["context"][k] == v

canvas_sdk/questionnaires/tests/test_utils.py

@@ -1,74 +0,0 @@
-import json
-from pathlib import Path
-
-import pytest
-import yaml
-
-from canvas_sdk.effects import Effect
-from canvas_sdk.events import Event, EventRequest, EventType
-from canvas_sdk.questionnaires import questionnaire_from_yaml
-from plugin_runner.plugin_runner import LOADED_PLUGINS
-from settings import PLUGIN_DIRECTORY
-
-
-@pytest.mark.parametrize("install_test_plugin", ["test_load_questionnaire"], indirect=True)
-def test_from_yaml_valid_questionnaire(install_test_plugin: Path, load_test_plugins: None) -> None:
-    """Test that the from_yaml function loads a valid questionnaire."""
-    plugin = LOADED_PLUGINS[
-        "test_load_questionnaire:test_load_questionnaire.protocols.my_protocol:ValidQuestionnaire"
-    ]
-    result: list[Effect] = plugin["class"](Event(EventRequest(type=EventType.UNKNOWN))).compute()
-
-    assert (
-        yaml.load(
-            (
-                Path(PLUGIN_DIRECTORY)
-                / "test_load_questionnaire/questionnaires/example_questionnaire.yml"
-            )
-            .resolve()
-            .read_text(),
-            Loader=yaml.SafeLoader,
-        ).items()
-        <= json.loads(result[0].payload).items()
-    )
-
-
-@pytest.mark.parametrize("install_test_plugin", ["test_load_questionnaire"], indirect=True)
-def test_from_yaml_invalid_questionnaire(
-    install_test_plugin: Path, load_test_plugins: None
-) -> None:
-    """Test that the from_yaml function raises an error for invalid questionnaires."""
-    plugin = LOADED_PLUGINS[
-        "test_load_questionnaire:test_load_questionnaire.protocols.my_protocol:InvalidQuestionnaire"
-    ]
-    with pytest.raises(FileNotFoundError):
-        plugin["class"](Event(EventRequest(type=EventType.UNKNOWN))).compute()
-
-
-@pytest.mark.parametrize("install_test_plugin", ["test_load_questionnaire"], indirect=True)
-def test_from_yaml_forbidden_questionnaire(
-    install_test_plugin: Path, load_test_plugins: None
-) -> None:
-    """Test that the from_yaml function raises an error for a questionnaire outside plugin package."""
-    plugin = LOADED_PLUGINS[
-        "test_load_questionnaire:test_load_questionnaire.protocols.my_protocol:ForbiddenQuestionnaire"
-    ]
-    with pytest.raises(PermissionError):
-        plugin["class"](Event(EventRequest(type=EventType.UNKNOWN))).compute()
-
-
-def test_from_yaml_non_plugin_caller() -> None:
-    """Test that the from_yaml function returns None when called outside a plugin."""
-    assert questionnaire_from_yaml("questionnaires/example_questionnaire.yml") is None
-
-
-@pytest.mark.parametrize("install_test_plugin", ["test_load_questionnaire"], indirect=True)
-def test_from_yaml_sets_default_values(install_test_plugin: Path) -> None:
-    """Test that the from_yaml function sets default values for properties."""
-    globals()["__is_plugin__"] = True
-    globals()["__name__"] = "test_load_questionnaire"
-
-    definition = questionnaire_from_yaml("questionnaires/example_questionnaire.yml")
-
-    assert definition is not None
-    assert definition["display_results_in_social_history_section"] is False

canvas_sdk/templates/tests/test_utils.py

@@ -1,43 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from canvas_sdk.effects import Effect
-from canvas_sdk.events import Event, EventRequest, EventType
-from plugin_runner.plugin_runner import LOADED_PLUGINS
-
-
-@pytest.mark.parametrize("install_test_plugin", ["test_render_template"], indirect=True)
-def test_render_to_string_valid_template(
-    install_test_plugin: Path, load_test_plugins: None
-) -> None:
-    """Test that the render_to_string function loads and renders a valid template."""
-    plugin = LOADED_PLUGINS[
-        "test_render_template:test_render_template.protocols.my_protocol:ValidTemplate"
-    ]
-    result: list[Effect] = plugin["class"](Event(EventRequest(type=EventType.UNKNOWN))).compute()
-    assert "html" in result[0].payload
-
-
-@pytest.mark.parametrize("install_test_plugin", ["test_render_template"], indirect=True)
-def test_render_to_string_invalid_template(
-    install_test_plugin: Path, load_test_plugins: None
-) -> None:
-    """Test that the render_to_string function raises an error for invalid templates."""
-    plugin = LOADED_PLUGINS[
-        "test_render_template:test_render_template.protocols.my_protocol:InvalidTemplate"
-    ]
-    with pytest.raises(FileNotFoundError):
-        plugin["class"](Event(EventRequest(type=EventType.UNKNOWN))).compute()
-
-
-@pytest.mark.parametrize("install_test_plugin", ["test_render_template"], indirect=True)
-def test_render_to_string_forbidden_template(
-    install_test_plugin: Path, load_test_plugins: None
-) -> None:
-    """Test that the render_to_string function raises an error for a template outside plugin package."""
-    plugin = LOADED_PLUGINS[
-        "test_render_template:test_render_template.protocols.my_protocol:ForbiddenTemplate"
-    ]
-    with pytest.raises(PermissionError):
-        plugin["class"](Event(EventRequest(type=EventType.UNKNOWN))).compute()