test_experiments.py

# ruff: noqa: E402

import re
from copy import deepcopy
from datetime import date
from unittest.mock import patch

import jsonschema
import pytest
import requests
import requests_mock

arq = pytest.importorskip("arq")
cdot = pytest.importorskip("cdot")
fastapi = pytest.importorskip("fastapi")

from mavedb.lib.exceptions import NonexistentOrcidUserError
from mavedb.lib.validation.urn_re import MAVEDB_TMP_URN_RE
from mavedb.models.experiment import Experiment as ExperimentDbModel
from mavedb.models.experiment_set import ExperimentSet as ExperimentSetDbModel
from mavedb.models.score_set import ScoreSet as ScoreSetDbModel
from mavedb.view_models.experiment import Experiment, ExperimentCreate
from mavedb.view_models.orcid import OrcidUser
from tests.helpers.constants import (
    EXTRA_USER,
    TEST_BIORXIV_IDENTIFIER,
    TEST_CROSSREF_IDENTIFIER,
    TEST_EXPERIMENT_WITH_KEYWORD,
    TEST_EXPERIMENT_WITH_KEYWORD_HAS_DUPLICATE_OTHERS_RESPONSE,
    TEST_EXPERIMENT_WITH_KEYWORD_RESPONSE,
    TEST_EXPERIMENT_WITH_UPDATE_KEYWORD_RESPONSE,
    TEST_MEDRXIV_IDENTIFIER,
    TEST_MINIMAL_EXPERIMENT,
    TEST_MINIMAL_EXPERIMENT_RESPONSE,
    TEST_MINIMAL_SEQ_SCORESET,
    TEST_ORCID_ID,
    TEST_PUBMED_IDENTIFIER,
    TEST_PUBMED_URL_IDENTIFIER,
    TEST_USER,
    TEST_USER2,
)
from tests.helpers.dependency_overrider import DependencyOverrider
from tests.helpers.util.contributor import add_contributor
from tests.helpers.util.experiment import create_experiment
from tests.helpers.util.score_set import create_seq_score_set, create_seq_score_set_with_variants, publish_score_set
from tests.helpers.util.user import change_ownership
from tests.helpers.util.variant import mock_worker_variant_insertion


def test_test_minimal_experiment_is_valid():
    jsonschema.validate(instance=TEST_MINIMAL_EXPERIMENT, schema=ExperimentCreate.model_json_schema())


def test_create_minimal_experiment(client, setup_router_db):
    response = client.post("/api/v1/experiments/", json=TEST_MINIMAL_EXPERIMENT)
    assert response.status_code == 200
    response_data = response.json()
    jsonschema.validate(instance=response_data, schema=Experiment.model_json_schema())
    assert isinstance(MAVEDB_TMP_URN_RE.fullmatch(response_data["urn"]), re.Match)
    assert isinstance(MAVEDB_TMP_URN_RE.fullmatch(response_data["experimentSetUrn"]), re.Match)
    expected_response = deepcopy(TEST_MINIMAL_EXPERIMENT_RESPONSE)
    expected_response.update({"urn": response_data["urn"], "experimentSetUrn": response_data["experimentSetUrn"]})
    assert sorted(expected_response.keys()) == sorted(response_data.keys())
    for key in expected_response:
        assert (key, expected_response[key]) == (key, response_data[key])


def test_create_experiment_with_contributor(client, setup_router_db):
    experiment = deepcopy(TEST_MINIMAL_EXPERIMENT)
    experiment.update({"contributors": [{"orcid_id": TEST_ORCID_ID}]})

    with patch(
        "mavedb.lib.orcid.fetch_orcid_user",
        lambda orcid_id: OrcidUser(orcid_id=orcid_id, given_name="ORCID", family_name="User"),
    ):
        response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 200
    response_data = response.json()
    jsonschema.validate(instance=response_data, schema=Experiment.model_json_schema())
    assert isinstance(MAVEDB_TMP_URN_RE.fullmatch(response_data["urn"]), re.Match)
    assert isinstance(MAVEDB_TMP_URN_RE.fullmatch(response_data["experimentSetUrn"]), re.Match)
    expected_response = deepcopy(TEST_MINIMAL_EXPERIMENT_RESPONSE)
    expected_response.update({"urn": response_data["urn"], "experimentSetUrn": response_data["experimentSetUrn"]})
    expected_response["contributors"] = [
        {
            "recordType": "Contributor",
            "orcidId": TEST_ORCID_ID,
            "givenName": "ORCID",
            "familyName": "User",
        }
    ]
    assert sorted(expected_response.keys()) == sorted(response_data.keys())
    for key in expected_response:
        assert (key, expected_response[key]) == (key, response_data[key])


def test_cannot_create_experiment_with_nonexistent_contributor(client, setup_router_db):
    experiment = deepcopy(TEST_MINIMAL_EXPERIMENT)
    experiment.update({"contributors": [{"orcid_id": TEST_ORCID_ID}]})

    with patch(
        "mavedb.lib.orcid.fetch_orcid_user",
        side_effect=NonexistentOrcidUserError(f"No ORCID user was found for ORCID ID {TEST_ORCID_ID}."),
    ):
        response = client.post("/api/v1/experiments/", json=experiment)

    assert response.status_code == 404
    response_data = response.json()

    assert "No ORCID user was found for ORCID ID 1111-1111-1111-1111." in response_data["detail"]


def test_create_experiment_with_keywords(session, client, setup_router_db):
    response = client.post("/api/v1/experiments/", json=TEST_EXPERIMENT_WITH_KEYWORD)
    assert response.status_code == 200
    response_data = response.json()
    jsonschema.validate(instance=response_data, schema=Experiment.model_json_schema())
    assert isinstance(MAVEDB_TMP_URN_RE.fullmatch(response_data["urn"]), re.Match)
    assert isinstance(MAVEDB_TMP_URN_RE.fullmatch(response_data["experimentSetUrn"]), re.Match)
    expected_response = deepcopy(TEST_EXPERIMENT_WITH_KEYWORD_RESPONSE)
    expected_response.update({"urn": response_data["urn"], "experimentSetUrn": response_data["experimentSetUrn"]})
    assert sorted(expected_response.keys()) == sorted(response_data.keys())
    for key in expected_response:
        assert (key, expected_response[key]) == (key, response_data[key])


def test_cannot_create_experiment_without_email(client, setup_router_db):
    client.put("api/v1/users/me", json={"email": None})
    response = client.post("/api/v1/experiments/", json=TEST_MINIMAL_EXPERIMENT)
    assert response.status_code == 403
    response_data = response.json()
    assert response_data["detail"] == "There must be an email address associated with your account to use this feature."


