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'