"""The tests for the MQTT component."""
import asyncio
import ssl
import unittest
from unittest import mock

import pytest
import voluptuous as vol

from homeassistant.components import mqtt
from homeassistant.const import (
    ATTR_DOMAIN,
    ATTR_SERVICE,
    EVENT_CALL_SERVICE,
    EVENT_HOMEASSISTANT_STOP,
)
from homeassistant.core import callback
from homeassistant.setup import async_setup_component
from homeassistant.exceptions import ConfigEntryNotReady

from tests.common import (
    MockConfigEntry,
    async_fire_mqtt_message,
    async_mock_mqtt_component,
    fire_mqtt_message,
    get_test_home_assistant,
    mock_coro,
    mock_mqtt_component,
    threadsafe_coroutine_factory,
)


@pytest.fixture
def mock_MQTT():
    """Make sure connection is established."""
    with mock.patch("homeassistant.components.mqtt.MQTT") as mock_MQTT:
        mock_MQTT.return_value.async_connect.return_value = mock_coro(True)
        yield mock_MQTT


async def async_mock_mqtt_client(hass, config=None):
    """Mock the MQTT paho client."""
    if config is None:
        config = {mqtt.CONF_BROKER: "mock-broker"}

    with mock.patch("paho.mqtt.client.Client") as mock_client:
        mock_client().connect.return_value = 0
        mock_client().subscribe.return_value = (0, 0)
        mock_client().unsubscribe.return_value = (0, 0)
        mock_client().publish.return_value = (0, 0)
        result = await async_setup_component(hass, mqtt.DOMAIN, {mqtt.DOMAIN: config})
        assert result
        await hass.async_block_till_done()
        return mock_client()


mock_mqtt_client = threadsafe_coroutine_factory(async_mock_mqtt_client)


