def test_create_thumb_down(self, verify_id_token):
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
create_user_1(self.app)
response = self.ping_to_create_post(user=mock_user_1,
title="mock_title_1",
description="test_description")
post = response.get_json()
post_id, uid = post["_id"], mock_user_1["uid"]
# create comment
response = self.app.post(
"/posts/{post_id}/comments".format(post_id=post_id),
headers=dict(uid=uid),
data=dict(comment="create_comment_test"))
comment = response.get_json()
comment_id = comment["_id"]
# thumb down.
response = self.app.post(
"/posts/{post_id}/comments/{comment_id}/thumb_down".format(
post_id=post_id, comment_id=comment_id),
headers=dict(uid=uid))
self.assertEqual(response.status_code, 200)
comment_from_db = Comment.objects.first()
user = User.objects.first()
self.assertIn(user.id, comment_from_db.thumb_down_user_ids)
def test_delete_favorite(self, send, verify_id_token):
# create mock_user_1 and post_1
create_user_1(self.app)
response = self.ping_to_create_post(user=mock_user_1,
title="mock_title_1",
description="test_description")
post = response.get_json()
pid, uid = post["_id"], mock_user_1["uid"]
# create favorite
self.app.post("/posts/{pid}/favorite".format(pid=pid),
headers=dict(uid=mock_user_1["uid"]))
# favorite must be created
post_to_verify = Post.objects.first()
favorite_user_ids = post_to_verify.favorite_user_ids
self.assertEqual(len(favorite_user_ids), 1)
# delete favorite back
self.app.delete("/posts/{pid}/favorite".format(pid=pid),
headers=dict(uid=mock_user_1["uid"]))
# favorite must be created
post_to_verify = Post.objects.first()
favorite_user_ids = post_to_verify.favorite_user_ids
self.assertEqual(len(favorite_user_ids), 0)
def test_route_list_posts(self, verify_id_token):
"""Checks to retrieve all posts properly."""
# insert user then create post
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
create_user_1(self.app)
self.ping_to_create_post(user=mock_user_1,
title="mock_title_1",
description="test_description")
# insert user then create post
verify_id_token.return_value = dict(uid=mock_user_2["uid"])
create_user_2(self.app)
self.ping_to_create_post(user=mock_user_2,
title="mock_title_2",
description="test_description")
# insert user then create post
verify_id_token.return_value = dict(uid=mock_user_3["uid"])
create_user_3(self.app)
self.ping_to_create_post(user=mock_user_3,
title="mock_title_3",
description="test_description")
response = self.app.get("/posts?page=0")
posts = response.get_json()
self.assertEqual(len(posts), 3)
def test_verify_fail_due_to_duplicate_phone(self, get_user,
verify_id_token):
class MockUser:
email = "*****@*****.**"
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
get_user.return_value = MockUser()
create_user_1(self.app)
# Create testing datetime
known = pendulum.datetime(2001, 5, 21, 12)
pendulum.set_test_now(known)
response = self.app.put("/verifications/sms",
data=dict(phone="+821022889311",
expired_at="990446400",
sms_code="291455"))
json_data = response.get_json()
self.assertEqual(json_data.get("verified"), True)
phone = json_data["phone"]
sms_code = json_data["sms_code"]
sms_token = json_data["sms_token"]
response = self.app.get(
"/users/phone/{phone}/sms_code/{sms_code}/sms_token/{sms_token}".
format(phone=phone, sms_code=sms_code, sms_token=sms_token))
json_data = response.get_json()
email, is_exists = json_data["email"], json_data["is_exists"]
self.assertEqual(email, "*****@*****.**")
self.assertEqual(is_exists, True)
def test_update_user(self, verify_id_token):
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
# insert user only with uid.
create_user_1(self.app)
updated_user = User.objects().first()
self.assertEqual(updated_user["uid"], mock_user_1["uid"])
self.assertEqual(updated_user["nickname"], mock_user_1["nickname"])
self.assertEqual(updated_user["sex"], mock_user_1["sex"])
self.assertEqual(updated_user["birthed_at"], mock_user_1["birthed_at"])
self.assertEqual(updated_user["height"], mock_user_1["height"])
self.assertEqual(updated_user["body_id"], mock_user_1["body_id"])
self.assertEqual(updated_user["occupation"], mock_user_1["occupation"])
self.assertEqual(updated_user["education"], mock_user_1["education"])
self.assertEqual(updated_user["religion_id"],
mock_user_1["religion_id"])
self.assertEqual(updated_user["drink_id"], mock_user_1["drink_id"])
self.assertEqual(updated_user["smoking_id"], mock_user_1["smoking_id"])
self.assertEqual(updated_user["blood_id"], mock_user_1["blood_id"])
self.assertEqual(updated_user["device_token"],
'cPFFTaZTQ2ivAN-bAmxNI5:APA91bFsgmm')
self.assertEqual(updated_user["introduction"],
mock_user_1["introduction"])
self.assertEqual(updated_user["last_login_at"],
mock_user_1["last_login_at"])
self.assertEqual(len(updated_user["charm_ids"]),
len(mock_user_1["charm_ids"]))
self.assertEqual(len(updated_user["ideal_type_ids"]),
len(mock_user_1["ideal_type_ids"]))
self.assertEqual(len(updated_user["interest_ids"]),
len(mock_user_1["interest_ids"]))
def test_update_image(self, verify_id_token):
"""Checks for an update of an image that already exists.."""
# mock_user_1 has images.
uid = mock_user_1.get("uid")
image_index_to_update = 2
# insert user
create_user_1(self.app)
user = User.objects.first()
user.update(user_images=[], user_images_temp=[])
# read file and send to server.
file_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"testdata/nyan.png")
with open(file_dir, "rb") as image:
file = image.read()
b = bytearray(file)
response = self.app.post(
"/users/{user_id}/user_images/{index}".format(user_id=str(
user.id),
index=0),
headers=dict(uid=uid),
data=dict(user_image=(io.BytesIO(b), "test.jpg")),
follow_redirects=False,
content_type="multipart/form-data")
response = self.app.post(
"/users/{user_id}/user_images/{index}".format(user_id=str(
user.id),
index=1),
headers=dict(uid=uid),
data=dict(user_image=(io.BytesIO(b), "test.jpg")),
follow_redirects=False,
content_type="multipart/form-data")
response = self.app.post(
"/users/{user_id}/user_images/{index}".format(user_id=str(
user.id),
index=2),
headers=dict(uid=uid),
data=dict(user_image=(io.BytesIO(b), "test.jpg")),
follow_redirects=False,
content_type="multipart/form-data")
# retrieve it again and check
user = User.objects(uid=uid).first()
user_images_temp = user.user_images_temp
updated_image_temp = user_images_temp[image_index_to_update]
original_image = mock_user_1["user_images"][image_index_to_update]
self.assertEqual(response.status_code, 200)
self.assertNotEqual(original_image["url"], updated_image_temp["url"])
self.assertEqual(user.available, False)
self.assertEqual(user.status, "OPENED")
def test_create_message(self, send, verify_id_token):
from firebase_admin import messaging
messaging.send = lambda x: x # set mock function to messaging.send
mock_time = pendulum.datetime(2020, 5, 21, 12)
pendulum.set_test_now(mock_time)
# insert user1
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
create_user_1(self.app)
# insert user2
verify_id_token.return_value = dict(uid=mock_user_2["uid"])
create_user_2(self.app)
# open chat room with user1 and user2
users = User.objects.all()
user_1, user_2 = users[0], users[1]
conversation = Conversation(
title=None,
participants=[user_1, user_2],
references=[user_1, user_2],
created_at=pendulum.now().int_timestamp).save()
first_message = "first_message 1"
second_message = "second_message 2"
# insert message_1
response = self.app.post(
"/conversations/{conversation_id}/messages/{message}".format(
conversation_id=conversation.id, message=first_message),
headers=dict(uid=user_1.uid),
content_type='application/json')
self.assertEqual(response.status_code, 200)
# insert message_2
response = self.app.post(
"/conversations/{conversation_id}/messages/{message}".format(
conversation_id=conversation.id, message=second_message),
headers=dict(uid=user_1.uid),
content_type='application/json')
self.assertEqual(response.status_code, 200)
conversation = Conversation.objects.first()
# assert embedded_messages
messages = conversation.messages
self.assertEqual(len(messages), 2)
self.assertEqual(str(messages[0].user_id), str(user_1.id))
self.assertEqual(messages[0].message, first_message)
self.assertEqual(str(messages[1].user_id), str(user_1.id))
self.assertEqual(messages[1].message, second_message)
def test_get_conversation(self, send, verify_id_token):
# insert user1
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
create_user_1(self.app)
# insert user2
verify_id_token.return_value = dict(uid=mock_user_2["uid"])
create_user_2(self.app)
# open chat room with user1 and user2
users = User.objects.all()
user_1, user_2 = users[0], users[1]
conversation = Conversation(
title=None,
participants=[user_1, user_2],
references=[user_1, user_2],
created_at=pendulum.now().int_timestamp).save()
self.app.post(
"/conversations/{conversation_id}/messages/test_message_1".format(
conversation_id=conversation.id),
headers=dict(uid=user_1.uid))
self.app.post(
"/conversations/{conversation_id}/messages/test_message_2".format(
conversation_id=conversation.id),
headers=dict(uid=user_2.uid))
self.app.post(
"/conversations/{conversation_id}/messages/test_message_3".format(
conversation_id=conversation.id),
headers=dict(uid=user_1.uid))
response = self.app.get("/conversations/{conversation_id}".format(
conversation_id=conversation.id),
headers=dict(uid=user_1.uid))
conversation: dict = response.get_json()
embedded_messages = conversation.get("messages")
# checks embedded messages
self.assertEqual(len(embedded_messages), 3)
self.assertEqual(embedded_messages[0]["message"], "test_message_1")
self.assertEqual(embedded_messages[0]["user_id"], str(user_1.id))
self.assertEqual(embedded_messages[1]["message"], "test_message_2")
self.assertEqual(embedded_messages[1]["user_id"], str(user_2.id))
self.assertEqual(embedded_messages[2]["message"], "test_message_3")
self.assertEqual(embedded_messages[2]["user_id"], str(user_1.id))
participants = conversation.get("participants")
# checks room members
self.assertEqual(participants[0]["nickname"], user_1.nickname)
self.assertEqual(participants[1]["nickname"], user_2.nickname)
def test_create_sub_comment(self, verify_id_token):
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
create_user_1(self.app)
verify_id_token.return_value = dict(uid=mock_user_2["uid"])
create_user_2(self.app)
response = self.ping_to_create_post(user=mock_user_1,
title="mock_title_1",
description="test_description")
self.assertEqual(response.status_code, 200)
post = response.get_json()
post_id = post["_id"]
# create comment
response = self.app.post(
"/posts/{post_id}/comments?comment=create_comment_test".format(
post_id=post_id),
headers=dict(uid=mock_user_1["uid"]))
self.assertEqual(response.status_code, 200)
# create sub comment
comment = Comment.objects.first()
response = self.app.post(
"/posts/{post_id}/comments".format(post_id=post_id),
headers=dict(uid=mock_user_1["uid"]),
data=dict(comment="create_sub_comment_test",
comment_id=comment.id))
self.assertEqual(response.status_code, 200)
comment_to_verify = Comment.objects.first()
sub_comment = comment_to_verify.comments[0]
self.assertTrue(comment_to_verify is not None)
self.assertEqual(len(comment_to_verify.comments), 1)
self.assertEqual(sub_comment.comment, "create_sub_comment_test")
# create sub comment2
comment = Comment.objects.first()
response = self.app.post(
"/posts/{post_id}/comments".format(post_id=post_id),
headers=dict(uid=mock_user_2["uid"]),
data=dict(comment="create_sub_comment_test2",
comment_id=comment.id))
self.assertEqual(response.status_code, 200)
comment_to_verify = Comment.objects.first()
self.assertTrue(comment_to_verify is not None)
self.assertEqual(len(comment_to_verify.comments), 2)
self.assertEqual(comment_to_verify.comments[0].comment,
"create_sub_comment_test")
self.assertEqual(comment_to_verify.comments[1].comment,
"create_sub_comment_test2")
def test_create_post(self, verify_id_token):
"""Checks to create a post properly."""
# insert user then create post
create_user_1(self.app)
response = self.ping_to_create_post(user=mock_user_1)
post = Post.objects().first()
self.assertEqual(response.status_code, 200)
self.assertEqual(post["title"], "mock_title")
self.assertEqual(post["description"], "hello world")
resources = post["resources"]
self.assertRegex(resources[0]["url"],
"https://storage.googleapis.com/.*")
self.assertRegex(resources[0]["type"], "IMAGE")
def test_verify_success(self, verify_id_token):
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
create_user_1(self.app)
# Create testing datetime
known = pendulum.datetime(2001, 5, 21, 12)
pendulum.set_test_now(known)
response = self.app.put("/verifications/sms",
data=dict(phone="+821022881234",
expired_at="990446400",
sms_code="174522"),
headers=dict(uid=mock_user_1["uid"]))
json_data = response.get_json()
self.assertEqual(json_data.get("verified"), True)
def test_issue(self, verify_id_token):
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
create_user_1(self.app)
# Create testing datetime
known = pendulum.datetime(2001, 5, 21, 12)
pendulum.set_test_now(known)
response = self.app.post("/verifications/sms",
data=dict(phone="+821022889311"))
json_data = response.get_json()
expired_at = json_data.get("expired_at")
expired_at_to_verify = pendulum.now().int_timestamp + (60 * 10)
self.assertEqual(expired_at, expired_at_to_verify)
def test_create_request(self, mock_send, mock_verify_id_token):
"""Should have a new request has been created."""
mock_verify_id_token.return_value = dict(uid=mock_user_1["uid"])
response_1 = create_user_1(self.app)
mock_verify_id_token.return_value = dict(uid=mock_user_2["uid"])
response_2 = create_user_2(self.app)
# 1: user_from, 2: user_to
user_1, user_2 = response_1.get_json(), response_2.get_json()
user_1, user_2 = User.objects.get_or_404(id=user_1["_id"]), \
User.objects.get_or_404(id=user_2["_id"])
mock_verify_id_token.return_value = dict(uid=user_1.uid)
response = self.app.post("/requests/user_to/{user_id}/type/{type}".format(
user_id=str(user_2.id), type=1),
headers=dict(uid=user_1.uid))
self.assertEqual(response.status_code, 200)
request = Request.objects.first()
self.assertEqual(request.user_from.uid, mock_user_1["uid"])
self.assertEqual(request.user_to.uid, mock_user_2["uid"])
self.assertEqual(mock_send.call_count, 1)
def test_create_duplicated_request(
self, mock_send, mock_verify_id_token):
"""Should have a bad request exception raise."""
mock_verify_id_token.return_value = dict(uid=mock_user_1["uid"])
response_1 = create_user_1(self.app)
mock_verify_id_token.return_value = dict(uid=mock_user_2["uid"])
response_2 = create_user_2(self.app)
# 1: user_from, 2: user_to
user_1, user_2 = response_1.get_json(), response_2.get_json()
user_1, user_2 = User.objects.get_or_404(id=user_1["_id"]), \
User.objects.get_or_404(id=user_2["_id"])
mock_verify_id_token.return_value = dict(uid=user_1["uid"])
response = self.app.post(
"/requests/user_to/{user_id}/type/{type}".format(
user_id=str(user_2["id"]), type=1),
headers=dict(uid=user_1["uid"]))
self.assertEqual(response.status_code, 200)
self.assertEqual(mock_send.call_count, 1)
with self.app as client:
# send duplicate one again to raise ValueError intended.
client.post(
"/requests/user_to/{user_id}/type/{type}".format(
user_id=str(user_2["id"]), type=1),
headers=dict(uid=user_1["uid"]))
self.assertRaises(exceptions.BadRequest)
self.assertEqual(mock_send.call_count, 1)
def test_list_users_within_distance(self, mock_verify_id_token):
"""There must not be recommended users because anotehr users contacts contain my number."""
mock_time = pendulum.datetime(2020, 5, 21, 12)
pendulum.set_test_now(mock_time)
# insert user_1
mock_verify_id_token.return_value = dict(uid=mock_user_1["uid"])
response_1 = create_user_1(self.app)
self.assertEqual(response_1.status_code, 200)
# insert user_2
mock_verify_id_token.return_value = dict(uid=mock_user_2["uid"])
response_2 = create_user_2(self.app)
self.assertEqual(response_2.status_code, 200)
User.objects(uid=mock_user_1["uid"]).update(available=True)
User.objects(uid=mock_user_2["uid"]).update(available=True)
user_1 = User.objects(uid=mock_user_1["uid"]).first()
user_2 = User.objects(uid=mock_user_2["uid"]).first()
Contact(owner=user_2,
phones=[user_1.phone],
last_updated_at=pendulum.now().int_timestamp).save()
response = self.app.get("/users/{user_id}/distance/10".format(
user_id=response_1.get_json().get("_id")),
headers=dict(uid=mock_user_1["uid"]),
content_type="application/json")
self.assertEqual(response.status_code, 500)
recommendation = Recommendation.objects.first()
self.assertEqual(len(recommendation.user_ids), 0)
def test_update_star_rating_score(self, mock_send, mock_verify_id_token):
# insert user_1
mock_verify_id_token.return_value = dict(uid=mock_user_1["uid"])
response = create_user_1(self.app)
self.assertEqual(response.status_code, 200)
# insert user_2
mock_verify_id_token.return_value = dict(uid=mock_user_2["uid"])
response = create_user_2(self.app)
self.assertEqual(response.status_code, 200)
# user 1 rates score to user 2
user_id = str(User.objects(uid=mock_user_2["uid"]).first().id)
response = self.app.put("/users/{user_id}/score/{score}".format(
user_id=user_id, score=5),
headers=dict(uid=mock_user_1["uid"]),
content_type="application/json")
self.assertEqual(response.status_code, 200)
rate = StarRating.objects.first()
self.assertEqual(rate.user_from.uid, mock_user_1["uid"])
self.assertEqual(rate.user_to.uid, mock_user_2["uid"])
self.assertEqual(rate.score, 5)
def test_user_images_approval(self, verify_id_token):
uid = mock_user_1.get("uid")
verify_id_token.return_value = dict(uid=uid)
response_1 = create_user_1(self.app)
user = response_1.get_json()
# read file and send to server.
file_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"testdata/nyan.png")
with open(file_dir, "rb") as image:
file = image.read()
b = bytearray(file)
response = self.app.post(
"/users/{user_id}/user_images/{index}".format(
user_id=user["_id"], index=0),
headers=dict(uid=uid),
data=dict(user_image=(io.BytesIO(b), "test.jpg")),
follow_redirects=False,
content_type="multipart/form-data")
self.assertEqual(response.status_code, 200)
response = self.app.post(
"/users/{user_id}/user_images/{index}".format(
user_id=user["_id"], index=1),
headers=dict(uid=uid),
data=dict(user_image=(io.BytesIO(b), "test.jpg")),
follow_redirects=False,
content_type="multipart/form-data")
self.assertEqual(response.status_code, 200)
response = self.app.post(
"/users/{user_id}/user_images/{index}".format(
user_id=user["_id"], index=2),
headers=dict(uid=uid),
data=dict(user_image=(io.BytesIO(b), "test.jpg")),
follow_redirects=False,
content_type="multipart/form-data")
self.assertEqual(response.status_code, 200)
# retrieve it again and check
user = User.objects(uid=uid).first()
self.assertEqual(len(user.user_images), 0)
self.assertEqual(len(user.user_images_temp), 3)
response = self.app.put(
"/users/{user_id}/status/approval".format(user_id=str(user.id)))
user = User.objects(uid=uid).first()
self.assertEqual(response.status_code, 200)
self.assertEqual(len(user.user_images), 3)
self.assertEqual(len(user.user_images_temp), 3)
for index, _ in enumerate(user.user_images):
self.assertEqual(user.user_images[index],
user.user_images_temp[index])
def test_create_request_with_free_pass_unavailable_and_no_point(
self, mock_send, mock_verify_id_token):
"""Should have a new request has been canceled."""
mock_verify_id_token.return_value = dict(uid=mock_user_1["uid"])
response_1 = create_user_1(self.app)
mock_verify_id_token.return_value = dict(uid=mock_user_2["uid"])
response_2 = create_user_2(self.app)
# 1: user_from, 2: user_to
user_1, user_2 = response_1.get_json(), response_2.get_json()
user_1, user_2 = User.objects.get_or_404(id=user_1["_id"]), \
User.objects.get_or_404(id=user_2["_id"])
mock_verify_id_token.return_value = dict(uid=user_1["uid"])
user = User.objects(uid=user_1["uid"]).first()
# unavailable tokens
user.update(free_pass_tokens=[LONG_MAX, LONG_MAX])
response = self.app.post("/requests/user_to/{user_id}/type/{type}".format(
user_id=str(user_2.id), type=1),
headers=dict(uid=user_1["uid"]))
self.assertEqual(response.status_code, 500)
self.assertEqual(mock_send.call_count, 0)
def test_get_user(self, verify_id_token):
# insert user1
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
response_1 = create_user_1(self.app)
id_1 = response_1.get_json()["_id"]
# insert user2
verify_id_token.return_value = dict(uid=mock_user_2["uid"])
response_2 = create_user_2(self.app)
id_2 = response_2.get_json()["_id"]
response_user_1 = self.app.get("/users/{uid}".format(uid=id_1))
response_user_2 = self.app.get("/users/{uid}".format(uid=id_2))
user_1 = response_user_1.get_json()
user_2 = response_user_2.get_json()
for key, value in mock_user_1.items():
if key not in [
"uid", "device_token", "user_images", "location",
"joined_at", "phone"
]:
self.assertEqual(user_1[key], value)
for key, value in mock_user_2.items():
if key not in [
"uid", "device_token", "user_images", "location",
"joined_at", "phone"
]:
self.assertEqual(user_2[key], value)
def test_list_user_posts(self, verify_id_token):
# insert user_1
response = create_user_1(self.app)
user_1 = User.objects.first()
# when nothing post found
response = self.app.get(
"/users/{user_id}/posts".format(user_id=user_1.id))
self.assertEqual(response.status_code, 200)
# insert post1
file_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"testdata/nyan.png")
with open(file_dir, "rb") as image:
b = bytearray(image.read())
self.app.post("/posts",
data=dict(title="mock_title",
description="mock_description",
post_image=(io.BytesIO(b), "test.jpg")),
headers=dict(uid=mock_user_1["uid"]),
follow_redirects=False,
content_type="multipart/form-data")
# when 1 post found
response = self.app.get(
"/users/{user_id}/posts".format(user_id=user_1.id))
posts = response.get_json()
self.assertEqual(response.status_code, 200)
self.assertEqual(posts[0]["title"], "mock_title")
self.assertEqual(posts[0]["description"], "mock_description")
resources = posts[0]["resources"]
self.assertRegex(resources[0]["url"],
"https://storage.googleapis.com/.*")
self.assertRegex(resources[0]["type"], "IMAGE")
def test_get_push_setting(self, mock_verify_id_token):
"""Should return push setting json response."""
mock_time = pendulum.datetime(2020, 5, 21, 12)
pendulum.set_test_now(mock_time)
# insert user_1
mock_verify_id_token.return_value = dict(uid=mock_user_1["uid"])
response_1 = create_user_1(self.app)
self.assertEqual(response_1.status_code, 200)
response = self.app.get("/users/{user_id}/setting/push".format(
user_id=response_1.get_json().get("_id")),
headers=dict(uid=mock_user_1["uid"]),
content_type="application/json")
data = response.get_json()
self.assertEqual(response.status_code, 200)
self.assertEqual(data.get("poke"), True)
self.assertEqual(data.get("request"), True)
self.assertEqual(data.get("comment"), True)
self.assertEqual(data.get("high_rate"), True)
self.assertEqual(data.get("match"), True)
self.assertEqual(data.get("favorite_comment"), True)
self.assertEqual(data.get("conversation"), True)
self.assertEqual(data.get("lookup"), True)
def test_create_request_with_free_pass_unavailable_but_point_available(
self, mock_send, mock_verify_id_token):
"""Should have a new request has been created."""
mock_verify_id_token.return_value = dict(uid=mock_user_1["uid"])
response_1 = create_user_1(self.app)
mock_verify_id_token.return_value = dict(uid=mock_user_2["uid"])
response_2 = create_user_2(self.app)
# 1: user_from, 2: user_to
user_1, user_2 = response_1.get_json(), response_2.get_json()
user_1, user_2 = User.objects.get_or_404(id=user_1["_id"]), \
User.objects.get_or_404(id=user_2["_id"])
mock_verify_id_token.return_value = dict(uid=user_1["uid"])
user = User.objects(uid=user_1["uid"]).first()
user.update(free_pass_tokens=[LONG_MAX, LONG_MAX])
# payment point is charged.
Payment(owner=user, type="PURCHASE", amount=10,
created_at=pendulum.now().int_timestamp).save()
point_amount = user.get_current_amount_of_point()
self.assertEqual(point_amount, 10)
response = self.app.post("/requests/user_to/{user_id}/type/{type}".format(
user_id=str(user_2.id), type=1),
headers=dict(uid=user_1["uid"]))
self.assertEqual(response.status_code, 200)
self.assertEqual(mock_send.call_count, 1)
point_amount = user.get_current_amount_of_point()
self.assertEqual(point_amount, 5)
def test_verify_failed3(self, verify_id_token):
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
create_user_1(self.app)
# Create testing datetime
known = pendulum.datetime(2001, 5, 23, 12)
pendulum.set_test_now(known)
response = self.app.put("/verifications/sms",
data=dict(phone="+821022889311",
expired_at="990446400",
sms_code="291455"),
headers=dict(uid=mock_user_1["uid"]))
json_data = response.get_json()
verified, reason = json_data["verified"], json_data["reason"]
self.assertEqual(verified, False)
self.assertEqual(reason, "SMS_CODE가 만료 되었습니다.")
def test_verify_failed2(self, verify_id_token):
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
create_user_1(self.app)
# Create testing datetime
known = pendulum.datetime(2001, 5, 21, 12)
pendulum.set_test_now(known)
response = self.app.put("/verifications/sms",
data=dict(phone="INVALID_PHONE_NUMBER",
expired_at="990446400",
sms_code="957822"),
headers=dict(uid=mock_user_1["uid"]))
json_data = response.get_json()
verified, reason = json_data["verified"], json_data["reason"]
self.assertEqual(verified, False)
self.assertEqual(reason, "유효하지 않은 SMS_CODE 입니다.")
def test_route_list_posts_with_favorite(self, send, verify_id_token):
"""Checks if the response includes favorite_user_ids but not favorite_users."""
# insert user then create post
create_user_1(self.app)
self.ping_to_create_post(user=mock_user_1,
title="mock_title_1",
description="test_description")
post = Post.objects.first()
# create favorite
self.app.post("/posts/{pid}/favorite".format(pid=post.id),
headers=dict(uid=mock_user_1["uid"]))
response = self.app.get("/posts?page=0")
posts = response.get_json()
self.assertEqual(response.status_code, 200)
self.assertEqual(len(posts[0]["favorite_user_ids"]), 1)
def test_delete_image(self, verify_id_token):
"""Checks for deletion of an image that already exists.."""
# mock_user_1 has images.
uid = mock_user_1.get("uid")
# insert user
response = create_user_1(self.app)
user = response.get_json()
# read file and send to server.
file_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"testdata/nyan.png")
with open(file_dir, "rb") as image:
file = image.read()
b = bytearray(file)
response = self.app.post(
"/users/{user_id}/user_images/{index}".format(
user_id=user["_id"], index=0),
headers=dict(uid=uid),
data=dict(user_image=(io.BytesIO(b), "test.jpg")),
follow_redirects=False,
content_type="multipart/form-data")
self.assertEqual(response.status_code, 200)
response = self.app.post(
"/users/{user_id}/user_images/{index}".format(
user_id=user["_id"], index=1),
headers=dict(uid=uid),
data=dict(user_image=(io.BytesIO(b), "test.jpg")),
follow_redirects=False,
content_type="multipart/form-data")
self.assertEqual(response.status_code, 200)
response = self.app.post(
"/users/{user_id}/user_images/{index}".format(
user_id=user["_id"], index=2),
headers=dict(uid=uid),
data=dict(user_image=(io.BytesIO(b), "test.jpg")),
follow_redirects=False,
content_type="multipart/form-data")
self.assertEqual(response.status_code, 200)
# delete user image using index.
response = self.app.delete(
"/users/{user_id}/user_images/{index}".format(user_id=user["_id"],
index=2),
headers=dict(uid=uid),
content_type="application/json")
self.assertEqual(response.status_code, 200)
user = User.objects.first()
self.assertEqual(len(user.user_images_temp), 2)
self.assertEqual(user.available, False)
self.assertEqual(user.status, "OPENED")
def test_create_comment(self, verify_id_token):
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
create_user_1(self.app)
response = self.ping_to_create_post(user=mock_user_1,
title="mock_title_1",
description="test_description")
post = response.get_json()
post_id, uid = post["_id"], mock_user_1["uid"]
response = self.app.post(
"/posts/{post_id}/comments".format(post_id=post_id),
headers=dict(uid=uid),
data=dict(comment="create_comment_test"))
self.assertEqual(response.status_code, 200)
post = Post.objects.first()
comment = post.comments[0]
self.assertTrue(comment is not None)
self.assertEqual(comment.comment, "create_comment_test")
def test_get_post(self, verify_id_token):
"""Checks to retrieve a post properly."""
# insert user then create post
create_user_1(self.app)
response = self.ping_to_create_post(user=mock_user_1,
title="mock_title",
description="test_description")
self.assertEqual(response.status_code, 200)
created_post_id = response.get_json()["_id"]
# ping to get post
response = self.app.get(
"/posts/{pid}".format(pid=str(created_post_id)))
post: dict = response.get_json()
author: dict = post["author"]
self.assertEqual(post["title"], "mock_title")
self.assertEqual(post["description"], "test_description")
resources = post["resources"]
self.assertRegex(resources[0]["url"],
"https://storage.googleapis.com.*")
self.assertRegex(resources[0]["type"], "IMAGE")
self.assertEqual(author.get("uid", None), None)
self.assertEqual(author["nickname"], mock_user_1["nickname"])
self.assertEqual(author["sex"], mock_user_1["sex"])
self.assertEqual(author["birthed_at"], mock_user_1["birthed_at"])
self.assertEqual(author["height"], mock_user_1["height"])
self.assertEqual(author["body_id"], mock_user_1["body_id"])
self.assertEqual(author["occupation"], mock_user_1["occupation"])
self.assertEqual(author["education"], mock_user_1["education"])
self.assertEqual(author["religion_id"], mock_user_1["religion_id"])
self.assertEqual(author["drink_id"], mock_user_1["drink_id"])
self.assertEqual(author["smoking_id"], mock_user_1["smoking_id"])
self.assertEqual(author["blood_id"], mock_user_1["blood_id"])
self.assertEqual(author["device_token"], mock_user_1["device_token"])
self.assertEqual(author["introduction"], mock_user_1["introduction"])
self.assertEqual(author["last_login_at"], mock_user_1["last_login_at"])
self.assertEqual(author["user_images"], [])
def test_create_favorite(self, send, verify_id_token):
# create mock_user_1 and post_1
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
create_user_1(self.app)
response = self.ping_to_create_post(user=mock_user_1,
title="mock_title_1",
description="test_description")
post = response.get_json()
pid, uid = post["_id"], mock_user_1["uid"]
# create favorite
self.app.post("/posts/{pid}/favorite".format(pid=pid),
headers=dict(uid=mock_user_1["uid"]))
# favorite must be created
post_to_verify = Post.objects.first()
favorite_user_ids = post_to_verify.favorite_user_ids
self.assertEqual(len(favorite_user_ids), 1)
# same user creates favorite again.
self.app.post("/posts/{pid}/favorite".format(pid=pid),
headers=dict(uid=mock_user_1["uid"]))
# the number should be stayed because it"s a same user.
post_to_verify = Post.objects.first()
favorite_user_ids = post_to_verify.favorite_user_ids
self.assertEqual(len(favorite_user_ids), 1)
# create mock_user_2 for reference user.
verify_id_token.return_value = dict(uid=mock_user_2["uid"])
create_user_2(self.app)
# another user creates favorite.
self.app.post("/posts/{pid}/favorite".format(pid=pid),
headers=dict(uid=mock_user_2["uid"]))
# the number should be increased because it"s an another user.
post_to_verify = Post.objects.first()
self.assertEqual(len(post_to_verify.favorite_user_ids), 2)
def test_update_registration_token(self, verify_id_token):
# insert an user
response = create_user_1(self.app)
# update the user
self.app.put("/users/device_token/{device_token}".format(
device_token="updated_registration_token_value"),
headers=dict(uid=mock_user_1["uid"]))
user_1 = User.objects(uid=mock_user_1["uid"]).first()
# registration_token must be updated.
self.assertEqual(user_1.device_token,
"updated_registration_token_value")
