def test_get_all_users(test_app):
test_user_list = MockUserListResponse().dict()
expected_status = HTTP_200_OK
attrs_to_test = [
"firstname",
"lastname",
"email",
"phonenumber",
"country",
"birthdate",
"photo",
]
responses.add(
responses.GET,
re.compile(USER_REGEX),
json=test_user_list,
status=expected_status,
)
response = test_app.get(f"{APPSERVER_URL}/users")
response_json = response.json()
assert response.status_code == expected_status
check_responses_equality(response_json, test_user_list, ["amount"])
test_users = test_user_list["users"]
response_users = response_json["users"]
for i, user in enumerate(response_users):
check_responses_equality(user, test_users[i], attrs_to_test)
def test_get_all_room_reviews(test_app):
mock_review_response = MockReviewListResponse()
test_review_list = mock_review_response.dict()
expected_status = HTTP_200_OK
attrs_to_compare = ["room_id"]
room_attrs_to_compare = [
"review", "reviewer", "reviewer_id", "room_id", "id"
]
responses.add(
responses.GET,
re.compile(REVIEW_REGEX),
json=mock_review_response.dict(),
status=expected_status,
)
response = test_app.get(
f"{APPSERVER_URL}/rooms/{test_review_list['room_id']}/reviews")
assert response.status_code == expected_status
response_json = response.json()
response_reviews = response_json["reviews"]
test_reviews = test_review_list["reviews"]
check_responses_equality(response.json(), test_review_list,
attrs_to_compare)
for i, response_review in enumerate(response_reviews):
check_responses_equality(response_review, test_reviews[i],
room_attrs_to_compare)
def test_get_all_room_photos(test_app, monkeypatch):
mock_room_photos = MockRoomPhotoList().dict()
test_room_id = mock_room_photos["room_id"]
expected_status = HTTP_200_OK
list_attrs_to_test = ["amount", "room_id"]
attrs_to_test = [
"url",
"firebase_id",
"id",
"room_id",
"created_at",
"updated_at",
]
responses.add(
responses.GET,
re.compile(POSTSERVER_ROOM_REGEX),
json=mock_room_photos,
status=expected_status,
)
room_list_response = test_app.get(f"{APPSERVER_URL}/rooms/{test_room_id}/photos")
check_responses_equality(
room_list_response.json(), mock_room_photos, list_attrs_to_test
)
for i, room_photo in enumerate(room_list_response.json()["room_photos"]):
check_responses_equality(
room_photo, mock_room_photos["room_photos"][i], attrs_to_test
)
def test_get_all_rooms(test_app):
test_room_list = MockRoomListResponse().dict()
expected_status = HTTP_200_OK
attrs_to_test = [
"title",
"description",
"type",
"owner",
"owner_uuid",
"price_per_day",
"latitude",
"longitude",
"location",
"capacity",
]
responses.add(
responses.GET,
re.compile(POSTSERVER_ROOM_REGEX),
json=test_room_list,
status=expected_status,
)
response = test_app.get(f"{APPSERVER_URL}/rooms")
assert response.status_code == expected_status
response_json = response.json()
rooms = response_json["rooms"]
test_rooms = test_room_list["rooms"]
check_responses_equality(response_json, test_room_list, ["amount"])
for i, room in enumerate(rooms):
check_responses_equality(room, test_rooms[i], attrs_to_test)
def test_delete_room_photo(test_app, monkeypatch):
test_room_photo = MockRoomPhotoUploadResponse().dict()
test_room = MockRoomResponse().dict()
test_user_id = 1
test_room_id = test_room_photo["room_id"]
expected_status = HTTP_200_OK
attrs_to_test = [
"url",
"firebase_id",
"id",
"room_id",
"created_at",
"updated_at",
]
header = {"x-access-token": "tokenrefalso"}
monkeypatch.setattr(AuthSender, "is_valid_token", lambda x: True)
monkeypatch.setattr(AuthSender, "has_permission_to_modify", lambda x, y: True)
monkeypatch.setattr(AuthSender, "get_uuid_from_token", lambda x: test_user_id)
monkeypatch.setattr(photouploader, "remove_room_photo", lambda x, y: None)
responses.add(
responses.GET,
re.compile(POSTSERVER_ROOM_REGEX),
json=test_room,
status=expected_status,
)
expected_upload_service_response = (
test_room_photo["url"],
test_room_photo["firebase_id"],
)
monkeypatch.setattr(
photouploader,
"upload_room_photo",
lambda x, y: expected_upload_service_response,
)
responses.add(
responses.POST,
re.compile(POSTSERVER_ROOM_REGEX),
json=test_room_photo,
status=HTTP_201_CREATED,
)
upload_photo(test_app, test_room_id, header)
responses.add(
responses.DELETE,
re.compile(POSTSERVER_ROOM_REGEX),
json=test_room_photo,
status=expected_status,
)
room_response = test_app.delete(
f"{APPSERVER_URL}/rooms/{test_room_id}/photos/{test_room_photo['firebase_id']}",
headers=header,
)
assert room_response.status_code == expected_status
check_responses_equality(room_response.json(), test_room_photo, attrs_to_test)
def test_post_guest_rating(test_app, monkeypatch):
test_rating = MockUserRatingResponse().dict()
payload = {"rating": test_rating["rating"]}
test_user = MockUserResponse().dict()
test_user_id = 1
expected_status = HTTP_201_CREATED
attrs_to_test = ["rating", "reviewer", "reviewer_id"]
header = {"x-access-token": "tokenrefalso"}
monkeypatch.setattr(AuthSender, "is_valid_token", lambda x: True)
monkeypatch.setattr(AuthSender, "has_permission_to_comment",
lambda x, y: True)
monkeypatch.setattr(AuthSender, "get_uuid_from_token",
lambda x: test_rating)
responses.add(
responses.GET,
re.compile(USER_REGEX),
json=test_user,
status=HTTP_200_OK,
)
responses.add(
responses.POST,
re.compile(GUEST_RATING_REGEX),
json=test_rating,
status=expected_status,
)
response = test_app.post(
f"{APPSERVER_URL}/users/{test_user_id}/guest_ratings",
json=payload,
headers=header,
)
assert response.status_code == expected_status
check_responses_equality(response.json(), test_rating, attrs_to_test)
def test_upload_room_photo(test_app, monkeypatch):
test_room_photo = MockRoomPhotoUploadResponse().dict()
test_room = MockRoomResponse().dict()
test_user_id = 1
test_room_id = test_room_photo["room_id"]
test_files = {"file": ("test_image.png", b"laimageeennnrefake")}
expected_status = HTTP_201_CREATED
attrs_to_test = [
"url",
"firebase_id",
"id",
"room_id",
"created_at",
"updated_at",
]
header = {"x-access-token": "tokenrefalso"}
expected_upload_service_response = (
test_room_photo["url"],
test_room_photo["firebase_id"],
)
monkeypatch.setattr(AuthSender, "is_valid_token", lambda x: True)
monkeypatch.setattr(AuthSender, "has_permission_to_modify", lambda x, y: True)
monkeypatch.setattr(AuthSender, "get_uuid_from_token", lambda x: test_user_id)
monkeypatch.setattr(
photouploader,
"upload_room_photo",
lambda x, y: expected_upload_service_response,
)
responses.add(
responses.GET,
re.compile(POSTSERVER_ROOM_REGEX),
json=test_room,
status=HTTP_200_OK,
)
responses.add(
responses.POST,
re.compile(POSTSERVER_ROOM_REGEX),
json=test_room_photo,
status=expected_status,
)
response = test_app.post(
f"{APPSERVER_URL}/rooms/{test_room_id}/photos", files=test_files, headers=header
)
response_json = response.json()
assert response.status_code == expected_status
check_responses_equality(response_json, test_room_photo, attrs_to_test)
def test_create_room(test_app, monkeypatch):
test_payment_room = MockPaymentRoomResponse().dict()
test_room = MockRoomResponse().dict()
test_user = MockUserResponse().dict()
test_user["id"] = test_room["owner_uuid"]
test_room["owner"] = f"{test_user['firstname']} {test_user['lastname']}"
expected_status = HTTP_201_CREATED
attrs_to_test = [
"title",
"description",
"type",
"owner",
"owner_uuid",
"price_per_day",
"latitude",
"longitude",
"location",
"capacity",
]
header = {"x-access-token": "tokenrefalso"}
monkeypatch.setattr(AuthSender, "is_valid_token", lambda x: True)
monkeypatch.setattr(AuthSender, "get_uuid_from_token",
lambda x: test_room["owner_uuid"])
responses.add(
responses.GET,
re.compile(USER_REGEX),
json=test_user,
status=HTTP_200_OK,
)
responses.add(
responses.POST,
re.compile(PAYMENT_ROOM_REGEX),
json=test_payment_room,
status=expected_status,
)
responses.add(
responses.POST,
re.compile(POSTSERVER_ROOM_REGEX),
json=test_room,
status=expected_status,
)
response = test_app.post(f"{APPSERVER_URL}/rooms",
json=test_room,
headers=header)
assert response.status_code == expected_status
check_responses_equality(response.json(), test_room, attrs_to_test)
def test_post_room_comment(test_app, monkeypatch):
test_comment = MockCommentResponse().dict()
test_comment_payload = {
"comment": test_comment["comment"],
"main_comment_id": test_comment["main_comment_id"],
}
test_room = MockRoomResponse().dict()
test_user = MockUserResponse().dict()
expected_status = HTTP_201_CREATED
attrs_to_test = [
"comment",
"commentator",
"commentator_id",
"main_comment_id",
"id",
"room_id",
]
header = {"x-access-token": "tokenrefalso"}
monkeypatch.setattr(AuthSender, "is_valid_token", lambda x: True)
monkeypatch.setattr(AuthSender, "has_permission_to_comment", lambda x, y: True)
monkeypatch.setattr(
AuthSender, "get_uuid_from_token", lambda x: test_comment["commentator_id"]
)
responses.add(
responses.GET,
re.compile(POSTSERVER_ROOM_REGEX),
json=test_room,
status=HTTP_200_OK,
)
responses.add(
responses.GET,
re.compile(USER_REGEX),
json=test_user,
status=HTTP_200_OK,
)
responses.add(
responses.POST,
re.compile(COMMENT_REGEX),
json=test_comment,
status=expected_status,
)
response = test_app.post(
f"{APPSERVER_URL}/rooms/{test_room['id']}/comments",
json=test_comment_payload,
headers=header,
)
assert response.status_code == expected_status
check_responses_equality(response.json(), test_comment, attrs_to_test)
def test_delete_room(test_app, monkeypatch):
test_room = MockRoomResponse().dict()
test_payment_room = MockPaymentRoomResponse().dict()
test_room_id = test_room["id"]
expected_status = HTTP_200_OK
attrs_to_test = [
"title",
"description",
"type",
"owner",
"owner_uuid",
"price_per_day",
"latitude",
"longitude",
"location",
"capacity",
]
header = {"x-access-token": "tokenrefalso"}
monkeypatch.setattr(AuthSender, "is_valid_token", lambda x: True)
monkeypatch.setattr(AuthSender, "has_permission_to_modify",
lambda x, y: True)
monkeypatch.setattr(AuthSender, "get_uuid_from_token",
lambda x: test_room["owner_uuid"])
responses.add(
responses.GET,
re.compile(POSTSERVER_ROOM_REGEX),
json=test_room,
status=expected_status,
)
responses.add(
responses.DELETE,
re.compile(POSTSERVER_ROOM_REGEX),
json=test_room,
status=expected_status,
)
responses.add(
responses.DELETE,
re.compile(PAYMENT_ROOM_REGEX),
json=test_payment_room,
status=expected_status,
)
response = test_app.delete(f"{APPSERVER_URL}/rooms/{test_room_id}",
headers=header)
assert response.status_code == expected_status
response_json = response.json()
check_responses_equality(response_json, test_room, attrs_to_test)
def test_get_single_host_rating(test_app):
test_rating = MockUserRatingResponse().dict()
test_user_id = 1
test_rating_id = 2
expected_status = HTTP_200_OK
attrs_to_test = ["rating", "reviewer", "reviewer_id"]
responses.add(
responses.GET,
re.compile(HOST_RATING_REGEX),
json=test_rating,
status=expected_status,
)
response = test_app.get(
f"{APPSERVER_URL}/users/{test_user_id}/host_ratings/{test_rating_id}")
assert response.status_code == expected_status
check_responses_equality(response.json(), test_rating, attrs_to_test)
def test_get_room_by_id(test_app, monkeypatch):
test_room = MockRoomResponse().dict()
test_favorite = MockFavoriteRoomResponse().dict()
test_room_id = test_room["id"]
expected_status = HTTP_200_OK
attrs_to_test = [
"title",
"description",
"type",
"owner",
"owner_uuid",
"price_per_day",
"latitude",
"longitude",
"location",
"capacity",
]
header = {"x-access-token": "tokenrefalso"}
monkeypatch.setattr(AuthSender, "is_valid_token", lambda x: True)
monkeypatch.setattr(AuthSender, "get_uuid_from_token",
lambda x: test_room["owner_uuid"])
responses.add(
responses.GET,
re.compile(POSTSERVER_ROOM_REGEX),
json=test_room,
status=expected_status,
)
responses.add(
responses.GET,
re.compile(FAVORITE_ROOM_REGEX),
json=test_favorite,
status=expected_status,
)
response = test_app.get(f"{APPSERVER_URL}/rooms/{test_room_id}",
headers=header)
assert response.status_code == expected_status
response_json = response.json()
check_responses_equality(response.json(), test_room, attrs_to_test)
assert response_json["id"] == test_room_id
def test_get_single_room_review(test_app):
test_review = MockReviewResponse().dict()
test_review_id = test_review["id"]
test_room_id = test_review["room_id"]
expected_status = HTTP_200_OK
attrs_to_test = ["review", "reviewer", "reviewer_id", "room_id", "id"]
responses.add(
responses.GET,
re.compile(REVIEW_REGEX),
json=test_review,
status=expected_status,
)
response = test_app.get(
f"{APPSERVER_URL}/rooms/{test_room_id}/reviews/{test_review_id}",
json=test_review,
)
assert response.status_code == expected_status
check_responses_equality(response.json(), test_review, attrs_to_test)
def test_get_all_user_host_ratings(test_app):
test_rating_list = MockUserRatingListResponse().dict()
test_user_id = 1
expected_status = HTTP_200_OK
attrs_to_test = ["rating", "reviewer", "reviewer_id"]
responses.add(
responses.GET,
re.compile(HOST_RATING_REGEX),
json=test_rating_list,
status=expected_status,
)
response = test_app.get(
f"{APPSERVER_URL}/users/{test_user_id}/host_ratings")
response_json = response.json()
assert response.status_code == expected_status
for i, response_rating in enumerate(response_json["ratings"]):
check_responses_equality(response_rating,
test_rating_list["ratings"][i], attrs_to_test)
def test_change_profile_picture(test_app, monkeypatch):
mock_user_response = MockUserResponse()
test_user = mock_user_response.dict()
test_user_id = 1
test_files = {"file": ("test_image.png", b"laimageeennnrefake")}
expected_status = HTTP_200_OK
attrs_to_test = [
"firstname",
"lastname",
"email",
"phonenumber",
"country",
"birthdate",
"photo",
]
header = {"x-access-token": "tokenrefalso"}
expected_image_url = test_user["photo"]
monkeypatch.setattr(AuthSender, "is_valid_token", lambda x: True)
monkeypatch.setattr(AuthSender, "has_permission_to_modify", lambda x, y: True)
monkeypatch.setattr(AuthSender, "get_uuid_from_token", lambda x: test_user_id)
monkeypatch.setattr(
photouploader, "upload_profile_photo", lambda x, y: expected_image_url
)
responses.add(
responses.PATCH,
re.compile(USER_REGEX),
json=mock_user_response.dict(),
status=expected_status,
)
response = test_app.post(
f"{APPSERVER_URL}/me/profile_picture", files=test_files, headers=header
)
assert response.status_code == expected_status
check_responses_equality(response.json(), test_user, attrs_to_test)
def test_post_room_review(test_app, monkeypatch):
test_review = MockReviewResponse().dict()
test_room = MockRoomResponse().dict()
test_user = MockUserResponse().dict()
expected_status = HTTP_201_CREATED
attrs_to_test = ["review", "reviewer", "reviewer_id", "room_id", "id"]
header = {"x-access-token": "tokenrefalso"}
monkeypatch.setattr(AuthSender, "is_valid_token", lambda x: True)
monkeypatch.setattr(AuthSender, "has_permission_to_comment",
lambda x, y: True)
monkeypatch.setattr(AuthSender, "get_uuid_from_token",
lambda x: test_review["reviewer_id"])
responses.add(
responses.GET,
re.compile(POSTSERVER_ROOM_REGEX),
json=test_room,
status=HTTP_200_OK,
)
responses.add(
responses.GET,
re.compile(USER_REGEX),
json=test_user,
status=HTTP_200_OK,
)
responses.add(
responses.POST,
re.compile(REVIEW_REGEX),
json=test_review,
status=expected_status,
)
response = test_app.post(
f"{APPSERVER_URL}/rooms/{test_room['id']}/reviews",
json=test_review,
headers=header,
)
assert response.status_code == expected_status
check_responses_equality(response.json(), test_review, attrs_to_test)
def test_create_user(test_app, monkeypatch):
test_user = MockUserResponse().dict()
test_wallet = MockPaymentWalletResponse().dict()
expected_status = HTTP_201_CREATED
attrs_to_test = [
"firstname",
"lastname",
"email",
"phonenumber",
"country",
"birthdate",
"photo",
]
header = {"x-access-token": "tokenrefalso"}
monkeypatch.setattr(AuthSender, "is_valid_token", lambda x: True)
responses.add(
responses.POST,
re.compile(AUTH_REGEX),
json={"email": test_user["email"], "uuid": test_user["id"]},
status=expected_status,
)
responses.add(
responses.POST,
re.compile(USER_REGEX),
json=test_user,
status=expected_status,
)
responses.add(
responses.POST,
re.compile(PAYMENT_WALLET_REGEX),
json=test_wallet,
status=expected_status,
)
response = test_app.post(f"{APPSERVER_URL}/users", json=test_user, headers=header)
assert response.status_code == expected_status
check_responses_equality(response.json(), test_user, attrs_to_test)
def test_edit_user(test_app, monkeypatch):
test_full_user = MockUserResponse().dict()
test_user_id = test_full_user["id"]
expected_status = HTTP_200_OK
attrs_to_test = ["firstname", "lastname", "email", "phonenumber"]
test_user = {attr: test_full_user[attr] for attr in attrs_to_test}
header = {"x-access-token": "tokenrefalso"}
monkeypatch.setattr(AuthSender, "is_valid_token", lambda x: True)
monkeypatch.setattr(AuthSender, "has_permission_to_modify", lambda x, y: True)
monkeypatch.setattr(AuthSender, "get_uuid_from_token", lambda x: test_user_id)
responses.add(
responses.PATCH,
re.compile(USER_REGEX),
json=test_full_user,
status=expected_status,
)
response = test_app.patch(
f"{APPSERVER_URL}/users/{test_user_id}", json=test_user, headers=header
)
assert response.status_code == expected_status
check_responses_equality(response.json(), test_user, attrs_to_test)
def test_get_user_by_id(test_app):
test_user = MockUserResponse().dict()
test_user_id = 1
expected_status = HTTP_200_OK
attrs_to_test = [
"firstname",
"lastname",
"email",
"phonenumber",
"country",
"birthdate",
"photo",
]
responses.add(
responses.GET,
re.compile(USER_REGEX),
json=test_user,
status=expected_status,
)
response = test_app.get(f"{APPSERVER_URL}/users/{test_user_id}")
assert response.status_code == expected_status
check_responses_equality(response.json(), test_user, attrs_to_test)
def test_get_all_room_comments(test_app):
mock_comment_response = MockCommentListResponse()
test_comment_list = mock_comment_response.dict()
expected_status = HTTP_200_OK
attrs_to_compare = ["amount", "room_id"]
room_attrs_to_compare = [
"comment",
"commentator",
"commentator_id",
"main_comment_id",
"id",
"room_id",
]
responses.add(
responses.GET,
re.compile(COMMENT_REGEX),
json=mock_comment_response.dict(),
status=expected_status,
)
response = test_app.get(
f"{APPSERVER_URL}/rooms/{test_comment_list['room_id']}/comments"
)
assert response.status_code == expected_status
response_json = response.json()
response_comments = response_json["comments"]
test_comments = test_comment_list["comments"]
check_responses_equality(response.json(), test_comment_list, attrs_to_compare)
for i, response_comment in enumerate(response_comments):
check_responses_equality(
response_comment["comment"],
test_comments[i]["comment"],
room_attrs_to_compare,
)
for j, response_answer in enumerate(response_comment["answers"]):
check_responses_equality(
response_answer, test_comments[i]["answers"][j], room_attrs_to_compare
)
