def when_feature_send_mail_to_users_enabled_and_offer_booking_email_sends_to_offerer_and_administration( self, app): # Given user = create_user(email='*****@*****.**') offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue) stock.resolvedOffer.bookingEmail = '*****@*****.**' booking = create_booking(user, stock, venue) mocked_send_email = Mock() return_value = Mock() return_value.status_code = 200 mocked_send_email.return_value = return_value with patch( 'utils.mailing.feature_send_mail_to_users_enabled', return_value=True ), patch( 'domain.user_emails.make_offerer_booking_recap_email_after_user_action', return_value={'Html-part': ''}) as make_offerer_recap_email: # When send_user_driven_cancellation_email_to_offerer( booking, mocked_send_email) # Then make_offerer_recap_email.assert_called_once_with( booking, is_cancellation=True) mocked_send_email.assert_called_once() args = mocked_send_email.call_args assert args[1]['data'][ 'To'] == '[email protected], [email protected]'
def when_feature_send_mail_to_users_disabled_sends_email_to_pass_culture_dev( self, app): # given offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer( offerer, venue, booking_email='*****@*****.**') mocked_send_email = Mock() return_value = Mock() return_value.status_code = 200 mocked_send_email.return_value = return_value with patch('utils.mailing.feature_send_mail_to_users_enabled' ) as send_mail_to_users, patch( 'domain.user_emails.set_booking_recap_sent_and_save' ) as set_booking_recap_sent_and_save: send_mail_to_users.return_value = False # when send_final_booking_recap_email(stock, mocked_send_email) # then mocked_send_email.assert_called_once() args = mocked_send_email.call_args assert args[1]['data']['To'] == '*****@*****.**' set_booking_recap_sent_and_save.assert_called_once_with(stock)
def when_feature_send_mail_to_users_enabled_and_not_offer_booking_email_sends_only_to_administration( self, app): # given offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, booking_email=None) mocked_send_email = Mock() return_value = Mock() return_value.status_code = 200 mocked_send_email.return_value = return_value with patch('utils.mailing.feature_send_mail_to_users_enabled' ) as send_mail_to_users, patch( 'domain.user_emails.set_booking_recap_sent_and_save' ) as set_booking_recap_sent_and_save: send_mail_to_users.return_value = True # when send_final_booking_recap_email(stock, mocked_send_email) # then mocked_send_email.assert_called_once() args = mocked_send_email.call_args assert args[1]['data']['To'] == '*****@*****.**' set_booking_recap_sent_and_save.assert_called_once_with(stock)
def when_header_is_not_standard_but_request_is_valid(self, app): # Given user = create_user() admin_user = create_user(email='*****@*****.**') offerer = create_offerer() user_offerer = create_user_offerer(admin_user, offerer) venue = create_venue(offerer) stock = create_stock_with_event_offer( offerer, venue, price=0, beginning_datetime=Patch.tomorrow, end_datetime=Patch.tomorrow_plus_one_hour, booking_limit_datetime=Patch.tomorrow_minus_one_hour) booking = create_booking(user, stock, venue=venue) PcObject.save(booking, user_offerer) booking_id = booking.id url = '/bookings/token/{}'.format(booking.token) # When response = TestClient(app.test_client()) \ .with_auth('*****@*****.**') \ .patch(url, headers={'origin': 'http://random_header.fr'}) # Then assert response.status_code == 204 assert Booking.query.get(booking_id).isUsed
def when_called_calls_send_email(self, app): # Given venue = create_venue(None, 'Test offerer', '*****@*****.**', '123 rue test', '93000', 'Test city', '93') stock = create_stock_with_event_offer(offerer=None, venue=venue) user = create_user('Test', departement_code='93', email='*****@*****.**', can_book_free_offers=True) booking = create_booking(user, stock, venue, None) booking.token = '56789' mocked_send_email = Mock() return_value = Mock() return_value.status_code = 200 mocked_send_email.return_value = return_value # When send_booking_confirmation_email_to_user(booking, mocked_send_email) # Then mocked_send_email.assert_called_once() called_with_args = mocked_send_email.call_args[1]['data'] assert 'This is a test (ENV=development). In production, email would have been sent to : [email protected]' in \ called_with_args[ 'Html-part'] assert called_with_args['To'] == '*****@*****.**' assert called_with_args['FromName'] == 'Pass Culture' assert called_with_args['FromEmail'] == '*****@*****.**'
def when_user_not_editor_and_valid_email_but_invalid_offer_id( self, app): # Given user = create_user() admin_user = create_user(email='*****@*****.**') offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer( offerer, venue, price=0, beginning_datetime=Patch.tomorrow, end_datetime=Patch.tomorrow_plus_one_hour, booking_limit_datetime=Patch.tomorrow_minus_one_hour) booking = create_booking(user, stock, venue=venue) PcObject.save(booking, admin_user) booking_id = booking.id url = '/bookings/token/{}?email={}&offer_id={}'.format( booking.token, user.email, humanize(123)) # When response = TestClient( app.test_client()).with_auth('*****@*****.**').patch(url) # Then assert response.status_code == 404 assert not Booking.query.get(booking_id).isUsed
def when_booking_already_validated(self, app): # Given user = create_user() admin_user = create_user(email='*****@*****.**') offerer = create_offerer() user_offerer = create_user_offerer(admin_user, offerer) venue = create_venue(offerer) stock = create_stock_with_event_offer( offerer, venue, price=0, beginning_datetime=Patch.tomorrow, end_datetime=Patch.tomorrow_plus_one_hour, booking_limit_datetime=Patch.tomorrow_minus_one_hour) booking = create_booking(user, stock, venue=venue) booking.isUsed = True PcObject.save(booking, user_offerer) booking_id = booking.id url = '/bookings/token/{}'.format(booking.token) # When response = TestClient( app.test_client()).with_auth('*****@*****.**').patch(url) # Then assert response.status_code == 410 assert response.json['booking'] == [ 'Cette réservation a déjà été validée' ] assert Booking.query.get(booking_id).isUsed
def when_user_has_rights(self, app): # Given user = create_user() admin_user = create_user(email='*****@*****.**') offerer = create_offerer() user_offerer = create_user_offerer(admin_user, offerer) venue = create_venue(offerer) stock = create_stock_with_event_offer( offerer, venue, price=0, beginning_datetime=Patch.tomorrow, end_datetime=Patch.tomorrow_plus_one_hour, booking_limit_datetime=Patch.tomorrow_minus_one_hour) booking = create_booking(user, stock, venue=venue) PcObject.save(booking, user_offerer) booking_id = booking.id url = '/bookings/token/{}'.format(booking.token) # When response = TestClient( app.test_client()).with_auth('*****@*****.**').patch(url) # Then assert response.status_code == 204 assert Booking.query.get(booking_id).isUsed assert Booking.query.get(booking_id).dateUsed is not None
def when_user_not_editor_and_valid_email(self, app): # Given user = create_user() admin_user = create_user(email='*****@*****.**') offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer( offerer, venue, price=0, beginning_datetime=Patch.tomorrow, end_datetime=Patch.tomorrow_plus_one_hour, booking_limit_datetime=Patch.tomorrow_minus_one_hour) booking = create_booking(user, stock, venue=venue) PcObject.save(booking, admin_user) booking_id = booking.id url = '/bookings/token/{}?email={}'.format(booking.token, user.email) # When response = TestClient( app.test_client()).with_auth('*****@*****.**').patch(url) # Then assert response.status_code == 403 assert response.json['global'] == [ "Vous n'avez pas les droits d'accès suffisant pour accéder à cette information." ] assert not Booking.query.get(booking_id).isUsed
def when_booking_is_on_stock_with_beginning_datetime_in_more_than_72_hours( self, app): # Given in_73_hours = datetime.utcnow() + timedelta(hours=73) in_74_hours = datetime.utcnow() + timedelta(hours=74) in_72_hours = datetime.utcnow() + timedelta(hours=72) user = create_user(email='*****@*****.**') admin_user = create_user(email='*****@*****.**') offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer( offerer, venue, price=0, beginning_datetime=in_73_hours, end_datetime=in_74_hours, booking_limit_datetime=in_72_hours) booking = create_booking(user, stock, venue=venue) PcObject.save(admin_user, booking) url = '/bookings/token/{}?email={}&offer_id={}'.format( booking.token, '*****@*****.**', humanize(stock.offerId)) # When response = TestClient(app.test_client()).get(url) # Then assert response.status_code == 403 assert response.json['beginningDatetime'] == [ 'Vous ne pouvez pas valider cette contremarque plus de 72h avant le début de l\'évènement' ]
def expect_bookings_to_be_cancelled(self, app): # given user = create_user(email='*****@*****.**') other_user = create_user(email='*****@*****.**') offerer = create_offerer() user_offerer = create_user_offerer(user, offerer) venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=0) booking1 = create_booking(other_user, stock=stock, is_cancelled=False) booking2 = create_booking(other_user, stock=stock, is_cancelled=False) PcObject.save(user, stock, user_offerer, booking1, booking2) # when response = TestClient(app.test_client()).with_auth( '*****@*****.**').delete('/stocks/' + humanize(stock.id)) # then assert response.status_code == 200 bookings = Booking.query.filter_by(isCancelled=True).all() assert booking1 in bookings assert booking2 in bookings
def expect_the_booking_to_have_good_includes(self, app): offerer = create_offerer('987654321', 'Test address', 'Test city', '93000', 'Test name') venue = create_venue(offerer, 'Test offerer', '*****@*****.**', '123 rue test', '93000', 'Test city', '93') ok_stock = create_stock_with_event_offer(offerer=offerer, venue=venue, price=0) ok_stock.bookingLimitDatetime = datetime.utcnow() + timedelta( minutes=2) ok_stock.bookingLimitDatetime = datetime.utcnow() + timedelta( minutes=2) PcObject.save(ok_stock) user = create_user(email='*****@*****.**') PcObject.save(user) recommendation = create_recommendation(offer=ok_stock.offer, user=user) PcObject.save(recommendation) booking_json = { 'stockId': humanize(ok_stock.id), 'recommendationId': humanize(recommendation.id), 'quantity': 1 } r_create = TestClient(app.test_client()).with_auth( email='*****@*****.**').post('/bookings', json=booking_json) assert r_create.status_code == 201 assert r_create.json['stock']['isBookable']
def test_should_return_offers_that_occur_in_less_than_10_days_and_things_first( app): # Given offerer = create_offerer() venue = create_venue(offerer, postal_code='34000', departement_code='34') stock1 = create_stock_with_thing_offer(offerer, venue, name='thing') stock2 = create_stock_with_event_offer( offerer, venue, beginning_datetime=datetime.utcnow() + timedelta(days=4), end_datetime=datetime.utcnow() + timedelta(days=4, hours=2), name='event_occurs_soon', thumb_count=1) stock3 = create_stock_with_event_offer( offerer, venue, beginning_datetime=datetime.utcnow() + timedelta(days=11), end_datetime=datetime.utcnow() + timedelta(days=11, hours=2), name='event_occurs_later', thumb_count=1) PcObject.save(stock3) PcObject.save(stock2) PcObject.save(stock1) # When offers = get_active_offers(user=create_user(email="*****@*****.**"), departement_codes=['00'], offer_id=None) # Then assert len(offers) == 3 assert (offers[0].name == 'event_occurs_soon' and offers[1].name == 'thing') \ or (offers[1].name == 'event_occurs_soon' and offers[0].name == 'thing') assert offers[2].name == 'event_occurs_later'
def test_queryNotSoftDeleted_should_not_return_soft_deleted(app): # Given offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue) stock.isSoftDeleted = True PcObject.save(stock) # When result = Stock.queryNotSoftDeleted().all() # Then assert not result
def when_current_user_has_no_rights_on_offer(self, app): # given user = create_user(email='*****@*****.**') offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue) PcObject.save(user, stock) # when response = TestClient(app.test_client()).with_auth('*****@*****.**') \ .delete('/stocks/' + humanize(stock.id)) # then assert response.status_code == 403
def when_end_limit_datetime_is_none_for_event(self, app): # given user = create_user(email='*****@*****.**', can_book_free_offers=False, is_admin=True) offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue) PcObject.save(stock, user) # when response = TestClient(app.test_client()).with_auth('*****@*****.**') \ .patch('/stocks/' + humanize(stock.id), json={'endDatetime': None}) # then assert response.status_code == 400 assert response.json['endDatetime'] == ['Ce paramètre est obligatoire']
def when_user_has_no_rights(self, app): # given user = create_user(email='*****@*****.**') offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue) PcObject.save(user, stock) # when response = TestClient(app.test_client()).with_auth('*****@*****.**') \ .patch('/stocks/' + humanize(stock.id), json={'available': 5}) # then assert response.status_code == 403 assert "Vous n'avez pas les droits d'accès suffisant pour accéder à cette information." in response.json[ 'global']
def when_available_below_number_of_already_existing_bookings(self, app): # given user = create_user() user_admin = create_user(email='*****@*****.**', can_book_free_offers=False, is_admin=True) offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=0) stock.available = 1 booking = create_booking(user, stock, venue, recommendation=None) PcObject.save(booking, user_admin) # when response = TestClient(app.test_client()).with_auth('*****@*****.**') \ .patch('/stocks/' + humanize(stock.id), json={'available': 0}) # then assert response.status_code == 200 assert 'available' in response.json
def when_wrong_type_for_available(self, app): # given user = create_user() user_admin = create_user(email='*****@*****.**', can_book_free_offers=False, is_admin=True) offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=0) stock.available = 1 booking = create_booking(user, stock, venue, recommendation=None) PcObject.save(booking, user_admin) # when response = TestClient(app.test_client()).with_auth('*****@*****.**') \ .patch('/stocks/' + humanize(stock.id), json={'available': ' '}) # then assert response.status_code == 400 assert response.json['available'] == ['Saisissez un nombre valide']
def when_offer_id_is_missing(self, app): # Given user = create_user() offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=0) booking = create_booking(user, stock, venue=venue) PcObject.save(booking) url = '/bookings/token/{}?email={}'.format( booking.token, user.email) # When response = TestClient(app.test_client()).patch(url) # Then assert response.status_code == 400 assert response.json['offer_id'] == [ "L'id de l'offre réservée est obligatoire dans l'URL [?offer_id=<id>]" ]
def when_user_is_admin(self, app): # given user = create_user(email='*****@*****.**', can_book_free_offers=False, is_admin=True) offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=10, available=10) PcObject.save(user, stock) humanized_stock_id = humanize(stock.id) # when request_update = TestClient(app.test_client()).with_auth('*****@*****.**') \ .patch('/stocks/' + humanized_stock_id, json={'available': 5, 'price': 20}) # then assert request_update.status_code == 200 request_after_update = TestClient(app.test_client()).with_auth('*****@*****.**').get( '/stocks/' + humanized_stock_id) assert request_after_update.json['available'] == 5 assert request_after_update.json['price'] == 20
def when_booking_limit_datetime_after_beginning_datetime(self, app): # given user = create_user(email='*****@*****.**', can_book_free_offers=False, is_admin=True) offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue) PcObject.save(stock, user) stockId = stock.id serialized_date = serialize(stock.beginningDatetime + timedelta(days=1)) # when response = TestClient(app.test_client()).with_auth('*****@*****.**') \ .patch('/stocks/' + humanize(stockId), json={'bookingLimitDatetime': serialized_date}) # then assert response.status_code == 400 assert response.json['bookingLimitDatetime'] == [ 'La date limite de réservation pour cette offre est postérieure à la date de début de l\'évènement' ]
def expect_booking_to_be_used(self, app): # Given user = create_user() offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=0) booking = create_booking(user, stock, venue=venue) PcObject.save(booking) booking_id = booking.id url = '/bookings/token/{}?email={}&offer_id={}'.format( booking.token, user.email, humanize(stock.resolvedOffer.id)) # When response = TestClient(app.test_client()).patch(url) # Then assert response.status_code == 204 assert Booking.query.get(booking_id).isUsed is True
def when_email_is_missing(self, app): # Given user = create_user() offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=0) booking = create_booking(user, stock, venue=venue) PcObject.save(booking) url = '/bookings/token/{}?&offer_id={}'.format( booking.token, humanize(stock.resolvedOffer.id)) # When response = TestClient(app.test_client()).patch(url) # Then assert response.status_code == 400 assert response.json['email'] == [ "L'adresse email qui a servie à la réservation est obligatoire dans l'URL [?email=<email>]" ]
def when_user_has_not_enough_credit(self, app): # Given user = create_user(email='*****@*****.**') offerer = create_offerer(siren='899999768', address='2 Test adress', city='Test city', postal_code='93000', name='Test offerer') venue = create_venue(offerer=offerer, name='Venue name', booking_email='*****@*****.**', address='1 Test address', postal_code='93000', city='Test city', departement_code='93') stock = create_stock_with_event_offer(offerer, venue, price=200) event_offer = stock.resolvedOffer recommendation = create_recommendation(event_offer, user) deposit_date = datetime.utcnow() - timedelta(minutes=2) deposit = create_deposit(user, amount=0) PcObject.save(recommendation) PcObject.save(stock) PcObject.save(deposit) booking_json = { "stockId": humanize(stock.id), "recommendationId": humanize(recommendation.id), "quantity": 1 } # When r_create = TestClient(app.test_client()) \ .with_auth('*****@*****.**') \ .post('/bookings', json=booking_json) # Then assert r_create.status_code == 400 assert 'insufficientFunds' in r_create.json assert r_create.json['insufficientFunds'] == [ "Le solde de votre pass est insuffisant pour réserver cette offre." ]
def expect_booking_to_be_used(self, app): # Given user = create_user() admin_user = create_user(email='*****@*****.**') offerer = create_offerer() user_offerer = create_user_offerer(admin_user, offerer) venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=0) booking = create_booking(user, stock, venue=venue) PcObject.save(booking, user_offerer) booking_id = booking.id url = '/bookings/token/{}'.format(booking.token) # When response = TestClient( app.test_client()).with_auth('*****@*****.**').patch(url) # Then assert response.status_code == 204 assert Booking.query.get(booking_id).isUsed is True
def when_user_is_not_editor_and_email_does_not_match(self, app): # Given user = create_user() admin_user = create_user(email='*****@*****.**') offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=0) booking = create_booking(user, stock, venue=venue) PcObject.save(booking, admin_user) booking_id = booking.id url = '/bookings/token/{}?email={}'.format( booking.token, '*****@*****.**') # When response = TestClient( app.test_client()).with_auth('*****@*****.**').patch(url) # Then assert response.status_code == 404 assert Booking.query.get(booking_id).isUsed is False
def when_booking_does_not_exist(self, app): # Given user = create_user() offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=0) booking = create_booking(user, stock, venue=venue) PcObject.save(booking) url = '/bookings/token/{}?email={}&offer_id={}'.format( booking.token, '*****@*****.**', humanize(stock.resolvedOffer.id)) # When response = TestClient(app.test_client()).patch(url) # Then assert response.status_code == 404 assert response.json['global'] == [ "Cette contremarque n'a pas été trouvée" ]
def when_stock_is_soft_deleted(self, app): # given user = create_user(email='*****@*****.**', can_book_free_offers=False, is_admin=True) offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=10, available=10, is_soft_deleted=True) PcObject.save(user, stock) humanized_stock_id = humanize(stock.id) # when request = TestClient(app.test_client()).with_auth('*****@*****.**') \ .get('/stocks/' + humanized_stock_id) # then assert request.status_code == 404
def when_booking_limit_datetime_is_none_for_event(self, app): # Given user = create_user(email='*****@*****.**', can_book_free_offers=False, is_admin=True) offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue) PcObject.save(user, stock) data = { 'price': 0, 'offerId': humanize(stock.offer.id), 'bookingLimitDatetime': None } # When response = TestClient(app.test_client()).with_auth(user.email) \ .patch('/stocks/' + humanize(stock.id), json=data) # Then assert response.status_code == 400 assert response.json["bookingLimitDatetime"] == ['Ce paramètre est obligatoire']