def test_cannot_create_experiment_that_keyword_does_not_match_db_keyword(client, setup_router_db):
    # Database does not have this keyword.
    invalid_keyword = {
        "keywords": [
            {
                "keyword": {
                    "key": "Invalid key",
                    "label": "Invalid label",
                },
            }
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **invalid_keyword}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 422
    response_data = response.json()
    assert response_data["detail"] == "Invalid keyword Invalid key or Invalid label"


def test_cannot_create_experiment_that_keywords_has_wrong_combination1(client, setup_router_db):
    # Test src/mavedb/lib/validation/keywords.validate_keyword_keys function
    wrong_keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "Endogenous locus library method",
                    "special": False,
                    "description": "Description",
                },
            },
            {
                "keyword": {
                    "key": "In Vitro Construct Library Method System",
                    "label": "Oligo-directed mutagenic PCR",
                    "special": False,
                    "description": "Description",
                },
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **wrong_keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 422
    response_data = response.json()
    assert (
        response_data["detail"]
        == "If 'Variant Library Creation Method' is 'Endogenous locus library method', both 'Endogenous Locus "
        "Library Method System' and 'Endogenous Locus Library Method Mechanism' must be present."
    )


def test_cannot_create_experiment_that_keywords_has_wrong_combination2(client, setup_router_db):
    # Test src/mavedb/lib/validation/keywords.validate_keyword_keys function
    wrong_keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "In vitro construct library method",
                    "special": False,
                    "description": "Description",
                },
            },
            {
                "keyword": {
                    "key": "Endogenous Locus Library Method System",
                    "label": "SaCas9",
                    "special": False,
                    "description": "Description",
                },
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **wrong_keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 422
    response_data = response.json()
    assert (
        response_data["detail"]
        == "If 'Variant Library Creation Method' is 'In vitro construct library method', both 'In Vitro Construct "
        "Library Method System' and 'In Vitro Construct Library Method Mechanism' must be present."
    )


def test_cannot_create_experiment_that_keywords_has_wrong_combination3(client, setup_router_db):
    """
    Test src/mavedb/lib/validation/keywords.validate_keyword_keys function
    If choose Other in Variant Library Creation Method, should not have Endogenous
    """
    wrong_keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "Other",
                    "special": False,
                    "description": "Description",
                },
                "description": "Description",
            },
            {
                "keyword": {
                    "key": "Endogenous Locus Library Method System",
                    "label": "SaCas9",
                    "special": False,
                    "description": "Description",
                },
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **wrong_keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 422
    response_data = response.json()
    assert (
        response_data["detail"]
        == "If 'Variant Library Creation Method' is 'Other', none of 'Endogenous Locus Library Method System', "
        "'Endogenous Locus Library Method Mechanism', 'In Vitro Construct Library Method System', or 'In Vitro "
        "Construct Library Method Mechanism' should be present."
    )


def test_cannot_create_experiment_that_keywords_has_wrong_combination4(client, setup_router_db):
    """
    Test src/mavedb/lib/validation/keywords.validate_keyword_keys function
    If choose Other in Variant Library Creation Method, should not have in vitro
    """
    wrong_keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "Other",
                    "special": False,
                    "description": "Description",
                },
                "description": "Description",
            },
            {
                "keyword": {
                    "key": "In Vitro Construct Library Method System",
                    "label": "Error-prone PCR",
                    "special": False,
                    "description": "Description",
                },
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **wrong_keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 422
    response_data = response.json()
    assert (
        response_data["detail"]
        == "If 'Variant Library Creation Method' is 'Other', none of 'Endogenous Locus Library Method System', "
        "'Endogenous Locus Library Method Mechanism', 'In Vitro Construct Library Method System', or 'In Vitro "
        "Construct Library Method Mechanism' should be present."
    )


# Test the validator of Endogenous locus keywords
def test_create_experiment_that_keywords_has_endogenous(client, setup_router_db):
    """
    Test src/mavedb/lib/validation/keywords.validate_keyword_keys function
    if users choose endogenous locus library method in Variant Library Creation Method
    """
    keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "Endogenous locus library method",
                    "special": False,
                    "description": "Description",
                },
            },
            {
                "keyword": {
                    "key": "Endogenous Locus Library Method System",
                    "label": "SaCas9",
                    "special": False,
                    "description": "Description",
                },
            },
            {
                "keyword": {
                    "key": "Endogenous Locus Library Method Mechanism",
                    "label": "Base editor",
                    "special": False,
                    "description": "Description",
                },
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 200


def test_cannot_create_experiment_that_keywords_has_endogenous_without_method_mechanism(client, setup_router_db):
    """
    Test src/mavedb/lib/validation/keywords.validate_keyword_keys function
    Choose endogenous locus library method in Variant Library Creation Method,
    but miss the endogenous locus library method mechanism
    """
    incomplete_keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "Endogenous locus library method",
                    "special": False,
                    "description": "Description",
                },
            },
            {
                "keyword": {
                    "key": "Endogenous Locus Library Method System",
                    "label": "SaCas9",
                    "special": False,
                    "description": "Description",
                },
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **incomplete_keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 422
    response_data = response.json()
    assert (
        response_data["detail"] == "If 'Variant Library Creation Method' is 'Endogenous locus library method', "
        "both 'Endogenous Locus Library Method System' and 'Endogenous Locus Library Method Mechanism' "
        "must be present."
    )


def test_cannot_create_experiment_that_keywords_has_endogenous_without_method_system(client, setup_router_db):
    """
    Test src/mavedb/lib/validation/keywords.validate_keyword_keys function
    Choose endogenous locus library method in Variant Library Creation Method,
    but miss the endogenous locus library method system
    """
    incomplete_keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "Endogenous locus library method",
                    "special": False,
                    "description": "Description",
                },
            },
            {
                "keyword": {
                    "key": "Endogenous Locus Library Method Mechanism",
                    "label": "Base editor",
                    "special": False,
                    "description": "Description",
                },
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **incomplete_keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 422
    response_data = response.json()
    assert (
        response_data["detail"] == "If 'Variant Library Creation Method' is 'Endogenous locus library method', "
        "both 'Endogenous Locus Library Method System' and 'Endogenous Locus Library Method Mechanism' "
        "must be present."
    )


# Test the validator of in vitro keywords
def test_create_experiment_that_keywords_has_in_vitro(client, setup_router_db):
    """
    Test src/mavedb/lib/validation/keywords.validate_keyword_keys function
    if users choose in vitro construct library method in Variant Library Creation Method
    """
    keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "In vitro construct library method",
                    "special": False,
                    "description": "Description",
                },
            },
            {
                "keyword": {
                    "key": "In Vitro Construct Library Method System",
                    "label": "Oligo-directed mutagenic PCR",
                    "special": False,
                    "description": "Description",
                },
            },
            {
                "keyword": {
                    "key": "In Vitro Construct Library Method Mechanism",
                    "label": "Native locus replacement",
                    "special": False,
                    "description": "Description",
                },
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 200


def test_cannot_create_experiment_that_keywords_has_in_vitro_without_method_system(client, setup_router_db):
    """
    Test src/mavedb/lib/validation/keywords.validate_keyword_keys function
    Choose in vitro construct library method in Variant Library Creation Method,
    but miss the in vitro construct library method system
    """
    incomplete_keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "In vitro construct library method",
                    "special": False,
                    "description": "Description",
                },
            },
            {
                "keyword": {
                    "key": "In Vitro Construct Library Method Mechanism",
                    "label": "Native locus replacement",
                    "special": False,
                    "description": "Description",
                },
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **incomplete_keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 422
    response_data = response.json()
    assert (
        response_data["detail"] == "If 'Variant Library Creation Method' is 'In vitro construct library method', "
        "both 'In Vitro Construct Library Method System' and 'In Vitro Construct Library Method Mechanism' "
        "must be present."
    )


def test_cannot_create_experiment_that_keywords_has_in_vitro_without_method_mechanism(client, setup_router_db):
    """
    Test src/mavedb/lib/validation/keywords.validate_keyword_keys function
    Choose in vitro construct library method in Variant Library Creation Method,
    but miss the in vitro construct library method mechanism
    """
    incomplete_keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "In vitro construct library method",
                    "special": False,
                    "description": "Description",
                },
            },
            {
                "keyword": {
                    "key": "In Vitro Construct Library Method System",
                    "label": "Oligo-directed mutagenic PCR",
                    "special": False,
                    "description": "Description",
                },
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **incomplete_keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 422
    response_data = response.json()
    assert (
        response_data["detail"] == "If 'Variant Library Creation Method' is 'In vitro construct library method', "
        "both 'In Vitro Construct Library Method System' and 'In Vitro Construct Library Method Mechanism' "
        "must be present."
    )


def test_create_experiment_that_keyword_gene_ontology_has_valid_code(client, setup_router_db):
    valid_keyword = {
        "keywords": [
            {
                "keyword": {
                    "key": "Phenotypic Assay Mechanism",
                    "label": "Label",
                    "code": "GO:1234567",
                    "special": False,
                    "description": "Description",
                },
            },
        ],
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **valid_keyword}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 200
    response_data = response.json()
    assert response_data["keywords"][0]["keyword"]["key"] == "Phenotypic Assay Mechanism"
    assert response_data["keywords"][0]["keyword"]["label"] == "Label"
    assert response_data["keywords"][0]["keyword"]["code"] == "GO:1234567"


def test_create_experiment_that_keyword_gene_ontology_is_other_without_code(client, setup_router_db):
    valid_keyword = {
        "keywords": [
            {
                "keyword": {
                    "key": "Phenotypic Assay Mechanism",
                    "label": "Other",
                    "code": None,
                    "description": "Description",
                },
                "description": "Description",
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **valid_keyword}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 200
    response_data = response.json()
    assert response_data["keywords"][0]["keyword"]["key"] == "Phenotypic Assay Mechanism"
    assert response_data["keywords"][0]["keyword"]["label"] == "Other"


# TODO(#511) Re-enable the Gene Ontology code requirement.
# def test_cannot_create_experiment_that_keyword_has_an_invalid_code(client, setup_router_db):
#     invalid_keyword = {
#         "keywords": [
#             {
#                 "keyword": {
#                     "key": "Phenotypic Assay Mechanism",
#                     "label": "Label",
#                     "code": "invalid",
#                     "description": "Description",
#                 },
#             },
#         ]
#     }
#     experiment = {**TEST_MINIMAL_EXPERIMENT, **invalid_keyword}
#     response = client.post("/api/v1/experiments/", json=experiment)
#     assert response.status_code == 422
#     response_data = response.json()
#     assert "Invalid Gene Ontology accession." in response_data["detail"][0]["msg"]


def test_cannot_create_experiment_that_keyword_label_is_other_without_description(client, setup_router_db):
    """
    Test src/mavedb/lib/validation/keywords.validate_description function
    If choose other, description should not be null.
    """
    invalid_keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "Other",
                    "special": False,
                    "description": "Description",
                },
                "description": None,
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **invalid_keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 422
    response_data = response.json()
    assert "Other option does not allow empty description." in response_data["detail"][0]["msg"]


def test_cannot_create_experiment_that_keywords_have_duplicate_keys(client, setup_router_db):
    # Test src/mavedb/lib/validation/keywords.validate_duplicates function
    invalid_keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "Other",
                    "special": False,
                    "description": "Description",
                },
                "description": "Description",
            },
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "In vitro construct library method",
                    "special": False,
                    "description": "Description",
                },
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **invalid_keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 422
    response_data = response.json()
    assert response_data["detail"] == "Duplicate keys found in keywords."


