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=tomorrow,
booking_limit_datetime=tomorrow_minus_one_hour)
booking = create_booking(user=user, stock=stock, venue=venue)
booking.isUsed = True
repository.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_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=tomorrow,
booking_limit_datetime=tomorrow_minus_one_hour)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.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_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=tomorrow,
booking_limit_datetime=tomorrow_minus_one_hour)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.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_non_standard_origin_header(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=datetime.utcnow() + timedelta(hours=46),
booking_limit_datetime=datetime.utcnow() + timedelta(hours=24),
)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(booking, user_offerer)
url = f"/v2/bookings/token/{booking.token}"
# When
response = (
TestClient(app.test_client())
.with_auth("*****@*****.**")
.get(url, headers={"origin": "http://random_header.fr"})
)
# Then
assert response.status_code == 200
def when_api_key_given_not_related_to_booking_offerer(self, app):
# Given
user = create_user(email="*****@*****.**")
pro_user = create_user(email="*****@*****.**")
offerer = create_offerer()
offerer2 = create_offerer(siren="987654321")
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0, event_type=EventType.CINEMA)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(pro_user, booking, user_offerer, offerer2)
offerer_api_key = create_api_key(offerer_id=offerer2.id)
repository.save(offerer_api_key)
user2ApiKey = "Bearer " + offerer_api_key.value
# When
url = "/v2/bookings/use/token/{}".format(booking.token)
response = TestClient(app.test_client()).patch(
url, headers={"Authorization": user2ApiKey, "Origin": "http://localhost"}
)
# Then
assert response.status_code == 403
assert response.json["user"] == ["Vous n'avez pas les droits suffisants pour valider cette contremarque."]
def when_api_key_is_provided_and_booking_has_not_been_validated_already(self, app):
# Given
user = create_user()
pro_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(booking, user_offerer)
offererApiKey = create_api_key(offerer_id=offerer.id)
repository.save(offererApiKey)
# When
url = "/v2/bookings/keep/token/{}".format(booking.token)
user2_api_key = "Bearer " + offererApiKey.value
response = TestClient(app.test_client()).patch(
url, headers={"Authorization": user2_api_key, "Origin": "http://localhost"}
)
# Then
assert response.status_code == 410
assert response.json["booking"] == ["Cette réservation n'a pas encore été validée"]
assert Booking.query.get(booking.id).isUsed is False
def when_api_key_is_provided_and_booking_payment_exists(self, app):
# Given
user = create_user()
pro_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0)
booking = create_booking(user=user, stock=stock, venue=venue, is_used=True)
payment = create_payment(booking, offerer, Decimal(10), iban="CF13QSDFGH456789", bic="QSDFGH8Z555")
repository.save(booking, user_offerer, payment)
offererApiKey = create_api_key(offerer_id=offerer.id)
repository.save(offererApiKey)
# When
url = "/v2/bookings/keep/token/{}".format(booking.token)
user2_api_key = "Bearer " + offererApiKey.value
response = TestClient(app.test_client()).patch(
url, headers={"Authorization": user2_api_key, "Origin": "http://localhost"}
)
# Then
assert response.status_code == 410
assert response.json["payment"] == ["Le remboursement est en cours de traitement"]
assert Booking.query.get(booking.id).isUsed is True
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
repository.save(stock)
# When
result = Stock.queryNotSoftDeleted().all()
# Then
assert not result
def test_is_expired_when_stock_is_an_event_in_the_past(self):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
one_day_in_the_past = datetime.utcnow() - timedelta(hours=24)
stock = create_stock_with_event_offer(
offerer=offerer,
venue=venue,
beginning_datetime=one_day_in_the_past)
# When
is_event_expired = stock.isEventExpired
# Then
assert is_event_expired is True
def test_is_not_expired_when_stock_is_an_event_in_the_future(self):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
three_days_from_now = datetime.utcnow() + timedelta(hours=72)
stock = create_stock_with_event_offer(
offerer=offerer,
venue=venue,
beginning_datetime=three_days_from_now)
# When
is_event_expired = stock.isEventExpired
# Then
assert is_event_expired is False
def test_is_deletable_when_stock_is_an_event_in_the_future(self):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
three_days_from_now = datetime.utcnow() + timedelta(hours=72)
stock = create_stock_with_event_offer(
offerer=offerer,
venue=venue,
beginning_datetime=three_days_from_now)
# When
is_event_deletable = stock.isEventDeletable
# Then
assert is_event_deletable is True
def when_booking_is_not_provided_at_all(self, app):
# Given
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=user, stock=stock, venue=venue)
repository.save(booking)
# When
url = "/v2/bookings/use/token/"
response = TestClient(app.test_client()).patch(url)
# Then
assert response.status_code == 404
def when_user_not_logged_in_and_doesnt_give_api_key(self, app):
# Given
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=user, stock=stock, venue=venue)
repository.save(booking)
# When
url = "/v2/bookings/use/token/{}".format(booking.token)
response = TestClient(app.test_client()).patch(url)
# Then
assert response.status_code == 401
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=user, stock=stock, venue=venue)
repository.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 test_is_not_deletable_when_stock_is_expired_since_more_than_event_automatic_refund_delay(
self):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
expired_date_and_automaticaly_refunded = datetime.utcnow(
) - EVENT_AUTOMATIC_REFUND_DELAY_FOR_TEST
stock = create_stock_with_event_offer(
offerer=offerer,
venue=venue,
beginning_datetime=expired_date_and_automaticaly_refunded)
# When
is_event_deletable = stock.isEventDeletable
# Then
assert is_event_deletable is False
def when_user_is_logged_in_and_booking_does_not_exist(self, app):
# Given
user = create_user()
pro_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(booking, user_offerer)
# When
url = "/v2/bookings/use/token/{}".format("123456")
response = TestClient(app.test_client()).with_auth("*****@*****.**").patch(url)
# Then
assert response.status_code == 404
assert response.json["global"] == ["Cette contremarque n'a pas été trouvée"]
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=user, stock=stock, venue=venue)
repository.save(booking)
url = "/bookings/token/{}?email={}&offer_id={}".format(
booking.token, "*****@*****.**", humanize(stock.offer.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 test_should_send_cancellation_by_offerer_email_only_to_administration_when_no_booking_email_provided(
self, make_offerer_driven_cancellation_email_for_offerer):
# Given
user = create_user(email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue)
stock.offer.bookingEmail = None
booking = create_booking(user=user, stock=stock)
# When
send_offerer_driven_cancellation_email_to_offerer(booking)
# Then
make_offerer_driven_cancellation_email_for_offerer.assert_called_once_with(
booking)
assert mails_testing.outbox[0].sent_data[
"To"] == "*****@*****.**"
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=user, stock=stock, venue=venue)
repository.save(booking)
url = "/bookings/token/{}?&offer_id={}".format(booking.token, humanize(stock.offer.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_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=user, stock=stock, venue=venue)
repository.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_user_is_not_attached_to_linked_offerer(self, app):
# Given
user = create_user()
pro_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=user, stock=stock, venue=venue)
repository.save(booking, pro_user)
booking_id = booking.id
url = f"/v2/bookings/use/token/{booking.token}"
# When
response = TestClient(app.test_client()).with_auth("*****@*****.**").patch(url)
# Then
assert response.status_code == 403
assert response.json["user"] == ["Vous n'avez pas les droits suffisants pour valider cette contremarque."]
assert Booking.query.get(booking_id).isUsed is False
def when_api_key_is_provided_and_booking_has_been_cancelled_already(self, app):
# Given
user = create_user()
pro_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0)
booking = create_booking(user=user, stock=stock, venue=venue, is_cancelled=True)
repository.save(booking, user_offerer)
url = f"/v2/bookings/use/token/{booking.token}"
# When
response = TestClient(app.test_client()).with_auth(pro_user.email).patch(url)
# Then
assert response.status_code == 403
assert response.json["booking"] == ["Cette réservation a été annulée"]
assert Booking.query.get(booking.id).isUsed is False
def when_user_is_logged_in_and_booking_token_is_null(self, app):
# Given
user = create_user()
pro_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(booking, user_offerer)
# When
url = "/v2/bookings/keep/token/"
response = TestClient(app.test_client()).with_auth("*****@*****.**").patch(url)
# Then
assert response.status_code == 404
def when_api_key_is_provided_and_booking_has_been_refunded(self, app):
# Given
user = create_user()
pro_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0)
booking = create_booking(user=user, stock=stock, venue=venue, is_used=True)
payment = create_payment(booking=booking, offerer=offerer)
repository.save(payment, user_offerer)
# When
url = f"/v2/bookings/use/token/{booking.token}"
response = TestClient(app.test_client()).with_auth(pro_user.email).patch(url)
# Then
assert response.status_code == 403
assert response.json["payment"] == ["Cette réservation a été remboursée"]
def when_user_is_logged_in_and_booking_has_not_been_validated_already(self, app):
# Given
user = create_user()
pro_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(booking, user_offerer)
# When
url = "/v2/bookings/keep/token/{}".format(booking.token)
response = TestClient(app.test_client()).with_auth("*****@*****.**").patch(url)
# Then
assert response.status_code == 410
assert response.json["booking"] == ["Cette réservation n'a pas encore été validée"]
assert Booking.query.get(booking.id).isUsed is False
def test_should_send_cancellation_by_offerer_email_to_offerer(
self, make_offerer_driven_cancellation_email_for_offerer):
# Given
user = users_factories.BeneficiaryGrant18Factory.build(
email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer)
venue.bookingEmail = "*****@*****.**"
stock = create_stock_with_event_offer(offerer, venue)
stock.offer.bookingEmail = "*****@*****.**"
booking = create_booking(user=user, stock=stock)
# When
send_offerer_driven_cancellation_email_to_offerer(booking)
# Then
make_offerer_driven_cancellation_email_for_offerer.assert_called_once_with(
booking)
assert len(mails_testing.outbox) == 1 # test number of emails sent
assert mails_testing.outbox[0].sent_data["To"] == "*****@*****.**"
def when_api_key_is_provided_and_booking_has_been_validated_already(self, app):
# Given
user = create_user()
pro_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
booking.isUsed = True
repository.save(booking, user_offerer)
booking_id = booking.id
# When
url = "/v2/bookings/use/token/{}".format(booking.token)
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 is True
def test_should_send_cancellation_by_offerer_email_only_to_administration_when_no_booking_email_provided(
self, feature_send_mail_to_users_enabled,
make_offerer_driven_cancellation_email_for_offerer):
# Given
user = create_user(email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue)
stock.offer.bookingEmail = None
booking = create_booking(user=user, stock=stock)
mocked_send_email = Mock()
# When
send_offerer_driven_cancellation_email_to_offerer(
booking, mocked_send_email)
# Then
make_offerer_driven_cancellation_email_for_offerer.assert_called_once_with(
booking)
mocked_send_email.assert_called_once()
args = mocked_send_email.call_args_list
assert args[0][1]["data"]["To"] == "*****@*****.**"
def when_user_is_logged_in_and_booking_payment_exists(self, app):
# Given
user = create_user()
pro_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue, price=0)
booking = create_booking(user=user, stock=stock, venue=venue, is_used=True)
payment = create_payment(booking, offerer, Decimal(10), iban="CF13QSDFGH456789", bic="QSDFGH8Z555")
repository.save(booking, user_offerer, payment)
# When
url = "/v2/bookings/keep/token/{}".format(booking.token)
response = TestClient(app.test_client()).with_auth("*****@*****.**").patch(url)
# Then
assert response.status_code == 410
assert response.json["payment"] == ["Le remboursement est en cours de traitement"]
assert Booking.query.get(booking.id).isUsed is True
def test_should_send_booking_cancellation_email_only_to_administration_when_no_booking_email_provided(
self, mock_feature_send_mail_to_users_enabled, app):
# Given
user = create_user(email="*****@*****.**")
offerer = create_offerer()
deposit = create_deposit(user, amount=500)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(offerer, venue)
stock.offer.bookingEmail = None
booking = create_booking(user=user, stock=stock)
mocked_send_email = Mock()
repository.save(deposit, stock)
# When
send_user_driven_cancellation_email_to_offerer(booking,
mocked_send_email)
# Then
mocked_send_email.assert_called_once()
args = mocked_send_email.call_args_list
assert args[0][1]["data"]["To"] == "*****@*****.**"
