def test_returns_real_balances(self, app):
# given
user1 = create_user(email="*****@*****.**")
user2 = create_user(email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock1 = create_stock(offer=offer, price=20)
stock2 = create_stock(offer=offer, price=30)
stock3 = create_stock(offer=offer, price=40)
repository.save(stock1, stock2, stock3, user1, user2)
_create_balances_for_user1(stock1, stock2, stock3, user1, venue)
_create_balances_for_user2(stock3, user2, venue)
# when
balances = get_all_users_wallet_balances()
# then
assert balances[0].real_balance == 90
assert balances[1].real_balance == 200
def test_returns_min_year_if_no_beneficiary_import_exist(self, app):
# given
yesterday = datetime.utcnow() - timedelta(days=1)
user = create_user(date_created=yesterday)
repository.save(user)
# when
most_recent_creation_date = find_most_recent_beneficiary_creation_date_for_source(
BeneficiaryImportSources.demarches_simplifiees, 1)
# then
assert most_recent_creation_date == datetime(MINYEAR, 1, 1)
def test_returns_nothing_if_one_criteria_does_not_match(self, app):
# given
user = create_user(date_of_birth=datetime(2000, 5, 1),
first_name="Jean",
last_name="DOe")
repository.save(user)
# when
users = find_by_civility("john", "doe", datetime(2000, 5, 1))
# then
assert not users
def test_titelive_stock_provider_available_stock_is_sum_of_updated_available_and_bookings(
self, stub_get_stocks_information, app
):
# Given
stub_get_stocks_information.side_effect = [
iter(
[
{
"ref": "9780199536986",
"available": 5,
"price": 0,
}
]
)
]
offerer = create_offerer()
venue = create_venue(offerer, siret="12345678912345")
titelive_stocks_provider = activate_provider("TiteLiveStocks")
venue_provider = create_venue_provider(
venue, titelive_stocks_provider, is_active=True, venue_id_at_offer_provider="12345678912345"
)
product = create_product_with_thing_type(id_at_providers="9780199536986")
offer = create_offer_with_thing_product(
venue, product=product, id_at_providers="9780199536986@12345678912345"
)
stock = create_stock(id_at_providers="9780199536986@12345678912345", offer=offer, price=0, quantity=20)
booking = create_booking(user=create_user(), quantity=1, stock=stock)
repository.save(venue_provider, booking)
stub_get_stocks_information.side_effect = [
iter(
[
{
"ref": "9780199536986",
"available": 66,
"price": 0,
}
]
)
]
titelive_stocks = TiteLiveStocks(venue_provider)
# When
titelive_stocks.updateObjects()
# Then
stock = Stock.query.one()
assert stock.quantity == 67
def when_offerer_already_have_user_offerer_new_user_offerer_has_validation_token(
self, mock_api_entreprise, make_validation_email_object, app):
# Given
make_validation_email_object.return_value = {"Html-part": None}
mock_api_entreprise.return_value = MagicMock(
status_code=200,
text="",
json=MagicMock(
return_value=copy.deepcopy(api_entreprise_json_mock)))
user = create_user(is_beneficiary=False, is_admin=False)
user_2 = create_user(email="*****@*****.**",
is_admin=False)
offerer = create_offerer()
user_offerer = create_user_offerer(user_2,
offerer,
validation_token=None)
digital_venue_type = create_venue_type(
label=DEFAULT_DIGITAL_VENUE_LABEL)
repository.save(user, user_2, offerer, user_offerer,
digital_venue_type)
body = {
"name": "Test Offerer",
"siren": "123456789",
"address": "123 rue de Paris",
"postalCode": "93100",
"city": "Montreuil",
}
# when
response = TestClient(app.test_client()).with_auth(
user.email).post("/offerers", json=body)
# then
assert response.status_code == 201
offerer = Offerer.query.first()
created_user_offerer = (UserOfferer.query.filter(
UserOfferer.offerer == offerer).filter(
UserOfferer.user == user).one())
assert created_user_offerer.validationToken is not None
def test_should_prevent_a_used_booking_from_being_cancelled(
self, app):
# Given
pro_user = create_user(email="Mr [email protected]",
public_name="Mr Books")
offerer = create_offerer(siren="793875030")
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
book_offer = create_offer_with_event_product(venue)
stock = create_stock(offer=book_offer)
user = create_user(email="*****@*****.**", public_name="J.F")
create_deposit(user)
booking = create_booking(user=user,
stock=stock,
is_used=True,
venue=venue)
repository.save(booking, user_offerer)
api_key = random_token(64)
offerer_api_key = create_api_key_for_offerer(offerer, api_key)
repository.save(offerer_api_key)
# When
response = TestClient(app.test_client()).patch(
"/v2/bookings/cancel/token/{}".format(booking.token),
headers={
"Authorization": "Bearer " + api_key,
"Origin": "http://localhost"
},
)
# Then
assert response.status_code == 403
assert response.json["global"] == [
"Impossible d'annuler une réservation consommée"
]
updated_booking = Booking.query.first()
assert updated_booking.isUsed
assert updated_booking.isCancelled is False
def when_account_is_known(self, app):
# given
user = create_user(
civility="M.",
departement_code="93",
email="*****@*****.**",
first_name="Jean",
last_name="Smisse",
date_of_birth=datetime.datetime(2000, 1, 1),
phone_number="0612345678",
postal_code="93020",
public_name="Toto",
)
user.isEmailValidated = True
repository.save(user)
data = {
"identifier": user.email,
"password": user.clearTextPassword
}
# when
response = TestClient(app.test_client()).post("/users/signin",
json=data)
# then
assert response.status_code == 200
assert not any("password" in field.lower()
for field in response.json)
assert response.json == {
"activity": None,
"address": None,
"city": None,
"civility": "M.",
"dateCreated": format_into_utc_date(user.dateCreated),
"dateOfBirth": format_into_utc_date(user.dateOfBirth),
"departementCode": "93",
"email": "*****@*****.**",
"firstName": "Jean",
"hasAllowedRecommendations": False,
"hasOffers": False,
"hasPhysicalVenues": False,
"id": humanize(user.id),
"isAdmin": False,
"isBeneficiary": True,
"isEmailValidated": True,
"lastConnectionDate": None,
"lastName": "Smisse",
"needsToFillCulturalSurvey": False,
"phoneNumber": "0612345678",
"postalCode": "93020",
"publicName": "Toto",
}
def when_list_show_types(self, app):
# given
user = create_user()
repository.save(user)
# when
response = TestClient(app.test_client()).with_auth(
user.email).get("/showTypes")
# then
response_json = response.json
assert response.status_code == 200
assert response_json == show_types
def test_should_return_errors_when_invalid_user(mock_count_users_by_email,
app):
# Given
user = create_user(public_name="Jo")
mock_count_users_by_email.return_value = 0
# When
api_errors = validate(user)
# Then
assert api_errors.errors == {
"publicName": ["Tu dois saisir au moins 3 caractères."]
}
def test_is_validated_property_when_still_offerer_has_validation_token(
self, app):
# Given
offerer = create_offerer(siren="123456789", validation_token="AAZRER")
user = create_user(postal_code=None)
user_offerer = create_user_offerer(user, offerer)
repository.save(user_offerer)
# When
isValidated = offerer.isValidated
# Then
assert isValidated is False
def when_user_is_logged_in_and_booking_payment_exists(self, app):
# Given
user = create_user()
pro_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0)
booking = create_booking(user=user, stock=stock, venue=venue, is_used=True)
payment = create_payment(booking, offerer, Decimal(10), iban="CF13QSDFGH456789", bic="QSDFGH8Z555")
repository.save(booking, user_offerer, payment)
# When
url = "/v2/bookings/keep/token/{}".format(booking.token)
response = TestClient(app.test_client()).with_auth("*****@*****.**").patch(url)
# Then
assert response.status_code == 410
assert response.json["payment"] == ["Le remboursement est en cours de traitement"]
assert Booking.query.get(booking.id).isUsed is True
def test_check_user_can_validate_bookings_returns_true_when_user_is_authenticated_and_has_editor_rights_on_booking(
self, app):
# Given
user = create_user()
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer, None)
repository.save(user, offerer, user_offerer)
# When
result = check_user_can_validate_bookings(user, offerer.id)
# Then
assert result is True
def test_should_return_error_message_when_user_public_name_is_empty(
self, app):
# Given
user = create_user(public_name="")
api_errors = ApiErrors()
# When
api_error = validate(user, api_errors)
# Then
assert api_error.errors["publicName"] == [
"Tu dois saisir au moins 3 caractères."
]
def when_user_not_logged_in_right_email_and_wrong_offer(self, app):
# Given
user = create_user(email="*****@*****.**")
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer)
stock = create_stock_with_thing_offer(offerer,
venue,
offer=None,
price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(admin_user, booking)
url = f"/bookings/token/{booking.token}[email protected]&offer_id={humanize(123)}"
# When
response = TestClient(app.test_client()).get(url)
# Then
assert response.status_code == 404
assert response.json["global"] == [
"Cette contremarque n'a pas été trouvée"
]
def test_find_one_or_none_by_user_id_raises_exception_when_several_are_found(
app):
# Given
user = create_user(email="*****@*****.**")
offerer1 = create_offerer(siren="123456789")
offerer2 = create_offerer(siren="987654321")
user_offerer1 = create_user_offerer(user, offerer1)
user_offerer2 = create_user_offerer(user, offerer2)
repository.save(user_offerer1, user_offerer2)
# When
with pytest.raises(MultipleResultsFound):
find_one_or_none_by_user_id(user.id)
def test_save_user_offerer_raise_api_error_when_not_unique(app):
# Given
user = create_user()
offerer = create_offerer()
uo1 = create_user_offerer(user, offerer)
repository.save(user, offerer, uo1)
uo2 = create_user_offerer(user, offerer)
# When
with pytest.raises(ApiErrors) as error:
repository.save(uo2)
assert error.value.errors["global"] == ["Une entrée avec cet identifiant existe déjà dans notre base de données"]
def when_the_api_key_is_not_linked_to_the_right_offerer(self, app):
# Given
pro_user = create_user(email="Mr [email protected]",
public_name="Mr Books")
offerer = create_offerer(siren="793875030")
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
book_offer = create_offer_with_event_product(venue)
stock = create_stock(offer=book_offer)
user = create_user(email="*****@*****.**", public_name="J.F")
create_deposit(user)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(booking, user_offerer)
offerer_with_api_key = create_offerer()
repository.save(offerer_with_api_key)
api_key = random_token(64)
offerer_api_key = create_api_key_for_offerer(
offerer_with_api_key, api_key)
repository.save(offerer_api_key)
# When
response = TestClient(app.test_client()).patch(
"/v2/bookings/cancel/token/{}".format(booking.token),
headers={
"Authorization": "Bearer " + api_key,
"Origin": "http://localhost"
},
)
# Then
assert response.status_code == 403
assert response.json["user"] == [
"Vous n'avez pas les droits suffisants pour annuler cette réservation."
]
def test_find_email_of_user_offerer_should_returns_email(app):
# Given
offerer = create_offerer()
pro_user = create_user(email="*****@*****.**")
user_offerer = create_user_offerer(pro_user, offerer)
repository.save(pro_user, user_offerer)
# When
result = find_new_offerer_user_email(offerer.id)
# Then
assert result == "*****@*****.**"
def test_return_dict_for_native_under_age_user(self):
# Given
user = create_user(email="*****@*****.**", date_of_birth=datetime(1995, 2, 5))
token = users_factories.EmailValidationToken.build(user=user)
# When
activation_email_data = beneficiary_activation.get_activation_email_data_for_native(user, token)
# Then
assert activation_email_data["Vars"]["nativeAppLink"]
assert "email=fabien%2Btest%40example.net" in activation_email_data["Vars"]["nativeAppLink"]
assert not activation_email_data["Vars"]["isEligible"]
assert activation_email_data["Vars"]["isMinor"]
def test_when_user_is_admin_should_prevent_from_accessing_bookings_list(
self):
# Given
user = create_user(is_admin=True, is_beneficiary=False)
# When
with pytest.raises(UnauthorizedForAdminUser) as exception:
check_is_authorized_to_access_bookings_recap(user)
# Then
assert exception.value.errors["global"] == [
"Le statut d'administrateur ne permet pas d'accéder au suivi des réservations"
]
def test_should_return_subject_with_correct_departement_code(self):
# Given
user = create_user(departement_code="93")
offerer = create_offerer(postal_code="95490")
user_offerer = create_user_offerer(user=user, offerer=offerer)
# When
email_object = make_validation_email_object(
user_offerer=user_offerer, offerer=offerer, get_by_siren=get_by_siren_stub
)
# Then
assert email_object.get("Subject") == "95 - inscription / rattachement PRO à valider : Test Offerer"
def test_should_return_error_message_when_user_password_is_less_than_8_characters(
self, app):
# Given
user = create_user(password="******")
api_errors = ApiErrors()
# When
api_error = validate(user, api_errors)
# Then
assert api_error.errors["password"] == [
"Tu dois saisir au moins 8 caractères."
]
def test_should_return_error_message_when_admin_user_is_beneficiary(
self, app):
# Given
user = create_user(is_admin=True, is_beneficiary=True)
api_errors = ApiErrors()
# When
api_error = validate(user, api_errors)
# Then
assert api_error.errors["isBeneficiary"] == [
"Admin ne peut pas être bénéficiaire"
]
def test_real_wallet_balance_is_the_sum_of_deposits_if_no_bookings(
self, app):
# given
user = create_user()
deposit1 = create_deposit(user, amount=100)
deposit2 = create_deposit(user, amount=50)
repository.save(deposit1, deposit2)
# when
balance = user.real_wallet_balance
# then
assert balance == Decimal(150)
def when_booking_user_email_with_special_character_not_url_encoded(self, app):
# Given
user = create_user(email="*****@*****.**")
user_admin = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(user_admin, offerer, is_admin=True)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_name="Event Name")
event_occurrence = create_event_occurrence(offer, beginning_datetime=tomorrow)
stock = create_stock_from_event_occurrence(
event_occurrence, price=0, booking_limit_date=tomorrow_minus_one_hour
)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(user_offerer, booking)
url = "/bookings/token/{}?email={}".format(booking.token, user.email)
# When
response = TestClient(app.test_client()).with_auth("*****@*****.**").patch(url)
# Then
assert response.status_code == 404
def test_find_one_or_none_by_user_id_should_return_one_user_offerer_with_same_user_id(app):
# Given
user = create_user(email="*****@*****.**")
offerer = create_offerer(siren="123456789")
user_offerer = create_user_offerer(user, offerer)
repository.save(user_offerer)
# When
first_user_offerer = find_one_or_none_by_user_id(user.id)
# Then
assert isinstance(first_user_offerer, UserOfferer)
assert first_user_offerer.id == user_offerer.id
def should_return_empty_list_when_no_venues_exist(self, app: object):
# given
pro_user = create_user()
offerer = create_offerer()
user_offerer = create_user_offerer(user=pro_user, offerer=offerer)
repository.save(user_offerer)
# when
found_venues = self.venue_sql_repository.get_by_pro_identifier(
pro_user.id, False)
# then
assert found_venues == []
def test_should_not_return_error_when_user_count_raise_error_and_id_is_provided(
self, mocked_count_users_by_email, app):
# Given
user = create_user(idx=1)
mocked_count_users_by_email.return_value = IntegrityError(
"mock", "mock", "mock")
api_errors = ApiErrors()
# When
api_error = validate(user, api_errors)
# Then
assert api_error.errors == {}
def save_users_with_deposits():
user1 = create_user(
is_beneficiary=True,
email="*****@*****.**",
reset_password_token_validity_limit=datetime.utcnow() +
timedelta(hours=24),
)
user2 = create_user(
is_beneficiary=True,
email="*****@*****.**",
reset_password_token_validity_limit=datetime.utcnow() +
timedelta(hours=24),
)
user3 = create_user(
is_beneficiary=True,
email="*****@*****.**",
reset_password_token_validity_limit=datetime.utcnow() +
timedelta(hours=24),
)
user4 = create_user(
is_beneficiary=True,
email="*****@*****.**",
reset_password_token_validity_limit=datetime.utcnow() +
timedelta(hours=24),
)
user5 = create_user(
is_beneficiary=True,
email="*****@*****.**",
reset_password_token_validity_limit=datetime.utcnow() +
timedelta(hours=24),
)
deposit1 = create_deposit(user1, amount=500)
deposit2 = create_deposit(user2, amount=500)
deposit3 = create_deposit(user3, amount=500)
deposit4 = create_deposit(user4, amount=500)
deposit5 = create_deposit(user5, amount=500)
repository.save(deposit1, deposit2, deposit3, deposit4, deposit5)
logger.info("created 5 users with 500 € deposits")
return user1, user2, user3, user4, user5
def when_activation_token_exists(self, app):
# given
token = "U2NCXTNB2"
user = create_user(reset_password_token=token)
repository.save(user)
# when
request = TestClient(app.test_client()).get("/users/token/" +
token)
# then
assert request.status_code == 200
assert request.json == {}
