def get_http_request(url, payload, method='POST', headers=None, use_proxy=False, use_proxy_auth=False, trust_env=True): try: session = Session() session.trust_env = trust_env session.proxies = Util.get_proxies() if use_proxy else None session.auth = Util.get_proxy_auth() if use_proxy_auth else None request = Request( 'POST' if method not in ('GET', 'POST') else method, url, data=payload if method == 'POST' else None, params=payload if method == 'GET' else None, headers=headers ) prepped = request.prepare() response = session.send( prepped, timeout=app.config['HTTP_REQUESTS_TIMEOUT'] ) session.close() except Exception, e: response = Response() response.raise_for_status() return response, 'Error al realizar la consulta - Motivo: {}'.format(e.message)
def test_token(self, mock_head, mock_post, mock_service_creds): # mock out the token request response the_response = Response() the_response.status_code = 200 the_response.json = MagicMock(return_value={'access_token': 'foobar'}) mock_post.return_value = the_response block = OAuthBlock() self.configure_block(block, { "key_config_file": "tests/KEY_FILE_GOES_HERE.json" }) token = block.get_access_token( 'https://www.googleapis.com/auth/analytics.readonly') self.assertEqual(token['access_token'], 'foobar') # Oauth2ServiceAccount.get_access_token is mocked, so # Oauth2ServiceAccount.parse_token_from_response(r) is never called, # and self._oauth_token is never assigned. # Need to assign it here before checking block.get_access_token_headers block._oauth_token = {'access_token': 'foobar'} self.assertEqual(block.get_access_token_headers(), { 'Authorization': 'Bearer foobar' })
def get_acacess_token_app(tenant_id,client_id,client_secret,resource): initialise() url = "https://login.windows.net/" + tenant_id + "/oauth2/token" body_data = "&grant_type=client_credentials&resource="+ resource +"&client_id="+ client_id + "&client_secret="+ urllib.quote_plus(client_secret) headers = {"Content-Type":"application/x-www-form-urlencoded"} req = Request(method="POST",url=url,data=body_data) req_prepped = req.prepare() s = Session() res = Response() res = s.send(req_prepped) access_token_det = {} if (res.status_code == 200): responseJSON = json.loads(res.content) access_token_det["details"]= responseJSON["access_token"] access_token_det["status"]="1" access_token_det["exp_time"]=responseJSON["expires_in"] access_token_det["exp_date"]=responseJSON["expires_on"] access_token_det["accessDetails"]=responseJSON else: access_token_det["details"]= str(res.status_code) + str(res.json()) access_token_det["status"]="0" return access_token_det
def parse_arrivals_from_infotrafic(line_id: int, stations: Dict[str, Station], response: requests.Response, include_unknown_stations: bool = False) -> Tuple[List[Tuple[Union[Station,str], Arrival]]]: response.raise_for_status() if response.status_code == requests.codes.ok: bs = bs4.BeautifulSoup(response.text, "html.parser") prevcolor = None datacolor = '00BFFF' routes = [] route = None tz = pytz.timezone("Europe/Bucharest") now = tzlocal.get_localzone().localize(datetime.now()).astimezone(tz).replace(second=0, microsecond=0) for row in bs.find_all("table"): if row['bgcolor'] == datacolor: if prevcolor != datacolor: route = [] routes.append(route) cols = row.find_all("b") raw_station_name = cols[1].text.strip() station = stations.get(raw_station_name, None) arrival = parse_arrival(now, line_id, station.station_id if station else -1, cols[2].text) if station is not None or include_unknown_stations: route.append((station if station is not None else raw_station_name, arrival)) prevcolor = row['bgcolor'] return routes if route else None return None
def test_get_json_data(self, gobase_get_full_response): response = Response() response._content = "not a json object" gobase_get_full_response.return_value = response with self.assertRaises(GoCdApiException): self.gobase.get_json_data(self.gobase.url)
def logged_in(self, login='******', travis_user=True): """ A context manager to do stuff, while logged in as fred. """ response = Response() response._content = json.dumps( dict(id=12345, login=login, name='Fred') ) data = Mock() data.get = Mock(return_value=response) data.access_token = GH_TOKEN true = Mock(return_value=True) if travis_user: travis_patch = patch('travis_utils.is_travis_user', true) travis_patch.start() with patch('statiki.github', Mock(spec=OAuth2Service)) as gh: gh.get_auth_session = Mock(return_value=data) try: yield self.app.get('/authorized?code="bazooka"') finally: if travis_user: travis_patch.stop() self.app.get('/logout')
def test_yahoo_get_by_date(yahoo, logger): sample = Response() sample.status_code = 200 sample._content = YAHOO_RESPONSE yahoo._get = lambda *a, **kw: sample assert yahoo.get_by_date(date.today(), "CZK", logger) == Decimal("25.959")
def _method(self, url, *args, **kwargs): success = url in self.urls content = self.urls.get(url, '') resp = Response() resp._content = content.encode('utf-8') resp.status_code = codes.ok if success else codes.not_found return resp
def stub(url): response = Response() response._content = json response.url = url response.status_code = status_code response.json = json_loads_stub(json) return response
def fake_response_handler(url=None, **kwargs): r = Response() r.status_code = 200 r.encoding = "utf-8" assert url in fake_responses, "unknown URL: " + url r._content = fake_responses[url] return r
def test_download_redownload_as_hash_mismatches(self): with open('os.snap', 'wb') as f: f.write(b'0000000') snap_content = b'1234567890' snap_sha512 = ('12b03226a6d8be9c6e8cd5e55dc6c7920caaa39df14aab92d5e' '3ea9340d1c8a4d3d0b8e4314f1f6ef131ba4bf1ceb9186ab87c' '801af0d5c95b1befb8cedae2b9') mock_details = self.mock_get.return_value mock_details.ok = True mock_details.content = json.dumps({ '_embedded': { 'clickindex:package': [{ 'download_url': 'http://localhost', 'anon_download_url': 'http://localhost', 'download_sha512': snap_sha512, }], } }).encode('utf-8') mock_snap = Response() mock_snap.status_code = 200 mock_snap._content = snap_content self.mock_get.side_effect = [mock_details, mock_snap] download('os', 'edge', 'os.snap', None, 'amd64') self.mock_logger.info.assert_has_calls([ call("Getting details for 'os'"), call("Downloading 'os'"), call("Successfully downloaded 'os'")]) self.assertTrue(os.path.exists('os.snap'))
def test_download_fails_due_to_hash_mismatch(self): snap_content = b'1234567890' mock_details = self.mock_get.return_value mock_details.ok = True mock_details.content = json.dumps({ '_embedded': { 'clickindex:package': [{ 'download_url': 'http://localhost', 'anon_download_url': 'http://localhost', 'download_sha512': '12345', }], } }).encode('utf-8') mock_snap = Response() mock_snap.status_code = 200 mock_snap._content = snap_content self.mock_get.side_effect = [mock_details, mock_snap] with self.assertRaises(RuntimeError) as raised: download('os', 'edge', 'os.snap', None, 'amd64') self.assertEqual("Failed to download 'os'", str(raised.exception)) self.mock_logger.info.assert_has_calls([ call("Getting details for 'os'"), call("Downloading 'os'")]) self.assertTrue(os.path.exists('os.snap'))
def new_response(self, response): """Convert an tornado.HTTPResponse object to a requests.Response object""" new = Response() new._content = response.body new.status_code = response.code new.headers = dict(response.headers.get_all()) return new
def handle_401(self, r: R, **kwargs): """Takes the given response and re-tries auth with a new nonce.""" if r.status_code == 401 and self.num_401_calls < 2: self.num_401_calls += 1 # Renew nonce nonce = self.new_nonce(max(self._nonce(), self.last_nonce + 1)) # Consume content and release the original connection # to allow our new request to reuse the same one. r.content r.close() prep = r.request.copy() cookies = prep._cookies requests.auth.extract_cookies_to_jar(cookies, r.request, r.raw) prep.prepare_cookies(cookies) self.auth_request(prep, nonce) _r = r.connection.send(prep, **kwargs) _r.history.append(r) _r.request = prep return _r return r
def test_upload_app_ok(self): # fake upload response mock_response = self.mock_post.return_value mock_response.ok = True mock_response.return_value = { 'success': True, 'status_url': 'http://example.com/status/', } # fake poll status response application_url = 'http://example.com/app/1' revision = '1' ok_response = Response() ok_response.status_code = 200 ok_response.encoding = 'utf-8' ok_response._content = json.dumps( {'completed': True, 'revision': revision, 'application_url': application_url}).encode('utf-8') self.mock_get.return_value = ok_response success = upload(self.binary_file.name, 'foo') self.assertTrue(success) self.assertIn( call('Application uploaded successfully (as revision {})'.format( revision)), self.mock_logger.info.call_args_list) self.assertIn(call('Please check out the application at: %s\n', application_url), self.mock_logger.info.call_args_list)
def test_get_token_with_scope(self, get_token): the_response = Response() the_response.status_code = 200 the_response.json = MagicMock(return_value={'access_token': 'foobar'}) get_token.return_value = the_response block = OAuthBlock() self.configure_block(block, {}) token = block.get_access_token( 'user', 'pass', scope='my-scope', addl_params={ 'extra': 'value' }) self.assertEqual(token['access_token'], 'foobar') self.assertEqual(block.get_access_token_headers(), { 'Authorization': 'Bearer foobar' }) get_token.assert_called_once_with( 'http://oauthbase/token', data={ 'username': '******', 'password': '******', 'scope': 'my-scope', 'grant_type': 'password', 'extra': 'value' })
def test_snap_already_downloaded(self): snap_content = b'1234567890' snap_sha512 = ('12b03226a6d8be9c6e8cd5e55dc6c7920caaa39df14aab92d5e' '3ea9340d1c8a4d3d0b8e4314f1f6ef131ba4bf1ceb9186ab87c' '801af0d5c95b1befb8cedae2b9') with open('os.snap', 'wb') as f: f.write(snap_content) mock_details = self.mock_get.return_value mock_details.ok = True mock_details.content = json.dumps({ 'download_url': 'http://localhost', 'download_sha512': snap_sha512, }).encode('utf-8') mock_snap = Response() mock_snap.status_code = 200 mock_snap._content = snap_content self.mock_get.side_effect = [mock_details, mock_snap] download('os', 'os.snap', None, 'amd64') self.mock_logger.info.assert_has_calls([ call("Getting details for 'os'"), call("Already downloaded 'os'")]) self.assertTrue(os.path.exists('os.snap'))
async def did_receive_response( self, response: requests.Response, request: Request ) -> typing.Any: response.raise_for_status() return response.json(object_hook=self.convert_to_object)
def test_add_channel_channel_already_exists(mock_staff_client, patched_users_api): """Channel already exists with that channel name""" response_409 = Response() response_409.status_code = statuses.HTTP_409_CONFLICT mock_staff_client.channels.create.return_value = response_409 title = "title" name = "name" description = "public description" channel_type = "private" input_search = Search.from_dict({"unmodified": "search"}) role = RoleFactory.create() mod = UserFactory.create() with pytest.raises(ChannelAlreadyExistsException): api.add_channel( original_search=input_search, title=title, name=name, description=description, channel_type=channel_type, program_id=role.program.id, creator_id=mod.id, ) mock_staff_client.channels.create.assert_called_once_with( title=title, name=name, description=description, channel_type=channel_type, )
def make_response(self, status_code=200, reason='OK', data=None): data = data or {} response = Response() response.status_code = status_code response.reason = reason response._content = json.dumps(data).encode('utf-8') return response
def handle(self, method, *args, **kwargs): """Log method calls to a list and return a mock response.""" MockGovDelivery.calls.append((method, args, kwargs)) response = Response() response.status_code = 200 return response
def build_response(request, status_code=200, headers={}, content='(none)'): """ Build a :class:`requests.Response` object on the basis of the passed parameters. """ response = Response() response.status_code = status_code response.reason = responses[status_code] response.headers = CaseInsensitiveDict(headers) # Pretend that we've already read from the socket response._content = content response.encoding = get_encoding_from_headers(response.headers) response.url = request.url response.raw = MockRawResponse() # Give the Response some context. response.request = request response.connection = MockConnection() return response
def test_outside_app(self): resp = Response() resp.status_code = 200 resp._content = '{"ok": true}' flexmock(urlfetch.S).should_receive('request').with_args( method='POST', url='http://services.dev.guokr.com/taskqueue.json', files=None, data={ 'appname': 'test', 'method_': 'GET', 'url_': 'http://www.g.cn', 'countdown_': 0 }).and_return(resp).once() taskqueue.add_url('http://www.g.cn') # success flexmock(urlfetch.S).should_receive('request').and_return(resp) self.assertRaises(RuntimeError, taskqueue.add_url, '/test') # fail self.assertRaises(RuntimeError, taskqueue.add, '.test_view') # fail with self.app.test_request_context('http://localhost/testxx'): flexmock(urlfetch.S).should_receive('request').with_args( method='POST', url='http://services.dev.guokr.com/taskqueue.json', files=None, data={ 'appname': 'test', 'method_': 'POST', 'url_': 'http://backends.dev.guokr.com/test.json', 'countdown_': 0 }).and_return(resp).twice() taskqueue.add_url('/test.json', method_='POST') # success taskqueue.add('.test_view', method='POST') # success
def test_raises_error_on_4XX_or_5XX_responses(self, mock_request): mock_request.__name__ = 'request' data_set = DataSet('', None) response = Response() response.status_code = 418 mock_request.return_value = response assert_raises(HTTPError, data_set.post, {'key': 'foo'})
def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None): resp = Response() resp.status_code = 200 ticket = re.findall(r"abematv-license://(.*)", request.url)[0] resp._content = self._get_videokey_from_ticket(ticket) return resp
def __init__(self): """Use response.text have performance problem, use response.html fix it. This is an issue, maybe some init charset not set, requests use chardet library to detect charset of the html content. """ ResponseLib.__init__(self)
def test_private_user(self, mock_get, mock_id, mock_auth, mock_retry): blk = InstagramSearchByUser() self.configure_block(blk, { "queries": [ "user1", "user2" ] }) blk.queries = ['1', '2'] blk._n_queries = len(blk.queries()) resp = Response() resp.status_code = 400 resp.json = Mock() resp.json.return_value = \ { 'meta': { 'error_type': 'APINotAllowedError', 'code': 400, 'error_message': 'you cannot view this resource' } } mock_get.return_value = resp paging = False self.assertEqual(0, blk._idx) blk.poll(paging) # skip to next idx because we are not retrying. self.assertEqual(1, blk._idx)
def create_response(**kw): r = Response() r._content = b'' r.status = 200 for k, v in kw.items(): setattr(r, k, v) return r
def test_retry(self, mock_get, mock_id, mock_auth, mock_retry): blk = InstagramSearchByUser() self.configure_block(blk, { "queries": [ "user1", "user2" ] }) blk.queries = ['1', '2'] blk._n_queries = len(blk.queries()) resp = Response() resp.status_code = 400 resp.json = Mock() resp.json.return_value = \ { 'meta': { 'error_type': 'WardrobeMalfunction', 'code': 400, 'error_message': "Your pants don't fit" } } mock_get.return_value = resp paging = False self.assertEqual(0, blk._idx) blk.poll(paging) # don't skip to next idx because we are retrying. self.assertEqual(0, blk._idx)
def test_reset_rabbit_connection_errors(): rabbit_manager = Mock() with patch('nameko.testing.utils.get_rabbit_connections') as connections: connections.return_value = [{ 'vhost': 'vhost_name', 'name': 'connection_name' }] # 500 error response_500 = Response() response_500.status_code = 500 error_500 = HTTPError(response=response_500) rabbit_manager.delete_connection.side_effect = error_500 with pytest.raises(HTTPError): reset_rabbit_connections("vhost_name", rabbit_manager) # 404 error response_404 = Response() response_404.status_code = 404 error_404 = HTTPError(response=response_404) rabbit_manager.delete_connection.side_effect = error_404 # does not raise reset_rabbit_connections("vhost_name", rabbit_manager)
def test_malformed_request(postmark, postmark_request): postmark_request.return_value = Response() postmark_request.return_value.status_code = 500 postmark_request.return_value._content = b"Server Error" with pytest.raises(HTTPError, matches="Server Error"): postmark.call("GET", "endpoint")
def raise_for_status(self): if hasattr(self, 'error') and self.error: raise self.error Response.raise_for_status(self)
def parse_response(self, response: requests.Response, **kwargs) -> Iterable[Mapping]: json_response = response.json() records = json_response.get("results", []) yield from records
def _assert_valid_credentials(login_response: requests.Response) -> None: if not login_response.json()['success']: raise InvalidCredentials(login_response.json()['message'])
def upload_file(self, body, key=None, metadata=None, headers=None, access_key=None, secret_key=None, queue_derive=None, verbose=None, verify=None, checksum=None, delete=None, retries=None, retries_sleep=None, debug=None, request_kwargs=None): """Upload a single file to an item. The item will be created if it does not exist. :type body: Filepath or file-like object. :param body: File or data to be uploaded. :type key: str :param key: (optional) Remote filename. :type metadata: dict :param metadata: (optional) Metadata used to create a new item. :type headers: dict :param headers: (optional) Add additional IA-S3 headers to request. :type queue_derive: bool :param queue_derive: (optional) Set to False to prevent an item from being derived after upload. :type verify: bool :param verify: (optional) Verify local MD5 checksum matches the MD5 checksum of the file received by IAS3. :type checksum: bool :param checksum: (optional) Skip based on checksum. :type delete: bool :param delete: (optional) Delete local file after the upload has been successfully verified. :type retries: int :param retries: (optional) Number of times to retry the given request if S3 returns a 503 SlowDown error. :type retries_sleep: int :param retries_sleep: (optional) Amount of time to sleep between ``retries``. :type verbose: bool :param verbose: (optional) Print progress to stdout. :type debug: bool :param debug: (optional) Set to True to print headers to stdout, and exit without sending the upload request. Usage:: >>> import internetarchive >>> item = internetarchive.Item('identifier') >>> item.upload_file('/path/to/image.jpg', ... key='photos/image1.jpg') True """ # Set defaults. headers = {} if headers is None else headers metadata = {} if metadata is None else metadata access_key = self.session.access_key if access_key is None else access_key secret_key = self.session.secret_key if secret_key is None else secret_key queue_derive = True if queue_derive is None else queue_derive verbose = False if verbose is None else verbose verify = True if verify is None else verify delete = False if delete is None else delete # Set checksum after delete. checksum = True if delete or checksum is None else checksum retries = 0 if retries is None else retries retries_sleep = 30 if retries_sleep is None else retries_sleep debug = False if debug is None else debug request_kwargs = {} if request_kwargs is None else request_kwargs md5_sum = None if not hasattr(body, 'read'): body = open(body, 'rb') size = get_file_size(body) if not headers.get('x-archive-size-hint'): headers['x-archive-size-hint'] = size # Build IA-S3 URL. key = body.name.split('/')[-1] if key is None else key base_url = '{0.session.protocol}//s3.us.archive.org/{0.identifier}'.format( self) url = '{0}/{1}'.format( base_url, urllib.parse.quote(key.lstrip('/').encode('utf-8'))) # Skip based on checksum. if checksum: md5_sum = get_md5(body) ia_file = self.get_file(key) if (not self.tasks) and (ia_file) and (ia_file.md5 == md5_sum): log.info('{f} already exists: {u}'.format(f=key, u=url)) if verbose: print(' {f} already exists, skipping.'.format(f=key)) if delete: log.info('{f} successfully uploaded to ' 'https://archive.org/download/{i}/{f} ' 'and verified, deleting ' 'local copy'.format(i=self.identifier, f=key)) os.remove(body.name) # Return an empty response object if checksums match. # TODO: Is there a better way to handle this? return Response() # require the Content-MD5 header when delete is True. if verify or delete: if not md5_sum: md5_sum = get_md5(body) headers['Content-MD5'] = md5_sum def _build_request(): body.seek(0, os.SEEK_SET) if verbose: try: chunk_size = 1048576 expected_size = size / chunk_size + 1 chunks = chunk_generator(body, chunk_size) progress_generator = progress.bar( chunks, expected_size=expected_size, label=' uploading {f}: '.format(f=key)) data = IterableToFileAdapter(progress_generator, size) except: print(' uploading {f}'.format(f=key)) data = body else: data = body request = S3Request(method='PUT', url=url, headers=headers, data=data, metadata=metadata, access_key=access_key, secret_key=secret_key, queue_derive=queue_derive) return request if debug: return _build_request() else: try: error_msg = ('s3 is overloaded, sleeping for ' '{0} seconds and retrying. ' '{1} retries left.'.format( retries_sleep, retries)) while True: if retries > 0: if self.session.s3_is_overloaded(access_key): sleep(retries_sleep) log.info(error_msg) if verbose: print(' warning: {0}'.format(error_msg), file=sys.stderr) retries -= 1 continue request = _build_request() prepared_request = request.prepare() response = self.session.send(prepared_request, stream=True, **request_kwargs) if (response.status_code == 503) and (retries > 0): log.info(error_msg) if verbose: print(' warning: {0}'.format(error_msg), file=sys.stderr) sleep(retries_sleep) retries -= 1 continue else: if response.status_code == 503: log.info( 'maximum retries exceeded, upload failed.') break response.raise_for_status() log.info('uploaded {f} to {u}'.format(f=key, u=url)) if delete and response.status_code == 200: log.info( '{f} successfully uploaded to ' 'https://archive.org/download/{i}/{f} and verified, deleting ' 'local copy'.format(i=self.identifier, f=key)) os.remove(body.name) return response except HTTPError as exc: msg = get_s3_xml_text(exc.response.content) error_msg = (' error uploading {0} to {1}, ' '{2}'.format(key, self.identifier, msg)) log.error(error_msg) if verbose: print(' error uploading {0}: {1}'.format(key, msg), file=sys.stderr) # Raise HTTPError with error message. raise type(exc)(error_msg, response=exc.response, request=exc.request)
def _check_for_captcha(login_response: requests.Response) -> None: if login_response.json().get('captcha_needed', False): raise CaptchaRequired('Captcha required')
def get_pretty_response(resp: Response) -> JsonDict: resp.encoding = 'utf-8' return json.loads(resp.text, object_hook=convert_json)
def resolve_url(url, *args, **kwargs): response = Response() response.status_code = 200 response.url = url return response
def responses(code, path=None, redirection=None, data=None, url=None, headers={'Content-Type': 'text/xml'}): response = Response() response.status_code = code if path is not None and redirection is None: with open(data_file(path), 'rb') as f: response.raw = BytesIO(f.read()) elif data is not None: response._content = data.encode('utf-8') if redirection is not None: temp = Response() temp.status_code = 301 if 'permanent' in redirection else 302 temp.url = path response.history.append(temp) response.url = redirection headers['location'] = path if url is None: if redirection is not None: url = redirection else: url = 'https://example.com/{}'.format(str(uuid4())) response.url = url response.headers = headers return response
def create_response_obj_with_header(): resp = Response() resp.headers['x-openstack-request-id'] = REQUEST_ID resp.headers['Etag'] = 'd5103bf7b26ff0310200d110da3ed186' resp.status_code = 200 return resp
def create_response_with_compute_header(): resp = Response() resp.headers['x-compute-request-id'] = FAKE_REQUEST_ID return resp
def process_response(response: Response, latest_log_id: int) -> int: for log in response.json(): check_gt(log["id"], latest_log_id) latest_log_id = log["id"] print("{} [{}]: {}".format(log["time"], log["level"], log["message"])) return latest_log_id
def mocked_request(*_, **__): mocked_resp = Response() mocked_resp.status_code = mocked_codes["codes"].pop() return mocked_resp
def mock_request(*_, **__): mocked_resp = Response() mocked_resp.status_code = HTTPNotFound.code return mocked_resp
def _get_index_id_from_response(response: Response): return response.json()['result_url'].split('/')[3]
def mesh_client_http_error(): response = Response() response.status_code = 400 response.reason = "Bad request for url" response.url = TEST_INBOX_URL return HTTPError(response=response)
def assert_status_hook(response: Response, *args, **kwargs): response.raise_for_status()
def _get_analysis_id_from_response(response: Response): return response.json()['result_url'].split('/')[2]
def get_valid_json_from_response(self, response: requests.Response): try: return response.json() except (ValueError, json.JSONDecodeError): return response.text
def send(self, request, **kwargs): """ Wraps a file, described in request, in a Response object. :param request: The PreparedRequest` being "sent". :returns: a Response object containing the file """ # Check that the method makes sense. Only support GET if request.method != "GET": raise ValueError("Invalid request method %s" % request.method) # Parse the URL url_parts = urlparse(request.url) # Reject URLs with a hostname component if url_parts.netloc and url_parts.netloc != "localhost": raise ValueError( "file: URLs with hostname components are not permitted") resp = Response() # Open the file, translate certain errors into HTTP responses # Use urllib's unquote to translate percent escapes into whatever # they actually need to be try: # Split the path on / (the URL directory separator) and decode any # % escapes in the parts path_parts = [unquote(p) for p in url_parts.path.split('/')] # If os.sep is in any of the parts, someone fed us some shenanigans. # Treat is like a missing file. if any(os.sep in p for p in path_parts): raise IOError(errno.ENOENT, os.strerror(errno.ENOENT)) # Put it the path back together # [0] will be an empty string, so stick os.sep in there to make # the path absolute path_parts[0] = os.sep path = os.path.join(*path_parts) resp.raw = open(path, "rb") except IOError as e: if e.errno == errno.EACCES: resp.status_code = 403 elif e.errno == errno.ENOENT: resp.status_code = 404 else: resp.status_code = 400 # Wrap the error message in a file-like object # The error message will be localized, try to convert the string # representation of the exception into a byte stream resp_str = str(e).encode(locale.nl_langinfo(locale.CODESET)) resp.raw = BytesIO(resp_str) resp.headers['Content-Length'] = len(resp_str) else: resp.status_code = 200 # If it's a regular file, set the Content-Length resp_stat = os.fstat(resp.raw.fileno()) if stat.S_ISREG(resp_stat.st_mode): resp.headers['Content-Length'] = resp_stat.st_size return resp
import os import mock from guessit import guessit from requests import Response import tvsort_sl.utils as utils from tvsort_sl.app import PROCESS_RUNNING from tvsort_sl.conf import get_conf_file_name from tvsort_sl.tests.test_base import tv_sort r_200 = Response() r_200.status_code = 200 r_202 = Response() r_202.status_code = 202 r_400 = Response() r_400.status_code = 400 def setup_function(_): utils.create_folder(tv_sort.settings.get('TV_PATH')) utils.create_folder(tv_sort.settings.get('DUMMY_PATH')) utils.create_folder(tv_sort.settings.get('MOVIES_PATH')) utils.create_folder(tv_sort.settings.get('UNSORTED_PATH')) def teardown_function(_): utils.delete_folder(tv_sort.settings.get('TV_PATH'), force=True) utils.delete_folder(tv_sort.settings.get('DUMMY_PATH'), force=True) utils.delete_folder(tv_sort.settings.get('MOVIES_PATH'), force=True) utils.delete_folder(tv_sort.settings.get('UNSORTED_PATH'), force=True)
def __init__(self, json_data): Response.__init__(self) self.json_data = json_data self.status_code = json_data["status_code"] self.reason = json_data["reason"] self.url = json_data["url"]
def parse_response(self, response: requests.Response, **kwargs) -> Iterable[Mapping]: """ We need to get out the nested complex data structures for further normalisation, so the transform_data method is applied. """ yield from transform_data(response.json().get("elements"))
Run these tests with tox -e test -- -k test_translation """ from pathlib import Path from unittest import mock from requests import Response from dashboard.internet_nl_dashboard.logic.internet_nl_translations import ( convert_vue_i18n_format, get_locale_content, get_po_as_dictionary_v2, load_as_po_file, translate_field) path = Path(__file__).parent # Create the desired normal response, by simply forcing the correct properties to be present. # This is probably not the way to do it, yet i found the other methods be mostly obscure. perfect_response = Response() perfect_response._content = "yolo" def file_get_contents(filepath): with open(filepath, 'r') as content_file: return content_file.read() def mocked_requests_get(*args, **kwargs): class MockResponse: def __init__(self, content, status_code): self.content = content self.status_code = status_code if args[0] == 'https://raw.githubusercontent.com/NLnetLabs/Internet.nl/master/translations/nl/main.po':
def get(self, request, format=None): snippets = ResourceExperience.objects.all() serializer = ResourceExperienceSerializer(snippets, many=True) return Response(serializer.data)
def delete(self, ctx, payload, resource_id): response = Response() response.status_code = 200 response._content = json.dumps({'profile': {'name': resource_id, 'message': 'deleted'}}).encode('utf-8') Configuration.Instance().delete_section_or_profile(resource_id) return response
def get(self, request, pk, format=None): snippet = self.get_object(pk) serializer = ResourceExperienceSerializer(snippet) return Response(serializer.data)
def delete(self, request, pk, format=None): snippet = self.get_object(pk) snippet.delete() return Response(status=status.HTTP_204_NO_CONTENT)
def get_fields(res: Response): json = res.json() return json.get("data", []), json.get("meta", {}), json.get("error", [])
def _enter_steam_guard_if_necessary(self, login_response: requests.Response) -> requests.Response: if login_response.json()['requires_twofactor']: self.one_time_code = guard.generate_one_time_code(self.shared_secret) return self._send_login_request() return login_response