cdp-client 2.1.1__tar.gz → 2.2.0__tar.gz

cdp_client-2.2.0/PKG-INFO

@@ -0,0 +1,472 @@
+Metadata-Version: 2.1
+Name: cdp-client
+Version: 2.2.0
+Summary: Provides an API that allows to interact with CDP applications
+Home-page: https://github.com/CDPTechnologies/PythonCDPClient
+Author: CDP Technologies AS
+Author-email: info@cdptech.com
+License: MIT
+Keywords: cdp cdpstudio studio client cdp-client cdp_client
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+License-File: LICENSE.txt
+Requires-Dist: promise
+Requires-Dist: websocket-client
+Requires-Dist: protobuf
+Requires-Dist: mock
+
+CDP-Client
+==========
+
+A simple python interface for the CDP Studio development platform that allows Python scripts to interact with CDP Applications - retrieve CDP Application structures and read-write object values. For more information about CDP Studio see https://cdpstudio.com/
+
+The API makes heavy use of promise library for asynchronous operations. For more information see https://pypi.python.org/pypi/promise
+
+Installation
+------------
+
+::
+
+    $ pip install cdp-client
+
+Usage
+-----
+
+The example below shows how you subscribe to CDP signal value changes.
+
+.. code:: python
+
+    from cdp_client import cdp
+
+    def on_value_changed(value, timestamp):
+        print(value)
+	
+    def subscribe_to_value_changes(node):
+        node.subscribe_to_value_changes(on_value_changed)
+	
+    client = cdp.Client(host='127.0.0.1')
+    client.find_node('AppName.ComponentName.SignalName').then(subscribe_to_value_changes)
+    client.run_event_loop()
+
+API
+---
+
+Before all examples, you need:
+
+.. code:: python
+
+    from cdp_client import cdp
+
+Global API
+~~~~~~~~~~
+
+Client(host, port, auto_reconnect, notification_listener, encryption_parameters)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+- Arguments
+
+    host - String for hosts ip address
+
+    port - Optional port number to connect to. If not specified default port 7689 is used.
+
+    auto_reconnect - Optional argument to enable/disable automatic reconnect when connection is lost. Defaults to True if not specified.
+
+    notification_listener - NotificationListener object whose methods are called on different connection events (e.g. when server requires credentials)
+
+    encryption_parameters - Optional argument to set encryption and its parameters, TLS certificates verification etc. Parameter is compatible with python websocket client 'sslopt' parameter. For more information see https://pypi.org/project/websocket_client
+
+- Returns
+
+    The connected client object.
+
+- Usage example
+
+    .. code:: python
+
+        client = cdp.Client(host='127.0.0.1')
+
+- Usage example with password authentication
+
+    .. code:: python
+
+        class MyListener(cdp.NotificationListener):
+            def credentials_requested(self, request):
+                if request.user_auth_result().code() == cdp.AuthResultCode.CREDENTIALS_REQUIRED:
+                    # Do something to gather username and password variables (either sync or async way) and then call:
+                    request.accept({'Username': 'test', 'Password': '12345678'});
+
+        client = cdp.Client(host='127.0.0.1', notification_listener=MyListener())
+
+- Usage example with password authentication and encryption in use, without server certificate verification
+
+    .. code:: python
+
+        import ssl
+
+        class MyListener(cdp.NotificationListener):
+            def credentials_requested(self, request):
+                if request.user_auth_result().code() == cdp.AuthResultCode.CREDENTIALS_REQUIRED:
+                    # Do something to gather username and password variables (either sync or async way) and then call:
+                    request.accept({'Username': 'test', 'Password': '12345678'});
+
+        client = cdp.Client(host='127.0.0.1', notification_listener=MyListener(),
+                            encryption_parameters={'use_encryption': True, 'cert_reqs': ssl.CERT_NONE})
+
+
+- Usage example with password authentication and encryption in use, with server certificate verification
+
+    .. code:: python
+
+        import ssl
+
+        class MyListener(cdp.NotificationListener):
+            def credentials_requested(self, request):
+                if request.user_auth_result().code() == cdp.AuthResultCode.CREDENTIALS_REQUIRED:
+                    # Do something to gather username and password variables (either sync or async way) and then call:
+                    request.accept({'Username': 'test', 'Password': '12345678'});
+
+        client = cdp.Client(host='127.0.0.1', notification_listener=MyListener(),
+                            encryption_parameters={'use_encryption': True,
+                                                   'cert_reqs': ssl.CERT_REQUIRED,
+                                                   'ca_certs': 'StudioAPI.crt',
+                                                   'check_hostname': False},
+
+Instance Methods / Client
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+client.root_node()
+^^^^^^^^^^^^^^^^^^
+
+Gets the application Node object of the connected application.
+
+- Returns
+
+    Promise containing root Node object when fulfilled.
+
+- Usage
+
+    .. code:: python
+
+        client.root_node().then(on_success).catch(on_error)
+
+client.find_node(path)
+^^^^^^^^^^^^^^^^^^^^^^
+
+Searches for the node specified by full dot separated path. **The requested node must reside in the application client was connected to. Root node is not considered part of the path.**
+
+- Arguments
+
+    path - Dot separated string to target node
+
+- Returns
+
+    Promise containing requested Node object when fulfilled. Otherwise NotFoundError when rejected.
+
+- Usage
+
+    .. code:: python
+
+        client.find_node('AppName.ComponentName.SignalName').then(on_success).catch(on_error)
+
+client.run_event_loop()
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Runs the event loop that serves network communication layer for incoming/outgoing data. **This is a blocking call that must be run for any communication to happen.** The method can be cancelled by calling disconnect.
+
+client.disconnect()
+^^^^^^^^^^^^^^^^^^^
+
+Stops the event loop and closes the connection to connected application. This method also releases the blocking run_event_loop call.
+
+Instance Methods / Node
+~~~~~~~~~~~~~~~~~~~~~~~
+
+node.name()
+^^^^^^^^^^^
+
+- Returns
+
+    The name of the Node object. Names in a parent node are all unique.
+
+node.path()
+^^^^^^^^^^^
+
+- Returns
+
+    A dot separated path of the Node object starting with application name.
+
+node.parent()
+^^^^^^^^^^^^^
+
+- Returns
+
+    The parent Node object.
+
+node.type()
+^^^^^^^^^^^
+
+- Returns
+
+    The type of the Node object returned as one of the cdp.NodeType values.
+
+node.class_name()
+^^^^^^^^^^^^^^^^^
+
+- Returns
+
+    CDP class name as a string.
+
+node.last_value()
+^^^^^^^^^^^^^^^^^
+
+- Returns
+
+    The last known value received by the Node object.
+
+node.set_value(value, timestamp)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Sets a new value for the Node object. Timestamp will be ignored in current implementation.
+
+- Arguments
+
+    value - New value
+
+    timestamp - UTC time in nanoseconds since Epoch
+
+node.is_read_only()
+^^^^^^^^^^^^^^^^^^^
+
+- Returns
+
+    False if nodes value cannot be set, otherwise True.
+
+node.is_leaf()
+^^^^^^^^^^^^^^
+
+- Returns
+
+    True if node doesn't have any children, otherwise False.
+
+node.child(name)
+^^^^^^^^^^^^^^^^
+
+- Arguments
+
+    name - Child nodes name to search for
+
+- Returns
+
+    Promise containing requested Node object when fulfilled.
+
+- Usage
+
+    .. code:: python
+
+        node.child('NodeName').then(on_success).catch(on_error)
+
+node.children()
+^^^^^^^^^^^^^^^
+
+- Returns
+
+    Promise containing all children of this Node object when fulfilled.
+
+- Usage
+
+    .. code:: python
+
+        node.children().then(on_success).catch(on_error)
+
+node.for_each_child(callback)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Loops through all children and calls callback function for each of them
+
+- Arguments
+
+    callback - Function(node)
+
+- Returns
+
+    Promise containing all children of this Node object when fulfilled.
+
+- Usage
+
+    .. code:: python
+
+        def on_callback(child):
+            do something
+
+        node.for_each_child(on_callback)
+
+node.subscribe_to_structure_changes(callback)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Starts listening structure changes and passes the changes to provided callback funtion
+
+- Arguments
+
+    callback - Function(added_nodes, removed_nodes) where added_nodes and removed_nodes is a list
+
+- Usage
+
+    .. code:: python
+
+        def on_change(added_nodes, removed_nodes):
+            do something
+
+        node.subscribe_to_structure_changes(on_change)
+
+node.subscribe_to_value_changes(callback, fs=5, sample_rate=0)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Starts listening value changes and passes the changes to provided callback function
+
+- Arguments
+
+    callback - Function(value, timestamp)
+
+    fs - Maximum frequency that value updates are expected (controls how many changes are sent in a single packet). Defaults to 5 hz.
+    
+    sample_rate - Maximum amount of value updates sent per second (controls the amount of data transferred). Zero means all samples must be provided. Defaults to 0.
+
+- Usage
+
+    .. code:: python
+
+        def on_change(value, timestamp):
+            do something
+
+        node.subscribe_to_value_changes(on_change)
+
+
+node.unsubscribe_from_structure_changes(callback)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Stops listening previously subscribed structure changes
+
+- Arguments
+
+    callback - Function(added_nodes, removed_nodes) where added_nodes and removed_nodes is a list
+
+- Usage
+
+    .. code:: python
+
+        def on_change(added_nodes, removed_nodes):
+            do something
+
+        node.unsubscribe_from_structure_changes(on_change)
+
+node.unsubscribe_from_value_changes(callback)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Stops listening previously subscribed value changes
+
+- Arguments
+
+    callback - Function(value, timestamp)
+
+- Usage
+
+    .. code:: python
+
+        def on_change(value, timestamp):
+            do something
+	
+        node.unsubscribe_from_value_changes(on_change)
+
+Notification Listener
+~~~~~~~~~~~~~~~~~~~~~
+
+To handle different connection events (like prompt user to accept a system use notification message or request user to enter credentials for authentication or idle lockout re-authentication) a notification_listener parameter must be provided to the Client.
+The notification_listener parameter must be a object of type class cdp.NotificationListener.
+
+class NotificationListener
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    .. code:: python
+
+        class NotificationListener:
+            def application_acceptance_requested(self, request=AuthRequest()):
+                request.accept()
+
+            def credentials_requested(self, request=AuthRequest()):
+                raise NotImplementedError("NotificationListener credentials_requested() not implemented!")
+
+NotificationListener.application_acceptance_requested(self, request=AuthRequest())
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Called by Client when new application TLS or plain TCP connection is established.
+Can be used to prompt the user a System Use Notification (a message that can be configured in CDP Studio Security settings).
+
+- Arguments
+
+    request - a object that has method accept() that should be called to accept the connection and a reject() to reject the connection.
+
+- Usage
+
+    .. code:: python
+
+        class MyListener(cdp.NotificationListener):
+            def application_acceptance_requested(self, request):
+                if request.system_use_notification():
+                    # Pop up a System Use Notification message and ask for confirmation to continue,
+                    # then based on the user answer call either request.accept() or request.reject()
+                else:
+                    request.accept()
+
+        client = cdp.Client(host='127.0.0.1', port=7689, notification_listener=MyListener())
+
+NotificationListener.credentials_requested(self, request=AuthRequest())
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Called by Client when server is requesting credentials (authentication or idle lockout re-authentication).
+
+- Arguments
+
+    request - a object that has method accept(data=dict()) that should be called (with credentials) for authentication try, and also a method reject() to reject the connection.
+
+- Usage
+
+    .. code:: python
+
+        class MyListener(cdp.NotificationListener):
+            def credentials_requested(self, request):
+                if request.user_auth_result().code() == cdp.AuthResultCode.CREDENTIALS_REQUIRED:
+                    # Do something to gather username and password variables (either sync or async way) and then call:
+                    request.accept({'Username': 'test', 'Password': '12345678'});
+                if request.user_auth_result().code() == cdp.AuthResultCode.REAUTHENTICATION_REQUIRED:
+                    # Pop user a message that idle lockout was happened and server requires new authentication to continue:
+                    request.accept({'Username': 'test', 'Password': '12345678'});
+
+        client = cdp.Client(host='127.0.0.1', port=7689, notification_listener=MyListener())
+
+Tests
+-----
+
+To run the test suite execute the following command in package root folder:
+
+.. code:: sh
+
+    $ python setup.py test
+
+License
+-------
+
+`MIT
+License <https://github.com/CDPTechnologies/PythonCDPClient/blob/master/LICENSE.txt>`__

{cdp-client-2.1.1 → cdp_client-2.2.0}/cdp_client/cdp.py

@@ -372,25 +372,25 @@ class Node:
         if type == proto.eDOUBLE:
             variant.d_value = value
         elif type == proto.eUINT64:
-            variant.f_value = value
+            variant.f_value = int(value)
         elif type == proto.eINT64:
-            variant.ui64_value = value
+            variant.ui64_value = int(value)
         elif type == proto.eFLOAT:
             variant.i64_value = value
         elif type == proto.eUINT:
-            variant.ui_value = value
+            variant.ui_value = int(value)
         elif type == proto.eINT:
-            variant.i_value = value
+            variant.i_value = int(value)
         elif type == proto.eUSHORT:
-            variant.us_value = value
+            variant.us_value = int(value)
         elif type == proto.eSHORT:
-            variant.s_value = value
+            variant.s_value = int(value)
         elif type == proto.eUCHAR:
-            variant.uc_value = value
+            variant.uc_value = int(value)
         elif type == proto.eCHAR:
-            variant.c_value = value
+            variant.c_value = int(value)
         elif type == proto.eBOOL:
-            variant.b_value = value
+            variant.b_value = bool(value)
         elif type == proto.eSTRING:
             variant.str_value = str(value)
         return variant
@@ -701,7 +701,7 @@ class Connection:
         value = proto.ValueRequest()
         value.node_id = node_id
         value.fs = fs
-        if sample_rate is not 0:
+        if sample_rate != 0:
             value.sample_rate = sample_rate
         if stop:
             value.stop = stop

{cdp-client-2.1.1 → cdp_client-2.2.0}/cdp_client/tests/fake_data.py

@@ -118,7 +118,6 @@ def create_value_unrequest(node_id):
     value = proto.ValueRequest()
     value.node_id = node_id
     value.fs = 1
-    value.sample_rate = 0
     value.stop = True
     request.getter_request.extend([value])
     return request

{cdp-client-2.1.1 → cdp_client-2.2.0}/cdp_client/tests/test_client.py

@@ -23,7 +23,7 @@ class ClientTester(unittest.TestCase):
         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)
