"""Tests for action model."""

import pytest

from conflict_manager.constants import database as db_consts
from conflict_manager.models import action
from conflict_manager.utils import model_utils


@pytest.fixture
def actions_data():
    """Fixture data for actions."""
    return [
        {
            'conflict_id': 1,
            'action': 'release',
            'reason': 'SHOULD_NOT_HAVE_BEEN_CLAIMED',
            'additional_information': 'foo',
            'account_id': 18805,
            'account_type': 'vendor',
        },
        {
            'conflict_id': 3,
            'action': 'assert',
            'reason': 'MASTER_COPYRIGHT_OWNER',
            'additional_information': 'bar',
            'account_id': 18805,
            'account_type': 'vendor',
        },
    ]


def test_get_ids_to_update(mocker):
    """Test get_ids_to_update."""
    run_query_mock = mocker.patch.object(model_utils, 'run_query')
    ids = ['6541', '245435']

    expected_sql = (
        'SELECT CONFLICT_ID from {action_table} WHERE CONFLICT_ID in (:ids);')

    expected_params = {'ids': ids}

    action.get_ids_to_update(ids, mocker.Mock())
    _, kwargs = run_query_mock.call_args

    assert kwargs['params'] == expected_params
    assert kwargs['sql'] == expected_sql


def test_update(actions_data, mocker):
    """Test update function."""
    run_query_mock = mocker.patch.object(model_utils, 'run_query')

    expected_sql = """
        UPDATE {action_table}
        SET
            conflict_id = :conflict_id,
            action = :action,
            action_date = TO_TIMESTAMP_NTZ(:action_date),
            reason = :reason,
            additional_information = :additional_information,
            account_id = :account_id,
            account_type = :account_type
        WHERE conflict_id = :conflict_id;
    """

    action.update(actions_data, mocker.Mock())
    _, kwargs = run_query_mock.call_args

    assert kwargs['params'] == actions_data
    assert kwargs['sql'] == expected_sql


def test_insert(actions_data, mocker):
    """Test insert function."""
    run_query_mock = mocker.patch.object(model_utils, 'run_query')

    expected_sql = """
        INSERT INTO {action_table}(
            conflict_id,
            action,
            action_date,
            reason,
            additional_information,
            account_id,
            account_type)
        VALUES(
            :conflict_id,
            :action,
            TO_TIMESTAMP_NTZ(:action_date),
            :reason,
            :additional_information,
            :account_id,
            :account_type);
    """

    action.insert(actions_data, mocker.Mock())
    _, kwargs = run_query_mock.call_args

    assert kwargs['params'] == actions_data
    assert kwargs['sql'] == expected_sql


def test_create(actions_data, mocker):
    """Test create function."""
    get_ids_to_update_mock = mocker.patch.object(
        action, 'get_ids_to_update', return_value=[1])

    update_mock = mocker.patch.object(
        action, 'update',
        return_value=[{db_consts.NUMBER_OF_ROWS_UPDATED: 1}])
    insert_mock = mocker.patch.object(
        action, 'insert',
        return_value=[{db_consts.NUMBER_OF_ROWS_INSERTED: 1}])

    session = mocker.Mock()

    result = action.create(actions_data, session=session)

    assert result.message == [
        {db_consts.NUMBER_OF_ROWS_INSERTED: 1},
        {db_consts.NUMBER_OF_ROWS_UPDATED: 1}
    ]

    get_ids_to_update_mock.assert_called_with([1, 3], session)
    update_mock.assert_called_with([actions_data[0]], session)
    insert_mock.assert_called_with([actions_data[1]], session)