Пример #1
0
    def test_vm_deployer_error(self):
        name = 'name'
        name_gen = Mock(return_value=name)
        pv_service = Mock()
        si = Mock()
        clone_parmas = Mock()
        clone_res = Mock()
        clone_res.error = Mock()

        pv_service.CloneVmParameters = Mock(return_value=clone_parmas)
        pv_service.clone_vm = Mock(return_value=clone_res)
        params = DeployDataHolder.create_from_params(
            template_model={
                "vCenter_resource_name": "vcenter_resource_name",
                "vm_folder": "vfolder_name",
                "template_name": "template_name"
            },
            vm_cluster_model={
                "cluster_name": "cluster_name",
                "resource_pool": "resource_pool"
            },
            datastore_name="datastore_name",
            power_on=False)

        deployer = VirtualMachineDeployer(pv_service, name_gen)

        self.assertRaises(Exception, deployer.deploy_from_template, si, params)
        self.assertTrue(pv_service.CloneVmParameters.called)
Пример #2
0
    def test_server_sends_marshaled_exception_when_callback_raises_exception(self, mock_command_response):
        request = '{"name": "foobar", "arg": {"arg1": "value"}}'

        expected = '{"error": "raise me!", "value": null}'

        command_response = Mock(CommandResponse)
        command_response.error = "raise me!"
        command_response.value = None
        mock_command_response.return_value = command_response
        callback = Mock(side_effect=BusCtlServerError())

        marshaler = Mock(Marshaler)
        server = BusCtlServer()
        server._marshaler = marshaler

        command = Mock()
        command.name = "foobar"
        marshaler.unmarshal_command.return_value = command
        marshaler.marshal_response.return_value = expected

        command_class = Mock()
        command_class.name = "foobar"

        server.add_command(command_class, callback)

        response = server._process_next_command(request)

        self.assertEqual(response, expected)
        marshaler.marshal_response.assert_called_once_with(command_response)
Пример #3
0
    def test_server_sends_marshaled_exception_when_callback_raises_exception(
            self, mock_command_response):
        request = '{"name": "foobar", "arg": {"arg1": "value"}}'

        expected = '{"error": "raise me!", "value": null}'

        command_response = Mock(CommandResponse)
        command_response.error = "raise me!"
        command_response.value = None
        mock_command_response.return_value = command_response
        callback = Mock(side_effect=BusCtlServerError())

        marshaler = Mock(Marshaler)
        server = BusCtlServer()
        server._marshaler = marshaler

        command = Mock()
        command.name = "foobar"
        marshaler.unmarshal_command.return_value = command
        marshaler.marshal_response.return_value = expected

        command_class = Mock()
        command_class.name = "foobar"

        server.add_command(command_class, callback)

        response = server._process_next_command(request)

        self.assertEqual(response, expected)
        marshaler.marshal_response.assert_called_once_with(command_response)
Пример #4
0
    def test_handle_produce_response_on_nonretriable(self, fake_decode,
                                                     fake_retry):
        m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
        m2 = Message('test_driver', {'val': 2}, None, None, 0, 1)
        response = Mock()
        response.code = 500
        response.error = False
        response.request = Mock()
        response.request._batch = [m1, m2]
        response.request._id = 1
        body = {
            'offsets': [{}, {}],
            'value_schema_id': 1,
            'key_schema_id': 2,
            'error_code': 50101,
            'message': 'Nonretriable'
        }
        fake_decode.return_value = body

        self.producer._handle_produce_response('test_driver', response)

        calls = [
            call('test_driver', m1, 'nonretriable'),
            call('test_driver', m2, 'nonretriable')
        ]
        self.client.mock_for('drop_message').assert_has_calls(calls)
Пример #5
0
    def test_should_list_three_actual_calls(self):
        mock_object = Mock()

        mock_object.error('spam eggs')
        mock_object.warn('hello world')
        mock_object.info('foo bar')

        exception_raised = False
        try:
            verify(mock_object).warn()
        except VerificationError as error:
            exception_raised = True
            assert_that(str(error), equal_to("""
Expected: call mock.Mock.warn() << at least once >>
 but was: call mock.Mock.error('spam eggs')
          call mock.Mock.warn('hello world')
          call mock.Mock.info('foo bar')
"""))
        assert_that(exception_raised)
