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']
