def test_authenticated_user_link_facebook_account_already_linked_to_another_user_fail(
tenant: Tenant, landlord: Landlord, session: Session,
application: Application):
assert session.query(User).count() == 2
assert not session.query(SocialAccount).count()
email = "someemail"
access_token = "someacctoken"
mockid = "someid"
fname = "fname"
lname = "lname"
application.authenticate_facebook(session, mockid, access_token, email,
fname, lname, UserRole.TENANT, tenant)
assert session.query(SocialAccount).count()
assert session.query(SocialAccount).all()[0].user == tenant
with pytest.raises(ApplicationError):
application.authenticate_facebook(
session,
mockid,
"diff token",
"diff email",
"diff fname",
"diff lname",
UserRole.LANDLORD,
landlord,
)
def test_landlord_process_another_appliation_when_one_application_was_unsuccessful_ok(
session: Session,
application: Application,
failed_apartment_application: ApartmentApplication,
another_considered_apartment_application: ApartmentApplication,
):
assert (another_considered_apartment_application.status ==
ApartmentApplicationStatus.CONSIDERED)
assert (not session.query(ApartmentApplication).join(Contract).filter(
or_(
ApartmentApplication.status
== ApartmentApplicationStatus.PROCESSING,
ApartmentApplication.status == ApartmentApplicationStatus.AWARDED,
)).count())
application.process_apartment_application(
session, another_considered_apartment_application)
session.expire_all()
assert (another_considered_apartment_application.status ==
ApartmentApplicationStatus.PROCESSING)
assert (session.query(ApartmentApplication).join(Contract).filter(
or_(
ApartmentApplication.status ==
ApartmentApplicationStatus.PROCESSING,
ApartmentApplication.status == ApartmentApplicationStatus.AWARDED,
)).count() == 1)
def test_update_user_profile(user: User, session: Session,
application: Application):
prev_firstname = user.first_name
prev_lastname = user.last_name
prev_city = user.city
new_fname = "new updated fname"
new_lname = "new updated lname"
new_city = "new updated city"
assert prev_firstname != new_fname
assert prev_lastname != new_lname
assert prev_city != new_city
application.update_profile(
session,
user,
first_name=new_fname,
last_name=new_lname,
city=new_city,
email=user.email,
phone_number=user.phone_number,
gender=user.gender,
dob=user.dob,
)
xuser = session.query(User).get(user.id)
assert xuser.first_name == new_fname
assert xuser.last_name == new_lname
assert xuser.city == new_city
assert xuser.email == user.email
assert xuser.phone_number == user.phone_number
assert xuser.gender == user.gender
assert xuser.dob == user.dob
def test_authenticated_user_link_a_different_facebook_account_from_already_linked_one_ok(
tenant: Tenant, session: Session, application: Application):
assert session.query(User).count() == 1
assert not session.query(SocialAccount).count()
application.authenticate_facebook(
session,
"oneid",
"oneaccess_token",
"one_email",
"onefname",
"onelname",
UserRole.TENANT,
tenant,
)
assert session.query(SocialAccount).count()
saccount = session.query(SocialAccount).all()[0]
assert saccount.user == tenant
assert saccount.account_email == "one_email"
assert saccount.access_token == "oneaccess_token"
assert saccount.account_id == "oneid"
application.authenticate_facebook(
session,
"diff id",
"diff token",
"diff email",
"diff fname",
"diff lname",
UserRole.LANDLORD,
tenant,
)
saccount = session.query(SocialAccount).all()[0]
assert saccount.user == tenant
assert saccount.account_email == "diff email"
assert saccount.access_token == "diff token"
assert saccount.account_id == "diff id"
def test_tenant_update_apartment_fail(
client: TestClient,
session: Session,
landlord_auth_header: dict,
tenant_auth_header: dict,
application: Application,
):
application.create_amenity(session, "first")
application.create_amenity(session, "second")
assert not session.query(Apartment).count()
response = client.post("/api/apartments/",
json=apartment_create_data,
headers=landlord_auth_header)
assert response.status_code == 201
assert session.query(Apartment).count() == 1
apartment = session.query(Apartment).all()[0]
assert apartment.name != "updated name"
assert apartment.amenities == []
response = client.put(
f"/api/apartments/{apartment.id}",
json={
"name": "updated name",
"amenities": ["first", "second"]
},
headers=tenant_auth_header,
)
assert response.status_code == 403
def test_tenant_accept_keys_for_contract_not_signed_fail(
process_apartment_application: ApartmentApplication,
session: Session,
application: Application,
):
assert process_apartment_application.status == ApartmentApplicationStatus.PROCESSING
with pytest.raises(ApplicationError):
application.tenant_receive_keys(session, process_apartment_application)
def test_tenant_accept_keys_when_landlord_has_not_provided_keys_fail(
awarded_apartment_application: ApartmentApplication,
session: Session,
application: Application,
):
assert awarded_apartment_application.status == ApartmentApplicationStatus.AWARDED
assert not awarded_apartment_application.contract.landlord_has_provided_keys
with pytest.raises(ApplicationError):
application.tenant_receive_keys(session, awarded_apartment_application)
def test_landlord_provide_keys_for_contract_not_signed_fail(
process_apartment_application: ApartmentApplication,
session: Session,
application: Application,
):
assert process_apartment_application.status == ApartmentApplicationStatus.PROCESSING
with pytest.raises(ApplicationError):
application.provide_keys_to_tenant(session,
process_apartment_application)
def test_another_tenant_apply_for_completed_apartment_application_fail(
another_tenant: Tenant,
session: Session,
completed_apartment_application: ApartmentApplication,
application: Application,
):
with pytest.raises(ApplicationError):
application.apply_for_apartment(
session, another_tenant, completed_apartment_application.apartment)
def test_landlord_process_another_application_when_one_application_is_complete_fail(
another_considered_apartment_application: ApartmentApplication,
completed_apartment_application: ApartmentApplication,
session: Session,
application: Application,
):
with pytest.raises(ApplicationError):
application.process_apartment_application(
session, another_considered_apartment_application)
def test_tenant_sign_contract_for_application_not_in_processing_status_fail(
new_apartment_application: ApartmentApplication,
session: Session,
application: Application,
):
signed_on = datetime.utcnow()
with pytest.raises(ApplicationError):
application.tenant_signed_contract(session, new_apartment_application,
signed_on)
def test_landlord_start_move_in_process_for_application_not_in_considered_status_fail(
application: Application,
session: Session,
new_apartment_application: ApartmentApplication,
):
assert new_apartment_application.status == ApartmentApplicationStatus.NEW
with pytest.raises(ApplicationError):
application.process_apartment_application(session,
new_apartment_application)
def test_tenant_apply_for_apartment(application: Application, tenant: Tenant,
apartment: Apartment, session: Session):
assert not session.query(ApartmentApplication).count()
application.apply_for_apartment(session, tenant, apartment)
assert session.query(ApartmentApplication).count()
apartment_application = session.query(ApartmentApplication).all()[0]
assert apartment_application.tenant == tenant
assert apartment_application.apartment == apartment
assert apartment_application.status == ApartmentApplicationStatus.NEW
def test_landlord_consider_apartment_application_not_in_new_status_fail(
application: Application,
session: Session,
awarded_apartment_application: ApartmentApplication,
):
assert awarded_apartment_application.status == ApartmentApplicationStatus.AWARDED
with pytest.raises(ApplicationError):
application.consider_apartment_application(
session, awarded_apartment_application)
def completed_apartment_application(
awarded_apartment_application: ApartmentApplication,
application: Application,
session: Session,
):
application.provide_keys_to_tenant(session, awarded_apartment_application)
application.tenant_receive_keys(session, awarded_apartment_application)
assert awarded_apartment_application.status == ApartmentApplicationStatus.COMPLETED
return awarded_apartment_application
def test_create_exisiting_amenity_fail(session: Session,
application: Application):
assert not session.query(Amenity).count()
application.create_amenity(session, "hello")
assert session.query(Amenity).count() == 1
amenity = session.query(Amenity).all()[0]
assert amenity.title == "hello"
with pytest.raises(ApplicationError):
application.create_amenity(session, "hello")
def test_tenant_upload_proof_of_income(
application: Application, tenant: Tenant, file, clear_upload # noqa
):
file_extension = "pdf"
tenant_file_path: Path = (
Path(UPLOAD_PATH) / "proof_of_income" / (str(tenant.id) + "." + file_extension)
)
assert not tenant_file_path.exists()
application.upload_proof_of_income(tenant, file, file_extension)
assert tenant_file_path.exists()
def test_user_upload_copy_id_ok(
application: Application, user: User, file, clear_upload # noqa
):
file_extension = "pdf"
user_file_path: Path = (
Path(UPLOAD_PATH) / "copy_ids" / (str(user.id) + "." + file_extension)
)
assert not user_file_path.exists()
application.upload_copy_id(user, file, file_extension)
assert user_file_path.exists()
def test_landlord_percentage_profile(landlord: Landlord, file,
application: Application, clear_upload):
copy_id_path = util.get_copy_ids_path()
proof_of_income_path = util.get_proof_of_income_path()
proof_of_enrollment_path = util.get_proof_of_enrollment_path()
paths = [copy_id_path, proof_of_income_path, proof_of_enrollment_path]
assert all(not application.file_service.list_files(path) for path in paths)
assert landlord.profile_percentage == 0
application.upload_copy_id(landlord, file, "pdf")
assert landlord.profile_percentage == 30
def test_landlord_sign_contract_not_in_new_status_fail(
new_apartment_application: ApartmentApplication,
session: Session,
application: Application,
):
signed_on = datetime.utcnow()
with pytest.raises(ApplicationError):
application.landlord_signed_contract(session,
new_apartment_application,
signed_on)
def test_tenant_apply_for_already_awarded_apartment_fail(
application: Application,
awarded_apartment_application: ApartmentApplication,
another_tenant: Tenant,
session: Session,
):
assert awarded_apartment_application.status == ApartmentApplicationStatus.AWARDED
with pytest.raises(ApplicationError):
application.apply_for_apartment(
session, another_tenant, awarded_apartment_application.apartment)
def test_tenant_accept_rejected_invitation_fail(
application: Application,
session: Session,
tenant: Tenant,
booking_request: BookingRequest,
):
booking_req = application.reject_application_invitation(
session, tenant, booking_request)
with pytest.raises(ApplicationError):
application.accept_application_invitation(session, tenant, booking_req)
def test_tenant_reject_invitation_to_apply_for_apartment(
application: Application,
session: Session,
tenant: Tenant,
booking_request: BookingRequest,
):
application.reject_application_invitation(session, tenant, booking_request)
booking_req = session.query(BookingRequest).get(booking_request.id)
assert booking_req.status == BookingRequestStatus.REJECTED
assert not booking_req.apartment_application_id
def test_tenant_accept_invitation_to_apply_for_apartment(
application: Application,
session: Session,
tenant: Tenant,
booking_request: BookingRequest,
):
application.accept_application_invitation(session, tenant, booking_request)
booking_req = session.query(BookingRequest).get(booking_request.id)
assert booking_req.status == BookingRequestStatus.ACCEPTED
assert booking_req.apartment_application_id is not None
def test_landlord_reject_apartment_application_not_in_new_status_fail(
application: Application,
session: Session,
considered_apartment_application: ApartmentApplication,
):
assert (considered_apartment_application.status ==
ApartmentApplicationStatus.CONSIDERED)
with pytest.raises(ApplicationError):
application.reject_apartment_application(
session, considered_apartment_application)
def test_set_bank_detail(user: User, session: Session,
application: Application):
assert not user.bank_detail
account_name = "Test Account Name"
account_number = "Test Account Number"
application.set_bank_detail(session, user, account_name, account_number)
xuser = session.query(User).get(user.id)
assert xuser.bank_detail
assert xuser.bank_detail.account_name == account_name
assert xuser.bank_detail.account_number == account_number
assert xuser.bank_detail.user_id == user.id
def test_authenticated_user_upload_profile_photo_ok(
application: Application,
landlord: Landlord,
file: IO,
clear_upload, # noqa
):
filename = "profile1.jpg"
target_path: Path = Path(UPLOAD_PATH) / f"profile_images/{landlord.id}.jpg"
assert not target_path.exists()
application.upload_profile_image(landlord, file, filename)
assert target_path.exists()
def test_tenant_apply_for_same_apartment_again_fail(application: Application,
tenant: Tenant,
apartment: Apartment,
session: Session):
application.apply_for_apartment(session, tenant, apartment)
apartment_application = session.query(ApartmentApplication).all()[0]
assert apartment_application.tenant == tenant
assert apartment_application.apartment == apartment
assert apartment_application.status == ApartmentApplicationStatus.NEW
with pytest.raises(ApplicationError):
application.apply_for_apartment(session, tenant, apartment)
def test_invite_tenant_for_already_awarded_apartment_fail(
application: Application,
session: Session,
tenant: Tenant,
another_tenant: Tenant,
landlord: Landlord,
awarded_apartment_application,
):
with pytest.raises(ApplicationError):
application.invite_tenant_to_apply(
session, landlord, another_tenant,
awarded_apartment_application.apartment)
def test_set_looking_for(tenant: Tenant, session: Session,
application: Application):
assert not tenant.looking_for
house_type = HouseType.BUNGALOW
city = "preferred city"
max_budget = 45.78
application.set_looking_for(session, tenant, house_type, city, max_budget)
assert tenant.looking_for
assert tenant.looking_for.id
assert tenant.looking_for.house_type == HouseType.BUNGALOW
assert tenant.looking_for.city == city
assert tenant.looking_for.max_budget == max_budget