"""Lambda test module."""

from unittest.mock import patch

import pytest
from constants import errors
from constants import general
import index
import lambda_exceptions


@pytest.fixture
def event_data():
    """Fixture for the incoming event."""
    return {
        'key': 'test_key',
        'bucket': 'test_bucket'
    }


@patch('util.extract_triggered_key')
@patch('s3.object_exists')
@patch('s3.head_object')
@patch('file_validator.is_valid_file_type')
@patch('file_validator.is_valid_file_size')
def test_handler(
        is_valid_file_size_mock, is_valid_file_type_mock, s3_head_object_mock,
        s3_object_exists_mock, extract_triggered_key_mock, event_data):
    """Test handler function."""
    extract_triggered_key_mock.return_value = (
        event_data['bucket'], event_data['key'])
    test_mime_type = 'test_mime_type'
    test_file_size = 1234567
    s3_object_mock = {
        'ContentType': test_mime_type, 'ContentLength': test_file_size}
    s3_object_exists_mock.return_value = True
    s3_head_object_mock.return_value = s3_object_mock
    is_valid_file_type_mock.return_value = True

    result = index.handler(event_data, None)

    s3_object_exists_mock.assert_called_once_with(
        event_data['bucket'], event_data['key'])
    s3_head_object_mock.assert_called_once_with(
        event_data['bucket'], event_data['key'])
    is_valid_file_type_mock.assert_called_once_with(event_data['key'])
    is_valid_file_size_mock.assert_called_once_with(test_file_size)
    assert result == {
        'function': general.LAMBDA_NAME,
        'status': 200,
        's3_object': {
            'key': event_data['key'],
            'bucket': event_data['bucket']
        }
    }


@patch('util.extract_triggered_key')
@patch('s3.object_exists')
@patch('status.send_failure_status')
def test_handler_object_not_found(
        send_failure_status_mock, s3_object_exists_mock,
        extract_triggered_key_mock, event_data):
    """Test handler function with s3 object not found."""
    extract_triggered_key_mock.return_value = (
        event_data['bucket'], event_data['key'])
    s3_object_exists_mock.return_value = False
    error_msg = errors.ERROR_MESSAGES[errors.S3_FILE_NOT_FOUND_CODE].format(
        **event_data)

    result = index.handler(event_data, None)
    send_failure_status_mock.assert_called_once_with(
        general.LAMBDA_NAME, errors.INVALID_DATA_ERROR_STATUS,
        event_data['key'], errors.S3_FILE_NOT_FOUND_CODE,
        error_msg, event_data['bucket'])

    assert result == {
        'function': general.LAMBDA_NAME,
        'status': 400,
        's3_object': {
            'key': event_data['key'],
            'bucket': event_data['bucket']
        },
        'error_code': 's3_file_not_found',
        'error_description': ['test_key not found in bucket test_bucket!']
    }


@patch('util.extract_triggered_key')
@patch('s3.object_exists')
@patch('file_validator.is_valid_file_type')
@patch('status.send_failure_status')
def test_handler_with_wrong_file_type(
        send_failure_status_mock, is_valid_file_type_mock,
        s3_object_exists_mock, extract_triggered_key_mock, event_data):
    """Test handler function with wrong file type."""
    event_data['key'] = 'test_wrong_extention.html'
    extract_triggered_key_mock.return_value = (
        event_data['bucket'], event_data['key'])
    s3_object_exists_mock.return_value = True
    is_valid_file_type_mock.return_value = False
    error_msg = errors.ERROR_MESSAGES[
        errors.WRONG_FILE_TYPE_ERROR_CODE].format(
            key=event_data['key'],
            bucket=event_data['bucket'],
            extension='.html')

    result = index.handler(event_data, None)
    s3_object_exists_mock.assert_called_once_with(
        event_data['bucket'], event_data['key'])
    is_valid_file_type_mock.assert_called_once_with(event_data['key'])
    send_failure_status_mock.assert_called_once_with(
        general.LAMBDA_NAME, errors.INVALID_DATA_ERROR_STATUS,
        event_data['key'], errors.WRONG_FILE_TYPE_ERROR_CODE,
        error_msg, event_data['bucket'])
    assert result == {
        'function': general.LAMBDA_NAME,
        'status': errors.INVALID_DATA_ERROR_STATUS,
        's3_object': {
            'key': event_data['key'],
            'bucket': event_data['bucket']
        },
        'error_code': 'wrong_file_type_error',
        'error_description': [
            'test_wrong_extention.html file (bucket test_bucket) '
            'has wrong file type (.html)']
    }


