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