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)