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(id_at_providers='123456781', offerer=offerer1)
bank_information2 = create_bank_information(id_at_providers='123456782', offerer=offerer2)
user = create_user(can_book_free_offers=False, is_admin=True)
user.offerers = [offerer1, offerer2]
PcObject.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',
'firstThumbDominantColor', 'iban', 'id', 'idAtProviders', 'isActive',
'isValidated', 'lastProviderId', 'managedVenues', 'modelName', 'nOffers',
'name', 'postalCode', 'siren', 'thumbCount', 'userHasAccess'
}
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, available=5)
offerer = create_offerer(name='Test Offerer')
venue = create_venue(
offerer,
name='Test Venue',
)
booking = create_booking(user, stock=stock, quantity=1)
offerer_bank_information = create_bank_information(bic='Lajr93',
iban='B135TGGEG532TG',
offerer=offerer)
venue_bank_information = 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_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, available=5)
offerer = create_offerer(name='Test Offerer')
venue = create_venue(offerer, name='Test Venue')
offerer_bank_information = create_bank_information(bic='QsdFGH8Z555',
iban='cf13QSDFGH456789',
offerer=offerer)
venue_bank_information = create_bank_information(bic=None,
iban=None,
venue=venue)
booking = create_booking(user, stock=stock, quantity=1)
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_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 when_user_has_rights_on_managing_offerer(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock(offer=offer)
create_bank_information(venue=venue, id_at_providers=venue.siret)
create_bank_information(offerer=offerer,
id_at_providers=offerer.siren)
PcObject.save(user, stock)
# when
response = TestClient(app.test_client()).with_auth(email='*****@*****.**') \
.get(f'/offers/{humanize(offer.id)}')
# then
response_json = response.json
assert response.status_code == 200
assert 'iban' in response_json['venue']
assert 'bic' in response_json['venue']
assert 'iban' in response_json['venue']['managingOfferer']
assert 'bic' in response_json['venue']['managingOfferer']
assert 'validationToken' not in response_json['venue'][
'managingOfferer']
def when_param_validated_is_true_returns_all_info_of_validated_offerers(self, app):
# given
user = create_user()
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(user, offerer1)
user_offerer2 = create_user_offerer(user, offerer2)
user_offerer3 = create_user_offerer(user, offerer3)
bank_information1 = create_bank_information(id_at_providers='123456781', offerer=offerer1)
bank_information2 = create_bank_information(id_at_providers='123456782', offerer=offerer2)
bank_information3 = create_bank_information(id_at_providers='123456783', offerer=offerer3)
PcObject.save(bank_information1, bank_information2, bank_information3, user_offerer1,
user_offerer2, user_offerer3)
# when
response = TestClient(app.test_client()) \
.with_auth(user.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',
'firstThumbDominantColor', 'iban', 'id', 'idAtProviders', 'isActive',
'isValidated', 'lastProviderId', 'managedVenues', 'modelName', 'nOffers',
'name', 'postalCode', 'siren', 'thumbCount', 'userHasAccess'
]
def test_create_payment_for_booking_with_common_information(app):
# given
user = create_user()
stock = create_stock(price=10, available=5)
booking = create_booking(user, stock=stock, quantity=1)
booking.stock.offer = Offer()
booking.stock.offer.venue = Venue()
offerer = create_offerer()
offerer_bank_information = 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_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_find_all_offerer_reimbursement_details(self, app):
# Given
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)
venue2 = create_venue(offerer1, siret='12345678912346')
bank_information1 = create_bank_information(
id_at_providers='79387501900056', venue=venue1)
bank_information2 = create_bank_information(
id_at_providers='79387501900057', venue=venue2)
offer1 = create_offer_with_thing_product(
venue1,
url='https://host/path/{token}?offerId={offerId}&email={email}')
offer2 = 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,
stock1,
venue=venue1,
token='ABCDEF',
is_used=True)
booking2 = create_booking(user, stock1, venue=venue1, token='ABCDEG')
booking3 = create_booking(user,
stock2,
venue=venue2,
token='ABCDEH',
is_used=True)
PcObject.save(deposit, 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_user_has_rights_on_offerer(self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
create_bank_information(venue=venue, id_at_providers=venue.siret)
user_offerer = create_user_offerer(user, offerer)
PcObject.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_does_not_retrive_payments_linked_to_venue_with_bank_information_if_bank_information_linked_to_offerer(self,
app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offerer_bank_information = create_bank_information(offerer=offerer, id_at_providers=offerer.siren)
venue_bank_information = create_bank_information(venue=venue, id_at_providers=venue.siret)
user = create_user(email='*****@*****.**')
offer = create_offer_with_thing_product(venue)
stock = create_stock(offer=offer, price=0)
booking = create_booking(user, stock, venue)
payment = create_payment(booking, offerer, 10)
payment.setStatus(TransactionStatus.NOT_PROCESSABLE)
PcObject.save(payment)
# When
payments = find_all_with_status_not_processable_for_bank_information(offerer_bank_information)
# Then
assert len(payments) == 0
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(id_at_providers='123456781', offerer=offerer1)
bank_information2 = create_bank_information(id_at_providers='123456782', offerer=offerer2)
user = create_user(can_book_free_offers=False, is_admin=True)
user.offerers = [offerer1, offerer2]
PcObject.save(user, bank_information1, bank_information2)
# when
response = TestClient(app.test_client()) \
.with_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 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(id_at_providers='79387501900056', venue=venue1)
bank_information2 = create_bank_information(id_at_providers='79387501900057', 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, stock1, venue=venue1, token='ABCDEF', is_used=True)
booking2 = create_booking(user, stock1, venue=venue1, token='ABCDEG')
booking3 = create_booking(user, stock2, venue=venue2, token='ABCDEH', is_used=True)
booking4 = create_booking(user, stock3, venue=venue3, token='ABCDEI', is_used=True)
booking5 = create_booking(user, stock4, venue=venue3, token='ABCDEJ', is_used=True)
booking6 = create_booking(user, stock4, venue=venue3, token='ABCDEK', is_used=True)
PcObject.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_updates_bank_information_when_existing_bank_information_with_same_id_at_provider(self,
find_latest_sync_end_event,
get_application_details,
get_all_application_ids_for_procedure,
environment,
app):
# given
offerer = create_offerer(siren='793875030', idx=self.OFFERER_ID)
venue = create_venue(offerer=offerer, idx=self.VENUE_ID)
bank_information = create_bank_information(
application_id=self.APPLICATION_ID,
bic='PSSTFRPPLIL',
iban="FR1420041010050500013M02606",
offerer=offerer,
venue=venue,
id_at_providers=f"{self.OFFERER_ID}|{self.VENUE_ID}"
)
PcObject.save(venue, bank_information)
last_provider_sync = LocalProviderEvent()
last_provider_sync.date = datetime(2020, 1, 2)
find_latest_sync_end_event.return_value = last_provider_sync
get_all_application_ids_for_procedure.return_value = [self.APPLICATION_ID]
NEW_IBAN = 'FR7630006000011234567890189'
NEW_BIC = 'AGRIFRPP'
get_application_details.return_value = _create_detail_response(
self.APPLICATION_ID, self.OFFERER_ID, self.VENUE_ID, iban=NEW_IBAN, bic=NEW_BIC
)
# when
provider_test(app,
VenueWithoutSIRETBankInformationProvider,
None,
checkedObjects=1,
createdObjects=0,
updatedObjects=1,
erroredObjects=0,
checkedThumbs=0,
createdThumbs=0,
updatedThumbs=0,
erroredThumbs=0)
# then
bank_information = BankInformation.query.all()
assert len(bank_information) == 1
bank_information = BankInformation.query.first()
assert bank_information.iban == NEW_IBAN
assert bank_information.bic == NEW_BIC
assert bank_information.offererId == self.OFFERER_ID
assert bank_information.venueId == self.VENUE_ID
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',
id_at_providers='123456789',
offerer=offerer)
PcObject.save(bank_information)
# When
bic = offerer.bic
# Then
assert bic == 'BDFEFR2LCCB'
def test_does_not_call_save_if_no_relevant_payments(self, app):
# Given
offerer = create_offerer()
other_offerer = create_offerer(siren='987654321')
venue = create_venue(offerer, siret=offerer.siren + '12345')
other_venue = create_venue(other_offerer,
siret=other_offerer.siren + '12345')
bank_information_list = [
create_bank_information(offerer=offerer,
id_at_providers=offerer.siren),
create_bank_information(venue=other_venue,
id_at_providers=other_venue.siret)
]
PcObject.save(*bank_information_list)
try:
# When
retry_linked_payments(bank_information_list)
# Then
except ValueError:
assert pytest.fail("Should not try to save empty list")
def test_bic_property_returns_bank_information_bic_when_venue_has_bank_information(
self, app):
# Given
offerer = create_offerer(siren='123456789')
venue = create_venue(offerer, siret='12345678912345')
bank_information = create_bank_information(
bic='BDFEFR2LCCB', id_at_providers='12345678912345', venue=venue)
PcObject.save(bank_information)
# When
bic = venue.bic
# Then
assert bic == 'BDFEFR2LCCB'
def test_changes_transaction_status_to_retry_when_finds_relevant_payments(
self, app):
# Given
offerer = create_offerer()
other_offerer = create_offerer(siren='987654321')
venue = create_venue(offerer, siret=offerer.siren + '12345')
other_venue = create_venue(other_offerer,
siret=other_offerer.siren + '12345')
bank_information_list = [
create_bank_information(offerer=offerer,
id_at_providers=offerer.siren),
create_bank_information(venue=other_venue,
id_at_providers=other_venue.siret)
]
user = create_user(email='*****@*****.**')
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, other_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(*(bank_information_list + [payment, other_payment]))
# When
retry_linked_payments(bank_information_list)
# Then
payments = Payment.query.all()
assert len(payments) == 2
for payment in payments:
assert payment.currentStatus.status == TransactionStatus.RETRY
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_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',
id_at_providers='123456789',
offerer=offerer)
PcObject.save(bank_information)
# When
iban = offerer.iban
# Then
assert iban == 'FR7630007000111234567890144'
def test_should_not_reimburse_offerer_if_he_has_more_than_20000_euros_in_bookings_on_several_venues(
self, app):
# Given
deactivate_feature(FeatureToggle.DEGRESSIVE_REIMBURSEMENT_RATE)
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)
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,
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) == 2
assert len(not_processable) == 0
assert sum(p.amount for p in pending) == 20000
def when_bank_information_table_has_max_update_2019_1_1_returns_2019_1_1(
self, app):
# given
offerer = create_offerer(siren='793875019')
venue = create_venue(offerer, siret='79387501900056')
bank_information = create_bank_information(
id_at_providers='79387501900056',
date_modified_at_last_provider=datetime(2019, 1, 1),
venue=venue)
PcObject.save(bank_information)
# when
last_update = get_last_update_from_bank_information()
# then
assert last_update == datetime(2019, 1, 1)
def test_returns_a_tuple_of_pending_and_not_processable_payments(
self, app):
# Given
deactivate_feature(FeatureToggle.DEGRESSIVE_REIMBURSEMENT_RATE)
offerer1 = create_offerer(siren='123456789')
offerer2 = create_offerer(siren='987654321')
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(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,
paying_stock1,
venue1,
is_used=True)
booking2 = create_booking(user,
paying_stock1,
venue1,
is_used=True)
booking3 = create_booking(user,
paying_stock2,
venue2,
is_used=True)
booking4 = create_booking(user, free_stock1, venue1, is_used=True)
PcObject.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_only_retrieves_payments_with_status_not_processable(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
bank_information = create_bank_information(offerer=offerer, id_at_providers=offerer.siren)
user = create_user(email='*****@*****.**')
other_user = create_user(email='*****@*****.**')
offer = create_offer_with_thing_product(venue)
stock = create_stock(offer=offer, price=0)
booking = create_booking(user, stock, venue)
other_booking = create_booking(other_user, stock, venue)
payment = create_payment(booking, offerer, 10)
other_payment = create_payment(other_booking, offerer, 10)
payment.setStatus(TransactionStatus.NOT_PROCESSABLE)
other_payment.setStatus(TransactionStatus.SENT)
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_create_payment_for_booking_with_pending_status(app):
# given
user = create_user()
stock = create_stock(price=10, available=5)
booking = create_booking(user, stock=stock, quantity=1)
booking.stock.offer = Offer()
booking.stock.offer.venue = Venue()
offerer = create_offerer()
booking.stock.offer.venue.managingOfferer = offerer
offerer_bank_information = create_bank_information(bic='QSDFGH8Z555',
iban='CF13QSDFGH456789',
offerer=offerer)
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert len(payment.statuses) == 1
assert payment.statuses[0].status == TransactionStatus.PENDING
assert payment.statuses[0].detail is None
assert payment.statuses[0].date == datetime(2018, 10, 15, 9, 21, 34)
def save_offerer_without_iban():
offerer_without_iban = create_offerer(siren='213400328', name='Béziers')
venue_with_siret_with_iban = create_venue(offerer=offerer_without_iban,
siret='21340032800018',
is_virtual=False)
venue_with_siret_without_iban = create_venue(offerer=offerer_without_iban,
siret='21340032800802',
is_virtual=False)
venue_online = create_venue(offerer=offerer_without_iban,
siret=None,
is_virtual=True)
bank_information = create_bank_information(
venue=venue_with_siret_with_iban,
bic='BDFEFRPPCCT',
iban='FR733000100206C343000000066',
application_id=2,
id_at_providers=venue_with_siret_with_iban.siret)
PcObject.save(bank_information, venue_online, venue_with_siret_with_iban,
venue_with_siret_without_iban)
logger.info(
'created 1 offerer without iban and 1 virtual venue, 1 venue with siret with iban and 1 venue with siret without iban'
)
return venue_online, venue_with_siret_with_iban, venue_with_siret_without_iban
def when_user_has_rights_on_managing_offerer(self, app):
# given
offerer = create_offerer()
user = create_user(email='*****@*****.**')
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer, name='L\'encre et la plume')
bank_information = create_bank_information(
bic='QSDFGH8Z555',
iban='FR7630006000011234567890189',
venue=venue)
PcObject.save(user_offerer, bank_information)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
# when
response = auth_request.get('/venues/%s' % humanize(venue.id))
# then
assert response.status_code == 200
response_json = response.json
assert response_json['bic'] == 'QSDFGH8Z555'
assert response_json['iban'] == 'FR7630006000011234567890189'
assert 'validationToken' not in response_json
assert 'validationToken' not in response_json['managingOfferer']
def save_offerer_with_iban():
offerer_with_iban = create_offerer(siren='180046021', name='Philarmonie')
venue_with_siret = create_venue(offerer=offerer_with_iban,
siret='18004602100026',
is_virtual=False)
venue_without_siret = create_venue(offerer=offerer_with_iban,
siret=None,
is_virtual=False,
comment='pas de siret')
venue_online = create_venue(offerer=offerer_with_iban,
siret=None,
is_virtual=True)
bank_information = create_bank_information(
offerer=offerer_with_iban,
bic='TRPUFRP1',
iban='FR7610071750000000100420866',
application_id=1,
id_at_providers=offerer_with_iban.siren)
PcObject.save(bank_information, venue_online, venue_with_siret,
venue_without_siret)
logger.info(
'created 1 offerer with iban and 1 virtual venue, 1 venue with siret and 1 venue without siret'
)
return venue_online, venue_with_siret, venue_without_siret
def create_industrial_offerers_with_pro_users():
logger.info('create_industrial_offerers_with_pro_users')
locations = create_locations_from_places(OFFERER_PLACES,
max_location_per_place=3)
offerers_by_name = {}
users_by_name = {}
user_offerers_by_name = {}
user_index = 0
user_validation_prefix, user_validation_suffix = 'AZERTY', 123
# add a real offerer just for the inscription/validation API
real_siren = "784340093"
if not check_if_siren_already_exists(real_siren):
offerer_name = '784340093 lat:48.8 lon:1.48'
offerer = create_offerer(address="LIEU DIT CARTOUCHERIE",
city="Paris 12",
name="THEATRE DU SOLEIL",
postal_code="75012",
siren=real_siren)
offerers_by_name[offerer_name] = offerer
departement_code = 75
domain = MOCK_DOMAINS[user_index]
first_name = MOCK_FIRST_NAMES[user_index]
last_name = MOCK_LAST_NAMES[user_index]
email = get_email(first_name, last_name, domain)
user_name = '{} {}'.format(first_name, last_name)
user = create_user(departement_code=str(departement_code),
email=email,
first_name=first_name,
last_name=last_name,
postal_code="{}100".format(departement_code),
public_name="{} {}".format(first_name, last_name),
validation_token='{}{}'.format(
user_validation_prefix, user_validation_suffix))
users_by_name[user_name] = user
user_index += 1
user_validation_suffix += 1
user_offerers_by_name['{} / {}'.format(
user_name, offerer_name)] = create_user_offerer(
offerer=offerer,
user=user,
)
# loop on locations to create offerers and associated users
incremented_siren = 222222222
starting_index = 0
iban_prefix = 'FR7630001007941234567890185'
bic_prefix, bic_suffix = 'QSDFGH8Z', 555
user_offerer_validation_prefix, user_offerer_validation_suffix = 'AZERTY', 123
for (location_index, location) in enumerate(locations):
mock_index = location_index % len(MOCK_NAMES) + starting_index
departement_code = location['postalCode'][:2]
offerer_name = '{} lat:{} lon:{}'.format(incremented_siren,
location['latitude'],
location['longitude'])
offerer = create_offerer(
address=location['address'].upper(),
city=location['city'],
name=MOCK_NAMES[mock_index],
postal_code=location['postalCode'],
siren=str(incremented_siren),
)
# create every OFFERERS_WITH_IBAN_REMOVE_MODULO an offerer with no iban
if location_index % OFFERERS_WITH_IBAN_REMOVE_MODULO:
bank_information = create_bank_information(
bic=bic_prefix + str(bic_suffix),
iban=iban_prefix,
id_at_providers=offerer.siren,
offerer=offerer)
offerers_by_name[offerer_name] = offerer
incremented_siren += 1
bic_suffix += 1
# special user that signed up with this offerer
domain = MOCK_DOMAINS[user_index % len(MOCK_DOMAINS)]
first_name = MOCK_FIRST_NAMES[user_index % len(MOCK_FIRST_NAMES)]
last_name = MOCK_LAST_NAMES[user_index % len(MOCK_LAST_NAMES)]
email = get_email(first_name, last_name, domain)
user_name = '{} {}'.format(first_name, last_name)
if location_index % VALIDATED_USER_REMOVE_MODULO:
user_validation_token = None
else:
user_validation_token = '{}{}'.format(user_validation_prefix,
user_validation_suffix)
if location_index % VALIDATED_OFFERERS_REMOVE_MODULO == 0:
offerer.generate_validation_token()
user = create_user(departement_code=str(departement_code),
email=email,
first_name=first_name,
last_name=last_name,
postal_code="{}100".format(departement_code),
public_name="{} {}".format(first_name, last_name),
validation_token=user_validation_token)
users_by_name[user_name] = user
user_validation_suffix += 1
user_index += 1
# user_offerer with None as validation token
# because this user has created the offerer
user_offerers_by_name['{} / {}'.format(
user_name, offerer_name)] = create_user_offerer(offerer=offerer,
user=user)
# create also users that are attached to this offerer
for attached_user_index in range(ATTACHED_PRO_USERS_COUNT):
# special user that signed up with this offerer
domain = MOCK_DOMAINS[user_index % len(MOCK_DOMAINS)]
first_name = MOCK_FIRST_NAMES[user_index % len(MOCK_FIRST_NAMES)]
last_name = MOCK_LAST_NAMES[user_index % len(MOCK_LAST_NAMES)]
email = get_email(first_name, last_name, domain)
user_name = '{} {}'.format(first_name, last_name)
if location_index % VALIDATED_USER_REMOVE_MODULO:
user_validation_token = None
else:
user_validation_token = '{}{}'.format(user_validation_prefix,
user_validation_suffix)
user_name = '{} {}'.format(first_name, last_name)
user = create_user(departement_code=str(departement_code),
email=email,
first_name=first_name,
last_name=last_name,
postal_code="{}100".format(departement_code),
public_name="{} {}".format(
first_name, last_name),
validation_token=user_validation_token)
users_by_name[user_name] = user
user_index += 1
user_validation_suffix += 1
if location_index % VALIDATED_USER_OFFERER_REMOVE_MODULO:
user_offerer_validation_token = None
else:
user_offerer_validation_token = '{}{}'.format(
user_offerer_validation_prefix,
user_offerer_validation_suffix)
user_offerers_by_name['{} / {}'.format(
user_name, offerer_name)] = create_user_offerer(
offerer=offerer,
user=user,
validation_token=user_offerer_validation_token)
user_offerer_validation_suffix += 1
# loop on users to make some of them with several attached offerers
user_items_with_several_offerers = pick_every(
users_by_name.items(), USERS_WITH_SEVERAL_OFFERERS_PICK_MODULO)
user_offerer_index = 0
for (user_name, user) in user_items_with_several_offerers:
offerer_items_with_three_attached_users = pick_every(
offerers_by_name.items(),
OFFERERS_WITH_THREE_ATTACHED_USERS_PICK_MODULO)
for (offerer_name, offerer) in offerer_items_with_three_attached_users:
user_offerer_name = '{} / {}'.format(user_name, offerer_name)
if user_offerer_name in user_offerers_by_name:
continue
if offerer.validationToken == None \
and user_offerer_index % VALIDATED_USER_OFFERER_REMOVE_MODULO == 0:
user_offerer_validation_token = None
else:
user_offerer_validation_token = '{}{}'.format(
user_offerer_validation_prefix,
user_offerer_validation_suffix)
user_offerers_by_name['{} / {}'.format(
user_name, offerer_name)] = create_user_offerer(
offerer=offerer,
user=user,
validation_token=user_offerer_validation_token)
user_offerer_index += 1
user_offerer_validation_suffix += 1
objects_to_save = list(offerers_by_name.values()) + \
list(users_by_name.values()) + \
list(user_offerers_by_name.values())
PcObject.save(*objects_to_save)
logger.info('created {} offerers with pro users'.format(
len(offerers_by_name)))
return (offerers_by_name, users_by_name, user_offerers_by_name)
def test_get_offerers_with_params_for_pc_reporting_return_200_and_filtered_offerers(
app):
# given
data = {
"has_siren": True,
"is_validated": True,
"has_validated_user_offerer": True,
"has_validated_user": True,
"has_bank_information": False,
"is_active": True
}
user_querying = create_user(can_book_free_offers=False, is_admin=True)
offerer_no_siren = create_offerer(siren=None,
is_active=True,
validation_token=None)
offerer_not_validated = create_offerer(siren='123456789',
is_active=True,
validation_token='blabla')
offerer_not_validated_user_offerer = create_offerer(siren='123456780',
is_active=True,
validation_token=None)
offerer_not_validated_user = create_offerer(siren='123456781',
is_active=True,
validation_token=None)
offerer_bank_information = create_offerer(siren='123456782',
is_active=True,
validation_token=None)
offerer_not_active = create_offerer(siren='123456783',
is_active=False,
validation_token=None)
offerer_ok = create_offerer(siren='123456784',
is_active=True,
validation_token=None)
user_validated = create_user(email='*****@*****.**',
validation_token=None)
user_validated_2 = create_user(email='*****@*****.**',
validation_token=None)
user_not_validated = create_user(email='*****@*****.**',
validation_token='blabla')
user_offerer_no_siren = create_user_offerer(user_validated,
offerer_no_siren,
validation_token=None)
user_offerer_not_validated_offerer = create_user_offerer(
user_validated_2, offerer_not_validated, validation_token=None)
user_offerer_not_validated = create_user_offerer(
user_validated,
offerer_not_validated_user_offerer,
validation_token='blabla')
user_offerer_not_validated_user = create_user_offerer(
user_not_validated, offerer_not_validated_user, validation_token=None)
user_offerer_bank_information = create_user_offerer(
user_validated, offerer_bank_information, validation_token=None)
user_offerer_not_active = create_user_offerer(user_validated,
offerer_not_active)
user_offerer_ok = create_user_offerer(user_validated,
offerer_ok,
validation_token=None)
PcObject.save(user_querying, user_offerer_no_siren,
user_offerer_not_validated_offerer,
user_offerer_not_validated, user_offerer_not_validated_user,
user_offerer_bank_information, user_offerer_not_active,
user_offerer_ok)
bank_information = create_bank_information(
bic="AGRIFRPP",
iban='DE89370400440532013000',
id_at_providers=offerer_bank_information.siren,
offerer=offerer_bank_information)
PcObject.save(bank_information)
auth_request = TestClient(
app.test_client()).with_auth(email=user_querying.email)
# when
response = auth_request.post('/exports/offerers', json=data)
# then
assert response.status_code == 200
response_json = response.json
assert len(response_json) == 1
assert response_json[0]['siren'] == '123456784'
