def test_run_with_calls(self): """check connect/call rpc/close connection calls sequence""" fake_ctx, node, instance = self._get_mock_context_for_run() hello_message = ( """<?xml version=\'1.0\' encoding=\'UTF-8\'?>\n<rfc6020""" + """:hello xmlns:a="b" xmlns:d="c" xmlns:rfc6020="urn:ie""" + """tf:params:xml:ns:netconf:base:1.0">\n <rfc6020:capa""" + """bilities>\n <rfc6020:capability>urn:ietf:params:n""" + """etconf:base:1.0</rfc6020:capability>\n <rfc6020:c""" + """apability>urn:ietf:params:netconf:base:1.1</rfc6020:""" + """capability>\n </rfc6020:capabilities>\n</rfc6020:he""" + """llo>\n""") # no calls current_ctx.set(fake_ctx) rpc.run(ctx=fake_ctx) # with empty list of calls rpc.run(ctx=fake_ctx, calls=[]) # with list of calls, but without auth with self.assertRaises(cfy_exc.NonRecoverableError): rpc.run(ctx=fake_ctx, calls=[{'action': 'get'}]) node.properties = { 'netconf_auth': { "user": "******", "password": "******", "ip": "super_secret", # save logs "store_logs": True }, 'metadata': { 'xmlns': { 'd': 'c' } }, "base_xmlns": { "a": "b" } } # check usage of ip list nc_conn = mock.Mock() nc_conn.connect = mock.MagicMock( side_effect=cfy_exc.NonRecoverableError("Check Exception")) with mock.patch( 'cloudify_terminal_sdk.netconf_connection.NetConfConnection', mock.MagicMock(return_value=nc_conn)): with self.assertRaises(cfy_exc.NonRecoverableError): # we have empty action rpc.run(ctx=fake_ctx, calls=[{'unknow': 'get'}]) nc_conn.connect.assert_called_with('super_secret', 'me', hello_message, 'secret', None, 830) fake_ctx.get_resource.assert_not_called() # connect without exception nc_conn = self._get_fake_nc_connect() with mock.patch( 'cloudify_terminal_sdk.netconf_connection.NetConfConnection', mock.MagicMock(return_value=nc_conn)): # we have empty action rpc.run(ctx=fake_ctx, calls=[{'unknow': 'get'}]) nc_conn.connect.assert_called_with('super_secret', 'me', hello_message, 'secret', None, 830) fake_ctx.get_resource.assert_not_called() # have some payload rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "a": "b" } }]) # have lock/unlock operations rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "a": "b" } }], lock=["rfc6020@candidate"]) # have some copy operations rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "a": "b" } }], back_database="a", front_database="b") # check save to runtime properties self.assertEqual(instance.runtime_properties, {}) rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "c": "d" }, 'save_to': 'd' }]) # looks as we save something self.assertTrue("d" in instance.runtime_properties) self.assertTrue("d_ns" in instance.runtime_properties) self.assertTrue("rfc6020@ok" in instance.runtime_properties["d"]) self.assertEqual(nc_conn.current_level, netconf_connection.NETCONF_1_0_CAPABILITY) # version 1.1 and ip from cloudify.relationships.contained_in nc_conn.connect = mock.MagicMock( return_value=self.CORRECT_HELLO_1_1_REPLY) # drop ip from auth dict, lets use 'container' ip node.properties['netconf_auth']["ip"] = None instance.host_ip = "ip_from_runtime" with mock.patch( 'cloudify_terminal_sdk.netconf_connection.NetConfConnection', mock.MagicMock(return_value=nc_conn)): rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', }]) # we use correct ip from instance runtime properties nc_conn.connect.assert_called_with('ip_from_runtime', 'me', hello_message, 'secret', None, 830) self.assertEqual(nc_conn.current_level, netconf_connection.NETCONF_1_1_CAPABILITY) # we have failed operations nc_conn = self._get_fake_nc_connect() nc_conn.send = mock.Mock(side_effect=[ # copy-config self.CORRECT_REPLY, # failed operation self.INCORRECT_REPLY, # failed reset config self.INCORRECT_REPLY ]) with mock.patch( 'cloudify_terminal_sdk.netconf_connection.NetConfConnection', mock.MagicMock(return_value=nc_conn)): with self.assertRaises(cfy_exc.RecoverableError): # we have some failed operation rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "a": "b" } }], back_database="a", front_database="b") # failed operation, but reset successed nc_conn.send = mock.Mock(side_effect=[ # copy-config self.CORRECT_REPLY, # failed operation self.INCORRECT_REPLY, # failed reset config self.CORRECT_REPLY ]) with mock.patch( 'cloudify_terminal_sdk.netconf_connection.NetConfConnection', mock.MagicMock(return_value=nc_conn)): with self.assertRaises(cfy_exc.RecoverableError): # we have some failed operation rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "a": "b" } }], back_database="a", front_database="b")
def test_run(self): """check connect/call rpc/close connection sequence""" fake_ctx = cfy_mocks.MockCloudifyContext() instance = mock.Mock() instance.runtime_properties = {} fake_ctx._instance = instance node = mock.Mock() fake_ctx._node = node node.properties = {} node.runtime_properties = {} # no calls rpc.run(ctx=fake_ctx) # with empty list of calls rpc.run(ctx=fake_ctx, calls=[]) # with list of calls, but without auth with self.assertRaises(cfy_exc.NonRecoverableError): rpc.run(ctx=fake_ctx, calls=[{'action': 'get'}]) # netconf connection mock nc_conn = mock.Mock() nc_conn.connect = mock.MagicMock( return_value=self.CORRECT_HELLO_REPLY ) nc_conn.send = mock.MagicMock( return_value=self.CORRECT_REPLY ) nc_conn.close = mock.MagicMock( return_value=self.CORRECT_CLOSE_REPLY ) nc_conn.current_level = netconf_connection.NETCONF_1_0_CAPABILITY node.properties = { 'netconf_auth': { "user": "******", "password": "******", "ip": "super_secret" }, 'metadata': { 'xmlns': { 'd': 'c' } }, "base_xmlns": { "a": "b" } } with mock.patch( 'cloudify_netconf.netconf_connection.connection', mock.MagicMock(return_value=nc_conn) ): # we have empty action rpc.run(ctx=fake_ctx, calls=[{'unknow': 'get'}]) # have some payload rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "a": "b" } }]) # have lock/unlock operations rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "a": "b" } }], lock=["rfc6020@candidate"]) # have some copy operations rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "a": "b" } }], back_database="a", front_database="b") # check save to runtime properties self.assertEqual(instance.runtime_properties, {}) rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "c": "d" }, 'save_to': 'd' }]) # looks as we save something self.assertTrue("d" in instance.runtime_properties) self.assertTrue("d_ns" in instance.runtime_properties) self.assertTrue( "rfc6020@ok" in instance.runtime_properties["d"] ) # validation without relaxng rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "c": "d" }, 'save_to': 'd', 'validation': { 'xpath': 'somepath' } }]) self.assertEqual( nc_conn.current_level, netconf_connection.NETCONF_1_0_CAPABILITY ) # version 1.1 nc_conn.connect = mock.MagicMock( return_value=self.CORRECT_HELLO_1_1_REPLY ) with mock.patch( 'cloudify_netconf.netconf_connection.connection', mock.MagicMock(return_value=nc_conn) ): rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', }]) self.assertEqual( nc_conn.current_level, netconf_connection.NETCONF_1_1_CAPABILITY )
def test_run_with_template(self): """check connect/call rpc/close connection calls sequence""" fake_ctx, node, instance = self._get_mock_context_for_run() hello_message = ( """<?xml version=\'1.0\' encoding=\'UTF-8\'?>\n<rfc6020""" + """:hello xmlns:a="b" xmlns:d="c" xmlns:rfc6020="urn:ie""" + """tf:params:xml:ns:netconf:base:1.0">\n <rfc6020:capa""" + """bilities>\n <rfc6020:capability>urn:ietf:params:n""" + """etconf:base:1.0</rfc6020:capability>\n <rfc6020:c""" + """apability>urn:ietf:params:netconf:base:1.1</rfc6020:""" + """capability>\n </rfc6020:capabilities>\n</rfc6020:he""" + """llo>\n""") # no calls current_ctx.set(fake_ctx) # with empty list of calls rpc.run(ctx=fake_ctx, template=None) rpc.run(ctx=fake_ctx, template="") # with list of calls, but without auth with self.assertRaises(cfy_exc.NonRecoverableError): rpc.run(ctx=fake_ctx, template="template.xml") nc_conn = self._get_fake_nc_connect() node.properties = { 'netconf_auth': { "user": "******", "password": "******", "ip": "super_secret" }, 'metadata': { 'xmlns': { 'd': 'c' } }, "base_xmlns": { "a": "b" } } with mock.patch( 'cloudify_terminal_sdk.netconf_connection.NetConfConnection', mock.MagicMock(return_value=nc_conn)): # we have empty action rpc.run(ctx=fake_ctx, template="template.xml") nc_conn.connect.assert_called_with('super_secret', 'me', hello_message, 'secret', None, 830) fake_ctx.get_resource.assert_called_with("template.xml") # have some params fake_ctx.get_resource = mock.MagicMock(return_value="{{ a }}") # empty params rpc.run(ctx=fake_ctx, template="template.xml", params={}) rpc.run(ctx=fake_ctx, templates=["template.xml"], params={}) # real params rpc.run(ctx=fake_ctx, template="template.xml", params={'a': 'b'}) rpc.run(ctx=fake_ctx, templates=["template.xml"], params={'a': 'b'}) # template with empty commands, must be skiped fake_ctx.get_resource = mock.MagicMock( return_value="]]>]]>\n]]>]]>") rpc.run(ctx=fake_ctx, template="template.xml", params={'a': 'b'}) rpc.run(ctx=fake_ctx, templates=["template.xml"], params={'a': 'b'}) template_mock = io.StringIO(u"{{ a }}") with mock.patch('cloudify_netconf.xml_rpc.open', return_value=template_mock, create=True) as mocked_open: rpc.run(ctx=fake_ctx, templates=["file:///template.xml"], params={'a': 'b'}) mocked_open.assert_called_once_with("/template.xml") nc_conn.send.assert_called_with('b') template_mock = mock.Mock() template_mock.content = 'b' with mock.patch('requests.get', return_value=template_mock, create=True) as mocked_open: rpc.run(ctx=fake_ctx, templates=["http://cloudify.co/template.xml"], params={'a': 'b'}) mocked_open.assert_called_once_with( "http://cloudify.co/template.xml") nc_conn.send.assert_called_with('b')
def test_run(self): """check connect/call rpc/close connection sequence""" fake_ctx = cfy_mocks.MockCloudifyContext() instance = mock.Mock() instance.runtime_properties = {} fake_ctx._instance = instance node = mock.Mock() fake_ctx._node = node node.properties = {} node.runtime_properties = {} # no calls rpc.run(ctx=fake_ctx) # with empty list of calls rpc.run(ctx=fake_ctx, calls=[]) # with list of calls, but without auth with self.assertRaises(cfy_exc.NonRecoverableError): rpc.run(ctx=fake_ctx, calls=[{'action': 'get'}]) # netconf connection mock nc_conn = mock.Mock() nc_conn.connect = mock.MagicMock(return_value=self.CORRECT_HELLO_REPLY) nc_conn.send = mock.MagicMock(return_value=self.CORRECT_REPLY) nc_conn.close = mock.MagicMock(return_value=self.CORRECT_CLOSE_REPLY) nc_conn.current_level = netconf_connection.NETCONF_1_0_CAPABILITY node.properties = { 'netconf_auth': { "user": "******", "password": "******", "ip": "super_secret" }, 'metadata': { 'xmlns': { 'd': 'c' } }, "base_xmlns": { "a": "b" } } with mock.patch('cloudify_netconf.netconf_connection.connection', mock.MagicMock(return_value=nc_conn)): # we have empty action rpc.run(ctx=fake_ctx, calls=[{'unknow': 'get'}]) # have some payload rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "a": "b" } }]) # have lock/unlock operations rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "a": "b" } }], lock=["rfc6020@candidate"]) # have some copy operations rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "a": "b" } }], back_database="a", front_database="b") # check save to runtime properties self.assertEqual(instance.runtime_properties, {}) rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "c": "d" }, 'save_to': 'd' }]) # looks as we save something self.assertTrue("d" in instance.runtime_properties) self.assertTrue("d_ns" in instance.runtime_properties) self.assertTrue("rfc6020@ok" in instance.runtime_properties["d"]) # validation without relaxng rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', 'payload': { "c": "d" }, 'save_to': 'd', 'validation': { 'xpath': 'somepath' } }]) self.assertEqual(nc_conn.current_level, netconf_connection.NETCONF_1_0_CAPABILITY) # version 1.1 nc_conn.connect = mock.MagicMock( return_value=self.CORRECT_HELLO_1_1_REPLY) with mock.patch('cloudify_netconf.netconf_connection.connection', mock.MagicMock(return_value=nc_conn)): rpc.run(ctx=fake_ctx, calls=[{ 'action': 'run_something', }]) self.assertEqual(nc_conn.current_level, netconf_connection.NETCONF_1_1_CAPABILITY)