Ejemplo n.º 1
0
    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='******')
Ejemplo n.º 2
0
    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)
Ejemplo n.º 4
0
    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()
Ejemplo n.º 5
0
    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')
Ejemplo n.º 8
0
 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)
Ejemplo n.º 10
0
    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)
Ejemplo n.º 11
0
    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)
Ejemplo n.º 14
0
    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)
Ejemplo n.º 15
0
    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))
Ejemplo n.º 16
0
    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]))
Ejemplo n.º 17
0
    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)
Ejemplo n.º 19
0
    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')
Ejemplo n.º 20
0
    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')
Ejemplo n.º 21
0
    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)
Ejemplo n.º 22
0
    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'))
Ejemplo n.º 23
0
    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')
Ejemplo n.º 24
0
    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(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)
Ejemplo n.º 27
0
 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=[])
Ejemplo n.º 28
0
 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='******')
     ])
Ejemplo n.º 29
0
 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())
Ejemplo n.º 31
0
    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)
Ejemplo n.º 32
0
    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')
Ejemplo n.º 33
0
    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')
Ejemplo n.º 34
0
    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'))
Ejemplo n.º 35
0
    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'))
Ejemplo n.º 36
0
        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)
Ejemplo n.º 38
0
    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')
Ejemplo n.º 39
0
        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)
            )
Ejemplo n.º 40
0
        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
Ejemplo n.º 41
0
    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)
Ejemplo n.º 42
0
        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))
Ejemplo n.º 43
0
    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')
Ejemplo n.º 44
0
    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')
Ejemplo n.º 45
0
    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)
Ejemplo n.º 46
0
    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')
Ejemplo n.º 47
0
    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')
Ejemplo n.º 48
0
    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))
Ejemplo n.º 49
0
    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")
Ejemplo n.º 50
0
        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
Ejemplo n.º 51
0
    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)
Ejemplo n.º 52
0
  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()
Ejemplo n.º 53
0
        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_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)
Ejemplo n.º 55
0
  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"])