def test_fails_when_is_digital_but_physical_venue(self, app): # Given digital_thing = create_product_with_thing_type( thing_type=ThingType.JEUX_VIDEO, url='http://mygame.fr/offre') offerer = create_offerer() physical_venue = create_venue(offerer) PcObject.save(physical_venue) offer = create_offer_with_thing_product(physical_venue, digital_thing) # When with pytest.raises(ApiErrors) as errors: PcObject.save(offer) # Then assert errors.value.errors['venue'] == [ 'Une offre numérique doit obligatoirement être associée au lieu "Offre en ligne"' ]
def test_returns_20_if_one_booking_with_amount_10_and_quantity_2( self, app): # Given user = create_user(email='*****@*****.**') deposit = create_deposit(user, amount=500) offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_thing_product(venue) stock = create_stock(price=10, offer=offer) booking = create_booking(user, stock, venue=venue, quantity=2) PcObject.save(booking, deposit) # When total_amount_spent = get_total_amount_spent() # Then assert total_amount_spent == 20
def test_returns_national_thing_with_different_department(self, app): # given product = create_product_with_thing_type(thing_name='Lire un livre', is_national=True) offerer = create_offerer() venue = create_venue(offerer, postal_code='34000', departement_code='34') offer = create_offer_with_thing_product(venue, product) PcObject.save(offer) query = Product.query.filter_by(name='Lire un livre') # when query = department_or_national_offers(query, ['93']) # then assert product in query.all()
def when_searching_by_keywords_and_distance(self, app): # Given user = create_user(email='*****@*****.**') concert_offer13 = create_offer_with_event_product( self.venue13, event_name='Funky Concert de Gael Faye', event_type=EventType.MUSIQUE) concert_offer75 = create_offer_with_event_product( self.venue75, event_name='Funky Concert de Gael Faye', event_type=EventType.MUSIQUE) concert_offer973 = create_offer_with_event_product( self.venue973, event_name='Kiwi', event_type=EventType.MUSIQUE) event_occurrence13 = create_event_occurrence( concert_offer13, beginning_datetime=self.in_one_hour, end_datetime=self.ten_days_from_now) event_occurrence75 = create_event_occurrence( concert_offer75, beginning_datetime=self.in_one_hour, end_datetime=self.ten_days_from_now) event_occurrence973 = create_event_occurrence( concert_offer973, beginning_datetime=self.in_one_hour, end_datetime=self.ten_days_from_now) recommendation13 = create_recommendation(concert_offer13, user) recommendation75 = create_recommendation(concert_offer75, user) recommendation973 = create_recommendation(concert_offer973, user) stock13 = create_stock_from_event_occurrence(event_occurrence13) stock75 = create_stock_from_event_occurrence(event_occurrence75) stock973 = create_stock_from_event_occurrence(event_occurrence973) PcObject.save(stock13, recommendation13, stock75, recommendation75, stock973, recommendation973) # When response = TestClient(app.test_client()).with_auth( user.email).get(RECOMMENDATION_URL + '?distance=1&keywords=funky') # Then assert len(response.json) == 2
def test_returns_true_when_a_beneficiary_import_exist_with_status_created( self, app): # given now = datetime.utcnow() user1 = create_user(email='*****@*****.**', date_created=now) beneficiary_import = create_beneficiary_import( user1, status=ImportStatus.CREATED, demarche_simplifiee_application_id=123) PcObject.save(beneficiary_import) # when result = is_already_imported(123) # then assert result is True
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 test_success_when_is_physical_and_physical_venue(self, app): # Given physical_thing = create_product_with_thing_type( thing_type=ThingType.LIVRE_EDITION, url=None) offerer = create_offerer() physical_venue = create_venue(offerer, is_virtual=False, siret=offerer.siren + '12345') PcObject.save(physical_venue) offer = create_offer_with_thing_product(physical_venue, physical_thing) # When PcObject.save(physical_thing, offer) # Then assert offer.url is None
def test_fails_when_is_physical_but_venue_is_virtual(self, app): # Given physical_thing = create_product_with_thing_type( thing_type=ThingType.JEUX_VIDEO, url=None) offerer = create_offerer() digital_venue = create_venue(offerer, is_virtual=True, siret=None) PcObject.save(digital_venue) offer = create_offer_with_thing_product(digital_venue, physical_thing) # When with pytest.raises(ApiErrors) as errors: PcObject.save(offer) # Then assert errors.value.errors['venue'] == [ 'Une offre physique ne peut être associée au lieu "Offre en ligne"' ]
def test_collect_application_details_for_each_application(self, find_latest_sync_end_event, get_application_details, get_all_application_ids_for_procedure, app): # given APPLICATION_ID_2 = 2 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, APPLICATION_ID_2] get_application_details.return_value = _create_detail_response(self.APPLICATION_ID, self.OFFERER_ID, self.VENUE_ID) PROCEDURE_ID_VENUE_WITHOUT_SIRET = '5636727' TOKEN = '4872' offerer = create_offerer(siren='793875030', idx=self.OFFERER_ID) venue = create_venue(offerer=offerer, idx=self.VENUE_ID) PcObject.save(venue) # when with patch.dict(os.environ, { 'DEMARCHES_SIMPLIFIEES_VENUE_WITHOUT_SIRET_PROCEDURE_ID': PROCEDURE_ID_VENUE_WITHOUT_SIRET, 'DEMARCHES_SIMPLIFIEES_TOKEN': TOKEN }, clear=True): provider_test(app, VenueWithoutSIRETBankInformationProvider, None, checkedObjects=0, createdObjects=2, updatedObjects=0, erroredObjects=0, checkedThumbs=0, createdThumbs=0, updatedThumbs=0, erroredThumbs=0, BankInformation=0) # then assert get_application_details.call_count == 2 assert get_application_details.call_args_list == [ call(self.APPLICATION_ID, PROCEDURE_ID_VENUE_WITHOUT_SIRET, TOKEN), call(APPLICATION_ID_2, PROCEDURE_ID_VENUE_WITHOUT_SIRET, TOKEN) ]
def test_filter_query_where_user_is_user_offerer_and_is_validated(app): # Given user = create_user(email='*****@*****.**') offerer1 = create_offerer(siren='123456789') offerer2 = create_offerer(siren='987654321') offerer3 = create_offerer(siren='123456780') user_offerer1 = create_user_offerer(user, offerer1) user_offerer2 = create_user_offerer(user, offerer2) event1 = create_product_with_event_type( event_name='Rencontre avec Jacques Martin') event2 = create_product_with_event_type( event_name='Concert de contrebasse') thing1 = create_product_with_thing_type(thing_name='Jacques la fripouille') thing2 = create_product_with_thing_type(thing_name='Belle du Seigneur') venue1 = create_venue(offerer1, name='Bataclan', city='Paris', siret=offerer1.siren + '12345') venue2 = create_venue(offerer2, name='Librairie la Rencontre', city='Saint Denis', siret=offerer2.siren + '54321') venue3 = create_venue(offerer3, name='Une librairie du méchant concurrent gripsou', city='Saint Denis', siret=offerer3.siren + '54321') offer1 = create_offer_with_event_product(venue1, event1) offer2 = create_offer_with_event_product(venue1, event2) offer3 = create_offer_with_thing_product(venue2, thing1) offer4 = create_offer_with_thing_product(venue3, thing2) PcObject.save(user_offerer1, user_offerer2, offerer3, offer1, offer2, offer3, offer4) # When offers = filter_query_where_user_is_user_offerer_and_is_validated( Offer.query.join(Venue).join(Offerer), user).all() # Then offer_ids = [offer.id for offer in offers] assert offer1.id in offer_ids assert offer2.id in offer_ids assert offer3.id in offer_ids assert offer4.id not in offer_ids
def test_create_filter_matching_all_keywords_in_any_models_with_several_keywords_at_just_venue_or_just_offerer_level( app): # given event_product = create_product_with_event_type() thing_product = create_product_with_thing_type() ok_offerer1 = create_offerer(name="Librairie La Rencontre") offerer2 = create_offerer(siren='123456788') offerer3 = create_offerer(siren='123456787') offerer4 = create_offerer(siren='123456786') ok_venue1 = create_venue(ok_offerer1, siret=ok_offerer1.siren + '54321') venue2 = create_venue(offerer2, siret=offerer2.siren + '12345') ok_venue3 = create_venue(offerer3, name='Librairie la Rencontre', city='Saint Denis', siret=offerer3.siren + '54321') venue4 = create_venue(offerer4, name='Bataclan', city='Paris', siret=offerer4.siren + '12345') ok_offer1 = create_offer_with_event_product(ok_venue1, event_product) ko_offer2 = create_offer_with_event_product(venue2, event_product) ok_offer3 = create_offer_with_thing_product(ok_venue1, thing_product) ko_offer4 = create_offer_with_thing_product(venue2, thing_product) ok_offer5 = create_offer_with_event_product(ok_venue3, event_product) ko_offer6 = create_offer_with_event_product(venue4, event_product) ok_offer7 = create_offer_with_thing_product(ok_venue3, thing_product) ko_offer8 = create_offer_with_thing_product(venue4, thing_product) PcObject.save(ok_offer1, ko_offer2, ok_offer3, ko_offer4, ok_offer5, ko_offer6, ok_offer7, ko_offer8) # when query = filter_offers_with_keywords_string(build_offer_search_base_query(), 'Librairie Rencontre') # then found_offers = query.all() found_offers_id = [found_offer.id for found_offer in found_offers] assert ok_offer1.id in found_offers_id assert ko_offer2.id not in found_offers_id assert ok_offer3.id in found_offers_id assert ko_offer4.id not in found_offers_id assert ok_offer5.id in found_offers_id assert ko_offer6.id not in found_offers_id assert ok_offer7.id in found_offers_id assert ko_offer8.id not in found_offers_id
def test_nOffers(app): # given offerer = create_offerer() venue_1 = create_venue(offerer, siret='12345678912345') venue_2 = create_venue(offerer, siret='67891234512345') venue_3 = create_venue(offerer, siret='23451234567891') offer_v1_1 = create_offer_with_thing_product(venue_1) offer_v1_2 = create_offer_with_event_product(venue_1) offer_v2_1 = create_offer_with_event_product(venue_2) offer_v2_2 = create_offer_with_event_product(venue_2) offer_v3_1 = create_offer_with_thing_product(venue_3) PcObject.save(offer_v1_1, offer_v1_2, offer_v2_1, offer_v2_2, offer_v3_1) # when n_offers = offerer.nOffers # then assert n_offers == 5
def test_returns_one_when_user_with_one_cancelled_and_one_non_cancelled_bookings(self, app): # Given user_having_booked = create_user(departement_code='73') offerer = create_offerer() venue = create_venue(offerer) offer1 = create_offer_with_thing_product(venue) offer2 = create_offer_with_thing_product(venue) stock1 = create_stock(offer=offer1, price=0) stock2 = create_stock(offer=offer2, price=0) booking1 = create_booking(user_having_booked, stock1, is_cancelled=False) booking2 = create_booking(user_having_booked, stock2, is_cancelled=True) PcObject.save(booking1, booking2) # When number_of_users_having_booked = count_users_having_booked_by_departement_code('73') # Then assert number_of_users_having_booked == 1
def test_count_users_by_departement_when_departement_code_given(self, app): # Given activated_user_from_74 = create_user(can_book_free_offers=True, departement_code='74') activated_user_from_75 = create_user(can_book_free_offers=True, departement_code='75', email='*****@*****.**') offerer = create_offerer() venue = create_venue(offerer) offer1 = create_offer_with_thing_product(venue) stock1 = create_stock(offer=offer1, price=0) booking1 = create_booking(activated_user_from_74, stock1) booking2 = create_booking(activated_user_from_75, stock1) PcObject.save(booking1, booking2) PcObject.save(activated_user_from_74, activated_user_from_75) # When count = count_users_having_booked('74') # Then assert count == 1
def when_the_token_is_missing(self, app): # given user = create_user(reset_password_token='KL89PBNG51') PcObject.save(user) data = {'newPassword': '******'} # when response = TestClient(app.test_client()).post( '/users/new-password', json=data, headers={'origin': 'http://localhost:3000'}) # then assert response.status_code == 400 assert response.json['token'] == [ 'Votre lien de changement de mot de passe est invalide.' ]
def when_new_password_is_missing(self, app): # given user = create_user(reset_password_token='KL89PBNG51') PcObject.save(user) data = {'token': 'KL89PBNG51'} # when response = TestClient(app.test_client()).post( '/users/new-password', json=data, headers={'origin': 'http://localhost:3000'}) # then assert response.status_code == 400 assert response.json['newPassword'] == [ 'Vous devez renseigner un nouveau mot de passe.' ]
def test_returns_an_event_if_it_is_given_in_department_list(self, app): # given product = create_product_with_event_type('Voir une pièce', is_national=False) offerer = create_offerer() venue = create_venue(offerer, is_virtual=False, postal_code='29000', departement_code='29') offer = create_offer_with_event_product(venue, product) PcObject.save(offer) query = Product.query.filter_by(name='Voir une pièce') # when query = department_or_national_offers(query, ['29']) # then assert query.count() == 1
def when_offer_id_is_not_received(self, app): # Given user = create_user(email='*****@*****.**') PcObject.save(user) json = { 'mediationId': 'DA', } # When response = TestClient(app.test_client()).with_auth( user.email).post(f'{API_URL}/favorites', json=json) # Then assert response.status_code == 400 assert response.json['global'] == [ "Le paramètre offerId est obligatoire" ]
def test_does_not_show_anything_to_user_offerer_when_not_validated( self, app): # Given user = create_user() offerer = create_offerer() venue = create_venue(offerer) user_offerer = create_user_offerer( user, offerer, validation_token=secrets.token_urlsafe(20)) offer = create_offer_with_thing_product(venue) PcObject.save(user_offerer, offer) auth_request = TestClient( app.test_client()).with_auth(email=user.email) # When response = auth_request.get('/offers') # Then assert response.status_code == 200 assert response.json == []
def test_returns_national_event_with_different_department(self, app): # given product = create_product_with_event_type('Voir une pièce', is_national=True) offerer = create_offerer() venue = create_venue(offerer, is_virtual=False, postal_code='29000', departement_code='29') offer = create_offer_with_event_product(venue, product) PcObject.save(offer) query = Product.query.filter_by(name='Voir une pièce') # when query = department_or_national_offers(query, ['93']) # then assert product in query.all()
def do_ban_payments(message_id: str, payment_ids_to_ban: List[int]): matching_payments = find_payments_by_message(message_id) try: banned_payments, retry_payments = apply_banishment( matching_payments, payment_ids_to_ban) except UnmatchedPayments as e: logger.error('Le message "%s" ne contient pas les paiements : %s.' '\nAucun paiement n\'a été mis à jour.' % (message_id, e.payment_ids)) else: if banned_payments: PcObject.save(*(banned_payments + retry_payments)) logger.info('Paiements bannis : %s ' % list(map(lambda p: p.id, banned_payments))) logger.info('Paiements à réessayer : %s ' % list(map(lambda p: p.id, retry_payments)))
def post_for_password_token(): validate_reset_request(request) email = request.get_json()['email'] user = find_user_by_email(email) if not user: return '', 204 generate_reset_token(user) PcObject.save(user) app_origin_url = request.headers.get('origin') try: send_reset_password_email(user, send_raw_email, app_origin_url) except MailServiceException as e: app.logger.error('Mail service failure', e) return '', 204
def test_beginning_datetime_cannot_be_after_end_datetime(app): # given offer = create_offer_with_thing_product(create_venue(create_offerer())) now = datetime.utcnow() beginning = now - timedelta(days=5) end = beginning - timedelta(days=1) stock = create_stock(offer=offer, beginning_datetime=beginning, end_datetime=end) # when with pytest.raises(ApiErrors) as e: PcObject.save(stock) # then assert e.value.errors['endDatetime'] == [ 'La date de fin de l\'événement doit être postérieure à la date de début' ]
def when_user_has_already_seen_recommendation(self, app): # given user = create_user() offerer = create_offerer() venue = create_venue(offerer, postal_code='29100', siret='12345678912341') offer = create_offer_with_thing_product(venue) mediation = create_mediation(offer, is_active=True) stock = create_stock_from_offer(offer) recommendation = create_recommendation(offer=offer, user=user, mediation=mediation, is_clicked=False) PcObject.save(stock, recommendation) # when response = TestClient(app.test_client()).with_auth(user.email) \ .put(RECOMMENDATION_URL, json={'seenRecommendationIds': [humanize(recommendation.id)]}) # then assert response.status_code == 200 assert response.json == []
def when_offers_have_no_thumb_count_for_thing_and_a_mediation( self, app): # given user = create_user(email='*****@*****.**') offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_thing_product(venue, thumb_count=0) stock = create_stock_from_offer(offer, price=0) mediation = create_mediation(offer) PcObject.save(user, stock, mediation) auth_request = TestClient(app.test_client()).with_auth(user.email) # when response = auth_request.put(RECOMMENDATION_URL, json={'seenRecommendationIds': []}) # then assert response.status_code == 200 assert len(response.json) == 1
def test_does_not_update_thing_when_unknonw_id_at_providers_in_given_zip_file( self, app): # given filename = 'tests/local_providers/Resume-full_01012019.zip' thing_1 = create_product_with_thing_type( id_at_providers='1234567029006') init_titelive_thing_descriptions = InitTiteLiveThingDescriptions( filename) init_titelive_thing_descriptions.dbObject.isActive = True PcObject.save(thing_1, init_titelive_thing_descriptions.dbObject) # when init_titelive_thing_descriptions.updateObjects() # then assert init_titelive_thing_descriptions.checkedObjects == 0 assert init_titelive_thing_descriptions.updatedObjects == 0
def when_offerer_id_does_not_exist(self, app): # given user1 = create_user(email='*****@*****.**') user2 = create_user(email='*****@*****.**') offerer = create_offerer(siren='123456781') user_offerer1 = create_user_offerer(user1, offerer) user_offerer2 = create_user_offerer(user2, offerer) PcObject.save(user_offerer1, user_offerer2) non_existing_offerer_id = 'B9' # when response = TestClient(app.test_client()) \ .with_auth(email=user1.email) \ .get('/userOfferers/' + non_existing_offerer_id) # then assert response.status_code == 200 assert response.json == []
def test_send_transactions_set_status_to_error_with_details_if_email_was_not_sent_properly( app): # given offerer1 = create_offerer(name='first offerer') user = create_user() venue1 = create_venue(offerer1) stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1)) booking1 = create_booking(user, stock1) booking2 = create_booking(user, stock1) booking3 = create_booking(user, stock1) deposit = create_deposit(user, amount=500) payments = [ create_payment(booking1, offerer1, Decimal(10), iban='CF13QSDFGH456789', bic='QSDFGH8Z555'), create_payment(booking2, offerer1, Decimal(20), iban='CF13QSDFGH456789', bic='QSDFGH8Z555'), create_payment(booking3, offerer1, Decimal(20), iban='CF13QSDFGH456789', bic='QSDFGH8Z555') ] PcObject.save(deposit) PcObject.save(*payments) app.mailjet_client.send.create.return_value = Mock(status_code=400) # when send_transactions(payments, 'BD12AZERTY123456', 'AZERTY9Q666', '0000', ['*****@*****.**']) # then updated_payments = Payment.query.all() for payment in updated_payments: assert len(payment.statuses) == 2 assert payment.currentStatus.status == TransactionStatus.ERROR assert payment.currentStatus.detail == "Erreur d'envoi à MailJet"
def test_send_transactions_creates_a_new_payment_transaction_if_email_was_sent_properly( app): # given@ offerer1 = create_offerer(name='first offerer') user = create_user() venue1 = create_venue(offerer1) stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1)) booking1 = create_booking(user, stock1) booking2 = create_booking(user, stock1) booking3 = create_booking(user, stock1) deposit = create_deposit(user, amount=500) payments = [ create_payment(booking1, offerer1, Decimal(10), iban='CF13QSDFGH456789', bic='QSDFGH8Z555'), create_payment(booking2, offerer1, Decimal(20), iban='CF13QSDFGH456789', bic='QSDFGH8Z555'), create_payment(booking3, offerer1, Decimal(20), iban='CF13QSDFGH456789', bic='QSDFGH8Z555') ] PcObject.save(deposit) PcObject.save(*payments) app.mailjet_client.send.create.return_value = Mock(status_code=200) # when send_transactions(payments, 'BD12AZERTY123456', 'AZERTY9Q666', '0000', ['*****@*****.**']) # then updated_payments = Payment.query.all() assert all(p.paymentMessageName == 'passCulture-SCT-20181015-092134' for p in updated_payments) assert all(p.paymentMessageChecksum == payments[0].paymentMessageChecksum for p in updated_payments)
def validate(): token = request.args.get('token') check_validation_request(token) model_names = request.args.get('modelNames') if model_names is None: e = ApiErrors() e.add_error('modelNames', 'Vous devez fournir des noms de classes') return jsonify(e.errors), 400 model_names = model_names.split(',') objects_to_validate = [] for model_name in model_names: query = getattr(models, model_name) \ .query \ .filter_by(validationToken=token) objects_to_validate += query.all() if len(objects_to_validate) == 0: return "Aucun(e) objet ne correspond à ce code de validation" \ + " ou l'objet est déjà validé", \ 404 for obj in objects_to_validate: obj.validationToken = None PcObject.save(*objects_to_validate) user_offerers = iter( [obj for obj in objects_to_validate if isinstance(obj, UserOfferer)]) user_offerer = next(user_offerers, None) offerers = iter( [obj for obj in objects_to_validate if isinstance(obj, Offerer)]) offerer = next(offerers, None) try: send_validation_confirmation_email(user_offerer, offerer, send_raw_email) except MailServiceException as e: app.logger.error('Mail service failure', e) return "Validation effectuée", 202