def post(self, request, format=None): serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def cart_remove(request): cart = Cart(request) product = get_object_or_404(Product, id=request.data['product_id']) cart.remove(product) return Response({**request.session, 'total': cart.get_total_price()})
def add_contact_to_list(self, email: str, list_id: str) -> Response: response = Response() response.status_code = 201 return response
def _fake_resp(status_code): resp = Response() resp.status_code = status_code return resp
def cart_detail(request): cart = Cart(request) return Response({**request.session, 'total': cart.get_total_price()})
""" 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, load_as_po_file) 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 error(code: int, message: str) -> HTTPError: response = Response() response.status_code = code response.reason = message return HTTPError(f'Exception {code} {message}', response=response)
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 not in ("GET", "HEAD"): raise ValueError("Invalid request method %s" % request.method) # Parse the URL url_parts = urlparse(request.url) # Make the Windows URLs slightly nicer if is_win32 and url_parts.netloc.endswith(":"): url_parts = url_parts._replace(path="/" + url_parts.netloc + url_parts.path, netloc='') # Reject URLs with a hostname component if url_parts.netloc and url_parts.netloc not in ("localhost", ".", "..", "-"): raise ValueError( "file: URLs with hostname components are not permitted") # If the path is relative update it to be absolute if url_parts.netloc in (".", ".."): pwd = os.path.abspath(url_parts.netloc).replace(os.sep, "/") + "/" if is_win32: # prefix the path with a / in Windows pwd = "/" + pwd url_parts = url_parts._replace( path=urljoin(pwd, url_parts.path.lstrip("/"))) resp = Response() resp.url = request.url # 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: # If the netloc is - then read from stdin if url_parts.netloc == "-": if is_py3: resp.raw = sys.stdin.buffer else: resp.raw = sys.stdin # make a fake response URL, the current directory resp.url = "file://" + os.path.abspath(".").replace( os.sep, "/") + "/" else: # 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('/')] # Strip out the leading empty parts created from the leading /'s while path_parts and not path_parts[0]: path_parts.pop(0) # 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)) # Look for a drive component. If one is present, store it separately # so that a directory separator can correctly be added to the real # path, and remove any empty path parts between the drive and the path. # Assume that a part ending with : or | (legacy) is a drive. if path_parts and (path_parts[0].endswith('|') or path_parts[0].endswith(':')): path_drive = path_parts.pop(0) if path_drive.endswith('|'): path_drive = path_drive[:-1] + ':' while path_parts and not path_parts[0]: path_parts.pop(0) else: path_drive = '' # Try to put the path back together # Join the drive back in, and stick os.sep in front of the path to # make it absolute. path = path_drive + os.sep + os.path.join(*path_parts) # Check if the drive assumptions above were correct. If path_drive # is set, and os.path.splitdrive does not return a drive, it wasn't # reall a drive. Put the path together again treating path_drive # as a normal path component. if path_drive and not os.path.splitdrive(path): path = os.sep + os.path.join(path_drive, *path_parts) # Use io.open since we need to add a release_conn method, and # methods can't be added to file objects in python 2. resp.raw = io.open(path, "rb") resp.raw.release_conn = resp.raw.close except IOError as e: if e.errno == errno.EACCES: resp.status_code = codes.forbidden elif e.errno == errno.ENOENT: resp.status_code = codes.not_found else: resp.status_code = codes.bad_request # 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.getpreferredencoding(False)) resp.raw = BytesIO(resp_str) resp.headers['Content-Length'] = len(resp_str) # Add release_conn to the BytesIO object resp.raw.release_conn = resp.raw.close else: resp.status_code = codes.ok # 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
def test_submit_batch_params(dag, mocker): http_conn_id_yarn = "http_conn_id_yarn" http_conn_id_spark = "http_conn_id_spark" http_conn_id_livy = "http_conn_id_livy" timeout_minutes = 4 poll_period_sec = 5 verify_in = "yarn" op = LivyBatchOperator( file="file", proxy_user="******", class_name="class_name", arguments=["arg1", "arg2"], jars=["jar1", "jar2"], py_files=["py_file1", "py_file2"], files=["file1", "file2"], driver_memory="driver_memory", driver_cores=1, executor_memory="executor_memory", executor_cores=2, num_executors=3, archives=["archive1", "archive2"], queue="queue", name="name", conf={"key1": "val1", "key2": 2}, timeout_minutes=timeout_minutes, poll_period_sec=poll_period_sec, verify_in=verify_in, http_conn_id_livy=http_conn_id_livy, http_conn_id_spark=http_conn_id_spark, http_conn_id_yarn=http_conn_id_yarn, task_id="test_submit_batch_params", dag=dag, ) mock_response = Response() mock_response._content = b'{"id": 1}' patched_hook = mocker.patch.object(HttpHook, "run", return_value=mock_response) op.submit_batch() assert op.timeout_minutes == timeout_minutes assert op.poll_period_sec == poll_period_sec assert op.verify_in == verify_in assert op.http_conn_id_livy == http_conn_id_livy assert op.http_conn_id_spark == http_conn_id_spark assert op.http_conn_id_yarn == http_conn_id_yarn expected_json = json.loads( """{ "proxyUser": "******", "file": "file", "className": "class_name", "args": [ "arg2", "arg1" ], "pyFiles": [ "py_file1", "py_file2" ], "jars": [ "jar1", "jar2" ], "files": [ "file1", "file2" ], "driverMemory": "driver_memory", "driverCores": 1, "executorMemory": "executor_memory", "executorCores": 2, "numExecutors": 3, "archives": [ "archive1", "archive2" ], "name": "name", "queue": "queue", "conf": { "key1": "val1", "key2": 2 } }""" ) actual_args, actual_kwargs = patched_hook._call_matcher(patched_hook.call_args) actual_json = find_json_in_args(actual_args, actual_kwargs) if actual_json is None: raise AssertionError( f"Can not find JSON in HttpHook args.\n" f"Args:\n{actual_args}\n" f"KWArgs (JSON should be under 'data' key):\n{actual_kwargs}" ) else: diff = DeepDiff(actual_json, expected_json, ignore_order=True) if diff: print(f"\nDifference:\n{json.dumps(diff, indent=2)}") assert not diff
def get(self, request, pk, format=None): snippet = self.get_object(pk) serializer = DisciplinesSerializer(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(self, request, format=None): snippets = Disciplines.objects.all() serializer = DisciplinesSerializer(snippets, many=True) return Response(serializer.data)
def delete(self, request, pk, format=None): person = self.get_object(pk) person.delete() return Response(status=status.HTTP_204_NO_CONTENT)
def get(self, request, pk, format=None): person = self.get_object(pk) serializer = UserSerializer(person) return Response(serializer.data)
def get_response(self, content=b"", status_code=200): response = Response() response.status_code = status_code response._content = content response.encoding = "utf-8" return response
def _response(content): r = Response() r._content = json.dumps(content).encode() return r
def get_response(code: str, status_code: int, content: bytes) -> Response: r = Response() r.code = code r.status_code = status_code r._content = content return r
def _get_response(): response = Response() response.status_code = 200 response._content = b'Some content' return response
def get(self, request): users = User.objects.all() serializer = UserSerializer(users, many=True) return Response(serializer.data, status=status.HTTP_200_OK)
def raise_http_error(): x = Response() x.status_code = 404 x.reason = err raise HTTPError(err, response=x)
def build_response(reason=None, status_code=200, headers={}): response = Response() response.status_code = status_code response.headers = headers response.reason = reason return response
def connection_error(): x = Response() x.status_code = 500 x.reason = err raise ConnectionError(err, response=x)
def get_session_id(request): cart = Cart(request) cart.save() return Response({'session_id': cart.session.session_key})
def create_fake_response(dict_response, status_code=200): response = Response() response.status_code = status_code response._content = bytes(json.dumps(dict_response).encode('utf-8')) return response
def cart_add(request): cart = Cart(request) product = get_object_or_404(Product, id=request.data['product_id']) cart.add(product=product, quantity=request.data['quantity']) return Response({**request.session, 'total': cart.get_total_price()})
def create_response(body, status, headers=None): res = Response() res.headers = headers res._content = body res.status_code = status return res
def update_contact(self, email: str, *, birth_date: date, department: str) -> Response: response = Response() response.status_code = 200 return response
def setUp(self): self.test_resp = Response() self.test_resp = mock.MagicMock(status_code=601, url='https://fake.url.com', headers='blah')
def create_contact(self, email: str) -> Response: response = Response() response.status_code = 400 return response
def get(self, request, format=None): persons = Users.objects.all() serializer = UserSerializer(persons, many=True) return Response(serializer.data)