+        self.assertEqual(nodes[0]._id(), fake_data.system_node.info.node_id)
 
     @mock.patch.object(cdp.NodeTree, 'root_node')
     @mock.patch.object(cdp.Node, 'child')
@@ -38,7 +38,7 @@ class ClientTester(unittest.TestCase):
                                   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)
+        self.assertEqual(nodes[0]._id(), fake_data.value1_node.info.node_id)
 
     @mock.patch.object(cdp.Connection, 'run_event_loop')
     def test_run_event_loop(self, mock_run_event_loop):

{cdp-client-2.1.1 → cdp_client-2.2.0}/cdp_client/tests/test_node.py

@@ -35,7 +35,7 @@ class NodeTester(unittest.TestCase):
     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)
+        self.assertEqual(node.last_value(), data.value1.d_value)
 
     @mock.patch.object(cdp.Connection, 'send_value')
     def test_value_setter(self, mock_send_value):
@@ -79,7 +79,7 @@ class NodeTester(unittest.TestCase):
         mock_send_structure_request.return_value = Promise(lambda resolve, reject: resolve(data.app2_node))
         node.children().then(lambda n: children.extend(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))
+        self.assertEqual(len(children), len(self._root_node.node))
 
     @mock.patch.object(cdp.Connection, 'send_structure_request')
     def test_children_iterator(self, mock_send_structure_request):
