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