def test_cannot_create_experiment_that_keywords_have_duplicate_labels(client, setup_router_db):
    """
    Test src/mavedb/lib/validation/keywords.validate_duplicates function
    Keyword labels are not allowed duplicates except Other.
    """
    invalid_keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Delivery Method",
                    "label": "In vitro construct library method",
                    "special": False,
                    "description": "Description",
                },
            },
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "In vitro construct library method",
                    "special": False,
                    "description": "Description",
                },
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **invalid_keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 422
    response_data = response.json()
    assert response_data["detail"] == "Duplicate labels found in keywords."


def test_create_experiment_that_keywords_have_duplicate_others(client, setup_router_db):
    """
    Test src/mavedb/lib/validation/keywords.validate_duplicates function
    Keyword labels are not allowed duplicates except Other.
    """
    keywords = {
        "keywords": [
            {
                "keyword": {
                    "key": "Variant Library Creation Method",
                    "label": "Other",
                    "special": False,
                    "description": "Description",
                },
                "description": "Description",
            },
            {
                "keyword": {"key": "Delivery Method", "label": "Other", "special": False, "description": "Description"},
                "description": "Description",
            },
        ]
    }
    experiment = {**TEST_MINIMAL_EXPERIMENT, **keywords}
    response = client.post("/api/v1/experiments/", json=experiment)
    assert response.status_code == 200
    response_data = response.json()
    jsonschema.validate(instance=response_data, schema=Experiment.model_json_schema())
    assert isinstance(MAVEDB_TMP_URN_RE.fullmatch(response_data["urn"]), re.Match)
    assert isinstance(MAVEDB_TMP_URN_RE.fullmatch(response_data["experimentSetUrn"]), re.Match)
    expected_response = deepcopy(TEST_EXPERIMENT_WITH_KEYWORD_HAS_DUPLICATE_OTHERS_RESPONSE)
    expected_response.update({"urn": response_data["urn"], "experimentSetUrn": response_data["experimentSetUrn"]})
    assert sorted(expected_response.keys()) == sorted(response_data.keys())
    for key in expected_response:
        assert (key, expected_response[key]) == (key, response_data[key])


def test_update_experiment_keywords(session, client, setup_router_db):
    response = client.post("/api/v1/experiments/", json=TEST_EXPERIMENT_WITH_KEYWORD)
    assert response.status_code == 200
    experiment = response.json()
    experiment_post_payload = experiment.copy()
    experiment_post_payload.update(
        {
            "keywords": [
                {
                    "keyword": {
                        "key": "Phenotypic Assay Profiling Strategy",
                        "label": "Shotgun sequencing",
                        "special": False,
                        "description": "Description",
                    },
                    "description": "Details of phenotypic assay profiling strategy",
                },
            ]
        }
    )
    updated_response = client.put(f"/api/v1/experiments/{experiment['urn']}", json=experiment_post_payload)
    assert updated_response.status_code == 200
    updated_experiment = updated_response.json()
    updated_expected_response = deepcopy(TEST_EXPERIMENT_WITH_UPDATE_KEYWORD_RESPONSE)
    updated_expected_response.update(
        {"urn": updated_experiment["urn"], "experimentSetUrn": updated_experiment["experimentSetUrn"]}
    )
    assert sorted(updated_expected_response.keys()) == sorted(updated_experiment.keys())
    for key in updated_experiment:
        assert (key, updated_expected_response[key]) == (key, updated_experiment[key])
    for kw in updated_experiment["keywords"]:
        assert "Delivery Method" not in kw["keyword"]["key"]


def test_update_experiment_keywords_case_insensitive(session, client, setup_router_db):
    experiment = create_experiment(client)
    experiment_post_payload = experiment.copy()
    # Test database has Delivery Method. The updating keyword's key is delivery method.
    experiment_post_payload.update(
        {
            "keywords": [
                {
                    "keyword": {
                        "key": "delivery method",
                        "label": "Other",
                        "special": False,
                        "description": "Description",
                    },
                    "description": "Details of delivery method",
                },
            ]
        }
    )
    response = client.put(f"/api/v1/experiments/{experiment['urn']}", json=experiment_post_payload)
    response_data = response.json()
    expected_response = deepcopy(TEST_EXPERIMENT_WITH_KEYWORD_RESPONSE)
    expected_response.update({"urn": response_data["urn"], "experimentSetUrn": response_data["experimentSetUrn"]})
    assert sorted(expected_response.keys()) == sorted(response_data.keys())
    for key in expected_response:
        assert (key, expected_response[key]) == (key, response_data[key])


def test_can_delete_experiment(client, setup_router_db):
    experiment = create_experiment(client)
    response = client.delete(f"api/v1/experiments/{experiment['urn']}")
    assert response.status_code == 200
    get_response = client.get(f"api/v1/experiments/{experiment['urn']}")
    assert get_response.status_code == 404


@pytest.mark.parametrize(
    "test_field,test_value",
    [
        ("urn", "tmp:33df10c9-78b3-4e04-bafb-2446078573d7"),
        ("numScoreSets", 2),
        ("createdBy", {"firstName": "Sneaky", "lastName": "User", "orcidId": "0000-9999-9999-0000"}),
        ("modifiedBy", {"firstName": "Sneaky", "lastName": "User", "orcidId": "0000-9999-9999-0000"}),
        ("creationDate", date(2020, 4, 1).isoformat()),
        ("modificationDate", date(2020, 4, 1).isoformat()),
        ("publishedDate", date(2020, 4, 1).isoformat()),
    ],
)
def test_cannot_create_special_fields(client, setup_router_db, test_field, test_value):
    response_data = create_experiment(client, {test_field: test_value})
    if test_field in response_data:
        assert (test_field, response_data[test_field]) != (test_field, test_value)


@pytest.mark.parametrize(
    "test_field,test_value",
    [
        ("createdBy", {"firstName": "Sneaky", "lastName": "User", "orcidId": "0000-9999-9999-0000"}),
        ("modifiedBy", {"firstName": "Sneaky", "lastName": "User", "orcidId": "0000-9999-9999-0000"}),
        ("creationDate", date(2020, 4, 1).isoformat()),
        ("modificationDate", date(2020, 4, 1).isoformat()),
        ("publishedDate", date(2020, 4, 1).isoformat()),
    ],
)
def test_cannot_edit_special_fields(client, setup_router_db, test_field, test_value):
    experiment = create_experiment(client)
    response_data = create_experiment(client, {test_field: test_value, "urn": experiment["urn"]})
    if test_field in response_data:
        assert (test_field, response_data[test_field]) != (test_field, test_value)


def test_cannot_assign_to_missing_experiment_set(client, setup_router_db):
    experiment_set_urn = "tmp:33df10c9-78b3-4e04-bafb-2446078573d7"
    experiment_post_payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
    experiment_post_payload.update({"experimentSetUrn": experiment_set_urn})
    response = client.post("/api/v1/experiments/", json=experiment_post_payload)
    assert response.status_code == 404
    response_data = response.json()
    assert f"experiment set with URN '{experiment_set_urn}' not found" in response_data["detail"]


def test_can_update_own_private_experiment_set(session, client, setup_router_db):
    experiment = create_experiment(client)
    experiment_post_payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
    experiment_post_payload.update({"experimentSetUrn": experiment["experimentSetUrn"], "title": "Second Experiment"})
    response = client.post("/api/v1/experiments/", json=experiment_post_payload)
    assert response.status_code == 200
    assert response.json()["experimentSetUrn"] == experiment["experimentSetUrn"]
    assert response.json()["title"] == "Second Experiment"


def test_cannot_update_other_users_private_experiment_set(session, client, setup_router_db):
    experiment = create_experiment(client)
    change_ownership(session, experiment["urn"], ExperimentDbModel)
    change_ownership(session, experiment["experimentSetUrn"], ExperimentSetDbModel)
    experiment_post_payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
    experiment_post_payload.update({"experimentSetUrn": experiment["experimentSetUrn"]})
    response = client.post("/api/v1/experiments/", json=experiment_post_payload)
    assert response.status_code == 404
    response_data = response.json()
    assert f"experiment set with URN '{experiment['experimentSetUrn']}' not found" in response_data["detail"]


def test_anonymous_cannot_update_other_users_private_experiment_set(
    session, client, anonymous_app_overrides, setup_router_db
):
    experiment = create_experiment(client)
    experiment_post_payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
    experiment_post_payload.update({"experimentSetUrn": experiment["experimentSetUrn"]})

    with DependencyOverrider(anonymous_app_overrides):
        response = client.post("/api/v1/experiments/", json=experiment_post_payload)

    assert response.status_code == 401
    response_data = response.json()
    assert "Could not validate credentials" in response_data["detail"]


