"""Lambda test module."""

import datetime

import pytest

from constants import common_fields
from constants import const
from constants import fields
import index


def patch_session_scope(mocker, return_value):
    """Patch session scope function."""
    # session mock
    mocked_session = mocker.Mock()
    mocked_session.execute.return_value = return_value
    # context mock
    mocked_context = mocker.Mock()
    mocked_context.__enter__ = mocker.Mock(
        return_value=mocked_session)
    mocked_context.__exit__ = mocker.Mock(return_value=None)
    # session scope function mock
    mocked_session_scope = mocker.patch(
        'connectors.vector_obtain_orders.session_scope')
    mocked_session_scope.return_value = mocked_context
    return mocked_session


def test_save_to_vo_sync_errors(mocker):
    """Test index.save_to_vo_sync_errors function."""
    # patch session scope
    mocked_session = patch_session_scope(mocker, None)
    sql_text = 'test'
    mocked_sqlalchemy_text = mocker.patch('index.sqlalchemy.text')
    mocked_sqlalchemy_text.return_value = sql_text
    order_dict = {common_fields.VO_ORDER_ID: 1}
    error_message = 'error'
    error_timestamp = datetime.datetime.utcnow()

    index.save_to_vo_sync_errors(order_dict, error_message, error_timestamp)

    assert mocked_session.execute.call_count == 1
    assert mocked_session.execute.call_args[0] == (
        sql_text,
        {'vector_order_id': order_dict[common_fields.VO_ORDER_ID],
         'error_msg': error_message,
         'error_timestamp': error_timestamp})


def test_handle_record(mocker):
    """Test index.handle_record function."""
    mocked_save_to_vo_sync_errors = mocker.patch(
        'index.save_to_vo_sync_errors')

    index.handle_record({
        fields.EVENT_RECORD_SNS_MESSAGE: '{}',
        fields.EVENT_RECORD_SNS_TIMESTAMP:
            datetime.datetime.utcnow().strftime(const.TIMESTAMP_TEMPLATE),
        fields.EVENT_RECORD_SNS_ATTRIBUTES: {
            fields.EVENT_RECORD_SNS_ATTRIBUTES_ERROR: {
                fields.EVENT_RECORD_SNS_ATTRIBUTES_ERROR_MESSAGE: 'error'
            }}
    })

    assert mocked_save_to_vo_sync_errors.call_count == 1
    assert mocked_save_to_vo_sync_errors.call_args[1] == {}


def test_handle_record_incorrect_data(mocker):
    """Test index.handle_record function with incorrect data."""
    with pytest.raises(KeyError):
        index.handle_record({})


def test_handle_all_records(mocker):
    """Test index.handle_all_records function."""
    mocked_handle_record = mocker.patch('index.handle_record')

    index.handle_all_records([{fields.EVENT_RECORD_SNS: {}}])

    assert mocked_handle_record.call_count == 1
    assert mocked_handle_record.call_args[1] == {}


def test_handle_all_records_incorrect_data(mocker):
    """Test index.handle_all_records function with incorrect data."""
    mocked_capture_message = mocker.patch(
        'index.sentry.sentry_client.captureMessage')
    record = {'test': 1}

    index.handle_all_records([record])

    assert mocked_capture_message.call_count == 1
    assert mocked_capture_message.call_args[1] == {
        'stack': True, 'extra': record}


def test_handler(mocker):
    """Test index.test_handler function."""
    mocked_handle_all_records = mocker.patch('index.handle_all_records')

    index.handler({fields.EVENT_RECORDS: {}}, None)

    assert mocked_handle_all_records.call_count == 1
    assert mocked_handle_all_records.call_args[1] == {}


def test_handler_incorrect_data(mocker):
    """Test index.test_handler function with incorrect data."""
    with pytest.raises(KeyError):
        index.handler({}, None)