def test_should_change_pro_users_to_beneficiary(app):
# given
offerer_1 = create_offerer(siren="987654321")
offerer_2 = create_offerer(siren="567890342")
offerer_3 = create_offerer(siren="345987987")
AGE18_ELIGIBLE_BIRTH_DATE = datetime.now() - relativedelta(years=18, months=4)
pro_1 = users_factories.ProFactory(
dateOfBirth=AGE18_ELIGIBLE_BIRTH_DATE, email="*****@*****.**", needsToFillCulturalSurvey=False
)
pro_2 = users_factories.ProFactory(dateOfBirth=AGE18_ELIGIBLE_BIRTH_DATE, email="*****@*****.**")
pro_3 = users_factories.ProFactory(dateOfBirth=AGE18_ELIGIBLE_BIRTH_DATE, email="*****@*****.**")
user_offerer_1 = create_user_offerer(pro_1, offerer_1)
user_offerer_2 = create_user_offerer(pro_1, offerer_2)
user_offerer_3 = create_user_offerer(pro_3, offerer_3)
repository.save(user_offerer_1, user_offerer_2, user_offerer_3)
pro_users_list_to_change = [pro_1.id, pro_2.id]
# when
change_pro_users_to_beneficiary(pro_users_list_to_change)
# then
assert pro_1.has_beneficiary_role
assert pro_1.has_beneficiary_role
assert not pro_1.has_pro_role
assert pro_1.needsToFillCulturalSurvey
assert pro_1.wallet_balance == 300
assert pro_2.has_beneficiary_role
assert pro_2.has_beneficiary_role
assert not pro_2.has_pro_role
assert pro_2.needsToFillCulturalSurvey
assert pro_2.wallet_balance == 300
assert UserOfferer.query.count() == 1
def should_not_return_venues_of_non_validated_offerer(self, app: object):
# given
pro_user = create_user()
offerer_validated = create_offerer(siren="123456789")
offerer_not_validated = create_offerer(siren="987654321",
validation_token="TOKEN")
create_user_offerer(user=pro_user, offerer=offerer_validated)
create_user_offerer(user=pro_user,
offerer=offerer_not_validated,
validation_token="NEKOT")
venue_of_validated_offerer = create_venue(offerer=offerer_validated,
siret="12345678912345",
name="B")
venue_of_unvalidated_offerer = create_venue(
offerer=offerer_not_validated, siret="98765432198765", name="A")
repository.save(venue_of_validated_offerer,
venue_of_unvalidated_offerer)
expected_venue = venue_with_offerer_name_domain_converter.to_domain(
venue_of_validated_offerer)
# when
found_venues = self.venue_sql_repository.get_by_pro_identifier(
pro_user.id, False)
# then
assert len(found_venues) == 1
assert found_venues[0].name == expected_venue.name
def when_connected_user_does_not_return_unrelated_venues(self, app):
# given
theater_company = create_offerer(name="Shakespear company",
siren="987654321")
theater_administrator = create_user(email="*****@*****.**")
theater_user_offerer = create_user_offerer(theater_administrator,
theater_company)
theater_venue = create_venue(theater_company,
name="National Shakespear Theater",
siret="98765432112345")
bookshop_offerer = create_offerer(name="Bookshop",
siren="123456789")
bookshop_user = create_user(email="*****@*****.**")
bookshop_user_offerer = create_user_offerer(
bookshop_user, bookshop_offerer)
bookshop_venue = create_venue(bookshop_offerer,
name="Contes et légendes",
siret="12345678912345")
repository.save(theater_user_offerer, theater_venue,
bookshop_user_offerer, bookshop_venue)
auth_request = TestClient(
app.test_client()).with_auth(email=bookshop_user.email)
# when
response = auth_request.get("/venues")
# then
assert len(response.json) == 1
first_returned_venue = response.json[0]
assert first_returned_venue["name"] == "Contes et légendes"
def should_return_only_venues_of_pro_user(self, app: object):
# given
pro_user = create_user()
offerer = create_offerer()
other_offerer = create_offerer(siren="987654321")
create_user_offerer(user=pro_user, offerer=offerer)
venue_1 = create_venue(offerer=offerer, siret="12345678912345")
venue_2 = create_venue(offerer=offerer, siret="12345678998765")
venue_not_affiliated_to_pro_user = create_venue(offerer=other_offerer,
siret="98765432198765")
repository.save(venue_1, venue_2, venue_not_affiliated_to_pro_user)
expected_venue_1 = venue_with_offerer_name_domain_converter.to_domain(
venue_1)
expected_venue_2 = venue_with_offerer_name_domain_converter.to_domain(
venue_2)
# when
found_venues = self.venue_sql_repository.get_by_pro_identifier(
pro_user.id, False)
# then
assert len(found_venues) == 2
assert isinstance(found_venues[0], VenueWithOffererName)
found_venues_id = [venue.identifier for venue in found_venues]
assert set(found_venues_id) == {
expected_venue_1.identifier, expected_venue_2.identifier
}
def test_returns_has_physical_venues_and_has_offers(self, app):
# Given
user = create_user(email="*****@*****.**")
offerer = create_offerer()
offerer2 = create_offerer(siren="123456788")
user_offerer = create_user_offerer(user, offerer)
user_offerer2 = create_user_offerer(user, offerer2)
offerer_virtual_venue = create_venue(offerer,
is_virtual=True,
siret=None)
offerer2_physical_venue = create_venue(offerer2,
siret="12345678856734")
offerer2_virtual_venue = create_venue(offerer,
is_virtual=True,
siret=None)
offer = create_offer_with_thing_product(
offerer_virtual_venue,
thing_type=ThingType.JEUX_VIDEO_ABO,
url="http://fake.url")
offer2 = create_offer_with_thing_product(offerer2_physical_venue)
repository.save(offer, offer2, offerer2_virtual_venue,
user_offerer, user_offerer2)
# When
response = TestClient(app.test_client()).with_auth(
"*****@*****.**").get("/users/current")
# Then
assert response.json["hasPhysicalVenues"] is True
assert response.json["hasOffers"] is True
def create_industrial_user_offerers(users_by_name, offerers_by_name):
logger.info("create_industrial_user_offerers")
user_offerers_by_name = {}
# special validation
user = users_by_name["pro93 real-validation"]
offerer = offerers_by_name["414819409 lat:48.8 lon:1.48"]
user_offerers_by_name["pro93 real-validation / 414819409 lat:48.8 lon:1.48"] = create_user_offerer(
offerer=offerer, user=user
)
# loop on users
for (user_name, user) in users_by_name.items():
for (offerer_name, offerer) in offerers_by_name.items():
if (
PostalCode(offerer.postalCode).get_departement_code() != user.departementCode
or "real-validation" in user_name
):
continue
user_offerers_by_name["{} / {}".format(user_name, offerer_name)] = create_user_offerer(
offerer=offerer, user=user
)
repository.save(*user_offerers_by_name.values())
logger.info("created %d user_offerers", len(user_offerers_by_name))
return user_offerers_by_name
def test_should_change_pro_users_to_beneficiary(app):
# given
offerer_1 = create_offerer(siren="987654321")
offerer_2 = create_offerer(siren="567890342")
offerer_3 = create_offerer(siren="345987987")
pro_1 = create_user(email="*****@*****.**", is_beneficiary=False, needs_to_fill_cultural_survey=False)
pro_2 = create_user(email="*****@*****.**")
pro_3 = create_user(email="*****@*****.**")
user_offerer_1 = create_user_offerer(pro_1, offerer_1)
user_offerer_2 = create_user_offerer(pro_1, offerer_2)
user_offerer_3 = create_user_offerer(pro_3, offerer_3)
repository.save(pro_1, pro_2, user_offerer_1, user_offerer_2, user_offerer_3)
pro_users_list_to_change = [pro_1.id, pro_2.id]
# when
change_pro_users_to_beneficiary(pro_users_list_to_change)
# then
assert pro_1.isBeneficiary
assert pro_1.needsToFillCulturalSurvey
assert pro_1.wallet_balance == 500
assert pro_2.isBeneficiary
assert pro_2.needsToFillCulturalSurvey
assert pro_2.wallet_balance == 500
assert UserOfferer.query.count() == 1
def should_filter_out_non_validated_offerers(self, app):
# Given
user = create_user()
offerer1 = create_offerer(validation_token="RTYUIO")
offerer2 = create_offerer(siren="987654310")
user_offerer1 = create_user_offerer(user=user, offerer=offerer1)
user_offerer2 = create_user_offerer(user=user, offerer=offerer2)
repository.save(user_offerer1, user_offerer2)
# When
paginated_offerers = PaginatedOfferersSQLRepository(
).with_status_and_keywords(
user_id=user.id,
user_is_admin=user.isAdmin,
is_filtered_by_offerer_status=True,
only_validated_offerers=True,
pagination_limit=10,
keywords=None,
page=0,
)
# Then
assert isinstance(paginated_offerers, PaginatedOfferers)
assert paginated_offerers.total == 1
assert len(paginated_offerers.offerers) == 1
assert paginated_offerers.offerers[0].id == offerer2.id
def should_return_all_venues_of_pro_user_ordered_by_name(
self, app: object):
# given
pro_user = create_user()
offerer = create_offerer()
create_user_offerer(user=pro_user, offerer=offerer)
venue_1 = create_venue(offerer=offerer,
siret="12345678912345",
name="B")
venue_2 = create_venue(offerer=offerer,
siret="98765432198765",
name="A")
repository.save(venue_1, venue_2)
expected_venue_1 = venue_with_offerer_name_domain_converter.to_domain(
venue_1)
expected_venue_2 = venue_with_offerer_name_domain_converter.to_domain(
venue_2)
# when
found_venues = self.venue_sql_repository.get_by_pro_identifier(
pro_user.id, False)
# then
assert len(found_venues) == 2
assert found_venues[0].name == expected_venue_2.name
assert found_venues[1].name == expected_venue_1.name
def test_should_return_all_user_emails(self, app):
# Given
first_day_after_quarantine = datetime(2020, 4, 16)
today = datetime(2020, 4, 10)
tomorrow = today + timedelta(days=1)
pro = users_factories.ProFactory(email="*****@*****.**")
pro1 = users_factories.ProFactory(email="*****@*****.**")
offerer = create_offerer(siren="123456789")
user_offerer = create_user_offerer(user=pro, offerer=offerer)
venue = create_venue(offerer, siret="1234567899876")
offer = create_offer_with_event_product(venue)
stock = create_stock(beginning_datetime=tomorrow, offer=offer)
offerer1 = create_offerer(siren="987654321")
user_offerer1 = create_user_offerer(user=pro1, offerer=offerer1)
venue1 = create_venue(offerer1, siret="9876543216543")
offer1 = create_offer_with_event_product(venue1)
stock1 = create_stock(beginning_datetime=tomorrow, offer=offer1)
repository.save(stock1, stock, user_offerer, user_offerer1)
# When
pro_emails = fetch_user_emails_for_offers_with_max_stock_date_between_today_and_end_of_quarantine(
first_day_after_quarantine, today)
# Then
assert len(pro_emails) == 2
assert set(pro_emails) == {
"*****@*****.**", "*****@*****.**"
}
def should_return_linked_offerers_with_matching_keywords_in_venue_name(
self, app):
# Given
user = create_user()
offerer1 = create_offerer(name="Theatre")
offerer2 = create_offerer(name="Cinema", siren="912345678")
venue1 = create_venue(name="Les fleurs",
offerer=offerer1,
siret=None,
is_virtual=True)
venue2 = create_venue(name="Les jardins du vide",
offerer=offerer2,
siret=None,
is_virtual=True)
user_offerer1 = create_user_offerer(user=user, offerer=offerer1)
user_offerer2 = create_user_offerer(user=user, offerer=offerer2)
repository.save(user_offerer1, user_offerer2, venue1, venue2)
# When
paginated_offerers = PaginatedOfferersSQLRepository(
).with_status_and_keywords(
user_id=user.id,
user_is_admin=user.isAdmin,
is_filtered_by_offerer_status=False,
only_validated_offerers=None,
pagination_limit=10,
keywords="jardins",
page=0,
)
# Then
assert isinstance(paginated_offerers, PaginatedOfferers)
assert paginated_offerers.total == 1
assert len(paginated_offerers.offerers) == 1
def test_filter_query_where_user_is_user_offerer_and_is_validated(app):
# Given
user = create_user(email="*****@*****.**")
offerer1 = create_offerer(siren="123456789")
offerer2 = create_offerer(siren="987654321")
offerer3 = create_offerer(siren="123456780")
user_offerer1 = create_user_offerer(user, offerer1)
user_offerer2 = create_user_offerer(user, offerer2)
event1 = create_product_with_event_type(event_name="Rencontre avec Jacques Martin")
event2 = create_product_with_event_type(event_name="Concert de contrebasse")
thing1 = create_product_with_thing_type(thing_name="Jacques la fripouille")
thing2 = create_product_with_thing_type(thing_name="Belle du Seigneur")
venue1 = create_venue(offerer1, name="Bataclan", city="Paris", siret=offerer1.siren + "12345")
venue2 = create_venue(offerer2, name="Librairie la Rencontre", city="Saint Denis", siret=offerer2.siren + "54321")
venue3 = create_venue(
offerer3, name="Une librairie du méchant concurrent gripsou", city="Saint Denis", siret=offerer3.siren + "54321"
)
offer1 = create_offer_with_event_product(venue=venue1, product=event1)
offer2 = create_offer_with_event_product(venue=venue1, product=event2)
offer3 = create_offer_with_thing_product(venue=venue2, product=thing1)
offer4 = create_offer_with_thing_product(venue=venue3, product=thing2)
repository.save(user_offerer1, user_offerer2, offerer3, offer1, offer2, offer3, offer4)
# When
offers = filter_query_where_user_is_user_offerer_and_is_validated(Offer.query.join(Venue).join(Offerer), user).all()
# Then
offer_ids = [offer.id for offer in offers]
assert offer1.id in offer_ids
assert offer2.id in offer_ids
assert offer3.id in offer_ids
assert offer4.id not in offer_ids
def should_return_venues_filtered_by_offerer_id_when_provided(
self, app: object):
# given
pro_user = create_user()
wanted_offerer = create_offerer(idx=1)
unwanted_offerer = create_offerer(idx=2, siren="5654367")
create_user_offerer(user=pro_user, offerer=wanted_offerer)
create_user_offerer(user=pro_user, offerer=unwanted_offerer)
venue_from_wanted_offerer = create_venue(
name="Kléber",
offerer=wanted_offerer,
siret="12345678912345",
public_name="Librairie Kléber")
venue_from_unwanted_offerer = create_venue(name="QG FNAC",
offerer=unwanted_offerer,
siret="98765432198765")
repository.save(venue_from_wanted_offerer, venue_from_unwanted_offerer)
# when
found_venues = self.venue_sql_repository.get_by_pro_identifier(
pro_user.id, False, Identifier(1))
# then
assert len(found_venues) == 1
assert found_venues[0].name == venue_from_wanted_offerer.name
def when_user_has_rights_and_regular_offer(self, app):
# Given
user = create_user(email="*****@*****.**",
public_name="John Doe")
create_deposit(user)
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
create_user_offerer(admin_user, offerer)
venue = create_venue(offerer,
name="Venue name",
address="Venue address")
offer = create_offer_with_event_product(
venue=venue,
event_name="Event Name",
event_type=EventType.CINEMA)
four_days_from_now = datetime.utcnow() + timedelta(days=4)
event_occurrence = create_event_occurrence(
offer, beginning_datetime=four_days_from_now)
stock = create_stock_from_event_occurrence(event_occurrence,
price=12)
unconfirmed_booking = create_booking(
user=user,
quantity=3,
stock=stock,
venue=venue,
date_created=datetime.utcnow() - timedelta(hours=48))
repository.save(unconfirmed_booking)
url = f"/v2/bookings/token/{unconfirmed_booking.token}"
# When
response = TestClient(
app.test_client()).with_auth("*****@*****.**").get(url)
# Then
assert response.headers["Content-type"] == "application/json"
assert response.status_code == 200
assert response.json == {
"bookingId": humanize(unconfirmed_booking.id),
"dateOfBirth": "",
"datetime": format_into_utc_date(stock.beginningDatetime),
"ean13": "",
"email": "*****@*****.**",
"formula": "PLACE",
"isUsed": False,
"offerId": offer.id,
"offerName": "Event Name",
"offerType": "EVENEMENT",
"phoneNumber": "",
"price": 12.0,
"publicOfferId": humanize(offer.id),
"quantity": 3,
"userName": "******",
"venueAddress": "Venue address",
"venueDepartementCode": "93",
"venueName": "Venue name",
}
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 test_find_first_by_user_offerer_id_returns_the_first_offerer_that_was_created(app):
# given
user = create_user()
offerer1 = create_offerer(name="offerer1", siren="123456789")
offerer2 = create_offerer(name="offerer2", siren="789456123")
offerer3 = create_offerer(name="offerer2", siren="987654321")
user_offerer1 = create_user_offerer(user, offerer1)
user_offerer2 = create_user_offerer(user, offerer2)
repository.save(user_offerer1, user_offerer2, offerer3)
# when
offerer = find_first_by_user_offerer_id(user_offerer1.id)
# then
assert offerer.id == offerer1.id
def when_latitude_out_of_range_and_longitude_wrong_format(self, app):
# given
offerer = create_offerer(siren="302559178")
user = create_user()
user_offerer = create_user_offerer(user, offerer)
repository.save(user_offerer)
data = {
"name": "Ma venue",
"siret": "30255917810045",
"address": "75 Rue Charles Fourier, 75013 Paris",
"postalCode": "75200",
"bookingEmail": "*****@*****.**",
"city": "Paris",
"managingOffererId": humanize(offerer.id),
"latitude": -98.82387,
"longitude": "112°3534",
"isVirtual": False,
}
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
# when
response = auth_request.post("/venues", json=data)
# then
assert response.status_code == 400
assert response.json["latitude"] == [
"La latitude doit être comprise entre -90.0 et +90.0"
]
assert response.json["longitude"] == ["Format incorrect"]
def test_should_consider_the_venue_to_be_permanent(self, app):
# given
offerer = create_offerer(siren="302559178")
user = create_user()
user_offerer = create_user_offerer(user, offerer)
venue_type = create_venue_type(label="Musée")
venue_label = create_venue_label(
label="CAC - Centre d'art contemporain d'intérêt national")
repository.save(user_offerer, venue_type, venue_label)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
venue_data = {
"name": "Ma venue",
"siret": "30255917810045",
"address": "75 Rue Charles Fourier, 75013 Paris",
"postalCode": "75200",
"bookingEmail": "*****@*****.**",
"city": "Paris",
"managingOffererId": humanize(offerer.id),
"latitude": 48.82387,
"longitude": 2.35284,
"publicName": "Ma venue publique",
"venueTypeId": humanize(venue_type.id),
"venueLabelId": humanize(venue_label.id),
}
# when
auth_request.post("/venues", json=venue_data)
# then
venue = Venue.query.one()
assert venue.isPermanent == True
def when_posting_a_virtual_venue_for_managing_offerer_with_preexisting_virtual_venue(self, app):
# given
offerer = create_offerer(siren="302559178")
user = create_user()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer, name="L'encre et la plume", is_virtual=True, siret=None)
repository.save(venue, user_offerer)
venue_data = {
"name": "Ma venue",
"siret": "30255917810045",
"address": "75 Rue Charles Fourier, 75013 Paris",
"postalCode": "75200",
"bookingEmail": "*****@*****.**",
"city": "Paris",
"managingOffererId": humanize(offerer.id),
"latitude": 48.82387,
"longitude": 2.35284,
"isVirtual": True,
}
auth_request = TestClient(app.test_client()).with_auth(email=user.email)
# when
response = auth_request.post("/venues", json=venue_data)
# then
assert response.status_code == 400
assert response.json == {
"isVirtual": ["Un lieu pour les offres numériques existe déjà pour cette structure"]
}
def when_non_standard_origin_header(self, app):
# Given
user = create_user()
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(admin_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(
offerer,
venue,
price=0,
beginning_datetime=datetime.utcnow() + timedelta(hours=46),
booking_limit_datetime=datetime.utcnow() + timedelta(hours=24),
)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(booking, user_offerer)
url = f"/v2/bookings/token/{booking.token}"
# When
response = (
TestClient(app.test_client())
.with_auth("*****@*****.**")
.get(url, headers={"origin": "http://random_header.fr"})
)
# Then
assert response.status_code == 200
def when_user_has_rights_and_regular_offer_and_token_in_lower_case(
self, app):
# Given
user = create_user(email="*****@*****.**",
public_name="John Doe")
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(admin_user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(
venue, event_name="Event Name", event_type=EventType.CINEMA)
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence,
price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(user_offerer, booking)
booking_token = booking.token.lower()
url = f"/bookings/token/{booking_token}"
# When
response = TestClient(
app.test_client()).with_auth("*****@*****.**").get(url)
# Then
assert response.status_code == 200
response_json = response.json
assert response_json == {
"bookingId": humanize(booking.id),
"date": serialize(booking.stock.beginningDatetime),
"email": "*****@*****.**",
"isUsed": False,
"offerName": "Event Name",
"userName": "******",
"venueDepartementCode": "93",
}
def when_successful_and_existing_offerer_creates_editor_user_offerer_and_does_not_log_in(self, app):
# Given
json_offerer = {
"name": "Test Offerer",
"siren": "349974931",
"address": "Test adresse",
"postalCode": "75000",
"city": "Paris",
}
venue_type = create_venue_type(label="Offre numérique")
offerer = Offerer(from_dict=json_offerer)
offerer.generate_validation_token()
user = create_user(email="*****@*****.**", public_name="bobby")
user_offerer = create_user_offerer(user, offerer)
repository.save(venue_type, offerer, user_offerer)
data = BASE_DATA_PRO.copy()
# When
response = TestClient(app.test_client()).post("/users/signup/pro", json=data)
# Then
assert response.status_code == 204
assert "Set-Cookie" not in response.headers
user = User.query.filter_by(email="*****@*****.**").first()
assert user is not None
offerer = Offerer.query.filter_by(siren="349974931").first()
assert offerer is not None
user_offerer = UserOfferer.query.filter_by(user=user, offerer=offerer).first()
assert user_offerer is not None
assert user_offerer.validationToken is not None
def when_given_api_key_not_related_to_booking_offerer(self, app):
# Given
user = create_user(email="*****@*****.**")
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
offerer2 = create_offerer(siren="987654321")
user_offerer = create_user_offerer(admin_user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(admin_user, booking, user_offerer, offerer2)
offerer2ApiKey = create_api_key(offerer_id=offerer2.id)
repository.save(offerer2ApiKey)
user2ApiKey = f"Bearer {offerer2ApiKey.value}"
url = f"/v2/bookings/token/{booking.token}"
# When
response = TestClient(app.test_client()).get(
url, headers={"Authorization": user2ApiKey, "Origin": "http://localhost"}
)
# Then
assert response.status_code == 403
assert response.json["user"] == ["Vous n'avez pas les droits suffisants pour valider cette contremarque."]
def when_user_has_rights_and_email_with_special_characters_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)
stock = create_stock_from_event_occurrence(event_occurrence,
price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(user_offerer, booking)
url = f"/bookings/token/{booking.token}?email={user.email}"
# When
response = TestClient(
app.test_client()).with_auth("*****@*****.**").get(url)
# Then
assert response.status_code == 404
def when_user_has_api_key_but_token_not_found(self, app):
# Given
user = create_user(email="*****@*****.**")
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(admin_user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(admin_user, booking, user_offerer)
offererApiKey = create_api_key(offerer_id=offerer.id)
repository.save(offererApiKey)
user2ApiKey = f"Bearer {offererApiKey.value}"
url = "/v2/bookings/token/12345"
# When
response = TestClient(app.test_client()).get(
url, headers={"Authorization": user2ApiKey, "Origin": "http://localhost"}
)
# Then
assert response.status_code == 404
assert response.json["global"] == ["Cette contremarque n'a pas été trouvée"]
def should_only_return_offerers_linked_to_user(self, app):
# Given
user = create_user()
offerer1 = create_offerer()
offerer2 = create_offerer(siren="912345678")
user_offerer = create_user_offerer(user=user, offerer=offerer1)
repository.save(user_offerer, offerer2)
# When
paginated_offerers = PaginatedOfferersSQLRepository(
).with_status_and_keywords(
user_id=user.id,
user_is_admin=user.isAdmin,
is_filtered_by_offerer_status=False,
only_validated_offerers=None,
pagination_limit=10,
keywords=None,
page=0,
)
# Then
assert isinstance(paginated_offerers, PaginatedOfferers)
assert paginated_offerers.total == 1
assert len(paginated_offerers.offerers) == 1
assert paginated_offerers.offerers[0].userHasAccess == True
def when_api_key_given_not_related_to_booking_offerer(self, app):
# Given
user = create_user(email="*****@*****.**")
pro_user = create_user(email="*****@*****.**")
offerer = create_offerer()
offerer2 = create_offerer(siren="987654321")
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0, event_type=EventType.CINEMA)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(pro_user, booking, user_offerer, offerer2)
offerer_api_key = create_api_key(offerer_id=offerer2.id)
repository.save(offerer_api_key)
user2ApiKey = "Bearer " + offerer_api_key.value
# When
url = "/v2/bookings/use/token/{}".format(booking.token)
response = TestClient(app.test_client()).patch(
url, headers={"Authorization": user2ApiKey, "Origin": "http://localhost"}
)
# Then
assert response.status_code == 403
assert response.json["user"] == ["Vous n'avez pas les droits suffisants pour valider cette contremarque."]
def when_api_key_is_provided_and_rights_and_regular_offer(self, app):
# Given
user = create_user(email="*****@*****.**", public_name="John Doe")
user2 = create_user(email="*****@*****.**", public_name="Jane Doe")
offerer = create_offerer()
user_offerer = create_user_offerer(user2, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_name="Event Name", event_type=EventType.CINEMA)
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(user_offerer, booking)
offererApiKey = create_api_key(offerer_id=offerer.id)
repository.save(offererApiKey)
user2ApiKey = f"Bearer {offererApiKey.value}"
booking_token = booking.token.lower()
url = f"/v2/bookings/token/{booking_token}"
# When
response = TestClient(app.test_client()).get(
url, headers={"Authorization": user2ApiKey, "Origin": "http://localhost"}
)
# Then
assert response.status_code == 200
def expect_user_offerer_attachment_to_be_validated(self, app):
# Given
user_offerer_token = secrets.token_urlsafe(20)
offerer_token = secrets.token_urlsafe(20)
offerer = create_offerer(
siren="349974931",
address="12 boulevard de Pesaro",
city="Nanterre",
postal_code="92000",
name="Crédit Coopératif",
validation_token=offerer_token,
)
user = create_user()
user_offerer = create_user_offerer(
user, offerer, validation_token=user_offerer_token)
repository.save(offerer, user_offerer)
user_offerer_id = offerer.id
# When
response = TestClient(app.test_client()).get(
"/validate/user-offerer/" + user_offerer_token,
headers={"origin": "http://localhost:3000"})
# Then
assert response.status_code == 202
user_offerer = UserOfferer.query.filter_by(
offererId=user_offerer_id).first()
assert user_offerer.isValidated
