core/tests/mock/zwave.py

"""Mock helpers for Z-Wave component."""
from unittest.mock import MagicMock

from pydispatch import dispatcher


def value_changed(value):
    """Fire a value changed."""
    dispatcher.send(
        MockNetwork.SIGNAL_VALUE_CHANGED,
        value=value,
        node=value.node,
        network=value.node._network
    )


def node_changed(node):
    """Fire a node changed."""
    dispatcher.send(
        MockNetwork.SIGNAL_NODE,
        node=node,
        network=node._network
    )


def notification(node_id, network=None):
    """Fire a notification."""
    dispatcher.send(
        MockNetwork.SIGNAL_NOTIFICATION,
        args={'nodeId': node_id},
        network=network
    )


class MockOption(MagicMock):
    """Mock Z-Wave options."""

    def __init__(self, device=None, config_path=None, user_path=None,
                 cmd_line=None):
        """Initialize a Z-Wave mock options."""
        super().__init__()
        self.device = device
        self.config_path = config_path
        self.user_path = user_path
        self.cmd_line = cmd_line

    def _get_child_mock(self, **kw):
        """Create child mocks with right MagicMock class."""
        return MagicMock(**kw)


class MockNetwork(MagicMock):
    """Mock Z-Wave network."""

    SIGNAL_NETWORK_FAILED = 'mock_NetworkFailed'
    SIGNAL_NETWORK_STARTED = 'mock_NetworkStarted'
    SIGNAL_NETWORK_READY = 'mock_NetworkReady'
    SIGNAL_NETWORK_STOPPED = 'mock_NetworkStopped'
    SIGNAL_NETWORK_RESETTED = 'mock_DriverResetted'
    SIGNAL_NETWORK_AWAKED = 'mock_DriverAwaked'
    SIGNAL_DRIVER_FAILED = 'mock_DriverFailed'
    SIGNAL_DRIVER_READY = 'mock_DriverReady'
    SIGNAL_DRIVER_RESET = 'mock_DriverReset'
    SIGNAL_DRIVER_REMOVED = 'mock_DriverRemoved'
    SIGNAL_GROUP = 'mock_Group'
    SIGNAL_NODE = 'mock_Node'
    SIGNAL_NODE_ADDED = 'mock_NodeAdded'
    SIGNAL_NODE_EVENT = 'mock_NodeEvent'
    SIGNAL_NODE_NAMING = 'mock_NodeNaming'
    SIGNAL_NODE_NEW = 'mock_NodeNew'
    SIGNAL_NODE_PROTOCOL_INFO = 'mock_NodeProtocolInfo'
    SIGNAL_NODE_READY = 'mock_NodeReady'
    SIGNAL_NODE_REMOVED = 'mock_NodeRemoved'
    SIGNAL_SCENE_EVENT = 'mock_SceneEvent'
    SIGNAL_VALUE = 'mock_Value'
    SIGNAL_VALUE_ADDED = 'mock_ValueAdded'
    SIGNAL_VALUE_CHANGED = 'mock_ValueChanged'
    SIGNAL_VALUE_REFRESHED = 'mock_ValueRefreshed'
    SIGNAL_VALUE_REMOVED = 'mock_ValueRemoved'
    SIGNAL_POLLING_ENABLED = 'mock_PollingEnabled'
    SIGNAL_POLLING_DISABLED = 'mock_PollingDisabled'
    SIGNAL_CREATE_BUTTON = 'mock_CreateButton'
    SIGNAL_DELETE_BUTTON = 'mock_DeleteButton'
    SIGNAL_BUTTON_ON = 'mock_ButtonOn'
    SIGNAL_BUTTON_OFF = 'mock_ButtonOff'
    SIGNAL_ESSENTIAL_NODE_QUERIES_COMPLETE = \
        'mock_EssentialNodeQueriesComplete'
    SIGNAL_NODE_QUERIES_COMPLETE = 'mock_NodeQueriesComplete'
    SIGNAL_AWAKE_NODES_QUERIED = 'mock_AwakeNodesQueried'
    SIGNAL_ALL_NODES_QUERIED = 'mock_AllNodesQueried'
    SIGNAL_ALL_NODES_QUERIED_SOME_DEAD = \
        'mock_AllNodesQueriedSomeDead'
    SIGNAL_MSG_COMPLETE = 'mock_MsgComplete'
    SIGNAL_NOTIFICATION = 'mock_Notification'
    SIGNAL_CONTROLLER_COMMAND = 'mock_ControllerCommand'
    SIGNAL_CONTROLLER_WAITING = 'mock_ControllerWaiting'

    STATE_STOPPED = 0
    STATE_FAILED = 1
    STATE_RESETTED = 3
    STATE_STARTED = 5
    STATE_AWAKED = 7
    STATE_READY = 10

    def __init__(self, options=None, *args, **kwargs):
        """Initialize a Z-Wave mock network."""
        super().__init__()
        self.options = options
        self.state = MockNetwork.STATE_STOPPED


class MockNode(MagicMock):
    """Mock Z-Wave node."""

    def __init__(self, *,
                 node_id='567',
                 name='Mock Node',
                 manufacturer_id='ABCD',
                 product_id='123',
                 product_type='678',
                 command_classes=None,
                 can_wake_up_value=True,
                 manufacturer_name='Test Manufacturer',
                 product_name='Test Product',
                 network=None,
                 **kwargs):
        """Initialize a Z-Wave mock node."""
        super().__init__()
        self.node_id = node_id
        self.name = name
        self.manufacturer_id = manufacturer_id
        self.product_id = product_id
        self.product_type = product_type
        self.manufacturer_name = manufacturer_name
        self.product_name = product_name
        self.can_wake_up_value = can_wake_up_value
        self._command_classes = command_classes or []
        if network is not None:
            self._network = network
        for attr_name in kwargs:
            setattr(self, attr_name, kwargs[attr_name])

    def has_command_class(self, command_class):
        """Test if mock has a command class."""
        return command_class in self._command_classes

    def get_battery_level(self):
        """Return mock battery level."""
        return 42

    def can_wake_up(self):
        """Return whether the node can wake up."""
        return self.can_wake_up_value

    def _get_child_mock(self, **kw):
        """Create child mocks with right MagicMock class."""
        return MagicMock(**kw)


class MockValue(MagicMock):
    """Mock Z-Wave value."""

    _mock_value_id = 1234

    def __init__(self, *,
                 label='Mock Value',
                 node=None,
                 instance=0,
                 index=0,
                 value_id=None,
                 **kwargs):
        """Initialize a Z-Wave mock value."""
        super().__init__()
        self.label = label
        self.node = node
        self.instance = instance
        self.index = index
        if value_id is None:
            MockValue._mock_value_id += 1
            value_id = MockValue._mock_value_id
        self.value_id = value_id
        self.object_id = value_id
        for attr_name in kwargs:
            setattr(self, attr_name, kwargs[attr_name])

    def _get_child_mock(self, **kw):
        """Create child mocks with right MagicMock class."""
        return MagicMock(**kw)

    def refresh(self):
        """Mock refresh of node value."""
        value_changed(self)


class MockEntityValues():
    """Mock Z-Wave entity values."""

    def __init__(self, **kwargs):
        """Initialize the mock zwave values."""
        self.primary = None
        self.wakeup = None
        self.battery = None
        self.power = None
        for name in kwargs:
            setattr(self, name, kwargs[name])

    def __iter__(self):
        """Allow iteration over all values."""
        return iter(self.__dict__.values())