diff --git a/tests/components/zwave/conftest.py b/tests/components/zwave/conftest.py index 50edcfec157..146347620bd 100644 --- a/tests/components/zwave/conftest.py +++ b/tests/components/zwave/conftest.py @@ -1,8 +1,10 @@ """Fixtures for Z-Wave tests.""" import pytest -from tests.async_mock import MagicMock, patch -from tests.mock.zwave import MockNetwork, MockOption +from homeassistant.components.zwave import const + +from tests.async_mock import AsyncMock, MagicMock, patch +from tests.mock.zwave import MockNetwork, MockNode, MockOption, MockValue @pytest.fixture @@ -24,3 +26,53 @@ def mock_openzwave(): }, ): yield base_mock + + +@pytest.fixture +def mock_discovery(): + """Mock discovery.""" + discovery = MagicMock() + discovery.async_load_platform = AsyncMock(return_value=None) + yield discovery + + +@pytest.fixture +def mock_import_module(): + """Mock import module.""" + platform = MagicMock() + mock_device = MagicMock() + mock_device.name = "test_device" + platform.get_device.return_value = mock_device + + import_module = MagicMock() + import_module.return_value = platform + yield import_module + + +@pytest.fixture +def mock_values(): + """Mock values.""" + node = MockNode() + mock_schema = { + const.DISC_COMPONENT: "mock_component", + const.DISC_VALUES: { + const.DISC_PRIMARY: {const.DISC_COMMAND_CLASS: ["mock_primary_class"]}, + "secondary": {const.DISC_COMMAND_CLASS: ["mock_secondary_class"]}, + "optional": { + const.DISC_COMMAND_CLASS: ["mock_optional_class"], + const.DISC_OPTIONAL: True, + }, + }, + } + value_class = MagicMock() + value_class.primary = MockValue( + command_class="mock_primary_class", node=node, value_id=1000 + ) + value_class.secondary = MockValue(command_class="mock_secondary_class", node=node) + value_class.duplicate_secondary = MockValue( + command_class="mock_secondary_class", node=node + ) + value_class.optional = MockValue(command_class="mock_optional_class", node=node) + value_class.no_match_value = MockValue(command_class="mock_bad_class", node=node) + + yield (node, value_class, mock_schema) diff --git a/tests/components/zwave/test_init.py b/tests/components/zwave/test_init.py index 4cf639e7faf..16e8494963d 100644 --- a/tests/components/zwave/test_init.py +++ b/tests/components/zwave/test_init.py @@ -22,7 +22,7 @@ from homeassistant.helpers.device_registry import async_get_registry as get_dev_ from homeassistant.helpers.entity_registry import async_get_registry from homeassistant.setup import setup_component -from tests.async_mock import AsyncMock, MagicMock, patch +from tests.async_mock import MagicMock, patch from tests.common import async_fire_time_changed, get_test_home_assistant, mock_registry from tests.mock.zwave import MockEntityValues, MockNetwork, MockNode, MockValue @@ -817,363 +817,497 @@ async def test_network_complete_some_dead(hass, mock_openzwave): assert len(events) == 1 -class TestZWaveDeviceEntityValues(unittest.TestCase): - """Tests for the ZWaveDeviceEntityValues helper.""" +async def test_entity_discovery( + hass, mock_discovery, mock_import_module, mock_values, mock_openzwave +): + """Test the creation of a new entity.""" + (node, value_class, mock_schema) = mock_values - @pytest.fixture(autouse=True) - def set_mock_openzwave(self, mock_openzwave): - """Use the mock_openzwave fixture for this class.""" - self.mock_openzwave = mock_openzwave + registry = mock_registry(hass) - def setUp(self): - """Initialize values for this testcase class.""" - self.hass = get_test_home_assistant() - self.hass.start() - self.registry = mock_registry(self.hass) + mock_receivers = [] - setup_component(self.hass, "zwave", {"zwave": {}}) - self.hass.block_till_done() + def mock_connect(receiver, signal, *args, **kwargs): + if signal == MockNetwork.SIGNAL_VALUE_ADDED: + mock_receivers.append(receiver) - self.node = MockNode() - self.mock_schema = { - const.DISC_COMPONENT: "mock_component", - const.DISC_VALUES: { - const.DISC_PRIMARY: {const.DISC_COMMAND_CLASS: ["mock_primary_class"]}, - "secondary": {const.DISC_COMMAND_CLASS: ["mock_secondary_class"]}, - "optional": { - const.DISC_COMMAND_CLASS: ["mock_optional_class"], - const.DISC_OPTIONAL: True, - }, - }, - } - self.primary = MockValue( - command_class="mock_primary_class", node=self.node, value_id=1000 - ) - self.secondary = MockValue(command_class="mock_secondary_class", node=self.node) - self.duplicate_secondary = MockValue( - command_class="mock_secondary_class", node=self.node - ) - self.optional = MockValue(command_class="mock_optional_class", node=self.node) - self.no_match_value = MockValue(command_class="mock_bad_class", node=self.node) + with patch("pydispatch.dispatcher.connect", new=mock_connect): + await async_setup_component(hass, "zwave", {"zwave": {}}) + await hass.async_block_till_done() - self.entity_id = "mock_component.mock_node_mock_value" - self.zwave_config = {"zwave": {}} - self.device_config = {self.entity_id: {}} - self.addCleanup(self.tear_down_cleanup) + assert len(mock_receivers) == 1 - def tear_down_cleanup(self): - """Stop everything that was started.""" - self.hass.stop() + entity_id = "mock_component.mock_node_mock_value" + zwave_config = {"zwave": {}} + device_config = {entity_id: {}} - @patch.object(zwave, "import_module") - @patch.object(zwave, "discovery") - def test_entity_discovery(self, discovery, import_module): - """Test the creation of a new entity.""" - discovery.async_load_platform = AsyncMock(return_value=None) - mock_platform = MagicMock() - import_module.return_value = mock_platform - mock_device = MagicMock() - mock_device.name = "test_device" - mock_platform.get_device.return_value = mock_device + with patch.object(zwave, "discovery", mock_discovery): values = zwave.ZWaveDeviceEntityValues( - hass=self.hass, - schema=self.mock_schema, - primary_value=self.primary, - zwave_config=self.zwave_config, - device_config=self.device_config, - registry=self.registry, + hass=hass, + schema=mock_schema, + primary_value=value_class.primary, + zwave_config=zwave_config, + device_config=device_config, + registry=registry, ) + assert not mock_discovery.async_load_platform.called - assert values.primary is self.primary - assert len(list(values)) == 3 - assert sorted(list(values), key=lambda a: id(a)) == sorted( - [self.primary, None, None], key=lambda a: id(a) - ) - assert not discovery.async_load_platform.called + assert values.primary is value_class.primary + assert len(list(values)) == 3 + assert sorted(list(values), key=lambda a: id(a)) == sorted( + [value_class.primary, None, None], key=lambda a: id(a) + ) - values.check_value(self.secondary) - self.hass.block_till_done() + with patch.object(zwave, "discovery", mock_discovery), patch.object( + zwave, "import_module", mock_import_module + ): + values.check_value(value_class.secondary) + await hass.async_block_till_done() - assert values.secondary is self.secondary - assert len(list(values)) == 3 - assert sorted(list(values), key=lambda a: id(a)) == sorted( - [self.primary, self.secondary, None], key=lambda a: id(a) - ) + assert mock_discovery.async_load_platform.called + assert len(mock_discovery.async_load_platform.mock_calls) == 1 - assert discovery.async_load_platform.called - assert len(discovery.async_load_platform.mock_calls) == 1 - args = discovery.async_load_platform.mock_calls[0][1] - assert args[0] == self.hass + args = mock_discovery.async_load_platform.mock_calls[0][1] + assert args[0] == hass assert args[1] == "mock_component" assert args[2] == "zwave" - assert args[3] == {const.DISCOVERY_DEVICE: mock_device.unique_id} - assert args[4] == self.zwave_config - - discovery.async_load_platform.reset_mock() - values.check_value(self.optional) - values.check_value(self.duplicate_secondary) - values.check_value(self.no_match_value) - self.hass.block_till_done() - - assert values.optional is self.optional - assert len(list(values)) == 3 - assert sorted(list(values), key=lambda a: id(a)) == sorted( - [self.primary, self.secondary, self.optional], key=lambda a: id(a) - ) - assert not discovery.async_load_platform.called - - assert values._entity.value_added.called - assert len(values._entity.value_added.mock_calls) == 1 - assert values._entity.value_changed.called - assert len(values._entity.value_changed.mock_calls) == 1 - - @patch.object(zwave, "import_module") - @patch.object(zwave, "discovery") - def test_entity_existing_values(self, discovery, import_module): - """Test the loading of already discovered values.""" - discovery.async_load_platform = AsyncMock(return_value=None) - mock_platform = MagicMock() - import_module.return_value = mock_platform - mock_device = MagicMock() - mock_device.name = "test_device" - mock_platform.get_device.return_value = mock_device - self.node.values = { - self.primary.value_id: self.primary, - self.secondary.value_id: self.secondary, - self.optional.value_id: self.optional, - self.no_match_value.value_id: self.no_match_value, + assert args[3] == { + const.DISCOVERY_DEVICE: mock_import_module().get_device().unique_id } + assert args[4] == zwave_config + assert values.secondary is value_class.secondary + assert len(list(values)) == 3 + assert sorted(list(values), key=lambda a: id(a)) == sorted( + [value_class.primary, value_class.secondary, None], key=lambda a: id(a) + ) + + mock_discovery.async_load_platform.reset_mock() + with patch.object(zwave, "discovery", mock_discovery): + values.check_value(value_class.optional) + values.check_value(value_class.duplicate_secondary) + values.check_value(value_class.no_match_value) + await hass.async_block_till_done() + + assert not mock_discovery.async_load_platform.called + + assert values.optional is value_class.optional + assert len(list(values)) == 3 + assert sorted(list(values), key=lambda a: id(a)) == sorted( + [value_class.primary, value_class.secondary, value_class.optional], + key=lambda a: id(a), + ) + + assert values._entity.value_added.called + assert len(values._entity.value_added.mock_calls) == 1 + assert values._entity.value_changed.called + assert len(values._entity.value_changed.mock_calls) == 1 + + +async def test_entity_existing_values( + hass, mock_discovery, mock_import_module, mock_values, mock_openzwave +): + """Test the loading of already discovered values.""" + (node, value_class, mock_schema) = mock_values + + registry = mock_registry(hass) + + mock_receivers = [] + + def mock_connect(receiver, signal, *args, **kwargs): + if signal == MockNetwork.SIGNAL_VALUE_ADDED: + mock_receivers.append(receiver) + + with patch("pydispatch.dispatcher.connect", new=mock_connect): + await async_setup_component(hass, "zwave", {"zwave": {}}) + await hass.async_block_till_done() + + entity_id = "mock_component.mock_node_mock_value" + zwave_config = {"zwave": {}} + device_config = {entity_id: {}} + + node.values = { + value_class.primary.value_id: value_class.primary, + value_class.secondary.value_id: value_class.secondary, + value_class.optional.value_id: value_class.optional, + value_class.no_match_value.value_id: value_class.no_match_value, + } + + with patch.object(zwave, "discovery", mock_discovery), patch.object( + zwave, "import_module", mock_import_module + ): values = zwave.ZWaveDeviceEntityValues( - hass=self.hass, - schema=self.mock_schema, - primary_value=self.primary, - zwave_config=self.zwave_config, - device_config=self.device_config, - registry=self.registry, + hass=hass, + schema=mock_schema, + primary_value=value_class.primary, + zwave_config=zwave_config, + device_config=device_config, + registry=registry, ) - self.hass.block_till_done() + await hass.async_block_till_done() - assert values.primary is self.primary - assert values.secondary is self.secondary - assert values.optional is self.optional - assert len(list(values)) == 3 - assert sorted(list(values), key=lambda a: id(a)) == sorted( - [self.primary, self.secondary, self.optional], key=lambda a: id(a) - ) - - assert discovery.async_load_platform.called - assert len(discovery.async_load_platform.mock_calls) == 1 - args = discovery.async_load_platform.mock_calls[0][1] - assert args[0] == self.hass + assert mock_discovery.async_load_platform.called + assert len(mock_discovery.async_load_platform.mock_calls) == 1 + args = mock_discovery.async_load_platform.mock_calls[0][1] + assert args[0] == hass assert args[1] == "mock_component" assert args[2] == "zwave" - assert args[3] == {const.DISCOVERY_DEVICE: mock_device.unique_id} - assert args[4] == self.zwave_config - assert not self.primary.enable_poll.called - - @patch.object(zwave, "import_module") - @patch.object(zwave, "discovery") - def test_node_schema_mismatch(self, discovery, import_module): - """Test node schema mismatch.""" - self.node.generic = "no_match" - self.node.values = { - self.primary.value_id: self.primary, - self.secondary.value_id: self.secondary, + assert args[3] == { + const.DISCOVERY_DEVICE: mock_import_module().get_device().unique_id } - self.mock_schema[const.DISC_GENERIC_DEVICE_CLASS] = ["generic_match"] + assert args[4] == zwave_config + assert not value_class.primary.enable_poll.called + + assert values.primary is value_class.primary + assert values.secondary is value_class.secondary + assert values.optional is value_class.optional + assert len(list(values)) == 3 + assert sorted(list(values), key=lambda a: id(a)) == sorted( + [value_class.primary, value_class.secondary, value_class.optional], + key=lambda a: id(a), + ) + + +async def test_node_schema_mismatch(hass, mock_discovery, mock_values, mock_openzwave): + """Test node schema mismatch.""" + (node, value_class, mock_schema) = mock_values + + registry = mock_registry(hass) + + mock_receivers = [] + + def mock_connect(receiver, signal, *args, **kwargs): + if signal == MockNetwork.SIGNAL_VALUE_ADDED: + mock_receivers.append(receiver) + + with patch("pydispatch.dispatcher.connect", new=mock_connect): + await async_setup_component(hass, "zwave", {"zwave": {}}) + await hass.async_block_till_done() + + entity_id = "mock_component.mock_node_mock_value" + zwave_config = {"zwave": {}} + device_config = {entity_id: {}} + + node.generic = "no_match" + node.values = { + value_class.primary.value_id: value_class.primary, + value_class.secondary.value_id: value_class.secondary, + } + mock_schema[const.DISC_GENERIC_DEVICE_CLASS] = ["generic_match"] + + with patch.object(zwave, "discovery", mock_discovery): values = zwave.ZWaveDeviceEntityValues( - hass=self.hass, - schema=self.mock_schema, - primary_value=self.primary, - zwave_config=self.zwave_config, - device_config=self.device_config, - registry=self.registry, + hass=hass, + schema=mock_schema, + primary_value=value_class.primary, + zwave_config=zwave_config, + device_config=device_config, + registry=registry, ) values._check_entity_ready() - self.hass.block_till_done() + await hass.async_block_till_done() - assert not discovery.async_load_platform.called + assert not mock_discovery.async_load_platform.called - @patch.object(zwave, "import_module") - @patch.object(zwave, "discovery") - def test_entity_workaround_component(self, discovery, import_module): - """Test component workaround.""" - discovery.async_load_platform = AsyncMock(return_value=None) - mock_platform = MagicMock() - import_module.return_value = mock_platform - mock_device = MagicMock() - mock_device.name = "test_device" - mock_platform.get_device.return_value = mock_device - self.node.manufacturer_id = "010f" - self.node.product_type = "0b00" - self.primary.command_class = const.COMMAND_CLASS_SENSOR_ALARM - self.entity_id = "binary_sensor.mock_node_mock_value" - self.device_config = {self.entity_id: {}} - self.mock_schema = { - const.DISC_COMPONENT: "mock_component", - const.DISC_VALUES: { - const.DISC_PRIMARY: { - const.DISC_COMMAND_CLASS: [const.COMMAND_CLASS_SWITCH_BINARY] - } - }, - } +async def test_entity_workaround_component( + hass, mock_discovery, mock_import_module, mock_values, mock_openzwave +): + """Test component workaround.""" + (node, value_class, mock_schema) = mock_values - with patch.object(zwave, "async_dispatcher_send") as mock_dispatch_send: + registry = mock_registry(hass) - values = zwave.ZWaveDeviceEntityValues( - hass=self.hass, - schema=self.mock_schema, - primary_value=self.primary, - zwave_config=self.zwave_config, - device_config=self.device_config, - registry=self.registry, - ) - values._check_entity_ready() - self.hass.block_till_done() + mock_receivers = [] - assert mock_dispatch_send.called - assert len(mock_dispatch_send.mock_calls) == 1 - args = mock_dispatch_send.mock_calls[0][1] - assert args[1] == "zwave_new_binary_sensor" + def mock_connect(receiver, signal, *args, **kwargs): + if signal == MockNetwork.SIGNAL_VALUE_ADDED: + mock_receivers.append(receiver) - @patch.object(zwave, "import_module") - @patch.object(zwave, "discovery") - def test_entity_workaround_ignore(self, discovery, import_module): - """Test ignore workaround.""" - self.node.manufacturer_id = "010f" - self.node.product_type = "0301" - self.primary.command_class = const.COMMAND_CLASS_SWITCH_BINARY + with patch("pydispatch.dispatcher.connect", new=mock_connect): + await async_setup_component(hass, "zwave", {"zwave": {}}) + await hass.async_block_till_done() - self.mock_schema = { - const.DISC_COMPONENT: "mock_component", - const.DISC_VALUES: { - const.DISC_PRIMARY: { - const.DISC_COMMAND_CLASS: [const.COMMAND_CLASS_SWITCH_BINARY] - } - }, - } + node.manufacturer_id = "010f" + node.product_type = "0b00" + value_class.primary.command_class = const.COMMAND_CLASS_SENSOR_ALARM + + entity_id = "binary_sensor.mock_node_mock_value" + zwave_config = {"zwave": {}} + device_config = {entity_id: {}} + + mock_schema = { + const.DISC_COMPONENT: "mock_component", + const.DISC_VALUES: { + const.DISC_PRIMARY: { + const.DISC_COMMAND_CLASS: [const.COMMAND_CLASS_SWITCH_BINARY] + } + }, + } + + with patch.object( + zwave, "async_dispatcher_send" + ) as mock_dispatch_send, patch.object( + zwave, "discovery", mock_discovery + ), patch.object( + zwave, "import_module", mock_import_module + ): values = zwave.ZWaveDeviceEntityValues( - hass=self.hass, - schema=self.mock_schema, - primary_value=self.primary, - zwave_config=self.zwave_config, - device_config=self.device_config, - registry=self.registry, + hass=hass, + schema=mock_schema, + primary_value=value_class.primary, + zwave_config=zwave_config, + device_config=device_config, + registry=registry, ) values._check_entity_ready() - self.hass.block_till_done() + await hass.async_block_till_done() - assert not discovery.async_load_platform.called + assert mock_dispatch_send.called + assert len(mock_dispatch_send.mock_calls) == 1 + args = mock_dispatch_send.mock_calls[0][1] + assert args[1] == "zwave_new_binary_sensor" - @patch.object(zwave, "import_module") - @patch.object(zwave, "discovery") - def test_entity_config_ignore(self, discovery, import_module): - """Test ignore config.""" - self.node.values = { - self.primary.value_id: self.primary, - self.secondary.value_id: self.secondary, - } - self.device_config = {self.entity_id: {zwave.CONF_IGNORED: True}} + +async def test_entity_workaround_ignore( + hass, mock_discovery, mock_values, mock_openzwave +): + """Test ignore workaround.""" + (node, value_class, mock_schema) = mock_values + + registry = mock_registry(hass) + + mock_receivers = [] + + def mock_connect(receiver, signal, *args, **kwargs): + if signal == MockNetwork.SIGNAL_VALUE_ADDED: + mock_receivers.append(receiver) + + with patch("pydispatch.dispatcher.connect", new=mock_connect): + await async_setup_component(hass, "zwave", {"zwave": {}}) + await hass.async_block_till_done() + + entity_id = "mock_component.mock_node_mock_value" + zwave_config = {"zwave": {}} + device_config = {entity_id: {}} + + node.manufacturer_id = "010f" + node.product_type = "0301" + value_class.primary.command_class = const.COMMAND_CLASS_SWITCH_BINARY + + mock_schema = { + const.DISC_COMPONENT: "mock_component", + const.DISC_VALUES: { + const.DISC_PRIMARY: { + const.DISC_COMMAND_CLASS: [const.COMMAND_CLASS_SWITCH_BINARY] + } + }, + } + + with patch.object(zwave, "discovery", mock_discovery): values = zwave.ZWaveDeviceEntityValues( - hass=self.hass, - schema=self.mock_schema, - primary_value=self.primary, - zwave_config=self.zwave_config, - device_config=self.device_config, - registry=self.registry, + hass=hass, + schema=mock_schema, + primary_value=value_class.primary, + zwave_config=zwave_config, + device_config=device_config, + registry=registry, ) values._check_entity_ready() - self.hass.block_till_done() + await hass.async_block_till_done() - assert not discovery.async_load_platform.called + assert not mock_discovery.async_load_platform.called - @patch.object(zwave, "import_module") - @patch.object(zwave, "discovery") - def test_entity_config_ignore_with_registry(self, discovery, import_module): - """Test ignore config. - The case when the device is in entity registry. - """ - self.node.values = { - self.primary.value_id: self.primary, - self.secondary.value_id: self.secondary, - } - self.device_config = {"mock_component.registry_id": {zwave.CONF_IGNORED: True}} - with patch.object(self.registry, "async_schedule_save"): - self.registry.async_get_or_create( - "mock_component", - zwave.DOMAIN, - "567-1000", - suggested_object_id="registry_id", - ) +async def test_entity_config_ignore(hass, mock_discovery, mock_values, mock_openzwave): + """Test ignore config.""" + (node, value_class, mock_schema) = mock_values + registry = mock_registry(hass) + + mock_receivers = [] + + def mock_connect(receiver, signal, *args, **kwargs): + if signal == MockNetwork.SIGNAL_VALUE_ADDED: + mock_receivers.append(receiver) + + with patch("pydispatch.dispatcher.connect", new=mock_connect): + await async_setup_component(hass, "zwave", {"zwave": {}}) + await hass.async_block_till_done() + + entity_id = "mock_component.mock_node_mock_value" + zwave_config = {"zwave": {}} + device_config = {entity_id: {}} + + node.values = { + value_class.primary.value_id: value_class.primary, + value_class.secondary.value_id: value_class.secondary, + } + device_config = {entity_id: {zwave.CONF_IGNORED: True}} + + with patch.object(zwave, "discovery", mock_discovery): + values = zwave.ZWaveDeviceEntityValues( + hass=hass, + schema=mock_schema, + primary_value=value_class.primary, + zwave_config=zwave_config, + device_config=device_config, + registry=registry, + ) + values._check_entity_ready() + await hass.async_block_till_done() + + assert not mock_discovery.async_load_platform.called + + +async def test_entity_config_ignore_with_registry( + hass, mock_discovery, mock_values, mock_openzwave +): + """Test ignore config. + + The case when the device is in entity registry. + """ + (node, value_class, mock_schema) = mock_values + + registry = mock_registry(hass) + + mock_receivers = [] + + def mock_connect(receiver, signal, *args, **kwargs): + if signal == MockNetwork.SIGNAL_VALUE_ADDED: + mock_receivers.append(receiver) + + with patch("pydispatch.dispatcher.connect", new=mock_connect): + await async_setup_component(hass, "zwave", {"zwave": {}}) + await hass.async_block_till_done() + + entity_id = "mock_component.mock_node_mock_value" + zwave_config = {"zwave": {}} + device_config = {entity_id: {}} + + node.values = { + value_class.primary.value_id: value_class.primary, + value_class.secondary.value_id: value_class.secondary, + } + device_config = {"mock_component.registry_id": {zwave.CONF_IGNORED: True}} + with patch.object(registry, "async_schedule_save"): + registry.async_get_or_create( + "mock_component", + zwave.DOMAIN, + "567-1000", + suggested_object_id="registry_id", + ) + + with patch.object(zwave, "discovery", mock_discovery): zwave.ZWaveDeviceEntityValues( - hass=self.hass, - schema=self.mock_schema, - primary_value=self.primary, - zwave_config=self.zwave_config, - device_config=self.device_config, - registry=self.registry, + hass=hass, + schema=mock_schema, + primary_value=value_class.primary, + zwave_config=zwave_config, + device_config=device_config, + registry=registry, ) - self.hass.block_till_done() + await hass.async_block_till_done() - assert not discovery.async_load_platform.called + assert not mock_discovery.async_load_platform.called - @patch.object(zwave, "import_module") - @patch.object(zwave, "discovery") - def test_entity_platform_ignore(self, discovery, import_module): - """Test platform ignore device.""" - self.node.values = { - self.primary.value_id: self.primary, - self.secondary.value_id: self.secondary, - } - platform = MagicMock() - import_module.return_value = platform - platform.get_device.return_value = None + +async def test_entity_platform_ignore( + hass, mock_discovery, mock_values, mock_openzwave +): + """Test platform ignore device.""" + (node, value_class, mock_schema) = mock_values + + registry = mock_registry(hass) + + mock_receivers = [] + + def mock_connect(receiver, signal, *args, **kwargs): + if signal == MockNetwork.SIGNAL_VALUE_ADDED: + mock_receivers.append(receiver) + + with patch("pydispatch.dispatcher.connect", new=mock_connect): + await async_setup_component(hass, "zwave", {"zwave": {}}) + await hass.async_block_till_done() + + entity_id = "mock_component.mock_node_mock_value" + zwave_config = {"zwave": {}} + device_config = {entity_id: {}} + + node.values = { + value_class.primary.value_id: value_class.primary, + value_class.secondary.value_id: value_class.secondary, + } + + import_module = MagicMock() + platform = MagicMock() + import_module.return_value = platform + platform.get_device.return_value = None + + with patch.object(zwave, "discovery", mock_discovery), patch.object( + zwave, "import_module", import_module + ): zwave.ZWaveDeviceEntityValues( - hass=self.hass, - schema=self.mock_schema, - primary_value=self.primary, - zwave_config=self.zwave_config, - device_config=self.device_config, - registry=self.registry, + hass=hass, + schema=mock_schema, + primary_value=value_class.primary, + zwave_config=zwave_config, + device_config=device_config, + registry=registry, ) - self.hass.block_till_done() + await hass.async_block_till_done() - assert not discovery.async_load_platform.called + assert not mock_discovery.async_load_platform.called - @patch.object(zwave, "import_module") - @patch.object(zwave, "discovery") - def test_config_polling_intensity(self, discovery, import_module): - """Test polling intensity.""" - mock_platform = MagicMock() - import_module.return_value = mock_platform - mock_device = MagicMock() - mock_device.name = "test_device" - mock_platform.get_device.return_value = mock_device - self.node.values = { - self.primary.value_id: self.primary, - self.secondary.value_id: self.secondary, - } - self.device_config = {self.entity_id: {zwave.CONF_POLLING_INTENSITY: 123}} + +async def test_config_polling_intensity( + hass, mock_discovery, mock_import_module, mock_values, mock_openzwave +): + """Test polling intensity.""" + (node, value_class, mock_schema) = mock_values + + registry = mock_registry(hass) + + mock_receivers = [] + + def mock_connect(receiver, signal, *args, **kwargs): + if signal == MockNetwork.SIGNAL_VALUE_ADDED: + mock_receivers.append(receiver) + + with patch("pydispatch.dispatcher.connect", new=mock_connect): + await async_setup_component(hass, "zwave", {"zwave": {}}) + await hass.async_block_till_done() + + entity_id = "mock_component.mock_node_mock_value" + zwave_config = {"zwave": {}} + device_config = {entity_id: {}} + + node.values = { + value_class.primary.value_id: value_class.primary, + value_class.secondary.value_id: value_class.secondary, + } + device_config = {entity_id: {zwave.CONF_POLLING_INTENSITY: 123}} + + with patch.object(zwave, "discovery", mock_discovery), patch.object( + zwave, "import_module", mock_import_module + ): values = zwave.ZWaveDeviceEntityValues( - hass=self.hass, - schema=self.mock_schema, - primary_value=self.primary, - zwave_config=self.zwave_config, - device_config=self.device_config, - registry=self.registry, + hass=hass, + schema=mock_schema, + primary_value=value_class.primary, + zwave_config=zwave_config, + device_config=device_config, + registry=registry, ) values._check_entity_ready() - self.hass.block_till_done() + await hass.async_block_till_done() - assert discovery.async_load_platform.called - assert self.primary.enable_poll.called - assert len(self.primary.enable_poll.mock_calls) == 1 - assert self.primary.enable_poll.mock_calls[0][1][0] == 123 + assert mock_discovery.async_load_platform.called + + assert value_class.primary.enable_poll.called + assert len(value_class.primary.enable_poll.mock_calls) == 1 + assert value_class.primary.enable_poll.mock_calls[0][1][0] == 123 class TestZwave(unittest.TestCase):