def test_make_offerer_driven_cancellation_email_for_offerer_event_when_other_booking( self, app): # Given user1 = create_user(email="*****@*****.**", first_name="John", last_name="Doe", public_name="John Doe") user2 = create_user(email="*****@*****.**", first_name="Jane", last_name="Smith", public_name="Jane S.") offerer = create_offerer(name="Test offerer") venue = create_venue(offerer, name="Le petit théâtre", address="1 rue de la Libération", city="Montreuil", postal_code="93100") offer = create_offer_with_event_product( venue, event_name="Le théâtre des ombres") event_occurrence = create_event_occurrence(offer, beginning_datetime=datetime( 2019, 7, 20, 12, 0, 0, tzinfo=timezone.utc)) stock = create_stock_from_event_occurrence(event_occurrence, price=20, quantity=10) booking1 = create_booking(user=user1, stock=stock, token="98765") booking2 = create_booking(user=user2, stock=stock, token="12345") # When with patch("pcapi.utils.mailing.find_ongoing_bookings_by_stock", return_value=[booking2]): email = make_offerer_driven_cancellation_email_for_offerer( booking1) # Then email_html = BeautifulSoup(email["Html-part"], "html.parser") html_recap_table = email_html.find("table", {"id": "recap-table"}).text assert "Prénom" in html_recap_table assert "Nom" in html_recap_table assert "Email" in html_recap_table assert "Jane" in html_recap_table assert "Smith" in html_recap_table assert "*****@*****.**" in html_recap_table assert "12345" in html_recap_table
def test_returns_correct_users_information_from_bookings_stock(self): # Given user_1 = create_user( is_beneficiary=True, departement_code="93", email="*****@*****.**", first_name="Jean", last_name="Dupont", public_name="Test", ) user_2 = create_user( is_beneficiary=True, departement_code="93", email="*****@*****.**", first_name="Jaja", last_name="Dudu", public_name="Test", ) user_3 = create_user( is_beneficiary=True, departement_code="93", email="*****@*****.**", first_name="Toto", last_name="Titi", public_name="Test", ) offerer = create_offerer() venue = create_venue( offerer=offerer, name="Test offerer", booking_email="*****@*****.**", is_virtual=True, siret=None ) thing_offer = create_offer_with_thing_product(venue, thing_type=ThingType.LIVRE_EDITION) beginning_datetime = datetime(2019, 11, 6, 14, 00, 0, tzinfo=timezone.utc) stock = create_stock_from_offer(thing_offer, price=0, quantity=10, beginning_datetime=beginning_datetime) booking_1 = create_booking(user=user_1, stock=stock, venue=venue, token="HELLO0") booking_2 = create_booking(user=user_2, stock=stock, venue=venue, token="HELLO1") booking_3 = create_booking(user=user_3, stock=stock, venue=venue, token="HELLO2") stock.bookings = [booking_1, booking_2, booking_3] # When users_informations = extract_users_information_from_bookings(stock.bookings) # Then assert users_informations == [ {"firstName": "Jean", "lastName": "Dupont", "email": "*****@*****.**", "contremarque": "HELLO0"}, {"firstName": "Jaja", "lastName": "Dudu", "email": "*****@*****.**", "contremarque": "HELLO1"}, {"firstName": "Toto", "lastName": "Titi", "email": "*****@*****.**", "contremarque": "HELLO2"}, ]
def test_reimburses_95_percent_for_book_product_when_bookings_exceed_100000_euros( self, app): # Given offerer1 = create_offerer(siren="123456789") repository.save(offerer1) bank_information = create_bank_information( bic="BDFEFR2LCCB", iban="FR7630006000011234567890189", offerer=offerer1) venue1 = create_venue(offerer1, siret="12345678912345") venue2 = create_venue(offerer1, siret="98765432154321") venue3 = create_venue(offerer1, siret="98123432154321") offer1 = create_offer_with_thing_product( venue1, thing_type=ThingType.LIVRE_EDITION, url=None) offer2 = create_offer_with_thing_product( venue2, thing_type=ThingType.LIVRE_EDITION, url=None) offer3 = create_offer_with_thing_product( venue3, thing_type=ThingType.LIVRE_EDITION, url=None) paying_stock1 = create_stock_from_offer(offer1, price=10000) paying_stock2 = create_stock_from_offer(offer2, price=10000) paying_stock3 = create_stock_from_offer(offer3, price=100000) user = create_user() deposit = create_deposit(user, amount=120000) booking1 = create_booking(user=user, stock=paying_stock1, venue=venue1, is_used=True, quantity=1) booking2 = create_booking(user=user, stock=paying_stock2, venue=venue2, is_used=True, quantity=1) booking3 = create_booking(user=user, stock=paying_stock3, venue=venue3, is_used=True, quantity=1) repository.save(deposit, booking1, booking2, booking3, bank_information) # When pending, not_processable = generate_new_payments() # Then assert len(pending) == 3 assert len(not_processable) == 0 assert sum(p.amount for p in pending) == 115000
def test_create_payment_for_booking_takes_recipient_name_and_siren_from_offerer( app): # given user = create_user() stock = create_stock(price=10, quantity=5) booking = create_booking(user=user, quantity=1, stock=stock) booking.stock.offer = Offer() offerer = create_offerer(name="Test Offerer", siren="123456789") venue = create_venue(offerer, name="Test Venue") create_bank_information(bic="QSDFGH8Z555", iban="CF13QSDFGH456789", offerer=offerer) create_bank_information(bic=None, iban=None, venue=venue) booking.stock.offer.venue = venue booking.stock.offer.venue.managingOfferer = offerer booking_reimbursement = BookingReimbursement( booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10)) # when payment = create_payment_for_booking(booking_reimbursement) # then assert payment.recipientName == "Test Offerer" assert payment.recipientSiren == "123456789"
def test_create_payment_for_booking_when_no_iban_on_venue_should_take_payment_info_from_offerer( app): # given user = create_user() stock = create_stock(price=10, quantity=5) offerer = create_offerer(name="Test Offerer") venue = create_venue(offerer, name="Test Venue") create_bank_information(bic="QsdFGH8Z555", iban="cf13QSDFGH456789", offerer=offerer) create_bank_information(bic=None, iban=None, venue=venue) booking = create_booking(user=user, quantity=1, stock=stock) booking.stock.offer = Offer() booking.stock.offer.venue = venue booking.stock.offer.venue.managingOfferer = offerer booking_reimbursement = BookingReimbursement( booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10)) # when payment = create_payment_for_booking(booking_reimbursement) # then assert payment.iban == "CF13QSDFGH456789" assert payment.bic == "QSDFGH8Z555"
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_user_has_booked_some_offers(self, app): # Given user = UserFactory( email="*****@*****.**", postalCode="93020", ) offerer = create_offerer( siren="999199987", address="2 Test adress", city="Test city", postal_code="93000", name="Test offerer" ) venue = create_venue(offerer) thing_offer = create_offer_with_thing_product(venue=None) stock = create_stock_with_thing_offer(offerer, venue, thing_offer, price=5) booking = create_booking(user=user, stock=stock, venue=venue, quantity=1) repository.save(venue, booking) # When response = TestClient(app.test_client()).with_auth("*****@*****.**").get("/beneficiaries/current") # Then assert response.json["wallet_balance"] == 495.0 assert response.json["expenses"] == [ {"domain": "all", "current": 5.0, "limit": 500.0}, {"domain": "digital", "current": 0.0, "limit": 200.0}, {"domain": "physical", "current": 5.0, "limit": 200.0}, ]
def when_booking_is_already_validated(self, app): # Given user = create_user(email="*****@*****.**") admin_user = create_user(email="*****@*****.**") offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_thing_offer(offerer, venue, offer=None, price=0) booking = create_booking(user=user, stock=stock, is_used=True, venue=venue) repository.save(admin_user, booking) url = f"/bookings/token/{booking.token}[email protected]&offer_id={humanize(stock.offerId)}" # When response = TestClient(app.test_client()).get(url) # Then assert response.status_code == 410 assert response.json["booking"] == [ "Cette réservation a déjà été validée" ]
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 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_contains_info_on_venue(self): # given user = create_user(email="*****@*****.**", idx=3) offerer = create_offerer(siren="987654321", name="Joe le Libraire") venue = create_venue(offerer, name="Jack le Sculpteur", siret="1234567891234", idx=1) offer = create_offer_with_thing_product(venue) stock = create_stock(offer=offer, price=12, quantity=5) booking = create_booking(user=user, stock=stock, date_created=datetime(2018, 2, 5), idx=5, quantity=2) payment = create_payment(booking, offerer, 35) find_date = Mock() find_date.return_value = datetime(2018, 2, 19) # when details = create_payment_details(payment, find_booking_date_used=find_date) # then assert details.venue_name == "Jack le Sculpteur" assert details.venue_siret == "1234567891234" assert details.venue_humanized_id == humanize(venue.id)
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_user_is_logged_in_and_a_favorite_booked_offer_exist(self, app): # Given user = create_user() offerer = create_offerer() venue = create_venue(offerer, postal_code="29100", siret="12345678912341") offer = create_offer_with_thing_product(venue, thumb_count=0) mediation = create_mediation(offer, is_active=True) favorite = create_favorite(mediation=mediation, offer=offer, user=user) stock = create_stock(offer=offer, price=0) booking = create_booking(user=user, stock=stock) repository.save(booking, favorite) # When response = TestClient(app.test_client()).with_auth(user.email).get("/favorites") # Then assert response.status_code == 200 assert len(response.json) == 1 favorite = response.json[0] assert "offer" in favorite assert "venue" in favorite["offer"] assert "stocks" in favorite["offer"] assert stock.price == favorite["offer"]["stocks"][0]["price"] assert booking.quantity == favorite["booking"]["quantity"] assert humanize(booking.id) in favorite["booking"]["id"] assert "validationToken" not in favorite["offer"]["venue"]
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_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_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 test_it_returns_only_payments_with_current_status_as_not_processable( self): # given user = create_user() booking = create_booking(user=user) offerer = create_offerer() payments = [ create_payment(booking, offerer, 30, status=TransactionStatus.PENDING), create_payment(booking, offerer, 30, status=TransactionStatus.NOT_PROCESSABLE), create_payment(booking, offerer, 30, status=TransactionStatus.ERROR), ] # when pending_payments = keep_only_not_processable_payments(payments) # then assert len(pending_payments) == 1 assert pending_payments[ 0].currentStatus.status == TransactionStatus.NOT_PROCESSABLE
def test_returns_as_much_payment_details_as_there_are_payments_given(self): # given offerer1, offerer2 = create_offerer(), create_offerer() user1, user2 = create_user(), create_user() payments = [ create_payment(create_booking(user=user1), offerer1, 10), create_payment(create_booking(user=user1), offerer1, 20), create_payment(create_booking(user=user2), offerer2, 30), ] # when details = create_all_payments_details(payments, find_booking_date_used=Mock()) # then assert len(details) == 3
def test_create_payment_for_booking_with_common_information(app): # given user = create_user() stock = create_stock(price=10, quantity=5) booking = create_booking(user=user, quantity=1, stock=stock) booking.stock.offer = Offer() booking.stock.offer.venue = VenueSQLEntity() offerer = create_offerer() create_bank_information(bic="QSDFGH8Z555", iban="CF13QSDFGH456789", offerer=offerer) booking.stock.offer.venue.managingOfferer = offerer booking_reimbursement = BookingReimbursement( booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10)) # when payment = create_payment_for_booking(booking_reimbursement) # then assert payment.booking == booking assert payment.amount == Decimal(10) assert payment.reimbursementRule == ReimbursementRules.PHYSICAL_OFFERS.value.description assert payment.reimbursementRate == ReimbursementRules.PHYSICAL_OFFERS.value.rate assert payment.comment is None assert payment.author == "batch" assert payment.transactionLabel == "pass Culture Pro - remboursement 2nde quinzaine 10-2018"
def test_cancel_a_booking_already_cancelled(self, app): # Given pro_user = create_user(email="Mr [email protected]", public_name="Mr Books") offerer = create_offerer(siren="793875030") user_offerer = create_user_offerer(pro_user, offerer) venue = create_venue(offerer) book_offer = create_offer_with_thing_product(venue) stock = create_stock(offer=book_offer) user = users_factories.UserFactory() booking = create_booking(user=user, stock=stock, is_cancelled=True, venue=venue) repository.save(booking, user_offerer) api_key = random_token(64) offerer_api_key = create_api_key_for_offerer(offerer, api_key) repository.save(offerer_api_key) # When response = TestClient(app.test_client()).patch( "/v2/bookings/cancel/token/{}".format(booking.token), headers={ "Authorization": "Bearer " + api_key, "Origin": "http://localhost" }, ) # Then assert response.status_code == 410 assert response.json["global"] == [ "Cette contremarque a déjà été annulée" ]
def test_contains_info_on_offer(self): # given user = create_user(email="*****@*****.**", idx=3) offerer = create_offerer(siren="987654321", name="Joe le Libraire") venue = create_venue(offerer, name="Jack le Sculpteur", siret="1234567891234") offer = create_offer_with_thing_product(venue) stock = create_stock(offer=offer, price=12, quantity=5) booking = create_booking(user=user, stock=stock, date_created=datetime(2018, 2, 5), idx=5, quantity=2) payment = create_payment(booking, offerer, 35) find_date = Mock() find_date.return_value = datetime(2018, 2, 19) # when details = create_payment_details(payment, find_booking_date_used=find_date) # then assert details.offer_name == "Test Book" assert details.offer_type == "Audiovisuel - films sur supports physiques et VOD"
def test_modify_statuses_on_given_payments(self, app): # given user = users_factories.UserFactory() booking = create_booking(user=user) offerer = booking.stock.offer.venue.managingOfferer transaction1 = create_payment_message(name="XML1") transaction2 = create_payment_message(name="XML2") transaction3 = create_payment_message(name="XML3") uuid1, uuid2, uuid3 = uuid.uuid4(), uuid.uuid4(), uuid.uuid4() payment1 = create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=transaction1) payment2 = create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid2, payment_message=transaction2) payment3 = create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=transaction3) payment4 = create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid3, payment_message=transaction1) payment5 = create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=transaction1) payment6 = create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=transaction1) repository.save(payment1, payment2, payment3, payment4, payment5, payment6) # when do_ban_payments("XML1", [payment1.id, payment5.id]) # then assert payment1.currentStatus.status == TransactionStatus.BANNED assert payment2.currentStatus.status == TransactionStatus.PENDING assert payment3.currentStatus.status == TransactionStatus.PENDING assert payment4.currentStatus.status == TransactionStatus.RETRY assert payment5.currentStatus.status == TransactionStatus.BANNED assert payment6.currentStatus.status == TransactionStatus.RETRY
def test_create_payment_for_booking_when_iban_is_on_venue_should_take_payment_info_from_venue( app): # given user = create_user() stock = create_stock(price=10, quantity=5) offerer = create_offerer(name="Test Offerer") venue = create_venue( offerer, name="Test Venue", ) booking = create_booking(user=user, quantity=1, stock=stock) create_bank_information(bic="Lajr93", iban="B135TGGEG532TG", offerer=offerer) create_bank_information(bic="LokiJU76", iban="KD98765RFGHZ788", venue=venue) booking.stock.offer = Offer() booking.stock.offer.venue = venue booking.stock.offer.venue.managingOfferer = offerer booking_reimbursement = BookingReimbursement( booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10)) # when payment = create_payment_for_booking(booking_reimbursement) # then assert payment.iban == "KD98765RFGHZ788" assert payment.bic == "LOKIJU76"
def test_should_return_empty_isbn_when_product_does_not_contain_isbn(self): # Given user = create_user(email="*****@*****.**", public_name="John Doe") offerer = create_offerer() venue = create_venue(offerer, name="Venue name", address="Venue address") product = create_product_with_thing_type( thing_name="Event Name", thing_type=ThingType.CINEMA_ABO, extra_data={}) offer = create_offer_with_thing_product(venue, product=product, idx=999) stock = create_stock(offer=offer, price=12) booking = create_booking(user=user, quantity=3, stock=stock, venue=venue) # When response = serialize_booking(booking) # Then assert response["ean13"] == ""
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 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 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 test_fnac_stock_provider_available_stock_is_sum_of_updated_available_and_bookings( self, mock_fnac_api_response, app ): # Given mock_fnac_api_response.return_value = iter([{"ref": "9780199536986", "available": 5, "price": 0}]) offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") fnac_stocks_provider = activate_provider("FnacStocks") venue_provider = create_venue_provider( venue, fnac_stocks_provider, is_active=True, venue_id_at_offer_provider="12345678912345" ) product = create_product_with_thing_type(id_at_providers="9780199536986") offer = create_offer_with_thing_product( venue, product=product, id_at_providers="9780199536986@12345678912345" ) stock = create_stock(id_at_providers="9780199536986@12345678912345", offer=offer, price=0, quantity=20) booking = create_booking(user=create_user(), quantity=1, stock=stock) repository.save(venue_provider, booking) mock_fnac_api_response.return_value = iter([{"ref": "9780199536986", "available": 66, "price": 0}]) fnac_stocks = FnacStocks(venue_provider) # When fnac_stocks.updateObjects() # Then stock = Stock.query.one() assert stock.quantity == 67
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."]