"""Lambda test module."""

from types import SimpleNamespace

import index

import pytest

import test_utils


@pytest.fixture
def ar_contract_details():
    """Return get active_contracts query sample data."""
    return [
        SimpleNamespace(
            id=100,
            vendor_id=1,
            royalty_collection_territory='17, 201'
        ),
        SimpleNamespace(
            id=200,
            vendor_id=2,
            royalty_collection_territory=''
        ),
        SimpleNamespace(
            id=300,
            vendor_id=3,
            royalty_collection_territory=''
        )
    ]


@pytest.fixture
def ar_contract_details_not_enabled():
    """Return get active_contracts query sample data."""
    return [
        SimpleNamespace(
            id=200,
            vendor_id=2,
            royalty_collection_territory=''
        ),
        SimpleNamespace(
            id=300,
            vendor_id=3,
            royalty_collection_territory=''
        )
    ]


@pytest.fixture
def enable_vendors():
    """Return list of enabled vendors."""
    return [2]


@pytest.fixture
def disable_vendors():
    """Return list of disabled vendors."""
    return [1, 3]


@pytest.fixture
def enable_message():
    """Return enable message for vendors."""
    return 'Enabled feature for vendors [2]'


@pytest.fixture
def disable_message():
    """Return disable message for vendors."""
    return 'Disabled feature for vendors [1, 3]'


@pytest.fixture
def no_contracts_log():
    """Return loger message for no active contracts."""
    return 'There are no active Contract(s)'


@pytest.fixture
def enable_disable_message():
    """Return enabled_disable message for vendors."""
    return (
        'Enabled feature for vendors [2] and '
        'Disabled feature for vendors [1, 3].')


@pytest.fixture
def not_enable_disable_message():
    """Return enabled_disable message for vendors."""
    return (
        'Not enabled feature for any vendor and '
        'Disabled feature for vendors [1, 3].')


def test_handler(
        mocker, ar_contract_details, enable_message,
        disable_message, enable_disable_message):
    """Test main handler method."""
    mocked_get_active_contracts = mocker.patch(
        'index.get_active_contracts')
    mocked_get_active_contracts.return_value = ar_contract_details

    mocked_enable_feature = mocker.patch(
        'index.enable_feature')
    mocked_enable_feature.return_value = enable_message

    mocked_disable_feature = mocker.patch(
        'index.disable_feature')
    mocked_disable_feature.return_value = disable_message

    mocked_logger = mocker.patch(
        'index.logger.info')
    mocked_logger.return_value = enable_disable_message

    result = index.handler(None, None)

    assert mocked_get_active_contracts.call_count == 1
    assert mocked_enable_feature.call_count == 1
    assert mocked_disable_feature.call_count == 1
    assert mocked_logger.call_count == 1
    assert result == enable_disable_message


def test_handler_logger(mocker, no_contracts_log):
    """Test main handler method for no active contracts."""
    mocked_get_active_contracts = mocker.patch(
        'index.get_active_contracts')
    mocked_get_active_contracts.return_value = []
    mocked_logger = mocker.patch(
        'index.logger.info')
    mocked_logger.return_value = no_contracts_log

    result = index.handler(None, None)

    assert mocked_get_active_contracts.call_count == 1
    assert mocked_logger.call_count == 1
    assert result == no_contracts_log


def test_handler_not_enabled(
        mocker, ar_contract_details_not_enabled, enable_message,
        disable_message, not_enable_disable_message):
    """Test main handler for not enabled vendors."""
    mocked_get_active_contracts = mocker.patch(
        'index.get_active_contracts')
    mocked_get_active_contracts.return_value = ar_contract_details_not_enabled

    mocked_disable_feature = mocker.patch(
        'index.disable_feature')
    mocked_disable_feature.return_value = disable_message

    mocked_logger = mocker.patch(
        'index.logger.info')
    mocked_logger.return_value = not_enable_disable_message

    result = index.handler(None, None)

    assert mocked_get_active_contracts.call_count == 1
    assert mocked_disable_feature.call_count == 1
    assert mocked_logger.call_count == 1
    assert result == not_enable_disable_message


def test_get_active_contracts(mocker, ar_contract_details):
    """Test index.get_active_contracts function."""
    # patch session scope
    mocked_session = test_utils.mock_db_session(mocker)
    mocked_session.execute.return_value.all.return_value = ar_contract_details
    sql_text = 'test'
    mocked_sqlalchemy_text = mocker.patch('index.sqlalchemy.text')
    mocked_sqlalchemy_text.return_value = sql_text

    result = index.get_active_contracts()

    assert result == ar_contract_details
    assert mocked_session.execute.call_args[0] == (sql_text,)


def test_enable_feature(mocker, enable_vendors, enable_message):
    """Test index.enable_feature function."""
    # patch session scope
    mocked_session = test_utils.mock_db_session(mocker)
    mocked_session.execute.return_value = enable_message
    sql_text = 'test'
    mocked_sqlalchemy_text = mocker.patch('index.sqlalchemy.text')
    mocked_sqlalchemy_text.return_value = sql_text

    result = index.enable_feature(enable_vendors)

    assert result == enable_message
    assert mocked_session.execute.call_args[0] == (sql_text,)


def test_disable_feature(mocker, disable_vendors, disable_message):
    """Test index.disable_feature function."""
    # patch session scope
    mocked_session = test_utils.mock_db_session(mocker)
    mocked_session.execute.return_value = disable_message
    sql_text = 'test'
    mocked_sqlalchemy_text = mocker.patch('index.sqlalchemy.text')
    mocked_sqlalchemy_text.return_value = sql_text

    result = index.disable_feature(disable_vendors)

    assert result == disable_message
    assert mocked_session.execute.call_args[0] == (sql_text,)