"""Tests for VendContactRole model."""

from unittest import mock

import flask

from permissions.models import vend_contact_role


@mock.patch('permissions.models.vend_contact_role.g')
def test_create_by_role_ids_if_not_exist_finds_all_roles(g_mock, app_context):
    """Test find_or_create_by_role_ids behavior when all requested roles are found."""
    session_mock = mock.Mock()
    vend_contact_id = 31770
    vend_contact = mock.Mock(id=vend_contact_id)
    role_ids = [2, 3]
    found_roles = [mock.Mock(role_id=3), mock.Mock(role_id=2)]
    session_mock.query.return_value.filter.return_value.all.return_value = found_roles

    result_list = vend_contact_role.VendContactRole.create_by_role_ids_if_not_exist(
        tx=session_mock, vend_contact=vend_contact, role_ids=role_ids
    )

    assert result_list == []
    session_mock.query.assert_called_with(vend_contact_role.VendContactRole)
    # Unfortunately we can't compare separate sqlalchemy BinaryExpression objects directly,
    # so going into their internals to compare values.
    filter_arg1 = session_mock.query.return_value.filter.call_args[0][0]
    filter_arg2 = session_mock.query.return_value.filter.call_args[0][1]
    assert filter_arg1.left.name == 'vend_contact_id'
    assert filter_arg1.right.value == vend_contact_id
    assert filter_arg2.left.name == 'role_id'
    assert [c.value for c in filter_arg2.right.element.clauses] == role_ids
    g_mock.log.info.assert_called_with(
        'Existing vend_contact_roles found for invited user',
        resources={'existing_role_ids': [3, 2]},
    )


def test_create_by_role_ids_if_not_exist_finds_no_roles():
    """Test create_by_role_ids_if_not_exist behavior when no roles are found."""
    session_mock = mock.Mock()
    vend_contact = mock.Mock()
    role_ids = [2, 3]
    session_mock.query.return_value.filter.return_value.all.return_value = []

    result_list = vend_contact_role.VendContactRole.create_by_role_ids_if_not_exist(
        tx=session_mock, vend_contact=vend_contact, role_ids=role_ids
    )

    assert len(result_list) == 2
    assert result_list[0].role_id == 2
    assert result_list[0].vend_contact == vend_contact
    assert result_list[1].role_id == 3
    assert result_list[1].vend_contact == vend_contact


@mock.patch('permissions.models.vend_contact_role.g')
def test_create_by_role_ids_if_not_exist_finds_some_roles(g_mock, app_context):
    """Test create_by_role_ids_if_not_exist behavior when some requested roles are found."""
    session_mock = mock.Mock()
    vend_contact_id = 31770
    vend_contact = mock.Mock(id=vend_contact_id)
    role_ids = [2, 3]
    session_mock.query.return_value.filter.return_value.all.return_value = [mock.Mock(role_id=3)]

    result_list = vend_contact_role.VendContactRole.create_by_role_ids_if_not_exist(
        tx=session_mock, vend_contact=vend_contact, role_ids=role_ids
    )

    assert len(result_list) == 1
    assert result_list[0].role_id == 2
    assert result_list[0].vend_contact == vend_contact
    g_mock.log.info.assert_called_with(
        'Existing vend_contact_roles found for invited user',
        resources={'existing_role_ids': [3]},
    )


@mock.patch('permissions.models.vend_contact_role.g')
def test_find_or_create_by_role_ids_finds_unexpected_roles(g_mock, app_context):
    """Test find_or_create_by_role_ids behavior when unrequested roles are found."""
    session_mock = mock.Mock()
    vend_contact_id = 31770
    vend_contact = mock.Mock(id=vend_contact_id)
    role_ids = [2, 3]
    session_mock.query.return_value.filter.return_value.all.return_value = [
        mock.Mock(role_id=3),
        mock.Mock(role_id=9),
    ]

    result_list = vend_contact_role.VendContactRole.create_by_role_ids_if_not_exist(
        tx=session_mock, vend_contact=vend_contact, role_ids=role_ids
    )

    g_mock.log.warn.assert_called_with(
        'Existing vend contact roles found that did not match requested roles',
        resources={
            'requested_role_ids': role_ids,
            'existing_role_ids': [3, 9],
        },
    )
    assert len(result_list) == 1
    assert result_list[0].role_id == 2
    assert result_list[0].vend_contact == vend_contact


@mock.patch('permissions.models.vend_contact_role.g')
def test_delete_roles_by_vend_contact_id(
    g_mock: mock.MagicMock,
    app_context: flask.ctx.AppContext,
) -> None:
    """Test delete_roles_by_vend_contact_id deletes all roles for a vend contact."""
    session_mock = mock.Mock()
    vend_contact_id = 31770

    vend_contact_role.VendContactRole.delete_roles_by_vend_contact_id(
        session=session_mock, vend_contact_id=vend_contact_id
    )

    session_mock.query.assert_called_with(vend_contact_role.VendContactRole)
    # Unfortunately we can't compare separate sqlalchemy BinaryExpression objects directly,
    # so going into their internals to compare values.
    filter_arg = session_mock.query.return_value.filter.call_args[0][0]
    assert filter_arg.left.name == 'vend_contact_id'
    assert filter_arg.right.value == vend_contact_id
    session_mock.query.return_value.filter.return_value.delete.assert_called_with(
        synchronize_session=False
    )
    g_mock.log.info.assert_called_with(
        'Deleted all vend contact roles for vend_contact',
        resources={'vend_contact_id': vend_contact_id},
    )


def test_delete_roles_by_ids_and_vend_contact_id():
    """Test delete_roles_by_ids_and_vend_contact_id deletes specified roles for a vend contact."""
    session_mock = mock.Mock()
    role_ids = [1, 2, 3]
    vend_contact_id = 31770

    vend_contact_role.VendContactRole.delete_roles_by_ids_and_vend_contact_id(
        tx=session_mock, role_ids=role_ids, vend_contact_id=vend_contact_id
    )

    session_mock.query.assert_called_with(vend_contact_role.VendContactRole)
    # Unfortunately we can't compare separate sqlalchemy BinaryExpression objects directly,
    # so going into their internals to compare values.
    filter_arg1 = session_mock.query.return_value.filter.call_args[0][0]
    filter_arg2 = session_mock.query.return_value.filter.call_args[0][1]
    assert filter_arg1.left.name == 'role_id'
    assert [c.value for c in filter_arg1.right.element.clauses] == role_ids
    assert filter_arg2.left.name == 'vend_contact_id'
    assert filter_arg2.right.value == vend_contact_id
    session_mock.query.return_value.filter.return_value.delete.assert_called_with(
        synchronize_session=False
    )