@patch('util.extract_triggered_key')
@patch('s3.object_exists')
@patch('s3.head_object')
@patch('file_validator.is_valid_file_type')
@patch('file_validator.is_valid_file_size')
@patch('status.send_failure_status')
def test_handler_with_wrong_file_size(
        send_failure_status_mock, is_valid_file_size_mock,
        is_valid_file_type_mock, s3_head_object_mock,
        s3_object_exists_mock, extract_triggered_key_mock, event_data):
    """Test handler function with wrong file size."""
    extract_triggered_key_mock.return_value = (
        event_data['bucket'], event_data['key'])
    test_mime_type = 'test_mime_type'
    test_wrong_file_size = 11223344556677
    s3_object_mock = {
        'ContentType': test_mime_type, 'ContentLength': test_wrong_file_size}
    s3_object_exists_mock.return_value = True
    s3_head_object_mock.return_value = s3_object_mock
    is_valid_file_type_mock.return_value = True
    is_valid_file_size_mock.return_value = False
    error_msg = errors.ERROR_MESSAGES[
        errors.WRONG_FILE_SIZE_ERROR_CODE].format(
        key=event_data['key'],
        bucket=event_data['bucket'],
        size=test_wrong_file_size)

    result = index.handler(event_data, None)
    s3_object_exists_mock.assert_called_once_with(
        event_data['bucket'], event_data['key'])
    s3_head_object_mock.assert_called_once_with(
        event_data['bucket'], event_data['key'])

    is_valid_file_size_mock.assert_called_once_with(test_wrong_file_size)
    send_failure_status_mock.assert_called_once_with(
        general.LAMBDA_NAME, errors.INVALID_DATA_ERROR_STATUS,
        event_data['key'], errors.WRONG_FILE_SIZE_ERROR_CODE,
        error_msg, event_data['bucket'])

    assert result == {
        'function': general.LAMBDA_NAME,
        'status': errors.INVALID_DATA_ERROR_STATUS,
        's3_object': {
            'key': event_data['key'],
            'bucket': event_data['bucket']
        },
        'error_code': 'wrong_file_size_error',
        'error_description': [
            'test_key file (bucket test_bucket) has wrong size '
            '(11223344556677 bytes)']
    }


@patch('status.send_failure_status')
@patch('s3.object_exists')
@patch('util.extract_triggered_key')
def test_handler_failure(
        extract_triggered_key_mock, object_exists_mock,
        send_failure_status_mock, event_data):
    """Test handler with exception."""
    extract_triggered_key_mock.return_value = (
        event_data['bucket'], event_data['key'])
    exception_msg = 'error message'
    error_msg = errors.ERROR_MESSAGES[
        errors.FILE_VERIFICATION_ERROR_CODE].format(message=exception_msg)
    object_exists_mock.side_effect = Exception(exception_msg)

    result = index.handler(event_data, None)
    send_failure_status_mock.assert_called_once_with(
        general.LAMBDA_NAME, errors.INTERNAL_ERROR_STATUS,
        'Key is not identified', errors.FILE_VERIFICATION_ERROR_CODE,
        error_msg, 'Bucket is not identified')
    assert result == {
        'function': general.LAMBDA_NAME,
        'status': errors.INTERNAL_ERROR_STATUS,
        's3_object': {
            'key': 'Key is not identified',
            'bucket': 'Bucket is not identified'
        },
        'error_code': 'file_verification_error',
        'error_description': ['error message']
    }


@patch('util.extract_triggered_key')
@patch('status.send_failure_status')
def test_extract_triggered_key_failure(
        send_failure_status_mock,
        extract_triggered_key_mock, event_data):
    """Test handler with exception."""
    test_exception = lambda_exceptions.UnexpectedEventBody(['key', 'bucket'])
    extract_triggered_key_mock.side_effect = test_exception
    result = index.handler(event_data, None)
    send_failure_status_mock.assert_called_once_with(
        general.LAMBDA_NAME, errors.INTERNAL_ERROR_STATUS,
        'Key is not identified', errors.FILE_VERIFICATION_ERROR_CODE,
        'An error occurred during file verification: Error message: {}'.format(
            str(test_exception)), 'Bucket is not identified')
    assert result == {
        'function': general.LAMBDA_NAME,
        'status': errors.INTERNAL_ERROR_STATUS,
        's3_object': {
            'key': 'Key is not identified',
            'bucket': 'Bucket is not identified'
        },
        'error_code': 'file_verification_error',
        'error_description': [str(test_exception)]
    }