def test_admin_can_update_other_users_private_experiment_set(session, client, admin_app_overrides, setup_router_db):
    experiment = create_experiment(client)
    experiment_post_payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
    experiment_post_payload.update({"experimentSetUrn": experiment["experimentSetUrn"], "title": "Second Experiment"})

    with DependencyOverrider(admin_app_overrides):
        response = client.post("/api/v1/experiments/", json=experiment_post_payload)

    assert response.status_code == 200
    assert response.json()["experimentSetUrn"] == experiment["experimentSetUrn"]
    assert response.json()["title"] == "Second Experiment"


def test_can_update_own_public_experiment_set(session, data_provider, client, setup_router_db, data_files):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    response_data = create_experiment(
        client,
        {"experimentSetUrn": published_score_set["experiment"]["experimentSetUrn"], "title": "Second Experiment"},
    )
    assert response_data["experimentSetUrn"] == published_score_set["experiment"]["experimentSetUrn"]
    assert response_data["title"] == "Second Experiment"


def test_cannot_update_other_users_public_experiment_set(session, data_provider, client, setup_router_db, data_files):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    published_experiment_set_urn = published_score_set["experiment"]["experimentSetUrn"]
    change_ownership(session, published_experiment_set_urn, ExperimentSetDbModel)
    experiment_post_payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
    experiment_post_payload.update({"experimentSetUrn": published_experiment_set_urn, "title": "Second Experiment"})
    response = client.post("/api/v1/experiments/", json=experiment_post_payload)
    assert response.status_code == 403
    response_data = response.json()
    assert (
        f"insufficient permissions on experiment set with URN '{published_experiment_set_urn}'"
        in response_data["detail"]
    )


def test_anonymous_cannot_update_others_user_public_experiment_set(
    session, data_provider, client, anonymous_app_overrides, setup_router_db, data_files
):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    published_experiment_set_urn = published_score_set["experiment"]["experimentSetUrn"]
    experiment_post_payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
    experiment_post_payload.update({"experimentSetUrn": published_experiment_set_urn, "title": "Second Experiment"})

    with DependencyOverrider(anonymous_app_overrides):
        response = client.post("/api/v1/experiments/", json=experiment_post_payload)

    assert response.status_code == 401
    response_data = response.json()
    assert "Could not validate credentials" in response_data["detail"]


def test_admin_can_update_other_users_public_experiment_set(
    session, data_provider, client, admin_app_overrides, setup_router_db, data_files
):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    with DependencyOverrider(admin_app_overrides):
        response_data = create_experiment(
            client,
            {"experimentSetUrn": published_score_set["experiment"]["experimentSetUrn"], "title": "Second Experiment"},
        )
    assert response_data["experimentSetUrn"] == published_score_set["experiment"]["experimentSetUrn"]
    assert response_data["title"] == "Second Experiment"


def test_edit_preserves_optional_metadata(client, setup_router_db):
    pass


@pytest.mark.parametrize(
    "test_field,test_value",
    [
        ("title", "Edited Title"),
        ("shortDescription", "Edited Short Description"),
        ("abstractText", "Edited Abstract"),
        ("methodText", "Edited Methods"),
    ],
)
def test_can_edit_private_experiment(client, setup_router_db, test_field, test_value):
    experiment = create_experiment(client)
    experiment_post_payload = experiment.copy()
    experiment_post_payload.update({test_field: test_value, "urn": experiment["urn"]})
    response = client.put(f"/api/v1/experiments/{experiment['urn']}", json=experiment_post_payload)
    assert response.status_code == 200
    response_data = response.json()
    jsonschema.validate(instance=response_data, schema=Experiment.model_json_schema())
    assert (test_field, response_data[test_field]) == (test_field, test_value)


def test_can_add_contributor_to_own_private_experiment(client, setup_router_db):
    experiment = create_experiment(client)
    experiment_post_payload = experiment.copy()
    experiment_post_payload.update({"contributors": [{"orcid_id": TEST_ORCID_ID}]})

    with patch(
        "mavedb.lib.orcid.fetch_orcid_user",
        lambda orcid_id: OrcidUser(orcid_id=orcid_id, given_name="ORCID", family_name="User"),
    ):
        response = client.put(f"/api/v1/experiments/{experiment['urn']}", json=experiment_post_payload)

    assert response.status_code == 200
    response_data = response.json()
    jsonschema.validate(instance=response_data, schema=Experiment.model_json_schema())
    assert ("contributors", response_data["contributors"]) == (
        "contributors",
        [
            {
                "recordType": "Contributor",
                "orcidId": TEST_ORCID_ID,
                "givenName": "ORCID",
                "familyName": "User",
            }
        ],
    )


def test_cannot_add_nonexistent_contributor_to_experiment(client, setup_router_db):
    experiment = create_experiment(client)
    experiment_post_payload = experiment.copy()
    experiment_post_payload.update({"contributors": [{"orcid_id": TEST_ORCID_ID}]})

    with patch(
        "mavedb.lib.orcid.fetch_orcid_user",
        side_effect=NonexistentOrcidUserError(f"No ORCID user was found for ORCID ID {TEST_ORCID_ID}."),
    ):
        response = client.put(f"/api/v1/experiments/{experiment['urn']}", json=experiment_post_payload)

    assert response.status_code == 404
    response_data = response.json()

    assert "No ORCID user was found for ORCID ID 1111-1111-1111-1111." in response_data["detail"]


@pytest.mark.parametrize(
    "test_field,test_value",
    [
        ("title", "Edited Title"),
        ("shortDescription", "Edited Short Description"),
        ("abstractText", "Edited Abstract"),
        ("methodText", "Edited Methods"),
    ],
)
def test_cannot_edit_other_users_private_experiment(client, session, setup_router_db, test_field, test_value):
    experiment = create_experiment(client)
    experiment_post_payload = experiment.copy()
    experiment_post_payload.update({test_field: test_value, "urn": experiment["urn"]})
    change_ownership(session, experiment["urn"], ExperimentDbModel)
    response = client.put(f"/api/v1/experiments/{experiment['urn']}", json=experiment_post_payload)
    assert response.status_code == 404
    response_data = response.json()
    assert f"experiment with URN '{experiment['urn']}' not found" in response_data["detail"]


@pytest.mark.parametrize(
    "test_field,test_value",
    [
        ("title", "Edited Title"),
        ("shortDescription", "Edited Short Description"),
        ("abstractText", "Edited Abstract"),
        ("methodText", "Edited Methods"),
    ],
)
def test_anonymous_cannot_update_other_users_private_experiment(
    client, anonymous_app_overrides, session, setup_router_db, test_field, test_value
):
    experiment = create_experiment(client)
    experiment_post_payload = experiment.copy()
    experiment_post_payload.update({test_field: test_value, "urn": experiment["urn"]})
    change_ownership(session, experiment["urn"], ExperimentDbModel)

    with DependencyOverrider(anonymous_app_overrides):
        response = client.put(f"/api/v1/experiments/{experiment['urn']}", json=experiment_post_payload)

    assert response.status_code == 401
    response_data = response.json()
    assert "Could not validate credentials" in response_data["detail"]


@pytest.mark.parametrize(
    "test_field,test_value",
    [
        ("title", "Edited Title"),
        ("shortDescription", "Edited Short Description"),
        ("abstractText", "Edited Abstract"),
        ("methodText", "Edited Methods"),
    ],
)
def test_contributor_can_update_other_users_private_experiment(
    session, client, test_field, test_value, setup_router_db
):
    experiment = create_experiment(client)
    change_ownership(session, experiment["urn"], ExperimentDbModel)
    add_contributor(
        session,
        experiment["urn"],
        ExperimentDbModel,
        TEST_USER["username"],
        TEST_USER["first_name"],
        TEST_USER["last_name"],
    )
    experiment_post_payload = experiment.copy()
    experiment_post_payload.update({test_field: test_value, "urn": experiment["urn"]})
    response = client.put(f"/api/v1/experiments/{experiment['urn']}", json=experiment_post_payload)
    assert response.status_code == 200
    response_data = response.json()
    jsonschema.validate(instance=response_data, schema=Experiment.model_json_schema())
    assert (test_field, response_data[test_field]) == (test_field, test_value)


@pytest.mark.parametrize(
    "test_field,test_value",
    [
        ("title", "Edited Title"),
        ("shortDescription", "Edited Short Description"),
        ("abstractText", "Edited Abstract"),
        ("methodText", "Edited Methods"),
    ],
)
def test_admin_can_update_other_users_private_experiment(
    client, admin_app_overrides, setup_router_db, test_field, test_value
):
    experiment = create_experiment(client)
    experiment_post_payload = experiment.copy()
    experiment_post_payload.update({test_field: test_value, "urn": experiment["urn"]})
    with DependencyOverrider(admin_app_overrides):
        response = client.put(f"/api/v1/experiments/{experiment['urn']}", json=experiment_post_payload)
    assert response.status_code == 200
    response_data = response.json()
    jsonschema.validate(instance=response_data, schema=Experiment.model_json_schema())
    assert (test_field, response_data[test_field]) == (test_field, test_value)


