text: """Test Z-Wave node entity."""
  from unittest.mock import MagicMock, patch
  
  import pytest
  
  from homeassistant.components.zwave import const, node_entity
  from homeassistant.const import ATTR_ENTITY_ID
  
  import tests.mock.zwave as mock_zwave
  
  # Integration is disabled
  pytest.skip("Integration has been disabled in the manifest", allow_module_level=True)
  
  
  async def test_maybe_schedule_update(hass, mock_openzwave):
      """Test maybe schedule update."""
      base_entity = node_entity.ZWaveBaseEntity()
      base_entity.entity_id = "zwave.bla"
      base_entity.hass = hass
  
      with patch.object(hass.loop, "call_later") as mock_call_later:
          base_entity._schedule_update()
          assert mock_call_later.called
  
          base_entity._schedule_update()
          assert len(mock_call_later.mock_calls) == 1
          assert base_entity._update_scheduled is True
  
          do_update = mock_call_later.mock_calls[0][1][1]
  
          do_update()
          assert base_entity._update_scheduled is False
  
          base_entity._schedule_update()
          assert len(mock_call_later.mock_calls) == 2
  
  
  async def test_node_event_activated(hass, mock_openzwave):
      """Test Node event activated event."""
      mock_receivers = []
  
      def mock_connect(receiver, signal, *args, **kwargs):
          if signal == mock_zwave.MockNetwork.SIGNAL_NODE_EVENT:
              mock_receivers.append(receiver)
  
      node = mock_zwave.MockNode(node_id=11)
  
      with patch("pydispatch.dispatcher.connect", new=mock_connect):
          entity = node_entity.ZWaveNodeEntity(node, mock_openzwave)
  
      assert len(mock_receivers) == 1
  
      events = []
  
      def listener(event):
          events.append(event)
  
      hass.bus.async_listen(const.EVENT_NODE_EVENT, listener)
  
      # Test event before entity added to hass
      value = 234
      hass.async_add_job(mock_receivers[0], node, value)
      await hass.async_block_till_done()
      assert len(events) == 0
  
      # Add entity to hass
      entity.hass = hass
      entity.entity_id = "zwave.mock_node"
  
      value = 234
      hass.async_add_job(mock_receivers[0], node, value)
      await hass.async_block_till_done()
  
      assert len(events) == 1
      assert events[0].data[ATTR_ENTITY_ID] == "zwave.mock_node"
      assert events[0].data[const.ATTR_NODE_ID] == 11
      assert events[0].data[const.ATTR_BASIC_LEVEL] == value
  
  
  async def test_scene_activated(hass, mock_openzwave):
      """Test scene activated event."""
      mock_receivers = []
  
      def mock_connect(receiver, signal, *args, **kwargs):
          if signal == mock_zwave.MockNetwork.SIGNAL_SCENE_EVENT:
              mock_receivers.append(receiver)
  
      node = mock_zwave.MockNode(node_id=11)
  
      with patch("pydispatch.dispatcher.connect", new=mock_connect):
          entity = node_entity.ZWaveNodeEntity(node, mock_openzwave)
  
      assert len(mock_receivers) == 1
  
      events = []
  
      def listener(event):
          events.append(event)
  
      hass.bus.async_listen(const.EVENT_SCENE_ACTIVATED, listener)
  
      # Test event before entity added to hass
      scene_id = 123
      hass.async_add_job(mock_receivers[0], node, scene_id)
      await hass.async_block_till_done()
      assert len(events) == 0
  
      # Add entity to hass
      entity.hass = hass
      entity.entity_id = "zwave.mock_node"
  
      scene_id = 123
      hass.async_add_job(mock_receivers[0], node, scene_id)
      await hass.async_block_till_done()
  
      assert len(events) == 1
      assert events[0].data[ATTR_ENTITY_ID] == "zwave.mock_node"
      assert events[0].data[const.ATTR_NODE_ID] == 11
      assert events[0].data[const.ATTR_SCENE_ID] == scene_id
  
  
  async def test_central_scene_activated(hass, mock_openzwave):
      """Test central scene activated event."""
      mock_receivers = []
  
      def mock_connect(receiver, signal, *args, **kwargs):
          if signal == mock_zwave.MockNetwork.SIGNAL_VALUE_CHANGED:
              mock_receivers.append(receiver)
  
      node = mock_zwave.MockNode(node_id=11)
  
      with patch("pydispatch.dispatcher.connect", new=mock_connect):
          entity = node_entity.ZWaveNodeEntity(node, mock_openzwave)
  
      assert len(mock_receivers) == 1
  
      events = []
  
      def listener(event):
          events.append(event)
  
      hass.bus.async_listen(const.EVENT_SCENE_ACTIVATED, listener)
  
      # Test event before entity added to hass
      scene_id = 1
      scene_data = 3
      value = mock_zwave.MockValue(
          command_class=const.COMMAND_CLASS_CENTRAL_SCENE, index=scene_id, data=scene_data
      )
      hass.async_add_job(mock_receivers[0], node, value)
      await hass.async_block_till_done()
      assert len(events) == 0
  
      # Add entity to hass
      entity.hass = hass
      entity.entity_id = "zwave.mock_node"
  
      scene_id = 1
      scene_data = 3
      value = mock_zwave.MockValue(
          command_class=const.COMMAND_CLASS_CENTRAL_SCENE, index=scene_id, data=scene_data
      )
      hass.async_add_job(mock_receivers[0], node, value)
      await hass.async_block_till_done()
  
      assert len(events) == 1
      assert events[0].data[ATTR_ENTITY_ID] == "zwave.mock_node"
      assert events[0].data[const.ATTR_NODE_ID] == 11
      assert events[0].data[const.ATTR_SCENE_ID] == scene_id
      assert events[0].data[const.ATTR_SCENE_DATA] == scene_data
  
  
  async def test_application_version(hass, mock_openzwave):
      """Test application version."""
      mock_receivers = {}
  
      signal_mocks = [
          mock_zwave.MockNetwork.SIGNAL_VALUE_CHANGED,
          mock_zwave.MockNetwork.SIGNAL_VALUE_ADDED,
      ]
  
      def mock_connect(receiver, signal, *args, **kwargs):
          if signal in signal_mocks:
              mock_receivers[signal] = receiver
  
      node = mock_zwave.MockNode(node_id=11)
  
      with patch("pydispatch.dispatcher.connect", new=mock_connect):
          entity = node_entity.ZWaveNodeEntity(node, mock_openzwave)
  
      for signal_mock in signal_mocks:
          assert signal_mock in mock_receivers.keys()
  
      events = []
  
      def listener(event):
          events.append(event)
  
      # Make sure application version isn't set before
      assert (
          node_entity.ATTR_APPLICATION_VERSION not in entity.extra_state_attributes.keys()
      )
  
      # Add entity to hass
      entity.hass = hass
      entity.entity_id = "zwave.mock_node"
  
      # Fire off an added value
      value = mock_zwave.MockValue(
          command_class=const.COMMAND_CLASS_VERSION,
          label="Application Version",
          data="5.10",
      )
      hass.async_add_job(
          mock_receivers[mock_zwave.MockNetwork.SIGNAL_VALUE_ADDED], node, value
      )
      await hass.async_block_till_done()
  
      assert entity.extra_state_attributes[node_entity.ATTR_APPLICATION_VERSION] == "5.10"
  
      # Fire off a changed
      value = mock_zwave.MockValue(
          command_class=const.COMMAND_CLASS_VERSION,
          label="Application Version",
          data="4.14",
      )
      hass.async_add_job(
          mock_receivers[mock_zwave.MockNetwork.SIGNAL_VALUE_CHANGED], node, value
      )
      await hass.async_block_till_done()
  
      assert entity.extra_state_attributes[node_entity.ATTR_APPLICATION_VERSION] == "4.14"
  
  
  async def test_network_node_changed_from_value(hass, mock_openzwave):
      """Test for network_node_changed."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode()
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
      value = mock_zwave.MockValue(node=node)
      with patch.object(entity, "maybe_schedule_update") as mock:
          mock_zwave.value_changed(value)
          mock.assert_called_once_with()
  
  
  async def test_network_node_changed_from_node(hass, mock_openzwave):
      """Test for network_node_changed."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode()
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
      with patch.object(entity, "maybe_schedule_update") as mock:
          mock_zwave.node_changed(node)
          mock.assert_called_once_with()
  
  
  async def test_network_node_changed_from_another_node(hass, mock_openzwave):
      """Test for network_node_changed."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode()
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
      with patch.object(entity, "maybe_schedule_update") as mock:
          another_node = mock_zwave.MockNode(node_id=1024)
          mock_zwave.node_changed(another_node)
          assert not mock.called
  
  
  async def test_network_node_changed_from_notification(hass, mock_openzwave):
      """Test for network_node_changed."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode()
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
      with patch.object(entity, "maybe_schedule_update") as mock:
          mock_zwave.notification(node_id=node.node_id)
          mock.assert_called_once_with()
  
  
  async def test_network_node_changed_from_another_notification(hass, mock_openzwave):
      """Test for network_node_changed."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode()
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
      with patch.object(entity, "maybe_schedule_update") as mock:
          mock_zwave.notification(node_id=1024)
          assert not mock.called
  
  
  async def test_node_changed(hass, mock_openzwave):
      """Test node_changed function."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode(
          query_stage="Dynamic",
          is_awake=True,
          is_ready=False,
          is_failed=False,
          is_info_received=True,
          max_baud_rate=40000,
          is_zwave_plus=False,
          capabilities=[],
          neighbors=[],
          location=None,
      )
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
  
      assert {
          "node_id": node.node_id,
          "node_name": "Mock Node",
          "manufacturer_name": "Test Manufacturer",
          "product_name": "Test Product",
      } == entity.extra_state_attributes
  
      node.get_values.return_value = {1: mock_zwave.MockValue(data=1800)}
      zwave_network.manager.getNodeStatistics.return_value = {
          "receivedCnt": 4,
          "ccData": [
              {"receivedCnt": 0, "commandClassId": 134, "sentCnt": 0},
              {"receivedCnt": 1, "commandClassId": 133, "sentCnt": 1},
              {"receivedCnt": 1, "commandClassId": 115, "sentCnt": 1},
              {"receivedCnt": 0, "commandClassId": 114, "sentCnt": 0},
              {"receivedCnt": 0, "commandClassId": 112, "sentCnt": 0},
              {"receivedCnt": 1, "commandClassId": 32, "sentCnt": 1},
              {"receivedCnt": 0, "commandClassId": 0, "sentCnt": 0},
          ],
          "receivedUnsolicited": 0,
          "sentTS": "2017-03-27 15:38:15:620 ",
          "averageRequestRTT": 2462,
          "lastResponseRTT": 3679,
          "retries": 0,
          "sentFailed": 1,
          "sentCnt": 7,
          "quality": 0,
          "lastRequestRTT": 1591,
          "lastReceivedMessage": [
              0,
              4,
              0,
              15,
              3,
              32,
              3,
              0,
              221,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
              0,
          ],
          "receivedDups": 1,
          "averageResponseRTT": 2443,
          "receivedTS": "2017-03-27 15:38:19:298 ",
      }
      entity.node_changed()
      assert {
          "node_id": node.node_id,
          "node_name": "Mock Node",
          "manufacturer_name": "Test Manufacturer",
          "product_name": "Test Product",
          "query_stage": "Dynamic",
          "is_awake": True,
          "is_ready": False,
          "is_failed": False,
          "is_info_received": True,
          "max_baud_rate": 40000,
          "is_zwave_plus": False,
          "battery_level": 42,
          "wake_up_interval": 1800,
          "averageRequestRTT": 2462,
          "averageResponseRTT": 2443,
          "lastRequestRTT": 1591,
          "lastResponseRTT": 3679,
          "receivedCnt": 4,
          "receivedDups": 1,
          "receivedTS": "2017-03-27 15:38:19:298 ",
          "receivedUnsolicited": 0,
          "retries": 0,
          "sentCnt": 7,
          "sentFailed": 1,
          "sentTS": "2017-03-27 15:38:15:620 ",
      } == entity.extra_state_attributes
  
      node.can_wake_up_value = False
      entity.node_changed()
  
      assert "wake_up_interval" not in entity.extra_state_attributes
  
  
  async def test_name(hass, mock_openzwave):
      """Test name property."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode()
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
      assert entity.name == "Mock Node"
  
  
  async def test_state_before_update(hass, mock_openzwave):
      """Test state before update was called."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode()
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
      assert entity.state is None
  
  
  async def test_state_not_ready(hass, mock_openzwave):
      """Test state property."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode(
          query_stage="Dynamic",
          is_awake=True,
          is_ready=False,
          is_failed=False,
          is_info_received=True,
      )
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
  
      node.is_ready = False
      entity.node_changed()
      assert entity.state == "initializing"
  
      node.is_failed = True
      node.query_stage = "Complete"
      entity.node_changed()
      assert entity.state == "dead"
  
      node.is_failed = False
      node.is_awake = False
      entity.node_changed()
      assert entity.state == "sleeping"
  
  
  async def test_state_ready(hass, mock_openzwave):
      """Test state property."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode(
          query_stage="Dynamic",
          is_awake=True,
          is_ready=False,
          is_failed=False,
          is_info_received=True,
      )
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
  
      node.query_stage = "Complete"
      node.is_ready = True
      entity.node_changed()
      await hass.async_block_till_done()
      assert entity.state == "ready"
  
      node.is_failed = True
      entity.node_changed()
      assert entity.state == "dead"
  
      node.is_failed = False
      node.is_awake = False
      entity.node_changed()
      assert entity.state == "sleeping"
  
  
  async def test_not_polled(hass, mock_openzwave):
      """Test should_poll property."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode()
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
      assert not entity.should_poll
  
  
  async def test_unique_id(hass, mock_openzwave):
      """Test unique_id."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode()
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
      assert entity.unique_id == "node-567"
  
  
  async def test_unique_id_missing_data(hass, mock_openzwave):
      """Test unique_id."""
      zwave_network = MagicMock()
      node = mock_zwave.MockNode()
      node.manufacturer_name = None
      node.name = None
      node.is_ready = False
      entity = node_entity.ZWaveNodeEntity(node, zwave_network)
  
      assert entity.unique_id is None
  