def register_courier(): if request.method == 'OPTIONS': return send_allowed(['POST']) else: data = request.get_json() email = data['email'] company = data['company'] phone = data['phone'] password = data['password'] password_rep = data['password_rep'] login = data['login'] if None in [email, company, phone, password, login]: res = make_response( Document(data={ 'status': 'fail', 'message': 'Some arguments are missing :(' }).to_json(), 400) elif password != password_rep: res = make_response( Document(data={ 'status': 'fail', 'message': 'Passwords don\'t match :(' }).to_json(), 400) else: save_courier(login, email, company, phone, password) correct_data = { 'status': 'success', 'message': 'Registered successfully, now please log in' } res = make_response(Document(data=correct_data).to_json(), 201) res.headers['Content-Type'] = "application/json" return res
def test_should_append_embedded_document(): app = flask.Flask(__name__) with app.test_request_context("/entity/231"): document = Document( embedded={ "orders": Embedded( embedded={"details": Embedded(data={"details": {}})}, links=link.Collection(link.Link("foo", "www.foo.com"), link.Link("boo", "www.boo.com")), data={"total": 30}, ) }, data={"currentlyProcessing": 14}, ) expected = { "_links": {"self": {"href": flask.request.path}}, "_embedded": { "orders": { "_links": {"foo": {"href": "www.foo.com"}, "boo": {"href": "www.boo.com"}}, "_embedded": {"details": {"details": {}}}, "total": 30, } }, "currentlyProcessing": 14, } assert expected == document.to_dict()
def add_user(): if request.method == 'OPTIONS': return allowed_methods(['POST']) firstname = request.json.get('firstname') lastname = request.json.get('lastname') username = request.json.get('username') password = request.json.get('password') email = request.json.get('email') address = request.json.get('address') pl = 'ąćęłńóśźż' PL = 'ĄĆĘŁŃÓŚŹŻ' if not re.compile(f'[A-Z{PL}][a-z{pl}]+').match(firstname): return create_message_response("Invalid firstname", 400) if not re.compile(f'[A-Z{PL}][a-z{pl}]+').match(lastname): return create_message_response("Invalid lastname", 400) if not re.compile('[a-z]{3,12}').match(username): return create_message_response("Invalid username", 400) if not re.compile('.{8,}').match(password.strip()): return create_message_response("Invalid password", 400) if not re.compile( '(?:[A-Za-z0-9!#$%&\'*+/=?^_`{|}~-]+(?:\\.[A-Za-z0-9!#$%&\'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?\\.)+[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?|\\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[A-Za-z0-9-]*[A-Za-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\\])' ).match(email.strip()): return create_message_response("Invalid email", 400) if address is None: return create_message_response("Empty address", 400) if user_exists(username): return create_message_response("Username already exists", 400) if not save_user(username, firstname, lastname, address, password, email): return create_message_response("An error occurred", 500) links = [Link('next', '/auth/login')] data = {'message': 'Account created'} document = Document(data=data, links=links) return document.to_json()
def test_data_in_embedded_can_be_array(): app = flask.Flask(__name__) with app.test_request_context("/entity/231"): document = Document( embedded={ "order": Embedded( data=[ {"total": 30.00, "currency": "USD", "status": "shipped"}, {"total": 20.00, "currency": "USD", "status": "processing"}, ] ) }, data={"currentlyProcessing": 14}, ) expected = { "currentlyProcessing": 14, "_links": {"self": {"href": u"/entity/231"}}, "_embedded": { "order": [ {"total": 30.00, "currency": "USD", "status": "shipped"}, {"total": 20.00, "currency": "USD", "status": "processing"}, ] }, } assert expected == document.to_dict()
def change_status(id): if g.username != COURIER_NAME: return error("Unauthorized", "Brak dostępu.", 401) json_data = request.json if not json_data: return error("No JSON provided", "Niepoprawne żądanie, brak zawartości JSON.") status = json_data.get("status") if status not in ["label", "in transit", "delivered", "collected"]: return error("Invalid status type", "Nieprawidłowy status paczki.") package = "package:" + id if not db.hexists(package, "status"): return error("Package not found", "Nie znaleziono paczki o danym identyfikatorze.") if status != db.hget(package, "status"): sender = db.hget(package, "sender") recipient = db.hget(package, "recipient") box_id = db.hget(package, "box_id") db.publish( f"user:{sender}", f"Nowy status paczki dla adresata '{recipient}', nadanej do skrytki numer {box_id}!\nOdśwież stronę, aby zobaczyć zmiany." ) db.hset(package, "status", status) links = [Link("packages", "/courier/packages")] document = Document(data={"package": db.hgetall(package)}, links=links) return document.to_json()
def sign_in(): if request.method == "OPTIONS": return send_allowed(['GET', 'POST']) elif request.method == "GET": return render_template("login.html", user=g.user) else: data = request.get_json() login = data.get('login') password = data.get('password') if None in [login, password] or verify_user(login, password) is False: res = make_response( Document( data={ 'status': 'fail', 'message': 'Invalid credentials', 'data': data }).to_json(), 400) else: encoded_jwt = get_jwt_payload(login, 'sender') res = make_response( Document( data={ 'status': 'success', 'message': 'Logged in sucessfully!', 'token': encoded_jwt.decode() }).to_json(), 200) res.set_cookie('token', encoded_jwt.decode(), secure=True, httponly=True, path="/") res.headers['Content-Type'] = "application/json" return res
def sender_get_label(label_uuid): if request.method == 'OPTIONS': return allowed_methods(['GET', 'PUT', 'DELETE']) if g.authorization is None: return create_message_response("Unauthorized", 401) if not db.hexists(f"label:{label_uuid}", "size"): return create_message_response("Label not Found", 404) username = g.authorization.get('sub') if not g.authorization.get('role') == 'courier' or db.hget( f"label:{label_uuid}", "sender").decode() == username: return create_message_response("Label not found", 404) receiver = db.hget(f"label:{label_uuid}", "receiver").decode() size = db.hget(f"label:{label_uuid}", "size").decode() po_box_id = db.hget(f"label:{label_uuid}", "POBoxId").decode() sent = db.hget(f"label:{label_uuid}", "sent").decode() data = { "labelId": label_uuid, "username": username, "receiver": receiver, "size": size, "POBoxId": po_box_id, "sent": sent } links = [Link('self', '/labels/' + label_uuid)] document = Document(data=data, links=links) return document.to_json()
def package_create(): if g.authorization is None or g.authorization.get('role') != 'courier': return create_message_response("Unauthorized", 401) label_id = request.json.get('labelId') if not db.hexists(f"label:{label_id}", "size"): return create_message_response("Label not Found", 404) if not db.hget(f"label:{label_id}", "sent").decode() == 'false': return create_message_response("Label already sent", 400) db.hset(f"label:{label_id}", "sent", 'true') package_id = str(uuid.uuid4()) db.hset(f"package:{package_id}", "packageId", f"{package_id}") db.hset(f"package:{package_id}", "labelId", f"{label_id}") db.hset(f"package:{package_id}", "status", "IN_TRANSIT") data = { "packageId": package_id, "labelId": label_id, "status": "IN_TRANSIT" } links = [Link('self', '/packages/{id}', templated=True)] document = Document(embedded={'data': Embedded(data=data)}, links=links) return document.to_json()
def add_label(): if g.authorization is None: return create_message_response("Unauthorized", 401) sender = g.authorization.get('sub') size = request.json.get('size') addressee = request.json.get('addressee') po_box_id = request.json.get('POBoxId') if addressee is None: return create_message_response("Invalid addressee", 400) if size not in ('XS', 'S', 'M', 'L', 'XL'): return create_message_response("Invalid size", 400) if po_box_id is None: return create_message_response("Invalid PO box id", 400) label_id = uuid.uuid4() db.hset(f"label:{label_id}", "sender", f"{sender}") db.hset(f"label:{label_id}", "addressee", f"{addressee}") db.hset(f"label:{label_id}", "size", f"{size}") db.hset(f"label:{label_id}", "POBoxId", f"{po_box_id}") db.hset(f"label:{label_id}", "sent", "false") data = { "id": str(label_id), "sender": sender, "addressee": addressee, "size": size, "POBoxId": po_box_id, "sent": "false" } links = [Link('self', '/labels/' + str(label_id))] document = Document(data=data, links=links) return document.to_json()
def get_labels_by_sender(): if g.authorization is None: return create_message_response("Unauthorized", 401) username = g.authorization.get('sub') keys = db.keys(pattern='label*') data = [] label_json = {} for key in keys: sender = db.hget(key, "sender").decode() if username == sender or g.authorization.get('role') == 'courier': label_id = key.decode().split(":")[1] link = Link('self', '/labels/' + label_id) addressee = db.hget(key, "addressee").decode() size = db.hget(key, "size").decode() po_box_id = db.hget(key, "POBoxId").decode() sent = db.hget(key, "sent").decode() label_json = { "id": label_id, "sender": sender, "addressee": addressee, "size": size, "poBox": po_box_id, "sent": sent, } data.append(Embedded(data=label_json, links=[link])) links = [Link('self', '/labels/{id}', templated=True)] document = Document(embedded={'data': Embedded(data=data)}, links=links) return document.to_json()
def delete_sender_package(username, id): if username != g.get("username") or g.get("username") == COURIER_NAME: return error("Unauthorized", "Brak dostępu.", 401) is_package_sender = db.sismember(f"user_packages:{username}", f"package:{id}") if not db.hget(f"package:{id}", "recipient"): return error("Package not found", "Nie znaleziono paczki") if not is_package_sender: return error("Unauthorized", "Brak dostępu.", 401) if not db.hget(f"package:{id}", "status") == "label": return error("Package in transit cannot be deleted", "Nie można usunąć, paczka jest już w drodze.") db.srem(f"user_packages:{username}", f"package:{id}") db.delete(f"package:{id}") log("Deleted package: " + id + " from sender: " + username) links = [Link("package:create", "/sender/" + g.username + "/packages")] document = Document(data={"status": "ok"}, links=links) return document.to_json()
def login_courier(): if request.method == 'OPTIONS': return send_allowed(['POST']) else: data = request.get_json() login = data['login'] password = data['password'] if None in [login, password] or "" in [login, password]: res = make_response( Document(data={ 'status': 'fail', 'message': 'Some arguments are missing :(' }).to_json(), 400) elif verify_user(login, password, 'courier'): res_correct = { 'status': 'success', 'message': 'Logged in correctly', 'token': get_jwt_payload(login, 'courier').decode() } res = make_response(Document(data=res_correct).to_json(), 200) else: res = make_response( Document(data={ 'status': 'fail', 'message': 'Invalid credentials :(' }).to_json(), 400) res.headers['Content-Type'] = "application/json" return res
def register(): data = request.json if not data: return {"error": "No JSON provided"}, 400 names_and_errors = { "username": "******", "firstname": "imienia", "lastname": "nazwiska", "email": "adresu email", "address": "adresu", "password": "******", "password2": "potwierdzenia hasła" } errors = [] errors_pl = [] fields = {} for name in names_and_errors: fields[name] = data.get(name) if not fields[name]: errors.append("No " + name + " provided.") errors_pl.append(f"Nie podano {names_and_errors[name]}.") if fields["password"] != fields["password2"]: errors.append("Passwords does not match") errors_pl.append("Hasła nie są takie same.") if fields["username"] and not re.fullmatch(r"^[a-z]{3,20}", fields["username"]): errors.append("Username must contain only 3-20 lowercase letters") errors_pl.append( "Nazwa użytkownika musi składać się z 3-20 małych liter.") if fields["username"] and db.hexists(f"user:{fields['username']}", "password"): errors.append("Username is taken") errors_pl.append("Nazwa użytkownika jest zajęta.") if len(errors) > 0: return error(errors, errors_pl) db.hset(f"user:{fields['username']}", "firstname", fields["firstname"]) db.hset(f"user:{fields['username']}", "lastname", fields["lastname"]) db.hset(f"user:{fields['username']}", "address", fields["address"]) db.hset(f"user:{fields['username']}", "email", fields["email"]) password = fields["password"].encode() hashed = hashpw(password, gensalt(5)) db.hset(f"user:{fields['username']}", "password", hashed) db.sadd("users", fields["username"]) links = [Link("sender:login", "/sender/login")] document = Document(links=links) return document.to_json(), 201
def sign_up(): if request.method == "OPTIONS": return send_allowed(['GET', 'POST']) elif request.method == "GET": return render_template("register.html", user=g.user) else: data = request.get_json() firstname = data.get("firstname") lastname = data.get("lastname") login = data.get("login") password = data.get("password") rep_password = data.get("rep_password") email = data.get("email") address = data.get("address") if None in [firstname, lastname, login, password, email, address]: res = make_response( Document( data={ 'status': 'fail', "message": 'Invalid data -- some fields are empty.' }).to_json(), 400) elif password != rep_password: res = make_response( Document(data={ 'status': 'fail', "message": "Passwords don't match." }).to_json(), 400) elif not check_username_available(login): res = make_response( Document(data={ 'status': 'fail', 'message': 'Login taken, silly :)' }).to_json(), 400) elif save_user(firstname, lastname, email, password, login, address): res = make_response( Document( data={ 'status': 'success', 'message': 'Successfully registered. Now please log in.' }).to_json(), 201) else: res = make_response( Document( data={ 'status': 'fail', 'message': 'Did not register, unknown error happened o_O' }).to_json(), 400) res.headers['Content-Type'] = "application/json" return res
def label_delete(label_uuid): if g.authorization is None: return create_message_response("Unauthorized", 401) username = g.authorization.get('sub') if not db.hexists(f"label:{label_uuid}", "size"): return create_message_response("Label not Found", 404) if not db.hget(f"label:{label_uuid}", "sender").decode() == username: return create_message_response("Label not found", 404) db.delete(f"label:{label_uuid}") link = [Link('all', '/labels')] document = Document(embedded={'data': Embedded(data={})}, links=link) return document.to_json()
def root(): if request.method == 'OPTIONS': return allowed_methods(['GET']) links = [ Link('auth', '/auth'), Link('labels', '/sender'), Link('packages', '/packages') ] # if g.authorization is None: # links.append(Link('test', '/test')) document = Document(data={}, links=links) return document.to_json()
def before(): token = request.headers.get("Authorization", "").replace("Bearer ", "") if token is not None: try: g.authorization = decode(token, str(JWT_SECRET), algorithms=["HS256"]) except ExpiredSignatureError: links = [Link("login", "sender/login")] document = Document(links=links) return document.to_json(), 440 except Exception as e: g.authorization = {} else: g.authorization = {}
def update_parcel_status(parcel_id): try: if g.user is not {} and g.user['role'] == 'courier': if request.method == 'OPTIONS': return send_allowed(['PUT']) else: parent_link = [Link('parcel:parent', '/courier/parcels')] data = request.get_json() sender_login = data['sender'] current_parcel = db.hget(f"user:{sender_login}:parcel", f"parcel_{parcel_id}") if current_parcel is not None: db.hdel(f"user:{sender_login}:parcel", f"parcel_{parcel_id}") current_parcel = json.loads(current_parcel.decode()) current_parcel['status'] = data['status'] db.hset(f"user:{sender_login}:parcel", f"parcel_{parcel_id}", json.dumps(current_parcel)) res = make_response( Document(data={ 'status': 'success', 'message': 'Parcel updated successfully' }, links=parent_link).to_json(), 200) else: res = make_response( Document(data={ 'status': 'fail', 'message': 'Requested package not found.' }, links=parent_link).to_json(), 400) else: res = make_response( Document( data={ 'status': 'fail', 'message': 'You\'re not allowed to view this page.' }).to_json(), 401) except Exception as e: print(e) res = make_response( Document( data={ 'status': 'fail', 'message': 'You\'re not allowed to view this page.' }).to_json(), 401) res.headers['Content-Type'] = "application/json" return res
def version_detail(name): version = Version.objects.get(version=name) links = [Link(rel, url) for (rel, url) in version.binaries.items()] return Document(data={ 'version': version.version }, links=Collection(*links)).to_dict()
def package_get(package_id): if request.method == 'OPTIONS': return allowed_methods(['GET', 'PUT']) if g.authorization is None or g.authorization.get('role') == 'courier': return create_message_response("Unauthorized", 401) if not db.hexists(f"package:{package_id}", "labelId"): return create_message_response("Package not found", 404) label_id = db.hget(f"package:{package_id}", "labelId").decode() status = db.hget(f"package:{package_id}", "status").decode() data = {"packageId": package_id, "labelId": label_id, "status": status} links = [Link('self', '/packages/' + package_id)] document = Document(data=data, links=links) return document.to_json()
def send_allowed(methods): if 'OPTIONS' not in methods: methods.append("OPTIONS") response = make_response(Document().to_json(), 204) response.headers['Allow'] = ', '.join(methods) return response
def get(self, database_name, table_name): try: connection.select_db(database_name) cursor = connection.cursor() cursor.execute(f'select * from {table_name}') return Document(data={'rows': list(cursor.fetchall())}).to_dict() except Exception as e: raise InvalidUsage(str(e), 400)
def courier_packages(): if g.username != COURIER_NAME: return error("Unauthorized", "Brak dostępu.", 401) packages = [] for user in db.smembers("users"): for package_name in db.smembers(f"user_packages:{user}"): package = db.hgetall(package_name) package["id"] = package_name.replace("package:", "") package["sender"] = user packages.append(package) links = [ Link("package:update_status", "/courier/packages/{id}", templated=True) ] document = Document(data={"packages": packages}, links=links) return document.to_json()
def get_package_list(): try: if g.user is not {} and g.user['role'] == 'courier': if request.method == 'OPTIONS': return send_allowed(['GET']) else: parcel_keys = db.keys("user:*:parcel") decoded_parcels = [] links = [] for parcel_key in parcel_keys: parcel_key = parcel_key.decode() parcel_list = db.hgetall(parcel_key) for parcel in parcel_list: decoded_parcel = json.loads( parcel_list[parcel].decode("UTF-8")) sender = parcel_key.replace('user:'******'') # strip beginning sender = sender.replace(':parcel', '') # strip end decoded_parcel['sender'] = sender decoded_parcels.append(decoded_parcel) links.append( Link(f'parcel:{decoded_parcel["id"]}', f"/courier/package/{decoded_parcel['id']}")) res = make_response( Document(data={ 'status': 'success', 'parcels': decoded_parcels }, links=links).to_json(), 200) else: res = make_response( Document( data={ 'status': 'fail', 'message': 'You\'re not allowed to view this page.' }).to_json(), 401) except Exception as e: print(e) res = make_response( Document( data={ 'status': 'fail', 'message': 'You\'re not allowed to view this page.' }).to_json(), 401) res.headers['Content-Type'] = "application/json" return res
def delete(self, database_name): try: cursor = connection.cursor() cursor.execute(f'DROP DATABASE {database_name}') return Document(data={ 'message': 'Database deleted successfully' }).to_dict() except Exception as e: raise InvalidUsage(str(e), 400)
def package_update(package_id): if request.method == 'OPTIONS': return allowed_methods(['GET', 'PUT']) if g.authorization is None or g.authorization.get('role') != 'courier': return create_message_response("Unauthorized", 401) if not db.hexists(f"package:{package_id}", "labelId"): return create_message_response("Package not found", 404) status = request.json.get('status') if status not in ('IN_TRANSIT', 'DELIVERED', 'PICKED_UP'): return create_message_response("Invalid status", 400) db.hset(f"package:{package_id}", "status", status) label_id = db.hget(f"package:{package_id}", "labelId").decode() data = {"packageId": package_id, "labelId": label_id, "status": status} links = [Link('self', '/packages/' + package_id)] document = Document(data=data, links=links) return document.to_json()
def login(): json = request.json if not json: return {"error": "No JSON provided"}, 400 username = json.get("username") password = json.get("password") db_password = db.hget(f"user:{username}", "password") if not username: return error("No username provided", "Nazwa użytkownika nie może być pusta.") if not password: return error("No password provided", "Hasło nie może być puste.") if not db_password: return error("Invalid username", "Nieprawidłowa nazwa użytkownika.") if not checkpw(password.encode(), db_password.encode()): return error("Invalid password", "Nieprawidłowe hasło.") log("Logged in user " + username) payload = { "exp": datetime.utcnow() + timedelta(seconds=JWT_LIFETIME), "iat": datetime.utcnow(), "sub": username } token = encode(payload, str(JWT_SECRET), algorithm="HS256") links = [ Link("sender:dashboard", "/sender/dashboard"), Link("sender:logout", "/sender/logout") ] document = Document(data={ "status": "logged-in", "token": token }, links=links) return document.to_json()
def get(self): cursor = connection.cursor() cursor.execute('show databases') databases = list(map(lambda x: x[0], cursor.fetchall())) links = list() for database in databases: links.append(link.Link(database, f'/mysql/database/{database}')) return Document(data={ 'databases': databases }, links=link.Collection(*links)).to_dict()
def delete(self, database_name, table_name): try: connection.select_db(database_name) cursor = connection.cursor() where = request.args.get('where') cursor.execute(f'delete from {table_name} where {where}') return Document(data={ 'message': 'Rows deleted successfully' }).to_dict() except Exception as e: raise InvalidUsage(str(e), 400)
def post(self, database_name, table_name): try: connection.select_db(database_name) cursor = connection.cursor() values = request.args.get('values') cursor.execute(f"insert into {table_name} VALUES ({values})") return Document(data={ 'message': 'Row inserted successfully' }).to_dict() except Exception as e: raise InvalidUsage(str(e), 400)
def delete(self, database_name, table_name): try: connection.select_db(database_name) cursor = connection.cursor() cursor.execute(f'drop table {table_name}') return Document( data={ 'message': f'Table {table_name} dropped successfully' }).to_dict() except Exception as e: raise InvalidUsage(str(e), 400)
def post(self, database_name, table_name): try: connection.select_db(database_name) cursor = connection.cursor() description = request.args.get('description') cursor.execute(f'create table {table_name} ({description})') return Document(data={ 'message': 'Table created successfully' }).to_dict() except Exception as e: raise InvalidUsage(str(e), 400)
def test_data_in_embedded_can_be_array_of_documents(): app = flask.Flask(__name__) with app.test_request_context("/entity/231"): document = Document( embedded={ "order": Embedded( data=[ Embedded( data={"total": 30.00, "currency": "USD", "status": "shipped"}, links=link.Collection(link.Link("foo", "www.foo30.com"), link.Link("boo", "www.boo30.com")), ), Embedded( data={"total": 20.00, "currency": "USD", "status": "processing"}, links=link.Collection(link.Link("foo", "www.foo20.com"), link.Link("boo", "www.boo20.com")), ), ] ) }, data={"currentlyProcessing": 14}, ) expected = { "currentlyProcessing": 14, "_links": {"self": {"href": u"/entity/231"}}, "_embedded": { "order": [ { "_links": {"foo": {"href": "www.foo30.com"}, "boo": {"href": "www.boo30.com"}}, "total": 30.00, "currency": "USD", "status": "shipped", }, { "_links": {"foo": {"href": "www.foo20.com"}, "boo": {"href": "www.boo20.com"}}, "total": 20.00, "currency": "USD", "status": "processing", }, ] }, } assert expected == document.to_dict()
def test_data_in_embedded_can_be_array(): app = flask.Flask(__name__) with app.test_request_context('/entity/231'): document = Document( embedded={ 'order': Embedded( data=[ { 'total': 30.00, 'currency': 'USD', 'status': 'shipped' }, { 'total': 20.00, 'currency': 'USD', 'status': 'processing' } ] ) }, data={ 'currentlyProcessing': 14 } ) expected = { 'currentlyProcessing': 14, '_links': {'self': {'href': u'/entity/231'}}, '_embedded': { 'order': [{ 'total': 30.00, 'currency': 'USD', 'status': 'shipped' }, { 'total': 20.00, 'currency': 'USD', 'status': 'processing' }] } } assert expected == document.to_dict()
def test_should_append_embedded_document(): app = flask.Flask(__name__) with app.test_request_context('/entity/231'): document = Document( embedded={ 'orders': Embedded( embedded={'details': Embedded( data={'details': {}} )}, links=link.Collection( link.Link('foo', 'www.foo.com'), link.Link('boo', 'www.boo.com') ), data={'total': 30}, ) }, data={'currentlyProcessing': 14} ) expected = { '_links': { 'self': { 'href': flask.request.path } }, '_embedded': { 'orders': { '_links': { 'foo': {'href': 'www.foo.com'}, 'boo': {'href': 'www.boo.com'} }, '_embedded': { 'details': {'details': {}} }, 'total': 30, } }, 'currentlyProcessing': 14 } assert expected == document.to_dict()
def test_empty_document_to_json(): app = flask.Flask(__name__) with app.test_request_context("/foo/23"): document = Document() expected = '{"_links": {"self": {"href": "/foo/23"}}}' assert expected == document.to_json()