def test_can_add_two_contributors(session, client, setup_router_db):
    experiment = create_experiment(client)
    change_ownership(session, experiment["urn"], ExperimentDbModel)
    add_contributor(
        session,
        experiment["urn"],
        ExperimentDbModel,
        TEST_USER["username"],
        TEST_USER["first_name"],
        TEST_USER["last_name"],
    )
    add_contributor(
        session,
        experiment["urn"],
        ExperimentDbModel,
        TEST_USER2["username"],
        TEST_USER2["first_name"],
        TEST_USER2["last_name"],
    )
    response = client.get(f"/api/v1/experiments/{experiment['urn']}")
    assert response.status_code == 200
    response_data = response.json()
    assert len(response_data["contributors"]) == 2
    assert any(c["orcidId"] == TEST_USER["username"] for c in response_data["contributors"])
    assert any(c["orcidId"] == TEST_USER2["username"] for c in response_data["contributors"])


def test_can_edit_published_experiment(client, setup_router_db):
    pass


def test_cannot_edit_unowned_experiment(client, setup_router_db):
    pass


@pytest.mark.parametrize("test_field", ["title", "shortDescription", "abstractText", "methodText"])
def test_required_fields(client, setup_router_db, test_field):
    experiment_post_payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
    del experiment_post_payload[test_field]
    response = client.post("/api/v1/experiments/", json=experiment_post_payload)
    response_data = response.json()
    assert response.status_code == 422
    assert "Field required" in response_data["detail"][0]["msg"]


@pytest.mark.parametrize(
    "mock_publication_fetch",
    [({"dbName": "PubMed", "identifier": f"{TEST_PUBMED_IDENTIFIER}"})],
    indirect=["mock_publication_fetch"],
)
def test_create_experiment_with_new_primary_pubmed_publication(client, setup_router_db, mock_publication_fetch):
    mocked_publication = mock_publication_fetch
    response_data = create_experiment(client, {"primaryPublicationIdentifiers": [mocked_publication]})

    assert len(response_data["primaryPublicationIdentifiers"]) == 1
    assert sorted(response_data["primaryPublicationIdentifiers"][0]) == sorted(
        [
            "abstract",
            "id",
            "authors",
            "dbName",
            "doi",
            "identifier",
            "title",
            "url",
            "recordType",
            "referenceHtml",
            "publicationJournal",
            "publicationYear",
        ]
    )


@pytest.mark.parametrize(
    "mock_publication_fetch",
    [({"dbName": "PubMed", "identifier": f"{TEST_PUBMED_URL_IDENTIFIER}"})],
    indirect=["mock_publication_fetch"],
)
def test_create_experiment_with_new_primary_pubmed_url_publication(client, setup_router_db, mock_publication_fetch):
    mocked_publication = mock_publication_fetch
    response_data = create_experiment(client, {"primaryPublicationIdentifiers": [mocked_publication]})

    assert len(response_data["primaryPublicationIdentifiers"]) == 1
    assert sorted(response_data["primaryPublicationIdentifiers"][0]) == sorted(
        [
            "abstract",
            "id",
            "authors",
            "dbName",
            "doi",
            "identifier",
            "title",
            "url",
            "recordType",
            "referenceHtml",
            "publicationJournal",
            "publicationYear",
        ]
    )
    assert response_data["primaryPublicationIdentifiers"][0]["identifier"] == "37162834"


@pytest.mark.parametrize(
    "mock_publication_fetch",
    [
        ({"dbName": "bioRxiv", "identifier": f"{TEST_BIORXIV_IDENTIFIER}"}),
        ({"dbName": "medRxiv", "identifier": f"{TEST_MEDRXIV_IDENTIFIER}"}),
    ],
    indirect=["mock_publication_fetch"],
)
def test_create_experiment_with_new_primary_preprint_publication(client, setup_router_db, mock_publication_fetch):
    mocked_publication = mock_publication_fetch
    response_data = create_experiment(client, {"primaryPublicationIdentifiers": [mocked_publication]})

    assert len(response_data["primaryPublicationIdentifiers"]) == 1
    assert sorted(response_data["primaryPublicationIdentifiers"][0]) == sorted(
        [
            "abstract",
            "id",
            "authors",
            "dbName",
            "identifier",
            "title",
            "url",
            "recordType",
            "referenceHtml",
            "doi",
            "publicationJournal",
            "publicationYear",
        ]
    )
    # TODO: add separate tests for generating the publication url and referenceHtml


@pytest.mark.parametrize(
    "mock_publication_fetch",
    [
        ({"dbName": "Crossref", "identifier": f"{TEST_CROSSREF_IDENTIFIER}"}),
    ],
    indirect=["mock_publication_fetch"],
)
def test_create_experiment_with_new_primary_crossref_publication(client, setup_router_db, mock_publication_fetch):
    mocked_publication = mock_publication_fetch
    response_data = create_experiment(client, {"primaryPublicationIdentifiers": [mocked_publication]})

    assert len(response_data["primaryPublicationIdentifiers"]) == 1
    assert sorted(response_data["primaryPublicationIdentifiers"][0]) == sorted(
        [
            "abstract",
            "id",
            "authors",
            "dbName",
            "identifier",
            "title",
            "url",
            "recordType",
            "referenceHtml",
            "doi",
            "publicationJournal",
            "publicationYear",
        ]
    )
    # TODO: add separate tests for generating the publication url and referenceHtml


@pytest.mark.parametrize(
    "db_name, identifier", [("biorxiv", TEST_BIORXIV_IDENTIFIER), ("medrxiv", TEST_MEDRXIV_IDENTIFIER)]
)
def test_create_experiment_rxiv_not_found(client, setup_router_db, db_name, identifier):
    with requests_mock.mock() as m:
        m.get(
            f"https://api.biorxiv.org/details/{db_name}/10.1101/{identifier}/na/json",
            json={"messages": [{"status": "no posts found"}], "collection": []},
        )
        payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
        payload["primaryPublicationIdentifiers"] = [{"identifier": f"{identifier}"}]
        r = client.post("/api/v1/experiments/", json=payload)

        assert m.called

        assert r.status_code == 404


@pytest.mark.parametrize(
    "db_name, identifier", [("biorxiv", TEST_BIORXIV_IDENTIFIER), ("medrxiv", TEST_MEDRXIV_IDENTIFIER)]
)
def test_create_experiment_rxiv_timeout(client, setup_router_db, db_name, identifier):
    with requests_mock.mock() as m:
        m.get(
            f"https://api.biorxiv.org/details/{db_name}/10.1101/{identifier}/na/json",
            exc=requests.exceptions.ConnectTimeout,
        )
        payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
        payload["primaryPublicationIdentifiers"] = [{"identifier": f"{identifier}"}]
        r = client.post("/api/v1/experiments/", json=payload)

        assert m.called
        assert r.status_code == 504


@pytest.mark.parametrize(
    "db_name, identifier", [("biorxiv", TEST_BIORXIV_IDENTIFIER), ("medrxiv", TEST_MEDRXIV_IDENTIFIER)]
)
def test_create_experiment_rxiv_unavailable(client, setup_router_db, db_name, identifier):
    with requests_mock.mock() as m:
        m.get(f"https://api.biorxiv.org/details/{db_name}/10.1101/{identifier}/na/json", status_code=503)
        payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
        payload["primaryPublicationIdentifiers"] = [{"identifier": f"{identifier}"}]
        r = client.post("/api/v1/experiments/", json=payload)

        assert m.called
        assert r.status_code == 502


@pytest.mark.parametrize("db_name, identifier", [("Crossref", TEST_CROSSREF_IDENTIFIER)])
def test_create_experiment_crossref_not_found(client, setup_router_db, db_name, identifier):
    with requests_mock.mock() as m:
        m.get(f"https://api.crossref.org/works/{identifier}", json="Resource not found.", status_code=404)
        payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
        payload["primaryPublicationIdentifiers"] = [{"identifier": f"{identifier}"}]
        r = client.post("/api/v1/experiments/", json=payload)

        assert m.called

        assert r.status_code == 404


@pytest.mark.parametrize("db_name, identifier", [("Crossref", TEST_CROSSREF_IDENTIFIER)])
def test_create_experiment_crossref_timeout(client, setup_router_db, db_name, identifier):
    with requests_mock.mock() as m:
        m.get(
            f"https://api.crossref.org/works/{identifier}",
            exc=requests.exceptions.ConnectTimeout,
        )
        payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
        payload["primaryPublicationIdentifiers"] = [{"identifier": f"{identifier}"}]
        r = client.post("/api/v1/experiments/", json=payload)

        assert m.called
        assert r.status_code == 504


@pytest.mark.parametrize("db_name, identifier", [("Crossref", TEST_CROSSREF_IDENTIFIER)])
def test_create_experiment_crossref_unavailable(client, setup_router_db, db_name, identifier):
    with requests_mock.mock() as m:
        m.get(f"https://api.crossref.org/works/{identifier}", status_code=503)
        payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
        payload["primaryPublicationIdentifiers"] = [{"identifier": f"{identifier}"}]
        r = client.post("/api/v1/experiments/", json=payload)

        assert m.called
        assert r.status_code == 502


