def testlast_create_delete_account(self):
"""
Tests the ability to create and delete an account
"""
username = random_valid_username()
password = b"ThiIsAnpassword!2 3"
password_hash = hashlib.sha256(password).hexdigest()
email = random_valid_email()
params = {
EVENT_TYPE_STR: EVENT_CREATE_ACCOUNT_STR,
USERNAME_STR: username,
EMAIL_STR: email,
PASSWORD_HASH_STR: password_hash,
HTTP_METHOD_STR: POST_REQUEST_STR,
}
# Create the account
self.assert_no_server_error(**params)
# Username and email should be all lower
username = username.lower()
email = email.lower()
_sql = "SELECT * FROM {0} WHERE {1} LIKE %s".format(USERS_TABLE_NAME, USERNAME_STR)
# Now check that it exists in the database
try:
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(_sql, username)
result = cursor.fetchone()
except Exception as e:
raise ValueError("SQL error in testlast_create_delete_account #1: %s" % repr(e))
self.assert_true(result[USERNAME_STR] == username,
'Failure creating account in testlast_create_delete_account, result: %s, username: %s'
% (result[USERNAME_STR], username))
self.assert_true(result[EMAIL_STR] == email,
'Failure creating account in testlast_create_delete_account, result: %s, email: %s'
% (result[EMAIL_STR], email))
# Now try and delete
del params[USERNAME_STR]
params[EVENT_TYPE_STR] = EVENT_DELETE_ACCOUNT_STR
params[HTTP_METHOD_STR] = DELETE_REQUEST_STR
self.assert_no_server_error(**params)
# Now check to make sure it no longer exists in the database
try:
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(_sql, username)
result = cursor.fetchone()
except Exception as e:
raise ValueError("SQL error in testlast_create_delete_account #2: %s" % repr(e))
self.assert_true(result is None,
'Failure deleting account in testlast_create_delete_account, result: %s' % result)
def test_misc(self):
"""
Test miscellaneous things
"""
# Check that there is an error if there is no event_type in params all http methods,
# even if all other params are sent for a function
for s in IMPLEMENTED_HTTP_METHODS:
info = {'error_tup': ERROR_NO_EVENT_TYPE, USERNAME_STR: 'a', EMAIL_STR: '[email protected]',
HTTP_METHOD_STR: s}
self.assert_server_error(**info)
# Error if an unknown event type is passed for both get and post
info.update({'error_tup': ERROR_UNKNOWN_EVENT_TYPE, EVENT_TYPE_STR: "uhfn01q7hrn0dfq9und-q"})
self.assert_server_error(**info)
_sql = "SELECT * FROM {0} WHERE {1} LIKE %s".format(USERS_TABLE_NAME, USERNAME_STR)
# Check that the salt works
try:
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(_sql, TEST_ACCOUNT_VERIFIED_USERNAME)
result = cursor.fetchone()
ph1 = result[PASSWORD_HASH_STR][VERIFICATION_CODE_SIZE:]
cursor.execute(_sql, TEST_ACCOUNT_UNVERIFIED_USERNAME)
result = cursor.fetchone()
ph2 = result[PASSWORD_HASH_STR][VERIFICATION_CODE_SIZE:]
except Exception as e:
raise ValueError('Exception trying to get database: %s' % repr(e))
self.assert_true(ph1 != ph2, message="Password hashes match, salt doesn't work!")
def delete_testing_accounts():
conn = get_new_db_conn()
cursor = conn.cursor()
#cursor.execute("DELETE FROM {0} WHERE {1} LIKE %s OR {1} LIKE %s".format(USERS_TABLE_NAME, USERNAME_STR),
# [TEST_ACCOUNT_VERIFIED_USERNAME, TEST_ACCOUNT_UNVERIFIED_USERNAME])
cursor.execute("DELETE FROM {0} WHERE {1} < 0".format(
RECIPES_TABLE_NAME, RECIPE_ID_STR))
conn.commit()
def testlast_update_user_profile(self):
params = {
EVENT_TYPE_STR: EVENT_UPDATE_USER_PROFILE_STR,
HTTP_METHOD_STR: POST_REQUEST_STR,
USERNAME_STR: TEST_ACCOUNT_VERIFIED_USERNAME,
PASSWORD_HASH_STR: TEST_ACCOUNT_PASSWORD_HASH,
NEW_USERNAME_STR: '',
NEW_EMAIL_STR: '',
NUT_ALLERGY_STR: False,
GLUTEN_FREE_STR: False,
SPICINESS_LEVEL_STR: -1,
}
self.assert_server_handles_invalid_inputs(**params)
# Test cant change username/email to ones that already exist
params[NEW_USERNAME_STR] = TEST_ACCOUNT_UNVERIFIED_USERNAME
self.assert_server_error(ERROR_USERNAME_ALREADY_EXISTS, **params)
# Test things actually change
email, username = random_valid_email(), random_valid_username()
params[NEW_USERNAME_STR] = username
params[NEW_EMAIL_STR] = email
params[NUT_ALLERGY_STR] = True
params[GLUTEN_FREE_STR] = True
params[SPICINESS_LEVEL_STR] = 3
self.assert_no_server_error(**params)
# Get from the database to check it is all correct
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(GET_WHERE_USERNAME_LIKE_SQL, [username])
result = cursor.fetchone()
self.assert_true(result[EMAIL_STR] == email)
self.assert_true(result[NUT_ALLERGY_STR] == 1)
self.assert_true(result[GLUTEN_FREE_STR] == 1)
self.assert_true(result[SPICINESS_LEVEL_STR] == 3)
# Update it all back to what it should be
params.update({
USERNAME_STR:
username,
EMAIL_STR:
email,
NEW_USERNAME_STR:
TEST_ACCOUNT_VERIFIED_USERNAME,
NEW_EMAIL_STR:
TEST_ACCOUNT_VERIFIED_EMAIL.lower().replace('.', '').replace(
'gmailcom', 'gmail.com'),
NUT_ALLERGY_STR:
False,
GLUTEN_FREE_STR:
False,
SPICINESS_LEVEL_STR:
-1
})
self.assert_no_server_error(**params)
def testlast_change_password(self):
"""
The ability to change one's password
"""
params = {
EVENT_TYPE_STR: EVENT_CHANGE_PASSWORD_STR,
USERNAME_STR: TEST_ACCOUNT_VERIFIED_USERNAME,
HTTP_METHOD_STR: POST_REQUEST_STR,
PASSWORD_HASH_STR: TEST_ACCOUNT_PASSWORD_HASH,
NEW_PASSWORD_HASH_STR: random_valid_password_hash()
}
self.assert_server_handles_invalid_inputs(**params)
# Invalid username
params[USERNAME_STR] = random_valid_username()
self.assert_server_error(ERROR_USERNAME_DOES_NOT_EXIST, **params)
# Invalid email
del params[USERNAME_STR]
params[EMAIL_STR] = random_valid_email()
self.assert_server_error(ERROR_EMAIL_DOES_NOT_EXIST, **params)
# Password and hash do not match
del params[EMAIL_STR]
params[USERNAME_STR] = TEST_ACCOUNT_VERIFIED_USERNAME
params[PASSWORD_HASH_STR] = random_valid_password_hash()
self.assert_server_error(ERROR_INCORRECT_PASSWORD, **params)
# Actually works to change password
params[PASSWORD_HASH_STR] = TEST_ACCOUNT_PASSWORD_HASH
self.assert_no_server_error(**params)
# Check to make sure the password hash is correct in the database
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(GET_WHERE_USERNAME_LIKE_SQL, [params[USERNAME_STR]])
params = {
EVENT_TYPE_STR: EVENT_LOGIN_STR,
HTTP_METHOD_STR: GET_REQUEST_STR,
USERNAME_STR: TEST_ACCOUNT_VERIFIED_USERNAME,
PASSWORD_HASH_STR: params[NEW_PASSWORD_HASH_STR]
}
self.assert_no_server_error(**params)
self._change_password_without_knowing()
def test_rate_recipe(self):
params = {
EVENT_TYPE_STR: EVENT_RATE_RECIPE_STR,
HTTP_METHOD_STR: POST_REQUEST_STR,
USERNAME_STR: TEST_ACCOUNT_VERIFIED_USERNAME,
PASSWORD_HASH_STR: TEST_ACCOUNT_PASSWORD_HASH,
RECIPE_ID_STR: -1,
RECIPE_RATING_STR: 4,
}
self.assert_server_handles_invalid_inputs(**params)
# Check rating is bad
params[RECIPE_RATING_STR] = -1
self.assert_server_error(ERROR_INVALID_RATING, **params)
params[RECIPE_RATING_STR] = 6
self.assert_server_error(ERROR_INVALID_RATING, **params)
# Check if the recipe doesn't exist
params[RECIPE_RATING_STR] = 5
params[RECIPE_ID_STR] = -1824781
self.assert_server_error(ERROR_UNKNOWN_RECIPE, **params)
# Check if recipe exists, but is private and shouldn't be rated
params[RECIPE_ID_STR] = -2
self.assert_server_error(ERROR_UNKNOWN_RECIPE, **params)
# Add in a few recipes that are able to rate
conn = get_new_db_conn()
cursor = conn.cursor()
recipe1 = [
-142, "title1", "", "", "", False, False, False, False, -1, "",
"sda"
]
recipe2 = [
-143, "title2", "", "", "", False, False, False, False, -1, "",
"sda2"
]
recipe3 = [
-144, "title3", "", "", "", False, False, False, False, -1, "",
"sda3"
]
cursor.execute(CREATE_RECIPE_SQL, recipe1)
cursor.execute(CREATE_RECIPE_SQL, recipe2)
cursor.execute(CREATE_RECIPE_SQL, recipe3)
conn.commit()
# Rate the recipes
ratings = [5, 3, 0]
params[RECIPE_ID_STR] = recipe1[0]
params[RECIPE_RATING_STR] = ratings[0]
self.assert_no_server_error(**params)
params[RECIPE_ID_STR] = recipe2[0]
params[RECIPE_RATING_STR] = ratings[1]
self.assert_no_server_error(**params)
params[RECIPE_ID_STR] = recipe3[0]
params[RECIPE_RATING_STR] = ratings[2]
self.assert_no_server_error(**params)
# Check the thingy is correct
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(GET_WHERE_USERNAME_LIKE_SQL,
[TEST_ACCOUNT_VERIFIED_USERNAME])
self.assert_equal(
cursor.fetchone()[RATED_RECIPES_STR], ','.join([
str(recipe1[0]) + ':' + str(ratings[0]),
str(recipe2[0]) + ':' + str(ratings[1]),
str(recipe3[0]) + ':' + str(ratings[2]),
]))
# Delete the created recipes and reset the rated recipes in username
cursor.execute(
"DELETE FROM {0} WHERE {1}=%s".format(RECIPES_TABLE_NAME,
RECIPE_ID_STR), [recipe1[0]])
cursor.execute(
"DELETE FROM {0} WHERE {1}=%s".format(RECIPES_TABLE_NAME,
RECIPE_ID_STR), [recipe2[0]])
cursor.execute(
"DELETE FROM {0} WHERE {1}=%s".format(RECIPES_TABLE_NAME,
RECIPE_ID_STR), [recipe3[0]])
cursor.execute(
"UPDATE {0} SET {1}='' WHERE {2} LIKE %s".format(
USERS_TABLE_NAME, RATED_RECIPES_STR, USERNAME_STR),
[TEST_ACCOUNT_VERIFIED_USERNAME])
conn.commit()
def test_update_recipe(self):
params = {
EVENT_TYPE_STR: EVENT_UPDATE_RECIPE_STR,
HTTP_METHOD_STR: POST_REQUEST_STR,
USERNAME_STR: TEST_ACCOUNT_VERIFIED_USERNAME,
PASSWORD_HASH_STR: TEST_ACCOUNT_PASSWORD_HASH,
RECIPE_ID_STR: -1
}
self.assert_server_handles_invalid_inputs(**params)
# Can't update a recipe that one does not own
self.assert_server_error(ERROR_UNKNOWN_RECIPE, **params)
# Can't update a recipe that does not exist
params[RECIPE_ID_STR] = -3566
self.assert_server_error(ERROR_UNKNOWN_RECIPE, **params)
# Make a recipe owned by TEST_ACCOUNT_VERIFIED
recipe_id = -123412
create_args = [
recipe_id, "A", "B", "", "JFDANSIJPNFIUANSFUINJAS", False, False,
False, False, -1, "RECIPE_PICTURE_STR",
TEST_ACCOUNT_VERIFIED_USERNAME
]
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(CREATE_RECIPE_SQL, create_args)
conn.commit()
# Make sure we can edit that one
new_recipe_args = {
RECIPE_ID_STR: recipe_id,
RECIPE_TITLE_STR: "AAAAA",
RECIPE_DESCRIPTION_STR: "BBBB",
RECIPE_INGREDIENTS_STR: "CCCCC",
RECIPE_TUTORIAL_STR: "NEW TUTORIAL",
RECIPE_PRIVATE_STR: 1,
NUT_ALLERGY_STR: 1,
GLUTEN_FREE_STR: 1,
VEGETARIAN_STR: 1,
SPICINESS_LEVEL_STR: 5,
RECIPE_PICTURE_STR: ""
}
params.update(new_recipe_args)
self.assert_no_server_error(**params)
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(GET_RECIPE_BY_ID_SQL, [new_recipe_args[RECIPE_ID_STR]])
result = cursor.fetchone()
for k, v in new_recipe_args.items():
self.assert_true(result[k] == v,
"Updating, %s != %s" % (result[k], v))
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(
"DELETE FROM {0} WHERE {1}=%s".format(RECIPES_TABLE_NAME,
RECIPE_ID_STR),
[new_recipe_args[RECIPE_ID_STR]])
conn.commit()
def test_update_get_user_favorites(self):
params = {
EVENT_TYPE_STR: EVENT_UPDATE_USER_FAVORITES_STR,
HTTP_METHOD_STR: POST_REQUEST_STR,
USERNAME_STR: TEST_ACCOUNT_VERIFIED_USERNAME,
PASSWORD_HASH_STR: TEST_ACCOUNT_PASSWORD_HASH,
RECIPE_ID_STR: -1
}
self.assert_server_handles_invalid_inputs(**params)
# Add in some temporary recipes
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(
"INSERT INTO {0} ({1}) VALUES (%s)".format(RECIPES_TABLE_NAME,
RECIPE_ID_STR), 2)
cursor.execute(
"INSERT INTO {0} ({1}) VALUES (%s)".format(RECIPES_TABLE_NAME,
RECIPE_ID_STR), 3)
cursor.execute(
"INSERT INTO {0} ({1}) VALUES (%s)".format(RECIPES_TABLE_NAME,
RECIPE_ID_STR), 4)
conn.commit()
# UPDATE
# check for recipes that do not exist
params[RECIPE_ID_STR] = 999999999
self.assert_server_error(ERROR_UNKNOWN_RECIPE, **params)
# Recipes that are not yet favorited
params[RECIPE_ID_STR] = -2
self.assert_server_error(ERROR_RECIPE_NOT_FAVORITED, **params)
# Add in some favorited recipes
params[RECIPE_ID_STR] = 2
self.assert_no_server_error(**params)
params[RECIPE_ID_STR] = 3
self.assert_no_server_error(**params)
params[RECIPE_ID_STR] = 4
self.assert_no_server_error(**params)
# Make sure it is as it should be
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(GET_WHERE_USERNAME_LIKE_SQL,
TEST_ACCOUNT_VERIFIED_USERNAME)
self.assert_true(cursor.fetchone()[FAVORITED_RECIPES_STR] == ','.join(
['2', '3', '4']))
# Delete all of the added ones
params[EVENT_TYPE_STR] = EVENT_UPDATE_USER_FAVORITES_STR
params[HTTP_METHOD_STR] = POST_REQUEST_STR
params[RECIPE_ID_STR] = -2
self.assert_no_server_error(**params)
params[RECIPE_ID_STR] = -3
self.assert_no_server_error(**params)
params[RECIPE_ID_STR] = -4
self.assert_no_server_error(**params)
# Make sure its good now
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(GET_WHERE_USERNAME_LIKE_SQL,
TEST_ACCOUNT_VERIFIED_USERNAME)
self.assert_true(cursor.fetchone()[FAVORITED_RECIPES_STR] == '')
# Delete temp recipes
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(
"DELETE FROM {0} WHERE {1}=%s".format(RECIPES_TABLE_NAME,
RECIPE_ID_STR), 2)
cursor.execute(
"DELETE FROM {0} WHERE {1}=%s".format(RECIPES_TABLE_NAME,
RECIPE_ID_STR), 3)
cursor.execute(
"DELETE FROM {0} WHERE {1}=%s".format(RECIPES_TABLE_NAME,
RECIPE_ID_STR), 4)
conn.commit()
def testlast_create_get_delete_recipe(self):
# Create two private recipes
params = {
EVENT_TYPE_STR: EVENT_CREATE_RECIPE_STR,
HTTP_METHOD_STR: POST_REQUEST_STR,
USERNAME_STR: TEST_ACCOUNT_VERIFIED_USERNAME,
PASSWORD_HASH_STR: TEST_ACCOUNT_PASSWORD_HASH,
RECIPE_TITLE_STR: "Fake title",
RECIPE_INGREDIENTS_STR: "Lots of\n ingredients\n in this",
RECIPE_DESCRIPTION_STR: "Descibr",
RECIPE_TUTORIAL_STR: "THIS IS A TUTORIAL",
RECIPE_PRIVATE_STR: True,
NUT_ALLERGY_STR: False,
GLUTEN_FREE_STR: False,
VEGETARIAN_STR: False,
SPICINESS_LEVEL_STR: 0,
}
self.assert_no_server_error(**params)
params[RECIPE_TITLE_STR] = "FAKE TITLE 2"
self.assert_no_server_error(**params)
# Get the most recent recipe
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(GET_NEXT_RECIPE_ID_SQL)
recipe_id = cursor.fetchone()[NEXT_RECIPE_ID_STR] - 2
# Make sure it is updated correctly on the user profile
created_recipes_str = str(recipe_id - 2) + "," + str(recipe_id)
cursor.execute(GET_WHERE_USERNAME_LIKE_SQL,
[TEST_ACCOUNT_VERIFIED_USERNAME])
self.assert_true(
cursor.fetchone()[CREATED_RECIPES_STR] == created_recipes_str)
# Get public recipe
params = {
EVENT_TYPE_STR: EVENT_GET_RECIPE_STR,
HTTP_METHOD_STR: GET_REQUEST_STR,
RECIPE_ID_STR: -1,
}
self.assert_no_server_error(**params)
# Get personal private recipe
params.update({
USERNAME_STR: TEST_ACCOUNT_VERIFIED_USERNAME,
PASSWORD_HASH_STR: TEST_ACCOUNT_PASSWORD_HASH,
})
self.assert_no_server_error(**params)
# Check recipe string is correct
created_recipes_str = str(recipe_id - 2) + "," + str(recipe_id)
cursor.execute(GET_WHERE_USERNAME_LIKE_SQL,
[TEST_ACCOUNT_VERIFIED_USERNAME])
self.assert_true(
cursor.fetchone()[CREATED_RECIPES_STR] == created_recipes_str)
# Delete recipe1
params = {
EVENT_TYPE_STR: EVENT_DELETE_RECIPE_STR,
HTTP_METHOD_STR: DELETE_REQUEST_STR,
RECIPE_ID_STR: recipe_id,
USERNAME_STR: TEST_ACCOUNT_VERIFIED_USERNAME,
PASSWORD_HASH_STR: TEST_ACCOUNT_PASSWORD_HASH
}
self.assert_no_server_error(**params)
conn = get_new_db_conn()
cursor = conn.cursor()
created_recipes_str = str(recipe_id - 2)
cursor.execute(GET_WHERE_USERNAME_LIKE_SQL,
[TEST_ACCOUNT_VERIFIED_USERNAME])
self.assert_true(
cursor.fetchone()[CREATED_RECIPES_STR] == created_recipes_str)
# Delete recipe2
params[RECIPE_ID_STR] = recipe_id - 2
self.assert_no_server_error(**params)
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(GET_WHERE_USERNAME_LIKE_SQL,
[TEST_ACCOUNT_VERIFIED_USERNAME])
self.assert_true(cursor.fetchone()[CREATED_RECIPES_STR] == '')
def _change_password_without_knowing(self):
# Try the updating of the password without knowing original password
params = {
EVENT_TYPE_STR: EVENT_GET_PASSWORD_CHANGE_CODE_STR,
USERNAME_STR: TEST_ACCOUNT_VERIFIED_USERNAME,
HTTP_METHOD_STR: GET_REQUEST_STR,
}
self.assert_server_handles_invalid_inputs(**params)
# Invalid username
params[USERNAME_STR] = random_valid_username()
self.assert_server_error(ERROR_USERNAME_DOES_NOT_EXIST, **params)
# Invalid email
del params[USERNAME_STR]
params[EMAIL_STR] = random_valid_email()
self.assert_server_error(ERROR_EMAIL_DOES_NOT_EXIST, **params)
# Send a good request for the code
params[USERNAME_STR] = TEST_ACCOUNT_VERIFIED_USERNAME
self.assert_no_server_error(**params)
# Make sure there is a valid code in the db
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(
"SELECT * FROM {0} WHERE {1} LIKE %s".format(
USERS_TABLE_NAME, USERNAME_STR),
TEST_ACCOUNT_VERIFIED_USERNAME)
result = cursor.fetchone()
code = result[PASSWORD_CHANGE_CODE_STR]
self.assert_true(len(code) == PASSWORD_CHANGE_CODE_SIZE)
# Update the password knowing only the code
params = {
EVENT_TYPE_STR: EVENT_CHANGE_PASSWORD_STR,
USERNAME_STR: TEST_ACCOUNT_VERIFIED_USERNAME,
HTTP_METHOD_STR: POST_REQUEST_STR,
NEW_PASSWORD_HASH_STR: TEST_ACCOUNT_PASSWORD_HASH,
PASSWORD_CHANGE_CODE_STR: "0" * PASSWORD_CHANGE_CODE_SIZE
}
# Wrong code
self.assert_server_error(ERROR_INVALID_PASSWORD_CHANGE_CODE, **params)
# Actually change the password
params[PASSWORD_CHANGE_CODE_STR] = code
self.assert_no_server_error(**params)
# Check that the new password hash is the original, and the password change code is gone
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(
"SELECT * FROM {0} WHERE {1} LIKE %s".format(
USERS_TABLE_NAME, USERNAME_STR),
TEST_ACCOUNT_VERIFIED_USERNAME)
result = cursor.fetchone()
self.assert_true(result[PASSWORD_CHANGE_CODE_STR] == '')
params = {
EVENT_TYPE_STR: EVENT_LOGIN_STR,
HTTP_METHOD_STR: GET_REQUEST_STR,
USERNAME_STR: TEST_ACCOUNT_VERIFIED_USERNAME,
PASSWORD_HASH_STR: TEST_ACCOUNT_PASSWORD_HASH
}
self.assert_no_server_error(**params)
def testverylast_search_engine(self):
params = {
EVENT_TYPE_STR: EVENT_QUERY_RECIPES_STR,
HTTP_METHOD_STR: GET_REQUEST_STR,
QUERY_STR: "",
}
self.assert_server_handles_invalid_inputs(**params)
# Do all of the creating of the recipes if we are offline only so it doesn't happen twice
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute("SELECT * FROM {0}".format(RECIPES_TABLE_NAME))
results = cursor.fetchall()
if len(results) < 5:
# Create the new recipes if they do not already exist
recipe_info, pics = read_recipe_info()
# Make a new user
params = {
EVENT_TYPE_STR: EVENT_CREATE_ACCOUNT_STR,
USERNAME_STR: JUST_WINGIT_USERNAME,
EMAIL_STR: JUST_WINGIT_EMAIL,
PASSWORD_HASH_STR: JUST_WINGIT_PASSWORD_HASH,
HTTP_METHOD_STR: POST_REQUEST_STR,
}
request(**params)
# Verify the user
conn = get_new_db_conn()
cursor = conn.cursor()
cursor.execute(UPDATE_VERIFICATION_CODE_SQL, JUST_WINGIT_USERNAME)
conn.commit()
# Create each new recipe for the database
for recipe, pic in zip(recipe_info, pics):
file_ext = pic.split('.')[-1]
# Get a link to the s3 upload and upload it
params = {
EVENT_TYPE_STR: EVENT_GET_S3_URL_STR,
USERNAME_STR: JUST_WINGIT_USERNAME,
PASSWORD_HASH_STR: JUST_WINGIT_PASSWORD_HASH,
HTTP_METHOD_STR: GET_REQUEST_STR,
S3_REASON_STR: S3_REASON_UPLOAD_RECIPE_IMAGE,
IMAGE_FILE_EXTENSION_STR: file_ext,
}
response = request(**params)
requests.post(response['url'],
data=response['fields'],
files={
'file': (response[RECIPE_PICTURE_ID_STR],
open(pic, 'rb'))
})
params = {
EVENT_TYPE_STR:
EVENT_CREATE_RECIPE_STR,
USERNAME_STR:
JUST_WINGIT_USERNAME,
PASSWORD_HASH_STR:
JUST_WINGIT_PASSWORD_HASH,
HTTP_METHOD_STR:
POST_REQUEST_STR,
RECIPE_PICTURE_STR:
S3_BUCKET_URL + RECIPE_IMAGES_DIR + "/" +
response[RECIPE_PICTURE_ID_STR] + "." + file_ext,
RECIPE_TITLE_STR:
recipe[0],
RECIPE_INGREDIENTS_STR:
recipe[1],
RECIPE_DESCRIPTION_STR:
recipe[2],
RECIPE_TUTORIAL_STR:
recipe[3],
NUT_ALLERGY_STR:
recipe[4] == '1',
GLUTEN_FREE_STR:
recipe[5] == '1',
VEGETARIAN_STR:
recipe[6] == '1',
SPICINESS_LEVEL_STR:
int(recipe[7]),
RECIPE_PRIVATE_STR:
False,
}
self.assert_no_server_error(**params)
# Actual testing of search engine
params = {
EVENT_TYPE_STR: EVENT_QUERY_RECIPES_STR,
HTTP_METHOD_STR: GET_REQUEST_STR,
QUERY_STR: ""
}
# Sent empty query should return empty string
self.assert_equal(
self.assert_no_server_error(**params)[QUERY_RESULTS_STR], "")
params[QUERY_STR] = " \n\n\t "
self.assert_equal(
self.assert_no_server_error(**params)[QUERY_RESULTS_STR], "")
params[NUT_ALLERGY_STR] = True
self.assert_true(
len(self.assert_no_server_error(**params)[QUERY_RESULTS_STR]) > 0)
print("Only nut:", request(**params))
del params[NUT_ALLERGY_STR]
params[SPICINESS_LEVEL_STR] = 3
self.assert_true(
len(self.assert_no_server_error(**params)[QUERY_RESULTS_STR]) > 0)
print("Only spic, val (%d):" % params[SPICINESS_LEVEL_STR],
request(**params))
del params[SPICINESS_LEVEL_STR]
params[VEGETARIAN_STR] = True
self.assert_true(
len(self.assert_no_server_error(**params)[QUERY_RESULTS_STR]) > 0)
print("Only veg:", request(**params))
del params[VEGETARIAN_STR]
params[QUERY_STR] = "Crispy Chicken Wings"
print("Full:", request(**params))
parser = argparse.ArgumentParser()
parser.add_argument(
"-d",
"-D",
"--db_rebuild",
help=
"WARNING: deletes and rebuilds the USERS database, all data will be deleted.",
action="store_true")
args = parser.parse_args()
# Delete and rebuild the database if the arg has been passed
if args.db_rebuild or _REBUILD_DB:
print("Rebuilding database...")
from lambda_code.utils import get_new_db_conn
rebuild_database(get_new_db_conn())
print("Database rebuilt!")
# Now, do the unit tests offline to make sure everything works
from tests.LambdaTestUtils import set_request_type_online
set_request_type_online(False)
print("\nTesting lambda code offline...")
from tests.TestLambda import TestLambda
TestLambda().test_all()
# Tests should have passed if we made it this far, make a zip file of everything needed
print('Building zip file...')
build_zip_file()
