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_returns_payments_with_last_payment_status_error(self, app): # Given user = create_user() booking = create_booking(user=user) create_deposit(user) error_payment1 = create_payment( booking, booking.stock.offer.venue.managingOfferer, 10, status=TransactionStatus.ERROR) error_payment2 = create_payment( booking, booking.stock.offer.venue.managingOfferer, 10, status=TransactionStatus.ERROR) pending_payment = create_payment( booking, booking.stock.offer.venue.managingOfferer, 10) repository.save(error_payment1, error_payment2, pending_payment) # When payments = payment_queries.find_error_payments() # Then assert len(payments) == 2 for payment in payments: assert payment.currentStatus.status == TransactionStatus.ERROR
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_returns_payments_with_last_payment_status_retry(self, app): # Given user = users_factories.UserFactory() booking = create_booking(user=user) offerer = booking.stock.offer.venue.managingOfferer retry_payment1 = create_payment(booking, offerer, 10, status=TransactionStatus.RETRY) retry_payment2 = create_payment(booking, offerer, 10, status=TransactionStatus.RETRY) pending_payment = create_payment(booking, offerer, 10, status=TransactionStatus.PENDING) repository.save(retry_payment1, retry_payment2, pending_payment) # When payments = payment_queries.find_retry_payments() # Then assert len(payments) == 2 for payment in payments: assert payment.currentStatus.status == TransactionStatus.RETRY
def test_returns_nothing_if_message_is_not_matched(self, app): # given user = users_factories.UserFactory() booking = create_booking(user=user) offerer = booking.stock.offer.venue.managingOfferer message1 = create_payment_message(name="XML1") message2 = create_payment_message(name="XML2") message3 = create_payment_message(name="XML3") uuid1, uuid2, uuid3 = uuid.uuid4(), uuid.uuid4(), uuid.uuid4() payments = [ create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=message1), create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid2, payment_message=message2), create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid3, payment_message=message3), ] repository.save(*payments) # when matching_payments = payment_queries.find_payments_by_message( "unknown message") # then assert matching_payments == []
def test_does_not_modify_statuses_on_given_payments_if_a_payment_id_is_not_found( self, app): # given booking = booking_factories.IndividualBookingFactory() offerer = booking.offerer transaction1 = create_payment_message(name="XML1") transaction2 = create_payment_message(name="XML2") uuid1, uuid2 = uuid.uuid4(), uuid.uuid4() payment1 = create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=transaction1) payment2 = create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid2, payment_message=transaction2) repository.save(payment1, payment2) # when do_ban_payments("XML1", [payment1.id, 123456]) # then assert payment1.currentStatus.status == TransactionStatus.PENDING assert payment2.currentStatus.status == TransactionStatus.PENDING
def test_it_returns_only_payments_with_current_status_as_not_processable( self): # given user = create_user() booking = create_booking(user=user) offerer = create_offerer() payments = [ create_payment(booking, offerer, 30, status=TransactionStatus.PENDING), create_payment(booking, offerer, 30, status=TransactionStatus.NOT_PROCESSABLE), create_payment(booking, offerer, 30, status=TransactionStatus.ERROR), ] # when pending_payments = keep_only_not_processable_payments(payments) # then assert len(pending_payments) == 1 assert pending_payments[ 0].currentStatus.status == TransactionStatus.NOT_PROCESSABLE
def test_does_not_modify_statuses_on_given_payments_if_a_payment_id_is_not_found( self, app): # given user = create_user() booking = create_booking(user=user) deposit = create_deposit(user) offerer = booking.stock.offer.venue.managingOfferer transaction1 = create_payment_message(name="XML1") transaction2 = create_payment_message(name="XML2") uuid1, uuid2 = uuid.uuid4(), uuid.uuid4() payment1 = create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=transaction1) payment2 = create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid2, payment_message=transaction2) repository.save(deposit, payment1, payment2) # when do_ban_payments("XML1", [payment1.id, 123456]) # then assert payment1.currentStatus.status == TransactionStatus.PENDING assert payment2.currentStatus.status == TransactionStatus.PENDING
def test_returns_payments_matching_message(self, app): # given beneficiary = users_factories.BeneficiaryGrant18Factory() booking = bookings_factories.IndividualBookingFactory(individualBooking__user=beneficiary) offerer = booking.offerer transaction1 = create_payment_message(name="XML1") transaction2 = create_payment_message(name="XML2") transaction3 = create_payment_message(name="XML3") uuid1, uuid2, uuid3 = uuid.uuid4(), uuid.uuid4(), uuid.uuid4() payments = [ create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=transaction1), create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid2, payment_message=transaction2), create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=transaction3), create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid3, payment_message=transaction1), create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=transaction1), ] repository.save(*payments) # when matching_payments = payment_queries.find_payments_by_message("XML1") # then assert len(matching_payments) == 3 for payment in matching_payments: assert payment.paymentMessageName == "XML1"
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_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_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_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_value_error_is_raised_if_payments_ids_do_not_match_payments(self): # given payments = [ create_payment(Booking(), Offerer(), 10, idx=111), create_payment(Booking(), Offerer(), 10, idx=222), ] ids_to_ban = [222, 333] # when with pytest.raises(UnmatchedPayments) as e: apply_banishment(payments, ids_to_ban) # then assert e.value.payment_ids == {333}
def test_no_payments_to_retry_if_all_are_banned(self): # given payments = [ create_payment(Booking(), Offerer(), 10, idx=111), create_payment(Booking(), Offerer(), 10, idx=222), ] ids_to_ban = [111, 222] # when banned_payments, retry_payments = apply_banishment( payments, ids_to_ban) # then assert len(banned_payments) == 2 assert retry_payments == []
def test_no_payments_are_returned_if_no_ids_are_provided(self): # given payments = [ create_payment(Booking(), Offerer(), 10, idx=111), create_payment(Booking(), Offerer(), 10, idx=222), ] ids_to_ban = [] # when banned_payments, retry_payments = apply_banishment( payments, ids_to_ban) # then assert banned_payments == [] assert retry_payments == []
def test_returns_as_much_payment_details_as_there_are_payments_given(self): # given offerer1, offerer2 = create_offerer(), create_offerer() user1, user2 = create_user(), create_user() payments = [ create_payment(create_booking(user=user1), offerer1, 10), create_payment(create_booking(user=user1), offerer1, 20), create_payment(create_booking(user=user2), offerer2, 30), ] # when details = create_all_payments_details(payments, find_booking_date_used=Mock()) # then assert len(details) == 3
def test_contains_info_on_offer(self): # given user = create_user(email="*****@*****.**", idx=3) offerer = create_offerer(siren="987654321", name="Joe le Libraire") venue = create_venue(offerer, name="Jack le Sculpteur", siret="1234567891234") offer = create_offer_with_thing_product(venue) stock = create_stock(offer=offer, price=12, quantity=5) booking = create_booking(user=user, stock=stock, date_created=datetime(2018, 2, 5), idx=5, quantity=2) payment = create_payment(booking, offerer, 35) find_date = Mock() find_date.return_value = datetime(2018, 2, 19) # when details = create_payment_details(payment, find_booking_date_used=find_date) # then assert details.offer_name == "Test Book" assert details.offer_type == "Audiovisuel - films sur supports physiques et VOD"
def test_contains_info_on_venue(self): # given user = create_user(email="*****@*****.**", idx=3) offerer = create_offerer(siren="987654321", name="Joe le Libraire") venue = create_venue(offerer, name="Jack le Sculpteur", siret="1234567891234", idx=1) offer = create_offer_with_thing_product(venue) stock = create_stock(offer=offer, price=12, quantity=5) booking = create_booking(user=user, stock=stock, date_created=datetime(2018, 2, 5), idx=5, quantity=2) payment = create_payment(booking, offerer, 35) find_date = Mock() find_date.return_value = datetime(2018, 2, 19) # when details = create_payment_details(payment, find_booking_date_used=find_date) # then assert details.venue_name == "Jack le Sculpteur" assert details.venue_siret == "1234567891234" assert details.venue_humanized_id == humanize(venue.id)
def test_should_cancel_reimbursed_and_banned_bookings_with_current_status_banned_and_wanted_dates( self, app): # Given booking = create_booking(stock=self.stock, user=self.beneficiary, date_used=datetime.utcnow(), is_used=True) payment = create_payment(offerer=self.offerer, booking=booking, status=TransactionStatus.SENT, status_date=self.WANTED_SENT_DATETIME) payment_banned_status = create_payment_status( payment=payment, status=TransactionStatus.BANNED, date=self.WANTED_BANNED_DATETIME) payment.statuses.append(payment_banned_status) repository.save(payment) # When cancel_banned_bookings() # Then corrected_booking = Booking.query.get(booking.id) assert corrected_booking.isCancelled is True assert corrected_booking.cancellationDate is not None assert corrected_booking.isUsed is False assert corrected_booking.dateUsed is None
def when_api_key_is_provided_and_booking_payment_exists(self, app): # Given user = create_user() pro_user = create_user(email="*****@*****.**") offerer = create_offerer() user_offerer = create_user_offerer(pro_user, offerer) venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=0) booking = create_booking(user=user, stock=stock, venue=venue, is_used=True) payment = create_payment(booking, offerer, Decimal(10), iban="CF13QSDFGH456789", bic="QSDFGH8Z555") repository.save(booking, user_offerer, payment) offererApiKey = create_api_key(offerer_id=offerer.id) repository.save(offererApiKey) # When url = "/v2/bookings/keep/token/{}".format(booking.token) user2_api_key = "Bearer " + offererApiKey.value response = TestClient(app.test_client()).patch( url, headers={"Authorization": user2_api_key, "Origin": "http://localhost"} ) # Then assert response.status_code == 410 assert response.json["payment"] == ["Le remboursement est en cours de traitement"] assert Booking.query.get(booking.id).isUsed is True
def test_generate_payment_csv_raw_contains_human_readable_status_with_details_when_error( self, app): # given user = users_factories.UserFactory(email="*****@*****.**") offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_thing_offer(offerer=offerer, venue=venue, price=10) booking = create_booking(user=user, stock=stock, is_used=True, token="ABCDEF", venue=venue) payment = create_payment( booking, offerer, transaction_label= "pass Culture Pro - remboursement 1ère quinzaine 07-2019", status=TransactionStatus.ERROR, amount=50, detail="Iban non fourni", ) repository.save(payment) payments_info = find_all_offerer_payments(offerer.id) # when raw_csv = ReimbursementDetails(payments_info[0]).as_csv_row() # then assert raw_csv[ 13] == "Erreur d'envoi du remboursement : Iban non fourni"
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_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_should_return_cancelled_booking_with_payment(self, app): # Given beneficiary = create_user() create_deposit(user=beneficiary) offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_event_product(venue) stock1 = create_stock(beginning_datetime=datetime(2020, 4, 16), offer=offer) stock2 = create_stock(beginning_datetime=datetime(2020, 4, 16), offer=offer) booking1 = create_booking(stock=stock1, user=beneficiary, is_cancelled=True) booking2 = create_booking(stock=stock2, user=beneficiary, is_cancelled=True) payment = create_payment(offerer=offerer, booking=booking1) repository.save(payment, booking2) # When bookings_result = get_bookings_cancelled_during_quarantine_with_payment( ) # Then assert bookings_result == [booking1]
def test_should_not_revert_booking_dateused_if_booking_already_has_one( self, stub_get_bookings_cancelled_during_quarantine_with_payment, app): # Given dateused = datetime(2020, 7, 3, 20, 4, 4) beneficiary = create_user() create_deposit(user=beneficiary) offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_event_product(venue) stock = create_stock(beginning_datetime=datetime(2020, 4, 16), offer=offer) booking = create_booking( stock=stock, user=beneficiary, is_cancelled=True, date_created=datetime(2019, 7, 3, 20, 4, 4), date_used=dateused, ) payment = create_payment(offerer=offerer, booking=booking) repository.save(payment) stub_get_bookings_cancelled_during_quarantine_with_payment.return_value = [ booking ] # When correct_booking_status() # Then corrected_booking = Booking.query.get(booking.id) assert corrected_booking.isCancelled is False assert corrected_booking.cancellationDate is None assert corrected_booking.isUsed is True assert corrected_booking.dateUsed == dateused
def test_payment_date_should_return_oldest_payment_date_for_status_sent_if_several( self, app): # Given user = users_factories.UserFactory() booking = create_booking(user=user) today = datetime.utcnow() yesterday = datetime.utcnow() - timedelta(days=1) offerer = booking.stock.offer.venue.managingOfferer payment_message = create_payment_message(name="mon message") payment = create_payment(booking, offerer, 5, payment_message=payment_message) payment_status = create_payment_status( payment, status=TransactionStatus.SENT, date=today) create_payment_status(payment, status=TransactionStatus.SENT, date=yesterday) repository.save(payment_status) # When payment_from_query = Payment.query.with_entities( Payment.lastProcessedDate.label("payment_date")).first() # Then assert payment_from_query.payment_date == yesterday
def test_returns_payments_matching_message(self, app): # given user = create_user() booking = create_booking(user=user) create_deposit(user) offerer = booking.stock.offer.venue.managingOfferer transaction1 = create_payment_message(name="XML1") transaction2 = create_payment_message(name="XML2") transaction3 = create_payment_message(name="XML3") uuid1, uuid2, uuid3 = uuid.uuid4(), uuid.uuid4(), uuid.uuid4() payments = [ create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=transaction1), create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid2, payment_message=transaction2), create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=transaction3), create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid3, payment_message=transaction1), create_payment(booking, offerer, 5, transaction_end_to_end_id=uuid1, payment_message=transaction1), ] repository.save(*payments) # when matching_payments = payment_queries.find_payments_by_message("XML1") # then assert len(matching_payments) == 3 for payment in matching_payments: assert payment.paymentMessageName == "XML1"