conftest.py

import json
import tempfile
from datetime import date, timedelta

import pytest
from django.core.files.images import ImageFile
from django.core.management import call_command
from django.db import connection
from django.urls import reverse
from pytest_factoryboy import register

from api.tests.factories import ApiTokenFactory
from applications.tests.factories import (
    MembershipApplicationFactory,
    SupporterApplicationFactory,
    VerificationApplicationFactory,
)
from comments.tests.factories import CommentFactory, DatedNoteFactory
from elections.tests.factories import (
    CandidateFactory,
    CandidatesListFactory,
    CandidatesListPartyFactory,
    ElectionFactory,
    ElectionPartyFactory,
)
from emails.tests.factories import EmailAccountFactory, EmailDomainFactory
from messaging.tests.factories import (
    MessageFactory,
    MessageTemplateFactory,
    SmsCounterFactory,
    VotingMessageFactory,
)
from notifications.tests.factories import EmailTemplateFactory, NotificationFactory
from onboarding.tests.factories import RegistrationFactory
from organization.config import MembershipCondition
from organization.models import Team, TeamMembership
from organization.tests.factories import (
    GroupConfigFactory,
    GroupFactory,
    GroupMembershipFactory,
    TeamFactory,
    TeamMembershipFactory,
)
from payments.tests.factories import PaymentFactory
from people.tests.factories import (
    EmailChangeRequestFactory,
    PersonActionLogFactory,
    PersonEventFactory,
    PersonFactory,
    PersonTagsLogFactory,
    ProblemTagFactory,
    UsernameLockFactory,
)
from profiles.tests.factories import ProfileFactory
from sync.tests.factories import MailtrainTeamShareFactory
from users.tests.factories import UserFactory

register(ApiTokenFactory)
register(CandidateFactory)
register(CandidatesListFactory)
register(CandidatesListPartyFactory)
register(CommentFactory)
register(DatedNoteFactory)
register(ElectionFactory)
register(ElectionPartyFactory)
register(EmailAccountFactory)
register(EmailChangeRequestFactory)
register(EmailDomainFactory)
register(EmailTemplateFactory)
register(GroupConfigFactory)
register(GroupFactory)
register(GroupMembershipFactory)
register(MailtrainTeamShareFactory)
register(MembershipApplicationFactory)
register(MessageFactory)
register(MessageTemplateFactory)
register(NotificationFactory)
register(PaymentFactory)
register(PersonActionLogFactory)
register(PersonEventFactory)
register(PersonFactory)
register(PersonTagsLogFactory)
register(ProblemTagFactory)
register(ProfileFactory)
register(RegistrationFactory)
register(SmsCounterFactory)
register(SupporterApplicationFactory)
register(TeamFactory)
register(TeamMembershipFactory)
register(UserFactory)
register(UsernameLockFactory)
register(VerificationApplicationFactory)
register(VotingMessageFactory)


@pytest.fixture(scope="session")
def django_db_setup(django_db_setup, django_db_blocker):
    with django_db_blocker.unblock():
        call_command("load_auth_groups")


@pytest.fixture(autouse=True)
def activate_postgresql_unaccent(db):
    with connection.cursor() as cursor:
        cursor.execute("CREATE EXTENSION IF NOT EXISTS unaccent;")


@pytest.fixture
def api_call(client):
    def fun(query, variables=None, headers=None):
        payload = {"query": query, "variables": variables or {}}
        headers = headers or {}
        response = client.post(
            reverse("graphql"),
            json.dumps(payload),
            content_type="application/json",
            **headers
        )
        return json.loads(response.content)

    return fun


@pytest.fixture
def date_gen():
    def gen():
        current = date(2020, 1, 1)
        day = timedelta(days=1)
        while True:
            yield current
            current += day

    return gen()


