"""Test sqs queue messages validation."""

from flexmock import flexmock
from moto import mock_sqs

from oto import response
import pytest

from label_copy_export.connectors import sentry
from label_copy_export.connectors import sqs
from label_copy_export.validation.validate_csv import validate_sqs_message


TEST_CORRELATION_ID = 'c305d169-455b-4bdd-ab69-0c49c49ae4fc'

sqs_attributes_correlation_id = {
    sqs.CORRELATION_ID_ATTRIBUTE: {
        'string_value': TEST_CORRELATION_ID
    }
}


def test_get_connection():
    """Test if get_connection() returns a valid connection object."""
    with mock_sqs():
        connection = sqs.get_connection(
            access_key_id='test', secret_access_key='test-key')
        assert connection is not None


@pytest.mark.parametrize('explicit_connection', [True, False])
def test_get_queue_success(explicit_connection):
    """Test get_queue returns a Queue with correct message_class."""
    dev_test_queue = 'dev-test-queue'
    with mock_sqs():
        connection = sqs.get_connection(
            access_key_id='test', secret_access_key='test-key')
        connection.create_queue(dev_test_queue)
        if explicit_connection:
            queue = sqs.get_queue(dev_test_queue, sqs_connection=connection)
        else:
            queue = sqs.get_queue(dev_test_queue)

    assert queue is not None
    assert queue.message_class == sqs.JSONMessageExt


def test_get_queue_none():
    """Test get_queue returns None when there is no queue."""
    mock_connection = flexmock()
    (flexmock(sqs)
     .should_receive('get_connection')
     .and_return(mock_connection))
    (flexmock(mock_connection)
     .should_receive('get_queue')
     .and_return(None))

    queue = sqs.get_queue('does-not-matter')
    assert queue is None


@pytest.mark.parametrize('sentry_client', [None, flexmock()])
def test_get_queue_failure(sentry_client):
    """Test get_queue returns None on unexpected exception."""
    (flexmock(sqs)
     .should_receive('get_connection')
     .and_raise(ValueError()))
    if sentry_client:
        (flexmock(sentry.sentry_client)
         .should_receive('captureException')
         .once())

    queue = sqs.get_queue('does-not-matter')
    assert queue is None


def test_csv_label_copy_export_schema(
        create_sqs_message, valid_csv_generation_triggering_message):
    """Test validation of valid csv generation message."""
    message = create_sqs_message(
        valid_csv_generation_triggering_message)
    result = validate_sqs_message(message)
    assert response_returned(result)
    assert result


def test_invalid_csv_generation_message_schema(
        create_sqs_message, invalid_csv_generation_triggering_message):
    """Test invalid project id validation behavior."""
    message = create_sqs_message(
        invalid_csv_generation_triggering_message)
    result = validate_sqs_message(message)
    assert response_returned(result)
    assert not result


def test_no_project_id_csv_generation_message_schema(
        create_sqs_message, no_project_id_csv_generation_triggering_message):
    """Test no project id validation behavior."""
    message = create_sqs_message(
        no_project_id_csv_generation_triggering_message)
    result = validate_sqs_message(message)
    assert response_returned(result)
    assert not result


def test_no_job_id_csv_generation_message_schema(
        create_sqs_message, no_job_id_csv_generation_triggering_message):
    """Test no job id validation behavior."""
    message = create_sqs_message(
        no_job_id_csv_generation_triggering_message)
    result = validate_sqs_message(message)
    assert response_returned(result)
    assert not result


def response_returned(result):
    """Check that validating function returns Response."""
    return isinstance(result, response.Response)


def test_json_message_ext_correlation_id():
    """Test if JSONMessageExt can return correlation_id."""
    json_message = sqs.JSONMessageExt()
    (flexmock(json_message)
     .should_receive('message_attributes')
     .and_return(sqs_attributes_correlation_id))
    assert json_message.correlation_id == TEST_CORRELATION_ID


def test_json_message_ext_no_correlation_id():
    """Test if JSONMessageExt return None for empty correlation_id header."""
    json_message = sqs.JSONMessageExt()
    assert json_message.correlation_id is None


def test_json_message_ext_context():
    """Test if JSONMessageExt context can store and return a test value."""
    json_message = sqs.JSONMessageExt()
    json_message.context.test_value = 'test'
    assert json_message.context.test_value == 'test'