Пример #6
0
 def get_obj(self, logger=None):
     if not logger:
         def print_msg(msg):
             print(msg)
         logger = Mock()
         logger.error = Mock(side_effect=print_msg)
         logger.warning = Mock(side_effect=print_msg)
         logger.info = Mock(side_effect=print_msg)
         logger.debug = Mock(side_effect=print_msg)
     return self.test_obj(logger)
Пример #7
0
    def test_log_not_written_when_exception_not_thrown(self):
        # Arrange
        logger = Mock()
        logger.error = MagicMock()

        # Act
        with ErrorHandlingContext(logger=logger):
            pass

        # Assert
        logger.error.assert_not_called()
    def test_log_not_written_when_exception_not_thrown(self):
        # Arrange
        logger = Mock()
        logger.error = MagicMock()

        # Act
        with ErrorHandlingContext(logger=logger):
            print 'hello world'

        # Assert
        logger.error.assert_not_called()
Пример #9
0
 def login(self, adapter, provider_name):
     del adapter, provider_name
     response = Mock()
     response.error = self.error
     if self.error:
         response.user = False
     else:
         user = Mock()
         user.name = self.name
         user.email = self.email
         response.user = user
     return response
Пример #10
0
 def login(self, adapter, provider_name):
     del adapter, provider_name
     response = Mock()
     response.error = self.error
     if self.error:
         response.user = False
     else:
         user = Mock()
         user.name = self.name
         user.email = self.email
         response.user = user
     return response
 def test_response_raise_for_status(self):
     original_response = Mock()
     original_response.error = None
     original_response.status_code = 500
     original_response.content = '{"message": "error"}'
     response = Response(original_response)
     try:
         response.raise_for_status()
     except ResponseError as e:
         self.assertEqual(str(e), "500: error")
     else:
         self.fail("Did not raise a Response Error")
Пример #12
0
    def test_should_list_three_actual_calls(self):
        mock_object = Mock()

        mock_object.error('spam eggs')
        mock_object.warn('hello world')
        mock_object.info('foo bar')

        exception_raised = False
        try:
            verify(mock_object).warn()
        except VerificationError as error:
            exception_raised = True
            assert_that(
                str(error),
                equal_to("""
Expected: call mock.Mock.warn() << at least once >>
 but was: call mock.Mock.error('spam eggs')
          call mock.Mock.warn('hello world')
          call mock.Mock.info('foo bar')
"""))
        assert_that(exception_raised)
    def test_log_written_when_exception_occurs(self):
        # Arrange
        logger = Mock()
        logger.error = MagicMock()
        try:

            # Act
            with ErrorHandlingContext(logger=logger):
                raise ValueError('some value error occurred')
        except ValueError:

            # Assert
            logger.error.assert_called()
Пример #14
0
    def test_log_written_when_exception_occurs(self):
        # Arrange
        logger = Mock()
        logger.error = MagicMock()
        try:

            # Act
            with ErrorHandlingContext(logger=logger):
                raise ValueError("some value error occurred")
        except ValueError:

            # Assert
            logger.error.assert_called()
Пример #15
0
    def test_is_success(self):
        self.task.query_extra_data_for_test_task = Mock()
        tt = TaskTester(self.task, self.path, Mock(), Mock())
        task_thread = Mock()

        # Proper task
        task_thread.error = None
        task_thread.result = ({"data": True}, 123)
        assert tt.is_success(task_thread)

        # Task thead result first arg is not tuple
        task_thread.result = {"data": True}
        assert not tt.is_success(task_thread)
        assert task_thread.error == "Wrong result format"
Пример #16
0
def get_posix_object(logger=None, setup=None, config=None):
    if config is None:
        config = lxml.etree.Element("Configuration")
    if not logger:
        def print_msg(msg):
            print(msg)
        logger = Mock()
        logger.error = Mock(side_effect=print_msg)
        logger.warning = Mock(side_effect=print_msg)
        logger.info = Mock(side_effect=print_msg)
        logger.debug = Mock(side_effect=print_msg)
    if not setup:
        setup = MagicMock()
    return Bcfg2.Client.Tools.POSIX.POSIX(logger, setup, config)
Пример #17
0
 def get_obj(self, logger=None, setup=None, config=None):
     if config is None:
         config = lxml.etree.Element("Configuration")
     if not logger:
         def print_msg(msg):
             print(msg)
         logger = Mock()
         logger.error = Mock(side_effect=print_msg)
         logger.warning = Mock(side_effect=print_msg)
         logger.info = Mock(side_effect=print_msg)
         logger.debug = Mock(side_effect=print_msg)
     if not setup:
         setup = MagicMock()
     return self.test_obj(logger, setup, config)
