"""Unit tests for KafkaMessage."""

import json
import re

import pytest

from switchboard_consumer.constants import entity_type
from switchboard_consumer.constants.system import ORCHARD
from switchboard_consumer.kafka_message import BadMessageFormat, KafkaMessage
from tests.conftest import SONY


class TestKafkaMessage:
    """Test KafkaMessage."""

    def test_invalid_json_message(self):
        """Test an invalid JSON message raises an Exception."""
        with pytest.raises(BadMessageFormat):
            KafkaMessage('not json')

    def test_valid_json_message(self):
        """Test a valid message."""
        kafka_message = KafkaMessage('{}')
        assert kafka_message.message == {}

    def test_sending_system_returns_correct_system(self):
        """Test sendingSystem is returned if present in the message."""
        message = json.dumps({
            'sendingSystem': SONY,
            'ids': [{'localId': 1, 'system': SONY}],
        })
        kafka_message = KafkaMessage(message)
        assert kafka_message.sending_system == SONY

    def test_sending_system_returns_none_if_no_system(self):
        """Test None is returned if no sending system in the message."""
        kafka_message = KafkaMessage(json.dumps({}))
        assert kafka_message.sending_system is None

    def test_sending_system_local_id_returns_ids(self):
        """Test ids are returned if present in the message."""
        message = {
            'sendingSystem': SONY,
            'ids': [{'localId': 1, 'system': SONY}],
        }
        kafka_message = KafkaMessage(json.dumps(message))
        assert kafka_message.sending_system_local_id == message['ids'][0]

    def test_sending_system_local_id_returns_none_if_no_ids(self):
        """Test None is returned if no ids present in the message."""
        message = {
            'sendingSystem': SONY,
            'ids': [],
        }
        kafka_message = KafkaMessage(json.dumps(message))
        assert kafka_message.sending_system_local_id is None

    def test_create_correlation_id(self):
        """Test correlation id is created if not in the message."""
        uuid_regex = re.compile('^[a-f0-9]{4}([a-f0-9]{4}-){4}[a-f0-9]{12}$')
        kafka_message = KafkaMessage(json.dumps({}))
        assert uuid_regex.match(kafka_message.correlation_id)

    def test_get_correlation_id(self):
        """Test correlation id is returned if in the message."""
        message = {'correlationId': 'abc123'}
        kafka_message = KafkaMessage(json.dumps(message))
        assert kafka_message.correlation_id == message['correlationId']

    def test_ids(self):
        """Test ids are returned if present in the message."""
        message = {
            'sendingSystem': SONY,
            'ids': [{'localId': 1, 'system': SONY}],
        }
        kafka_message = KafkaMessage(json.dumps(message))
        assert kafka_message.ids == message['ids']

    def test_ids_returns_none_if_no_ids(self):
        """Test None is returned if no ids present in the message."""
        message = {
            'sendingSystem': SONY,
            'ids': [],
        }
        kafka_message = KafkaMessage(json.dumps(message))
        assert kafka_message.ids == []

    def test_orchard_local_id(self):
        """Test Orchard local id returned if in the message."""
        message = {
            'sendingSystem': SONY,
            'ids': [{'localId': 1, 'system': ORCHARD}],
        }
        kafka_message = KafkaMessage(json.dumps(message))
        assert kafka_message.orchard_local_id == message['ids'][0]

    def test_orchard_local_id_with_no_id(self):
        """Test None returned if Orchard local id not in the message."""
        message = {
            'sendingSystem': SONY,
            'ids': [],
        }
        kafka_message = KafkaMessage(json.dumps(message))
        assert kafka_message.orchard_local_id is None

    def test_entity_type(self):
        """Test entityType returned if in the message."""
        message = {'entityType': entity_type.PROJECT}
        kafka_message = KafkaMessage(json.dumps(message))
        assert kafka_message.entity_type == entity_type.PROJECT

    def test_no_entity_type(self):
        """Test None returned if entityType not in the message."""
        kafka_message = KafkaMessage(json.dumps({}))
        assert kafka_message.entity_type is None