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."]
