"""Tests for fact_conflict_elasticsearch model."""
import opensearchpy
import pytest

from conflict_manager.models import fact_conflict_elasticsearch


@pytest.fixture
def successful_response(mocker):
    """Return a successful response."""
    return mocker.MagicMock(message='success', status_code=200)


@pytest.fixture
def pagination_values():
    """Return well-formed pagination values."""
    return {
        'offset': 0,
        'limit': 50,
        'sort_by': 'daily_average_views',
        'sort_order': 'asc'
    }


def test_filter_query(mocker, account_tuple, query_args):
    """Test the Elasticsearch function is called properly."""
    mock_call = mocker.patch.object(
        fact_conflict_elasticsearch, 'get_new_conflicts_for_account',
        return_value=successful_response)

    fact_conflict_elasticsearch.get_new_conflicts_for_account(
        account_tuple, query_args)

    mock_call.assert_called_once_with(account_tuple, query_args)


def test_search_object(mocker, account_tuple, query_args, pagination_values,
                       feature_engine):
    """Test the ElasticSearch Search object is created properly."""
    mock_call = mocker.patch.object(opensearchpy.Search, 'filter')

    fact_conflict_elasticsearch.get_new_conflicts_for_account(
        account_tuple, query_args, **pagination_values)

    mock_call.assert_called_with('term', vendor_id='7123')


def test_search_execute(mocker, account_tuple, query_args, pagination_values,
                        feature_engine):
    """Test the ElasticSearch Search object's execute function is called."""
    mock_call = mocker.patch.object(opensearchpy.Search, 'execute')

    fact_conflict_elasticsearch.get_new_conflicts_for_account(
        account_tuple, query_args, **pagination_values)

    mock_call.assert_called_once()


def test_delete_method(mocker, account_tuple, delete_args, result_hits,
                       feature_engine):
    """Test the delete method of the elasticsearch model."""
    mocker.patch.object(
        opensearchpy.Search, 'execute', return_value=result_hits(2))
    mock_call = mocker.patch.object(opensearchpy.Search, 'delete')

    fact_conflict_elasticsearch.delete_conflict(
        account_tuple, delete_args(2))

    mock_call.assert_called_once()


def test_delete_response_success(
        mocker, account_tuple, delete_args, result_hits, feature_engine):
    """Test model calls delete method with success."""
    mocker.patch(
        'opensearchpy.Search.execute', return_value=result_hits(2)
    )

    mocker.patch('opensearchpy.Search.delete')

    result = fact_conflict_elasticsearch.delete_conflict(
        account_tuple, delete_args(2))

    assert result.status == 200
    assert result.message == "_id's deleted: \n1,\n2"


def test_delete_response_not_found(
        mocker, account_tuple, delete_args, result_hits, feature_engine):
    """Test model handles delete method when not found."""
    mocker.patch(
        'opensearchpy.Search.execute', return_value=result_hits(0)
    )

    result = fact_conflict_elasticsearch.delete_conflict(
        account_tuple, delete_args(0))

    assert result.status == 404
    assert result.errors['message'] == "No matching _id's found in " \
                                       'Elasticsearch query'
    assert result.errors['code'] == 'not_found'


def test_get_new_conflicts_count(
        mocker, account_tuple, count_response, feature_engine):
    """Test model calls get new conflicts count."""
    mock_es_client = mocker.patch(
        'conflict_manager.models.fact_conflict_elasticsearch.OpenSearch')

    mock_boto3_session = mocker.patch('boto3.Session')
    mock_credentials = mocker.MagicMock()
    mock_credentials.access_key = 'mock_access_key'
    mock_credentials.secret_key = 'mock_secret_key'
    mock_credentials.token = 'mock_session_token'
    (mock_boto3_session.return_value.
     get_credentials).return_value = mock_credentials

    mock_aws4auth = mocker.patch('requests_aws4auth.AWS4Auth')
    mock_aws4auth.return_value = 'mock_aws4auth'

    mock_es_client.return_value.count.return_value = count_response(15)

    result = fact_conflict_elasticsearch.get_new_conflict_count_for_account(
        account_tuple)

    assert result.status == 200
    assert result.message['pagination']['total_records'] == 15