@@ -88,7 +88,7 @@ class NodeTester(unittest.TestCase):
         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))
+        self.assertEqual(len(children), len(self._root_node.node))
 
     @mock.patch.object(cdp.Connection, 'send_structure_request')
     def test_structure_subscription(self, mock_send_structure_request):
@@ -105,7 +105,7 @@ class NodeTester(unittest.TestCase):
         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
+        # 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)
@@ -113,14 +113,14 @@ class NodeTester(unittest.TestCase):
         mock_send_structure_request.return_value = Promise(lambda resolve, reject: resolve(self._root_node))
         node._update()
 
-        #verify
+        # 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))
+        self.assertEqual(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]:
+            self.assertFalse(child.name() == nodes_removed[0].name())
+            if child.name() == nodes_added[0].name():
                 found = True
         self.assertTrue(found)
 
@@ -141,8 +141,8 @@ class NodeTester(unittest.TestCase):
         node._update_structure(self._root_node)
 
         # verify
-        self.assertEquals(nodes_added, [])
-        self.assertEquals(nodes_removed, [])
+        self.assertEqual(nodes_added, [])
+        self.assertEqual(nodes_removed, [])
 
     @mock.patch.object(cdp.Connection, 'send_value_request')
     def test_value_subscription(self, mock_send_value_request):
