def test_run_auth_workflow_impicit_input(self): # wrong context type _ctx = Mock() _ctx.type = '<unknown>' ssh_mock = Mock() ssh_mock.connect = Mock(side_effect=OSError("e")) with patch("paramiko.SSHClient", Mock(return_value=ssh_mock)): with self.assertRaises(NonRecoverableError): tasks.run_as_workflow( {}, ctx=_ctx, calls=[{'action': 'ls'}], logger_file="/tmp/terminal.log", terminal_auth=json.loads(json.dumps( {'ip': 'ip', 'user': '******', 'password': '******'}))) # correct context type _ctx = Mock() _ctx.type = 'deployment' ssh_mock = Mock() ssh_mock.connect = Mock(side_effect=OSError("e")) with patch("paramiko.SSHClient", Mock(return_value=ssh_mock)): with self.assertRaises(OperationRetry): tasks.run_as_workflow( {}, ctx=_ctx, calls=[{'action': 'ls'}], logger_file="/tmp/terminal.log", terminal_auth=json.loads(json.dumps( {'ip': 'ip', 'user': '******', 'password': '******'}))) ssh_mock.connect.assert_called_with( 'ip', allow_agent=False, look_for_keys=False, password='******', port=22, timeout=5, username='******')
def test_ssh_client_connect_immediately_throws_on_fatal_execption(self): # Verify that fatal exceptions are immediately propagated and ensure # we don't try to retry on them from paramiko.ssh_exception import SSHException from paramiko.ssh_exception import PasswordRequiredException mock_ssh_client = Mock() mock_ssh_client.connect = Mock() mock_ssh_client.connect.side_effect = IOError('bam') mock_exceptions = [ SSHException('Invalid or unsupported key type'), PasswordRequiredException('private key file is encrypted'), SSHException('OpenSSH private key file checkints do not match') ] for mock_exception in mock_exceptions: mock_ssh_client.connect = Mock(side_effect=mock_exception) assertRaisesRegex(self, mock_exception.__class__, str(mock_exception), self.driver._ssh_client_connect, ssh_client=mock_ssh_client, wait_period=0.1, timeout=0.2)
def test_TestNetworkAdaptersRetriever_E0(self): content = Mock() si = create_autospec(spec=vim.ServiceInstance) si.RetrieveContent = Mock(return_value=content) pvServiceConnectError = Mock() pvServiceConnectError.connect = Mock(side_effect=Exception('TEST Exception')) pvServiceConnectNone = Mock() pvServiceConnectNone.connect = Mock(return_value=si) pvServiceConnectNone.find_network_by_name = Mock(return_value=None) csRetrieverService = Mock() csRetrieverService.getVCenterInventoryPathAttributeData = Mock( return_value={'vCenter_resource_name': 'Resource Name', "vm_folder": "TEST_FOLDER"}) helpers.get_resource_context_details = Mock(return_value={}) connDetails = create_autospec(VCenterConnectionDetails) resourceConnectionDetailsRetriever = Mock() resourceConnectionDetailsRetriever.getConnectionDetails = Mock(return_value=connDetails) switchRetriever = NetworkAdaptersRetrieverCommand(pvServiceConnectError, csRetrieverService, resourceConnectionDetailsRetriever) with self.assertRaises(ConnectionException) as context: switchRetriever.execute() self.assertTrue('User:' in context.exception.message) switchRetriever = NetworkAdaptersRetrieverCommand(pvServiceConnectNone, csRetrieverService, resourceConnectionDetailsRetriever) nics = switchRetriever.execute() self.assertIsNone(nics)
def test_create_endpoint_existing_channel(self): ch = Mock(spec=SendChannel) e = self._ef.create_endpoint(existing_channel=ch) self.assertEquals(e.channel, ch) self.assertEquals(ch.connect.call_count, 0) ch.connect("exist") ch.connect.assert_called_once_with('exist') e.close()
def test_TestNetworkAdaptersRetriever(self): content = Mock() si = create_autospec(spec=vim.ServiceInstance) si.RetrieveContent = Mock(return_value=content) vNic = create_autospec(spec=vim.vm.device.VirtualEthernetCard) vNic.deviceInfo = Mock() vNic.deviceInfo.summary = 'network1' vNic.macAddress = 'AA-BB' vNic.connectable = Mock() vNic.connectable.connected = 'True' vNic.connectable.startConnected = 'True' vmMachine = Mock() vmMachine.config.hardware.device = [vNic] pvService = Mock() pvService.connect = Mock(return_value=si) pvService.get_obj = Mock(return_value=vmMachine) pvService.find_network_by_name = Mock(return_value=vmMachine) pvServiceConnectError = Mock() pvServiceConnectError.connect = Mock( side_effect=Exception('TEST Exception')) pvServiceConnectNone = Mock() pvServiceConnectNone.connect = Mock(return_value=None) csRetrieverService = Mock() csRetrieverService.getVCenterInventoryPathAttributeData = Mock( return_value={ 'vCenter_resource_name': 'Resource Name', "vm_folder": "TEST_FOLDER" }) helpers.get_resource_context_details = Mock(return_value={}) connDetails = create_autospec(VCenterConnectionDetails) connDetails.host = 'host' connDetails.user = '******' connDetails.password = '******' connDetails.port = 443 resourceConnectionDetailsRetriever = Mock() resourceConnectionDetailsRetriever.getConnectionDetails = Mock( return_value=connDetails) switchRetriever = NetworkAdaptersRetrieverCommand( pvService, csRetrieverService, resourceConnectionDetailsRetriever) nics = switchRetriever.execute() self.assertEqual(nics[0].networkLabel, 'network1') self.assertEqual(nics[0].macAddress, 'AA-BB') self.assertEqual(nics[0].connected, 'True') self.assertEqual(nics[0].connectAtPowerOn, 'True')
def test_TestNetworkAdaptersRetriever(self): content = Mock() si = create_autospec(spec=vim.ServiceInstance) si.RetrieveContent = Mock(return_value=content) vNic = create_autospec(spec=vim.vm.device.VirtualEthernetCard) vNic.deviceInfo = Mock() vNic.deviceInfo.summary = 'network1' vNic.macAddress = 'AA-BB' vNic.connectable = Mock() vNic.connectable.connected = 'True' vNic.connectable.startConnected = 'True' vmMachine = Mock() vmMachine.config.hardware.device = [vNic] pvService = Mock() pvService.connect = Mock(return_value=si) pvService.get_obj = Mock(return_value=vmMachine) pvService.find_network_by_name = Mock(return_value=vmMachine) pvServiceConnectError = Mock() pvServiceConnectError.connect = Mock(side_effect=Exception('TEST Exception')) pvServiceConnectNone = Mock() pvServiceConnectNone.connect = Mock(return_value=None) csRetrieverService = Mock() csRetrieverService.getVCenterInventoryPathAttributeData = Mock( return_value={'vCenter_resource_name': 'Resource Name', "vm_folder": "TEST_FOLDER"}) helpers.get_resource_context_details = Mock(return_value={}) connDetails = create_autospec(VCenterConnectionDetails) connDetails.host = 'host' connDetails.user = '******' connDetails.password = '******' connDetails.port = 443 resourceConnectionDetailsRetriever = Mock() resourceConnectionDetailsRetriever.getConnectionDetails = Mock(return_value=connDetails) switchRetriever = NetworkAdaptersRetrieverCommand(pvService, csRetrieverService, resourceConnectionDetailsRetriever) nics = switchRetriever.execute() self.assertEqual(nics[0].networkLabel, 'network1') self.assertEqual(nics[0].macAddress, 'AA-BB') self.assertEqual(nics[0].connected, 'True') self.assertEqual(nics[0].connectAtPowerOn, 'True')
def test_progress_updates_system_tor(self, ftb): control_ep = Mock() control_ep.connect = Mock(return_value=defer.succeed(None)) directlyProvides(control_ep, IStreamClientEndpoint) ep = TCPHiddenServiceEndpoint.system_tor(self.reactor, control_ep, 1234) ep._tor_progress_update(40, "FOO", "foo to bar") return ep
def test_should_not_update_state_if_unaavailable(self): # Set app = NewrelicApp('1111','777') headers = {"X-Api-Key":'1111'} url ='/v2/applications/777.json' # Mocks connection_obj = Mock() response_obj = Mock() httplib.HTTPConnection = Mock(return_value=connection_obj) response_obj.status = 500 # Error response_obj.read = Mock(return_value='') connection_obj.connect = Mock() connection_obj.request = Mock() connection_obj.getresponse = Mock(return_value=response_obj) # Assertion app.update_state() connection_obj.connect.assert_called_once() connection_obj.request.assert_called_once_with('GET', url, '', headers) connection_obj.getresponse.assert_called_once() self.assertFalse(app.reachable)
def test_delete(self): # arrange uuid = 'uuid' network_name = 'network_name' network = Mock() network.name = network_name si = Mock() vm = Mock() vm.network = [network] connection_detail = Mock() connection_detail.host = Mock() connection_detail.username = Mock() connection_detail.password = Mock() connection_detail.port = Mock() pv_service = Mock() pv_service.connect = Mock(return_value=si) pv_service.find_by_uuid = Mock(return_value=vm) connector = VirtualSwitchToMachineDisconnectCommand( pv_service, Mock(), 'anetwork') # act res = connector.disconnect(si, uuid, network_name) # assert self.assertTrue( pv_service.connect.called_with(connection_detail.host, connection_detail.username, connection_detail.password, connection_detail.port)) self.assertTrue(pv_service.find_by_uuid.called_with(si, uuid)) self.assertTrue(res)
def test_delete_all(self): # arrange uuid = 'uuid' si = Mock() vm = Mock() connection_detail = Mock() connection_detail.host = Mock() connection_detail.username = Mock() connection_detail.password = Mock() connection_detail.port = Mock() pv_service = Mock() pv_service.connect = Mock(return_value=si) pv_service.find_by_uuid = Mock(return_value=vm) connector = VirtualSwitchToMachineDisconnectCommand( pv_service, Mock(), 'anetwork') # virtual_switch_to_machine_connector.remove_interfaces_from_vm = Mock(return_value=True) connector.get_network_by_name = lambda x, y: Mock() # act res = connector.disconnect(si, uuid) # assert self.assertTrue( pv_service.connect.called_with(connection_detail.host, connection_detail.username, connection_detail.password, connection_detail.port)) self.assertTrue(pv_service.find_by_uuid.called_with(si, uuid)) # self.assertTrue(virtual_switch_to_machine_connector.remove_interfaces_from_vm.called_with(vm)) self.assertTrue(res)
def test_delete(self): # arrange uuid = 'uuid' network_name = 'network_name' network = Mock() network.name = network_name si = Mock() vm = Mock() vm.network = [network] connection_detail = Mock() connection_detail.host = Mock() connection_detail.username = Mock() connection_detail.password = Mock() connection_detail.port = Mock() pv_service = Mock() pv_service.connect = Mock(return_value=si) pv_service.find_by_uuid = Mock(return_value=vm) connector = VirtualSwitchToMachineDisconnectCommand(pv_service, Mock(), 'anetwork') # act res = connector.disconnect(si, uuid, network_name) # assert self.assertTrue(pv_service.connect.called_with(connection_detail.host, connection_detail.username, connection_detail.password, connection_detail.port)) self.assertTrue(pv_service.find_by_uuid.called_with(si, uuid)) self.assertTrue(res)
def test_delete_all(self): # arrange uuid = 'uuid' si = Mock() vm = Mock() connection_detail = Mock() connection_detail.host = Mock() connection_detail.username = Mock() connection_detail.password = Mock() connection_detail.port = Mock() pv_service = Mock() pv_service.connect = Mock(return_value=si) pv_service.find_by_uuid = Mock(return_value=vm) connector = VirtualSwitchToMachineDisconnectCommand(pv_service, Mock(), 'anetwork') # virtual_switch_to_machine_connector.remove_interfaces_from_vm = Mock(return_value=True) connector.get_network_by_name = lambda x, y: Mock() # act res = connector.disconnect(si, uuid) # assert self.assertTrue(pv_service.connect.called_with(connection_detail.host, connection_detail.username, connection_detail.password, connection_detail.port)) self.assertTrue(pv_service.find_by_uuid.called_with(si, uuid)) # self.assertTrue(virtual_switch_to_machine_connector.remove_interfaces_from_vm.called_with(vm)) self.assertTrue(res)
def test_getConnection_mysql(self): # mock the MySQLdb module so we can test in an environement which does not have this module installed mock_MySQLdb = Mock() mock_MySQLdb.connect = Mock(return_value=sentinel) with patch.dict('sys.modules', {'MySQLdb': mock_MySQLdb}): # verify that a correct dsn does work as expected storage = DatabaseStorage( "mysql://*****:*****@somehost:someport/somedbname", Mock()) assert mock_MySQLdb.connect.called, "expecting MySQLdb.connect to be called" self.assertEqual(sentinel, storage.db) # verify that an incorrect dsn does fail an stops the bot with a nice error message mock_MySQLdb.connect.reset_mock() console_mock = Mock() storage = DatabaseStorage( "mysql://*****:*****@somehost:3446/", console_mock) assert console_mock.critical.called self.assertIn("missing MySQL database name", console_mock.critical.call_args[0][0]) assert not mock_MySQLdb.connect.called, "expecting MySQLdb.connect not to be called" self.assertIsNone(storage.db) # verify that an incorrect dsn does fail an stops the bot with a nice error message mock_MySQLdb.connect.reset_mock() console_mock = Mock() storage = DatabaseStorage("mysql://*****:*****@/database", console_mock) assert console_mock.critical.called self.assertIn("invalid MySQL host", console_mock.critical.call_args[0][0]) assert not mock_MySQLdb.connect.called, "expecting MySQLdb.connect not to be called" self.assertIsNone(storage.db)
def test_circuit_stream_failure(self): """ If the stream-attach fails the error propagates """ reactor = Mock() torstate = Mock() target = Mock() target.connect = Mock(return_value=defer.succeed(None)) circ = Mock() circ.state = 'FAILED' src_addr = Mock() src_addr.host = 'host' src_addr.port = 1234 target._get_address = Mock(return_value=defer.succeed(src_addr)) stream = Mock() stream.source_port = 1234 stream.source_addr = 'host' # okay, so we fire up our circuit-endpoint with mostly mocked # things, and a circuit that's already in 'FAILED' state. ep = TorCircuitEndpoint(reactor, torstate, circ, target) # should get a Failure from the connect() d = ep.connect(Mock()) attacher = yield _get_circuit_attacher(reactor, Mock()) attacher.attach_stream_failure(stream, RuntimeError("a bad thing")) try: yield d self.fail("Should get exception") except RuntimeError as e: self.assertEqual("a bad thing", str(e))
def test_get_address_endpoint(self): socks_ep = Mock() transport = proto_helpers.StringTransport() delayed_addr = [] def connect(factory): delayed_addr.append(factory._get_address()) delayed_addr.append(factory._get_address()) factory.startFactory() proto = factory.buildProtocol("addr") proto.makeConnection(transport) self.assertEqual(b'\x05\x01\x00', transport.value()) proto.dataReceived(b'\x05\x00') proto.dataReceived(b'\x05\x00\x00\x01\x00\x00\x00\x00\x00\x00') return proto socks_ep.connect = connect protocol = Mock() factory = Mock() factory.buildProtocol = Mock(return_value=protocol) ep = socks.TorSocksEndpoint(socks_ep, u'meejah.ca', 443, tls=True) yield ep.connect(factory) addr = yield ep._get_address() self.assertEqual(addr, IPv4Address('TCP', '10.0.0.1', 12345)) self.assertEqual(2, len(delayed_addr)) self.assertTrue(delayed_addr[0] is not delayed_addr[1]) self.assertTrue(all([d.called for d in delayed_addr]))
def test_connect_tls_context(self): socks_ep = Mock() transport = proto_helpers.StringTransport() def connect(factory): factory.startFactory() proto = factory.buildProtocol("addr") proto.makeConnection(transport) self.assertEqual(b'\x05\x01\x00', transport.value()) proto.dataReceived(b'\x05\x00') proto.dataReceived(b'\x05\x00\x00\x01\x00\x00\x00\x00\x00\x00') return proto socks_ep.connect = connect protocol = Mock() factory = Mock() factory.buildProtocol = Mock(return_value=protocol) from OpenSSL import SSL class CertificateOptions(object): def getContext(self, *args, **kw): return SSL.Context(SSL.TLSv1_METHOD) ep = socks.TorSocksEndpoint(socks_ep, u'meejah.ca', 443, tls=CertificateOptions()) proto = yield ep.connect(factory) self.assertEqual(proto, protocol)
def test_connect(self): # Arrange si = Mock() py_vmomi_service = Mock() py_vmomi_service.connect = Mock(return_value=si) resource_connection_details_retriever = Mock() dv_port_group_creator = MagicMock() virtual_machine_port_group_configurer = MagicMock() virtual_switch_to_machine_connector = VirtualSwitchToMachineConnector(py_vmomi_service, resource_connection_details_retriever, dv_port_group_creator, virtual_machine_port_group_configurer) virtual_machine_path = 'ParentFlder\\ChildFolder' virtual_machine_name = 'MachineName' vm_uuid = uuid.UUID('{12345678-1234-5678-1234-567812345678}') port_group_path = 'QualiSB' dv_switch_path = 'QualiSB' dv_switch_name = 'dvSwitch' dv_port_name = 'dv_port_name' # Act virtual_switch_to_machine_connector.connect(virtual_machine_name, dv_switch_path, dv_switch_name, dv_port_name, virtual_machine_path, vm_uuid, port_group_path) # Assert dv_port_group_creator.create_dv_port_group.assert_called_with(dv_port_name, dv_switch_name, dv_switch_path, si) virtual_machine_port_group_configurer.configure_port_group_on_vm.assert_called_with(si, virtual_machine_path, vm_uuid, port_group_path, dv_port_name)
def test_command_can_be_executed_succesfully(self): ssh_lib_mocked = Mock() ssh_lib_mocked.connect = Mock(return_value=True) ssh_lib_mocked.exec_command = Mock(return_value=('test', ['test'], '')) ssh_lib_mocked.close = Mock(return_value=True) assert 'test ' == SSHClient(ssh_lib_mocked, self.__generate_test_logger()).exec_command('ls', 'unit', 'test')
def test_success(self): """ Connect a stream via a circuit """ reactor = Mock() torstate = Mock() target = Mock() target.connect = Mock(return_value=defer.succeed('fake proto')) circ = Mock() circ.state = 'NEW' src_addr = Mock() src_addr.host = 'host' src_addr.port = 1234 target._get_address = Mock(return_value=defer.succeed(src_addr)) stream = Mock() stream.source_port = 1234 stream.source_addr = 'host' # okay, so we fire up our circuit-endpoint with mostly mocked # things, and a circuit that's already in 'FAILED' state. ep = TorCircuitEndpoint(reactor, torstate, circ, target) # should get a Failure from the connect() d = ep.connect(Mock()) attacher = yield _get_circuit_attacher(reactor, torstate) yield attacher.attach_stream(stream, [circ]) proto = yield d self.assertEqual(proto, 'fake proto')
def test_getConnection_mysql(self): # mock the MySQLdb module so we can test in an environement which does not have this module installed mock_MySQLdb = Mock() mock_MySQLdb.connect = Mock(return_value=sentinel) with patch.dict('sys.modules', {'MySQLdb': mock_MySQLdb}): # verify that a correct dsn does work as expected storage = DatabaseStorage("mysql://*****:*****@somehost:someport/somedbname", Mock()) assert mock_MySQLdb.connect.called, "expecting MySQLdb.connect to be called" self.assertEqual(sentinel, storage.db) # verify that an incorrect dsn does fail an stops the bot with a nice error message mock_MySQLdb.connect.reset_mock() console_mock = Mock() storage = DatabaseStorage("mysql://*****:*****@somehost:3446/", console_mock) assert console_mock.critical.called self.assertIn("missing MySQL database name", console_mock.critical.call_args[0][0]) assert not mock_MySQLdb.connect.called, "expecting MySQLdb.connect not to be called" self.assertIsNone(storage.db) # verify that an incorrect dsn does fail an stops the bot with a nice error message mock_MySQLdb.connect.reset_mock() console_mock = Mock() storage = DatabaseStorage("mysql://*****:*****@/database", console_mock) assert console_mock.critical.called self.assertIn("invalid MySQL host", console_mock.critical.call_args[0][0]) assert not mock_MySQLdb.connect.called, "expecting MySQLdb.connect not to be called" self.assertIsNone(storage.db)
def test_run_run_with_close(self): _ctx = self._gen_ctx() connection_mock = Mock() connection_mock.connect = Mock(return_value="") connection_mock.run = Mock(return_value="localhost") connection_mock.is_closed = Mock(side_effect=[False, True]) with patch("cloudify_terminal_sdk.terminal_connection.RawConnection", Mock(return_value=connection_mock)): tasks.run(ctx=_ctx, calls=[{}], terminal_auth=json.loads( json.dumps({ 'ip': 'ip', 'user': '******', 'password': '******', 'store_logs': True }))) connection_mock.run.assert_has_calls([ call(command='exit', prompt_check=None, warning_examples=[], error_examples=[], critical_examples=[]) ]) self.assertIsNone( _ctx.instance.runtime_properties.get('place_for_save'))
def test_TestNetworkAdaptersRetriever(self): content = Mock() si = create_autospec(spec=vim.ServiceInstance) si.RetrieveContent = Mock(return_value=content) vNic = create_autospec(spec=vim.vm.device.VirtualEthernetCard) vNic.deviceInfo = Mock() vNic.deviceInfo.summary = 'network1' vNic.macAddress = 'AA-BB' vNic.connectable = Mock() vNic.connectable.connected = 'True' vNic.connectable.startConnected = 'True' vmMachine = Mock() vmMachine.config.hardware.device = [vNic] pvService = Mock() pvService.connect = Mock(return_value=si) pvService.get_obj = Mock(return_value=vmMachine) pvService.find_network_by_name = Mock(return_value=vmMachine) switchRetriever = NetworkAdaptersRetrieverCommand(pvService) nics = switchRetriever.retrieve(si, "some path", "network name") self.assertEqual(nics[0].networkLabel, 'network1') self.assertEqual(nics[0].macAddress, 'AA-BB') self.assertEqual(nics[0].connected, 'True') self.assertEqual(nics[0].connectAtPowerOn, 'True')
def test_connect(self): # Arrange si = Mock() py_vmomi_service = Mock() py_vmomi_service.connect = Mock(return_value=si) resource_connection_details_retriever = Mock() dv_port_group_creator = MagicMock() virtual_machine_port_group_configurer = MagicMock() virtual_switch_to_machine_connector = VirtualSwitchToMachineConnector( py_vmomi_service, resource_connection_details_retriever, dv_port_group_creator, virtual_machine_port_group_configurer) virtual_machine_path = 'ParentFlder\\ChildFolder' virtual_machine_name = 'MachineName' vm_uuid = uuid.UUID('{12345678-1234-5678-1234-567812345678}') port_group_path = 'QualiSB' dv_switch_path = 'QualiSB' dv_switch_name = 'dvSwitch' dv_port_name = 'dv_port_name' # Act virtual_switch_to_machine_connector.connect( virtual_machine_name, dv_switch_path, dv_switch_name, dv_port_name, virtual_machine_path, vm_uuid, port_group_path) # Assert dv_port_group_creator.create_dv_port_group.assert_called_with( dv_port_name, dv_switch_name, dv_switch_path, si) virtual_machine_port_group_configurer.configure_port_group_on_vm.assert_called_with( si, virtual_machine_path, vm_uuid, port_group_path, dv_port_name)
def test_should_add_menu_iten(self): # Set ind = NewrelicIndicator() # Mocks method_callback = Mock(name='Method') menu_obj = Mock(name='Menu') menu_obj.append = Mock() menu_iten_obj = Mock(name='MenuItem') menu_iten_obj.connect = Mock() menu_iten_obj.show = Mock() ind.indicator = Mock(name='Indicator') ind.indicator.set_menu = Mock() gtk.Menu = Mock(return_value=menu_obj) gtk.MenuItem = Mock(return_value=menu_iten_obj) # Assertion ind._NewrelicIndicator__add_menu_iten('ItemName', method_callback) gtk.MenuItem.assert_called_once_with('ItemName') self.assertEquals(ind.menu, menu_obj) menu_iten_obj.connect.assert_called_once_with("activate", method_callback) menu_iten_obj.show.assert_called_once() menu_obj.append.assert_called_once_with(menu_iten_obj) ind.indicator.set_menu.assert_called_once_with(menu_obj)
def test_run_auth_enabled_logs(self): _ctx = self._gen_ctx() connection_mock = Mock() connection_mock.connect = Mock(side_effect=OSError("e")) with patch("cloudify_terminal_sdk.terminal_connection.RawConnection", Mock(return_value=connection_mock)): with self.assertRaises(OperationRetry): tasks.run(ctx=_ctx, calls=[{ 'action': 'ls' }], terminal_auth=json.loads( json.dumps({ 'ip': 'ip', 'user': '******', 'password': '******', 'store_logs': True }))) connection_mock.connect.assert_called_with('ip', 'user', 'password', None, 22, prompt_check=None, responses=[])
def test_run_auth_several_ips(self): _ctx = self._gen_ctx() ssh_mock = Mock() ssh_mock.connect = Mock(side_effect=OSError("e")) with patch("paramiko.SSHClient", Mock(return_value=ssh_mock)): with self.assertRaises(OperationRetry): tasks.run(ctx=_ctx, calls=[{ 'action': 'ls' }], terminal_auth=json.loads( json.dumps({ 'ip': ['ip1', 'ip2'], 'user': '******', 'password': '******' }))) ssh_mock.connect.assert_has_calls([ call('ip1', allow_agent=False, look_for_keys=False, password='******', port=22, timeout=5, username='******'), call('ip2', allow_agent=False, look_for_keys=False, password='******', port=22, timeout=5, username='******') ])
def test_run_auth_relationship(self): _ctx = self._gen_relation_ctx() ssh_mock = Mock() ssh_mock.connect = Mock(side_effect=OSError("e")) try: type(_ctx.target.instance).host_ip = PropertyMock( side_effect=NonRecoverableError('host_ip is undefined')) with patch("paramiko.SSHClient", Mock(return_value=ssh_mock)): with self.assertRaises(OperationRetry): tasks.run(ctx=_ctx, calls=[{ 'action': 'ls' }], logger_file="/tmp/terminal.log", terminal_auth=json.loads( json.dumps({ 'ip': 'ip', 'user': '******', 'password': '******' }))) ssh_mock.connect.assert_called_with('ip', allow_agent=False, look_for_keys=False, password='******', port=22, timeout=5, username='******') finally: type(_ctx.target.instance).host_ip = None
def test_connect(self): # Arrange si = Mock() py_vmomi_service = Mock() py_vmomi_service.connect = Mock(return_value=si) dv_port_group_creator = MagicMock() virtual_machine_port_group_configurer = MagicMock() vlan_spec = Mock() virtual_switch_to_machine_connector = VirtualSwitchToMachineConnector(dv_port_group_creator, virtual_machine_port_group_configurer) vm = Mock() network_map = Mock() network_map.dv_port_name = 'dv_port_name' network_map.dv_switch_name = 'dvSwitch' network_map.dv_switch_path = 'QualiSB' network_map.vlan_id = '100' network_map.vlan_spec = 'Access' # Act virtual_switch_to_machine_connector.connect_by_mapping(si=si, vm=vm, mapping=[network_map], default_network=Mock(spec=vim.Network), reserved_networks=[], logger=Mock())
def test_must_connect_to_network_on_create(self): """ Create a container with only required values. Optional values are not provided :return: """ network_id = "some id" generated_id = "fooobar" self.mock_docker_client.containers.create.return_value = Mock() self.mock_docker_client.containers.create.return_value.id = generated_id network_mock = Mock() self.mock_docker_client.networks.get.return_value = network_mock network_mock.connect = Mock() container = Container(self.image, self.cmd, self.working_dir, self.host_dir, docker_client=self.mock_docker_client) container.network_id = network_id container_id = container.create() self.assertEquals(container_id, generated_id) self.mock_docker_client.networks.get.assert_called_with(network_id) network_mock.connect.assert_called_with(container_id)
def test_run_with_save_responses(self): _ctx = self._gen_ctx() connection_mock = Mock() connection_mock.connect = Mock(return_value="") connection_mock.run = Mock(return_value="localhost") with patch("cloudify_terminal_sdk.terminal_connection.RawConnection", Mock(return_value=connection_mock)): tasks.run( ctx=_ctx, calls=[{'action': 'hostname', 'save_to': 'place_for_save', 'responses': [{'question': 'yes?', 'answer': 'no'}], 'errors': ['error'], 'promt_check': ['#']}], terminal_auth=json.loads(json.dumps( {'ip': 'ip', 'user': '******', 'password': '******', 'store_logs': True}))) connection_mock.run.assert_called_with( command='hostname', prompt_check=['#'], warning_examples=[], error_examples=['error'], critical_examples=[], responses=[{'question': 'yes?', 'answer': 'no'}]) self.assertEqual( _ctx.instance.runtime_properties.get('place_for_save'), 'localhost')
def test_run_run_without_save_smart(self): _ctx = self._gen_ctx() connection_mock = Mock() connection_mock.connect = Mock(return_value="") connection_mock.run = Mock(return_value="localhost") with patch("cloudify_terminal_sdk.terminal_connection.SmartConnection", Mock(return_value=connection_mock)): tasks.run( ctx=_ctx, calls=[{'action': 'hostname'}], terminal_auth=json.loads(json.dumps( {'ip': 'ip', 'user': '******', 'password': '******', 'store_logs': True, 'smart_device': True}))) connection_mock.run.assert_called_with( command='hostname', prompt_check=None, warning_examples=[], error_examples=[], critical_examples=[], responses=[]) self.assertIsNone( _ctx.instance.runtime_properties.get('place_for_save'))
def test_run_run_with_text_template(self): _ctx = self._gen_ctx() connection_mock = Mock() connection_mock.connect = Mock(return_value="") connection_mock.run = Mock(return_value="localhost") with patch("cloudify_terminal_sdk.terminal_connection.RawConnection", Mock(return_value=connection_mock)): tasks.run( ctx=_ctx, calls=[{'template_text': ""}, {'template_text': "bb"}, {'template_text': "{{ aa }}", 'params': {'aa': 'gg'}}], terminal_auth=json.loads(json.dumps( {'ip': 'ip', 'user': '******', 'password': '******'}))) connection_mock.run.assert_has_calls([ call(command='bb', prompt_check=None, warning_examples=[], error_examples=[], critical_examples=[], responses=[]), call(command='gg', prompt_check=None, warning_examples=[], error_examples=[], critical_examples=[], responses=[])]) self.assertIsNone( _ctx.instance.runtime_properties.get('place_for_save'))
def test_cancel(self, fake_sleep): """ if we start a component but call .stop before it connects, ever, it should still exit properly """ endpoint = Mock() directlyProvides(endpoint, IStreamClientEndpoint) component = Component( transports={ "type": "websocket", "url": "ws://127.0.0.1/ws", "endpoint": endpoint, }) def connect(factory, **kw): return Deferred() endpoint.connect = connect # XXX it would actually be nicer if we *could* support # passing a reactor in here, but the _batched_timer = # make_batched_timer() stuff (slash txaio in general) # makes this "hard". reactor = Clock() with replace_loop(reactor): d = component.start(reactor=reactor) component.stop() yield d
def test_destroyVirtualMachineCommand(self): content = Mock() si = create_autospec(spec=vim.ServiceInstance) si.RetrieveContent = Mock(return_value=content) pvService = Mock() pvService.connect = Mock(return_value=si) pvService.destroy_vm_by_name = MagicMock() csRetrieverService = Mock() csRetrieverService.getVCenterTemplateAttributeData = Mock(return_value=VCenterTemplateModel(template_name='test', vm_folder='Alex', vCenter_resource_name='vCenter')) csRetrieverService.getPowerStateAttributeData = Mock(return_value=True) csRetrieverService.getVMClusterAttributeData = Mock(return_value=VMClusterModel(cluster_name="cluster1", resource_pool="resourcePool1")) csRetrieverService.getVMStorageAttributeData = Mock(return_value="datastore") csRetrieverService.getVCenterConnectionDetails = Mock(return_value={"vCenter_url": "vCenter","user":"******","password":"******"}) resource_att = Mock() vm_name = Mock(return_value='test') resource_att.name = vm_name helpers.get_resource_context_details = Mock(return_value=resource_att) helpers.get_api_session = Mock() context_att = Mock() vm_id = Mock(return_value='id') context_att.id = vm_id helpers.get_reservation_context_details = Mock(return_value=context_att) command = DestroyVirtualMachineCommand(pvService, csRetrieverService) command.execute() self.assertTrue(pvService.connect.called) self.assertTrue(pvService.destroy_vm_by_name.called) self.assertTrue(si.RetrieveContent.called) pvService.destroy_vm_by_name.assert_called_with(content, si, vm_name) self.assertTrue(helpers.get_api_session().DeleteResource.called)
def test_connect(self): # Arrange si = Mock() py_vmomi_service = Mock() py_vmomi_service.connect = Mock(return_value=si) dv_port_group_creator = MagicMock() virtual_machine_port_group_configurer = MagicMock() vlan_spec = Mock() virtual_switch_to_machine_connector = VirtualSwitchToMachineConnector( dv_port_group_creator, virtual_machine_port_group_configurer) vm = Mock() network_map = Mock() network_map.dv_port_name = 'dv_port_name' network_map.dv_switch_name = 'dvSwitch' network_map.dv_switch_path = 'QualiSB' network_map.vlan_id = '100' network_map.vlan_spec = 'Access' # Act virtual_switch_to_machine_connector.connect_by_mapping( si=si, vm=vm, mapping=[network_map], default_network=Mock(spec=vim.Network), reserved_networks=[], logger=Mock(), promiscuous_mode='True')
def test_connect_no_auth_method(self, fake_sleep): endpoint = Mock() directlyProvides(endpoint, IStreamClientEndpoint) component = Component( transports={ "type": "websocket", "url": "ws://127.0.0.1/ws", "endpoint": endpoint, }, is_fatal=lambda e: True, ) def connect(factory, **kw): proto = factory.buildProtocol('boom') proto.makeConnection(Mock()) from autobahn.websocket.protocol import WebSocketProtocol from base64 import b64encode from hashlib import sha1 key = proto.websocket_key + WebSocketProtocol._WS_MAGIC proto.data = ( b"HTTP/1.1 101 Switching Protocols\x0d\x0a" b"Upgrade: websocket\x0d\x0a" b"Connection: upgrade\x0d\x0a" b"Sec-Websocket-Protocol: wamp.2.json\x0d\x0a" b"Sec-Websocket-Accept: " + b64encode(sha1(key).digest()) + b"\x0d\x0a\x0d\x0a" ) proto.processHandshake() from autobahn.wamp import role subrole = role.RoleSubscriberFeatures() msg = Hello(u"realm", roles=dict(subscriber=subrole), authmethods=[u"anonymous"]) serializer = JsonSerializer() data, is_binary = serializer.serialize(msg) proto.onMessage(data, is_binary) msg = Abort(reason=u"wamp.error.no_auth_method") proto.onMessage(*serializer.serialize(msg)) proto.onClose(False, 100, u"wamp.error.no_auth_method") return succeed(proto) endpoint.connect = connect # XXX it would actually be nicer if we *could* support # passing a reactor in here, but the _batched_timer = # make_batched_timer() stuff (slash txaio in general) # makes this "hard". reactor = Clock() with replace_loop(reactor): with self.assertRaises(RuntimeError) as ctx: d = component.start(reactor=reactor) # make sure we fire all our time-outs reactor.advance(3600) yield d self.assertIn( "Exhausted all transport", str(ctx.exception) )
def test_cancel(self, fake_sleep): """ if we start a component but call .stop before it connects, ever, it should still exit properly """ endpoint = Mock() directlyProvides(endpoint, IStreamClientEndpoint) component = Component( transports={ "type": "websocket", "url": "ws://127.0.0.1/ws", "endpoint": endpoint, } ) def connect(factory, **kw): return Deferred() endpoint.connect = connect # XXX it would actually be nicer if we *could* support # passing a reactor in here, but the _batched_timer = # make_batched_timer() stuff (slash txaio in general) # makes this "hard". reactor = Clock() with replace_loop(reactor): d = component.start(reactor=reactor) component.stop() yield d
def test_connect_to(self): from functions import connect_to with nested( patch('functions.log_write'), patch('sys.stdout', new=StringIO()), patch('functions.get_datetime'), ) as (log_write, stdout, get_dt): get_dt.return_value = {'date': '42', 'time': '42'} s = Mock() s.connect.side_effect = IOError() address = ('server', 'port') message = 'Could not connect to {0}\n{1}'.format(address, '\n') self.assertFalse(connect_to(address, s, 'foo')) self.assertEqual(stdout.getvalue(), message) log_write.assert_called_with('foo', '42', ' <> ', message) s.connect.side_effect = None s.connect = Mock() self.assertTrue(connect_to(address, s, 'foo')) s.connect.assert_called_with(address)
def test_connect_no_auth_method(self, fake_sleep): endpoint = Mock() directlyProvides(endpoint, IStreamClientEndpoint) component = Component( transports={ "type": "websocket", "url": "ws://127.0.0.1/ws", "endpoint": endpoint, }, is_fatal=lambda e: True, ) def connect(factory, **kw): proto = factory.buildProtocol('boom') proto.makeConnection(Mock()) from autobahn.websocket.protocol import WebSocketProtocol from base64 import b64encode from hashlib import sha1 key = proto.websocket_key + WebSocketProtocol._WS_MAGIC proto.data = (b"HTTP/1.1 101 Switching Protocols\x0d\x0a" b"Upgrade: websocket\x0d\x0a" b"Connection: upgrade\x0d\x0a" b"Sec-Websocket-Protocol: wamp.2.json\x0d\x0a" b"Sec-Websocket-Accept: " + b64encode(sha1(key).digest()) + b"\x0d\x0a\x0d\x0a") proto.processHandshake() from autobahn.wamp import role subrole = role.RoleSubscriberFeatures() msg = Hello(u"realm", roles=dict(subscriber=subrole), authmethods=[u"anonymous"]) serializer = JsonSerializer() data, is_binary = serializer.serialize(msg) proto.onMessage(data, is_binary) msg = Abort(reason=u"wamp.error.no_auth_method") proto.onMessage(*serializer.serialize(msg)) proto.onClose(False, 100, u"wamp.error.no_auth_method") return succeed(proto) endpoint.connect = connect # XXX it would actually be nicer if we *could* support # passing a reactor in here, but the _batched_timer = # make_batched_timer() stuff (slash txaio in general) # makes this "hard". reactor = Clock() with replace_loop(reactor): with self.assertRaises(RuntimeError) as ctx: d = component.start(reactor=reactor) # make sure we fire all our time-outs reactor.advance(3600) yield d self.assertIn("Exhausted all transport", str(ctx.exception))
def test_open_sftp(self): sftp_client_mocked = Mock() ssh_lib_mocked = Mock() ssh_lib_mocked.connect = Mock(return_value=True) ssh_lib_mocked.open_sftp = Mock(return_value=sftp_client_mocked) assert sftp_client_mocked == SSHClient(ssh_lib_mocked, self.__generate_test_logger()).open_sftp('unit', 'test')
def test_command_can_be_executed_succesfully(self): ssh_lib_mocked = Mock() ssh_lib_mocked.connect = Mock(return_value=True) ssh_lib_mocked.exec_command = Mock(return_value=('test', ['test'], '')) ssh_lib_mocked.close = Mock(return_value=True) assert 'test ' == SSHClient( ssh_lib_mocked, self.__generate_test_logger()).exec_command('ls', 'unit', 'test')
def test_ssh_client_connect_timeout(self): mock_ssh_client = Mock() mock_ssh_client.connect = Mock() mock_ssh_client.connect.side_effect = IOError('bam') try: self.driver._ssh_client_connect(ssh_client=mock_ssh_client, timeout=1) except LibcloudError, e: self.assertTrue(e.value.find('Giving up') != -1)
def test_command_fails_and_the_execution_does_not_stop(self): error_mocked = Mock() error_mocked.read = Mock(return_value='test') ssh_lib_mocked = Mock() ssh_lib_mocked.connect = Mock(return_value=True) ssh_lib_mocked.exec_command = Mock(return_value=('test', ['test'], error_mocked)) ssh_lib_mocked.close = Mock(return_value=True) assert 'test ' == SSHClient(ssh_lib_mocked, self.__generate_test_logger()).exec_command('ls', 'unit', 'test')
def test_open_sftp(self): sftp_client_mocked = Mock() ssh_lib_mocked = Mock() ssh_lib_mocked.connect = Mock(return_value=True) ssh_lib_mocked.open_sftp = Mock(return_value=sftp_client_mocked) assert sftp_client_mocked == SSHClient( ssh_lib_mocked, self.__generate_test_logger()).open_sftp('unit', 'test')
def test_connect_multiple_endpoints_many_errors(self, fake_cfg): transport = Mock() reactor = FakeReactor(self, transport, lambda: None) ep0 = Mock() ep1 = Mock() def boom0(*args, **kw): raise RuntimeError("the bad thing") def boom1(*args, **kw): raise RuntimeError("more sadness") ep0.connect = boom0 ep1.connect = boom1 directlyProvides(ep0, IStreamClientEndpoint) directlyProvides(ep1, IStreamClientEndpoint) with self.assertRaises(RuntimeError) as ctx: yield connect(reactor, [ep0, ep1]) self.assertTrue("the bad thing" in str(ctx.exception)) self.assertTrue("more sadness" in str(ctx.exception))
def test_ssh_client_connect_timeout(self): mock_ssh_client = Mock() mock_ssh_client.connect = Mock() mock_ssh_client.connect.side_effect = IOError("bam") try: self.driver._ssh_client_connect(ssh_client=mock_ssh_client, timeout=0.5) except LibcloudError: e = sys.exc_info()[1] self.assertTrue(e.value.find("Giving up") != -1) else: self.fail("Exception was not thrown")
def test_successful_proxy_connect(self, fake_sleep): endpoint = Mock() directlyProvides(endpoint, IStreamClientEndpoint) component = Component( transports={ u"type": u"websocket", u"url": u"ws://127.0.0.1/ws", u"endpoint": endpoint, u"proxy": { u"host": u"10.0.0.0", u"port": 65000, }, u"max_retries": 0, }, is_fatal=lambda _: True, ) @component.on_join def joined(session, details): return session.leave() def connect(factory, **kw): return succeed(Mock()) endpoint.connect = connect # XXX it would actually be nicer if we *could* support # passing a reactor in here, but the _batched_timer = # make_batched_timer() stuff (slash txaio in general) # makes this "hard". reactor = Clock() got_proxy_connect = Deferred() def _tcp(host, port, factory, **kw): self.assertEqual("10.0.0.0", host) self.assertEqual(port, 65000) got_proxy_connect.callback(None) return endpoint.connect(factory._wrappedFactory) reactor.connectTCP = _tcp with replace_loop(reactor): d = component.start(reactor=reactor) def done(x): if not got_proxy_connect.called: got_proxy_connect.callback(x) # make sure we fire all our time-outs d.addCallbacks(done, done) reactor.advance(3600) return got_proxy_connect
def test_command_fails_and_execution_is_stopped(self): error_mocked = Mock() error_mocked.read = Mock(return_value='test') ssh_lib_mocked = Mock() ssh_lib_mocked.connect = Mock(return_value=True) ssh_lib_mocked.exec_command = Mock(return_value=('test', ['test'], error_mocked)) ssh_lib_mocked.close = Mock(return_value=True) with pytest.raises(RuntimeError) as runtime_error: SSHClient(ssh_lib_mocked, self.__generate_test_logger()).exec_command('ls', 'unit', 'test', True) assert 'test' == str(runtime_error.value)
def test_mpdclient_connect_bad_host_raises_mpdclientexception(self): mpdconf={"host":"badhost","port":6600} mpdclient = MpdClient(mpdconf) #Mock the mpd client mpdmock=Mock() mpdclient.client=mpdmock #Mock the connect method connect=Mock(side_effect=ConnectionError()) mpdmock.connect=connect # Call with self.assertRaises(MpdClientException): mpdclient.connect()
def test_deployFromTemplateCommand(self): content = Mock() si = create_autospec(spec=vim.ServiceInstance) si.RetrieveContent = Mock(return_value=content) vmTemplate = Mock() pvService = Mock() pvService.connect = Mock(return_value=si) pvService.disconnect = Mock(return_value=Mock()) pvService.get_obj = Mock(return_value=vmTemplate) cloned_vm = Mock() cloned_vm.error = None pvService.clone_vm = Mock(return_value=cloned_vm) csRetrieverService = Mock() csRetrieverService.getVCenterTemplateAttributeData = Mock(return_value=VCenterTemplateModel(template_name='test', vm_folder='Alex', vCenter_resource_name='vCenter')) csRetrieverService.getPowerStateAttributeData = Mock(return_value=True) csRetrieverService.getVMClusterAttributeData = Mock(return_value=VMClusterModel(cluster_name="cluster1", resource_pool="resourcePool1")) csRetrieverService.getVMStorageAttributeData = Mock(return_value="datastore") csRetrieverService.getVCenterConnectionDetails = Mock(return_value={"vCenter_url": "vCenter", "user":"******", "password":"******"}) resourceContext = Mock() resourceContext.attributes = {"vCenter Template": "vCenter/Alex/test"} helpers.get_resource_context_details = Mock(return_value=resourceContext) session = Mock() session.GetResourceDetails = Mock(return_value={}) session.CreateResource = Mock() session.AddResourcesToReservation = Mock() session.SetAttributesValues = Mock() reservationContext = Mock(id="d8efb46f-4440-4685-b043-68de14ec4470") helpers.get_reservation_context_details = Mock(return_value=reservationContext) helpers.get_api_session = Mock(return_value=session) connection_details = VCenterConnectionDetails("vCenter", "user", "pass1") resource_connection_details_retriever = Mock() resource_connection_details_retriever.get_connection_details = Mock(return_value=connection_details) command = DeployFromTemplateCommand(pvService, csRetrieverService, resource_connection_details_retriever) command.execute() self.assertTrue(pvService.clone_vm.called) self.assertTrue(session.CreateResource.called) self.assertTrue(session.AddResourcesToReservation.called) self.assertTrue(session.SetAttributesValues.called)
def test_mpdclient_connectexception_raises_mpdclientexception(self): mpdconf={"host":"badhost","port":6600} mpdclient = MpdClient(mpdconf) #Mock the mpd client mpdmock=Mock() mpdclient.client=mpdmock #Mock the connect method and reaise MPDError connect=Mock(side_effect=MPDError()) mpdmock.connect=connect # Call with self.assertRaises(MpdClientException): mpdclient.connect() # Methods call assertions mpdmock.connect.assert_called_with(mpdconf["host"], mpdconf["port"])