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_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_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_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_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_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_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_insert_image_pending(self, verify_id_token):
"""Checks for an insert of an new image.."""
# mock_user_2 has no images.
uid = mock_user_2.get("uid")
index_to_test = 2
# insert user
verify_id_token.return_value = dict(uid=uid)
response = create_user_2(self.app)
self.assertEqual(response.status_code, 200)
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=index_to_test),
data=dict(user_image=(io.BytesIO(b), "test.jpg")),
headers=dict(uid=uid),
follow_redirects=False,
content_type="multipart/form-data")
user = User.objects(uid=uid).get_or_404()
self.assertEqual(response.status_code, 200)
self.assertEqual(len(user.user_images_temp), 1)
self.assertEqual(user.user_images_temp[0].index, index_to_test)
self.assertRegex(user.user_images_temp[0].url,
"https://storage.googleapis.com.*")
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_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_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_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_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_list_requests_to_me(self, mock_send, mock_verify_id_token):
"""Should have requests list which does like me."""
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)
mock_verify_id_token.return_value = dict(uid=mock_user_3["uid"])
response_3 = create_user_3(self.app)
user_1, user_2, user_3 = \
response_1.get_json(), response_2.get_json(), response_3.get_json()
user_1, user_2, user_3 = \
User.objects.get_or_404(id=str(user_1["_id"])), \
User.objects.get_or_404(id=str(user_2["_id"])), \
User.objects.get_or_404(id=str(user_3["_id"]))
# set mock id token
mock_verify_id_token.return_value = dict(uid=user_2["uid"])
response_1 = self.app.post("/requests/user_to/{user_id}/type/{type}".format(
user_id=str(user_1["id"]), type=1),
headers=dict(uid=user_2["uid"]))
self.assertEqual(mock_send.call_count, 1)
self.assertEqual(response_1.status_code, 200)
# set mock id token
mock_verify_id_token.return_value = dict(uid=user_3["uid"])
response_2 = self.app.post("/requests/user_to/{user_id}/type/{type}".format(
user_id=str(user_1["id"]), type=1),
headers=dict(uid=user_3["uid"]))
self.assertEqual(mock_send.call_count, 2)
self.assertEqual(response_2.status_code, 200)
user = User.objects(id=str(user_1["id"])).first()
requests = user.list_requests_to_me()
request_1, request_2 = requests[0], requests[1]
self.assertEqual(len(requests), 2)
# from mock_user_2 to mock_user_1
self.assertEqual(
request_1["user_from"]["nickname"], user_2["nickname"]) # user_from
self.assertEqual(
request_1["user_to"]["nickname"], user_1["nickname"]) # user_to
# from mock_user_3 to mock_user_1
self.assertEqual(
request_2["user_from"]["nickname"], user_3["nickname"]) # user_from
self.assertEqual(
request_2["user_to"]["nickname"], user_1["nickname"]) # user_to
def test_update_request_accepted(self, mock_send, mock_verify_id_token):
"""Should have response become 1 after the update."""
# set mock time
mock_time = pendulum.datetime(2020, 5, 21, 12)
pendulum.set_test_now(mock_time)
# create 2 users
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.objects.get_or_404(id=user_1["_id"])
user_2 = User.objects.get_or_404(id=user_2["_id"])
# set mock id token
mock_verify_id_token.return_value = dict(uid=user_1["uid"])
# create a request
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(mock_send.call_count, 1)
self.assertEqual(response.status_code, 200)
req = Request.objects.first()
# update a request with response 1 (yes)
response = self.app.put(
"/requests/{rid}/response/{response}".format(
rid=req["id"], response=1),
headers=dict(uid=user_2["uid"]))
# assert request
updated_request = Request.objects.first()
self.assertEqual(response.status_code, 200)
self.assertEqual(updated_request.response, 1)
self.assertEqual(updated_request.responded_at, pendulum.now().int_timestamp)
self.assertEqual(mock_send.call_count, 2)
# chat room must be created when accepted.
conversation = Conversation.objects.first()
member_1, member_2 = conversation.participants[0], conversation.participants[1]
self.assertEqual(user_1["uid"], member_1["uid"])
self.assertEqual(user_2["uid"], member_2["uid"])
self.assertEqual(conversation.created_at, pendulum.now().int_timestamp)
def test_poke(self, mock_send, verify_id_token):
# insert user_1
verify_id_token.return_value = dict(uid=mock_user_1["uid"])
response_1 = create_user_1(self.app)
# insert user_2
verify_id_token.return_value = dict(uid=mock_user_2["uid"])
response_2 = create_user_2(self.app)
user_from = response_1.get_json()
user_from = User.objects.get_or_404(id=user_from["_id"])
user_to = response_2.get_json()
user_to = User.objects.get_or_404(id=user_to["_id"])
# user_1 pokes user_2
poke_response = self.app.post(
"/users/{uid_to}/push/poke".format(uid_to=str(user_to.id)),
headers=dict(uid=user_from["uid"]))
self.assertEqual(poke_response.status_code, 200)
self.assertEqual(mock_send.call_count, 1)
def test_update_request_declined(self, mock_send, mock_verify_id_token):
"""Should have response become 0 after the update."""
# set mock time
mock_time = pendulum.datetime(2020, 5, 21, 12)
pendulum.set_test_now(mock_time)
# create 2 users
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_from, user_to = \
response_1.get_json(), response_2.get_json()
# set mock id token
user_from = User.objects.get_or_404(id=user_from["_id"])
mock_verify_id_token.return_value = dict(uid=user_from["uid"])
# create a request
response = self.app.post("/requests/user_to/{user_id}/type/{type}".format(
user_id=user_to["_id"], type=1),
headers=dict(uid=user_from["uid"]))
req = Request.objects.first()
self.assertEqual(response.status_code, 200)
self.assertEqual(mock_send.call_count, 1) # should be called when created
# update a request with response 0 (No!)
user_from = User.objects.get_or_404(id=user_to["_id"])
response = self.app.put("/requests/{rid}/response/{response}".format(
rid=req.id, response=0),
headers=dict(uid=user_from["uid"]))
# assert
updated_request = Request.objects.first()
self.assertEqual(response.status_code, 200)
self.assertEqual(updated_request.response, 0)
self.assertEqual(mock_send.call_count, 1) # should be not called when declined
self.assertEqual(updated_request.responded_at, pendulum.now().int_timestamp)
def test_create_request_when_he_already_sent_me(
self, mock_send, mock_verify_id_token):
"""Should have the response of the request become 1."""
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)
mock_verify_id_token.return_value = dict(uid=user_2["uid"])
response = self.app.post(
"/requests/user_to/{user_id}/type/{type}".format(
user_id=str(user_1["id"]), type=1),
headers=dict(uid=user_2["uid"]))
self.assertEqual(response.status_code, 200)
self.assertEqual(mock_send.call_count, 2)
request_id = response.get_json()["_id"]
request = Request.objects.get_or_404(id=request_id)
self.assertEqual(request.response, 1)
def test_does_know_each_other2(self, mock_verify_id_token):
"""Should be True at least when one person has the others phone 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_1 = User.objects(uid=mock_user_1["uid"]).first()
user_2 = User.objects(uid=mock_user_2["uid"]).first()
Contact(owner=user_1,
phones=[user_2.phone],
last_updated_at=pendulum.now().int_timestamp).save()
does_know_1 = user_1.does_know_each_other(user_2)
does_know_2 = user_2.does_know_each_other(user_1)
self.assertEqual(does_know_1, True)
self.assertEqual(does_know_2, True)