"""Lambda util test module."""

from unittest.mock import patch

import pytest

from constants import file_params
import lambda_exceptions
import util


@pytest.fixture
def temp_directory_fixture(tmpdir):
    """Fixture with test directory which contain two files and subdirectory."""
    test_directory = tmpdir.mkdir(file_params.DEFAULT_DOWNLOAD_DIRECTORY)
    test_directory.mkdir('test_dir')
    file_1 = test_directory.join('f1.txt')
    file_2 = test_directory.join('f2.txt')
    file_1.write('content_1')
    file_2.write('content_2')
    return test_directory


def test_say_hello():
    """Test util.say_hello function."""
    util.say_hello()
    assert True, 'Something terrible has happened.'


def test_extract_triggered_key():
    """Test extract_triggered_key function."""
    test_bucket = 'test_bucket'
    test_key = 'test_key'
    event_mock = {'detail': {
        'requestParameters': {
            'bucketName': test_bucket,
            'key': test_key
        }
    }}

    bucket, key = util.extract_triggered_key(event_mock)
    assert bucket == test_bucket
    assert key == test_key


def test_extract_triggered_key_with_invalid_params():
    """Test extract_triggered_key function."""
    event_mock = {'detail': {
        'requestParameters': {
            'event_arg': None,
        }
    }}

    with pytest.raises(lambda_exceptions.UnexpectedEventBody):
        util.extract_triggered_key(event_mock)


@patch('os.unlink')
@patch('shutil.rmtree')
def test_clean_directory_failure(
        rmtree_mock, unlink_mock, temp_directory_fixture):
    """Test for failure call of clean_directory method."""
    unlink_mock.side_effect = OSError()
    rmtree_mock.side_effect = OSError()
    util.clean_directory(temp_directory_fixture.strpath)
    assert len(temp_directory_fixture.listdir()) == 3


def test_clean_directory_success(temp_directory_fixture):
    """Test for successful call of clean_directory method."""
    # checking directory content before cleaning
    assert len(temp_directory_fixture.listdir()) == 3
    # test functional call
    util.clean_directory(temp_directory_fixture.strpath)
    # checking directory content after cleaning
    assert len(temp_directory_fixture.listdir()) == 0


def test_handle_lambda_result_handled_error():
    """Test wrapper returns formatted message after expected exception."""
    status, s3_obj, error_code, error_description = (400, {}, 'err', 'desc')
    lambda_name = 'mock_lambda'

    @util.handle_lambda_result(lambda_name=lambda_name, default_error_code='1')
    def lambda_handler_mock(event, context):
        return {
            'status': status, 's3_obj': s3_obj, 'error_code': error_code,
            'error_description': error_description}

    result = lambda_handler_mock({}, {})
    assert result == {
        'function': lambda_name,
        'status': status,
        's3_object': s3_obj,
        'error_code': error_code,
        'error_description': error_description
    }


def test_handle_lambda_result_skips_empty_args():
    """Test wrapper returns formatted message after successful lambda call."""
    status, s3_obj, error_code, error_description = (200, {}, None, None)
    lambda_name = 'mock_lambda'

    @util.handle_lambda_result(lambda_name=lambda_name, default_error_code='1')
    def lambda_handler_mock(event, context):
        return {
            'status': status, 's3_obj': s3_obj, 'error_code': error_code,
            'error_description': error_description}

    result = lambda_handler_mock({}, {})
    assert result == {
        'function': lambda_name,
        'status': status,
        's3_object': s3_obj
    }


def test_handle_lambda_result_handles_exception():
    """Test wrapper returns formatted message after successful lambda call."""
    lambda_name = 'mock_lambda'
    error_msg = 'error message'
    error_code = 'error_code'

    @util.handle_lambda_result(
        lambda_name=lambda_name, default_error_code=error_code)
    def lambda_handler_mock(event, context):
        raise Exception(error_msg)

    result = lambda_handler_mock({}, {})
    assert result == {
        'function': lambda_name,
        'status': 500,
        's3_object': {
            'bucket': 'Bucket is not identified',
            'key': 'Key is not identified'},
        'error_code': error_code,
        'error_description': [error_msg]
    }


@patch('util.clean_directory')
def test_handle_lambda_result_cleans_temp_dir(clean_directory_mock):
    """Test wrapper returns formatted message after expected exception."""
    status, s3_obj, error_code, error_description = (400, {}, 'err', 'desc')
    lambda_name = 'mock_lambda'

    @util.handle_lambda_result(lambda_name=lambda_name, default_error_code='1')
    def lambda_handler_mock(event, context):
        return {
            'status': status, 's3_obj': s3_obj, 'error_code': error_code,
            'error_description': error_description}

    result = lambda_handler_mock({}, {})
    assert result == {
        'function': lambda_name,
        'status': status,
        's3_object': s3_obj,
        'error_code': error_code,
        'error_description': error_description
    }
    clean_directory_mock.assert_called_once_with('/tmp/')