def when_booking_is_not_provided_at_all(self, app):
# Given
user = create_user(email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(booking)
offererApiKey = create_api_key(offerer_id=offerer.id)
repository.save(offererApiKey)
# When
url = "/v2/bookings/keep/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 == 404
def when_user_has_rights_and_regular_offer_and_token_in_lower_case(
self, app):
# Given
user = create_user(email="*****@*****.**",
public_name="John Doe")
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(admin_user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(
venue, event_name="Event Name", event_type=EventType.CINEMA)
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence,
price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(user_offerer, booking)
booking_token = booking.token.lower()
url = f"/v2/bookings/token/{booking_token}"
# When
response = TestClient(
app.test_client()).with_auth("*****@*****.**").get(url)
# Then
assert response.status_code == 200
def when_user_has_api_key_but_token_not_found(self, app):
# Given
user = create_user(email="*****@*****.**")
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(admin_user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(admin_user, booking, user_offerer)
offererApiKey = create_api_key(offerer_id=offerer.id)
repository.save(offererApiKey)
user2ApiKey = f"Bearer {offererApiKey.value}"
url = "/v2/bookings/token/12345"
# When
response = TestClient(app.test_client()).get(
url, headers={"Authorization": user2ApiKey, "Origin": "http://localhost"}
)
# Then
assert response.status_code == 404
assert response.json["global"] == ["Cette contremarque n'a pas été trouvée"]
def when_the_api_key_is_not_linked_to_the_right_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)
offer = create_offer_with_event_product(venue, event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(pro_user, booking, user_offerer, offerer2)
offererApiKey = create_api_key(offerer_id=offerer2.id)
repository.save(offererApiKey)
# When
user2_api_key = "Bearer " + offererApiKey.value
url = "/v2/bookings/keep/token/{}".format(booking.token)
response = TestClient(app.test_client()).patch(
url, headers={"Authorization": user2_api_key, "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 test_should_return_date_of_birth_and_phone_number_when_offer_is_an_activation(
self):
# Given
user = create_user(
date_of_birth=datetime(2001, 1, 1),
email="*****@*****.**",
phone_number="0612345678",
public_name="John Doe",
)
offerer = create_offerer()
venue = create_venue(offerer,
name="Venue name",
address="Venue address")
offer = create_offer_with_event_product(
venue=venue,
event_name="Event Name",
event_type=EventType.ACTIVATION)
event_occurrence = create_event_occurrence(
offer, beginning_datetime=datetime.utcnow())
stock = create_stock_from_event_occurrence(event_occurrence, price=12)
booking = create_booking(user=user,
quantity=3,
stock=stock,
venue=venue)
# When
response = serialize_booking(booking)
# Then
assert response["dateOfBirth"] == "2001-01-01T00:00:00Z"
assert response["phoneNumber"] == "0612345678"
def when_api_key_is_provided_and_rights_and_regular_offer(self, app):
# Given
user = create_user(email="*****@*****.**", public_name="John Doe")
user2 = create_user(email="*****@*****.**", public_name="Jane Doe")
offerer = create_offerer()
user_offerer = create_user_offerer(user2, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_name="Event Name", event_type=EventType.CINEMA)
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(user_offerer, booking)
offererApiKey = create_api_key(offerer_id=offerer.id)
repository.save(offererApiKey)
user2ApiKey = f"Bearer {offererApiKey.value}"
booking_token = booking.token.lower()
url = f"/v2/bookings/token/{booking_token}"
# When
response = TestClient(app.test_client()).get(
url, headers={"Authorization": user2ApiKey, "Origin": "http://localhost"}
)
# Then
assert response.status_code == 200
def when_user_has_rights_and_email_with_special_characters_not_url_encoded(
self, app):
# Given
user = create_user(email="*****@*****.**")
user_admin = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(user_admin,
offerer,
is_admin=True)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue,
event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence,
price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(user_offerer, booking)
url = f"/bookings/token/{booking.token}?email={user.email}"
# When
response = TestClient(
app.test_client()).with_auth("*****@*****.**").get(url)
# Then
assert response.status_code == 404
def test_should_humanize_ids(self):
# Given
user = create_user(email="*****@*****.**", public_name="John Doe")
offerer = create_offerer()
venue = create_venue(offerer,
name="Venue name",
address="Venue address")
offer = create_offer_with_event_product(venue=venue,
event_name="Event Name",
event_type=EventType.CINEMA,
idx=999)
event_occurrence = create_event_occurrence(
offer, beginning_datetime=datetime.utcnow())
stock = create_stock_from_event_occurrence(event_occurrence, price=12)
booking = create_booking(user=user,
quantity=3,
stock=stock,
venue=venue)
# When
response = serialize_booking(booking)
# Then
assert response["bookingId"] == humanize(booking.id)
assert response["offerId"] == offer.id
assert response["publicOfferId"] == humanize(offer.id)
def when_user_has_rights_and_regular_offer_and_token_in_lower_case(
self, app):
# Given
user = create_user(email="*****@*****.**",
public_name="John Doe")
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(admin_user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(
venue, event_name="Event Name", event_type=EventType.CINEMA)
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence,
price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(user_offerer, booking)
booking_token = booking.token.lower()
url = f"/bookings/token/{booking_token}"
# When
response = TestClient(
app.test_client()).with_auth("*****@*****.**").get(url)
# Then
assert response.status_code == 200
response_json = response.json
assert response_json == {
"bookingId": humanize(booking.id),
"date": serialize(booking.stock.beginningDatetime),
"email": "*****@*****.**",
"isUsed": False,
"offerName": "Event Name",
"userName": "******",
"venueDepartementCode": "93",
}
def _create_event_stock_and_offer_for_date(venue, date):
product = create_product_with_event_type()
offer = create_offer_with_event_product(venue=venue, product=product)
event_occurrence = create_event_occurrence(offer, beginning_datetime=date)
stock = create_stock_from_event_occurrence(event_occurrence,
booking_limit_date=date)
return stock
def create_industrial_event_stocks(event_occurrences_by_name):
logger.info("create_industrial_event_stocks")
event_stocks_by_name = {}
short_names_to_increase_price = []
event_occurrence_items = list(event_occurrences_by_name.items())
event_occurrence_items_with_stocks = remove_every(
event_occurrence_items, EVENT_OCCURRENCES_WITH_STOCKS_REMOVE_MODULO
)
for event_occurrence_item_with_stocks in event_occurrence_items_with_stocks:
(event_occurrence_with_stocks_name, event_occurrence_with_stocks) = event_occurrence_item_with_stocks
available = 10
short_name = get_occurrence_short_name(event_occurrence_with_stocks_name)
price = get_price_by_short_name(short_name)
price_counter = short_names_to_increase_price.count(short_name)
if price_counter > 2:
price = price + price_counter
short_names_to_increase_price.append(short_name)
if event_occurrence_with_stocks["offer"].product.offerType["value"] == str(EventType.ACTIVATION):
price = 0
name = event_occurrence_with_stocks_name + " / " + str(available) + " / " + str(price)
event_stocks_by_name[name] = create_stock_from_event_occurrence(
event_occurrence_with_stocks, price=price, quantity=available
)
repository.save(*event_stocks_by_name.values())
logger.info("created %d event_stocks", len(event_stocks_by_name))
def when_booking_user_email_with_special_character_not_url_encoded(
self, app):
# Given
user = create_user(email="*****@*****.**")
user_admin = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(user_admin, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_name="Event Name")
event_occurrence = create_event_occurrence(offer,
beginning_datetime=tomorrow)
stock = create_stock_from_event_occurrence(
event_occurrence,
price=0,
booking_limit_date=tomorrow_minus_one_hour)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(user_offerer, booking)
url = "/bookings/token/{}?email={}".format(booking.token, user.email)
# When
response = TestClient(
app.test_client()).with_auth("*****@*****.**").patch(url)
# Then
assert response.status_code == 404
def when_given_api_key_not_related_to_booking_offerer(self, app):
# Given
user = create_user(email="*****@*****.**")
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
offerer2 = create_offerer(siren="987654321")
user_offerer = create_user_offerer(admin_user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(admin_user, booking, user_offerer, offerer2)
offerer2ApiKey = create_api_key(offerer_id=offerer2.id)
repository.save(offerer2ApiKey)
user2ApiKey = f"Bearer {offerer2ApiKey.value}"
url = f"/v2/bookings/token/{booking.token}"
# When
response = TestClient(app.test_client()).get(
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 save_paid_reimbursable_event_offer(venue: VenueSQLEntity):
paid_reimbursable_event_offer = create_offer_with_event_product(
venue, event_name="Paid event", event_type=EventType.SPECTACLE_VIVANT)
past_occurrence = create_event_occurrence(paid_reimbursable_event_offer,
beginning_datetime=now -
three_days)
future_occurrence = create_event_occurrence(paid_reimbursable_event_offer,
beginning_datetime=now +
three_days)
past_event_stock = create_stock_from_event_occurrence(past_occurrence,
price=10)
future_event_stock = create_stock_from_event_occurrence(future_occurrence,
price=10)
repository.save(past_event_stock, future_event_stock)
logger.info(
"created 1 event offer with 1 past and 1 future occurrence with 1 paid stock of 10 € each"
)
return past_event_stock, future_event_stock
def save_free_event_offer_with_stocks(venue: VenueSQLEntity):
free_event_offer = create_offer_with_event_product(
venue, event_name="Free event", event_type=EventType.SPECTACLE_VIVANT)
past_occurrence = create_event_occurrence(free_event_offer,
beginning_datetime=now -
three_days)
future_occurrence = create_event_occurrence(free_event_offer,
beginning_datetime=now +
three_days)
past_free_event_stock = create_stock_from_event_occurrence(past_occurrence,
price=0)
future_free_event_stock = create_stock_from_event_occurrence(
future_occurrence, price=0)
repository.save(past_free_event_stock, future_free_event_stock)
logger.info(
"created 1 event offer with 1 past and 1 future occurrence with 1 free stock each"
)
return past_free_event_stock, future_free_event_stock
def when_user_has_rights_and_regular_offer(self, app):
# Given
user = create_user(email="*****@*****.**",
public_name="John Doe")
create_deposit(user)
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
create_user_offerer(admin_user, offerer)
venue = create_venue(offerer,
name="Venue name",
address="Venue address")
offer = create_offer_with_event_product(
venue=venue,
event_name="Event Name",
event_type=EventType.CINEMA)
four_days_from_now = datetime.utcnow() + timedelta(days=4)
event_occurrence = create_event_occurrence(
offer, beginning_datetime=four_days_from_now)
stock = create_stock_from_event_occurrence(event_occurrence,
price=12)
unconfirmed_booking = create_booking(
user=user,
quantity=3,
stock=stock,
venue=venue,
date_created=datetime.utcnow() - timedelta(hours=48))
repository.save(unconfirmed_booking)
url = f"/v2/bookings/token/{unconfirmed_booking.token}"
# When
response = TestClient(
app.test_client()).with_auth("*****@*****.**").get(url)
# Then
assert response.headers["Content-type"] == "application/json"
assert response.status_code == 200
assert response.json == {
"bookingId": humanize(unconfirmed_booking.id),
"dateOfBirth": "",
"datetime": format_into_utc_date(stock.beginningDatetime),
"ean13": "",
"email": "*****@*****.**",
"formula": "PLACE",
"isUsed": False,
"offerId": offer.id,
"offerName": "Event Name",
"offerType": "EVENEMENT",
"phoneNumber": "",
"price": 12.0,
"publicOfferId": humanize(offer.id),
"quantity": 3,
"userName": "******",
"venueAddress": "Venue address",
"venueDepartementCode": "93",
"venueName": "Venue name",
}
def test_make_offerer_driven_cancellation_email_for_offerer_event_when_no_other_booking(
self, app):
# Given
beginning_datetime = datetime(2019,
7,
20,
12,
0,
0,
tzinfo=timezone.utc)
booking_limit_datetime = beginning_datetime - timedelta(hours=1)
user = create_user(email="*****@*****.**", public_name="John Doe")
offerer = create_offerer(name="Test offerer")
venue = create_venue(offerer,
name="Le petit théâtre",
address="1 rue de la Libération",
city="Montreuil",
postal_code="93100")
offer = create_offer_with_event_product(
venue, event_name="Le théâtre des ombres")
event_occurrence = create_event_occurrence(
offer, beginning_datetime=beginning_datetime)
stock = create_stock_from_event_occurrence(
event_occurrence,
price=20,
quantity=10,
booking_limit_date=booking_limit_datetime)
booking = create_booking(user=user, stock=stock)
# When
with patch("pcapi.utils.mailing.find_ongoing_bookings_by_stock",
return_value=[]):
email = make_offerer_driven_cancellation_email_for_offerer(booking)
# Then
email_html = BeautifulSoup(email["Html-part"], "html.parser")
html_action = str(email_html.find("p", {"id": "action"}))
html_recap = str(email_html.find("p", {"id": "recap"}))
html_no_recal = str(email_html.find("p", {"id": "no-recap"}))
assert "Vous venez d'annuler" in html_action
assert "John Doe" in html_action
assert "*****@*****.**" in html_action
assert "pour Le théâtre des ombres" in html_recap
assert "proposé par Le petit théâtre" in html_recap
assert "le 20 juillet 2019 à 14:00" in html_recap
assert "1 rue de la Libération" in html_recap
assert "Montreuil" in html_recap
assert "93100" in html_recap
assert "Aucune réservation" in html_no_recal
assert (
email["Subject"] ==
"Confirmation de votre annulation de réservation pour Le théâtre des ombres, proposé par Le petit théâtre"
)
def save_free_event_offer_with_stocks(venue: Venue):
free_event_offer = create_offer_with_event_product(
venue,
event_name="Free event",
event_subcategory_id=subcategories.SPECTACLE_REPRESENTATION.id,
)
past_occurrence = create_event_occurrence(free_event_offer,
beginning_datetime=now -
three_days)
future_occurrence = create_event_occurrence(free_event_offer,
beginning_datetime=now +
three_days)
past_free_event_stock = create_stock_from_event_occurrence(past_occurrence,
price=0)
future_free_event_stock = create_stock_from_event_occurrence(
future_occurrence, price=0)
repository.save(past_free_event_stock, future_free_event_stock)
logger.info(
"created 1 event offer with 1 past and 1 future occurrence with 1 free stock each"
)
return past_free_event_stock, future_free_event_stock
def test_make_offerer_driven_cancellation_email_for_offerer_event_when_other_booking(
self, app):
# Given
user1 = create_user(email="*****@*****.**",
first_name="John",
last_name="Doe",
public_name="John Doe")
user2 = create_user(email="*****@*****.**",
first_name="Jane",
last_name="Smith",
public_name="Jane S.")
offerer = create_offerer(name="Test offerer")
venue = create_venue(offerer,
name="Le petit théâtre",
address="1 rue de la Libération",
city="Montreuil",
postal_code="93100")
offer = create_offer_with_event_product(
venue, event_name="Le théâtre des ombres")
event_occurrence = create_event_occurrence(offer,
beginning_datetime=datetime(
2019,
7,
20,
12,
0,
0,
tzinfo=timezone.utc))
stock = create_stock_from_event_occurrence(event_occurrence,
price=20,
quantity=10)
booking1 = create_booking(user=user1, stock=stock, token="98765")
booking2 = create_booking(user=user2, stock=stock, token="12345")
# When
with patch("pcapi.utils.mailing.find_ongoing_bookings_by_stock",
return_value=[booking2]):
email = make_offerer_driven_cancellation_email_for_offerer(
booking1)
# Then
email_html = BeautifulSoup(email["Html-part"], "html.parser")
html_recap_table = email_html.find("table", {"id": "recap-table"}).text
assert "Prénom" in html_recap_table
assert "Nom" in html_recap_table
assert "Email" in html_recap_table
assert "Jane" in html_recap_table
assert "Smith" in html_recap_table
assert "*****@*****.**" in html_recap_table
assert "12345" in html_recap_table
def test_should_send_mail_to_dev_when_feature_send_mail_to_users_is_disabled(
self, feature_send_mail_to_users_enabled):
# Given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence)
booking = create_booking(user=user, stock=stock)
# When
mailjet_data = retrieve_data_to_warn_beneficiary_after_pro_booking_cancellation(
booking)
# Then
assert mailjet_data["To"] == "*****@*****.**"
def when_booking_is_not_provided_at_all(self, app):
# Given
user = create_user(email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(booking)
url = "/v2/bookings/token/"
# When
response = TestClient(app.test_client()).get(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)
offer = create_offer_with_event_product(venue, event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(booking)
# When
url = "/v2/bookings/keep/token/{}".format(booking.token)
response = TestClient(app.test_client()).patch(url)
# Then
assert response.status_code == 401
def test_should_return_event_data_when_booking_is_on_an_event(self):
# Given
beginning_datetime = datetime(2019,
7,
20,
12,
0,
0,
tzinfo=timezone.utc)
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
event_occurrence = create_event_occurrence(
offer, beginning_datetime=beginning_datetime)
stock = create_stock_from_event_occurrence(event_occurrence, price=20)
booking = create_booking(user=user, stock=stock)
# When
mailjet_data = retrieve_data_to_warn_beneficiary_after_pro_booking_cancellation(
booking)
# Then
assert mailjet_data == {
"FromEmail": "*****@*****.**",
"MJ-TemplateID": 1116690,
"MJ-TemplateLanguage": True,
"To": "*****@*****.**",
"Vars": {
"event_date": "samedi 20 juillet 2019",
"event_hour": "14h",
"is_event": 1,
"is_free_offer": 0,
"is_online": 0,
"is_thing": 0,
"offer_name": booking.stock.offer.name,
"offer_price": "20",
"offerer_name": booking.stock.offer.venue.managingOfferer.name,
"user_first_name": user.firstName,
"venue_name": booking.stock.offer.venue.name,
},
}
def test_should_send_mail_to_offerer_and_pass_culture_administration_when_feature_send_mail_to_users_is_enabled(
self, feature_send_mail_to_users_enabled
):
# Given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence)
booking = create_booking(user=user, stock=stock)
bookings = [booking]
recipients = "[email protected], [email protected]"
# When
mailjet_data = retrieve_offerer_bookings_recap_email_data_after_offerer_cancellation(bookings, recipients)
# Then
assert mailjet_data["To"] == "[email protected], [email protected]"
def when_user_doesnt_have_rights_and_token_exists(self, app):
# Given
user = create_user(email="*****@*****.**")
querying_user = create_user(email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(querying_user, booking)
url = f"/v2/bookings/token/{booking.token}"
# When
response = TestClient(app.test_client()).with_auth("*****@*****.**").get(url)
# Then
assert response.status_code == 403
assert response.json["user"] == ["Vous n'avez pas les droits suffisants pour valider cette contremarque."]
def test_should_return_dict_when_offer_is_a_cinema(self):
# Given
user = create_user(email="*****@*****.**", public_name="John Doe")
offerer = create_offerer()
venue = create_venue(offerer,
name="Venue name",
address="Venue address")
offer = create_offer_with_event_product(venue=venue,
event_name="Event Name",
event_type=EventType.CINEMA)
event_occurrence = create_event_occurrence(
offer, beginning_datetime=datetime.utcnow())
stock = create_stock_from_event_occurrence(event_occurrence, price=12)
booking = create_booking(user=user,
quantity=3,
stock=stock,
venue=venue)
# When
response = serialize_booking(booking)
# Then
assert response == {
"bookingId": humanize(booking.id),
"dateOfBirth": "",
"datetime": "2019-11-26T18:29:20.891028Z",
"ean13": "",
"email": "*****@*****.**",
"formula": "PLACE",
"isUsed": False,
"offerId": offer.id,
"publicOfferId": humanize(offer.id),
"offerName": "Event Name",
"offerType": "EVENEMENT",
"phoneNumber": "",
"price": 12,
"quantity": 3,
"userName": "******",
"venueAddress": "Venue address",
"venueDepartementCode": "93",
"venueName": "Venue name",
}
def when_user_not_logged_in_and_gives_right_email(self, app):
# Given
user = create_user(email="*****@*****.**")
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue,
event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence,
price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(admin_user, booking)
url = f"/bookings/token/{booking.token}[email protected]"
# When
response = TestClient(app.test_client()).get(url)
# Then
assert response.status_code == 204
def when_user_not_logged_in_and_given_api_key_that_does_not_exists(self, app):
# Given
user = create_user(email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(booking)
# When
wrong_api_key = "Bearer WrongApiKey1234567"
url = "/v2/bookings/keep/token/{}".format(booking.token)
response = TestClient(app.test_client()).patch(
url, headers={"Authorization": wrong_api_key, "Origin": "http://localhost"}
)
# Then
assert response.status_code == 401
def test_should_return_empty_formula_when_offer_is_not_a_cinema(self):
# Given
user = create_user(email="*****@*****.**", public_name="John Doe")
offerer = create_offerer()
venue = create_venue(offerer,
name="Venue name",
address="Venue address")
offer = create_offer_with_event_product(venue=venue,
event_name="Event Name",
event_type=EventType.JEUX)
event_occurrence = create_event_occurrence(
offer, beginning_datetime=datetime.utcnow())
stock = create_stock_from_event_occurrence(event_occurrence, price=12)
booking = create_booking(user=user,
quantity=3,
stock=stock,
venue=venue)
# When
response = serialize_booking(booking)
# Then
assert response["formula"] == ""
def when_user_not_logged_in_and_doesnt_give_email(self, app):
# Given
user = create_user(email="*****@*****.**")
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue,
event_name="Event Name")
event_occurrence = create_event_occurrence(offer)
stock = create_stock_from_event_occurrence(event_occurrence,
price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(admin_user, booking)
url = f"/bookings/token/{booking.token}"
# When
response = TestClient(app.test_client()).get(url)
# Then
assert response.status_code == 400
error_message = response.json
assert error_message["email"] == [
"Vous devez préciser l'email de l'utilisateur quand vous n'êtes pas connecté(e)"
]
