def test_should_not_return_offer_ids_when_active_and_booking_limit_datetime_is_not_expired(
self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer1 = create_offer_with_event_product(is_active=True, venue=venue)
offer2 = create_offer_with_event_product(is_active=True, venue=venue)
offer3 = create_offer_with_thing_product(is_active=True, venue=venue)
offer4 = create_offer_with_thing_product(is_active=True, venue=venue)
stock1 = create_stock_from_offer(offer=offer1,
booking_limit_datetime=datetime(
2020, 1, 2, 0, 0, 0))
stock2 = create_stock_from_offer(offer=offer2,
booking_limit_datetime=datetime(
2020, 1, 2, 0, 0, 0))
stock3 = create_stock_from_offer(offer=offer3,
booking_limit_datetime=datetime(
2020, 1, 2, 0, 0, 0))
stock4 = create_stock_from_offer(offer=offer4,
booking_limit_datetime=datetime(
2020, 1, 2, 0, 0, 0))
repository.save(stock1, stock2, stock3, stock4)
# When
results = get_paginated_offer_ids_given_booking_limit_datetime_interval(
limit=4,
page=0,
from_date=datetime(2019, 12, 30, 10, 0, 0),
to_date=datetime(2019, 12, 31, 10, 0, 0))
# Then
assert len(results) == 0
def test_should_return_one_offer_id_when_offers_are_expired_exactly_since_one_day(
self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer1 = create_offer_with_event_product(is_active=True, venue=venue)
offer2 = create_offer_with_event_product(is_active=True, venue=venue)
in_range_stock = create_stock_from_offer(
offer=offer1,
booking_limit_datetime=datetime(2019, 12, 31, 10, 0, 0))
out_of_range_stock = create_stock_from_offer(
offer=offer2,
booking_limit_datetime=datetime(2019, 12, 30, 9, 59, 59))
repository.save(in_range_stock, out_of_range_stock)
# When
results = get_paginated_offer_ids_given_booking_limit_datetime_interval(
limit=2,
page=0,
from_date=datetime(2019, 12, 30, 10, 0, 0),
to_date=datetime(2019, 12, 31, 10, 0, 0))
# Then
assert len(results) == 1
assert offer1 in results
assert offer2 not in results
def should_not_return_activation_bookings(self, app):
# Given
user = create_user()
create_deposit(user)
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_event_product(
venue, event_type="ThingType.ACTIVATION")
offer2 = create_offer_with_event_product(
venue, event_type="EventType.ACTIVATION")
offer3 = create_offer_with_event_product(venue,
event_type="ThingType.ANY")
stock1 = create_stock(offer=offer1)
stock2 = create_stock(offer=offer2)
stock3 = create_stock(offer=offer3)
booking1 = create_booking(user=user, stock=stock1)
booking2 = create_booking(user=user, stock=stock2)
booking3 = create_booking(user=user, stock=stock3)
repository.save(booking1, booking2, booking3)
# When
result = BeneficiaryBookingsSQLRepository().get_beneficiary_bookings(
beneficiary_id=user.id)
# Then
assert len(result.bookings) == 1
assert result.bookings[0].id == booking3.id
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 test_nOffers_with_two_venue_providers_from_different_providers(app):
# given
provider1 = create_provider(local_class="OpenAgenda")
provider2 = create_provider(local_class="TiteLive")
repository.save(provider1, provider2)
offerer = create_offerer()
venue = create_venue(offerer)
venue_provider1 = create_venue_provider(venue, provider1)
venue_provider2 = create_venue_provider(venue, provider2)
offer_1 = create_offer_with_thing_product(
venue, last_provider_id=provider1.id, id_at_providers="offer1", last_provider=provider1
)
offer_2 = create_offer_with_event_product(
venue, last_provider_id=provider2.id, id_at_providers="offer2", last_provider=provider2
)
offer_3 = create_offer_with_event_product(
venue, last_provider_id=provider1.id, id_at_providers="offer3", last_provider=provider1
)
offer_4 = create_offer_with_thing_product(
venue, last_provider_id=provider1.id, id_at_providers="offer4", last_provider=provider1
)
repository.save(offer_1, offer_2, offer_3, offer_4, venue_provider1, venue_provider2)
# when
n_offers_for_venue_provider1 = venue_provider1.nOffers
n_offers_for_venue_provider2 = venue_provider2.nOffers
# then
assert n_offers_for_venue_provider1 == 3
assert n_offers_for_venue_provider2 == 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 test_delete_venue_and_offers_should_raise_an_attribute_error_when_at_least_one_offer_has_stocks(
self, app):
# Given
offerer = create_offerer(siren="123456789")
venue = create_venue(
offerer,
idx=1,
siret="12345678900002",
address="1 rue Vieille Adresse",
name="Vieux nom",
city="Vieilleville",
latitude="48.863",
longitude="2.36",
postal_code="75001",
)
offer1 = create_offer_with_event_product(venue)
offer2 = create_offer_with_event_product(venue)
stock = create_stock(offer=offer1)
repository.save(offer1, offer2, stock, venue)
# When
with pytest.raises(AttributeError) as e:
delete_venue_and_offers_for_venue_id(humanize(venue.id))
# Then
assert str(
e.value
) == "Offres non supprimables car au moins une contient des stocks"
def test_nOffers_with_one_venue_provider(app):
# given
provider = create_provider()
repository.save(provider)
offerer = create_offerer()
venue = create_venue(offerer)
venue_provider = create_venue_provider(venue, provider)
offer_1 = create_offer_with_thing_product(venue,
last_provider_id=provider.id,
id_at_providers="offer1",
last_provider=provider)
offer_2 = create_offer_with_event_product(venue,
last_provider_id=provider.id,
id_at_providers="offer2",
last_provider=provider)
offer_3 = create_offer_with_event_product(venue,
last_provider_id=provider.id,
id_at_providers="offer3",
last_provider=provider)
offer_4 = create_offer_with_thing_product(venue,
last_provider_id=provider.id,
id_at_providers="offer4",
last_provider=provider)
repository.save(offer_1, offer_2, offer_3, offer_4, venue_provider)
# when
n_offers = venue_provider.nOffers
# then
assert n_offers == 4
def test_should_return_one_offer_id_in_two_offers_from_second_page_when_limit_is_one(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer1 = create_offer_with_event_product(venue=venue)
offer2 = create_offer_with_event_product(venue=venue)
repository.save(offer1, offer2)
# When
offer_ids = get_paginated_offer_ids_by_venue_id(venue_id=venue.id, limit=1, page=1)
# Then
assert offer_ids == [offer2.id]
def test_nOffers(app):
offerer = create_offerer()
venue = create_venue(offerer)
offer_1 = create_offer_with_thing_product(venue)
offer_2 = create_offer_with_event_product(venue)
offer_4 = create_offer_with_event_product(venue)
offer_5 = create_offer_with_thing_product(venue)
repository.save(offer_1, offer_2, offer_4, offer_5)
# when
n_offers = venue.nOffers
# then
assert n_offers == 4
def test_should_return_one_offer_id_from_third_page_when_limit_is_1_and_three_active_offers(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer1 = create_offer_with_event_product(is_active=True, venue=venue)
offer2 = create_offer_with_event_product(is_active=False, venue=venue)
create_offer_with_thing_product(is_active=True, venue=venue)
offer4 = create_offer_with_thing_product(is_active=True, venue=venue)
repository.save(offer1, offer2)
# When
offer_ids = get_paginated_active_offer_ids(limit=1, page=2)
# Then
assert offer_ids == [offer4.id]
def test_should_return_two_offer_ids_from_first_page_when_limit_is_two_and_two_active_offers(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer1 = create_offer_with_event_product(is_active=True, venue=venue)
offer2 = create_offer_with_event_product(is_active=True, venue=venue)
create_offer_with_thing_product(is_active=True, venue=venue)
create_offer_with_thing_product(is_active=True, venue=venue)
repository.save(offer1, offer2)
# When
offer_ids = get_paginated_active_offer_ids(limit=2, page=0)
# Then
assert set(offer_ids) == {offer1.id, offer2.id}
def test_should_returns_204_with_lowercase_token(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 = users_factories.UserFactory()
booking = create_booking(user=user, stock=stock, 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
token = booking.token.lower()
response = TestClient(app.test_client()).patch(
"/v2/bookings/cancel/token/{}".format(token),
headers={
"Authorization": "Bearer " + api_key,
"Origin": "http://localhost"
},
)
# Then
assert response.status_code == 204
updated_booking = Booking.query.first()
assert updated_booking.isCancelled
def test_should_humanize_ids(self):
# Given
user = create_user(email="*****@*****.**", public_name="John Doe")
offerer = create_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,
idx=999)
event_occurrence = create_event_occurrence(
offer, beginning_datetime=datetime.utcnow())
stock = create_stock_from_event_occurrence(event_occurrence, price=12)
booking = create_booking(user=user,
quantity=3,
stock=stock,
venue=venue)
# When
response = serialize_booking(booking)
# Then
assert response["bookingId"] == humanize(booking.id)
assert response["offerId"] == offer.id
assert response["publicOfferId"] == humanize(offer.id)
def when_the_api_key_is_not_linked_to_the_right_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)
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(pro_user, booking, user_offerer, offerer2)
offererApiKey = create_api_key(offerer_id=offerer2.id)
repository.save(offererApiKey)
# When
user2_api_key = "Bearer " + offererApiKey.value
url = "/v2/bookings/keep/token/{}".format(booking.token)
response = TestClient(app.test_client()).patch(
url, headers={"Authorization": user2_api_key, "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 test_deactivate_offer(self, app):
# given
offerer = create_offerer()
venue = create_venue(offerer)
offers = [
create_offer_with_event_product(venue, is_active=True),
create_offer_with_event_product(venue, is_active=False),
]
status = False
# when
updated_offers = update_is_active_status(offers, status)
# then
for updated_offer in updated_offers:
assert not updated_offer.isActive
def test_should_return_date_of_birth_and_phone_number_when_offer_is_an_activation(
self):
# Given
user = create_user(
date_of_birth=datetime(2001, 1, 1),
email="*****@*****.**",
phone_number="0612345678",
public_name="John Doe",
)
offerer = create_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.ACTIVATION)
event_occurrence = create_event_occurrence(
offer, beginning_datetime=datetime.utcnow())
stock = create_stock_from_event_occurrence(event_occurrence, price=12)
booking = create_booking(user=user,
quantity=3,
stock=stock,
venue=venue)
# When
response = serialize_booking(booking)
# Then
assert response["dateOfBirth"] == "2001-01-01T00:00:00Z"
assert response["phoneNumber"] == "0612345678"
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_booking_is_not_provided_at_all(self, app):
# Given
user = create_user(email="*****@*****.**")
offerer = create_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(booking)
offererApiKey = create_api_key(offerer_id=offerer.id)
repository.save(offererApiKey)
# When
url = "/v2/bookings/keep/token/"
user2_api_key = "Bearer " + offererApiKey.value
response = TestClient(app.test_client()).patch(
url, headers={"Authorization": user2_api_key, "Origin": "http://localhost"}
)
# Then
assert response.status_code == 404
def test_should_return_cancelled_booking_with_payment(self, app):
# Given
beneficiary = create_user()
create_deposit(user=beneficiary)
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
stock1 = create_stock(beginning_datetime=datetime(2020, 4, 16),
offer=offer)
stock2 = create_stock(beginning_datetime=datetime(2020, 4, 16),
offer=offer)
booking1 = create_booking(stock=stock1,
user=beneficiary,
is_cancelled=True)
booking2 = create_booking(stock=stock2,
user=beneficiary,
is_cancelled=True)
payment = create_payment(offerer=offerer, booking=booking1)
repository.save(payment, booking2)
# When
bookings_result = get_bookings_cancelled_during_quarantine_with_payment(
)
# Then
assert bookings_result == [booking1]
def test_should_return_event_beginning_times_in_seconds(self, app):
# Given
in_three_days_at_eighteen_thirty = datetime.utcnow() + timedelta(
days=3)
in_four_days_at_eighteen_thirty = datetime.utcnow() + timedelta(days=4)
in_five_days_at_twenty_one_thirty = datetime.utcnow() + timedelta(
days=5, hours=3, seconds=18)
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer = create_offer_with_event_product(venue=venue)
stock1 = create_stock(
beginning_datetime=in_three_days_at_eighteen_thirty, offer=offer)
stock2 = create_stock(
beginning_datetime=in_five_days_at_twenty_one_thirty, offer=offer)
stock3 = create_stock(
beginning_datetime=in_four_days_at_eighteen_thirty, offer=offer)
repository.save(stock1, stock2, stock3)
# When
result = AlgoliaBackend.serialize_offer(offer)
# Then
eighteen_thirty_in_seconds = 66600
twenty_one_thirty_in_seconds = 77418
assert sorted(result["offer"]["times"]) == sorted(
[eighteen_thirty_in_seconds, twenty_one_thirty_in_seconds])
def when_the_booking_does_not_exists(self, app):
# Given
user = users_factories.UserFactory()
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
stock = create_stock(offer=offer)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(user_offerer, booking)
api_key = "A_MOCKED_API_KEY"
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/FAKETOKEN",
headers={
"Authorization": f"Bearer {api_key}",
"Origin": "http://localhost"
},
)
# Then
assert response.status_code == 404
assert response.json["global"] == [
"Cette contremarque n'a pas été trouvée"
]
def when_the_logged_user_has_not_rights_on_offerer(self, app):
# Given
pro_user = create_user(email="*****@*****.**",
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 = users_factories.UserFactory()
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()).with_auth(
user.email).patch("/v2/bookings/cancel/token/{}".format(
booking.token)))
# Then
assert response.status_code == 403
assert response.json["global"] == [
"Vous n'avez pas les droits d'accès suffisant pour accéder à cette information."
]
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"/v2/bookings/token/{booking_token}"
# When
response = TestClient(
app.test_client()).with_auth("*****@*****.**").get(url)
# Then
assert response.status_code == 200
def test_should_not_revert_booking_dateused_if_booking_already_has_one(
self, stub_get_bookings_cancelled_during_quarantine_with_payment,
app):
# Given
dateused = datetime(2020, 7, 3, 20, 4, 4)
beneficiary = create_user()
create_deposit(user=beneficiary)
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
stock = create_stock(beginning_datetime=datetime(2020, 4, 16),
offer=offer)
booking = create_booking(
stock=stock,
user=beneficiary,
is_cancelled=True,
date_created=datetime(2019, 7, 3, 20, 4, 4),
date_used=dateused,
)
payment = create_payment(offerer=offerer, booking=booking)
repository.save(payment)
stub_get_bookings_cancelled_during_quarantine_with_payment.return_value = [
booking
]
# When
correct_booking_status()
# Then
corrected_booking = Booking.query.get(booking.id)
assert corrected_booking.isCancelled is False
assert corrected_booking.cancellationDate is None
assert corrected_booking.isUsed is True
assert corrected_booking.dateUsed == dateused
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 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_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 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_activating_all_venue_offers(self, app):
# Given
user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
offer2 = create_offer_with_thing_product(venue)
stock1 = create_stock_from_offer(offer)
offer.isActive = False
offer2.isActive = False
repository.save(offer2, stock1, user_offerer, venue)
# When
client = TestClient(
app.test_client()).with_auth("*****@*****.**")
response = client.put(
f"/venues/{humanize(venue.id)}/offers/activate")
# Then
assert response.status_code == 200
assert response.json[0]["isActive"] == True
assert response.json[1]["isActive"] == True
offers = Offer.query.all()
assert offers[0].isActive == True
assert offers[1].isActive == True
