def get_events(self, sessionid): ''' Fetches the events from the gameevents service for a given sessionid. :param sessionid: ''' try: token = self.get_token() if token: #LOG.debug("Sending request for events...") #payload = {"token": token, "sessionid": sessionid} headers = {} headers["X-AUTH-TOKEN"] = token url = GAMEEVENTS_SERVICE_ENDPOINT + '/sessions/%s/events' % sessionid response = requests.get(url, headers=headers) if (response.status_code == 200): clean_response = {} try: count = int(response.headers.get( 'X-Total-Count', None)) #Load the list of responses json_response = response.json() LOG.debug(json_response) #Iterate over the responses and extract the interesting bit (gameevent key) clean_response = {} events = [] for item in json_response: events.append(item["gameevent"]) clean_response["events"] = events clean_response["count"] = count return clean_response except KeyError: #LOG.debug("Server response: %s " % myresponse["message"]) raise RequestException( "Unrecognized response from server") elif (response.status_code == 400): raise RequestException("Badly formed request.") elif (response.status_code == 401): raise RequestException("Not authorized.") else: raise RequestException( "Unknown error when trying to get token.") else: raise RequestException("Could not get a token.") except RequestException as e: LOG.error(e.args, exc_info=True) raise e except ValueError as e: LOG.error(e.args, exc_info=False) return False except Exception as e: LOG.error(e.args, exc_info=True) raise e
def initial_request_to_conductor(rc, conductor_url, conductor_req_json): """First steps in the request-redirect chain in making a call to Conductor :param rc: REST client object for calling conductor :param conductor_url: conductor's base URL to submit a placement request :param conductor_req_json: request json object to send to Conductor :return: URL to check for follow up (similar to redirects); we keep checking these till we get a result/error """ debug_log.debug("Payload to Conductor: {}".format(json.dumps(conductor_req_json))) raw_resp = rc.request(url=conductor_url, raw_response=True, method="POST", json=conductor_req_json) resp = raw_resp.json() if resp["status"] != "template": raise RequestException(response=raw_resp, request=raw_resp.request) time.sleep(10) # 10 seconds wait time to avoid being too quick! plan_url = resp["links"][0][0]["href"] debug_log.debug("Attempting to read the plan from " "the conductor provided url {}".format(plan_url)) raw_resp = rc.request(raw_response=True, url=plan_url) resp = raw_resp.json() if resp["plans"][0]["status"] in ["error"]: raise RequestException(response=raw_resp, request=raw_resp.request) return resp, raw_resp # now the caller of this will handle further follow-ups
def test_unknown_error(self, request): e = RequestException("error") e.response = MagicMock() e.response.status_code = 404 e.response.content = "Error Code" request().raise_for_status.side_effect = e self.assertRaises(TransportError, make_rest_api_call, "GET", "http://something.com/path/to/resource.txt")
def dummy_request_exception(self): e = RequestException("Web Request Exception Description") e.response = mock.MagicMock() e.request = Request(method="GET", url="SOME-URL") e.response.status_code = 400 e.response.content = "Some request exception occurred" # request().raise_for_status.side_effect = e return e
def _check_and_pack_response(self, r): # Review and use the different Error Codes from ISV API request_attrs = ('json', 'status_code', 'ok') for attr in request_attrs: if not hasattr(r, attr): raise RequestException(Message.RESPONSE_DOES_NOT_HAVE_ATTRIBUTE.format(attr, r.status_code)) if int(r.status_code) >= 299 and int(r.status_code) != 400: raise RequestException(Message.RESPONSE_ERROR.format(r.status_code, r.text))
def get_market_orders(self, instrument_id, order_type=None, offer_type=None, status=None, max_count=None): """Gets the market orders with the ability to apply filters. :param instrument_id: Instrument identifier. Use get_trader_instruments() to retrieve them. Optional. :type instrument_id: int :param order_type: Order type. Possible values OrderType.LIMIT, OrderType.MARKET and OrderType.STOP. Optional. :type order_type: OrderType :param offer_type: Offer type. Possible values OfferType.BID and OfferType.ASK. Optional. :type offer_type: OfferType :param status: Order status. A comma separated list of integers with possible values 10(Pending), 15(Failed), 20(Placed), 30(Rejected), 40(Cancelled), 50(PartiallyExecuted) and 60(Executed). Optional. :type status: string :param max_count: Maximum number of items returned. Default value is 100. Optional. :type max_count: int :returns: The list of orders. :rtype: list of dict. Each element has the following data:\n orderID (string)\n price (float)\n initialQuantity (float)\n quantity (float)\n dateCreated (string)\n offerType (int) - Possible values 1 (Bid) and 2 (Ask).\n type (int) - Possible values 1 (Limit), 2 (Market) and 3 (Stop).\n status (int) - Possible values 10 (Pending), 15 (Failed), 20 (Placed), 30 (Rejected), 40 (Cancelled), 50 (PartiallyExecuted) and 60 (Executed).\n instrumentID (int)\n trades (list of dict) :raises: RequestException """ data = {'apiID': self.api_id, 'instrumentID': instrument_id} if order_type is not None: if not isinstance(order_type, OrderType): raise ValueError('order_type must be of type OrderType') data['orderType'] = order_type.value if offer_type is not None: if not isinstance(offer_type, OfferType): raise ValueError('offer_type must be of type OfferType') data['offerType'] = offer_type.value if status is not None: data['status'] = status if max_count is not None: data['maxCount'] = max_count query_string = urlencode(data) response = requests.get(self.api_url + self.GET_MARKET_ORDERS_PATH + query_string) if response.status_code == 200: orders = response.json() for order in orders: convert_order_number_fields(order) return orders else: exception_message = 'Failed to get the market orders. {error_message}'.format( error_message=get_error_message(response)) raise RequestException(exception_message)
def invokeAPI(httpMethod, authUrl, payload, accessToken): nc = NorthApiClient() clientInfo = Constant().clientInfo() url = RestConstant.BASE_URL + clientInfo[ 'platformIp'] + ":" + clientInfo['platformPort'] + authUrl if accessToken == None: headers = {'Content-Type': 'application/json'} else: headers = { "app_key": clientInfo['appId'], "Authorization": "Bearer " + accessToken, "Content-Type": "application/json" } try: request = requests.Session() request.mount('https://', HTTPAdapter(pool_connections=10, pool_maxsize=10)) global response if httpMethod == "POST": response = requests.post(url, headers=headers, data=payload, cert=nc.cert, verify=False) elif httpMethod == "PUT": response = request.put(url, headers=headers, data=payload, cert=nc.cert, verify=False) elif httpMethod == "DELETE": response = request.delete(url, headers=headers, data=payload, cert=nc.cert, verify=False) elif httpMethod == "GET": response = request.get(url, headers=headers, params=payload, cert=nc.cert, verify=False) logging.info(url), logging.info(headers), logging.info( payload), logging.info(response.text) return response.text except ReadTimeout as e: logging.error(e) raise ReadTimeout(e) except ConnectionError as e: logging.error(e) raise ConnectionError(e) except RequestException as e: logging.error(e) raise RequestException(e) except Exception as e: logging.error(e) raise Exception(e)
def get_url_content(get: Callable, url_address: str): request_timeout = 5 try: response = get(url_address, params=(('format', 'j1'), ), timeout=request_timeout) response.raise_for_status() if response.text: # check response text is empty or not return response.text else: raise Exception("Response contains no data") except Timeout: raise Timeout(f"URL request timeout more than {request_timeout} sec") except URLRequired: raise URLRequired(f"{url_address} is an invalid URL") except ConnectionError: raise ConnectionError( "Refused connection or DNS failure etc. occurred") except HTTPError as http_err: raise HTTPError(f"HTTP error: {http_err} occurred") except RequestException as e: raise RequestException(f"There was an ambiguous exception that " f"occurred while handling request. Error: {e} ") except KeyboardInterrupt: raise KeyboardInterrupt("Script was interrupted by user")
def test_request_exception_is_wrapped(self): host = factories.HostFactory() self.mocked_api().host.get.side_effect = RequestException() self.assertRaises(ServiceBackendError, self.backend.create_host, host) self.mocked_api().host.get.side_effect = pyzabbix.ZabbixAPIException() self.assertRaises(ServiceBackendError, self.backend.create_host, host)
def get_partner_instruments(self): """Gets the available instruments for the partner. :returns: The list of instruments. :rtype: list of dict. Each element has the following data:\n id (int)\n description (string)\n name (string)\n baseCurrencyID (int) - The currency you bid for, i.e. for the Bitcoin/Euro base currency is the Bitcoin.\n quoteCurrencyID (int) - The currency you pay with, i.e. for the Bitcoin/Euro quote currency is the Euro.\n minOrderAmount (float) - The minimum order amount for an order. Every order having an amount less than that, will be rejected.\n commissionFeePercent (float) - The percent of the commission fee when trading this instrument. The value is a decimal between 0 and 1. :raises: RequestException """ data = {'apiID': self.api_id} query_string = urlencode(data) response = requests.get(self.api_url + self.GET_PARTNER_INSTRUMENTS_PATH + query_string) if response.status_code == 200: instruments = response.json() for instrument in instruments: convert_instrument_number_fields(instrument) return instruments else: exception_message = 'Failed to get the partner instruments. {error_message}'.format( error_message=get_error_message(response)) raise RequestException(exception_message)
def test_sync(self): # create classifier but don't sync the intents c = Classifier.create( self.org, self.user, BothubType.slug, "Booker", { BothubType.CONFIG_ACCESS_TOKEN: "123456789", BothubType.INTENT_URL: "https://nlp.bothub.it/info/" }, sync=False, ) with patch("requests.get") as mock_get: mock_get.return_value = MockResponse(400, '{ "error": "true" }') c.get_type().get_active_intents_from_api(c) self.assertEqual(HTTPLog.objects.filter(classifier=c).count(), 1) mock_get.side_effect = RequestException("Network is unreachable", response=MockResponse( 100, "")) c.get_type().get_active_intents_from_api(c) self.assertEqual(HTTPLog.objects.filter(classifier=c).count(), 2) with patch("requests.get") as mock_get: mock_get.return_value = MockResponse(200, INTENT_RESPONSE) intents = c.get_type().get_active_intents_from_api(c) self.assertEqual(HTTPLog.objects.filter(classifier=c).count(), 3) self.assertEqual(3, len(intents)) intent = intents[0] self.assertEqual("intent", intent.name) self.assertEqual("intent", intent.external_id)
def test_other_url_error(self): reason = Exception('Some other failure.') self.requests_mock.side_effect = RequestException(reason) tasks.fetch_manifest('url', self.upload.pk) self.check_validation( 'No manifest was found at that URL. Check the address and try ' 'again.')
def invokeAPI2(httpMethod, url, headers, payload): nc = NorthApiClient() try: request = requests.Session() request.mount('https://', HTTPAdapter(pool_connections=11, pool_maxsize=11)) global response if httpMethod == "POST": response = request.post(url, headers=headers, data=payload, cert=nc.cert, verify=False, timeout=10) logging.info(url), logging.info(headers), logging.info(payload), logging.info(response.text) return response.text except ReadTimeout as e: logging.error(e) raise ReadTimeout(e) except ConnectionError as e: logging.error(e) raise ConnectionError(e) except RequestException as e: logging.error(e) raise RequestException(e) except Exception as e: logging.error(e) raise Exception(e)
def test_get_request_exception_and_retry_and_success(self, Session): self.count = 0 request_exception = RequestException('I raise RequestException!') def exception_raiser(method, url, data, params, headers=None, allow_redirects=None): if self.count < 4: self.count += 1 raise request_exception return MagicMock(status_code=200, json=MagicMock(return_value={'success': 'True'})) Session.return_value = MagicMock(request=exception_raiser) ex = HttpExecutor('http://api.stormpath.com/v1', ('user', 'pass')) ShouldRetry = MagicMock(return_value=True) with patch('stormpath.http.HttpExecutor.should_retry', ShouldRetry): with self.assertRaises(Error): ex.get('/test') should_retry_calls = [ call(0, request_exception), call(1, request_exception), call(2, request_exception), call(3, request_exception), ] ShouldRetry.assert_has_calls(should_retry_calls)
def test_get_request_exception_and_retry_four_times(self, Session): request_exception = RequestException('I raise RequestException!') def exception_raiser(method, url, data, params, headers=None, allow_redirects=None): raise request_exception Session.return_value = MagicMock(request=exception_raiser) ex = HttpExecutor('http://api.stormpath.com/v1', ('user', 'pass')) def try_four_times(retries, status): return retries <= 3 ShouldRetry = MagicMock() ShouldRetry.side_effect = try_four_times with patch('stormpath.http.HttpExecutor.should_retry', ShouldRetry): with self.assertRaises(Error): ex.get('/test') should_retry_calls = [ call(0, request_exception), call(1, request_exception), call(2, request_exception), call(3, request_exception), call(4, request_exception) ] ShouldRetry.assert_has_calls(should_retry_calls)
def test_service_ok(mock_requests_get, fail_reason): url = "http://*****:*****@example.org" if fail_reason == "connection_error": mock_requests_get.side_effect = [RequestException(fail_reason)] expect_reason = "connection failed" elif fail_reason == "status_code": response = mock_requests_get.return_value response.ok = False response.status_code = 503 response.reason = "Service Unavailable" response.url = url expect_reason = "503: Service Unavailable" else: expect_reason = None ok, reason = status._service_ok(url) if fail_reason: assert not ok assert reason == expect_reason assert url not in reason else: assert ok assert reason is None mock_requests_get.assert_called_once_with(url)
def test_create_patient(self): """ ValueSource instances with direction set to DIRECTION_IMPORT should not be exported. """ requests = mock.Mock() requests.post.side_effect = RequestException() info = mock.Mock( updates={'sex': 'M', 'dob': '1918-07-18'}, extra_fields={}, ) case_config = copy.deepcopy(CASE_CONFIG) case_config['patient_identifiers'] = {} case_config['person_preferred_name'] = {} case_config['person_preferred_address'] = {} case_config['person_attributes'] = {} case_config['person_properties']['gender']['direction'] = DIRECTION_IMPORT case_config['person_properties']['birthdate']['direction'] = DIRECTION_EXPORT case_config = OpenmrsCaseConfig(case_config) with self.assertRaises(RequestException): create_patient(requests, info, case_config) requests.post.assert_called_with( '/ws/rest/v1/patient/', json={'person': {'birthdate': '1918-07-18'}}, raise_for_status=True, )
def test_url_timeout(self): reason = socket.timeout('too slow') self.requests_mock.side_effect = RequestException(reason) tasks.fetch_manifest('url', self.upload.pk) self.check_validation( 'No manifest was found at that URL. Check the address and try ' 'again.')
def on_task_start(self, task, config): url = config['url'] username = config['username'] password = config['password'] try: response = task.requests.send(construct_request(url, username=username, password=password)) if not response.ok: raise RequestException(str(response)) cookies = collect_cookies(response) if len(get_valid_cookies(cookies)) < 1: raise RequestException('No recognized WordPress cookies found. Perhaps username/password is invalid?') task.requests.add_cookiejar(cookies) except RequestException as err: log.error('%s', err) raise PluginError('WordPress Authentication at %s failed' % (url,))
def test_get_request_exception_and_retry_and_success(self, Session): self.count = 0 request_exception = RequestException('mocked error') successful_response = MagicMock( status_code=200, json=MagicMock(return_value={'success': 'True'})) def faker(*args, **kwargs): if self.count < 3: self.count += 1 raise request_exception return successful_response Session.return_value = MagicMock(request=faker) ex = HttpExecutor('http://api.stormpath.com/v1', ('user', 'pass')) should_retry = MagicMock(return_value=True) with patch('stormpath.http.HttpExecutor.should_retry', should_retry): resp = ex.get('/test') self.assertEqual(resp['sp_http_status'], 200) should_retry.assert_has_calls([ call(0, request_exception), call(1, request_exception), call(2, request_exception), ])
def __init__(self, mgtSvr, port=8096, user=None, passwd=None, apiKey=None, securityKey=None, asyncTimeout=3600, logging=None, scheme='http', path='client/api'): self.loglevel() #Turn off requests logs self.apiKey = apiKey self.securityKey = securityKey self.mgtSvr = mgtSvr self.port = port self.user = user self.passwd = passwd self.logging = logging self.path = path self.retries = 5 self.asyncTimeout = asyncTimeout self.auth = True if port == 8096 or \ (self.apiKey is None and self.securityKey is None): self.auth = False if scheme not in ['http', 'https']: raise RequestException("Protocol must be HTTP") self.protocol = scheme self.baseurl = "%s://%s:%d/%s"\ % (self.protocol, self.mgtSvr, self.port, self.path)
def test_channel_log(self): channel = self.create_channel("WA", "WhatsApp: 1234", "1234") exception = RequestException("Network is unreachable", response=MockResponse(100, "")) start = timezone.now() log1 = HTTPLog.create_from_exception( HTTPLog.WHATSAPP_TEMPLATES_SYNCED, "https://graph.facebook.com/v3.3/1234/message_templates", exception, start, channel=channel, ) self.login(self.admin) log_url = reverse("request_logs.httplog_read", args=[log1.id]) response = self.client.get(log_url) self.assertContains(response, "200") self.assertContains(response, "Connection Error") self.assertContains( response, "https://graph.facebook.com/v3.3/1234/message_templates") # and can't be from other org self.login(self.admin2) response = self.client.get(log_url) self.assertLoginRedirect(response)
def mocked_requests_get(*args, **kwargs): class MockResponse: def __init__(self, json_data, status_code): self.json_data = json_data self.status_code = status_code def json(self): return self.json_data with open( os.path.join(current_directory, 'http_responses/response_200.json')) as f: json_200 = json.load(f) with open( os.path.join(current_directory, 'http_responses/response_400.json')) as f: json_400 = json.load(f) print(args[0]) if args[0] == 'https://airapi.airly.eu/v2/measurements/installation?installationId=4444': return MockResponse(json_200, 200) elif args[ 0] == 'https://airapi.airly.eu/v2/measurements/installation?installationId=666': return MockResponse(json_400, 400) elif args[ 0] == 'https://airapi.airly.eu/v2/measurements/installation?installationId=888': raise RequestException() return MockResponse(None, 404)
def test_sync(self): c = Classifier.create( self.org, self.user, WitType.slug, "Booker", { WitType.CONFIG_APP_ID: "12345", WitType.CONFIG_ACCESS_TOKEN: "sesame" }, ) with patch("requests.get") as mock_get: mock_get.return_value = MockResponse(400, '{ "error": "true" }') self.assertEqual(HTTPLog.objects.filter(classifier=c).count(), 2) with self.assertRaises(Exception): c.get_type().get_active_intents_from_api(c) self.assertEqual( HTTPLog.objects.filter(classifier=c).count(), 3) mock_get.side_effect = RequestException("Network is unreachable", response=MockResponse( 100, "")) c.get_type().get_active_intents_from_api(c) self.assertEqual(HTTPLog.objects.filter(classifier=c).count(), 4) with patch("requests.get") as mock_get: mock_get.return_value = MockResponse(200, INTENT_RESPONSE) intents = c.get_type().get_active_intents_from_api(c) self.assertEqual(HTTPLog.objects.filter(classifier=c).count(), 5) self.assertEqual(2, len(intents)) car = intents[0] self.assertEqual("book_car", car.name) self.assertEqual("book_car", car.external_id)
def test_post_to_frontend_repeated_all_attempts_failed(self, mask_post_to_fe, mc_time): self.ptf.side_effect = RequestException() with pytest.raises(RequestException): self.fc._post_to_frontend_repeatedly(self.data, self.url_path) assert mc_time.sleep.called
def test_transmit_failure(self, client_mock, track_selection_reverse_mock): client_mock.get_oauth_access_token.return_value = "token", datetime.datetime.utcnow( ) client_mock_instance = client_mock.return_value client_mock_instance.send_course_import.side_effect = RequestException( 'error occurred') track_selection_reverse_mock.return_value = '/course_modes/choose/course-v1:edX+DemoX+Demo_Course/' course_exporter_mock = mock.MagicMock(courses=self.payload) course_exporter_mock.get_serialized_data_blocks.return_value = [ (json.dumps(self.payload), 2) ] course_exporter_mock.resolve_removed_courses.return_value = {} transmitter = courses.SuccessFactorsCourseTransmitter( self.enterprise_config) catalog_transmission_audit = transmitter.transmit(course_exporter_mock) client_mock_instance.send_course_import.assert_called_with( json.dumps(self.payload)) course_exporter_mock.get_serialized_data_blocks.assert_called() course_exporter_mock.resolve_removed_courses.assert_called_with({}) assert catalog_transmission_audit.enterprise_customer_uuid == self.enterprise_config.enterprise_customer.uuid assert catalog_transmission_audit.total_courses == len(self.payload) assert catalog_transmission_audit.status == '500' assert catalog_transmission_audit.error_message == 'error occurred'
def __if_status_is_not_OK_raise_error(url, response): from requests import RequestException if response.status_code != 200: raise RequestException( 'Failed to query url {} Returned status: {}'.format( url, response.status_code))
def test_extract_data(self): response_file = 'test/adapters/dcae/des_response.json' response_json = json_from_file(response_file) des_config = self.osdf_config.core['PCI']['DES'] service_id = des_config['service_id'] data = des_config['filter'] expected = response_json['result'] response = mock.MagicMock() response.status_code = 200 response.ok = True response.json.return_value = response_json self.patcher_req = patch('requests.request', return_value=response) self.Mock_req = self.patcher_req.start() self.assertEqual(expected, des.extract_data(service_id, data)) self.patcher_req.stop() response = mock.MagicMock() response.status_code = 404 response.raise_for_status.side_effect = HTTPError("404") self.patcher_req = patch('requests.request', return_value=response) self.Mock_req = self.patcher_req.start() self.assertRaises(DESException, des.extract_data, service_id, data) self.patcher_req.stop() self.patcher_req = patch('requests.request', side_effect=RequestException("error")) self.Mock_req = self.patcher_req.start() self.assertRaises(DESException, des.extract_data, service_id, data) self.patcher_req.stop()
def test_connection_error(self): reason = socket.gaierror(8, 'nodename nor servname provided') self.requests_mock.side_effect = RequestException(reason) tasks.fetch_manifest('url', self.upload.pk) self.check_validation( 'No manifest was found at that URL. Check the address and try ' 'again.')
def test_should_propagate_any_exception(self): # given mocked_request_function = Mock(side_effect=RequestException()) # when with pytest.raises(RequestException): _wrapper(mocked_request_function, "GET", "https://example.net")
def handle(self, *args, **options): ethereum_client = EthereumClientProvider() app_name = apps.get_app_config('history').verbose_name network_name = ethereum_client.get_network().name.capitalize() startup_message = f'Starting {app_name} version {__version__} on {network_name}' self.stdout.write(self.style.SUCCESS(startup_message)) if settings.SLACK_API_WEBHOOK: try: r = requests.post(settings.SLACK_API_WEBHOOK, json={'text': startup_message}) if r.ok: self.stdout.write( self.style.SUCCESS( f'Slack configured, "{startup_message}" sent')) else: raise RequestException() except RequestException as e: self.stdout.write( self.style.ERROR( f'Cannot send slack notification to webhook ' f'({settings.SLACK_API_WEBHOOK}): "{e}"')) else: self.stdout.write( self.style.SUCCESS('Slack not configured, ignoring'))
def __init__(self, status, *args, **kwargs): RequestException.__init__(self, args, kwargs) self.strerror = __STATMSG__.format(status)