@pytest.fixture
def teams_set(team_factory):
    party = team_factory(type=Team.Type.PARTY, name="Party")
    cen = team_factory(type=Team.Type.CEN, parent=party, name="Centrála")
    cf = team_factory(type=Team.Type.CF, parent=cen, name="Celostátní fórum")
    ks_a = team_factory(
        type=Team.Type.KS,
        parent=party,
        name="KS A",
        shortcut_part="KSA",
        people_db_id=10001,
    )
    ks_b = team_factory(
        type=Team.Type.KS,
        parent=party,
        name="KS B",
        shortcut_part="KSB",
        people_db_id=20002,
    )
    kf_a = team_factory(type=Team.Type.KF, parent=ks_a, name="KF A")
    kf_b = team_factory(type=Team.Type.KF, parent=ks_b, name="KF B")
    pks_a = team_factory(type=Team.Type.PKS, parent=ks_a, name="PKS A")
    pks_b = team_factory(type=Team.Type.PKS, parent=ks_b, name="PKS B")
    ms_a = team_factory(
        type=Team.Type.MS, parent=ks_a, name="MS A", shortcut_part="MSA"
    )
    ms_b = team_factory(
        type=Team.Type.MS, parent=ks_b, name="MS B", shortcut_part="MSB"
    )
    mf_a = team_factory(type=Team.Type.MF, parent=ms_a, name="MF A")
    mf_b = team_factory(type=Team.Type.MF, parent=ms_b, name="MF B")
    pms_a = team_factory(type=Team.Type.PMS, parent=ms_a, name="PMS A")
    pms_b = team_factory(type=Team.Type.PMS, parent=ms_b, name="PMS B")
    return {
        "party": party,
        "cen": cen,
        "cf": cf,
        "ks_a": ks_a,
        "ks_b": ks_b,
        "kf_a": kf_a,
        "kf_b": kf_b,
        "pks_a": pks_a,
        "pks_b": pks_b,
        "ms_a": ms_a,
        "ms_b": ms_b,
        "mf_a": mf_a,
        "mf_b": mf_b,
        "pms_a": pms_a,
        "pms_b": pms_b,
    }


@pytest.fixture
def teams_extra(teams_set, team_factory):
    teams_set["regp"] = team_factory(
        type=Team.Type.REGP, parent=teams_set["cen"], name="RegP"
    )
    teams_set["some_team"] = team_factory(
        type=Team.Type.TEAM,
        parent=teams_set["cf"],
        name="some team",
        shortcut_part="some-team",
    )
    teams_set["regp_ks_a"] = team_factory(
        type=Team.Type.KS_REGP, parent=teams_set["ks_a"], name="RegP KS A"
    )
    teams_set["regp_ks_b"] = team_factory(
        type=Team.Type.KS_REGP, parent=teams_set["ks_b"], name="RegP KS B"
    )
    teams_set["koks_a"] = team_factory(
        type=Team.Type.KOKS, parent=teams_set["ks_a"], name="KoKS A"
    )
    teams_set["koks_b"] = team_factory(
        type=Team.Type.KOKS, parent=teams_set["ks_b"], name="KoKS B"
    )
    teams_set["team_ks_a"] = team_factory(
        type=Team.Type.KS_TEAM, parent=teams_set["kf_a"], name="Team KS A"
    )
    teams_set["team_ks_b"] = team_factory(
        type=Team.Type.KS_TEAM, parent=teams_set["kf_b"], name="Team KS B"
    )
    teams_set["ms_a2"] = team_factory(
        type=Team.Type.MS, parent=teams_set["ks_a"], name="MS A2", shortcut_part="MSA2"
    )
    teams_set["mf_a2"] = team_factory(
        type=Team.Type.MF, parent=teams_set["ms_a2"], name="MF A2"
    )
    teams_set["regp_ms_a"] = team_factory(
        type=Team.Type.MS_REGP, parent=teams_set["ms_a"], name="RegP MS A"
    )
    teams_set["regp_ms_a2"] = team_factory(
        type=Team.Type.MS_REGP, parent=teams_set["ms_a2"], name="RegP MS A2"
    )
    teams_set["regp_ms_b"] = team_factory(
        type=Team.Type.MS_REGP, parent=teams_set["ms_b"], name="RegP MS B"
    )
    teams_set["team_ms_a"] = team_factory(
        type=Team.Type.MS_TEAM,
        parent=teams_set["ms_a"],
        name="Team MS A",
        shortcut_part="tma1",
    )
    teams_set["team_ms_b"] = team_factory(
        type=Team.Type.MS_TEAM,
        parent=teams_set["ms_b"],
        name="Team MS B",
        shortcut_part="tmb1",
    )
    teams_set["ms_club_a"] = team_factory(
        type=Team.Type.MS_CLUB,
        parent=teams_set["ms_a"],
        name="Club MS A",
        shortcut_part="clubma1",
    )
    teams_set["ms_club_b"] = team_factory(
        type=Team.Type.MS_CLUB,
        parent=teams_set["ms_b"],
        name="Club MS B",
        shortcut_part="clubmb1",
    )
    teams_set["ms_club_ks_a"] = team_factory(
        type=Team.Type.MS_CLUB,
        parent=teams_set["ks_a"],
        name="Club MS KS A",
        shortcut_part="cluba1",
    )
    return teams_set