Пример #18
0
    def test_handle_produce_response_transport_error(self, fake_retry):
        m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
        m2 = Message('test_driver', {'val': 2}, None, None, 0, 1)
        response = Mock()
        response.code = 599
        response.error = object()
        response.request = Mock()
        response.request._batch = [m1, m2]
        response.request._id = 1

        self.producer._handle_produce_response('test_driver', response)

        self.client.mock_for('response_5xx').assert_called_once_with('test_driver', response)
        fake_retry.assert_has_calls([call('test_driver', m1),
                                     call('test_driver', m2)])
 def test_response_raise_for_status_with_error(self):
     original_response = Mock()
     original_response.error = None
     original_response.status_code = 500
     original_response.content = '''{
         "message": "Error",
         "errors": ["Error 1", "Error 2"]
     }'''
     response = Response(original_response)
     try:
         response.raise_for_status()
     except ResponseError as e:
         self.assertEqual(str(e), "500: Error -> [Error 1, Error 2]")
     else:
         self.fail("Did not raise a Response Error")
    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)
Пример #21
0
def get_posix_object(logger=None, setup=None, config=None):
    if config is None:
        config = lxml.etree.Element("Configuration")
    if not logger:

        def print_msg(msg):
            print(msg)

        logger = Mock()
        logger.error = Mock(side_effect=print_msg)
        logger.warning = Mock(side_effect=print_msg)
        logger.info = Mock(side_effect=print_msg)
        logger.debug = Mock(side_effect=print_msg)
    if not setup:
        setup = MagicMock()
    return Bcfg2.Client.Tools.POSIX.POSIX(logger, setup, config)
    def setUp(self):
        config = types.ModuleType('config')

        handler_mock = Mock()
        config.HANDLER_CLASS = lambda : handler_mock

        logger_mock = Mock()
        logger_mock.info = Mock()
        logger_mock.error = Mock()
        logger_mock.debug = Mock()
        config.GET_LOGGER_FUNCTION = lambda : logger_mock

        def test_bindings(binder):
            binder.bind('cli_service', Mock())

        self.driver = CiscoNXOSDriver(config, test_bindings)
Пример #23
0
    def test_execute_command_with_fetch_response(self):
        command = Mock()
        request = Mock()
        raw_response = Mock()
        response = Mock()
        response.error = None
        self.marshaler.marshal_command.return_value = request
        self.transport.rpc_call.return_value = raw_response
        self.marshaler.unmarshal_response.return_value = response

        self.agent_client._fetch_response = True
        result = self.agent_client._execute_command(command)

        self.marshaler.marshal_command.assert_called_once_with(command)
        self.transport.rpc_call.assert_called_once_with('', self.QUEUE_NAME, request)
        self.assertEqual(result, response.value)
Пример #24
0
    def test_execute_command_with_fetch_response(self):
        command = Mock()
        request = Mock()
        raw_response = Mock()
        response = Mock()
        response.error = None
        self.marshaler.marshal_command.return_value = request
        self.transport.rpc_call.return_value = raw_response
        self.marshaler.unmarshal_response.return_value = response

        self.agent_client._fetch_response = True
        result = self.agent_client._execute_command(command)

        self.marshaler.marshal_command.assert_called_once_with(command)
        self.transport.rpc_call.assert_called_once_with(
            '', self.QUEUE_NAME, request)
        self.assertEqual(result, response.value)
Пример #25
0
    def test_handle_produce_response_transport_error(self, fake_retry):
        m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
        m2 = Message('test_driver', {'val': 2}, None, None, 0, 1)
        response = Mock()
        response.code = 599
        response.error = object()
        response.request = Mock()
        response.request._batch = [m1, m2]
        response.request._id = 1

        self.producer._handle_produce_response('test_driver', response)

        self.client.mock_for('response_5xx').assert_called_once_with(
            'test_driver', response)
        fake_retry.assert_has_calls(
            [call('test_driver', m1),
             call('test_driver', m2)])
Пример #26
0
    def test_handle_produce_response_on_200(self, fake_decode,
                                            fake_handle_success):
        m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
        m2 = Message('test_driver', {'val': 2}, None, None, 0, 1)
        response = Mock()
        response.code = 200
        response.error = False
        response.request = Mock()
        response.request._batch = [m1, m2]
        response.request._id = 1
        body = {'offsets': [{}, {}], 'value_schema_id': 1, 'key_schema_id': 2}
        fake_decode.return_value = body

        self.producer._handle_produce_response('test_driver', response)

        fake_handle_success.assert_called_once_with('test_driver', response,
                                                    body)