# pylint: disable=invalid-name
class TestMQTTComponent(unittest.TestCase):
    """Test the MQTT component."""

    def setUp(self):  # pylint: disable=invalid-name
        """Set up things to be run when tests are started."""
        self.hass = get_test_home_assistant()
        mock_mqtt_component(self.hass)
        self.calls = []

    def tearDown(self):  # pylint: disable=invalid-name
        """Stop everything that was started."""
        self.hass.stop()

    @callback
    def record_calls(self, *args):
        """Record calls."""
        self.calls.append(args)

    def aiohttp_client_stops_on_home_assistant_start(self):
        """Test if client stops on HA stop."""
        self.hass.bus.fire(EVENT_HOMEASSISTANT_STOP)
        self.hass.block_till_done()
        assert self.hass.data["mqtt"].async_disconnect.called

    def test_publish_calls_service(self):
        """Test the publishing of call to services."""
        self.hass.bus.listen_once(EVENT_CALL_SERVICE, self.record_calls)

        mqtt.publish(self.hass, "test-topic", "test-payload")

        self.hass.block_till_done()

        assert len(self.calls) == 1
        assert self.calls[0][0].data["service_data"][mqtt.ATTR_TOPIC] == "test-topic"
        assert (
            self.calls[0][0].data["service_data"][mqtt.ATTR_PAYLOAD] == "test-payload"
        )

    def test_service_call_without_topic_does_not_publish(self):
        """Test the service call if topic is missing."""
        self.hass.bus.fire(
            EVENT_CALL_SERVICE,
            {ATTR_DOMAIN: mqtt.DOMAIN, ATTR_SERVICE: mqtt.SERVICE_PUBLISH},
        )
        self.hass.block_till_done()
        assert not self.hass.data["mqtt"].async_publish.called

    def test_service_call_with_template_payload_renders_template(self):
        """Test the service call with rendered template.

        If 'payload_template' is provided and 'payload' is not, then render it.
        """
        mqtt.publish_template(self.hass, "test/topic", "{{ 1+1 }}")
        self.hass.block_till_done()
        assert self.hass.data["mqtt"].async_publish.called
        assert self.hass.data["mqtt"].async_publish.call_args[0][1] == "2"

    def test_service_call_with_payload_doesnt_render_template(self):
        """Test the service call with unrendered template.

        If both 'payload' and 'payload_template' are provided then fail.
        """
        payload = "not a template"
        payload_template = "a template"
        with pytest.raises(vol.Invalid):
            self.hass.services.call(
                mqtt.DOMAIN,
                mqtt.SERVICE_PUBLISH,
                {
                    mqtt.ATTR_TOPIC: "test/topic",
                    mqtt.ATTR_PAYLOAD: payload,
                    mqtt.ATTR_PAYLOAD_TEMPLATE: payload_template,
                },
                blocking=True,
            )
        assert not self.hass.data["mqtt"].async_publish.called

    def test_service_call_with_ascii_qos_retain_flags(self):
        """Test the service call with args that can be misinterpreted.

        Empty payload message and ascii formatted qos and retain flags.
        """
        self.hass.services.call(
            mqtt.DOMAIN,
            mqtt.SERVICE_PUBLISH,
            {
                mqtt.ATTR_TOPIC: "test/topic",
                mqtt.ATTR_PAYLOAD: "",
                mqtt.ATTR_QOS: "2",
                mqtt.ATTR_RETAIN: "no",
            },
            blocking=True,
        )
        assert self.hass.data["mqtt"].async_publish.called
        assert self.hass.data["mqtt"].async_publish.call_args[0][2] == 2
        assert not self.hass.data["mqtt"].async_publish.call_args[0][3]

    def test_validate_topic(self):
        """Test topic name/filter validation."""
        # Invalid UTF-8, must not contain U+D800 to U+DFFF.
        with pytest.raises(vol.Invalid):
            mqtt.valid_topic("\ud800")
        with pytest.raises(vol.Invalid):
            mqtt.valid_topic("\udfff")
        # Topic MUST NOT be empty
        with pytest.raises(vol.Invalid):
            mqtt.valid_topic("")
        # Topic MUST NOT be longer than 65535 encoded bytes.
        with pytest.raises(vol.Invalid):
            mqtt.valid_topic("ü" * 32768)
        # UTF-8 MUST NOT include null character
        with pytest.raises(vol.Invalid):
            mqtt.valid_topic("bad\0one")

        # Topics "SHOULD NOT" include these special characters
        # (not MUST NOT, RFC2119). The receiver MAY close the connection.
        mqtt.valid_topic("\u0001")
        mqtt.valid_topic("\u001F")
        mqtt.valid_topic("\u009F")
        mqtt.valid_topic("\u009F")
        mqtt.valid_topic("\uffff")

    def test_validate_subscribe_topic(self):
        """Test invalid subscribe topics."""
        mqtt.valid_subscribe_topic("#")
        mqtt.valid_subscribe_topic("sport/#")
        with pytest.raises(vol.Invalid):
            mqtt.valid_subscribe_topic("sport/#/")
        with pytest.raises(vol.Invalid):
            mqtt.valid_subscribe_topic("foo/bar#")
        with pytest.raises(vol.Invalid):
            mqtt.valid_subscribe_topic("foo/#/bar")

        mqtt.valid_subscribe_topic("+")
        mqtt.valid_subscribe_topic("+/tennis/#")
        with pytest.raises(vol.Invalid):
            mqtt.valid_subscribe_topic("sport+")
        with pytest.raises(vol.Invalid):
            mqtt.valid_subscribe_topic("sport+/")
        with pytest.raises(vol.Invalid):
            mqtt.valid_subscribe_topic("sport/+1")
        with pytest.raises(vol.Invalid):
            mqtt.valid_subscribe_topic("sport/+#")
        with pytest.raises(vol.Invalid):
            mqtt.valid_subscribe_topic("bad+topic")
        mqtt.valid_subscribe_topic("sport/+/player1")
        mqtt.valid_subscribe_topic("/finance")
        mqtt.valid_subscribe_topic("+/+")
        mqtt.valid_subscribe_topic("$SYS/#")

    def test_validate_publish_topic(self):
        """Test invalid publish topics."""
        with pytest.raises(vol.Invalid):
            mqtt.valid_publish_topic("pub+")
        with pytest.raises(vol.Invalid):
            mqtt.valid_publish_topic("pub/+")
        with pytest.raises(vol.Invalid):
            mqtt.valid_publish_topic("1#")
        with pytest.raises(vol.Invalid):
            mqtt.valid_publish_topic("bad+topic")
        mqtt.valid_publish_topic("//")

        # Topic names beginning with $ SHOULD NOT be used, but can
        mqtt.valid_publish_topic("$SYS/")

    def test_entity_device_info_schema(self):
        """Test MQTT entity device info validation."""
        # just identifier
        mqtt.MQTT_ENTITY_DEVICE_INFO_SCHEMA({"identifiers": ["abcd"]})
        mqtt.MQTT_ENTITY_DEVICE_INFO_SCHEMA({"identifiers": "abcd"})
        # just connection
        mqtt.MQTT_ENTITY_DEVICE_INFO_SCHEMA(
            {"connections": [["mac", "02:5b:26:a8:dc:12"]]}
        )
        # full device info
        mqtt.MQTT_ENTITY_DEVICE_INFO_SCHEMA(
            {
                "identifiers": ["helloworld", "hello"],
                "connections": [["mac", "02:5b:26:a8:dc:12"], ["zigbee", "zigbee_id"]],
                "manufacturer": "Whatever",
                "name": "Beer",
                "model": "Glass",
                "sw_version": "0.1-beta",
            }
        )
        # full device info with via_device
        mqtt.MQTT_ENTITY_DEVICE_INFO_SCHEMA(
            {
                "identifiers": ["helloworld", "hello"],
                "connections": [["mac", "02:5b:26:a8:dc:12"], ["zigbee", "zigbee_id"]],
                "manufacturer": "Whatever",
                "name": "Beer",
                "model": "Glass",
                "sw_version": "0.1-beta",
                "via_device": "test-hub",
            }
        )
        # no identifiers
        with pytest.raises(vol.Invalid):
            mqtt.MQTT_ENTITY_DEVICE_INFO_SCHEMA(
                {
                    "manufacturer": "Whatever",
                    "name": "Beer",
                    "model": "Glass",
                    "sw_version": "0.1-beta",
                }
            )
        # empty identifiers
        with pytest.raises(vol.Invalid):
            mqtt.MQTT_ENTITY_DEVICE_INFO_SCHEMA(
                {"identifiers": [], "connections": [], "name": "Beer"}
            )