@pytest.fixture
def person_wht(person_factory, team_factory):
    """
    Person with home_team
    """
    ks = team_factory(type=Team.Type.KS, name="KS T")
    ms = team_factory(type=Team.Type.MS, parent=ks, name="MS T")
    return person_factory(home_team=ms)


@pytest.fixture
def guest_team(team_factory):
    return team_factory(type=Team.Type.KS)


@pytest.fixture
def group_config_cf(group_config_factory):
    return group_config_factory(
        team_type=Team.Type.CF,
        bound_roles_json=[
            MembershipCondition(
                type=Team.Type.CF, role=TeamMembership.Role.MEMBER, is_suspended=False
            ).to_dict()
        ],
    )


@pytest.fixture
def image_file():
    with tempfile.NamedTemporaryFile(suffix=".png") as file:
        yield ImageFile(file, name=file.name)


###############################################################################
# These automock fixtures are used to disable some side effects which generates
# database load but are not useful for most of the tests. Where these features
# are actually tested, there are these fixtures overwritten to do nothing.


@pytest.fixture(autouse=True)
def automock_process_email_account(mocker):
    mocker.patch("people.models.person_event.process_email_account")


@pytest.fixture(autouse=True)
def automock_process_team_membership(mocker):
    mocker.patch("people.models.person_event.process_team_membership")


@pytest.fixture(autouse=True)
def automock_send_person_event_notifications(mocker):
    mocker.patch("people.models.person_event.send_person_event_notifications")


@pytest.fixture(autouse=True)
def automock_update_person_email_aliases(mocker):
    mocker.patch("people.models.person.update_person_email_aliases")


@pytest.fixture(autouse=True)
def automock_update_person_internal_email(mocker):
    mocker.patch("people.models.person.update_person_internal_email")


@pytest.fixture(autouse=True)
def automock_update_related_candidates(mocker):
    mocker.patch("people.models.person.update_related_candidates")


@pytest.fixture(autouse=True)
def automock_update_related_agents(mocker):
    mocker.patch("people.models.person.update_related_agents")


@pytest.fixture(autouse=True)
def automock_update_related_user(mocker):
    mocker.patch("people.models.person.Person._update_related_user")


@pytest.fixture(autouse=True)
def automock_update_related_groups_names(mocker):
    mocker.patch("organization.models.Team._update_related_groups_names")


@pytest.fixture(autouse=True)
def automock_group_update_email_alias_targets(mocker):
    mocker.patch("organization.models.Group.update_email_alias_targets")


@pytest.fixture(autouse=True)
def automock_group_membership_log_add(mocker):
    mocker.patch("organization.models.GroupMembership._log_add")


@pytest.fixture(autouse=True)
def automock_group_membership_log_remove(mocker):
    mocker.patch("organization.models.GroupMembership._log_remove")


@pytest.fixture(autouse=True)
def automock_team_membership_process_derived_groups(mocker):
    mocker.patch("organization.models.TeamMembership._process_derived_groups")


@pytest.fixture(autouse=True)
def automock_team_membership_reset_user_auth_groups(mocker):
    mocker.patch("organization.models.TeamMembership._reset_user_auth_groups")


@pytest.fixture(autouse=True)
def automock_team_membership_refresh_mailtrain_shares(mocker):
    mocker.patch("organization.models.TeamMembership._refresh_mailtrain_shares")


@pytest.fixture(autouse=True)
def automock_group_config_refresh_groups(mocker):
    mocker.patch("organization.models.GroupConfig._refresh_groups")


@pytest.fixture(autouse=True)
def automock_refresh_contact_by_koks_groups(mocker):
    mocker.patch("people.models.person.refresh_contact_by_koks_groups")


@pytest.fixture(autouse=True)
def automock_add_candidate_to_candidates_groups(mocker):
    mocker.patch("elections.models.add_candidate_to_candidates_groups")


@pytest.fixture(autouse=True)
def automock_remove_candidate_from_candidates_groups(mocker):
    mocker.patch("elections.models.remove_candidate_from_candidates_groups")