def test_remaining_quantity_for_stock_is_1_when_there_are_2_bookings_and_1_is_used_before_last_stock_update(
app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, available=2, price=0)
PcObject.save(stock)
user = create_user()
booking1 = create_booking(user,
stock,
quantity=1,
is_cancelled=False,
is_used=True,
date_used=datetime.utcnow() -
timedelta(days=1))
booking2 = create_booking(user,
stock,
quantity=1,
is_cancelled=False,
is_used=False)
# When
PcObject.save(booking1, booking2)
# Then
assert Stock.query.get(stock.id).remainingQuantity == 1
def test_should_return_multiple_departements_and_order_by_desc_booking_counts(self, app):
# Given
offerer93 = create_offerer(name='Offerer dans le 93', siren=111111111)
venue93 = create_venue(offerer93, departement_code='93', siret=11111111100001)
offer93 = create_offer_with_thing_product(venue93)
stock93 = create_stock(offer=offer93, price=10)
offerer95 = create_offerer(name='Offerer dans le 95', siren=222222222)
venue95 = create_venue(offerer95, departement_code='95', siret=22222222200001)
offer95 = create_offer_with_thing_product(venue95)
stock95 = create_stock(offer=offer95, price=10)
user_in_95 = create_user(departement_code='95', email="*****@*****.**")
create_deposit(user_in_95, amount=500)
booking_in_95 = create_booking(user_in_95, stock95, quantity=5)
user_in_93 = create_user(departement_code='93', email="*****@*****.**")
create_deposit(user_in_93, amount=500)
booking_in_93 = create_booking(user_in_93, stock93, quantity=2)
PcObject.save(booking_in_93, booking_in_95)
# When
bookings_by_departement = _query_get_non_cancelled_bookings_by_user_departement()
# Then
assert len(bookings_by_departement) == 2
assert bookings_by_departement == [('95', 5), ('93', 2)]
def test_check_offer_with_two_sold_out_one_unlimited_and_one_remaining_stocks(
self, app):
# given
user = create_user(email='*****@*****.**')
user2 = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
recommendation = create_recommendation(offer, user)
stock = create_stock_from_offer(offer, available=10)
stock2 = create_stock_from_offer(offer, available=5)
stock3 = create_stock_from_offer(offer, available=1)
stock4 = create_stock_from_offer(offer, available=None)
deposit = create_deposit(user2, amount=500)
booking = create_booking(user2,
stock2,
venue,
recommendation,
quantity=5)
booking2 = create_booking(user2,
stock3,
venue,
recommendation,
quantity=1)
PcObject.save(booking, booking2, deposit, user, offer, stock,
stock2, stock3, stock4, user2)
# when
result = offer.stockAlertMessage
# then
assert result == 'plus de places pour 3 offres'
def test_offer_remaining_stock_filter_filters_offer_with_no_remaining_stock(
app):
# 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, product)
stock = create_stock_from_offer(offer, available=2, price=0)
user = create_user()
booking1 = create_booking(user,
stock,
venue=venue,
quantity=2,
is_cancelled=True)
booking2 = create_booking(user, stock, venue=venue, quantity=2)
PcObject.save(booking1, booking2)
# When
nb_offers_with_remaining_stock = Offer.query \
.join(Stock) \
.filter(_has_remaining_stock_predicate()) \
.count()
# Then
assert nb_offers_with_remaining_stock == 0
def test_check_offer_with_all_remaining_stocks(self, app):
# given
user = create_user(email='*****@*****.**')
user2 = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
recommendation = create_recommendation(offer, user)
stock = create_stock_from_offer(offer, available=10)
stock2 = create_stock_from_offer(offer, available=40)
deposit = create_deposit(user2, amount=500)
booking = create_booking(user2,
stock,
venue,
recommendation,
quantity=3)
booking2 = create_booking(user2,
stock2,
venue,
recommendation,
quantity=11)
PcObject.save(booking, booking2, deposit, user, offer, stock,
stock2, user2)
# when
result = offer.stockAlertMessage
# then
assert result == 'encore 36 places'
def test_should_not_return_offers_with_no_stock(app):
# 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, product)
stock = create_stock_from_offer(offer, available=2, price=0)
user = create_user()
booking1 = create_booking(user,
stock,
venue=venue,
quantity=2,
is_cancelled=True)
booking2 = create_booking(user, stock, venue=venue, quantity=2)
PcObject.save(booking1, booking2)
# When
offers = get_active_offers(user=create_user(email="*****@*****.**"),
departement_codes=['00'],
offer_id=None)
# Then
assert len(offers) == 0
def test_returns_offerers_filtered_by_departement_based_on_venue(
self, app):
# Given
offerer1 = create_offerer(name='Small library', siren='111111111')
venue1 = create_venue(offerer1,
postal_code='33130',
siret='11111111100001')
offer1 = create_offer_with_thing_product(venue1)
stock1 = create_stock(offer=offer1, price=30)
offerer2 = create_offerer(name='National book store',
siren='222222222')
venue2 = create_venue(offerer2,
postal_code='33130',
siret='22222222200001')
offer2 = create_offer_with_thing_product(venue=venue2)
stock2 = create_stock(offer=offer2, price=10)
user_76 = create_user(departement_code='76')
user_77 = create_user(email='*****@*****.**', departement_code='77')
create_deposit(user_76, amount=500)
create_deposit(user_77, amount=500)
booking1 = create_booking(user_76, stock1, quantity=2)
booking2 = create_booking(user_76, stock2, quantity=2)
booking3 = create_booking(user_77, stock2, quantity=2)
PcObject.save(booking1, booking2, booking3)
# When
bookings_counts = _query_get_top_20_offerers_by_booking_amounts('76')
# Then
assert bookings_counts == [('Small library', 2, 60),
('National book store', 2, 20)]
def test_returns_only_payment_total_by_department(self, app):
# Given
offerer = create_offerer(siren='111111111')
venue = create_venue(offerer,
postal_code='78490',
siret='11111111100002')
offer = create_offer_with_thing_product(venue)
stock = create_stock(price=10, offer=offer)
user_in_35 = create_user(email='*****@*****.**',
departement_code='35')
user_in_78 = create_user(email='*****@*****.**',
departement_code='78')
create_deposit(user_in_35, amount=500)
create_deposit(user_in_78, amount=500)
booking_in_35 = create_booking(user_in_35, stock=stock, venue=venue)
booking_in_78 = create_booking(user_in_78, stock=stock, venue=venue)
payment1 = create_payment(booking_in_35, offerer, amount=20)
payment2 = create_payment(booking_in_78, offerer, amount=10)
PcObject.save(user_in_35, venue, payment1, payment2)
# When
total_amount_to_pay = get_total_amount_to_pay('35')
# Then
assert total_amount_to_pay == 20
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()
deposit = create_deposit(user, amount=500)
booking1 = create_booking(user, paying_stock, venue, is_used=True)
booking2 = create_booking(user, paying_stock, venue, is_used=True)
booking3 = create_booking(user, paying_stock, venue, is_used=True)
booking4 = create_booking(user, free_stock, venue, is_used=True)
payment1 = create_payment(booking1, offerer, 10, payment_message_name="ABCD123")
payment2 = create_payment(booking2, offerer, 10, payment_message_name="EFGH456")
PcObject.save(payment1, payment2)
PcObject.save(deposit, booking1, booking3, booking4)
# When
payements_by_id = get_payments_by_message_id('ABCD123')
# Then
assert len(payements_by_id) == 1
assert payements_by_id[0].paymentMessage.name == 'ABCD123'
def test_available_stocks_can_be_changed_even_when_bookings_with_cancellations_exceed_available(
app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, available=2, price=0)
PcObject.save(stock)
user = create_user()
cancelled_booking1 = create_booking(user,
stock,
quantity=1,
is_cancelled=True)
cancelled_booking2 = create_booking(user,
stock,
quantity=1,
is_cancelled=True)
booking1 = create_booking(user, stock, quantity=1, is_cancelled=False)
booking2 = create_booking(create_user(email='*****@*****.**'),
stock,
quantity=1,
is_cancelled=False)
PcObject.save(cancelled_booking1, cancelled_booking2, booking1, booking2)
stock.available = 3
# When
try:
PcObject.save(stock)
except:
# Then
assert False
def test_send_transactions_should_send_an_email_with_xml_attachment(app):
# given
offerer1 = create_offerer(name='first offerer')
user = create_user()
venue1 = create_venue(offerer1)
stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1))
booking1 = create_booking(user, stock1)
booking2 = create_booking(user, stock1)
booking3 = create_booking(user, stock1)
deposit = create_deposit(user, amount=500)
PcObject.save(deposit)
payments = [
create_payment(booking1, offerer1, Decimal(10)),
create_payment(booking2, offerer1, Decimal(20)),
create_payment(booking3, offerer1, Decimal(20))
]
app.mailjet_client.send.create.return_value = Mock(status_code=200)
# when
send_transactions(payments, 'BD12AZERTY123456', 'AZERTY9Q666', '0000',
['*****@*****.**'])
# then
app.mailjet_client.send.create.assert_called_once()
args = app.mailjet_client.send.create.call_args
assert len(args[1]['data']['Attachments']) == 1
def test_finds_all_payments_linked_to_offerer(self, app):
# Given
offerer = create_offerer()
other_offerer = create_offerer(siren='987654321')
venue = create_venue(offerer)
other_venue = create_venue(other_offerer, siret=other_offerer.siren + '12345')
bank_information = create_bank_information(offerer=offerer, id_at_providers=offerer.siren)
other_bank_information = create_bank_information(offerer=other_offerer, id_at_providers=other_venue.siret)
user = create_user()
offer = create_offer_with_thing_product(venue)
other_offer = create_offer_with_thing_product(other_venue)
stock = create_stock(offer=offer, price=0)
other_stock = create_stock(offer=other_offer, price=0)
booking = create_booking(user, stock, venue)
other_booking = create_booking(user, other_stock, other_venue)
payment = create_payment(booking, offerer, 10)
other_payment = create_payment(other_booking, other_offerer, 10)
payment.setStatus(TransactionStatus.NOT_PROCESSABLE)
other_payment.setStatus(TransactionStatus.NOT_PROCESSABLE)
PcObject.save(payment, other_payment)
# When
payments = find_all_with_status_not_processable_for_bank_information(bank_information)
# Then
assert len(payments) == 1
def test_generate_payment_details_csv_with_right_values(self, app):
# given
deactivate_feature(FeatureToggle.DEGRESSIVE_REIMBURSEMENT_RATE)
user = create_user(email='*****@*****.**')
deposit = create_deposit(user, amount=500, source='public')
offerer1 = create_offerer()
user_offerer1 = create_user_offerer(user, offerer1, validation_token=None)
venue1 = create_venue(offerer1)
bank_information1 = create_bank_information(id_at_providers='79387501900056', venue=venue1)
stock1 = create_stock_with_thing_offer(offerer=offerer1, venue=venue1, price=10)
booking1 = create_booking(user, stock1, venue=venue1, token='ABCDEF', is_used=True)
booking2 = create_booking(user, stock1, venue=venue1, token='ABCDEG')
PcObject.save(deposit, booking1, booking2, user_offerer1, bank_information1)
generate_new_payments()
reimbursement_details = find_all_offerer_reimbursement_details(offerer1.id)
# when
csv = generate_reimbursement_details_csv(reimbursement_details)
# then
assert _count_non_empty_lines(csv) == 2
assert _get_header(csv,
1) == "2019;Juillet : remboursement 1ère quinzaine;La petite librairie;12345678912345;123 rue de Paris;FR7630006000011234567890189;La petite librairie;Test Book;Doe;John;ABCDEF;;10.00;Remboursement initié"
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, paying_stock, venue, is_used=True)
booking2 = create_booking(user, paying_stock, venue, is_used=True)
booking3 = create_booking(user, paying_stock, venue, is_used=True)
booking4 = create_booking(user, free_stock, venue, is_used=True)
payment1 = create_payment(booking2,
offerer,
10,
payment_message_name="ABCD123")
PcObject.save(payment1)
PcObject.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 expect_bookings_to_be_cancelled(self, app):
# given
user = create_user(email='*****@*****.**')
other_user = create_user(email='*****@*****.**')
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0)
booking1 = create_booking(other_user,
stock=stock,
is_cancelled=False)
booking2 = create_booking(other_user,
stock=stock,
is_cancelled=False)
PcObject.save(user, stock, user_offerer, booking1, booking2)
# when
response = TestClient(app.test_client()).with_auth(
'*****@*****.**').delete('/stocks/' + humanize(stock.id))
# then
assert response.status_code == 200
bookings = Booking.query.filter_by(isCancelled=True).all()
assert booking1 in bookings
assert booking2 in bookings
def _create_balances_for_user1(stock1, stock2, stock3, user1, venue):
deposit1 = create_deposit(user1, amount=100)
deposit2 = create_deposit(user1, amount=50)
booking1 = create_booking(user1, venue=venue, stock=stock1, quantity=1, is_cancelled=True, is_used=False)
booking2 = create_booking(user1, venue=venue, stock=stock2, quantity=2, is_cancelled=False, is_used=True)
booking3 = create_booking(user1, venue=venue, stock=stock3, quantity=1, is_cancelled=False, is_used=False)
PcObject.save(deposit1, deposit2, booking1, booking2, booking3)
def test_raises_error_on_booking_when_existing_booking_is_used_and_booking_date_is_after_last_update_on_stock(
app):
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, price=0, available=1)
user1 = create_user(email='*****@*****.**')
user2 = create_user(email='*****@*****.**')
PcObject.save(stock)
date_after_stock_last_update = datetime.utcnow()
booking1 = create_booking(user1,
stock,
date_used=date_after_stock_last_update,
is_cancelled=False,
is_used=True)
PcObject.save(booking1)
date_after_last_booking = datetime.utcnow()
booking2 = create_booking(user2,
stock,
date_used=date_after_last_booking,
is_cancelled=False,
is_used=False)
# When
with pytest.raises(ApiErrors) as e:
PcObject.save(booking2)
# Then
assert e.value.errors['global'] == [
'la quantité disponible pour cette offre est atteinte'
]
def test_remaining_quantity_for_stock_is_0_when_there_are_2_bookings_not_used(
app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, available=2, price=0)
PcObject.save(stock)
user = create_user()
booking1 = create_booking(user,
stock,
quantity=1,
is_cancelled=False,
is_used=False)
booking2 = create_booking(user,
stock,
quantity=1,
is_cancelled=False,
is_used=False)
PcObject.save(booking1, booking2)
stock.available = 1
# When
PcObject.save(stock)
# Then
assert Stock.query.get(stock.id).remainingQuantity == 0
def when_user_has_an_offerer_attached_and_venue_id_argument_is_valid(
self, app):
# Given
user = create_user(email='*****@*****.**')
deposit = create_deposit(user, amount=500, source='public')
offerer1 = create_offerer()
offerer2 = create_offerer(siren='123456788')
user_offerer1 = create_user_offerer(user,
offerer1,
validation_token=None)
user_offerer2 = create_user_offerer(user,
offerer2,
validation_token=None)
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer1, siret='12345678912346')
venue3 = create_venue(offerer2, siret='12345678912347')
offer1 = create_offer_with_event_product(venue1)
offer2 = create_offer_with_thing_product(venue1)
offer3 = create_offer_with_thing_product(venue2)
stock1 = create_stock_from_offer(offer1, available=100, price=20)
stock2 = create_stock_from_offer(offer2, available=150, price=16)
stock3 = create_stock_from_offer(offer3, available=150, price=18)
booking1 = create_booking(user,
stock1,
venue=venue1,
token='ABCDEF')
booking2 = create_booking(user,
stock1,
venue=venue1,
token='ABCDEG')
booking3 = create_booking(user,
stock2,
venue=venue2,
token='ABCDEH')
booking4 = create_booking(user,
stock3,
venue=venue3,
token='ABCDEI')
PcObject.save(deposit, booking1, booking2, booking3, booking4,
user_offerer1, user_offerer2)
url = '/bookings/csv?venueId=%s' % (humanize(venue1.id))
# When
response = TestClient(app.test_client()).with_auth(
user.email).get(url)
# Then
content_lines = response.data.decode('utf-8').split('\n')[1:-1]
assert response.status_code == 200
assert response.headers[
'Content-type'] == 'text/csv; charset=utf-8;'
assert response.headers[
'Content-Disposition'] == 'attachment; filename=reservations_pass_culture.csv'
assert len(content_lines) == 3
def _create_departement_booking_for_users(departement_code, user_email, booking_count, siren):
user_having_booked = create_user(departement_code=departement_code, email=user_email)
offerer = create_offerer(siren=siren)
venue = create_venue(offerer, siret=siren + '12345')
offer = create_offer_with_thing_product(venue)
stock = create_stock(offer=offer, price=0)
for i in range(booking_count):
create_booking(user_having_booked, stock, is_cancelled=False)
PcObject.save(stock)
def test_all_bookings_are_cancelled(self):
# given
self.stock.bookings = [
create_booking(user1, is_used=False, is_cancelled=False),
create_booking(user2, is_used=False, is_cancelled=False),
]
# when
bookings = delete_stock_and_cancel_bookings(self.stock)
# then
assert all(map(lambda b: b.isCancelled, bookings))
def test_returns_false_if_stocks_have_none_available_quantity(self):
# given
offer = Offer()
user = create_user()
stock1 = create_stock(available=None)
stock2 = create_stock(available=None)
create_booking(user, stock=stock1, quantity=1)
create_booking(user, stock=stock2, quantity=1)
offer.stocks = [stock1, stock2]
# then
assert offer.isFullyBooked is False
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, stock1)
booking2 = create_booking(user, stock2)
booking3 = create_booking(user, 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_file_has_bic_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, stock1)
booking2 = create_booking(user, stock2)
booking3 = create_booking(user, 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_used_bookings_are_not_cancelled(self):
# given
self.stock.bookings = [
create_booking(user1, is_used=True, is_cancelled=False),
create_booking(user2, is_used=False, is_cancelled=False)
]
# when
bookings = delete_stock_and_cancel_bookings(self.stock)
# then
used_bookings = filter(lambda b: b.isUsed, bookings)
assert all(map(lambda b: not b.isCancelled, used_bookings))
def test_all_bookings_are_not_cancelled(self):
# given
self.stock.bookings = [
create_booking(user1, is_used=False, is_cancelled=False),
create_booking(user2, is_used=False, is_cancelled=False),
]
# when
with pytest.raises(TooLateToDeleteError):
bookings = delete_stock_and_cancel_bookings(self.stock)
# then
assert all(map(lambda b: not b.isCancelled, bookings))
def test_reimburses_95_percent_for_book_product_when_bookings_exceed_100000_euros(
self, app):
# Given
offerer1 = create_offerer(siren='123456789')
PcObject.save(offerer1)
bank_information = create_bank_information(
bic='BDFEFR2LCCB',
iban='FR7630006000011234567890189',
id_at_providers='123456789',
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,
paying_stock1,
venue1,
quantity=1,
is_used=True)
booking2 = create_booking(user,
paying_stock2,
venue2,
quantity=1,
is_used=True)
booking3 = create_booking(user,
paying_stock3,
venue3,
quantity=1,
is_used=True)
PcObject.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_stocks_with_past_booking_limit_datetimes_are_ignored(self):
# given
offer = Offer()
user = create_user()
stock1 = create_stock(available=2,
booking_limit_datetime=datetime.utcnow() -
timedelta(weeks=3))
stock2 = create_stock(available=1)
stock3 = create_stock(available=1)
create_booking(user, stock=stock2, quantity=1)
create_booking(user, stock=stock3, quantity=1)
offer.stocks = [stock1, stock2, stock3]
# then
assert offer.isFullyBooked is True
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, stock1)
booking2 = create_booking(user, stock2)
booking3 = create_booking(user, 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 when_already_booked_by_user_but_cancelled(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
thing_offer = create_offer_with_thing_product(venue)
deposit_date = datetime.utcnow() - timedelta(minutes=2)
deposit = create_deposit(user, amount=200)
stock = create_stock_with_thing_offer(offerer,
venue,
thing_offer,
price=90)
booking = create_booking(user, stock, venue, is_cancelled=True)
PcObject.save(stock, user, booking)
booking_json = {
'stockId': humanize(stock.id),
'recommendationId': None,
'quantity': 1
}
# When
response = TestClient(
app.test_client()).with_auth('*****@*****.**').post(
'/bookings', json=booking_json)
# Then
assert response.status_code == 201
