def test_create_payment_for_booking_takes_recipient_name_and_siren_from_offerer(
app):
# given
user = create_user()
stock = create_stock(price=10, quantity=5)
booking = create_booking(user=user, quantity=1, stock=stock)
booking.stock.offer = Offer()
offerer = create_offerer(name="Test Offerer", siren="123456789")
venue = create_venue(offerer, name="Test Venue")
create_bank_information(bic="QSDFGH8Z555",
iban="CF13QSDFGH456789",
offerer=offerer)
create_bank_information(bic=None, iban=None, venue=venue)
booking.stock.offer.venue = venue
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.recipientName == "Test Offerer"
assert payment.recipientSiren == "123456789"
def test_create_payment_for_booking_when_no_iban_on_venue_should_take_payment_info_from_offerer(
app):
# given
user = create_user()
stock = create_stock(price=10, quantity=5)
offerer = create_offerer(name="Test Offerer")
venue = create_venue(offerer, name="Test Venue")
create_bank_information(bic="QsdFGH8Z555",
iban="cf13QSDFGH456789",
offerer=offerer)
create_bank_information(bic=None, iban=None, venue=venue)
booking = create_booking(user=user, quantity=1, stock=stock)
booking.stock.offer = Offer()
booking.stock.offer.venue = venue
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.iban == "CF13QSDFGH456789"
assert payment.bic == "QSDFGH8Z555"
def test_create_payment_for_booking_with_common_information(app):
# given
user = create_user()
stock = create_stock(price=10, quantity=5)
booking = create_booking(user=user, quantity=1, stock=stock)
booking.stock.offer = Offer()
booking.stock.offer.venue = VenueSQLEntity()
offerer = create_offerer()
create_bank_information(bic="QSDFGH8Z555",
iban="CF13QSDFGH456789",
offerer=offerer)
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.booking == booking
assert payment.amount == Decimal(10)
assert payment.reimbursementRule == ReimbursementRules.PHYSICAL_OFFERS.value.description
assert payment.reimbursementRate == ReimbursementRules.PHYSICAL_OFFERS.value.rate
assert payment.comment is None
assert payment.author == "batch"
assert payment.transactionLabel == "pass Culture Pro - remboursement 2nde quinzaine 10-2018"
def test_create_payment_for_booking_when_iban_is_on_venue_should_take_payment_info_from_venue(
app):
# given
user = create_user()
stock = create_stock(price=10, quantity=5)
offerer = create_offerer(name="Test Offerer")
venue = create_venue(
offerer,
name="Test Venue",
)
booking = create_booking(user=user, quantity=1, stock=stock)
create_bank_information(bic="Lajr93",
iban="B135TGGEG532TG",
offerer=offerer)
create_bank_information(bic="LokiJU76",
iban="KD98765RFGHZ788",
venue=venue)
booking.stock.offer = Offer()
booking.stock.offer.venue = venue
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.iban == "KD98765RFGHZ788"
assert payment.bic == "LOKIJU76"
def test_when_status_change_rib_should_be_correctly_updated(
self, mock_application_details, app):
# Given
application_id = "8"
offerer = create_offerer(siren="793875030")
bank_information = create_bank_information(
application_id=8,
bic="QSDFGH8Z555",
iban="NL36INGB2682297498",
offerer=offerer,
status=BankInformationStatus.ACCEPTED,
date_modified=datetime(2018, 1, 1),
)
repository.save(offerer, bank_information)
mock_application_details.return_value = offerer_demarche_simplifiee_application_detail_response(
siren="793875030",
bic="QSDFGH8Z555",
iban="NL36INGB2682297498",
idx=8,
state="initiated")
# When
self.save_offerer_bank_informations.execute(
application_id=application_id)
# Then
bank_information_count = BankInformation.query.count()
assert bank_information_count == 1
bank_information = BankInformation.query.one()
assert bank_information.bic == None
assert bank_information.iban == None
assert bank_information.status == BankInformationStatus.DRAFT
def test_when_receive_new_application_with_lower_status_should_reject(self, mock_application_details, app):
# Given
application_id = "8"
offerer = create_offerer(siren="793875030")
venue = create_venue(offerer, siret="79387503012345")
bank_information = create_bank_information(
application_id=79,
bic="QSDFGH8Z555",
iban="NL36INGB2682297498",
venue=venue,
date_modified=datetime(2018, 1, 1),
status=BankInformationStatus.ACCEPTED,
)
repository.save(bank_information)
mock_application_details.return_value = venue_demarche_simplifiee_application_detail_response_with_siret(
siret="79387503012345", bic="SOGEFRPP", iban="FR7630007000111234567890144", idx=8, state="initiated"
)
# When
with pytest.raises(CannotRegisterBankInformation) as error:
self.save_venue_bank_informations.execute(application_id)
# Then
bank_information_count = BankInformation.query.count()
assert bank_information_count == 1
bank_information = BankInformation.query.one()
assert bank_information.bic == "QSDFGH8Z555"
assert bank_information.iban == "NL36INGB2682297498"
assert bank_information.status == BankInformationStatus.ACCEPTED
assert bank_information.applicationId == 79
assert error.value.args == ("Received application details state does not allow to change bank information",)
def test_when_rib_and_offerer_change_everything_should_be_updated(
self, mock_application_details, app):
# Given
application_id = "8"
offerer = create_offerer(siren="793875030")
new_offerer = create_offerer(siren="793875019")
bank_information = create_bank_information(
application_id=8,
bic="QSDFGH8Z555",
iban="NL36INGB2682297498",
offerer=offerer,
date_modified=datetime(2018, 1, 1),
)
repository.save(offerer, new_offerer, bank_information)
mock_application_details.return_value = offerer_demarche_simplifiee_application_detail_response(
siren="793875019",
bic="SOGEFRPP",
iban="FR7630007000111234567890144",
idx=8)
# When
self.save_offerer_bank_informations.execute(
application_id=application_id)
# Then
bank_information_count = BankInformation.query.count()
assert bank_information_count == 1
bank_information = BankInformation.query.one()
assert bank_information.bic == "SOGEFRPP"
assert bank_information.iban == "FR7630007000111234567890144"
assert bank_information.offererId == new_offerer.id
def test_when_receive_new_closed_application_should_override_previous_one(
self, mock_application_details, app):
# Given
application_id = "8"
offerer = create_offerer(siren="793875030")
bank_information = create_bank_information(
application_id=79,
bic="QSDFGH8Z555",
iban="NL36INGB2682297498",
offerer=offerer,
date_modified=datetime(2018, 1, 1),
)
repository.save(offerer, bank_information)
mock_application_details.return_value = offerer_demarche_simplifiee_application_detail_response(
siren="793875030",
bic="SOGEFRPP",
iban="FR7630007000111234567890144",
idx=8)
# When
self.save_offerer_bank_informations.execute(
application_id=application_id)
# Then
bank_information_count = BankInformation.query.count()
assert bank_information_count == 1
bank_information = BankInformation.query.one()
assert bank_information.bic == "SOGEFRPP"
assert bank_information.iban == "FR7630007000111234567890144"
assert bank_information.applicationId == 8
def test_when_receive_older_application_should_reject(
self, mock_application_details, app):
# Given
application_id = "8"
offerer = create_offerer(siren="793875030")
bank_information = create_bank_information(
application_id=79,
bic="QSDFGH8Z555",
iban="NL36INGB2682297498",
offerer=offerer,
date_modified=datetime(2020, 2, 2),
)
repository.save(offerer, bank_information)
mock_application_details.return_value = offerer_demarche_simplifiee_application_detail_response(
siren="793875030",
bic="SOGEFRPP",
iban="FR7630007000111234567890144",
idx=8)
# When
with pytest.raises(CannotRegisterBankInformation) as error:
self.save_offerer_bank_informations.execute(
application_id=application_id)
# Then
bank_information_count = BankInformation.query.count()
assert bank_information_count == 1
bank_information = BankInformation.query.one()
assert bank_information.bic == "QSDFGH8Z555"
assert bank_information.iban == "NL36INGB2682297498"
assert bank_information.status == BankInformationStatus.ACCEPTED
assert bank_information.applicationId == 79
assert error.value.args == (
"Received application details are older than saved one", )
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_when_receive_new_application_with_draft_state_should_update_previously_rejected_bank_information(
self, mock_application_details, app):
# Given
application_id = "8"
offerer = create_offerer(siren="793875030")
bank_information = create_bank_information(
application_id=79,
bic=None,
iban=None,
offerer=offerer,
date_modified=datetime(2018, 1, 1),
status=BankInformationStatus.REJECTED,
)
repository.save(offerer, bank_information)
mock_application_details.return_value = offerer_demarche_simplifiee_application_detail_response(
siren="793875030",
bic="SOGEFRPP",
iban="FR7630007000111234567890144",
idx=8,
state="initiated")
# When
self.save_offerer_bank_informations.execute(
application_id=application_id)
# Then
bank_information_count = BankInformation.query.count()
assert bank_information_count == 1
bank_information = BankInformation.query.one()
assert bank_information.bic == None
assert bank_information.iban == None
assert bank_information.status == BankInformationStatus.DRAFT
def when_user_has_an_offerer_attached(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")
bank_information1 = create_bank_information(application_id=1, venue=venue1)
bank_information2 = create_bank_information(application_id=7, venue=venue2)
stock1 = create_stock_with_thing_offer(offerer=offerer1, venue=venue1, price=10)
stock2 = create_stock_with_thing_offer(offerer=offerer1, venue=venue2, price=11)
stock3 = create_stock_with_thing_offer(offerer=offerer2, venue=venue3, price=12)
stock4 = create_stock_with_thing_offer(offerer=offerer2, venue=venue3, price=13)
booking1 = create_booking(user=user, stock=stock1, is_used=True, token="ABCDEF", venue=venue1)
booking2 = create_booking(user=user, stock=stock1, token="ABCDEG", venue=venue1)
booking3 = create_booking(user=user, stock=stock2, is_used=True, token="ABCDEH", venue=venue2)
booking4 = create_booking(user=user, stock=stock3, is_used=True, token="ABCDEI", venue=venue3)
booking5 = create_booking(user=user, stock=stock4, is_used=True, token="ABCDEJ", venue=venue3)
booking6 = create_booking(user=user, stock=stock4, is_used=True, token="ABCDEK", venue=venue3)
repository.save(
deposit,
booking1,
booking2,
booking3,
booking4,
booking5,
booking6,
user_offerer1,
user_offerer2,
bank_information1,
bank_information2,
)
generate_new_payments()
# When
response = TestClient(app.test_client()).with_auth(user.email).get("/reimbursements/csv")
response_lines = response.data.decode("utf-8").split("\n")
# Then
assert response.status_code == 200
assert response.headers["Content-type"] == "text/csv; charset=utf-8;"
assert response.headers["Content-Disposition"] == "attachment; filename=remboursements_pass_culture.csv"
assert len(response_lines) == 7
def test_find_all_offerer_reimbursement_details(self, app):
# Given
user = users_factories.UserFactory(email="*****@*****.**")
offerer1 = create_offerer(siren="123456789")
user_offerer1 = create_user_offerer(user,
offerer1,
validation_token=None)
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer1, siret="12345678912346")
bank_information1 = create_bank_information(application_id=1,
venue=venue1)
bank_information2 = create_bank_information(application_id=2,
venue=venue2)
create_offer_with_thing_product(
venue1,
url="https://host/path/{token}?offerId={offerId}&email={email}")
create_offer_with_thing_product(venue2)
stock1 = create_stock_with_thing_offer(offerer=offerer1,
venue=venue1,
price=10)
stock2 = create_stock_with_thing_offer(offerer=offerer1,
venue=venue2,
price=11)
booking1 = create_booking(user=user,
stock=stock1,
is_used=True,
token="ABCDEF",
venue=venue1)
booking2 = create_booking(user=user,
stock=stock1,
token="ABCDEG",
venue=venue1)
booking3 = create_booking(user=user,
stock=stock2,
is_used=True,
token="ABCDEH",
venue=venue2)
repository.save(booking1, booking2, booking3, user_offerer1,
bank_information1, bank_information2)
generate_new_payments()
# When
reimbursement_details = find_all_offerer_reimbursement_details(
offerer1.id)
# Then
assert len(reimbursement_details) == 2
def when_param_validated_is_true_returns_all_info_of_validated_offerers(self, app):
# given
pro = users_factories.ProFactory()
offerer1 = create_offerer(siren="123456781", name="offreur C", validation_token=None)
offerer2 = create_offerer(siren="123456782", name="offreur A", validation_token="AZE123")
offerer3 = create_offerer(siren="123456783", name="offreur B", validation_token=None)
user_offerer1 = create_user_offerer(pro, offerer1)
user_offerer2 = create_user_offerer(pro, offerer2)
user_offerer3 = create_user_offerer(pro, offerer3)
bank_information1 = create_bank_information(application_id=1, offerer=offerer1)
bank_information2 = create_bank_information(application_id=2, offerer=offerer2)
bank_information3 = create_bank_information(application_id=3, offerer=offerer3)
repository.save(
bank_information1, bank_information2, bank_information3, user_offerer1, user_offerer2, user_offerer3
)
# when
response = TestClient(app.test_client()).with_session_auth(pro.email).get("/offerers?validated=true")
# then
assert response.status_code == 200
assert len(response.json) == 2
assert list(response.json[0].keys()) == [
"address",
"bic",
"city",
"dateCreated",
"dateModifiedAtLastProvider",
"dateValidated",
"demarchesSimplifieesApplicationId",
"fieldsUpdated",
"iban",
"id",
"idAtProviders",
"isActive",
"isValidated",
"lastProviderId",
"managedVenues",
"nOffers",
"name",
"postalCode",
"siren",
"thumbCount",
"userHasAccess",
]
def test_validate_bank_information_raises_an_error_if_iban_is_missing():
# given
bank_information = create_bank_information(bic="BDFEFR2LCCB", iban=None)
# when
errors = entity_validator.validate(bank_information)
# then
assert errors.errors["iban"] == ["Cette information est obligatoire"]
def when_user_has_rights_on_offerer(self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
create_bank_information(venue=venue)
user_offerer = create_user_offerer(user, offerer)
repository.save(user_offerer, venue)
# when
response = TestClient(app.test_client()).with_auth(
user.email).get(f"/offerers/{humanize(offerer.id)}")
# then
assert response.status_code == 200
response_json = response.json
assert "bic" in response_json["managedVenues"][0]
assert "iban" in response_json["managedVenues"][0]
assert response_json["userHasAccess"] is True
def test_should_not_return_errors_when_valid_bank_information():
# Given
bank_information = create_bank_information(bic="AGFBFRCC", iban="FR7014508000301971798194B82")
# When
api_errors = validate(bank_information)
# Then
assert api_errors.errors == {}
def when_user_is_admin_and_param_validated_is_true_and_returns_only_validated_offerer(self, app):
# given
offerer1 = create_offerer(siren="123456781", name="offreur C", validation_token=None)
offerer2 = create_offerer(siren="123456782", name="offreur A", validation_token="AFYDAA")
bank_information1 = create_bank_information(application_id=1, offerer=offerer1)
bank_information2 = create_bank_information(application_id=2, offerer=offerer2)
user = users_factories.AdminFactory(offerers=[offerer1, offerer2])
repository.save(bank_information1, bank_information2)
# when
response = TestClient(app.test_client()).with_session_auth(user.email).get("/offerers?validated=true")
# then
assert response.status_code == 200
assert len(response.json) == 1
offerer_response = response.json[0]
assert offerer_response["name"] == "offreur C"
def test_validate_bank_information_raises_an_error_if_bic_is_missing():
# given
bank_information = create_bank_information(
bic=None, iban="FR7630006000011234567890189")
# when
errors = entity_validator.validate(bank_information)
# then
assert errors.errors["bic"] == ["Cette information est obligatoire"]
def test_offerer_errors_raises_an_error_if_both_iban_and_bic_are_none():
# given
bank_information = create_bank_information(bic=None, iban=None)
# when
errors = entity_validator.validate(bank_information)
# then
assert errors.errors["iban"] == ["Cette information est obligatoire"]
assert errors.errors["bic"] == ["Cette information est obligatoire"]
def test_offerer_errors_raises_an_error_if_both_iban_and_bic_are_empty():
# given
bank_information = create_bank_information(bic="", iban="")
# when
errors = entity_validator.validate(bank_information)
# then
assert errors.errors["iban"] == ['L’IBAN renseigné ("") est invalide']
assert errors.errors["bic"] == ['Le BIC renseigné ("") est invalide']
def test_should_return_no_error_message_when_iban_and_bic_are_valid_and_status_accepted(
):
# Given
bank_information = create_bank_information()
api_errors = ApiErrors()
# When
api_error = validate(bank_information, api_errors)
# Then
assert api_error.errors == {}
def test_iban_property_returns_bank_information_iban_when_offerer_has_bank_information(self, app):
# Given
offerer = create_offerer(siren="123456789")
bank_information = create_bank_information(iban="FR7630007000111234567890144", offerer=offerer)
repository.save(bank_information)
# When
iban = offerer.iban
# Then
assert iban == "FR7630007000111234567890144"
def test_bic_property_returns_bank_information_bic_when_offerer_has_bank_information(self, app):
# Given
offerer = create_offerer(siren="123456789")
bank_information = create_bank_information(bic="BDFEFR2LCCB", offerer=offerer)
repository.save(bank_information)
# When
bic = offerer.bic
# Then
assert bic == "BDFEFR2LCCB"
def when_user_is_admin_and_param_validated_is_false_and_returns_all_info_of_all_offerers(self, app):
# given
offerer1 = create_offerer(siren="123456781", name="offreur A", validation_token="F1TVYSGV")
offerer2 = create_offerer(siren="123456782", name="offreur B")
bank_information1 = create_bank_information(application_id=1, offerer=offerer1)
bank_information2 = create_bank_information(application_id=2, offerer=offerer2)
user = create_user(is_beneficiary=False, is_admin=True)
user.offerers = [offerer1, offerer2]
repository.save(user, bank_information1, bank_information2)
# when
response = TestClient(app.test_client()).with_auth(user.email).get("/offerers?validated=false")
# then
assert response.status_code == 200
assert len(response.json) == 1
offerer_response = response.json[0]
assert offerer_response["name"] == "offreur A"
assert set(offerer_response.keys()) == {
"address",
"bic",
"city",
"dateCreated",
"dateModifiedAtLastProvider",
"demarchesSimplifieesApplicationId",
"fieldsUpdated",
"iban",
"id",
"idAtProviders",
"isActive",
"isValidated",
"lastProviderId",
"managedVenues",
"nOffers",
"name",
"postalCode",
"siren",
"thumbCount",
"userHasAccess",
}
def test_returns_none_when_offerer_has_no_bank_informations(self, app):
# given
offerer = create_offerer()
bank_informations = create_bank_information(offerer=offerer)
repository.save(bank_informations)
# when
bank_informations = self.bank_informations_sql_repository.find_by_offerer(
offerer_id=0)
# then
assert bank_informations is None
def test_should_not_return_an_error_if_status_is_not_accepted_and_bic_and_iban_are_empty(
):
# Given
bank_information = create_bank_information(
bic=None, iban=None, status=BankInformationStatus.DRAFT)
api_errors = ApiErrors()
# When
api_error = validate(bank_information, api_errors)
# Then
assert api_error.errors == {}
def test_should_return_error_message_when_iban_is_invalid():
# Given
bank_information = create_bank_information(iban="FR76")
api_errors = ApiErrors()
# When
api_error = validate(bank_information, api_errors)
# Then
assert api_error.errors["iban"] == [
'L’IBAN renseigné ("FR76") est invalide'
]
def test_should_return_error_message_when_bic_is_invalid():
# Given
bank_information = create_bank_information(bic="1234")
api_errors = ApiErrors()
# When
api_error = validate(bank_information, api_errors)
# Then
assert api_error.errors["bic"] == [
'Le BIC renseigné ("1234") est invalide'
]
def test_should_return_errors_when_invalid_bank_information():
# Given
bank_information = create_bank_information(bic="1234", iban="1234")
# When
api_errors = validate(bank_information)
# Then
assert api_errors.errors == {
"bic": ['Le BIC renseigné ("1234") est invalide'],
"iban": ['L’IBAN renseigné ("1234") est invalide'],
}
