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