def test_create_experiment_with_invalid_doi(client, setup_router_db):
    experiment_post_payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
    experiment_post_payload.update({"doiIdentifiers": [{"identifier": "20711194"}]})
    response = client.post("/api/v1/experiments/", json=experiment_post_payload)
    assert response.status_code == 422
    response_data = response.json()
    assert (
        f"'{experiment_post_payload['doiIdentifiers'][0]['identifier']}' is not a valid DOI identifier"
        in response_data["detail"][0]["msg"]
    )


def test_create_experiment_with_invalid_primary_publication(client, setup_router_db):
    experiment_post_payload = deepcopy(TEST_MINIMAL_EXPERIMENT)
    experiment_post_payload.update({"primaryPublicationIdentifiers": [{"identifier": "abcdefg"}]})
    response = client.post("/api/v1/experiments/", json=experiment_post_payload)
    assert response.status_code == 422
    response_data = response.json()
    assert (
        f"'{experiment_post_payload['primaryPublicationIdentifiers'][0]['identifier']}' is not a valid DOI or a valid PubMed, bioRxiv, or medRxiv identifier"
        in response_data["detail"][0]["msg"]
    )


def test_get_own_private_experiment(client, setup_router_db):
    experiment = create_experiment(client)
    expected_response = deepcopy(TEST_MINIMAL_EXPERIMENT_RESPONSE)
    expected_response.update({"urn": experiment["urn"], "experimentSetUrn": experiment["experimentSetUrn"]})
    response = client.get(f"/api/v1/experiments/{experiment['urn']}")
    assert response.status_code == 200
    response_data = response.json()
    jsonschema.validate(instance=response_data, schema=Experiment.model_json_schema())
    assert sorted(expected_response.keys()) == sorted(response_data.keys())
    for key in expected_response:
        assert (key, expected_response[key]) == (key, response_data[key])


def test_cannot_get_other_users_private_experiment(session, client, setup_router_db):
    experiment = create_experiment(client)
    change_ownership(session, experiment["urn"], ExperimentDbModel)
    change_ownership(session, experiment["experimentSetUrn"], ExperimentSetDbModel)
    response = client.get(f"/api/v1/experiments/{experiment['urn']}")
    assert response.status_code == 404
    response_data = response.json()
    assert f"experiment with URN '{experiment['urn']}' not found" in response_data["detail"]


def test_anonymous_cannot_get_users_private_experiment(session, client, anonymous_app_overrides, setup_router_db):
    experiment = create_experiment(client)
    with DependencyOverrider(anonymous_app_overrides):
        response = client.get(f"/api/v1/experiments/{experiment['urn']}")

    assert response.status_code == 404
    response_data = response.json()
    assert f"experiment with URN '{experiment['urn']}' not found" in response_data["detail"]


def test_admin_can_get_other_users_private_experiment(client, admin_app_overrides, setup_router_db):
    experiment = create_experiment(client)
    expected_response = deepcopy(TEST_MINIMAL_EXPERIMENT_RESPONSE)
    expected_response.update({"urn": experiment["urn"], "experimentSetUrn": experiment["experimentSetUrn"]})
    with DependencyOverrider(admin_app_overrides):
        response = client.get(f"/api/v1/experiments/{experiment['urn']}")

    assert response.status_code == 200
    response_data = response.json()
    jsonschema.validate(instance=response_data, schema=Experiment.model_json_schema())
    assert sorted(expected_response.keys()) == sorted(response_data.keys())
    for key in expected_response:
        assert (key, expected_response[key]) == (key, response_data[key])


def test_users_get_one_score_set_to_own_private_experiment(client, setup_router_db):
    experiment = create_experiment(client)
    score_set = create_seq_score_set(client, experiment["urn"])
    response = client.get(f"/api/v1/experiments/{experiment['urn']}")
    assert response.status_code == 200
    response_data = response.json()
    assert response_data["numScoreSets"] == 1
    assert score_set["urn"] in response_data["scoreSetUrns"]


def test_users_get_one_score_set_to_own_public_experiment(session, data_provider, client, setup_router_db, data_files):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set_with_variants(
        client, session, data_provider, experiment["urn"], data_files / "scores.csv"
    )
    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    response = client.get(f"/api/v1/experiments/{score_set['experiment']['urn']}")
    assert response.status_code == 200
    response_data = response.json()
    assert response_data["numScoreSets"] == 1
    assert score_set["urn"] in response_data["scoreSetUrns"]


def test_users_get_one_published_score_set_from_other_experiment(
    session, data_provider, client, setup_router_db, data_files
):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set_with_variants(
        client, session, data_provider, experiment["urn"], data_files / "scores.csv"
    )
    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()
    change_ownership(session, score_set["experiment"]["urn"], ExperimentDbModel)
    change_ownership(session, score_set["urn"], ScoreSetDbModel)
    response = client.get(f"/api/v1/experiments/{score_set['experiment']['urn']}")
    assert response.status_code == 200
    response_data = response.json()
    assert response_data["numScoreSets"] == 1
    assert score_set["urn"] in response_data["scoreSetUrns"]


def test_users_get_one_published_score_set_from_others_experiment_with_a_private_score_set(
    session, data_provider, client, setup_router_db, data_files
):
    experiment = create_experiment(client)
    score_set_1 = create_seq_score_set_with_variants(
        client, session, data_provider, experiment["urn"], data_files / "scores.csv"
    )
    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        pub_score_set = publish_score_set(client, score_set_1["urn"])
        worker_queue.assert_called_once()
    score_set_2 = create_seq_score_set_with_variants(
        client, session, data_provider, pub_score_set["experiment"]["urn"], data_files / "scores.csv"
    )
    change_ownership(session, score_set_2["urn"], ScoreSetDbModel)
    response = client.get(f"/api/v1/experiments/{pub_score_set['experiment']['urn']}")
    assert response.status_code == 200
    response_data = response.json()
    assert response_data["numScoreSets"] == 1
    assert pub_score_set["urn"] in response_data["scoreSetUrns"]


def test_users_get_two_score_sets_from_own_experiment_with_a_private_and_a_published_score_sets(
    session, data_provider, client, setup_router_db, data_files
):
    experiment = create_experiment(client)
    score_set_1 = create_seq_score_set_with_variants(
        client, session, data_provider, experiment["urn"], data_files / "scores.csv"
    )
    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        pub_score_set = publish_score_set(client, score_set_1["urn"])
        worker_queue.assert_called_once()
    score_set_2 = create_seq_score_set_with_variants(
        client, session, data_provider, pub_score_set["experiment"]["urn"], data_files / "scores.csv"
    )
    response = client.get(f"/api/v1/experiments/{pub_score_set['experiment']['urn']}")
    assert response.status_code == 200
    response_data = response.json()
    assert response_data["numScoreSets"] == 2
    assert pub_score_set["urn"] in response_data["scoreSetUrns"]
    assert score_set_2["urn"] in response_data["scoreSetUrns"]


def test_users_get_one_score_set_from_own_experiment_with_a_superseding_score_sets(
    session, data_provider, client, setup_router_db, data_files
):
    experiment = create_experiment(client)
    score_set = create_seq_score_set_with_variants(
        client, session, data_provider, experiment["urn"], data_files / "scores.csv"
    )
    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        pub_score_set = publish_score_set(client, score_set["urn"])
        worker_queue.assert_called_once()
    score_set_post_payload = deepcopy(TEST_MINIMAL_SEQ_SCORESET)
    score_set_post_payload["experimentUrn"] = pub_score_set["experiment"]["urn"]
    score_set_post_payload["supersededScoreSetUrn"] = pub_score_set["urn"]
    superseding_score_set_response = client.post("/api/v1/score-sets/", json=score_set_post_payload)
    assert superseding_score_set_response.status_code == 200
    superseding_score_set = superseding_score_set_response.json()
    response = client.get(f"/api/v1/experiments/{superseding_score_set['experiment']['urn']}")
    assert response.status_code == 200
    response_data = response.json()
    # Only the superseding score set in experiment's score set list.
    assert response_data["numScoreSets"] == 1
    assert superseding_score_set["urn"] in response_data["scoreSetUrns"]
    assert pub_score_set["urn"] not in response_data["scoreSetUrns"]


def test_search_experiments(session, client, setup_router_db):
    experiment = create_experiment(client)
    search_payload = {"text": experiment["shortDescription"]}
    response = client.post("/api/v1/experiments/search", json=search_payload)
    assert response.status_code == 200
    assert response.json()[0]["title"] == experiment["title"]


def test_search_my_experiments(session, client, setup_router_db):
    experiment = create_experiment(client)
    search_payload = {"text": experiment["shortDescription"]}
    response = client.post("/api/v1/me/experiments/search", json=search_payload)
    assert response.status_code == 200
    assert response.json()[0]["title"] == experiment["title"]