# pylint: disable=invalid-name
class TestMQTTCallbacks(unittest.TestCase):
    """Test the MQTT callbacks."""

    def setUp(self):  # pylint: disable=invalid-name
        """Set up things to be run when tests are started."""
        self.hass = get_test_home_assistant()
        mock_mqtt_client(self.hass)
        self.calls = []

    def tearDown(self):  # pylint: disable=invalid-name
        """Stop everything that was started."""
        self.hass.stop()

    @callback
    def record_calls(self, *args):
        """Record calls."""
        self.calls.append(args)

    def aiohttp_client_starts_on_home_assistant_mqtt_setup(self):
        """Test if client is connected after mqtt init on bootstrap."""
        assert self.hass.data["mqtt"]._mqttc.connect.call_count == 1

    def test_receiving_non_utf8_message_gets_logged(self):
        """Test receiving a non utf8 encoded message."""
        mqtt.subscribe(self.hass, "test-topic", self.record_calls)

        with self.assertLogs(level="WARNING") as test_handle:
            fire_mqtt_message(self.hass, "test-topic", b"\x9a")

            self.hass.block_till_done()
            assert (
                "WARNING:homeassistant.components.mqtt:Can't decode payload "
                "b'\\x9a' on test-topic with encoding utf-8" in test_handle.output[0]
            )

    def test_all_subscriptions_run_when_decode_fails(self):
        """Test all other subscriptions still run when decode fails for one."""
        mqtt.subscribe(self.hass, "test-topic", self.record_calls, encoding="ascii")
        mqtt.subscribe(self.hass, "test-topic", self.record_calls)

        fire_mqtt_message(self.hass, "test-topic", "°C")

        self.hass.block_till_done()
        assert len(self.calls) == 1

    def test_subscribe_topic(self):
        """Test the subscription of a topic."""
        unsub = mqtt.subscribe(self.hass, "test-topic", self.record_calls)

        fire_mqtt_message(self.hass, "test-topic", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 1
        assert self.calls[0][0].topic == "test-topic"
        assert self.calls[0][0].payload == "test-payload"

        unsub()

        fire_mqtt_message(self.hass, "test-topic", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 1

    def test_subscribe_topic_not_match(self):
        """Test if subscribed topic is not a match."""
        mqtt.subscribe(self.hass, "test-topic", self.record_calls)

        fire_mqtt_message(self.hass, "another-test-topic", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 0

    def test_subscribe_topic_level_wildcard(self):
        """Test the subscription of wildcard topics."""
        mqtt.subscribe(self.hass, "test-topic/+/on", self.record_calls)

        fire_mqtt_message(self.hass, "test-topic/bier/on", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 1
        assert self.calls[0][0].topic == "test-topic/bier/on"
        assert self.calls[0][0].payload == "test-payload"

    def test_subscribe_topic_level_wildcard_no_subtree_match(self):
        """Test the subscription of wildcard topics."""
        mqtt.subscribe(self.hass, "test-topic/+/on", self.record_calls)

        fire_mqtt_message(self.hass, "test-topic/bier", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 0

    def test_subscribe_topic_level_wildcard_root_topic_no_subtree_match(self):
        """Test the subscription of wildcard topics."""
        mqtt.subscribe(self.hass, "test-topic/#", self.record_calls)

        fire_mqtt_message(self.hass, "test-topic-123", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 0

    def test_subscribe_topic_subtree_wildcard_subtree_topic(self):
        """Test the subscription of wildcard topics."""
        mqtt.subscribe(self.hass, "test-topic/#", self.record_calls)

        fire_mqtt_message(self.hass, "test-topic/bier/on", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 1
        assert self.calls[0][0].topic == "test-topic/bier/on"
        assert self.calls[0][0].payload == "test-payload"

    def test_subscribe_topic_subtree_wildcard_root_topic(self):
        """Test the subscription of wildcard topics."""
        mqtt.subscribe(self.hass, "test-topic/#", self.record_calls)

        fire_mqtt_message(self.hass, "test-topic", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 1
        assert self.calls[0][0].topic == "test-topic"
        assert self.calls[0][0].payload == "test-payload"

    def test_subscribe_topic_subtree_wildcard_no_match(self):
        """Test the subscription of wildcard topics."""
        mqtt.subscribe(self.hass, "test-topic/#", self.record_calls)

        fire_mqtt_message(self.hass, "another-test-topic", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 0

    def test_subscribe_topic_level_wildcard_and_wildcard_root_topic(self):
        """Test the subscription of wildcard topics."""
        mqtt.subscribe(self.hass, "+/test-topic/#", self.record_calls)

        fire_mqtt_message(self.hass, "hi/test-topic", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 1
        assert self.calls[0][0].topic == "hi/test-topic"
        assert self.calls[0][0].payload == "test-payload"

    def test_subscribe_topic_level_wildcard_and_wildcard_subtree_topic(self):
        """Test the subscription of wildcard topics."""
        mqtt.subscribe(self.hass, "+/test-topic/#", self.record_calls)

        fire_mqtt_message(self.hass, "hi/test-topic/here-iam", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 1
        assert self.calls[0][0].topic == "hi/test-topic/here-iam"
        assert self.calls[0][0].payload == "test-payload"

    def test_subscribe_topic_level_wildcard_and_wildcard_level_no_match(self):
        """Test the subscription of wildcard topics."""
        mqtt.subscribe(self.hass, "+/test-topic/#", self.record_calls)

        fire_mqtt_message(self.hass, "hi/here-iam/test-topic", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 0

    def test_subscribe_topic_level_wildcard_and_wildcard_no_match(self):
        """Test the subscription of wildcard topics."""
        mqtt.subscribe(self.hass, "+/test-topic/#", self.record_calls)

        fire_mqtt_message(self.hass, "hi/another-test-topic", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 0

    def test_subscribe_topic_sys_root(self):
        """Test the subscription of $ root topics."""
        mqtt.subscribe(self.hass, "$test-topic/subtree/on", self.record_calls)

        fire_mqtt_message(self.hass, "$test-topic/subtree/on", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 1
        assert self.calls[0][0].topic == "$test-topic/subtree/on"
        assert self.calls[0][0].payload == "test-payload"

    def test_subscribe_topic_sys_root_and_wildcard_topic(self):
        """Test the subscription of $ root and wildcard topics."""
        mqtt.subscribe(self.hass, "$test-topic/#", self.record_calls)

        fire_mqtt_message(self.hass, "$test-topic/some-topic", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 1
        assert self.calls[0][0].topic == "$test-topic/some-topic"
        assert self.calls[0][0].payload == "test-payload"

    def test_subscribe_topic_sys_root_and_wildcard_subtree_topic(self):
        """Test the subscription of $ root and wildcard subtree topics."""
        mqtt.subscribe(self.hass, "$test-topic/subtree/#", self.record_calls)

        fire_mqtt_message(self.hass, "$test-topic/subtree/some-topic", "test-payload")

        self.hass.block_till_done()
        assert len(self.calls) == 1
        assert self.calls[0][0].topic == "$test-topic/subtree/some-topic"
        assert self.calls[0][0].payload == "test-payload"

    def test_subscribe_special_characters(self):
        """Test the subscription to topics with special characters."""
        topic = "/test-topic/$(.)[^]{-}"
        payload = "p4y.l[]a|> ?"

        mqtt.subscribe(self.hass, topic, self.record_calls)

        fire_mqtt_message(self.hass, topic, payload)
        self.hass.block_till_done()
        assert len(self.calls) == 1
        assert self.calls[0][0].topic == topic
        assert self.calls[0][0].payload == payload

    def test_mqtt_failed_connection_results_in_disconnect(self):
        """Test if connection failure leads to disconnect."""
        for result_code in range(1, 6):
            self.hass.data["mqtt"]._mqttc = mock.MagicMock()
            self.hass.data["mqtt"]._mqtt_on_connect(
                None, {"topics": {}}, 0, result_code
            )
            assert self.hass.data["mqtt"]._mqttc.disconnect.called

    def test_mqtt_disconnect_tries_no_reconnect_on_stop(self):
        """Test the disconnect tries."""
        self.hass.data["mqtt"]._mqtt_on_disconnect(None, None, 0)
        assert not self.hass.data["mqtt"]._mqttc.reconnect.called

    @mock.patch("homeassistant.components.mqtt.time.sleep")
    def test_mqtt_disconnect_tries_reconnect(self, mock_sleep):
        """Test the re-connect tries."""
        self.hass.data["mqtt"].subscriptions = [
            mqtt.Subscription("test/progress", None, 0),
            mqtt.Subscription("test/progress", None, 1),
            mqtt.Subscription("test/topic", None, 2),
        ]
        self.hass.data["mqtt"]._mqttc.reconnect.side_effect = [1, 1, 1, 0]
        self.hass.data["mqtt"]._mqtt_on_disconnect(None, None, 1)
        assert self.hass.data["mqtt"]._mqttc.reconnect.called
        assert len(self.hass.data["mqtt"]._mqttc.reconnect.mock_calls) == 4
        assert [call[1][0] for call in mock_sleep.mock_calls] == [1, 2, 4]

    def test_retained_message_on_subscribe_received(self):
        """Test every subscriber receives retained message on subscribe."""

        def side_effect(*args):
            async_fire_mqtt_message(self.hass, "test/state", "online")
            return 0, 0

        self.hass.data["mqtt"]._mqttc.subscribe.side_effect = side_effect

        calls_a = mock.MagicMock()
        mqtt.subscribe(self.hass, "test/state", calls_a)
        self.hass.block_till_done()
        assert calls_a.called

        calls_b = mock.MagicMock()
        mqtt.subscribe(self.hass, "test/state", calls_b)
        self.hass.block_till_done()
        assert calls_b.called

    def test_not_calling_unsubscribe_with_active_subscribers(self):
        """Test not calling unsubscribe() when other subscribers are active."""
        unsub = mqtt.subscribe(self.hass, "test/state", None)
        mqtt.subscribe(self.hass, "test/state", None)
        self.hass.block_till_done()
        assert self.hass.data["mqtt"]._mqttc.subscribe.called

        unsub()
        self.hass.block_till_done()
        assert not self.hass.data["mqtt"]._mqttc.unsubscribe.called

    def test_restore_subscriptions_on_reconnect(self):
        """Test subscriptions are restored on reconnect."""
        mqtt.subscribe(self.hass, "test/state", None)
        self.hass.block_till_done()
        assert self.hass.data["mqtt"]._mqttc.subscribe.call_count == 1

        self.hass.data["mqtt"]._mqtt_on_disconnect(None, None, 0)
        self.hass.data["mqtt"]._mqtt_on_connect(None, None, None, 0)
        self.hass.block_till_done()
        assert self.hass.data["mqtt"]._mqttc.subscribe.call_count == 2

    def test_restore_all_active_subscriptions_on_reconnect(self):
        """Test active subscriptions are restored correctly on reconnect."""
        self.hass.data["mqtt"]._mqttc.subscribe.side_effect = (
            (0, 1),
            (0, 2),
            (0, 3),
            (0, 4),
        )

        unsub = mqtt.subscribe(self.hass, "test/state", None, qos=2)
        mqtt.subscribe(self.hass, "test/state", None)
        mqtt.subscribe(self.hass, "test/state", None, qos=1)
        self.hass.block_till_done()

        expected = [
            mock.call("test/state", 2),
            mock.call("test/state", 0),
            mock.call("test/state", 1),
        ]
        assert self.hass.data["mqtt"]._mqttc.subscribe.mock_calls == expected

        unsub()
        self.hass.block_till_done()
        assert self.hass.data["mqtt"]._mqttc.unsubscribe.call_count == 0

        self.hass.data["mqtt"]._mqtt_on_disconnect(None, None, 0)
        self.hass.data["mqtt"]._mqtt_on_connect(None, None, None, 0)
        self.hass.block_till_done()

        expected.append(mock.call("test/state", 1))
        assert self.hass.data["mqtt"]._mqttc.subscribe.mock_calls == expected


@asyncio.coroutine
def test_setup_embedded_starts_with_no_config(hass):
    """Test setting up embedded server with no config."""
    client_config = ("localhost", 1883, "user", "pass", None, "3.1.1")

    with mock.patch(
        "homeassistant.components.mqtt.server.async_start",
        return_value=mock_coro(return_value=(True, client_config)),
    ) as _start:
        yield from async_mock_mqtt_client(hass, {})
        assert _start.call_count == 1


@asyncio.coroutine
def test_setup_embedded_with_embedded(hass):
    """Test setting up embedded server with no config."""
    client_config = ("localhost", 1883, "user", "pass", None, "3.1.1")

    with mock.patch(
        "homeassistant.components.mqtt.server.async_start",
        return_value=mock_coro(return_value=(True, client_config)),
    ) as _start:
        _start.return_value = mock_coro(return_value=(True, client_config))
        yield from async_mock_mqtt_client(hass, {"embedded": None})
        assert _start.call_count == 1


async def test_setup_fails_if_no_connect_broker(hass):
    """Test for setup failure if connection to broker is missing."""
    entry = MockConfigEntry(domain=mqtt.DOMAIN, data={mqtt.CONF_BROKER: "test-broker"})

    with mock.patch("paho.mqtt.client.Client") as mock_client:
        mock_client().connect = lambda *args: 1
        assert not await mqtt.async_setup_entry(hass, entry)


async def test_setup_raises_ConfigEntryNotReady_if_no_connect_broker(hass):
    """Test for setup failure if connection to broker is missing."""
    entry = MockConfigEntry(domain=mqtt.DOMAIN, data={mqtt.CONF_BROKER: "test-broker"})

    with mock.patch("paho.mqtt.client.Client") as mock_client:
        mock_client().connect = mock.Mock(side_effect=OSError("Connection error"))
        with pytest.raises(ConfigEntryNotReady):
            await mqtt.async_setup_entry(hass, entry)


async def test_setup_uses_certificate_on_certificate_set_to_auto(hass, mock_MQTT):
    """Test setup uses bundled certs when certificate is set to auto."""
    entry = MockConfigEntry(
        domain=mqtt.DOMAIN,
        data={mqtt.CONF_BROKER: "test-broker", "certificate": "auto"},
    )

    assert await mqtt.async_setup_entry(hass, entry)

    assert mock_MQTT.called

    import requests.certs

    expectedCertificate = requests.certs.where()
    assert mock_MQTT.mock_calls[0][2]["certificate"] == expectedCertificate


async def test_setup_does_not_use_certificate_on_mqtts_port(hass, mock_MQTT):
    """Test setup doesn't use bundled certs when ssl set."""
    entry = MockConfigEntry(
        domain=mqtt.DOMAIN, data={mqtt.CONF_BROKER: "test-broker", "port": 8883}
    )

    assert await mqtt.async_setup_entry(hass, entry)

    assert mock_MQTT.called
    assert mock_MQTT.mock_calls[0][2]["port"] == 8883

    import requests.certs

    mqttsCertificateBundle = requests.certs.where()
    assert mock_MQTT.mock_calls[0][2]["port"] != mqttsCertificateBundle


async def test_setup_without_tls_config_uses_tlsv1_under_python36(hass, mock_MQTT):
    """Test setup defaults to TLSv1 under python3.6."""
    entry = MockConfigEntry(domain=mqtt.DOMAIN, data={mqtt.CONF_BROKER: "test-broker"})

    assert await mqtt.async_setup_entry(hass, entry)

    assert mock_MQTT.called

    import sys

    if sys.hexversion >= 0x03060000:
        expectedTlsVersion = ssl.PROTOCOL_TLS  # pylint: disable=no-member
    else:
        expectedTlsVersion = ssl.PROTOCOL_TLSv1

    assert mock_MQTT.mock_calls[0][2]["tls_version"] == expectedTlsVersion


async def test_setup_with_tls_config_uses_tls_version1_2(hass, mock_MQTT):
    """Test setup uses specified TLS version."""
    entry = MockConfigEntry(
        domain=mqtt.DOMAIN, data={mqtt.CONF_BROKER: "test-broker", "tls_version": "1.2"}
    )

    assert await mqtt.async_setup_entry(hass, entry)

    assert mock_MQTT.called

    assert mock_MQTT.mock_calls[0][2]["tls_version"] == ssl.PROTOCOL_TLSv1_2


async def test_setup_with_tls_config_of_v1_under_python36_only_uses_v1(hass, mock_MQTT):
    """Test setup uses TLSv1.0 if explicitly chosen."""
    entry = MockConfigEntry(
        domain=mqtt.DOMAIN, data={mqtt.CONF_BROKER: "test-broker", "tls_version": "1.0"}
    )

    assert await mqtt.async_setup_entry(hass, entry)

    assert mock_MQTT.called
    assert mock_MQTT.mock_calls[0][2]["tls_version"] == ssl.PROTOCOL_TLSv1


@asyncio.coroutine
def test_birth_message(hass):
    """Test sending birth message."""
    mqtt_client = yield from async_mock_mqtt_client(
        hass,
        {
            mqtt.CONF_BROKER: "mock-broker",
            mqtt.CONF_BIRTH_MESSAGE: {
                mqtt.ATTR_TOPIC: "birth",
                mqtt.ATTR_PAYLOAD: "birth",
            },
        },
    )
    calls = []
    mqtt_client.publish.side_effect = lambda *args: calls.append(args)
    hass.data["mqtt"]._mqtt_on_connect(None, None, 0, 0)
    yield from hass.async_block_till_done()
    assert calls[-1] == ("birth", "birth", 0, False)


@asyncio.coroutine
def test_mqtt_subscribes_topics_on_connect(hass):
    """Test subscription to topic on connect."""
    mqtt_client = yield from async_mock_mqtt_client(hass)

    hass.data["mqtt"].subscriptions = [
        mqtt.Subscription("topic/test", None),
        mqtt.Subscription("home/sensor", None, 2),
        mqtt.Subscription("still/pending", None),
        mqtt.Subscription("still/pending", None, 1),
    ]

    hass.add_job = mock.MagicMock()
    hass.data["mqtt"]._mqtt_on_connect(None, None, 0, 0)

    yield from hass.async_block_till_done()

    assert mqtt_client.disconnect.call_count == 0

    expected = {"topic/test": 0, "home/sensor": 2, "still/pending": 1}
    calls = {call[1][1]: call[1][2] for call in hass.add_job.mock_calls}
    assert calls == expected


async def test_setup_fails_without_config(hass):
    """Test if the MQTT component fails to load with no config."""
    assert not await async_setup_component(hass, mqtt.DOMAIN, {})


async def test_message_callback_exception_gets_logged(hass, caplog):
    """Test exception raised by message handler."""
    await async_mock_mqtt_component(hass)

    @callback
    def bad_handler(*args):
        """Record calls."""
        raise Exception("This is a bad message callback")

    await mqtt.async_subscribe(hass, "test-topic", bad_handler)
    async_fire_mqtt_message(hass, "test-topic", "test")
    await hass.async_block_till_done()

    assert (
        "Exception in bad_handler when handling msg on 'test-topic':"
        " 'test'" in caplog.text
    )


async def test_mqtt_ws_subscription(hass, hass_ws_client):
    """Test MQTT websocket subscription."""
    await async_mock_mqtt_component(hass)

    client = await hass_ws_client(hass)
    await client.send_json({"id": 5, "type": "mqtt/subscribe", "topic": "test-topic"})
    response = await client.receive_json()
    assert response["success"]

    async_fire_mqtt_message(hass, "test-topic", "test1")
    async_fire_mqtt_message(hass, "test-topic", "test2")

    response = await client.receive_json()
    assert response["event"]["topic"] == "test-topic"
    assert response["event"]["payload"] == "test1"

    response = await client.receive_json()
    assert response["event"]["topic"] == "test-topic"
    assert response["event"]["payload"] == "test2"

    # Unsubscribe
    await client.send_json({"id": 8, "type": "unsubscribe_events", "subscription": 5})
    response = await client.receive_json()
    assert response["success"]