"""Lambda test module."""

from unittest.mock import call, patch

import pytest

from constants import errors, slack_messages
import index


TEST_BUCKET = 'test_bucket'


@pytest.fixture()
def valid_xls_key():
    """Fixture for valid S3 key."""
    return (
        'soundexchange_reports/overlap/input'
        '/2018-09-29/THE_ORCHARD_ENTERPRISES_OVERLAP.xlsx')


@pytest.fixture
def mock_s3_event():
    """Fixture for S3 event."""
    def _inner(xls_key):
        return {
            'Records': [
                {
                    's3': {
                        'bucket': {'name': TEST_BUCKET},
                        'object': {'key': xls_key},
                    }
                }
            ]
        }
    return _inner


@patch('snowflake_connector.etl_connector.SnowflakeSQLExecutor')
@patch('models.reports.import_overlap_report')
@patch('util.convert_xsl_to_csv')
@patch('util.notify_slack')
def test_handler(
        notify_slack, convert_xsl_to_csv, import_overlap_report,
        SnowflakeSQLExecutor, mock_s3_event, valid_xls_key):
    """Test handler function."""
    date_str = '2018-09-29'
    bucket = 'test-bucket'

    csv_key = (
        f'soundexchange_reports/overlap/converted/{date_str}/'
        f'THE_ORCHARD_ENTERPRISES_OVERLAP.csv')

    result = index.handler(mock_s3_event(valid_xls_key), None)
    convert_xsl_to_csv.assert_called_with(bucket, valid_xls_key, csv_key)
    import_overlap_report.assert_called_with(
        SnowflakeSQLExecutor(), date_str, csv_key, valid_xls_key)

    notify_slack.assert_has_calls([
        call(slack_messages.IMPORT_STARTED.format(valid_xls_key)),
        call(slack_messages.IMPORT_SUCCESSFUL.format(valid_xls_key)),
    ])

    assert result == {'status': 'OK'}


@patch('models.reports.import_overlap_report')
@patch('util.convert_xsl_to_csv')
@patch('util.notify_slack')
def test_handler_invalid_xls_path(
        notify_slack, convert_xsl_to_csv,
        import_overlap_report, mock_s3_event):
    """Test handler for a case when the xls_path does not contain date."""
    xls_key = 'soundexchange_reports/overlap/input/report.xlsx'
    event = mock_s3_event(xls_key)
    expected_error = errors.INVALID_XLS_KEY.format(xls_key)

    with pytest.raises(ValueError, match=expected_error):
        index.handler(event, None)

    convert_xsl_to_csv.assert_not_called()
    import_overlap_report.assert_not_called()

    notify_slack.assert_has_calls([
        call(slack_messages.IMPORT_STARTED.format(xls_key)),
        call(slack_messages.IMPORT_FAILED.format(expected_error)),
    ])


@patch('index.logger')
@patch('models.reports.import_overlap_report')
@patch('util.convert_xsl_to_csv')
@patch('util.notify_slack')
def test_handler_not_an_xls_file(
        notify_slack, convert_xsl_to_csv, import_overlap_report,
        logger, mock_s3_event):
    """Test handler for a case when the file has incorrect extension."""
    xls_key = 'soundexchange_reports/overlap/input/report.csv'
    event = mock_s3_event(xls_key)
    index.handler(event, None)
    convert_xsl_to_csv.assert_not_called()
    import_overlap_report.assert_not_called()
    logger.error.assert_called_with(errors.INCORRECT_FILE_ERROR)

    notify_slack.assert_has_calls([
        call(slack_messages.IMPORT_STARTED.format(xls_key)),
        call(slack_messages.INCORRECT_EXTENSION),
    ])


@patch('snowflake_connector.etl_connector.SnowflakeSQLExecutor')
@patch('index.logger')
@patch('models.reports.import_overlap_report')
@patch('util.convert_xsl_to_csv', return_value=False)
@patch('util.notify_slack')
def test_handler_xls_file_does_not_exist(
        notify_slack, convert_xsl_to_csv, import_overlap_report,
        logger, SnowflakeSQLExecutor, mock_s3_event):
    """Test handler for a case when the xls file does not exist in S3."""
    xls_key = 'soundexchange_reports/overlap/input/2018-01-29/report.xlsx'
    event = mock_s3_event(xls_key)
    index.handler(event, None)
    import_overlap_report.assert_not_called()
    logger.info.assert_called_with(errors.FILE_DOES_NOT_EXIST.format(xls_key))

    notify_slack.assert_has_calls([
        call(slack_messages.IMPORT_STARTED.format(xls_key)),
        call(slack_messages.FILE_DOES_NOT_EXIST.format(xls_key)),
    ])


@patch('index.sentry')
@patch('snowflake_connector.etl_connector.SnowflakeSQLExecutor')
@patch('index.logger')
@patch('models.reports.import_overlap_report', side_effect=Exception)
@patch('util.convert_xsl_to_csv')
@patch('util.notify_slack')
def test_handler_xls_import_exception(
        notify_slack, convert_xsl_to_csv, import_overlap_report,
        logger, SnowflakeSQLExecutor, sentry, mock_s3_event):
    """Test handler for a case when there is an exception during import."""
    xls_key = 'soundexchange_reports/overlap/input/2018-01-29/report.xlsx'
    event = mock_s3_event(xls_key)
    with pytest.raises(Exception):
        index.handler(event, None)
    logger.exception.assert_called()
    sentry.capture_exception.assert_called()

    notify_slack.assert_has_calls([
        call(slack_messages.IMPORT_STARTED.format(xls_key)),
        call(slack_messages.IMPORT_FAILED.format('')),
    ])