@@ -159,11 +159,11 @@ class NodeTester(unittest.TestCase):
         for value in expected_values:
             node._update_value(value)
 
-        self.assertEquals(len(actual_values), len(expected_values))
-        self.assertEquals(len(timestamps), len(expected_values))
+        self.assertEqual(len(actual_values), len(expected_values))
+        self.assertEqual(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)
+            self.assertEqual(actual_values[index], value.d_value)
+            self.assertEqual(timestamps[index], value.timestamp)
     
     @mock.patch.object(cdp.Connection, 'send_value_request')
     def test_value_subscription_max_fs(self, mock_send_value_request):
@@ -214,7 +214,7 @@ class NodeTester(unittest.TestCase):
         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)
+        self.assertEqual(len(values), 0)
 
     @mock.patch.object(cdp.Connection, 'send_value_request')
     def test_value_unsubscription_max_fs(self, mock_send_value_request):

{cdp-client-2.1.1 → cdp_client-2.2.0}/cdp_client/tests/test_nodetree.py

@@ -27,8 +27,8 @@ class NodeTreeTester(unittest.TestCase):
         mock_send_structure_request.side_effect = [Promise(lambda resolve, reject: resolve(system_node)),
                                                    Promise(lambda resolve, reject: resolve(app_node))]
         self._node_tree.root_node().then(lambda n: nodes.append(n))