def test_search_meta_analysis_experiment(session, data_provider, client, setup_router_db, data_files):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    meta_score_set = create_seq_score_set(
        client,
        None,
        update={"title": "Test Meta Analysis", "metaAnalyzesScoreSetUrns": [score_set["urn"]]},
    )
    meta_score_set = mock_worker_variant_insertion(
        client, session, data_provider, meta_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_meta_score_set = publish_score_set(client, meta_score_set["urn"])
        worker_queue.assert_called_once()

    score_set_refresh = (client.get(f"/api/v1/score-sets/{score_set['urn']}")).json()
    search_payload = {"metaAnalysis": True}
    response = client.post("/api/v1/me/experiments/search", json=search_payload)
    assert response.status_code == 200
    response_data = response.json()
    assert any(item["urn"] == published_meta_score_set["experiment"]["urn"] for item in response_data)
    assert all(item["urn"] != score_set_refresh["experiment"]["urn"] for item in response_data)


def test_search_exclude_meta_analysis_experiment(session, data_provider, client, setup_router_db, data_files):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    meta_score_set = create_seq_score_set(
        client,
        None,
        update={"title": "Test Meta Analysis", "metaAnalyzesScoreSetUrns": [score_set["urn"]]},
    )
    meta_score_set = mock_worker_variant_insertion(
        client, session, data_provider, meta_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        meta_score_set = publish_score_set(client, meta_score_set["urn"])
        worker_queue.assert_called_once()

    score_set_refresh = (client.get(f"/api/v1/score-sets/{score_set['urn']}")).json()
    search_payload = {"metaAnalysis": False}
    response = client.post("/api/v1/me/experiments/search", json=search_payload)
    assert response.status_code == 200
    response_data = response.json()
    assert any(item["urn"] == score_set_refresh["experiment"]["urn"] for item in response_data)
    assert all(item["urn"] != meta_score_set["experiment"]["urn"] for item in response_data)


def test_search_score_sets_for_experiments(session, client, setup_router_db, data_files, data_provider):
    experiment = create_experiment(client)
    score_set = create_seq_score_set(client, experiment["urn"])
    score_set = mock_worker_variant_insertion(client, session, data_provider, score_set, data_files / "scores.csv")

    # make the unpublished score set owned by some other user. This shouldn't appear in the results.
    score_set_unpub = create_seq_score_set(client, experiment["urn"], update={"title": "Unpublished Score Set"})
    change_ownership(session, score_set_unpub["urn"], ScoreSetDbModel)

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, score_set["urn"])
        worker_queue.assert_called_once()

    # On score set publication, the experiment will get a new urn
    experiment_urn = published_score_set["experiment"]["urn"]
    response = client.get(f"/api/v1/experiments/{experiment_urn}/score-sets")
    assert response.status_code == 200
    assert len(response.json()) == 1
    assert response.json()[0]["urn"] == published_score_set["urn"]


# Creator created a superseding score set but not published it yet.
def test_owner_searches_score_sets_with_unpublished_superseding_score_sets_for_experiments(
    session, client, setup_router_db, data_files, data_provider
):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    score_set_post_payload = deepcopy(TEST_MINIMAL_SEQ_SCORESET)
    score_set_post_payload["experimentUrn"] = published_score_set["experiment"]["urn"]
    score_set_post_payload["supersededScoreSetUrn"] = published_score_set["urn"]
    superseding_score_set_response = client.post("/api/v1/score-sets/", json=score_set_post_payload)
    assert superseding_score_set_response.status_code == 200
    superseding_score_set = superseding_score_set_response.json()

    # On score set publication, the experiment will get a new urn
    experiment_urn = published_score_set["experiment"]["urn"]
    response = client.get(f"/api/v1/experiments/{experiment_urn}/score-sets")
    assert response.status_code == 200
    assert len(response.json()) == 1
    assert response.json()[0]["urn"] == superseding_score_set["urn"]


def test_non_owner_searches_score_sets_with_unpublished_superseding_score_sets_for_experiments(
    session, client, setup_router_db, data_files, data_provider
):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    score_set_post_payload = deepcopy(TEST_MINIMAL_SEQ_SCORESET)
    score_set_post_payload["experimentUrn"] = published_score_set["experiment"]["urn"]
    score_set_post_payload["supersededScoreSetUrn"] = published_score_set["urn"]
    superseding_score_set_response = client.post("/api/v1/score-sets/", json=score_set_post_payload)
    assert superseding_score_set_response.status_code == 200
    superseding_score_set = superseding_score_set_response.json()
    change_ownership(session, published_score_set["urn"], ScoreSetDbModel)
    change_ownership(session, superseding_score_set["urn"], ScoreSetDbModel)
    # On score set publication, the experiment will get a new urn
    experiment_urn = published_score_set["experiment"]["urn"]
    response = client.get(f"/api/v1/experiments/{experiment_urn}/score-sets")
    assert response.status_code == 200
    assert len(response.json()) == 1
    assert response.json()[0]["urn"] == published_score_set["urn"]


def test_owner_searches_published_superseding_score_sets_for_experiments(
    session, client, setup_router_db, data_files, data_provider
):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    # On score set publication, the experiment will get a new urn
    experiment_urn = published_score_set["experiment"]["urn"]
    superseding_score_set = create_seq_score_set(
        client, experiment_urn, update={"supersededScoreSetUrn": published_score_set["urn"]}
    )
    superseding_score_set = mock_worker_variant_insertion(
        client, session, data_provider, superseding_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_superseding_score_set = publish_score_set(client, superseding_score_set["urn"])
        worker_queue.assert_called_once()

    response = client.get(f"/api/v1/experiments/{experiment_urn}/score-sets")
    assert response.status_code == 200
    assert len(response.json()) == 1
    assert response.json()[0]["urn"] == published_superseding_score_set["urn"]


def test_non_owner_searches_published_superseding_score_sets_for_experiments(
    session, client, setup_router_db, data_files, data_provider
):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    # On score set publication, the experiment will get a new urn
    experiment_urn = published_score_set["experiment"]["urn"]
    superseding_score_set = create_seq_score_set(
        client, experiment_urn, update={"supersededScoreSetUrn": published_score_set["urn"]}
    )
    superseding_score_set = mock_worker_variant_insertion(
        client, session, data_provider, superseding_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_superseding_score_set = publish_score_set(client, superseding_score_set["urn"])
        worker_queue.assert_called_once()

    change_ownership(session, published_score_set["urn"], ScoreSetDbModel)
    change_ownership(session, published_superseding_score_set["urn"], ScoreSetDbModel)

    response = client.get(f"/api/v1/experiments/{experiment_urn}/score-sets")
    assert response.status_code == 200
    assert len(response.json()) == 1
    assert response.json()[0]["urn"] == published_superseding_score_set["urn"]


def test_search_score_sets_for_contributor_experiments(session, client, setup_router_db, data_files, data_provider):
    experiment = create_experiment(client)
    score_set = create_seq_score_set(client, experiment["urn"])
    score_set = mock_worker_variant_insertion(client, session, data_provider, score_set, data_files / "scores.csv")

    # make the unpublished score set owned by some other user. This shouldn't appear in the results.
    score_set_unpub = create_seq_score_set(client, experiment["urn"], update={"title": "Unpublished Score Set"})
    change_ownership(session, score_set_unpub["urn"], ScoreSetDbModel)
    add_contributor(
        session,
        score_set_unpub["urn"],
        ScoreSetDbModel,
        TEST_USER["username"],
        TEST_USER["first_name"],
        TEST_USER["last_name"],
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, score_set["urn"])
        worker_queue.assert_called_once()

    # On score set publication, the experiment will get a new urn
    experiment_urn = published_score_set["experiment"]["urn"]
    response = client.get(f"/api/v1/experiments/{experiment_urn}/score-sets")
    assert response.status_code == 200
    response_urns = [score_set["urn"] for score_set in response.json()]
    assert len(response_urns) == 2
    assert published_score_set["urn"] in response_urns
    assert score_set_unpub["urn"] in response_urns


def test_search_score_sets_for_my_experiments(session, client, setup_router_db, data_files, data_provider):
    experiment = create_experiment(client)
    score_set = create_seq_score_set(client, experiment["urn"])
    score_set = mock_worker_variant_insertion(client, session, data_provider, score_set, data_files / "scores.csv")

    # The unpublished score set is for the current user, so it should show up in results.
    score_set_unpub = create_seq_score_set(client, experiment["urn"], update={"title": "Unpublished Score Set"})
    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, score_set["urn"])
        worker_queue.assert_called_once()

    # On score set publication, the experiment will get a new urn
    experiment_urn = published_score_set["experiment"]["urn"]
    response = client.get(f"/api/v1/experiments/{experiment_urn}/score-sets")
    assert response.status_code == 200
    assert len(response.json()) == 2
    assert set(score_set["urn"] for score_set in response.json()) == set(
        (published_score_set["urn"], score_set_unpub["urn"])
    )


def test_search_their_experiments(session, client, setup_router_db):
    experiment = create_experiment(client)
    change_ownership(session, experiment["urn"], ExperimentDbModel)
    change_ownership(session, experiment["experimentSetUrn"], ExperimentSetDbModel)
    search_payload = {"text": experiment["shortDescription"]}
    response = client.post("/api/v1/experiments/search", json=search_payload)
    assert response.status_code == 200
    assert response.json()[0]["createdBy"]["orcidId"] == EXTRA_USER["username"]
    assert response.json()[0]["createdBy"]["firstName"] == EXTRA_USER["first_name"]


def test_search_not_my_experiments(session, client, setup_router_db):
    experiment = create_experiment(client)
    change_ownership(session, experiment["urn"], ExperimentDbModel)
    change_ownership(session, experiment["experimentSetUrn"], ExperimentSetDbModel)
    search_payload = {"text": experiment["shortDescription"]}
    response = client.post("/api/v1/me/experiments/search", json=search_payload)
    assert response.status_code == 200
    assert len(response.json()) == 0


def test_anonymous_search_experiments(session, client, anonymous_app_overrides, setup_router_db):
    experiment = create_experiment(client)
    search_payload = {"text": experiment["shortDescription"]}
    with DependencyOverrider(anonymous_app_overrides):
        response = client.post("/api/v1/experiments/search", json=search_payload)
    assert response.status_code == 200
    assert response.json()[0]["title"] == experiment["title"]


def test_anonymous_cannot_search_my_experiments(session, client, anonymous_app_overrides, setup_router_db):
    experiment = create_experiment(client)
    search_payload = {"text": experiment["shortDescription"]}
    with DependencyOverrider(anonymous_app_overrides):
        response = client.post("/api/v1/me/experiments/search", json=search_payload)
    assert response.status_code == 401
    assert response.json()["detail"] in "Could not validate credentials"


def test_anonymous_cannot_delete_other_users_private_experiment(
    session, client, setup_router_db, anonymous_app_overrides
):
    experiment = create_experiment(client)
    with DependencyOverrider(anonymous_app_overrides):
        response = client.delete(f"/api/v1/experiments/{experiment['urn']}")

    assert response.status_code == 401
    assert "Could not validate credentials" in response.json()["detail"]


def test_anonymous_cannot_delete_other_users_published_experiment(
    session, data_provider, client, setup_router_db, data_files, anonymous_app_overrides
):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    experiment_urn = score_set["experiment"]["urn"]
    with DependencyOverrider(anonymous_app_overrides):
        del_response = client.delete(f"/api/v1/experiments/{experiment_urn}")

    assert del_response.status_code == 401
    del_response_data = del_response.json()
    assert "Could not validate credentials" in del_response_data["detail"]


def test_can_delete_own_private_experiment(session, client, setup_router_db):
    experiment = create_experiment(client)
    response = client.delete(f"/api/v1/experiments/{experiment['urn']}")

    assert response.status_code == 200


def test_cannot_delete_own_published_experiment(session, data_provider, client, setup_router_db, data_files):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    experiment_urn = score_set["experiment"]["urn"]
    del_response = client.delete(f"/api/v1/experiments/{experiment_urn}")

    assert del_response.status_code == 403
    del_response_data = del_response.json()
    assert f"insufficient permissions on experiment with URN '{experiment_urn}'" in del_response_data["detail"]


def test_contributor_cannot_delete_other_users_private_experiment(
    session, client, setup_router_db, admin_app_overrides
):
    experiment = create_experiment(client)
    change_ownership(session, experiment["urn"], ExperimentDbModel)
    add_contributor(
        session,
        experiment["urn"],
        ExperimentDbModel,
        TEST_USER["username"],
        TEST_USER["first_name"],
        TEST_USER["last_name"],
    )
    response = client.delete(f"/api/v1/experiments/{experiment['urn']}")

    assert response.status_code == 403
    assert f"insufficient permissions on experiment with URN '{experiment['urn']}'" in response.json()["detail"]


def test_admin_can_delete_other_users_private_experiment(session, client, setup_router_db, admin_app_overrides):
    experiment = create_experiment(client)
    with DependencyOverrider(admin_app_overrides):
        response = client.delete(f"/api/v1/experiments/{experiment['urn']}")

    assert response.status_code == 200


def test_contributor_cannot_delete_other_users_published_experiment(
    session, data_provider, client, setup_router_db, data_files
):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )
    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    experiment_urn = score_set["experiment"]["urn"]
    change_ownership(session, experiment_urn, ExperimentDbModel)
    add_contributor(
        session,
        experiment_urn,
        ExperimentDbModel,
        TEST_USER["username"],
        TEST_USER["first_name"],
        TEST_USER["last_name"],
    )
    del_response = client.delete(f"/api/v1/experiments/{experiment_urn}")

    assert del_response.status_code == 403


def test_admin_can_delete_other_users_published_experiment(
    session, data_provider, client, setup_router_db, data_files, admin_app_overrides
):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    experiment_urn = score_set["experiment"]["urn"]
    with DependencyOverrider(admin_app_overrides):
        del_response = client.delete(f"/api/v1/experiments/{experiment_urn}")

    assert del_response.status_code == 200


def test_can_add_experiment_to_own_private_experiment_set(session, client, setup_router_db):
    experiment = create_experiment(client)
    test_experiment = deepcopy(TEST_MINIMAL_EXPERIMENT)
    test_experiment.update({"experimentSetUrn": experiment["experimentSetUrn"]})
    response = client.post("/api/v1/experiments/", json=test_experiment)
    assert response.status_code == 200


def test_can_add_experiment_to_own_public_experiment_set(session, data_provider, client, setup_router_db, data_files):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    test_experiment = deepcopy(TEST_MINIMAL_EXPERIMENT)
    test_experiment.update({"experimentSetUrn": published_score_set["experiment"]["experimentSetUrn"]})
    response = client.post("/api/v1/experiments/", json=test_experiment)
    assert response.status_code == 200


def test_contributor_can_add_experiment_to_others_private_experiment_set(session, client, setup_router_db):
    experiment = create_experiment(client)
    change_ownership(session, experiment["urn"], ExperimentDbModel)
    change_ownership(session, experiment["experimentSetUrn"], ExperimentSetDbModel)
    add_contributor(
        session,
        experiment["experimentSetUrn"],
        ExperimentSetDbModel,
        TEST_USER["username"],
        TEST_USER["first_name"],
        TEST_USER["last_name"],
    )
    test_experiment = deepcopy(TEST_MINIMAL_EXPERIMENT)
    test_experiment.update({"experimentSetUrn": experiment["experimentSetUrn"]})
    response = client.post("/api/v1/experiments/", json=test_experiment)
    assert response.status_code == 200


def test_contributor_can_add_experiment_to_others_public_experiment_set(
    session, data_provider, client, setup_router_db, data_files
):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    change_ownership(session, published_score_set["urn"], ScoreSetDbModel)
    change_ownership(session, published_score_set["experiment"]["urn"], ExperimentDbModel)
    change_ownership(session, published_score_set["experiment"]["experimentSetUrn"], ExperimentSetDbModel)
    add_contributor(
        session,
        published_score_set["experiment"]["experimentSetUrn"],
        ExperimentSetDbModel,
        TEST_USER["username"],
        TEST_USER["first_name"],
        TEST_USER["last_name"],
    )
    test_experiment = deepcopy(TEST_MINIMAL_EXPERIMENT)
    test_experiment.update({"experimentSetUrn": published_score_set["experiment"]["experimentSetUrn"]})
    response = client.post("/api/v1/experiments/", json=test_experiment)
    assert response.status_code == 200


def test_cannot_add_experiment_to_others_private_experiment_set(session, client, setup_router_db):
    experiment = create_experiment(client)
    experiment_set_urn = experiment["experimentSetUrn"]
    change_ownership(session, experiment["urn"], ExperimentDbModel)
    change_ownership(session, experiment_set_urn, ExperimentSetDbModel)
    test_experiment = deepcopy(TEST_MINIMAL_EXPERIMENT)
    test_experiment.update({"experimentSetUrn": experiment_set_urn})
    response = client.post("/api/v1/experiments/", json=test_experiment)
    assert response.status_code == 404
    response_data = response.json()
    assert f"experiment set with URN '{experiment_set_urn}' not found" in response_data["detail"]


def test_cannot_add_experiment_to_others_public_experiment_set(
    session, data_provider, client, setup_router_db, data_files
):
    experiment = create_experiment(client)
    unpublished_score_set = create_seq_score_set(client, experiment["urn"])
    unpublished_score_set = mock_worker_variant_insertion(
        client, session, data_provider, unpublished_score_set, data_files / "scores.csv"
    )

    with patch.object(arq.ArqRedis, "enqueue_job", return_value=None) as worker_queue:
        published_score_set = publish_score_set(client, unpublished_score_set["urn"])
        worker_queue.assert_called_once()

    experiment_set_urn = published_score_set["experiment"]["experimentSetUrn"]
    change_ownership(session, published_score_set["urn"], ScoreSetDbModel)
    change_ownership(session, published_score_set["experiment"]["urn"], ExperimentDbModel)
    change_ownership(session, experiment_set_urn, ExperimentSetDbModel)
    test_experiment = deepcopy(TEST_MINIMAL_EXPERIMENT)
    test_experiment.update({"experimentSetUrn": experiment_set_urn})
    response = client.post("/api/v1/experiments/", json=test_experiment)
    assert response.status_code == 403
    response_data = response.json()
    assert f"insufficient permissions on experiment set with URN '{experiment_set_urn}'" in response_data["detail"]