"""Tests for lambda_backfill module."""
import __builtin__
import base64
import json

from aws_kinesis_agg.deaggregator import iter_deaggregate_records
import pytest  # noqa

import lambda_backfill  # noqa


@pytest.fixture
def deaggregated_records():
    """List of records from lambda event."""
    with open('tests/lambda_event_fixture.json', 'r') as event_fixture:
        event = json.load(event_fixture)
    records = []
    for record in iter_deaggregate_records(event['Records']):
        payload = base64.b64decode(record['kinesis']['data'])
        json_payload = json.loads(payload)
        records.append(json_payload)

    return records


def test_update_redis_counter_no_job_id(mocker):
    """Expect to do nothing because no job_id provided."""
    mock_key_increment = mocker.patch.object(
        lambda_backfill.redis_conn, 'hincrby')

    lambda_backfill.update_redis_counter('', 1)

    assert mock_key_increment.called is False


def test_update_redis_counter_handles_exception(mocker):
    """Expect to catch error and print it."""
    error = Exception('Internal Error')
    mocker.patch.object(
        lambda_backfill.redis_conn, 'hincrby',
        side_effect=error)
    mock_print = mocker.patch.object(__builtin__, 'print')

    lambda_backfill.update_redis_counter('1', 1)

    mock_print.assert_called_with(error)


def test_update_redis_counter_happy_path(mocker):
    """Expect hash key in Redis to be incremented."""
    mock_key_increment = mocker.patch.object(
        lambda_backfill.redis_conn, 'hincrby')

    lambda_backfill.update_redis_counter('20', 1)

    mock_key_increment.assert_called_with('kinesis_counter', '20', 1)


def test_lambda_handler(mocker, deaggregated_records):
    """Expect to call updates and finish successfully."""
    mock_print = mocker.patch.object(__builtin__, 'print')
    mock_update_snowflake = mocker.patch.object(
        lambda_backfill.snowflake_model, 'update_snowflake')
    mock_update_redis_counter = mocker.patch.object(
        lambda_backfill, 'update_redis_counter')
    with open('tests/lambda_event_fixture.json', 'r') as event_fixture:
        event = json.load(event_fixture)
    expected_deaggregated_records = deaggregated_records
    expected_records_count = len(expected_deaggregated_records)
    expected_calls = [
        mocker.call('Deaggregated 2 records'),
        mocker.call('Successfully processed 2 records.')]

    lambda_backfill.lambda_handler(event, context=None)

    mock_print.assert_has_calls(expected_calls)
    mock_update_snowflake.assert_called_with(
        expected_deaggregated_records, 'INSERT', None)
    # 'test_job_id' is retrieved from record['kinesis']['data']['job_id']
    mock_update_redis_counter.assert_called_with(
        'test job id', expected_records_count)


def test_deaggregate_records(deaggregated_records):
    """Expect to get list of deaggregated records."""
    with open('tests/lambda_event_fixture.json', 'r') as event_fixture:
        event = json.load(event_fixture)
    expected_deaggregated_records = deaggregated_records

    result = lambda_backfill._deaggregate_records(event['Records'])

    assert result == expected_deaggregated_records


def test_get_job_id(deaggregated_records):
    """Expect to get job_id."""
    expected_job_id = 'test job id'

    result = lambda_backfill._get_job_id(deaggregated_records)

    assert result == expected_job_id


def test_get_job_id_not_found(deaggregated_records):
    """Expect to get empty string because job id wasn't provided."""
    for record in deaggregated_records:
        del record['job_id']

    result = lambda_backfill._get_job_id(deaggregated_records)

    assert result == ''