-        self.assertEquals(len(nodes), 1)
-        self.assertEquals(nodes[0]._id(), app_node.info.node_id)
+        self.assertEqual(len(nodes), 1)
+        self.assertEqual(nodes[0]._id(), app_node.info.node_id)
 
     @mock.patch.object(cdp.Connection, 'send_structure_request')
     def test_fetching_root_node_when_root_node_existing(self, mock_send_structure_request):
@@ -37,8 +37,8 @@ class NodeTreeTester(unittest.TestCase):
         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())
+        self.assertEqual(len(nodes), 1)
+        self.assertEqual(nodes[0]._id(), root_node._id())
 
     def test_find_node_by_id(self):
         system_node = copy(fake_data.system_node)
@@ -48,7 +48,7 @@ class NodeTreeTester(unittest.TestCase):
         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)
+        self.assertEqual(node._id(), fake_data.value1_node.info.node_id)
 
     def test_find_node_by_path(self):
         system_node = copy(fake_data.system_node)
@@ -59,4 +59,4 @@ class NodeTreeTester(unittest.TestCase):
         self._node_tree._root_node = root_node
         path = '.'.join([system_node.info.name, app_node.info.name, fake_data.value1_node.info.name])
         node = self._node_tree.find_by_path(path)
-        self.assertEquals(node._id(), fake_data.value1_node.info.node_id)
+        self.assertEqual(node._id(), fake_data.value1_node.info.node_id)