def test_query_performance(self, app, db_session, assert_num_queries):
# Given
now = datetime.utcnow()
pro = users_factories.UserFactory(isBeneficiary=False)
stock_1 = offers_factories.ThingStockFactory(
dateCreated=now,
dateModified=now,
dateModifiedAtLastProvider=now,
bookingLimitDatetime=now,
)
offer = stock_1.offer
stock_2 = offers_factories.ThingStockFactory(
dateCreated=now,
dateModified=now,
dateModifiedAtLastProvider=now,
bookingLimitDatetime=now,
offer=offer)
bookings_factories.BookingFactory(stock=stock_1)
bookings_factories.BookingFactory(stock=stock_1)
bookings_factories.BookingFactory(stock=stock_2)
offers_factories.UserOffererFactory(
user=pro, offerer=offer.venue.managingOfferer)
client = TestClient(app.test_client()).with_auth(email=pro.email)
check_user_has_rights_queries = 2
get_stock_queries = 1
offer_id = offer.id
# When
with assert_num_queries(testing.AUTHENTICATION_QUERIES +
check_user_has_rights_queries +
get_stock_queries):
response = client.get(f"/offers/{humanize(offer_id)}/stocks")
# Then
assert response.status_code == 200
def test_reimburses_95_percent_for_book_product_when_bookings_exceed_100000_euros(
self):
# Given
cutoff = datetime.datetime.now()
before_cutoff = cutoff - datetime.timedelta(days=1)
beneficiary = users_factories.BeneficiaryGrant18Factory(
email="*****@*****.**")
offerer1 = offers_factories.OffererFactory(siren="123456789")
offers_factories.BankInformationFactory(
bic="BDFEFR2LCCB",
iban="FR7630006000011234567890189",
offerer=offerer1)
venue1 = offers_factories.VenueFactory(managingOfferer=offerer1,
siret="12345678912345")
venue2 = offers_factories.VenueFactory(managingOfferer=offerer1,
siret="98765432154321")
venue3 = offers_factories.VenueFactory(managingOfferer=offerer1,
siret="98123432154321")
product = offers_factories.ThingProductFactory(
subcategoryId=subcategories.LIVRE_PAPIER.id)
offer1 = offers_factories.ThingOfferFactory(venue=venue1,
product=product)
offer2 = offers_factories.ThingOfferFactory(venue=venue2,
product=product)
offer3 = offers_factories.ThingOfferFactory(venue=venue3,
product=product)
paying_stock1 = offers_factories.ThingStockFactory(offer=offer1,
price=10000)
paying_stock2 = offers_factories.ThingStockFactory(offer=offer2,
price=10000)
paying_stock3 = offers_factories.ThingStockFactory(offer=offer3,
price=100000)
offers_factories.ThingStockFactory(offer=offer1, price=0)
beneficiary.deposit.amount = 120000
repository.save(beneficiary.deposit)
bookings_factories.UsedBookingFactory(user=beneficiary,
stock=paying_stock1,
dateUsed=before_cutoff,
quantity=1)
bookings_factories.UsedBookingFactory(user=beneficiary,
stock=paying_stock2,
dateUsed=before_cutoff,
quantity=1)
bookings_factories.UsedBookingFactory(user=beneficiary,
stock=paying_stock3,
dateUsed=before_cutoff,
quantity=1)
# When
generate_new_payments(cutoff, batch_date=datetime.datetime.now())
# Then
pending = get_pending_payments()
assert pending.count() == 3
assert total_amount(pending) == 115000
assert get_not_processable_payments().count() == 0
def test_records_new_payment_lines_in_database(self):
# Given
cutoff = datetime.datetime.now()
before_cutoff = cutoff - datetime.timedelta(days=1)
beneficiary = users_factories.BeneficiaryGrant18Factory(
email="*****@*****.**")
offerer = offers_factories.OffererFactory()
offer = offers_factories.ThingOfferFactory(
venue__managingOfferer=offerer)
paying_stock = offers_factories.ThingStockFactory(offer=offer)
free_stock = offers_factories.ThingStockFactory(offer=offer, price=0)
bookings_factories.UsedBookingFactory(user=beneficiary,
stock=paying_stock,
dateUsed=before_cutoff)
bookings_factories.UsedBookingFactory(user=beneficiary,
stock=paying_stock,
dateUsed=before_cutoff)
bookings_factories.UsedBookingFactory(user=beneficiary,
stock=free_stock,
dateUsed=before_cutoff)
bookings_factories.UsedBookingFactory(user=beneficiary,
stock=free_stock,
dateUsed=before_cutoff)
bookings_factories.UsedBookingFactory(user=beneficiary,
stock=paying_stock,
dateUsed=cutoff)
payment_message = payments_factories.PaymentMessageFactory(
name="ABCD123")
payments_factories.PaymentFactory(paymentMessage=payment_message)
initial_payment_count = Payment.query.count()
# When
n_queries = 1 # get_venue_ids_to_reimburse()
n_queries += 1 # fetch custom reimbursement rules
n_queries += 1 # find_bookings_eligible_for_payment_for_venue()
n_queries += 1 # insert payments
n_queries += 1 # release savepoint (commit)
n_queries += 1 # insert PENDING payment statuses
n_queries += 1 # release savepoint (commit)
n_queries += 1 # insert NOT_PROCESSABLE payment statuses
n_queries += 1 # release savepoint (commit)
with assert_num_queries(n_queries):
generate_new_payments(cutoff, batch_date=datetime.datetime.now())
# Then
assert Payment.query.count() - initial_payment_count == 2
def test_should_not_create_educational_booking_when_offer_is_not_an_event(
self):
# Given
educational_institution = educational_factories.EducationalInstitutionFactory(
)
educational_factories.EducationalYearFactory()
educational_redactor = educational_factories.EducationalRedactorFactory(
email="*****@*****.**")
stock = offers_factories.ThingStockFactory(
beginningDatetime=datetime.datetime(2021, 5, 15),
offer__isEducational=True)
redactor_informations = AuthenticatedInformation(
email=educational_redactor.email,
civility=educational_redactor.civility,
firstname=educational_redactor.firstName,
lastname=educational_redactor.lastName,
uai=educational_institution.institutionId,
)
# When
with pytest.raises(exceptions.OfferIsNotEvent) as error:
educational_api.book_educational_offer(
redactor_informations=redactor_informations,
stock_id=stock.id,
)
# Then
assert error.value.errors == {
"offer":
[f"L'offre {stock.offer.id} n'est pas une offre évènementielle"]
}
saved_bookings = EducationalBooking.query.join(Booking).filter(
Booking.stockId == stock.id).all()
assert len(saved_bookings) == 0
def test_should_set_not_processable_payments_to_retry_and_update_payments_bic_and_iban_using_venue_information(
self,
):
# Given
offerer = offers_factories.OffererFactory(name="first offerer")
stock = offers_factories.ThingStockFactory(offer__venue__managingOfferer=offerer)
booking = bookings_factories.UsedBookingFactory(stock=stock)
offers_factories.BankInformationFactory(offerer=offerer, iban="FR7611808009101234567890147", bic="CCBPFRPPVER")
not_processable_payment = payments_factories.PaymentFactory(booking=booking, amount=10, iban=None, bic=None)
payments_factories.PaymentStatusFactory(
payment=not_processable_payment, status=TransactionStatus.NOT_PROCESSABLE
)
sent_payment = payments_factories.PaymentFactory(
booking=booking, amount=10, iban="FR7630007000111234567890144", bic="BDFEFR2LCCB"
)
payments_factories.PaymentStatusFactory(payment=sent_payment, status=TransactionStatus.SENT)
new_batch_date = datetime.datetime.now()
# When
set_not_processable_payments_with_bank_information_to_retry(new_batch_date)
# Then
queried_not_processable_payment = Payment.query.filter_by(id=not_processable_payment.id).one()
assert queried_not_processable_payment.iban == "FR7611808009101234567890147"
assert queried_not_processable_payment.bic == "CCBPFRPPVER"
assert queried_not_processable_payment.batchDate == new_batch_date
def test_should_not_set_not_processable_payments_to_retry_when_bank_information_status_is_not_accepted(self):
# Given
offerer = offers_factories.OffererFactory(name="first offerer")
stock = offers_factories.ThingStockFactory(offer__venue__managingOfferer=offerer)
booking = bookings_factories.UsedBookingFactory(stock=stock)
offers_factories.BankInformationFactory(
offerer=offerer, iban=None, bic=None, status=BankInformationStatus.DRAFT
)
not_processable_payment = payments_factories.PaymentFactory(booking=booking, amount=10, iban=None, bic=None)
payments_factories.PaymentStatusFactory(
payment=not_processable_payment, status=TransactionStatus.NOT_PROCESSABLE
)
sent_payment = payments_factories.PaymentFactory(booking=booking, amount=10)
payments_factories.PaymentStatusFactory(payment=sent_payment, status=TransactionStatus.SENT)
new_batch_date = datetime.datetime.now()
# When
set_not_processable_payments_with_bank_information_to_retry(new_batch_date)
# Then
queried_not_processable_payment = Payment.query.filter_by(id=not_processable_payment.id).one()
queried_sent_payment = Payment.query.filter_by(id=sent_payment.id).one()
assert queried_not_processable_payment.iban == None
assert queried_not_processable_payment.bic == None
assert queried_not_processable_payment.batchDate != new_batch_date
assert queried_not_processable_payment.currentStatus.status == TransactionStatus.NOT_PROCESSABLE
assert queried_sent_payment.currentStatus.status == TransactionStatus.SENT
def test_should_return_thing_data_when_booking_is_on_an_online_offer(self):
# Given
stock = offers_factories.ThingStockFactory(
offer__product=offers_factories.DigitalProductFactory())
booking = bookings_factories.BookingFactory(stock=stock)
# When
mailjet_data = retrieve_data_to_warn_beneficiary_after_pro_booking_cancellation(
booking)
# Then
assert mailjet_data == {
"MJ-TemplateID": 1116690,
"MJ-TemplateLanguage": True,
"Vars": {
"can_book_again": 1,
"event_date": "",
"event_hour": "",
"is_event": 0,
"is_free_offer": 0,
"is_online": 1,
"is_thing": 0,
"offer_name": booking.stock.offer.name,
"offer_price": "10.00",
"offerer_name": booking.stock.offer.venue.managingOfferer.name,
"user_first_name": "Jeanne",
"venue_name": booking.stock.offer.venue.name,
},
}
def test_should_return_thing_data_when_booking_is_on_a_thing(self):
# Given
stock = offers_factories.ThingStockFactory()
booking = bookings_factories.IndividualBookingFactory(
stock=stock,
individualBooking__user__firstName="Georges",
individualBooking__user__lastName="Doux",
)
# When
mailjet_data = retrieve_data_to_warn_user_after_pro_booking_cancellation(
booking)
# Then
assert mailjet_data == {
"MJ-TemplateID": 1116690,
"MJ-TemplateLanguage": True,
"Vars": {
"event_date": "",
"event_hour": "",
"is_event": 0,
"is_free_offer": 0,
"is_online": 0,
"is_thing": 1,
"offer_name": booking.stock.offer.name,
"offer_price": "10.00",
"offerer_name": booking.offerer.name,
"user_first_name": "Georges",
"user_last_name": "Doux",
"venue_name": booking.venue.name,
},
}
def test_should_not_allow_booking_when_educational_offer_is_not_an_event(
self, test_data, app):
# Given
_, educational_institution, educational_redactor = test_data
stock = offer_factories.ThingStockFactory(offer__isEducational=True,
beginningDatetime=stock_date)
adage_jwt_fake_valid_token = _create_adage_valid_token_with_email(
email=educational_redactor.email,
uai=educational_institution.institutionId)
test_client = TestClient(app.test_client())
test_client.auth_header = {
"Authorization": f"Bearer {adage_jwt_fake_valid_token}"
}
# When
response = test_client.post(
"/adage-iframe/bookings",
json={
"stockId": stock.id,
},
)
# Then
assert response.status_code == 400
assert response.json == {"offer": "L'offre n'est pas un évènement"}
def test_do_not_update_if_thing_product(self):
booking_factories.IndividualBookingFactory(stock=offers_factories.ThingStockFactory())
api.auto_mark_as_used_after_event()
booking = Booking.query.first()
assert not booking.isUsed
assert booking.status is not BookingStatus.USED
assert not booking.dateUsed
def test_creates_pending_and_not_processable_payments(self):
# Given
cutoff = datetime.datetime.now()
before_cutoff = cutoff - datetime.timedelta(days=1)
beneficiary = users_factories.BeneficiaryGrant18Factory(
email="*****@*****.**")
offerer1 = offers_factories.OffererFactory(siren="123456789")
offerer2 = offers_factories.OffererFactory(siren="987654321")
offers_factories.BankInformationFactory(
bic="BDFEFR2LCCB",
iban="FR7630006000011234567890189",
offerer=offerer1)
venue1 = offers_factories.VenueFactory(managingOfferer=offerer1,
siret="12345678912345")
venue2 = offers_factories.VenueFactory(managingOfferer=offerer2,
siret="98765432154321")
offer1 = offers_factories.ThingOfferFactory(venue=venue1)
offer2 = offers_factories.ThingOfferFactory(venue=venue2)
paying_stock1 = offers_factories.ThingStockFactory(offer=offer1)
paying_stock2 = offers_factories.ThingStockFactory(offer=offer2)
free_stock1 = offers_factories.ThingStockFactory(offer=offer1, price=0)
bookings_factories.UsedBookingFactory(user=beneficiary,
stock=paying_stock1,
dateUsed=before_cutoff)
bookings_factories.UsedBookingFactory(user=beneficiary,
stock=paying_stock1,
dateUsed=before_cutoff)
bookings_factories.UsedBookingFactory(user=beneficiary,
stock=paying_stock2,
dateUsed=before_cutoff)
bookings_factories.UsedBookingFactory(user=beneficiary,
stock=free_stock1,
dateUsed=before_cutoff)
# When
generate_new_payments(cutoff, batch_date=datetime.datetime.now())
# Then
assert get_pending_payments().count() == 2
assert get_not_processable_payments().count() == 1
def test_returns_a_thing_stock_without_activation_codes(self, app):
# Given
now = datetime.utcnow()
pro = users_factories.ProFactory()
stock = offers_factories.ThingStockFactory(
dateCreated=now,
dateModified=now,
dateModifiedAtLastProvider=now,
bookingLimitDatetime=now,
)
stock_on_other_offer = offers_factories.ThingStockFactory(
offer__venue=stock.offer.venue)
offers_factories.UserOffererFactory(
user=pro, offerer=stock.offer.venue.managingOfferer)
client = TestClient(
app.test_client()).with_session_auth(email=pro.email)
# When
response = client.get(f"/offers/{humanize(stock.offer.id)}/stocks")
# Then
assert response.status_code == 200
assert stock_on_other_offer.id not in [
stock["id"] for stock in response.json["stocks"]
]
assert response.json == {
"stocks": [{
"hasActivationCodes": False,
"activationCodesExpirationDatetime": None,
"beginningDatetime": None,
"bookingLimitDatetime": "2019-10-15T00:00:00Z",
"bookingsQuantity": 0,
"dateCreated": "2019-10-15T00:00:00Z",
"dateModified": "2019-10-15T00:00:00Z",
"id": humanize(stock.id),
"isEventDeletable": True,
"isEventExpired": False,
"offerId": humanize(stock.offer.id),
"price": 10.0,
"quantity": 1000,
}],
}
def test_should_return_mailjet_data_on_thing_offer(
self, mock_is_offer_active, mock_build_pc_pro_offer_link):
# Given
stock = offers_factories.ThingStockFactory()
booking1 = bookings_factories.CancelledIndividualBookingFactory(
stock=stock, quantity=2)
booking2 = bookings_factories.IndividualBookingFactory(stock=stock,
quantity=1)
# When
mailjet_data = retrieve_offerer_booking_recap_email_data_after_user_cancellation(
booking1)
# Then
venue = stock.offer.venue
assert mailjet_data == {
"MJ-TemplateID": 780015,
"MJ-TemplateLanguage": True,
"Vars": {
"departement":
venue.departementCode,
"nom_offre":
stock.offer.name,
"lien_offre_pcpro":
"http://pc_pro.com/offer_link",
"nom_lieu":
venue.name,
"prix":
f"{stock.price}",
"is_event":
0,
"date":
"",
"heure":
"",
"quantite":
booking1.quantity,
"user_name":
booking1.publicName,
"user_email":
booking1.email,
"is_active":
0,
"nombre_resa":
1,
"users": [{
"contremarque": booking2.token,
"email": booking2.email,
"firstName": booking2.firstName,
"lastName": booking2.lastName,
}],
},
}
def test_should_return_true_when_stock_is_unlimited(self, app):
# Given
stock = offers_factories.ThingStockFactory(offer__isActive=True,
price=0,
quantity=None)
bookings_factories.IndividualBookingFactory(stock=stock, quantity=2)
# When
is_active = _is_offer_active_for_recap(stock)
# Then
assert is_active
def test_do_not_update_if_thing_product(self):
# Given
stock = offers_factories.ThingStockFactory()
bookings_factories.BookingFactory(stock=stock)
# When
update_booking_used_after_stock_occurrence()
# Then
booking = Booking.query.first()
assert not booking.isUsed
assert not booking.dateUsed
def test_quantity_update_with_cancellations_exceed_quantity(self):
# Given
stock = factories.ThingStockFactory(quantity=2)
bookings_factories.CancelledBookingFactory(stock=stock)
bookings_factories.CancelledBookingFactory(stock=stock)
bookings_factories.BookingFactory(stock=stock)
bookings_factories.BookingFactory(stock=stock)
# When
stock.quantity = 3
repository.save(stock)
# Then
assert Stock.query.get(stock.id).quantity == 3
def test_should_not_return_payments_to_retry_if_no_bank_information(self, app):
# Given
product = offers_factories.ThingProductFactory(name="Lire un livre", isNational=True)
venue = offers_factories.VenueFactory(postalCode="34000", departementCode="34")
offer = offers_factories.ThingOfferFactory(product=product, venue=venue)
stock = offers_factories.ThingStockFactory(offer=offer, price=0, quantity=2)
booking = bookings_factories.UsedIndividualBookingFactory(stock=stock, quantity=2)
payment = factories.PaymentFactory(booking=booking, amount=10)
factories.PaymentStatusFactory(payment=payment, status=TransactionStatus.NOT_PROCESSABLE)
# When
payments_to_retry = payment_queries.find_not_processable_with_bank_information()
# Then
assert payments_to_retry == []
def test_should_return_false_when_stock_is_unlimited_but_booking_date_is_past(
self, app):
# Given
stock = offers_factories.ThingStockFactory(
offer__isActive=True,
price=0,
quantity=None,
bookingLimitDatetime=datetime.now() - timedelta(days=6))
bookings_factories.IndividualBookingFactory(stock=stock, quantity=2)
# When
is_active = _is_offer_active_for_recap(stock)
# Then
assert not is_active
def test_does_not_return_soft_deleted_stock(self, app):
# Given
pro = users_factories.UserFactory(isBeneficiary=False)
stock = offers_factories.ThingStockFactory(isSoftDeleted=True)
offers_factories.UserOffererFactory(
user=pro, offerer=stock.offer.venue.managingOfferer)
client = TestClient(app.test_client()).with_auth(email=pro.email)
# When
response = client.get(f"/offers/{humanize(stock.offer.id)}/stocks")
# Then
assert response.status_code == 200
assert response.json == {
"stocks": [],
}
def test_returns_a_thing_stock(self, app):
# Given
beneficiary = users_factories.UserFactory()
stock = offers_factories.ThingStockFactory()
offer = stock.offer
# When
client = TestClient(
app.test_client()).with_auth(email=beneficiary.email)
response = client.get(f"/offers/{humanize(offer.id)}")
# Then
assert response.status_code == 200
data = response.json
assert data["stocks"][0]["cancellationLimitDate"] is None
assert data["offerType"]["canExpire"] is True
def test_returns_a_thing_stock(self, app):
# Given
beneficiary = users_factories.BeneficiaryGrant18Factory()
stock = offers_factories.ThingStockFactory()
offer = stock.offer
offer.subcategoryId = subcategories.LIVRE_PAPIER.id
repository.save(offer)
# When
client = TestClient(
app.test_client()).with_session_auth(email=beneficiary.email)
response = client.get(f"/offers/{humanize(offer.id)}")
# Then
assert response.status_code == 200
data = response.json
assert data["stocks"][0]["cancellationLimitDate"] is None
assert data["subcategoryId"] == "LIVRE_PAPIER"
def test_should_return_one_payment_info_with_error_status(self, app):
# Given
stock = offers_factories.ThingStockFactory(price=10)
now = datetime.utcnow()
booking = bookings_factories.UsedIndividualBookingFactory(
stock=stock, dateUsed=now, token="ABCDEF")
payment = payments_factories.PaymentFactory(
booking=booking,
transactionLabel=
"pass Culture Pro - remboursement 1ère quinzaine 07-2019")
payments_factories.PaymentStatusFactory(payment=payment,
status=TransactionStatus.ERROR,
detail="Iban non fourni")
# When
payments = legacy_find_all_offerer_payments(
stock.offer.venue.managingOfferer.id)
# Then
assert len(payments) == 1
assert payments[0] == (
"Doux",
"Jeanne",
None,
None,
"ABCDEF",
now,
1,
Decimal("10.00"),
stock.offer.name,
"1 boulevard Poissonnière",
stock.offer.venue.name,
stock.offer.venue.siret,
"1 boulevard Poissonnière",
Decimal("10.00"),
Decimal("1.00"),
"CF13QSDFGH456789",
"pass Culture Pro - remboursement 1ère quinzaine 07-2019",
TransactionStatus.ERROR,
"Iban non fourni",
)
def test_should_return_payment_to_retry_if_bank_information_linked_to_offerer_and_current_status_is_not_processable(
self, app
):
# Given
user_offerer = offers_factories.UserOffererFactory()
product = offers_factories.ThingProductFactory(name="Lire un livre", isNational=True)
venue = offers_factories.VenueFactory(
managingOfferer=user_offerer.offerer, postalCode="34000", departementCode="34"
)
offer = offers_factories.ThingOfferFactory(product=product, venue=venue)
stock = offers_factories.ThingStockFactory(offer=offer, price=0)
booking = bookings_factories.UsedIndividualBookingFactory(stock=stock)
not_processable_payment = factories.PaymentFactory(booking=booking, amount=10)
factories.PaymentStatusFactory(payment=not_processable_payment, status=TransactionStatus.NOT_PROCESSABLE)
offers_factories.BankInformationFactory(offerer=user_offerer.offerer)
# When
payments_to_retry = payment_queries.find_not_processable_with_bank_information()
# Then
assert not_processable_payment in payments_to_retry
def get_existing_pro_validated_user_with_validated_offerer_with_iban_validated_user_offerer_with_thing_offer_with_stock(
):
user_offerer = offers_factories.UserOffererFactory(
validationToken=None,
offerer__validationToken=None,
user__validationToken=None,
)
offers_factories.BankInformationFactory(offerer=user_offerer.offerer)
venue = offers_factories.VirtualVenueFactory(
managingOfferer=user_offerer.offerer)
venue = offers_factories.VenueFactory(managingOfferer=user_offerer.offerer)
offer = offers_factories.ThingOfferFactory(venue=venue, isActive=True)
stock = offers_factories.ThingStockFactory(offer=offer)
return {
"offer": get_offer_helper(offer),
"offerer": get_offerer_helper(user_offerer.offerer),
"stock": get_stock_helper(stock),
"user": get_pro_helper(user_offerer.user),
"venue": get_venue_helper(venue),
}
def test_make_offerer_driven_cancellation_email_for_offerer_thing_and_already_existing_booking(
self, app):
# Given
stock = offers_factories.ThingStockFactory(price=0, quantity=10)
booking = bookings_factories.IndividualBookingFactory(stock=stock,
token="12346")
booking2 = bookings_factories.IndividualBookingFactory(stock=stock,
token="12345")
ongoing_bookings = [booking2]
# When
with patch("pcapi.utils.mailing.find_ongoing_bookings_by_stock",
return_value=ongoing_bookings):
email = make_offerer_driven_cancellation_email_for_offerer(booking)
# Then
venue = stock.offer.venue
email_html = BeautifulSoup(email["Html-part"], "html.parser")
html_action = str(email_html.find("p", {"id": "action"}))
html_recap = email_html.find("p", {"id": "recap"}).text
html_recap_table = email_html.find("table", {"id": "recap-table"}).text
assert "Vous venez d'annuler" in html_action
assert booking.publicName in html_action
assert booking.email in html_action
assert f"pour {stock.offer.product.name}" in html_recap
assert f"proposé par {venue.name}" in html_recap
assert venue.address in html_recap
assert venue.city in html_recap
assert venue.postalCode in html_recap
assert booking2.firstName in html_recap_table
assert booking2.email in html_recap_table
assert booking.token not in html_recap_table
assert booking2.token not in html_recap_table
assert (
email["Subject"] ==
f"Confirmation de votre annulation de réservation pour {stock.offer.product.name}, proposé par {venue.name}"
)
def test_should_set_not_processable_payments_to_retry_and_update_payments_bic_and_iban_using_offerer_information(
self, make_transaction_label_stub
):
# Given
offerer = offers_factories.OffererFactory(name="first offerer")
stock = offers_factories.ThingStockFactory(offer__venue__managingOfferer=offerer)
booking = bookings_factories.UsedBookingFactory(stock=stock)
offers_factories.BankInformationFactory(offerer=offerer, iban="FR7611808009101234567890147", bic="CCBPFRPPVER")
not_processable_payment = payments_factories.PaymentFactory(
amount=10,
booking=booking,
bic="QSDFGH8Z555",
iban="CF13QSDFGH456789",
transactionLabel="My old transaction label",
)
payments_factories.PaymentStatusFactory(
payment=not_processable_payment, status=TransactionStatus.NOT_PROCESSABLE
)
sent_payment = payments_factories.PaymentFactory(booking=booking, amount=10)
payments_factories.PaymentStatusFactory(payment=sent_payment, status=TransactionStatus.SENT)
new_batch_date = datetime.datetime.now()
new_transaction_label = "My new transaction label"
make_transaction_label_stub.return_value = new_transaction_label
# When
set_not_processable_payments_with_bank_information_to_retry(new_batch_date)
# Then
queried_not_processable_payment = Payment.query.filter_by(id=not_processable_payment.id).one()
queried_sent_payment = Payment.query.filter_by(id=sent_payment.id).one()
assert queried_not_processable_payment.iban == "FR7611808009101234567890147"
assert queried_not_processable_payment.bic == "CCBPFRPPVER"
assert queried_not_processable_payment.batchDate == new_batch_date
assert queried_not_processable_payment.transactionLabel == new_transaction_label
assert queried_not_processable_payment.currentStatus.status == TransactionStatus.RETRY
assert queried_sent_payment.currentStatus.status == TransactionStatus.SENT
def test_should_not_return_payment_to_retry_if_bank_information_status_is_not_accepted(self, app):
# Given
user_offerer = offers_factories.UserOffererFactory()
product = offers_factories.ThingProductFactory(name="Lire un livre", isNational=True)
venue = offers_factories.VenueFactory(
managingOfferer=user_offerer.offerer, postalCode="34000", departementCode="34"
)
offer = offers_factories.ThingOfferFactory(product=product, venue=venue)
stock = offers_factories.ThingStockFactory(offer=offer, price=0)
booking = bookings_factories.UsedIndividualBookingFactory(stock=stock)
not_processable_payment = factories.PaymentFactory(
booking=booking, amount=10, iban="CF13QSDFGH456789", bic="QSDFGH8Z555"
)
factories.PaymentStatusFactory(payment=not_processable_payment, status=TransactionStatus.NOT_PROCESSABLE)
offers_factories.BankInformationFactory(
offerer=user_offerer.offerer, iban=None, bic=None, status=BankInformationStatus.DRAFT
)
# When
payments_to_retry = payment_queries.find_not_processable_with_bank_information()
# Then
assert payments_to_retry == []
def test_should_return_thing_specific_data_for_email_when_offer_is_a_thing():
stock = offers_factories.ThingStockFactory(
price=23.99,
offer__product__subcategoryId=subcategories.SUPPORT_PHYSIQUE_FILM.id,
offer__name="Super bien culturel",
)
booking = bookings_factories.IndividualBookingFactory(stock=stock, dateCreated=datetime.utcnow())
mediation = offers_factories.MediationFactory(offer=booking.stock.offer)
email_data = retrieve_data_for_beneficiary_booking_confirmation_email(booking.individualBooking)
expected = get_expected_base_email_data(
booking,
mediation,
all_things_not_virtual_thing=1,
event_date="",
event_hour="",
is_event=0,
is_single_event=0,
offer_name="Super bien culturel",
can_expire=1,
expiration_delay=30,
)
assert email_data == expected
def test_is_deletable_when_stock_is_not_an_event(self):
stock = factories.ThingStockFactory()
assert stock.isEventDeletable
def test_is_not_expired_when_stock_is_not_an_event(self):
stock = factories.ThingStockFactory()
assert not stock.isEventExpired
