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")