def test_node_info(self):
node = cdp.Node(None, self._connection, data.app1_node)
self.assertEqual(node._id(), data.app1_node.info.node_id)
self.assertEqual(node.name(), data.app1_node.info.name)
self.assertEqual(node.type(), cdp.NodeType.APPLICATION)
self.assertEqual(node.is_leaf(), True)
self.assertEqual(node.is_read_only(), True)
self.assertEqual(node.path(), node.name())
sub_node = cdp.Node(node, self._connection, data.app2_node)
self.assertEqual(sub_node.path(), node.path() + '.' + sub_node.name())
def test_structure_subscription(self, mock_send_structure_request):
def on_change(added, removed):
nodes_added.extend(added)
nodes_removed.extend(removed)
old_children = []
new_children = []
nodes_added = []
nodes_removed = []
node = cdp.Node(None, self._connection, self._root_node)
node.subscribe_to_structure_changes(on_change)
mock_send_structure_request.return_value = Promise(
lambda resolve, reject: resolve(data.app2_node))
node.children().then(lambda n: old_children.extend(n))
#change the structure - remove and add a node
node_to_remove = self._root_node.node[0]
node_to_add = data.app3_node
self._root_node.node.remove(node_to_remove)
self._root_node.node.extend([node_to_add])
mock_send_structure_request.return_value = Promise(
lambda resolve, reject: resolve(self._root_node))
node._update()
#verify
mock_send_structure_request.return_value = Promise(
lambda resolve, reject: resolve(node_to_add))
node.children().then(lambda n: new_children.extend(n))
self.assertEquals(len(old_children), len(new_children))
found = False
for child in new_children:
self.assertFalse(child.name() == nodes_removed[0])
if child.name() == nodes_added[0]:
found = True
self.assertTrue(found)
def test_root_getter(self, mock_root_node):
nodes = []
mock_root_node.return_value = Promise(lambda resolve, reject: resolve(
cdp.Node(None, self._client._connection, fake_data.system_node)))
self._client.root_node().then(lambda node: nodes.append(node))
mock_root_node.assert_called_once_with()
self.assertEquals(nodes[0]._id(), fake_data.system_node.info.node_id)
def test_find_node_by_id(self):
system_node = copy(fake_data.system_node)
app_node = copy(fake_data.app1_node)
app_node.node.extend([fake_data.value1_node])
system_node.node.extend([app_node])
root_node = cdp.Node(None, self._node_tree._connection, system_node)
self._node_tree._root_node = root_node
node = self._node_tree.find_by_id(fake_data.value1_node.info.node_id)
self.assertEquals(node._id(), fake_data.value1_node.info.node_id)
def test_child_getter_when_child_is_leaf(self,
mock_send_structure_request):
children = []
node = cdp.Node(None, self._connection, self._root_node)
node.child(data.app1_node.info.name).then(lambda n: children.append(n))
mock_send_structure_request.assert_not_called()
self.assertEqual(children[0]._id(), data.app1_node.info.node_id)
self.assertEqual(children[0].name(), data.app1_node.info.name)
self.assertEqual(children[0].type(), cdp.NodeType.APPLICATION)
def test_node_updated_when_node_value_received(self, mock_update_value,
mock_find_by_id):
self._connection._is_connected = True
mock_find_by_id.return_value = cdp.Node(None, self._connection,
fake_data.app1_node)
response = fake_data.create_value_response()
self._connection._handle_container_message(
None, response.SerializeToString())
mock_update_value.assert_called_once_with(response.getter_response[0])
def test_fetching_root_node_when_root_node_existing(
self, mock_send_structure_request):
nodes = []
root_node = cdp.Node(None, self._node_tree._connection,
fake_data.app1_node)
self._node_tree._root_node = root_node
self._node_tree.root_node().then(lambda n: nodes.append(n))
mock_send_structure_request.assert_not_called()
self.assertEquals(len(nodes), 1)
self.assertEquals(nodes[0]._id(), root_node._id())
def test_children_iterator(self, mock_send_structure_request):
children = []
node = cdp.Node(None, self._connection, self._root_node)
mock_send_structure_request.return_value = Promise(
lambda resolve, reject: resolve(data.app2_node))
node.for_each_child(lambda n: children.append(n))
mock_send_structure_request.assert_called_once_with(
data.app2_node.info.node_id,
node.path() + '.' + data.app2_node.info.name)
self.assertEquals(len(children), len(self._root_node.node))
def test_node_structure_requested_when_node_structure_change_received(
self, mock_send, mock_find_by_id):
self._connection._is_connected = True
mock_find_by_id.return_value = cdp.Node(None, self._connection,
fake_data.app1_node)
response = fake_data.create_structure_change_response(
fake_data.app1_node.info.node_id)
request = fake_data.create_structure_change_request(
response.structure_change_response[0])
self._connection._handle_container_message(
None, response.SerializeToString())
mock_send.assert_any_call(request.SerializeToString())
def test_find_node(self, mock_child, mock_root_node):
nodes = []
comp_node = copy(fake_data.comp1_node)
app_node = copy(fake_data.app1_node)
app_node.node.extend([comp_node])
comp_node.node.extend([fake_data.value1_node])
mock_root_node.return_value = Promise(lambda resolve, reject: resolve(
cdp.Node(None, self._client._connection, app_node)))
mock_child.side_effect = [
Promise(lambda resolve, reject: resolve(
cdp.Node(None, self._client._connection, comp_node))),
Promise(lambda resolve, reject: resolve(
cdp.Node(None, self._client._connection, fake_data.value1_node)
))
]
path = '.'.join([
app_node.info.name, comp_node.info.name,
fake_data.value1_node.info.name
])
self._client.find_node(path).then(lambda node: nodes.append(node))
self.assertEquals(nodes[0]._id(), fake_data.value1_node.info.node_id)
def test_child_getter_when_child_is_not_leaf(self,
mock_send_structure_request):
children = []
node = cdp.Node(None, self._connection, self._root_node)
mock_send_structure_request.return_value = Promise(
lambda resolve, reject: resolve(data.app2_node))
node.child(data.app2_node.info.name).then(lambda n: children.append(n))
mock_send_structure_request.assert_called_once_with(
data.app2_node.info.node_id,
node.path() + '.' + data.app2_node.info.name)
self.assertEqual(children[0]._id(), data.app2_node.info.node_id)
self.assertEqual(children[0].name(), data.app2_node.info.name)
self.assertEqual(children[0].type(), cdp.NodeType.APPLICATION)
def test_value_unsubscription(self, mock_send_value_unrequest,
mock_send_value_request):
def on_change(value):
values.append(value)
values = []
node = cdp.Node(None, self._connection, data.value1_node)
node.subscribe_to_value_changes(on_change)
mock_send_value_request.assert_called_once_with(node._id())
node.unsubscribe_from_value_changes(on_change)
mock_send_value_unrequest.assert_called_once_with(node._id())
node._update_value(data.value1)
self.assertEquals(len(values), 0)
def test_structure_unsubscription(self):
def on_change(added, removed):
nodes_added.extend(added)
nodes_removed.extend(removed)
nodes_added = []
nodes_removed = []
node = cdp.Node(None, self._connection, self._root_node)
node.subscribe_to_structure_changes(on_change)
node.unsubscribe_from_structure_changes(on_change)
# change the structure - remove a node
node_to_remove = self._root_node.node[0]
self._root_node.node.remove(node_to_remove)
node._update_structure(self._root_node)
# verify
self.assertEquals(nodes_added, [])
self.assertEquals(nodes_removed, [])
def test_value_subscription(self, mock_send_value_request):
def on_change(value, timestamp):
actual_values.append(value)
timestamps.append(timestamp)
actual_values = []
timestamps = []
node = cdp.Node(None, self._connection, data.value1_node)
node.subscribe_to_value_changes(on_change)
mock_send_value_request.assert_called_once_with(node._id())
expected_values = [data.value1, data.value2]
for value in expected_values:
node._update_value(value)
self.assertEquals(len(actual_values), len(expected_values))
self.assertEquals(len(timestamps), len(expected_values))
for index, value in enumerate(expected_values):
self.assertEquals(actual_values[index], value.d_value)
self.assertEquals(timestamps[index], value.timestamp)
def test_value_setter(self, mock_send_value):
node = cdp.Node(None, self._connection, data.value1_node)
node.set_value(data.value1.d_value, data.value1.timestamp)
mock_send_value.assert_called_with(data.value1)
def test_invalid_child_getter(self, mock_send_structure_request):
errors = []
node = cdp.Node(None, self._connection, self._root_node)
node.child("invalid").catch(lambda e: errors.append(e))
self.assertEqual(len(errors), 1)
mock_send_structure_request.assert_not_called()
def test_value(self):
node = cdp.Node(None, self._connection, data.value1_node)
node._update_value(data.value1)
self.assertEquals(node.last_value(), data.value1.d_value)