def test_extract_2_terrains(self): # given terrain = ['2', '4, 6', '2, 8', '3', '1, 2, 3', '4, 5, 6', '7, 8, 9'] TerrainsAnalyzer.extract_data_from_file = mock.Mock(return_value='') analyzer = TerrainsAnalyzer('') # when result = analyzer.extract_terrains(terrain) # then expected = [[[4, 6], [2, 8]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]]] self.assertEqual(result, expected)
def test_create_response_uri_generates_session_state_if_session_management_enabled( self): # RequestFactory doesn't support sessions, so we mock it self.request.session = mock.Mock(session_key=None) authorization_endpoint = AuthorizeEndpoint(self.request) authorization_endpoint.validate_params() uri = authorization_endpoint.create_response_uri() self.assertIn('session_state=', uri)
def test_minimum_effort_to_travel_3x3(self): # given terrain = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] TerrainsAnalyzer.extract_data_from_file = mock.Mock( return_value=terrain) analyzer = TerrainsAnalyzer('') # when result = analyzer.minimum_effort_to_travel(terrain) # then self.assertEqual(result, 21)
def test_get_or_make_loop_handles_runtime_error(): asyncio.set_event_loop(None) mock_loop = mock.Mock(asyncio.AbstractEventLoop) with mock.patch.object(asyncio, "new_event_loop", return_value=mock_loop) as new_event_loop: assert aio.get_or_make_loop() is mock_loop new_event_loop.assert_called_once_with() assert asyncio.get_event_loop_policy().get_event_loop() is mock_loop
def test_send_payload(self, mock_subproc_popen): process_mock = mock.Mock() attrs = {'stdout.readline.return_value': 'Test\n'} process_mock.configure_mock(**attrs) mock_subproc_popen.return_value = process_mock @mock.patch('requests.post', side_effect=mocked_post) def test_post(self, mock_get): feed_file('test', False, 1, '', 0) self.assertTrue(mock_subproc_popen.called)
def test_use_case_with_positive_percentage(connected_device): volume_increase_in_percentage = 10 initial_volume = connected_device.volume device_discovery_service = mock.Mock() device_discovery_service.get.return_value = connected_device # We mock the device discovery service device_transport_control_service = mock.Mock() volume_up_uc = VolumeUpUseCase(device_discovery_service, device_transport_control_service) volume_up_request = VolumeUpRequestObject.from_dict( {'volume_increase': volume_increase_in_percentage}) response_object = volume_up_uc.execute(volume_up_request) assert bool(response_object) is True device_transport_control_service.volume_up.assert_called_with( connected_device) assert connected_device.volume == initial_volume + volume_increase_in_percentage
def test_get_one(self): self.get_mock.return_value = fakes.FakeResponse(data=self.pod_json) pod_get_one = pods.PodGetOne(self.app, mock.Mock()) args = ['def'] verifies = [('name', 'def')] parsed_args = self.check_parser(pod_get_one, args, verifies) pod_get_one.take_action(parsed_args) self.get_mock.assert_called_once_with( self.base_url + '/def', headers=clientmanager.ClientManager.headers)
def test_use_case_with_positive_integer(connected_device): volume_decrease_integer = 10 initial_volume = connected_device.volume device_discovery_service = mock.Mock() device_discovery_service.get.return_value = connected_device # We mock the device discovery service device_transport_control_service = mock.Mock() volume_down_uc = VolumeDownUseCase(device_discovery_service, device_transport_control_service) volume_down_request = VolumeDownRequestObject.from_dict( {'volume_decrease': volume_decrease_integer}) response_object = volume_down_uc.execute(volume_down_request) assert bool(response_object) is True device_transport_control_service.volume_down.assert_called_with( connected_device) assert connected_device.volume == initial_volume - volume_decrease_integer
def test_get(self): self.get_mock.return_value = fakes.FakeResponse(data=self.projects_rsp) project_get = projects.ProjectGet(self.app, mock.Mock()) args = ['-name', 'dfs'] verifies = [('name', 'dfs')] parsed_args = self.check_parser(project_get, args, verifies) project_get.take_action(parsed_args) self.get_mock.assert_called_once_with( self.base_url + '?name=dfs', headers=clientmanager.ClientManager.headers)
def test_strip_site_theme_from_uri(self, parent_mock, helper_mock): """ Test site theme templates path is stripped from the given template path. """ theme = mock.Mock() theme.theme_dir_name = 'bragi' helper_mock.get_current_theme.return_value = theme helper_mock.get_project_root_name.return_value = 'lms' default_theme = mock.Mock() default_theme.theme_dir_name = 'default-theme' default_theme.name = 'default_theme' default_theme.path = Path('/themes/default_theme/lms') default_theme.template_path = Path('default-theme/lms/templates') parent_mock.return_value = default_theme template_path = strip_site_theme_templates_path( 'bragi/lms/templates/header.html') self.assertEqual(template_path, 'header.html')
def setUp(self): super().setUp() self.manager = mock.Mock() self.resource_type_factory = ResourceTypeFactory() self.resource_type_factory.register('server') self.server_resource_type = self.resource_type_factory.get('server') self.app = get_app() Api(self.app, manager=self.manager, resource_type_factory=self.resource_type_factory)
def test__lshw(self, udev_mock, po, wm, output_helper, hwd): wm.return_value = '/valid/path' udev_mock.return_value = "mocked_udevadm_out" process_mock = mock.Mock() attrs = {'communicate.return_value': (output_helper.lshw_out['stdout'], 'error')} process_mock.configure_mock(**attrs) po.return_value = process_mock out = hwd.HardwareDetections()._lshw() expected = output_helper.lshw_out['expected_return'] assert out == expected
def test_get_all(self): self.get_mock.return_value = fakes.FakeResponse(data=self.pods_rsp) pod_get = pods.PodGet(self.app, mock.Mock()) args = [] verifies = [] parsed_args = self.check_parser(pod_get, args, verifies) pod_get.take_action(parsed_args) self.get_mock.assert_called_once_with( self.base_url, headers=clientmanager.ClientManager.headers)
def test_send_call_message(self): message = pika_drv_msg.RpcPikaOutgoingMessage( self._pika_engine, self._message, self._context ) expiration = 1 stopwatch = timeutils.StopWatch(duration=expiration).start() result = "it is a result" reply_queue_name = "reply_queue_name" future = futures.Future() future.set_result(result) reply_listener = mock.Mock() reply_listener.register_reply_waiter.return_value = future reply_listener.get_reply_qname.return_value = reply_queue_name res = message.send( exchange=self._exchange, routing_key=self._routing_key, reply_listener=reply_listener, stopwatch=stopwatch, retrier=None ) self.assertEqual(result, res) self._pika_engine.connection_with_confirmation_pool.acquire( ).__enter__().channel.publish.assert_called_once_with( body=mock.ANY, exchange=self._exchange, mandatory=True, properties=mock.ANY, routing_key=self._routing_key ) body = self._pika_engine.connection_with_confirmation_pool.acquire( ).__enter__().channel.publish.call_args[1]["body"] self.assertEqual( b'{"_$_request_id": 555, "_$_token": "it is a token", ' b'"msg_str": "hello", "msg_type": 1}', body ) props = self._pika_engine.connection_with_confirmation_pool.acquire( ).__enter__().channel.publish.call_args[1]["properties"] self.assertEqual(props.content_encoding, 'utf-8') self.assertEqual(props.content_type, 'application/json') self.assertEqual(props.delivery_mode, 1) self.assertTrue(expiration * 1000 - float(props.expiration) < 100) self.assertEqual(props.headers, {'version': '1.0'}) self.assertEqual(props.correlation_id, message.msg_id) self.assertEqual(props.reply_to, reply_queue_name) self.assertTrue(props.message_id)
def test_get_one(self): self.get_mock.return_value = fakes.FakeResponse( data=self.testcase_json) testcase_get_one = testcases.TestcaseGetOne(self.app, mock.Mock()) args = ['--project-name', 'functest', 'def'] verifies = [('project_name', 'functest'), ('name', 'def')] parsed_args = self.check_parser(testcase_get_one, args, verifies) testcase_get_one.take_action(parsed_args) self.get_mock.assert_called_once_with( self.base_url.format(parsed_args.project_name) + '/def', headers=clientmanager.ClientManager.headers)
def test_get(self): self.get_mock.return_value = fakes.FakeResponse( data=self.testcases_rsp) testcase_get = testcases.TestcaseGet(self.app, mock.Mock()) args = ['--project-name', 'dfs'] verifies = [('project_name', 'dfs')] parsed_args = self.check_parser(testcase_get, args, verifies) testcase_get.take_action(parsed_args) self.get_mock.assert_called_once_with( self.base_url.format(parsed_args.project_name), headers=clientmanager.ClientManager.headers)
def test_device_matches(self, pu, ms, ps): ps.return_value = '/dev/disk/by-id' ms.return_value = '-name ata* -o -name scsi* -o -name nvme*' pu.return_value = -1 cephdisks.__salt__ = {} cephdisks.__salt__['helper.run'] = mock.Mock() cephdisks.__salt__['helper.run'].return_value = (0, '/dev/disk/by-id/sda', "") ret = cephdisks.device_('/dev/sda') assert ret == '/dev/disk/by-id/sda'
def test_delete_success(self): self.delete_mock.return_value = fk.FakeResponse() scenario_delete = scenarios.ScenarioDelete(self.app, mock.Mock()) args = ['def'] verifies = [('name', 'def')] parsed_args = self.check_parser(scenario_delete, args, verifies) scenario_delete.take_action(parsed_args) self.delete_mock.assert_called_once_with( self.base_url + '/def', data=None, headers=clientmanager.ClientManager.headers)
def build_fastapi_app(self, config={}, **limiter_args): limiter_args.setdefault("key_func", get_remote_address) limiter = Limiter(**limiter_args) app = FastAPI() app.state.limiter = limiter app.add_middleware(SlowAPIMiddleware) mock_handler = mock.Mock() mock_handler.level = logging.INFO limiter.logger.addHandler(mock_handler) return app, limiter
def test_handle_http_error(self, code): """Test for handle http errors when {code} code""" ex = mock.Mock() ex.resp.status = code ex.content = json.dumps({ "error": {"message": "message"} }) with self.assertRaises(HTTPException): file_actions.handle_http_error(ex)
def test_parse_animal_from_row(): row = mock.Mock() mock_name_column = mock.Mock() mock_name_attrs = {'href': mock.Mock()} mock_name_column.find.return_value.attrs = mock_name_attrs mock_collateral_adjectives_column = mock.Mock() collateral_adjectives = ['a', 'b'] mock_collateral_adjectives_column.contents = collateral_adjectives + [ mock.Mock() ] row.find_all.return_value = [ mock_name_column, None, None, None, None, mock_collateral_adjectives_column, None ] animal = parse_animal_from_row(row) assert animal.collateral_adjectives == collateral_adjectives assert animal.name == mock_name_column.get_text.return_value assert animal.link == mock_name_attrs['href']
def test_backup_mysql_status_updated(mock_get_dst, mock_backup_stream, mock_prep_status, mock_mysql_source, config_content): s_config = config_content.format(destination="ssh", port='1234') buf = StringIO.StringIO(s_config) config = ConfigParser.ConfigParser() config.readfp(buf) mock_dst = mock.Mock() mock_get_dst.return_value = mock_dst backup_mysql("hourly", config) mock_dst.status.assert_called_once()
def test_rclone_returns_output_rc(self, mock_subproc_popen): process_mock = mock.Mock() attrs = { 'returncode': '0', } process_mock.configure_mock(**attrs) mock_subproc_popen.return_value = process_mock rc, output = self.backend.run_rclone("foo") self.assertEqual(rc, "0")
def test_get_industry_tickers(self): self.db.collection.find = mock.Mock() self.db.collection.find.return_value = [{ "Industry": "Semiconductors", "Ticker": "AMD" }, { "Industry": "Semiconductors", "Ticker": "INTL" }] self.assertEqual(self.db.get_industry_tickers("Semiconductors"), ['AMD', 'INTL'])
def test_use_case_empty_parameters(connected_device): device_discovery_service = mock.Mock() device_discovery_service.get.return_value = connected_device # We mock the device discovery service initial_volume = connected_device.volume device_transport_control_service = mock.Mock() mute_uc = MuteUseCase(device_discovery_service, device_transport_control_service) mute_request_object = MuteRequestObject.from_dict({}) result_object = mute_uc.execute(mute_request_object) device_discovery_service.get.assert_called() device_transport_control_service.mute.assert_called() device_transport_control_service.mute.assert_called_with(connected_device) assert bool(result_object) is True assert connected_device.volume == initial_volume
def test_power_on_domain_not_found(self, mock_open): connection_mock = mock.Mock() connection_mock.lookupByName.side_effect = \ libvirt.libvirtError('virDomainLookupByName() failed', conn=connection_mock) mock_open.return_value = connection_mock self.assertRaises(drivers.DeviceNotFound, self.driver.power_on, 'domainA') connection_mock.close.assert_called_with()
def test__updates_needed(self, po, apt): """ Updates pending """ process_mock = mock.Mock() attrs = {'communicate.return_value': ("", "1;1")} process_mock.configure_mock(**attrs) po.return_value = process_mock ret = apt._updates_needed() assert po.called is True assert ret is True
def test_wsfe_number(self): # Simulamos la respuesta de la AFIP y un numero distinto al siguiente del talonario afip_wsfe = mock.Mock() afip_wsfe.get_last_number = mock.MagicMock(return_value=1) with self.assertRaises(ValidationError): self.invoice._action_wsfe_number(self.document_book_fc_a, afip_wsfe, 001) # Ahora probamos el caso que coinciden ambos talonarios afip_wsfe.get_last_number = mock.MagicMock(return_value=0) self.invoice._action_wsfe_number(self.document_book_fc_a, afip_wsfe, 001)
def test_percepcion_base_1000_5_porciento(self): partner = mock.Mock() perception = mock.Mock() rule = mock.Mock() rule.not_applicable_minimum = 400 perception.id = 1 perception.name = 'test' perception.jurisdiction = 'bs_as' perception.perception_rule_ids = [rule] r_value = {perception: 5.0} partner.get_perceptions_values = MagicMock(return_value=[r_value]) calculator = perception_calculator.PerceptionCalculator( partner, 1000, None) values = calculator.get_perceptions_values()[0] assert values['perception_id'] == perception.id assert values['base'] == 1000 assert values['amount'] == 50 assert values['name'] == perception.name assert values['jurisdiction'] == perception.jurisdiction
def test_03(self): url = 'http://127.0.0.1:8000/login/' data = { 'username': '******', 'password': '******', 'validate': 'wxym3', } mock_data = mock.Mock(return_value=data) self.run.run_main = mock_data res = self.run.run_main(url, 'POST', data) self.assertEqual(res['username'], 'LC003')