Пример #27
0
    def test_handleServiceCallCompleted_retry(self):
        writer = self.getUtility.return_value.metric_writer
        event = Mock(spec=ServiceCallCompleted)
        event.timestamp = 160.0
        event.error = None
        event.retry = object()
        key = _CountKey(event)
        self._task_stats[event.id].received = 100.0
        self._task_stats[event.id].started = 150.0
        self._servicecall_count[key] += 1
        self._servicecall_wip[key] += 1

        handleServiceCallCompleted(event)

        self.getUtility.assert_called_once_with(IMetricManager)
        self.assertEqual(1, len(self._task_stats))
        self.assertEqual(1, len(self._servicecall_count))
        self.assertEqual(1, len(self._servicecall_wip))
        self.assertEqual(1, self._servicecall_count[key])
        self.assertEqual(0, self._servicecall_wip[key])
        writer.write_metric.assert_has_calls((
            call(
                "zenhub.servicecall.wip",
                0,
                160000,
                {
                    "queue": event.queue,
                    "priority": event.priority.name,
                    "service": event.service,
                    "method": event.method,
                },
            ),
            call(
                "zenhub.servicecall.cycletime",
                10000,
                160000,
                {
                    "queue": event.queue,
                    "priority": event.priority.name,
                    "service": event.service,
                    "method": event.method,
                    "status": "retry",
                },
            ),
        ), any_order=True)
Пример #28
0
    def test__log_complete(self):
        call = Mock(spec=ServiceCall)
        task = Mock(spec=ServiceCallTask)
        task.call = call
        task.error = None
        task.received_tm = 10
        task.started_tm = 20
        task.completed_tm = 30
        task.workerId = "default_0"

        self.running._log_completed(task)

        self.logger.info.assert_called_once_with(
            "Completed task service=%s method=%s id=%s "
            "worker=%s status=%s duration=%0.2f lifetime=%0.2f",
            call.service, call.method, call.id.hex,
            task.workerId, "success", 10, 20,
        )
Пример #29
0
    def test_handle_produce_response_on_200(self, fake_decode, fake_handle_success):
        m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
        m2 = Message('test_driver', {'val': 2}, None, None, 0, 1)
        response = Mock()
        response.code = 200
        response.error = False
        response.request = Mock()
        response.request._batch = [m1, m2]
        response.request._id = 1
        body = {'offsets': [{}, {}],
                'value_schema_id': 1,
                'key_schema_id': 2}
        fake_decode.return_value = body

        self.producer._handle_produce_response('test_driver', response)

        fake_handle_success.assert_called_once_with('test_driver',
                                                    response,
                                                    body)
Пример #30
0
 def make_response(self, response_attrs=None, request_attrs=None):
     response = Mock()
     request = Mock()
     response.code = 200
     response.error = None
     response.body = json.dumps({'offsets': [{}]})
     request._id = 1
     request._topic = 'test_driver'
     request._batch = [
         Message('test_driver', self.test_value, None, None, 0, 1)
     ]
     for k, v in (response_attrs or {}).items():
         if k == 'body':
             v = json.dumps(v)
         setattr(response, k, v)
     for k, v in (request_attrs or {}).items():
         setattr(request, k, v)
     response.request = request
     return response
Пример #31
0
    def test_handle_produce_response_on_retriable(self, fake_decode, fake_retry):
        m1 = Message('test_driver', {'val': 1}, None, None, 0, 1)
        m2 = Message('test_driver', {'val': 2}, None, None, 0, 1)
        response = Mock()
        response.code = 500
        response.error = False
        response.request = Mock()
        response.request._batch = [m1, m2]
        response.request._id = 1
        body = {'offsets': [{}, {}],
                'value_schema_id': 1,
                'key_schema_id': 2,
                'error_code': 50001,
                'message': 'Retriable'}
        fake_decode.return_value = body

        self.producer._handle_produce_response('test_driver', response)

        fake_retry.assert_has_calls([call('test_driver', m1),
                                     call('test_driver', m2)])
