def when_trying_to_patch_forbidden_attributes(self, app):
# Given
offer = offers_factories.OfferFactory()
offers_factories.UserOffererFactory(
user__email="*****@*****.**",
offerer=offer.venue.managingOfferer,
)
# When
data = {
"dateCreated": serialize(datetime(2019, 1, 1)),
"dateModifiedAtLastProvider": serialize(datetime(2019, 1, 1)),
"id": 1,
"idAtProviders": 1,
"lastProviderId": 1,
"owningOffererId": "AA",
"thumbCount": 2,
}
client = TestClient(app.test_client()).with_auth("*****@*****.**")
response = client.patch(f"offers/{humanize(offer.id)}", json=data)
# Then
assert response.status_code == 400
assert response.json["owningOffererId"] == ["Vous ne pouvez pas changer cette information"]
forbidden_keys = {
"dateCreated",
"dateModifiedAtLastProvider",
"id",
"idAtProviders",
"lastProviderId",
"owningOffererId",
"thumbCount",
}
for key in forbidden_keys:
assert key in response.json
def when_booking_limit_datetime_after_beginning_datetime(
self, app, db_session):
# Given
user = users_factories.UserFactory(isAdmin=True)
offer = offers_factories.EventOfferFactory()
beginningDatetime = datetime(2019, 2, 14)
data = {
"price":
1222,
"offerId":
humanize(offer.id),
"beginningDatetime":
serialize(beginningDatetime),
"bookingLimitDatetime":
serialize(beginningDatetime + timedelta(days=2)),
}
# When
response = TestClient(app.test_client()).with_auth(user.email).post(
"/stocks", json=data)
# 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 _create_response_to_get_booking_by_token(booking: Booking) -> Dict:
offer_name = booking.stock.offer.product.name
date = None
offer = booking.stock.offer
is_event = ProductType.is_event(offer.type)
if is_event:
date = serialize(booking.stock.beginningDatetime)
venue_departement_code = offer.venue.departementCode
response = {
"bookingId": humanize(booking.id),
"date": date,
"email": booking.user.email,
"isUsed": booking.isUsed,
"offerName": offer_name,
"userName": booking.user.publicName,
"venueDepartementCode": venue_departement_code,
}
if offer.type == str(EventType.ACTIVATION):
response.update({
"phoneNumber": booking.user.phoneNumber,
"dateOfBirth": serialize(booking.user.dateOfBirth)
})
return response
def when_setting_beginning_datetime_on_offer_with_thing(
self, app, db_session):
# Given
user = users_factories.UserFactory(isAdmin=True)
offer = offers_factories.ThingOfferFactory()
beginningDatetime = datetime(2019, 2, 14)
data = {
"price":
0,
"offerId":
humanize(offer.id),
"beginningDatetime":
serialize(beginningDatetime),
"bookingLimitDatetime":
serialize(beginningDatetime - timedelta(days=2)),
}
# When
response = TestClient(app.test_client()).with_auth(user.email).post(
"/stocks", json=data)
# Then
assert response.status_code == 400
assert response.json == {
"global": [
"Impossible de mettre une date de début si l'offre ne porte pas sur un événement"
]
}
def _serialize_beneficiary_booking(
beneficiary_booking: BeneficiaryBooking, serialized_stocks: list[dict], with_qr_code: bool = False
) -> dict:
dictified_booking = {
"completedUrl": beneficiary_booking.booking_access_url,
"isEventExpired": beneficiary_booking.is_event_expired,
"amount": beneficiary_booking.amount,
"cancellationDate": serialize(beneficiary_booking.cancellationDate),
"dateCreated": serialize(beneficiary_booking.dateCreated),
"dateUsed": serialize(beneficiary_booking.dateUsed),
"id": humanize(beneficiary_booking.id),
"isCancelled": beneficiary_booking.isCancelled,
"isUsed": beneficiary_booking.isUsed,
"quantity": beneficiary_booking.quantity,
"displayAsEnded": beneficiary_booking.displayAsEnded,
"activationCode": beneficiary_booking.activationCode,
"stock": {
"id": humanize(beneficiary_booking.stockId),
"beginningDatetime": serialize(beneficiary_booking.beginningDatetime),
"offerId": humanize(beneficiary_booking.offerId),
"price": beneficiary_booking.price,
"isEventExpired": beneficiary_booking.is_event_expired,
"offer": {
"description": beneficiary_booking.description,
"durationMinutes": beneficiary_booking.durationMinutes,
"extraData": beneficiary_booking.extraData,
"isDuo": beneficiary_booking.isDuo,
"withdrawalDetails": beneficiary_booking.withdrawalDetails,
"id": humanize(beneficiary_booking.offerId),
"isDigital": beneficiary_booking.is_booked_offer_digital,
"isEvent": beneficiary_booking.is_booked_offer_event,
"isNational": beneficiary_booking.isNational,
"name": beneficiary_booking.name,
"thumbUrl": beneficiary_booking.thumb_url,
"stocks": serialized_stocks,
"isBookable": _serialize_offer_is_bookable(serialized_stocks),
"venue": {
"id": humanize(beneficiary_booking.venueId),
"departementCode": beneficiary_booking.departementCode,
"name": beneficiary_booking.venueName,
"address": beneficiary_booking.address,
"postalCode": beneficiary_booking.postalCode,
"city": beneficiary_booking.city,
"latitude": beneficiary_booking.latitude,
"longitude": beneficiary_booking.longitude,
},
"venueId": humanize(beneficiary_booking.venueId),
},
},
"stockId": humanize(beneficiary_booking.stockId),
"token": beneficiary_booking.token,
"userId": humanize(beneficiary_booking.userId),
}
if with_qr_code:
dictified_booking["qrCode"] = beneficiary_booking.qr_code
return dictified_booking
def _serialize_stock_for_beneficiary_booking(stock: Stock) -> dict:
return {
"dateCreated": serialize(stock.date_created),
"beginningDatetime": serialize(stock.beginning_datetime),
"bookingLimitDatetime": serialize(stock.booking_limit_datetime),
"dateModified": serialize(stock.date_modified),
"offerId": humanize(stock.offer_id),
"quantity": stock.quantity,
"price": stock.price,
"id": humanize(stock.id),
"isBookable": stock.is_available_for_booking,
"remainingQuantity": "unlimited",
}
def serialize_booking(booking: Booking) -> Dict:
booking_id = humanize(booking.id)
user_email = booking.user.email
is_used = booking.isUsed
offer_name = booking.stock.offer.product.name
user_name = booking.user.publicName
venue_departement_code = booking.stock.offer.venue.departementCode
offer_id = booking.stock.offer.id
venue_name = booking.stock.offer.venue.name
venue_address = booking.stock.offer.venue.address
offer_type = "EVENEMENT" if booking.stock.offer.isEvent else "BIEN"
offer_formula = ""
if booking.stock.offer.type == str(EventType.CINEMA):
offer_formula = "PLACE"
elif booking.stock.offer.type == str(ThingType.CINEMA_ABO):
offer_formula = "ABO"
offer_date_time = serialize(booking.stock.beginningDatetime
) if booking.stock.beginningDatetime else ""
price = booking.stock.price
quantity = booking.quantity
offer_extra_data = booking.stock.offer.extraData
product_isbn = ""
if offer_extra_data and "isbn" in offer_extra_data:
product_isbn = offer_extra_data["isbn"]
date_of_birth = ""
phone_number = ""
if booking.stock.offer.product.type == str(EventType.ACTIVATION):
date_of_birth = serialize(booking.user.dateOfBirth)
phone_number = booking.user.phoneNumber
return {
"bookingId": booking_id,
"dateOfBirth": date_of_birth,
"datetime": offer_date_time,
"ean13": product_isbn,
"email": user_email,
"formula": offer_formula,
"isUsed": is_used,
"offerId": offer_id,
"publicOfferId": humanize(offer_id),
"offerName": offer_name,
"offerType": offer_type,
"phoneNumber": phone_number,
"price": price,
"quantity": quantity,
"userName": user_name,
"venueAddress": venue_address,
"venueDepartementCode": venue_departement_code,
"venueName": venue_name,
}
def test_upsert_multiple_stocks(self, app):
# Given
offer = offers_factories.ThingOfferFactory()
existing_stock = offers_factories.StockFactory(offer=offer, price=10)
offers_factories.UserOffererFactory(
user__email="*****@*****.**",
offerer=offer.venue.managingOfferer,
)
booking_limit_datetime = datetime(2019, 2, 14)
# When
stock_data = {
"offerId":
humanize(offer.id),
"stocks": [
{
"id": humanize(existing_stock.id),
"price": 20,
"quantity": None,
"bookingLimitDatetime": serialize(booking_limit_datetime),
},
{
"price": 30,
"quantity": None,
"bookingLimitDatetime": serialize(booking_limit_datetime),
},
{
"price": 40,
"quantity": None,
"bookingLimitDatetime": serialize(booking_limit_datetime),
},
],
}
response = TestClient(
app.test_client()).with_auth("*****@*****.**").post(
"/stocks/bulk/", json=stock_data)
# Then
assert response.status_code == 201
response_dict = response.json
assert len(response_dict["stockIds"]) == len(stock_data["stocks"])
for idx, result_stock_id in enumerate(response_dict["stockIds"]):
expected_stock = stock_data["stocks"][idx]
result_stock = Stock.query.get(dehumanize(result_stock_id["id"]))
assert result_stock.price == expected_stock["price"]
assert result_stock.quantity == expected_stock["quantity"]
assert result_stock.bookingLimitDatetime == booking_limit_datetime
def test_on_enum_returns_dict_with_enum_value(self):
# Given
enum = ThingType.JEUX
# When
serialized_enum = serialize(enum)
# Then
assert serialized_enum == {
"conditionalFields": [],
"proLabel":
"Jeux (support physique)",
"appLabel":
"Support physique",
"offlineOnly":
True,
"onlineOnly":
False,
"sublabel":
"Jouer",
"description":
"Résoudre l’énigme d’un jeu de piste dans votre ville ? "
"Jouer en ligne entre amis ? "
"Découvrir cet univers étrange avec une manette ?",
"isActive":
False,
"canExpire":
True,
}
def when_missing_offer_id(self, app):
# Given
offer = offers_factories.ThingOfferFactory()
offers_factories.UserOffererFactory(
user__email="*****@*****.**",
offerer=offer.venue.managingOfferer,
)
booking_limit_datetime = datetime(2019, 2, 14)
# When
stock_data = {
"stocks": [
{
"quantity": -2,
"price": 0,
"bookingLimitDatetime": serialize(booking_limit_datetime),
},
],
}
response = TestClient(
app.test_client()).with_auth("*****@*****.**").post(
"/stocks/bulk/", json=stock_data)
# Then
assert response.status_code == 400
assert response.json == {"offerId": ["Ce champ est obligatoire"]}
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 when_user_has_no_rights_and_creating_stock_from_offer_id(
self, app, db_session):
# Given
user = users_factories.UserFactory(email="*****@*****.**")
offer = offers_factories.ThingOfferFactory()
offers_factories.UserOffererFactory(
user__email="*****@*****.**",
offerer=offer.venue.managingOfferer)
booking_datetime = datetime.utcnow()
# When
stock_data = {
"offerId":
humanize(offer.id),
"stocks": [
{
"quantity": 10,
"price": 0,
"bookingLimitDatetime": serialize(booking_datetime),
},
],
}
response = TestClient(app.test_client()).with_auth(user.email).post(
"/stocks/bulk/", json=stock_data)
# 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."
]
}
def test_on_datetime_list_returns_string_with_date_in_ISO_8601_list(self):
# Given
offer = Offer()
offer.stocks = [create_stock(beginning_datetime=now, offer=offer)]
# When
serialized_list = serialize(offer.dateRange)
# Then
for dt in serialized_list: # pylint: disable=not-an-iterable
self._assert_is_in_ISO_8601_format(dt)
def test_on_enum_returns_dict_with_enum_value(self):
# Given
class EnumTest(Enum):
TEST = {"toto": "tata", "is_toto": False, "toto_list": ["toto", "tata"]}
enum = EnumTest.TEST
# When
serialized_enum = serialize(enum)
# Then
assert serialized_enum == {"toto": "tata", "is_toto": False, "toto_list": ["toto", "tata"]}
def when_invalid_quantity_or_price_for_edition_and_creation(self, app):
# Given
offer = offers_factories.ThingOfferFactory()
existing_stock = offers_factories.StockFactory(offer=offer, price=10)
offers_factories.UserOffererFactory(
user__email="*****@*****.**",
offerer=offer.venue.managingOfferer,
)
booking_limit_datetime = datetime(2019, 2, 14)
# When
stock_data = {
"offerId":
humanize(offer.id),
"stocks": [
{
"id": humanize(existing_stock.id),
"price": -3,
"bookingLimitDatetime": serialize(booking_limit_datetime),
},
{
"quantity": -2,
"price": 0,
"bookingLimitDatetime": serialize(booking_limit_datetime),
},
],
}
response = TestClient(
app.test_client()).with_auth("*****@*****.**").post(
"/stocks/bulk/", json=stock_data)
# Then
assert response.status_code == 400
assert response.json == {"price": ["Le prix doit être positif"]}
persisted_stock = Stock.query.filter_by(offerId=offer.id)
assert persisted_stock.count() == 1
assert persisted_stock[0].price == 10
def _create_response_to_get_booking_by_token(booking: Booking) -> dict:
offer_name = booking.stock.offer.product.name
date = None
offer = booking.stock.offer
is_event = offer.isEvent
if is_event:
date = serialize(booking.stock.beginningDatetime)
venue_departement_code = offer.venue.departementCode
response = {
"bookingId": humanize(booking.id),
"date": date,
"email": booking.email,
"isUsed": booking.isUsed,
"offerName": offer_name,
"userName": booking.publicName,
"venueDepartementCode": venue_departement_code,
}
return response
def when_booking_limit_datetime_is_none_for_event(self, app, db_session):
# Given
user = users_factories.UserFactory(isAdmin=True)
offer = offers_factories.EventOfferFactory()
beginningDatetime = datetime(2019, 2, 14)
data = {
"price": 0,
"offerId": humanize(offer.id),
"bookingLimitDatetime": None,
"beginningDatetime": serialize(beginningDatetime),
}
# When
response = TestClient(app.test_client()).with_auth(user.email).post(
"/stocks", json=data)
# Then
assert response.status_code == 400
assert response.json == {
"bookingLimitDatetime": ["Ce paramètre est obligatoire"]
}
from pcapi.core.users.models import User
from pcapi.models.feature import override_features
from pcapi.routes.serialization import serialize
from tests.conftest import TestClient
BASE_DATA = {
"email": "*****@*****.**",
"firstName": "Toto",
"lastName": "Martin",
"postalCode": "93100",
"publicName": "Toto",
"password": "******",
"contact_ok": "true",
"phoneNumber": "0612345678",
"dateOfBirth": serialize(datetime(2001, 1, 1)),
}
class Post:
class Returns201:
@freeze_time("2019-01-01 01:00:00")
@patch(
"pcapi.routes.webapp.signup.get_authorized_emails_and_dept_codes")
@pytest.mark.usefixtures("db_session")
def when_data_is_accurate(self, get_authorized_emails_and_dept_codes,
app):
# Given
data = BASE_DATA.copy()
expected_response_json = {
"isBeneficiary": False,
