def test_get_insert_id(self):
# Check if initial ID is one
initial_id = crud.get_insert_id(User, self.session)
self.assertEqual(initial_id == 1, True)
# create multiple users
user_names = ["cris", "keenan", "mohit", "sarthak"]
user_emails = ["*****@*****.**", "*****@*****.**",
"*****@*****.**", "*****@*****.**"]
user_phones = ["858-2867-3567", "858-2867-3568",
"858-2867-3566", "858-2867-3565"]
user_descriptions = ["cultured man",
"cultured guy", "cultured men", "cultured dude"]
user_school_years = ["First", "Second", "Third", "Fourth"]
user_majors = ["Data Science", "CS", "ChemE", "CS"]
# Add users to database, store objects
for i in range(len(user_names)):
crud.add_user(
user_names[i],
user_emails[i],
datetime.now(),
user_phones[i],
user_descriptions[i],
user_school_years[i],
user_majors[i],
self.session)
current_id = crud.get_insert_id(User, self.session)
self.assertEqual((i+2) == current_id, True)
def test_get_exist_user_by_id():
"""Test search exists user by email."""
with mocked_transaction() as session:
user = add_user(session, fake.name(), fake.email(), fake.password(),
fake.address(), fake.latitude(), fake.longitude())
assert user is not None
assert get_user_by_id(session, user.id) is not None
def test_add_user(self):
user_name = "cris"
user_email = "*****@*****.**"
created_time = datetime.now()
user_phone = "858-2867-3567"
user_description = "cultured man"
user_school_year = "Third"
user_major = "Data Science"
user_object = crud.add_user(user_name, user_email, created_time,
user_phone, user_description,
user_school_year, user_major, self.session)
# check if the return object has correct information
self.assertEqual(user_object.email, user_email)
self.assertEqual(user_object.name, user_name)
self.assertEqual(user_object.date_created, created_time)
self.assertEqual(user_object.phone, user_phone)
self.assertEqual(user_object.description, user_description)
self.assertEqual(user_object.school_year, user_school_year)
self.assertEqual(user_object.major, user_major)
# check if the user is loaded into the database
query_object = crud.get_row_if_exists(User, self.session,
**{'email': user_email})
self.assertEqual(query_object == user_object, True)
def test_get_row_if_exists(self):
user_name = "cris"
user_email = "*****@*****.**"
created_time = datetime.now()
user_phone = "858-2867-3567"
user_description = "cultured man"
user_school_year = "Third"
user_major = "Data Science"
# check if it the method detects no users
query_object = crud.get_row_if_exists(
User,
self.session,
**{'email': user_email})
self.assertEqual(query_object is None, True)
# add the user
user_object = crud.add_user(
user_name,
user_email,
created_time,
user_phone,
user_description,
user_school_year,
user_major,
self.session)
# check if it the method detects an user
query_object = crud.get_row_if_exists(
User,
self.session,
**{'email': user_email})
self.assertEqual(query_object == user_object, True)
def test_update_field(self):
# create an user
user_name = "cris"
user_email = "*****@*****.**"
created_time = datetime.now()
user_phone = "858-2867-3567"
user_description = "cultured man"
user_school_year = "Third"
user_major = "Data Science"
user_object = crud.add_user(
user_name,
user_email,
created_time,
user_phone,
user_description,
user_school_year,
user_major,
self.session)
# change description
crud.update_field(
User,
self.session,
{'email': '*****@*****.**'},
{'description':'google man'})
user_object = crud.get_row_if_exists(
User,
self.session,
**{'email': '*****@*****.**'})
self.assertEqual(user_object.description == 'google man', True)
def test_add_new_user():
"""Test adding new user."""
with mocked_transaction() as session:
user = add_user(session, fake.name(), fake.email(), fake.password(),
fake.address(), fake.latitude(), fake.longitude())
assert user is not None
assert get_user_by_id(session, user.id) is not None
def test_authenticate_user():
"""Test user authentication."""
with mocked_transaction() as session:
not_hashed_password = fake.password()
user = add_user(session, fake.name(), fake.email(),
not_hashed_password, fake.address(), fake.latitude(),
fake.longitude())
assert user is not None
assert is_authenticated_user(session, user.email, not_hashed_password)
def test_delete_exists_user():
"""Test deleting user."""
with mocked_transaction() as session:
not_hashed_password = fake.password()
user = add_user(session, fake.name(), fake.email(),
not_hashed_password, fake.address(), fake.latitude(),
fake.longitude())
assert user is not None
assert delete_user(session, user.email, not_hashed_password)
assert get_user_by_id(session, user.id) is None
def test_update_user_categories():
"""Test update user categories."""
categories_ids = [1, 2, 3, 4, 5, 48, 201]
with mocked_transaction() as session:
user = add_user(session, fake.name(), fake.email(), fake.password(),
fake.address(), fake.latitude(), fake.longitude())
assert user is not None
update_categories_to_user(session, user.id, categories_ids)
user = get_user_by_id(session, user.id)
assert user.categories_ids == categories_ids
def test_get_near_users():
"""Test getting all nearby result_users functionality."""
RADIUS = 2 # KM
base_coordinates = (32.852310, 35.096149) # BASE
in_range_coordinates = [
(32.853418, 35.092406), # 0.37 KM
(32.852408, 35.090430), # 0.54 KM
(32.845414, 35.078663), # 1.81 KM
(32.842025, 35.105976), # 1.47 KM
(32.841159, 35.079529)
] # 1.99 KM
out_of_range_coordinates = [
(32.834380, 35.103056), # 2.09 KM
(32.832722, 35.081751), # 2.56 KM
(32.838491, 35.076007), # 2.43 KM
(32.838491, 35.076007), # 4.72 KM
(32.840005, 35.069641)
] # 2.83 KM
with mocked_transaction() as session:
in_range_users = [
add_user(session, fake.name(), fake.email(), fake.password(),
fake.address(), coordinate[0], coordinate[1])
for coordinate in in_range_coordinates
]
for coordinate in out_of_range_coordinates:
add_user(session, fake.name(), fake.email(), fake.password(),
fake.address(), coordinate[0], coordinate[1])
# Check that users was added.
assert len(get_all_users(session)) == len(out_of_range_coordinates) + \
len(in_range_coordinates)
result_users = get_near_users(session,
latitude=base_coordinates[0],
longitude=base_coordinates[1],
radius=RADIUS)
assert set(result_users) == set(in_range_users)
def test_write_room(self):
# create an user
user_name = "cris"
user_email = "*****@*****.**"
created_time = datetime.now()
user_phone = "858-2867-3567"
user_description = "cultured man"
user_school_year = "Third"
user_major = "Data Science"
user_object = crud.add_user(user_name, user_email, created_time,
user_phone, user_description,
user_school_year, user_major, self.session)
# the input json should be the same as output json from room_json except for id
test_json = {
'name': '75 Big Rock Cove St. Middletown',
'address': '75 Big Rock Cove St. Middletown, NY 10940',
'distance': '20 mins',
'pricePerMonth': 500,
'from_month': 'June/18',
'to_month': 'July/18',
'early_date': '06/01/18',
'late_date': '06/12/18',
'roomType': 'Single',
'other': [],
'facilities': [],
'leaserName': 'cris',
'leaserEmail': '*****@*****.**',
'leaserPhone': '858-2867-3567',
'leaserSchoolYear': 'Third',
'leaserMajor': 'Data Science',
'photos': ['photo1', 'photo2'],
'profilePhoto': 'profile_photo',
'negotiable': True,
'numBaths': 2.5,
'numBeds': 2,
'roomDescription': 'dream house in a life time'
}
crud.write_room(test_json, self.session, True)
room_object = crud.get_row_if_exists(Room, self.session, **{'id': 1})
self.assertEqual(room_object is not None, True)
result_json = crud.room_json(room_object, self.session, True)
test_json['roomId'] = 1
self.assertEqual(result_json == test_json, True)
def test_read_criteria(self):
# create multiple users
user_names = ["cris", "keenan", "mohit", "sarthak"]
user_emails = ["*****@*****.**", "*****@*****.**",
"*****@*****.**", "*****@*****.**"]
user_phones = ["858-2867-3567", "858-2867-3568",
"858-2867-3566", "858-2867-3565"]
user_descriptions = ["cultured man",
"cultured guy", "cultured men", "cultured dude"]
user_school_years = ["First", "Second", "Third", "Fourth"]
user_majors = ["Data Science", "CS", "ChemE", "CS"]
# Add users to database, store objects
user_objects = {}
for i in range(len(user_names)):
user_objects[user_names[i]] = crud.add_user(
user_names[i],
user_emails[i],
datetime.now(),
user_phones[i],
user_descriptions[i],
user_school_years[i],
user_majors[i],
self.session)
# Create single and multiple user queries
single_user_query = crud.read_criteria(
User, {"major": "ChemE", "school_year": "Third"}, self.session)
all_criteria_user_query = crud.read_criteria(User, {"name": "cris", "email": "*****@*****.**",
"phone": "858-2867-3567", "description": "cultured man", "major": "Data Science",
"school_year": "First"}, self.session)
multiple_user_query = crud.read_criteria(
User, {"major": "CS"}, self.session, "m")
all_user_query = crud.read_criteria(User, {}, self.session, "m")
# Check if queries match expected values
self.assertEqual(user_objects['mohit'] == single_user_query, True)
self.assertEqual(user_objects['cris'] == all_criteria_user_query, True)
self.assertEqual(any([x == user_objects['keenan']
for x in multiple_user_query]), True)
self.assertEqual(any([x == user_objects['sarthak']
for x in multiple_user_query]), True)
self.assertEqual(len(all_user_query) == len(user_objects), True)
def create_user():
session = current_app.config['DB_CONNECTION']
if request.method == 'OPTIONS':
return generateResponse()
requested_json = request.json
if get_row_if_exists(User, session, **{'email': requested_json['email']}):
message, status = 'Already Created', 200
return generateResponse(elem=message, status=status)
user = add_user(requested_json['name'],
requested_json['email'],
datetime.now(),
requested_json['phone'],
requested_json["description"],
requested_json["schoolYear"],
requested_json["major"],
session)
login_session["user_id"] = user.id
icon_path = './assets/profile_default_icons/'
selected_icon = random.choice(
os.listdir(icon_path))
path_name = "/".join(["user"+str(user.id),
'profile', "headshot.jpg"])
upload_file_wname(icon_path+selected_icon, 'houseit', path_name)
json_response = {'name': requested_json['name'],
'email': requested_json['email'],
'access_token': login_session["access_token"],
'message': 'Successfully created room.',
'description': user.description,
'phone': user.phone,
'schoolYear': user.school_year,
'major': user.major,
'profile_photo': path_name
}
response = generateResponse(json_response, 201)
response.set_cookie('access_token', login_session["access_token"])
return response
def test_write_attribute(self):
# create an user
user_name = "cris"
user_email = "*****@*****.**"
created_time = datetime.now()
user_phone = "858-2867-3567"
user_description = "cultured man"
user_school_year = "Third"
user_major = "Data Science"
user_object = crud.add_user(
user_name,
user_email,
created_time,
user_phone,
user_description,
user_school_year,
user_major,
self.session)
# create a move in
early_date = datetime(2018, 6, 1)
late_date = datetime(2018, 6, 12)
move_in_object = crud.add_move_in(
early_date,
late_date,
self.session)
# create a stay period
from_month = datetime(2018, 6, 1)
to_month = datetime(2018, 7, 1)
stay_period_object = crud.add_stay_period(
from_month,
to_month,
self.session)
# create an address
address = "75 Big Rock Cove St.Middletown, NY 10940"
distance = "20 mins"
address_object = crud.add_address(
distance,
address,
self.session)
# create a room
date_created = datetime.now()
room_type = room_types[0]
price = 500
negotiable = True
description = "dream house in a life time"
no_rooms = 2
no_bathrooms = 2
room_object = crud.add_room(
date_created,
room_type,
price,
negotiable,
description,
stay_period_object,
address_object,
user_object,
move_in_object,
no_rooms,
no_bathrooms,
self.session)
room_object = crud.add_room(
date_created,
room_type,
price,
negotiable,
description,
stay_period_object,
address_object,
user_object,
move_in_object,
no_rooms,
no_bathrooms,
self.session)
crud.write_attribute(
facilities[0:3],
'facilities',
room_object,
self.session)
count = self.session.query(House_Attribute).count()
self.assertEqual(count == 3, True)
categories = self.session.query(Attribute.category).distinct().all()
self.assertEqual(categories[0][0] == 'facilities', True)
names = set([result[0] for result in self.session.query(Attribute.name).all()])
self.assertEqual(names == set(facilities[0:3]), True)
def test_room_json(self):
# create an user
user_name = "cris"
user_email = "*****@*****.**"
created_time = datetime.now()
user_phone = "858-2867-3567"
user_description = "cultured man"
user_school_year = "Third"
user_major = "Data Science"
user_object = crud.add_user(
user_name,
user_email,
created_time,
user_phone,
user_description,
user_school_year,
user_major,
self.session)
# create a move in
early_date = datetime(2018, 6, 1)
late_date = datetime(2018, 6, 12)
move_in_object = crud.add_move_in(
early_date,
late_date,
self.session)
# create a stay period
from_month = datetime(2018, 6, 1)
to_month = datetime(2018, 7, 1)
stay_period_object = crud.add_stay_period(
from_month,
to_month,
self.session)
# create an address
address = "75 Big Rock Cove St.Middletown, NY 10940"
distance = "20 mins"
address_object = crud.add_address(
distance,
address,
self.session)
# create a room
date_created = datetime.now()
room_type = room_types[0]
price = 500
negotiable = True
description = "dream house in a life time"
no_rooms = 2
no_bathrooms = 2
room_object = crud.add_room(
date_created,
room_type,
price,
negotiable,
description,
stay_period_object,
address_object,
user_object,
move_in_object,
no_rooms,
no_bathrooms,
self.session)
result_json = crud.room_json(
room_object,
self.session,
True)
self.assertEqual(result_json["name"] ==
"75 Big Rock Cove St.Middletown", True)
self.assertEqual(result_json["location"] == address, True)
self.assertEqual(result_json["pricePerMonth"] == price, True)
self.assertEqual(result_json["from_month"] == "June/18", True)
self.assertEqual(result_json["to_month"] == "July/18", True)
self.assertEqual(result_json["early"] == "06/01/18", True)
self.assertEqual(result_json["late"] == "06/12/18", True)
self.assertEqual(result_json["roomType"] == room_type, True)
self.assertEqual(result_json["other"] == [], True)
self.assertEqual(result_json["facilities"] == [], True)
self.assertEqual(result_json["leaserName"] == user_name, True)
self.assertEqual(result_json["leaserEmail"] == user_email, True)
self.assertEqual(result_json["leaserPhone"] == user_phone, True)
self.assertEqual(
result_json["leaserSchoolYear"] == user_school_year, True)
self.assertEqual(result_json["leaserMajor"] == user_major, True)
self.assertEqual(result_json["photos"] == ["photo1", "photo2"], True)
self.assertEqual(result_json["profilePhoto"] == "profile_photo", True)
self.assertEqual(result_json["roomId"] == room_object.id, True)
self.assertEqual(result_json["negotiable"] == negotiable, True)
self.assertEqual(result_json["numBaths"] == no_rooms, True)
self.assertEqual(result_json["numBeds"] == no_bathrooms, True)
self.assertEqual(result_json["roomDescription"] == description, True)
# add three attributes
name, category = others[0], "other"
# create an attribute
attribute_object = crud.add_attribute(
name,
category,
self.session)
# connect room with the attribute
house_attribute_object = crud.add_house_attribute(
room_object,
attribute_object,
self.session)
name, category = others[1], "other"
# create an attribute
attribute_object = crud.add_attribute(
name,
category,
self.session)
# connect room with the attribute
house_attribute_object = crud.add_house_attribute(
room_object,
attribute_object,
self.session)
name, category = facilities[0], "facilities"
# create an attribute
attribute_object = crud.add_attribute(
name,
category,
self.session)
# connect room with the attribute
house_attribute_object = crud.add_house_attribute(
room_object,
attribute_object,
self.session)
result_json = crud.room_json(
room_object,
self.session,
True)
self.assertEqual(result_json["other"] == [others[0], others[1]], True)
self.assertEqual(result_json["facilities"] == [facilities[0]], True)
def test_read_rooms(self):
# add room allows duplicates since one can have multiple rooms same time with same criteria
# create an user
user_name = "cris"
user_email = "*****@*****.**"
created_time = datetime.now()
user_phone = "858-2867-3567"
user_description = "cultured man"
user_school_year = "Third"
user_major = "Data Science"
user_object = crud.add_user(
user_name,
user_email,
created_time,
user_phone,
user_description,
user_school_year,
user_major,
self.session)
# create a move in
early_date = datetime(2018, 6, 1)
late_date = datetime(2018, 6, 12)
move_in_object = crud.add_move_in(
early_date,
late_date,
self.session)
# create a stay period
from_month = datetime(2018, 6, 1)
to_month = datetime(2018, 7, 1)
stay_period_object = crud.add_stay_period(
from_month,
to_month,
self.session)
# create an address
address = "75 Big Rock Cove St.Middletown, NY 10940"
distance = "20 mins"
address_object = crud.add_address(
distance,
address,
self.session)
# create a room
date_created = datetime.now()
room_type = room_types[0]
price = 500
negotiable = True
description = "dream house in a life time"
no_rooms = 2
no_bathrooms = 2
room_object = crud.add_room(
date_created,
room_type,
price,
negotiable,
description,
stay_period_object,
address_object,
user_object,
move_in_object,
no_rooms,
no_bathrooms,
self.session)
room_object = crud.add_room(
date_created,
room_type,
price,
negotiable,
description,
stay_period_object,
address_object,
user_object,
move_in_object,
no_rooms,
no_bathrooms,
self.session)
room_object = crud.add_room(
date_created,
room_type,
price,
negotiable,
description,
stay_period_object,
address_object,
user_object,
move_in_object,
no_rooms,
no_bathrooms,
self.session)
number_of_rows = len(crud.read_rooms(self.session))
self.assertEqual(number_of_rows == 3, True)
# create a different user
user_name = "keenan"
user_email = "*****@*****.**"
created_time = datetime.now()
user_phone = "858-2867-8888"
user_description = "HK Dutch man"
user_school_year = "Grad"
user_major = "Computer Science"
user_object = crud.add_user(
user_name,
user_email,
created_time,
user_phone,
user_description,
user_school_year,
user_major,
self.session)
# create a move in
early_date = datetime(2018, 8, 1)
late_date = datetime(2018, 10, 12)
move_in_object = crud.add_move_in(
early_date,
late_date,
self.session)
# create a stay period
from_month = datetime(2018, 10, 1)
to_month = datetime(2019, 10, 1)
stay_period_object = crud.add_stay_period(
from_month,
to_month,
self.session)
# create an address
address = "75 Big Rock Cove St.Middletown, NY 10940"
distance = "20 mins"
address_object = crud.add_address(
distance,
address,
self.session)
# create a room
date_created = datetime.now()
room_type = room_types[0]
price = 500
negotiable = True
description = "smoking is bad for your health"
no_rooms = 4
no_bathrooms = 5
room_object = crud.add_room(
date_created,
room_type,
price,
negotiable,
description,
stay_period_object,
address_object,
user_object,
move_in_object,
no_rooms,
no_bathrooms,
self.session)
number_of_rows = len(crud.read_rooms(self.session))
self.assertEqual(number_of_rows == 4, True)
def test_add_and_remove_bookmark(self):
# create an user
user_name = "cris"
user_email = "*****@*****.**"
created_time = datetime.now()
user_phone = "858-2867-3567"
user_description = "cultured man"
user_school_year = "Third"
user_major = "Data Science"
user_object = crud.add_user(
user_name,
user_email,
created_time,
user_phone,
user_description,
user_school_year,
user_major,
self.session)
# create a move in
early_date = datetime(2018, 6, 1)
late_date = datetime(2018, 6, 12)
move_in_object = crud.add_move_in(
early_date,
late_date,
self.session)
# create a stay period
from_month = datetime(2018, 6, 1)
to_month = datetime(2018, 7, 1)
stay_period_object = crud.add_stay_period(
from_month,
to_month,
self.session)
# create an address
address = "75 Big Rock Cove St. Middletown, NY 10940"
distance = "20 mins"
address_object = crud.add_address(
distance,
address,
self.session)
# create a room
date_created = datetime.now()
room_type = room_types[0]
price = 500
negotiable = True
description = "dream house in a life time"
no_rooms = 2
no_bathrooms = 2
room_object = crud.add_room(
date_created,
room_type,
price,
negotiable,
description,
stay_period_object,
address_object,
user_object,
move_in_object,
no_rooms,
no_bathrooms,
self.session)
# connect bookmark with the room and user
bookmark_object = crud.add_bookmark(
room_object,
user_object,
self.session)
# check if the return object has correct information
self.assertEqual(bookmark_object.room_id, room_object.id)
self.assertEqual(bookmark_object.user_id, user_object.id)
# check duplicate handling
bookmark_object = crud.add_bookmark(
room_object,
user_object,
self.session)
number_of_rows = self.session.query(Bookmark).count()
self.assertEqual(number_of_rows == 1, True)
# check delete
crud.remove_bookmark(
room_object,
user_object,
self.session)
number_of_rows = self.session.query(Bookmark).count()
self.assertEqual(number_of_rows == 0, True)
crud.remove_bookmark(
room_object,
user_object,
self.session)
number_of_rows = self.session.query(Bookmark).count()
self.assertEqual(number_of_rows == 0, True)
def test_add_house_attribute(self):
name, category = others[0], "other"
# create an attribute (Single Case)
attribute_object = crud.add_attribute(
name,
category,
self.session)
# create a stay period
from_month = datetime(2018, 6, 1)
to_month = datetime(2018, 7, 1)
stay_period_object = crud.add_stay_period(
from_month,
to_month,
self.session)
# create an address
address = "75 Big Rock Cove St.Middletown, NY 10940"
distance = "20 mins"
address_object = crud.add_address(
distance,
address,
self.session)
# create an user
user_name = "cris"
user_email = "*****@*****.**"
created_time = datetime.now()
user_phone = "858-2867-3567"
user_description = "cultured man"
user_school_year = "Third"
user_major = "Data Science"
user_object = crud.add_user(
user_name,
user_email,
created_time,
user_phone,
user_description,
user_school_year,
user_major,
self.session)
# create a move in
early_date = datetime(2018, 6, 1)
late_date = datetime(2018, 6, 12)
move_in_object = crud.add_move_in(
early_date,
late_date,
self.session)
# create a room
date_created = datetime.now()
room_type = room_types[0]
price = 500
negotiable = True
description = "dream house in a life time"
no_rooms = 2
no_bathrooms = 2
room_object = crud.add_room(
date_created,
room_type,
price,
negotiable,
description,
stay_period_object,
address_object,
user_object,
move_in_object,
no_rooms,
no_bathrooms,
self.session)
# connect room with the attribute
house_attribute_object = crud.add_house_attribute(
room_object,
attribute_object,
self.session)
# check if the return object has correct information
self.assertEqual(house_attribute_object.room_id, room_object.id)
self.assertEqual(house_attribute_object.attribute_name,
attribute_object.name)
# one thing in the database
number_of_rows = self.session.query(House_Attribute).count()
self.assertEqual(number_of_rows == 1, True)
# create two attributes (multiple Case)
name, category = others[1], "other"
# create a second attribute
attribute_object = crud.add_attribute(
name,
category,
self.session)
house_attribute_object = crud.add_house_attribute(
room_object,
attribute_object,
self.session)
# check if the return object has correct information
self.assertEqual(house_attribute_object.room_id, room_object.id)
self.assertEqual(house_attribute_object.attribute_name,
attribute_object.name)
# two things in the database
number_of_rows = self.session.query(House_Attribute).count()
self.assertEqual(number_of_rows == 2, True)
# check duplicate handling
house_attribute_object = crud.add_house_attribute(
room_object,
attribute_object,
self.session)
number_of_rows = self.session.query(House_Attribute).count()
self.assertEqual(number_of_rows == 2, True)
def create_user():
"""Create user function that is called when user is not in the database
content_type: application/json
example of valid json request format:
"name": "CRISTIANO",
"email": "*****@*****.**",
"description": "YOU COULD NOT LIVE WITH YOUR OWN FAILURE, AND WHERE DID THAT BRING YOU? BACK TO ME",
"phone": "858-777-2345",
"schoolYear": "Grad",
"major": "MARVEL SCIENCE"
"""
# handle pre-flight for browsers CORS access
if request.method == "OPTIONS":
return generate_response()
# part1: verify that the request is legit
session = current_app.config["DB_CONNECTION"]
# verify the token
checked_and_verified, response = check_verify_token(request, login_session)
if checked_and_verified == False:
return response
try:
# if some existing users are techie, troll them
user_id = login_session["user_id"]
response = generate_message(MESSAGE_CREATE_USER_DUPLICATE_REQUEST, 405)
return response
except KeyError:
# nice error. This means we can proceed to process their json
checked_json, response, requested_json = check_json_form(
request, MESSAGE_BAD_JSON, MESSAGE_CREATE_USER_NO_JSON)
if checked_json == False:
return response
try:
user_name = requested_json["name"]
# user must complete account creation in the same session
# no need to handle key error since til now the login_user_email should exist
user_email = login_session["login_user_email"]
user_phone = requested_json["phone"]
user_description = requested_json["description"]
user_school_year = requested_json["school_year"]
user_major = requested_json["major"]
# verify types
correct_format, valid_update_pairs, response = process_request_json(
User, {
"name": user_name,
"email": user_email,
"phone": user_phone,
"description": user_description,
"school_year": user_school_year,
"major": user_major
})
if correct_format == False:
return response
user = add_user(user_name, user_email, datetime.now(), user_phone,
user_description, user_school_year, user_major,
session)
# update the user id in the session
login_session["user_id"] = user.id
# upload the image to S3 endpoint if not offline testing
if current_app.config["OFFLINE_TESTING"] != True:
# cris's favorite part: create randome icons
icon_path = "app/assets/profile_default_icons/"
selected_icon = random.choice(os.listdir(icon_path))
if current_app.config[
"TESTING"] == True: # if online testing mode
user_prefix = "test_user"
else:
user_prefix = "user"
photo_path_name = "/".join(
[user_prefix + str(user.id), "profile", "headshot.jpg"])
upload_file_wname(icon_path + selected_icon, "houseit",
photo_path_name)
# finally, send the sensitive data to be displayed on frontend/some techie user
json_response = generate_user_login_data(
user, current_app.config["TESTING"])
json_response["message"] = "Welcome to be a new HOMIE! CONGRATS!"
status_code = 201
response = generate_response(json_response, status_code)
return response
except KeyError:
response = generate_message(MESSAGE_CREATE_USER_INCOMPLETE_JSON,
400)
return response
def test_write_room(self):
# create an user
user_name = "cris"
user_email = "*****@*****.**"
created_time = datetime.now()
user_phone = "858-2867-3567"
user_description = "cultured man"
user_school_year = "Third"
user_major = "Data Science"
user_object = crud.add_user(
user_name,
user_email,
created_time,
user_phone,
user_description,
user_school_year,
user_major,
self.session)
# the input json should be the same as output json from room_json except for id
test_json = {"name": "75 Big Rock Cove St. Middletown",
"address": "75 Big Rock Cove St. Middletown, NY 10940",
"distance": "20 mins", "pricePerMonth": 500,
"fromMonth": "June/18", "toMonth": "July/18",
"earlyDate": "06/01/18", "lateDate": "06/12/18",
"roomType": "Single", "other": [], "facilities": [],
"photos": ["photo1", "photo2"],
"profilePhoto": "profile_photo",
"negotiable": True,
"numBaths": 2.5,
"numBeds": 2,
"roomDescription": "dream house in a life time"}
test_res_json = {"name": "75 Big Rock Cove St. Middletown",
"address": "75 Big Rock Cove St. Middletown, NY 10940",
"distance": "20 mins", "pricePerMonth": 500,
"fromMonth": "June/18", "toMonth": "July/18",
"earlyDate": "06/01/18", "lateDate": "06/12/18",
"roomType": "Single", "other": [], "facilities": [],
"photos": ["photo1", "photo2"],
"profilePhoto": "profile_photo",
"negotiable": True,
"numBaths": 2.5,
"numBeds": 2,
"roomDescription": "dream house in a life time",
"leaserName": user_name, "leaserEmail": user_email,
"leaserPhone": user_phone,
"leaserSchoolYear": user_school_year,
"leaserMajor": user_major, }
crud.write_room(transform_json_underscore(test_json),
user_object.id, self.session, True)
room_object = crud.get_row_if_exists(
Room,
self.session,
**{"id": 1})
self.assertEqual(room_object is not None, True)
result_json = crud.room_json(
room_object,
self.session,
True)
test_res_json["roomId"] = 1
self.assertEqual(result_json == test_res_json, True)