Пример #32
0
 def get_obj(self, logger=None, setup=None, config=None):
     if config is None:
         config = lxml.etree.Element("Configuration")
     if not logger:
         def print_msg(msg):
             print(msg)
         logger = Mock()
         logger.error = Mock(side_effect=print_msg)
         logger.warning = Mock(side_effect=print_msg)
         logger.info = Mock(side_effect=print_msg)
         logger.debug = Mock(side_effect=print_msg)
     if not setup:
         setup = MagicMock()
     if 'command_timeout' not in setup:
         setup['command_timeout'] = None
     execs = self.test_obj.__execs__
     self.test_obj.__execs__ = []
     rv = self.test_obj(logger, setup, config)
     self.test_obj.__execs__ = execs
     return rv
Пример #33
0
    def test_vm_deployer(self):
        name = 'name'
        uuid = 'uuid'
        name_gen = Mock(return_value=name)
        pv_service = Mock()
        si = Mock()
        clone_parmas = Mock()
        clone_res = Mock()
        clone_res.error = None
        clone_res.vm = Mock()
        clone_res.vm.summary = Mock()
        clone_res.vm.summary.config = Mock()
        clone_res.vm.summary.config.uuid = uuid

        pv_service.CloneVmParameters = Mock(return_value=clone_parmas)
        pv_service.clone_vm = Mock(return_value=clone_res)
        params = DeployDataHolder({
            "resource_context": None,
            "template_model": {
                "vCenter_resource_name": "vcenter_resource_name",
                "vm_folder": "vfolder_name",
                "template_name": "template_name"
            },
            "vm_cluster_model": {
                "cluster_name": "cluster_name",
                "resource_pool": "resource_pool"
            },
            "datastore_name": "datastore_name",
            "power_on": False
        })

        deployer = VirtualMachineDeployer(pv_service, name_gen)
        res = deployer.deploy_from_template(si, params)

        self.assertEqual(res.vm_name, name)
        self.assertEqual(res.vm_uuid, uuid)
        self.assertEqual(res.cloud_provider_resource_name,
                         params.template_model.vCenter_resource_name)
        self.assertTrue(pv_service.CloneVmParameters.called)
Пример #34
0
 def _mock_parser():
     parser = Mock()
     parser.error = ValidateOptions._raise_parser_error
     return parser
Пример #35
0
    def _start_gui(self, session_fails=False, expected_result=None):

        address = WebSocketAddress(u'127.0.0.1', 50000, realm=u'golem')
        logger = Mock()

        def resolve_call(alias, *args, **kwargs):
            if alias == aliases.Environment.datadir:
                return self.path
            elif alias == aliases.Environment.opts:
                return DictSerializer.dump(ClientConfigDescriptor())
            elif alias == aliases.Environment.opt_description:
                return u'test description'
            elif alias == aliases.Payments.ident:
                return u'0xdeadbeef'
            elif alias == aliases.Crypto.key_id:
                return u'0xbadfad'
            elif alias == aliases.Task.tasks_stats:
                return dict(in_network=0,
                            supported=0,
                            subtasks_computed=0,
                            subtasks_with_errors=0,
                            subtasks_with_timeout=0)
            elif alias == aliases.Payments.balance:
                return 0, 0, 0
            elif alias == aliases.Network.peers_connected:
                return []
            elif alias == aliases.Computation.status:
                return u''
            return 1

        with patch('logging.getLogger', return_value=logger), \
             patch('gui.startgui.start_error', side_effect=lambda err: logger.error(err)), \
             patch('gui.startgui.GUIApp.start', side_effect=lambda *a, **kw: logger.error("Success")), \
             patch('gui.startgui.install_qt5_reactor', side_effect=self._get_reactor), \
             patch('golem.rpc.session.Session.connect', session_connect(session_fails)), \
             patch('golem.rpc.session.Session.call', session_call(resolve_call)):

            try:

                from gui.startgui import GUIApp, start_gui

                gui_app = GUIApp(rendering=True)
                gui_app.gui.execute = lambda *a, **kw: logger.error("Success")
                gui_app.logic.customizer = Mock()

                thread = Thread(target=lambda: start_gui(address, gui_app))
                thread.daemon = True
                thread.start()

                deadline = time.time() + 10
                while True:

                    if logger.error.called:
                        if not logger.error.call_args:
                            raise Exception(u"Invalid result: {}".format(
                                logger.error.call_args))

                        message = logger.error.call_args[0][0]
                        assert unicode(message).find(expected_result) != -1
                        break

                    elif time.time() > deadline:
                        raise Exception(u"Test timed out")
                    else:
                        time.sleep(0.1)

            except Exception as exc:
                self.fail(u"Cannot start gui process: {}".format(exc))