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)
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)
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)
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)
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 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)
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()
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")
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()
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()
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"
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 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)
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)
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)
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)
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)
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_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)
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)
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, )
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
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)])
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
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)
def _mock_parser(): parser = Mock() parser.error = ValidateOptions._raise_parser_error return parser
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))