def test_file_has_recipient_name_and_siren_in_creditor_info(self, app):
# Given
offerer1 = create_offerer(name="first offerer", siren="123456789")
offerer2 = create_offerer(name="second offerer", siren="987654321")
offerer3 = create_offerer()
user = create_user()
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
venue3 = create_venue(offerer3)
stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(create_offer_with_thing_product(venue2))
stock3 = create_stock_from_offer(create_offer_with_thing_product(venue3))
booking1 = create_booking(user=user, stock=stock1)
booking2 = create_booking(user=user, stock=stock2)
booking3 = create_booking(user=user, stock=stock3)
payments = [
create_payment(booking1, offerer1, Decimal(10), iban="CF13QSDFGH456789", bic="QSDFGH8Z555"),
create_payment(booking2, offerer2, Decimal(20), iban="FR14WXCVBN123456", bic="WXCVBN7B444"),
create_payment(booking3, offerer3, Decimal(20), iban=None, bic=None),
]
# When
xml = generate_message_file(payments, "BD12AZERTY123456", "AZERTY9Q666", MESSAGE_ID, "0000")
# Then
assert find_all_nodes("//ns:PmtInf/ns:CdtTrfTxInf/ns:Cdtr/ns:Nm", xml)[0] == "first offerer"
assert find_all_nodes("//ns:PmtInf/ns:CdtTrfTxInf/ns:Cdtr/ns:Id/ns:OrgId/ns:Othr/ns:Id", xml)[0] == "123456789"
assert find_all_nodes("//ns:PmtInf/ns:CdtTrfTxInf/ns:Cdtr/ns:Nm", xml)[1] == "second offerer"
assert find_all_nodes("//ns:PmtInf/ns:CdtTrfTxInf/ns:Cdtr/ns:Id/ns:OrgId/ns:Othr/ns:Id", xml)[1] == "987654321"
def test_should_not_return_offer_ids_when_active_and_booking_limit_datetime_is_not_expired(
self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer1 = create_offer_with_event_product(is_active=True, venue=venue)
offer2 = create_offer_with_event_product(is_active=True, venue=venue)
offer3 = create_offer_with_thing_product(is_active=True, venue=venue)
offer4 = create_offer_with_thing_product(is_active=True, venue=venue)
stock1 = create_stock_from_offer(offer=offer1,
booking_limit_datetime=datetime(
2020, 1, 2, 0, 0, 0))
stock2 = create_stock_from_offer(offer=offer2,
booking_limit_datetime=datetime(
2020, 1, 2, 0, 0, 0))
stock3 = create_stock_from_offer(offer=offer3,
booking_limit_datetime=datetime(
2020, 1, 2, 0, 0, 0))
stock4 = create_stock_from_offer(offer=offer4,
booking_limit_datetime=datetime(
2020, 1, 2, 0, 0, 0))
repository.save(stock1, stock2, stock3, stock4)
# When
results = get_paginated_offer_ids_given_booking_limit_datetime_interval(
limit=4,
page=0,
from_date=datetime(2019, 12, 30, 10, 0, 0),
to_date=datetime(2019, 12, 31, 10, 0, 0))
# Then
assert len(results) == 0
def test_file_has_number_of_transactions_in_payment_info(self, app):
# Given
offerer1 = create_offerer()
offerer2 = create_offerer()
offerer3 = create_offerer()
user = create_user()
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
venue3 = create_venue(offerer3)
stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(create_offer_with_thing_product(venue2))
stock3 = create_stock_from_offer(create_offer_with_thing_product(venue3))
booking1 = create_booking(user=user, stock=stock1)
booking2 = create_booking(user=user, stock=stock2)
booking3 = create_booking(user=user, stock=stock3)
payments = [
create_payment(booking1, offerer1, Decimal(10), iban="CF13QSDFGH456789", bic="QSDFGH8Z555"),
create_payment(booking2, offerer2, Decimal(20), iban="FR14WXCVBN123456", bic="WXCVBN7B444"),
create_payment(booking3, offerer3, Decimal(20), iban=None, bic=None),
]
# When
xml = generate_message_file(payments, "BD12AZERTY123456", "AZERTY9Q666", MESSAGE_ID, "0000")
# Then
assert (
find_node("//ns:PmtInf/ns:NbOfTxs", xml) == "2"
), "The number of transactions should match the distinct number of IBANs"
def test_file_has_amount_in_credit_transfer_transaction_info(self, app):
# Given
offerer1 = create_offerer(name="first offerer")
offerer2 = create_offerer(name="second offerer")
user = create_user()
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(create_offer_with_thing_product(venue1))
stock3 = create_stock_from_offer(create_offer_with_thing_product(venue2))
booking1 = create_booking(user=user, stock=stock1)
booking2 = create_booking(user=user, stock=stock2)
booking3 = create_booking(user=user, stock=stock3)
payments = [
create_payment(booking1, offerer1, Decimal(10), iban="CF13QSDFGH456789", bic="QSDFGH8Z555"),
create_payment(booking2, offerer1, Decimal(20), iban="CF13QSDFGH456789", bic="QSDFGH8Z555"),
create_payment(booking3, offerer2, Decimal(20), iban="FR14WXCVBN123456", bic="WXCVBN7B444"),
]
# When
xml = generate_message_file(payments, "BD12AZERTY123456", "AZERTY9Q666", MESSAGE_ID, "0000")
# Then
nodes_amount = find_all_nodes("//ns:PmtInf/ns:CdtTrfTxInf/ns:Amt/ns:InstdAmt", xml)
assert nodes_amount[0] == "30"
assert nodes_amount[1] == "20"
def test_file_has_control_sum_in_group_header(self, app):
# Given
user = create_user()
offerer1 = create_offerer()
offerer2 = create_offerer()
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(create_offer_with_thing_product(venue2))
booking1 = create_booking(user=user, stock=stock1)
booking2 = create_booking(user=user, stock=stock2)
payments = [
create_payment(booking1, offerer1, Decimal(10), iban="CF13QSDFGH456789", bic="QSDFGH8Z555"),
create_payment(booking1, offerer1, Decimal(20), iban="CF13QSDFGH456789", bic="QSDFGH8Z555"),
create_payment(booking2, offerer2, Decimal(30), iban=None, bic=None),
]
# When
xml = generate_message_file(payments, "BD12AZERTY123456", "AZERTY9Q666", MESSAGE_ID, "0000")
# Then
assert (
find_node("//ns:GrpHdr/ns:CtrlSum", xml) == "30"
), "The control sum should match the total amount of money to pay"
def test_file_has_iban_in_credit_transfer_transaction_info(self, app):
# Given
offerer1 = create_offerer()
offerer2 = create_offerer()
offerer3 = create_offerer()
user = create_user()
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
venue3 = create_venue(offerer3)
stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(create_offer_with_thing_product(venue2))
stock3 = create_stock_from_offer(create_offer_with_thing_product(venue3))
booking1 = create_booking(user=user, stock=stock1)
booking2 = create_booking(user=user, stock=stock2)
booking3 = create_booking(user=user, stock=stock3)
payments = [
create_payment(booking1, offerer1, Decimal(10), iban="CF13QSDFGH456789", bic="QSDFGH8Z555"),
create_payment(booking2, offerer2, Decimal(20), iban="FR14WXCVBN123456", bic="WXCVBN7B444"),
create_payment(booking3, offerer3, Decimal(20), iban=None, bic=None),
]
# When
xml = generate_message_file(payments, "BD12AZERTY123456", "AZERTY9Q666", MESSAGE_ID, "0000")
# Then
assert find_all_nodes("//ns:PmtInf/ns:CdtTrfTxInf/ns:CdtrAcct/ns:Id/ns:IBAN", xml)[0] == "CF13QSDFGH456789"
assert find_all_nodes("//ns:PmtInf/ns:CdtTrfTxInf/ns:CdtrAcct/ns:Id/ns:IBAN", xml)[1] == "FR14WXCVBN123456"
def test_file_has_hexadecimal_uuids_as_end_to_end_ids_in_transaction_info(self, mocked_uuid, app):
# Given
user = create_user()
offerer1 = create_offerer(name="first offerer")
offerer2 = create_offerer(name="second offerer")
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(create_offer_with_thing_product(venue2))
booking1 = create_booking(user=user, stock=stock1)
booking2 = create_booking(user=user, stock=stock2)
uuid1 = UUID(hex="abcd1234abcd1234abcd1234abcd1234", version=4)
uuid2 = UUID(hex="cdef5678cdef5678cdef5678cdef5678", version=4)
mocked_uuid.side_effect = [uuid1, uuid2]
payments = [
create_payment(booking1, offerer1, Decimal(10), iban="CF13QSDFGH456789", bic="QSDFGH8Z555"),
create_payment(booking2, offerer1, Decimal(20), iban="FR14WXCVBN123456", bic="WXCVBN7B444"),
]
# When
xml = generate_message_file(payments, "BD12AZERTY123456", "AZERTY9Q666", MESSAGE_ID, "0000")
# Then
nodes_id = find_all_nodes("//ns:PmtInf/ns:CdtTrfTxInf/ns:PmtId/ns:EndToEndId", xml)
assert nodes_id[0] == uuid1.hex
assert nodes_id[1] == uuid2.hex
def test_should_return_1_offer_when_there_are_one_full_stock_and_one_empty_stock(
self):
# Given
product = create_product_with_thing_type(thing_name="Lire un livre",
is_national=True)
offerer = create_offerer()
venue = create_venue(offerer,
postal_code="34000",
departement_code="34")
offer = create_offer_with_thing_product(venue=venue, product=product)
stock1 = create_stock_from_offer(offer, price=0, quantity=2)
stock2 = create_stock_from_offer(offer, price=0, quantity=2)
user = create_user()
booking1 = create_booking(user=user,
stock=stock1,
quantity=2,
venue=venue)
repository.save(booking1, stock2)
bookings_quantity = _build_bookings_quantity_subquery()
# When
offers_count = (Offer.query.join(Stock).outerjoin(
bookings_quantity, Stock.id ==
bookings_quantity.c.stockId).filter((Stock.quantity == None) | (
(Stock.quantity -
func.coalesce(bookings_quantity.c.quantity, 0)) > 0)).count())
# Then
assert offers_count == 1
def test_should_return_one_offer_id_when_offers_are_expired_exactly_since_one_day(
self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer1 = create_offer_with_event_product(is_active=True, venue=venue)
offer2 = create_offer_with_event_product(is_active=True, venue=venue)
in_range_stock = create_stock_from_offer(
offer=offer1,
booking_limit_datetime=datetime(2019, 12, 31, 10, 0, 0))
out_of_range_stock = create_stock_from_offer(
offer=offer2,
booking_limit_datetime=datetime(2019, 12, 30, 9, 59, 59))
repository.save(in_range_stock, out_of_range_stock)
# When
results = get_paginated_offer_ids_given_booking_limit_datetime_interval(
limit=2,
page=0,
from_date=datetime(2019, 12, 30, 10, 0, 0),
to_date=datetime(2019, 12, 31, 10, 0, 0))
# Then
assert len(results) == 1
assert offer1 in results
assert offer2 not in results
def test_file_has_transaction_label_in_credit_transfer_transaction_info(self, app):
# Given
offerer1 = create_offerer(name="first offerer")
offerer2 = create_offerer(name="second offerer")
offerer3 = create_offerer(name="third offerer")
user = create_user()
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
venue3 = create_venue(offerer3)
stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(create_offer_with_thing_product(venue2))
stock3 = create_stock_from_offer(create_offer_with_thing_product(venue3))
booking1 = create_booking(user=user, stock=stock1)
booking2 = create_booking(user=user, stock=stock2)
booking3 = create_booking(user=user, stock=stock3)
payments = [
create_payment(
booking1,
offerer1,
Decimal(10),
iban="CF13QSDFGH456789",
bic="QSDFGH8Z555",
transaction_label="remboursement 1ère quinzaine 09-2018",
),
create_payment(
booking2,
offerer2,
Decimal(20),
iban="FR14WXCVBN123456",
bic="WXCVBN7B444",
transaction_label="remboursement 1ère quinzaine 09-2018",
),
create_payment(
booking3,
offerer3,
Decimal(20),
iban=None,
bic=None,
transaction_label="remboursement 1ère quinzaine 09-2018",
),
]
# When
xml = generate_message_file(payments, "BD12AZERTY123456", "AZERTY9Q666", MESSAGE_ID, "0000")
# Then
assert (
find_all_nodes("//ns:PmtInf/ns:CdtTrfTxInf/ns:RmtInf/ns:Ustrd", xml)[0]
== "remboursement 1ère quinzaine 09-2018"
)
assert (
find_all_nodes("//ns:PmtInf/ns:CdtTrfTxInf/ns:RmtInf/ns:Ustrd", xml)[1]
== "remboursement 1ère quinzaine 09-2018"
)
def test_generate_file_checksum_returns_a_checksum_of_the_file(mocked_uuid, app):
# given
offerer1 = create_offerer(name="first offerer", siren="123456789")
offerer2 = create_offerer(name="second offerer", siren="123456789")
user = create_user()
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(create_offer_with_thing_product(venue1))
stock3 = create_stock_from_offer(create_offer_with_thing_product(venue2))
booking1 = create_booking(user=user, stock=stock1)
booking2 = create_booking(user=user, stock=stock2)
booking3 = create_booking(user=user, stock=stock3)
payments = [
create_payment(
booking1,
offerer1,
Decimal(10),
iban="CF13QSDFGH456789",
bic="QSDFGH8Z555",
transaction_label="pass Culture Pro - remboursement 2nde quinzaine 07-2018",
),
create_payment(
booking2,
offerer1,
Decimal(20),
iban="CF13QSDFGH456789",
bic="QSDFGH8Z555",
transaction_label="pass Culture Pro - remboursement 2nde quinzaine 07-2018",
),
create_payment(
booking3,
offerer2,
Decimal(20),
iban="FR14WXCVBN123456",
bic="WXCVBN7B444",
transaction_label="pass Culture Pro - remboursement 2nde quinzaine 07-2018",
),
]
uuid1 = UUID(hex="abcd1234abcd1234abcd1234abcd1234", version=4)
uuid2 = UUID(hex="cdef5678cdef5678cdef5678cdef5678", version=4)
mocked_uuid.side_effect = [uuid1, uuid2]
xml = generate_message_file(payments, "BD12AZERTY123456", "AZERTY9Q666", MESSAGE_ID, "0000")
# when
checksum = generate_file_checksum(xml)
# then
assert checksum == b"\x16\x91\x0c\x11~Hs\xc5\x1a\xa3W1\x13\xbf!jq@\xea <h&\xef\x1f\xaf\xfc\x7fO\xc8\x82"
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_quantity_stocks_can_be_changed_even_when_bookings_with_cancellations_exceed_quantity(
app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, quantity=2, price=0)
repository.save(stock)
user1 = create_user()
user2 = create_user(email="*****@*****.**")
cancelled_booking1 = create_booking(user=user1,
stock=stock,
is_cancelled=True,
quantity=1)
cancelled_booking2 = create_booking(user=user1,
stock=stock,
is_cancelled=True,
quantity=1)
booking1 = create_booking(user=user1,
stock=stock,
is_cancelled=False,
quantity=1)
booking2 = create_booking(user=user2,
stock=stock,
is_cancelled=False,
quantity=1)
repository.save(cancelled_booking1, cancelled_booking2, booking1, booking2)
stock.quantity = 3
# Then the following should not raise
repository.save(stock)
def test_should_return_payment_to_retry_if_bank_information_linked_to_venue_and_current_status_is_not_processable(
self, app):
# Given
offerer = create_offerer()
user = users_factories.UserFactory()
venue = create_venue(offerer)
stock = create_stock_from_offer(create_offer_with_thing_product(venue),
price=0)
booking = create_booking(user=user, stock=stock)
not_processable_payment = create_payment(
booking,
offerer,
10,
status=TransactionStatus.NOT_PROCESSABLE,
iban="CF13QSDFGH456789",
bic="QSDFGH8Z555")
bank_information = create_bank_information(venue=venue)
repository.save(not_processable_payment, bank_information)
# When
payments_to_retry = payment_queries.find_not_processable_with_bank_information(
)
# Then
assert not_processable_payment in payments_to_retry
def test_should_return_thing_data_when_booking_is_on_an_online_offer(self):
# Given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue,
url="http://online.offer")
stock = create_stock_from_offer(offer, price=15)
booking = create_booking(user=user, stock=stock)
# When
mailjet_data = retrieve_data_to_warn_beneficiary_after_pro_booking_cancellation(
booking)
# Then
assert mailjet_data == {
"FromEmail": "*****@*****.**",
"MJ-TemplateID": 1116690,
"MJ-TemplateLanguage": True,
"To": "*****@*****.**",
"Vars": {
"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": "15",
"offerer_name": booking.stock.offer.venue.managingOfferer.name,
"user_first_name": user.firstName,
"venue_name": booking.stock.offer.venue.name,
},
}
def when_activating_all_venue_offers(self, app):
# Given
user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
offer2 = create_offer_with_thing_product(venue)
stock1 = create_stock_from_offer(offer)
offer.isActive = False
offer2.isActive = False
repository.save(offer2, stock1, user_offerer, venue)
# When
client = TestClient(
app.test_client()).with_auth("*****@*****.**")
response = client.put(
f"/venues/{humanize(venue.id)}/offers/activate")
# Then
assert response.status_code == 200
assert response.json[0]["isActive"] == True
assert response.json[1]["isActive"] == True
offers = Offer.query.all()
assert offers[0].isActive == True
assert offers[1].isActive == True
def create_industrial_thing_stocks(thing_offers_by_name):
logger.info("create_industrial_thing_stocks")
thing_stocks_by_name = {}
short_names_to_increase_price = []
thing_offer_items = list(thing_offers_by_name.items())
thing_offer_items_with_stocks = remove_every(thing_offer_items, THING_OFFERS_WITH_STOCK_REMOVE_MODULO)
for thing_offer_item_with_stocks in thing_offer_items_with_stocks:
(thing_offer_with_stocks_name, thing_offer_with_stocks) = thing_offer_item_with_stocks
quantity = 20
short_name = get_occurrence_short_name(thing_offer_with_stocks_name)
price = get_price_by_short_name(short_name)
price_counter = short_names_to_increase_price.count(short_name)
if price_counter > 2:
price = price + price_counter
short_names_to_increase_price.append(short_name)
name = thing_offer_with_stocks_name + " / " + str(quantity) + " / " + str(price)
thing_stocks_by_name[name] = create_stock_from_offer(thing_offer_with_stocks, quantity=quantity, price=price)
repository.save(*thing_stocks_by_name.values())
logger.info("created %d thing_stocks", len(thing_stocks_by_name))
def test_send_transactions_with_malformed_iban_on_payments_gives_them_an_error_status_with_a_cause(
app):
# given
offerer = create_offerer(name="first offerer")
user = create_user()
venue = create_venue(offerer)
stock = create_stock_from_offer(create_offer_with_thing_product(venue))
booking = create_booking(user=user, stock=stock)
deposit = create_deposit(user, amount=500)
payments = [
create_payment(booking,
offerer,
10,
iban="CF 13QSDFGH45 qbc //",
bic="QSDFGH8Z555"),
]
repository.save(deposit, *payments)
app.mailjet_client.send.create.return_value = Mock(status_code=400)
# when
with pytest.raises(DocumentInvalid):
send_transactions(payments, "BD12AZERTY123456", "AZERTY9Q666", "0000",
["*****@*****.**"])
# then
updated_payments = Payment.query.all()
for payment in updated_payments:
assert len(payment.statuses) == 2
assert payment.currentStatus.status == TransactionStatus.NOT_PROCESSABLE
assert (
payment.currentStatus.detail ==
"Element '{urn:iso:std:iso:20022:tech:xsd:pain.001.001.03}IBAN': "
"[facet 'pattern'] The value 'CF 13QSDFGH45 qbc //' is not accepted "
"by the pattern '[A-Z]{2,2}[0-9]{2,2}[a-zA-Z0-9]{1,30}'., line 76")
def test_reimburses_offerer_if_he_has_more_than_20000_euros_in_bookings_on_several_venues(
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)
offer2 = create_offer_with_thing_product(venue2)
offer3 = create_offer_with_thing_product(venue3)
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=10000)
user = create_user()
deposit = create_deposit(user, amount=50000)
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) == 30000
def test_returns_a_tuple_of_pending_and_not_processable_payments(
self, app):
# Given
offerer1 = create_offerer(siren="123456789")
offerer2 = create_offerer(siren="987654321")
repository.save(offerer1)
bank_information = create_bank_information(
bic="BDFEFR2LCCB",
iban="FR7630006000011234567890189",
offerer=offerer1)
venue1 = create_venue(offerer1, siret="12345678912345")
venue2 = create_venue(offerer2, siret="98765432154321")
offer1 = create_offer_with_thing_product(venue1)
offer2 = create_offer_with_thing_product(venue2)
paying_stock1 = create_stock_from_offer(offer1)
paying_stock2 = create_stock_from_offer(offer2)
free_stock1 = create_stock_from_offer(offer1, price=0)
user = create_user()
deposit = create_deposit(user, amount=500)
booking1 = create_booking(user=user,
stock=paying_stock1,
venue=venue1,
is_used=True)
booking2 = create_booking(user=user,
stock=paying_stock1,
venue=venue1,
is_used=True)
booking3 = create_booking(user=user,
stock=paying_stock2,
venue=venue2,
is_used=True)
booking4 = create_booking(user=user,
stock=free_stock1,
venue=venue1,
is_used=True)
repository.save(deposit, booking1, booking2, booking3, booking4,
bank_information)
# When
pending, not_processable = generate_new_payments()
# Then
assert len(pending) == 2
assert len(not_processable) == 1
def test_should_return_mailjet_data_with_correct_information_when_offer_is_an_event(
self, build_pc_pro_offer_link):
# Given
user = create_user(public_name="John Doe",
first_name="John",
last_name="Doe",
email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer, name="Venue name")
offer = create_offer_with_event_product(venue, event_name="My Event")
stock = create_stock_from_offer(offer,
price=12.52,
beginning_datetime=datetime(
2019, 10, 9, 10, 20, 00))
booking = create_booking(user,
stock=stock,
venue=venue,
quantity=2,
token="12345")
bookings = [booking]
# When
mailjet_data = retrieve_offerer_bookings_recap_email_data_after_offerer_cancellation(
bookings)
# Then
assert mailjet_data == {
"MJ-TemplateID": 1116333,
"MJ-TemplateLanguage": True,
"Vars": {
"offer_name":
"My Event",
"lien_offre_pcpro":
"http://pc_pro.com/offer_link",
"venue_name":
"Venue name",
"price":
"12.52",
"is_event":
1,
"event_date":
"09-Oct-2019",
"event_hour":
"12h20",
"quantity":
2,
"reservations_number":
1,
"users": [{
"countermark": "12345",
"email": "*****@*****.**",
"firstName": "John",
"lastName": "Doe"
}],
},
}
def test_populate_dict_on_soft_deleted_object_raises_DeletedRecordException(
app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
stock = create_stock_from_offer(create_offer_with_event_product(venue))
stock.isSoftDeleted = True
repository.save(stock)
# When
with pytest.raises(DeletedRecordException):
stock.populate_from_dict({"quantity": 5})
def test_only_returns_payments_with_given_message(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
paying_stock = create_stock_from_offer(offer)
free_stock = create_stock_from_offer(offer, price=0)
user = create_user()
create_deposit(user)
booking1 = create_booking(user=user,
stock=paying_stock,
venue=venue,
is_used=True)
booking2 = create_booking(user=user,
stock=paying_stock,
venue=venue,
is_used=True)
booking3 = create_booking(user=user,
stock=paying_stock,
venue=venue,
is_used=True)
booking4 = create_booking(user=user,
stock=free_stock,
venue=venue,
is_used=True)
payment1 = create_payment(booking1,
offerer,
10,
payment_message_name="ABCD123")
payment2 = create_payment(booking2,
offerer,
10,
payment_message_name="EFGH456")
repository.save(payment1, payment2, booking3, booking4)
# When
payements_by_id = payment_queries.get_payments_by_message_id("ABCD123")
# Then
assert len(payements_by_id) == 1
assert payements_by_id[0].paymentMessage.name == "ABCD123"
def should_not_get_offer_with_valid_stocks(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer = create_offer_with_event_product(is_active=True, venue=venue)
expired_stock = create_stock_from_offer(
offer=offer, booking_limit_datetime=datetime(2019, 12, 31))
valid_stock = create_stock_from_offer(offer=offer,
booking_limit_datetime=datetime(
2020, 1, 30))
repository.save(expired_stock, valid_stock)
# When
results = get_paginated_offer_ids_given_booking_limit_datetime_interval(
limit=2,
page=0,
from_date=datetime(2019, 12, 30, 10, 0, 0),
to_date=datetime(2019, 12, 31, 10, 0, 0))
# Then
assert results == []
def test_make_offerer_driven_cancellation_email_for_offerer_thing_and_already_existing_booking(
self, app):
# Given
user = create_user(email="*****@*****.**",
first_name="John",
last_name="Doe",
public_name="John Doe")
offerer = create_offerer(name="Test offerer")
venue = create_venue(offerer,
name="La petite librairie",
address="1 rue de la Libération",
city="Montreuil",
postal_code="93100")
thing_product = create_product_with_thing_type(
thing_name="Le récit de voyage")
offer = create_offer_with_thing_product(venue=venue,
product=thing_product)
stock = create_stock_from_offer(offer, price=0, quantity=10)
booking = create_booking(user=user, stock=stock, token="12346")
user2 = create_user(email="*****@*****.**",
first_name="James",
last_name="Bond",
public_name="James Bond")
booking2 = create_booking(user=user2, 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
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 "John Doe" in html_action
assert "*****@*****.**" in html_action
assert "pour Le récit de voyage" in html_recap
assert "proposé par La petite librairie" in html_recap
assert "1 rue de la Libération" in html_recap
assert "Montreuil" in html_recap
assert "93100" in html_recap
assert "James" in html_recap_table
assert "*****@*****.**" in html_recap_table
assert "12346" not in html_recap_table
assert "12345" not in html_recap_table
assert (
email["Subject"] ==
"Confirmation de votre annulation de réservation pour Le récit de voyage, proposé par La petite librairie"
)
def test_stock_can_have_an_quantity_stock_equal_to_zero(app):
# given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, quantity=0)
# when
repository.save(stock)
# then
assert stock.quantity == 0
def test_records_new_payment_lines_in_database(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
paying_stock = create_stock_from_offer(offer)
free_stock = create_stock_from_offer(offer, price=0)
user = create_user()
deposit = create_deposit(user, amount=500)
booking1 = create_booking(user=user,
stock=paying_stock,
venue=venue,
is_used=True)
booking2 = create_booking(user=user,
stock=paying_stock,
venue=venue,
is_used=True)
booking3 = create_booking(user=user,
stock=paying_stock,
venue=venue,
is_used=True)
booking4 = create_booking(user=user,
stock=free_stock,
venue=venue,
is_used=True)
payment1 = create_payment(booking2,
offerer,
10,
payment_message_name="ABCD123")
repository.save(payment1)
repository.save(deposit, booking1, booking3, booking4)
initial_payment_count = Payment.query.count()
# When
generate_new_payments()
# Then
assert Payment.query.count() - initial_payment_count == 2
def test_stock_cannot_have_a_negative_price(app):
# given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, price=-10)
# when
with pytest.raises(ApiErrors) as e:
repository.save(stock)
# then
assert e.value.errors["price"] is not None
def test_full_reimburses_book_product_when_bookings_are_below_20000_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")
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)
paying_stock1 = create_stock_from_offer(offer1, price=10000)
paying_stock2 = create_stock_from_offer(offer2, price=19990)
user = users_factories.UserFactory()
user.deposit.amount = 50000
repository.save(user.deposit)
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)
repository.save(booking1, booking2, bank_information)
# When
pending, not_processable = generate_new_payments()
# Then
assert len(pending) == 2
assert len(not_processable) == 0
assert sum(p.amount for p in pending) == 29990
def test_stock_cannot_have_a_negative_quantity_stock(app):
# given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, quantity=-4)
# when
with pytest.raises(ApiErrors) as e:
repository.save(stock)
# then
assert e.value.errors["quantity"] == ["La quantité doit être positive."]
