def user_login():
"""
(PUT: user)
Method to handle when a user authenticates (from Facebook), be it a new user, or recurring user
"""
fb_code = request.form.get("fb_code", None)
access_token = request.form.get("access_token", None)
if access_token is None:
access_token = get_user_access_token(fb_code, APP_ID, APP_SECRET)
fb_user_info, user = save_user(access_token, fb_code)
api_key = gen_api_key(access_token, user.id)
friends = get_friends(user, exclude_self=True)
return jsonify({"status": "ok",
"result": {
"user": {
"id": user.id,
"name": user.facebook_user.name,
},
"friends": sanify_friends(friends),
"facebook_user_id": fb_user_info["id"],
"facebook_portrait_url": "https://graph.facebook.com/%s/picture" % user.facebook_user.id,
"api_key": api_key,
}
})
def test_new_invalid_checkpoint(self):
"""
test the new_checkpoint API, with an invalid checkpoint (without expiry/price)
"""
# create/save user
authcode = "someauthcode"
test_user = self.create_facebook_test_user()
fb_info, user = save_user(test_user["access_token"], authcode)
# prep image file
image_path = join(get_resources_abs_path(), "test/images/timbre.jpg")
image_file = open(image_path, "r")
image = base64.encodestring(image_file.read())
# craft request params
data = {
"user_id": user.id,
"signature": gen_signature("put", "checkpoint", gen_api_key(user.access_token, user.id)),
"name": random_string(),
"longitude": 2.0,
"latitude": 1.0,
"description": random_string(),
"image": image,
"type:": "play",
}
# send it
response = self.client.put("/checkpoint/", data=data)
assert "Requires at least a price or expiry." in response.data
def create_saved_test_user(self):
from action.user import save_user
#create and save fb user
authcode = random_string()
test_user = self.create_facebook_test_user()
fb_info, user = save_user(test_user["access_token"], authcode)
return self.User(authcode, test_user, fb_info, user, None, None)
def test_share(self):
"""
Tests the share function in the share layer if it does work as expected
"""
#create and save facebook (test) user_a and user_b
test_user_a = self.create_facebook_test_user()
test_user_b = self.create_facebook_test_user()
fb_user_info_a, user_a = save_user(test_user_a["access_token"], "someauthcode")
fb_user_info_b, user_b = save_user(test_user_b["access_token"], "someauthcode")
make_friend_connection(user_a.facebook_user.id, user_b.facebook_user.id, user_a.access_token, user_b.access_token)
#create mock checkpoint and add it to user_a
checkpoint = add_checkpoint(*CheckpointTests.mock_checkpoint_data(user_a.id))
user_checkpoint = add_checkpoint_to_user(user_a, checkpoint)
#share checkpoint from user_a to user_b
share(user_a, user_b, user_checkpoint)
#assert
print test_user_a
def test_add_checkpoint(self):
"""
Tests the add_checkpoint() functionality by creating a mock checkpoint and saving
it to a mock user
"""
#create test user
test_fb_user = self.create_facebook_test_user()
fb_user, user = save_user(test_fb_user["access_token"], "someauthcode")
#create mock checkpoint
mock_cp_data = CheckpointTests.mock_checkpoint_data(user.id)
checkpoint = add_checkpoint(*mock_cp_data)
#asserts
assert not get_checkpoint(checkpoint.id) is None
def test_save_user(self):
#create test user with 3 friends
app_xs_token = get_app_access_token(APP_ID, APP_SECRET)
test_user = create_test_user(APP_ID, app_xs_token)
friend_1 = create_test_user(APP_ID, app_xs_token)
friend_2 = create_test_user(APP_ID, app_xs_token)
friend_3 = create_test_user(APP_ID, app_xs_token)
make_friend_connection(test_user["id"], friend_1["id"], test_user["access_token"], friend_1["access_token"])
make_friend_connection(test_user["id"], friend_2["id"], test_user["access_token"], friend_2["access_token"])
make_friend_connection(test_user["id"], friend_3["id"], test_user["access_token"], friend_3["access_token"])
fb_user_info, user = save_user(test_user["access_token"], "someauthcode")
#assert that <<User>> records are indeed created
assert not get_user_from_email(test_user["email"]) is None
#assert that <<FriendConnection>> records are made
from db import FriendConnection
assert FriendConnection.query.filter_by(fb_user_from=user.facebook_user.id).count() == 3
def test_login(self):
app_xs_token = get_app_access_token(APP_ID, APP_SECRET)
test_user = create_test_user(APP_ID, app_xs_token)
friend_1 = create_test_user(APP_ID, app_xs_token)
friend_2 = create_test_user(APP_ID, app_xs_token)
friend_3 = create_test_user(APP_ID, app_xs_token)
make_friend_connection(test_user["id"], friend_1["id"], test_user["access_token"], friend_1["access_token"])
make_friend_connection(test_user["id"], friend_2["id"], test_user["access_token"], friend_2["access_token"])
make_friend_connection(test_user["id"], friend_3["id"], test_user["access_token"], friend_3["access_token"])
#create friend_2 first
friend2_fb_user_info, friend2_user = save_user(friend_2["access_token"], "someauthcode")
data = {"access_token": test_user["access_token"]}
#login test_user
response = self.client.put("/user/?", data=data)
assert "ok" in response.data
json_resp = loads(response.data)
assert json_resp["status"] == "ok"
assert json_resp["result"]["friends"][0]["user_id"] == friend2_user.id
def test_authorization(self):
"""
tests the authorization of a rest api call
"""
#create a user
app_xs_token = get_app_access_token(APP_ID, APP_SECRET)
test_user = create_test_user(APP_ID, app_xs_token)
auth_code = "someauthcode"
fb_user_info, user = save_user(test_user["access_token"], auth_code)
user_id = user.id
api_key = gen_api_key(test_user["access_token"], user_id)
#create signature
signature = "\n".join([auth_code, "put", "checkpoint"])
encrypted_sig = hmac.new(api_key, signature)
base64_sig = base64.encodestring(encrypted_sig.hexdigest())
#using user's credentials to access new_checkpoint api
data = {"signature": base64_sig,
"user_id": user_id}
resp = self.client.put("/checkpoint/", data=data)
