def _setup_venues_for_users(self):
offerer = offers_factories.OffererFactory()
user_offerer = offers_factories.UserOffererFactory(offerer=offerer)
venue = offers_factories.VenueFactory(name="venue",
managingOfferer=offerer)
offerer_not_validated = offers_factories.OffererFactory(
validationToken="token")
offers_factories.UserOffererFactory(user=user_offerer.user,
offerer=offerer_not_validated)
venue_not_validated = offers_factories.VenueFactory(
name="venue_not_validated", managingOfferer=offerer_not_validated)
other_offerer = offers_factories.OffererFactory()
other_user_offerer = offers_factories.UserOffererFactory(
offerer=other_offerer)
other_venue = offers_factories.VenueFactory(
name="other_venue", managingOfferer=other_offerer)
other_offerer_not_validated = offers_factories.OffererFactory(
validationToken="other_token")
offers_factories.UserOffererFactory(
user=other_user_offerer.user, offerer=other_offerer_not_validated)
other_venue_not_validated = offers_factories.VenueFactory(
name="other_venue_not_validated",
managingOfferer=other_offerer_not_validated,
)
return {
"venue": venue,
"venue_not_validated": venue_not_validated,
"other_venue": other_venue,
"other_venue_not_validated": other_venue_not_validated,
}
def test_should_delete_user_offerers_in_csv(self):
# Given
user_offerer1 = offers_factories.UserOffererFactory()
user_offerer2 = offers_factories.UserOffererFactory()
user_offerer3 = offers_factories.UserOffererFactory()
csv_rows = [
[
"Lien structure sur le portail PRO",
"ID Structure",
"Email utilisateur",
"ID Utilisateur",
"Commentaire",
],
[
"unused", user_offerer1.offererId, "unused",
user_offerer1.userId, "unused", "unused", "unused", "unused"
],
[
"unused", user_offerer2.offererId, "unused",
user_offerer2.userId, "unused", "unused", "unused", "unused"
],
]
# When
_delete_user_offerers_from_rows(csv_rows)
# Then
user_offerer = UserOfferer.query.one()
assert user_offerer == user_offerer3
def when_mediation_is_created_with_thumb_file(self, app):
# given
offer = offers_factories.ThingOfferFactory()
offerer = offer.venue.managingOfferer
offers_factories.UserOffererFactory(
user__email="*****@*****.**",
offerer=offerer,
)
# when
client = TestClient(
app.test_client()).with_auth(email="*****@*****.**")
thumb = (IMAGES_DIR / "mouette_full_size.jpg").read_bytes()
files = {
"offerId": humanize(offer.id),
"offererId": humanize(offerer.id),
"thumb": (BytesIO(thumb), "image.png"),
}
response = client.post("/mediations", files=files)
# then
assert response.status_code == 201
mediation = Mediation.query.one()
assert mediation.thumbCount == 1
assert response.status_code == 201
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 when_mediation_is_created_with_thumb_url(self, app):
# given
offer = offers_factories.ThingOfferFactory()
offerer = offer.venue.managingOfferer
offers_factories.UserOffererFactory(
user__email="*****@*****.**",
offerer=offerer,
)
# when
client = TestClient(
app.test_client()).with_auth(email="*****@*****.**")
image_as_bytes = (IMAGES_DIR / "mouette_full_size.jpg").read_bytes()
data = {
"offerId": humanize(offer.id),
"offererId": humanize(offerer.id),
"thumbUrl": "https://example.com/image.jpg",
}
with requests_mock.Mocker() as mock:
mock.get(
"https://example.com/image.jpg",
content=image_as_bytes,
headers={"Content-Type": "image/jpeg"},
)
response = client.post("/mediations", form=data)
# then
assert response.status_code == 201
mediation = Mediation.query.one()
assert mediation.thumbCount == 1
assert response.json == {
"id": humanize(mediation.id),
}
def when_mediation_is_edited(self, app):
# given
mediation = offers_factories.MediationFactory()
offerer = mediation.offer.venue.managingOfferer
offers_factories.UserOffererFactory(
user__email="*****@*****.**",
offerer=offerer,
)
# when
client = TestClient(app.test_client()).with_auth(email="*****@*****.**")
data = {"isActive": False}
response = client.patch(f"/mediations/{humanize(mediation.id)}", json=data)
# then
mediation = Mediation.query.one()
assert not mediation.isActive
assert response.status_code == 200
assert response.json["id"] == humanize(mediation.id)
assert response.json["thumbUrl"] == mediation.thumbUrl
assert response.json == {
"authorId": None,
"credit": None,
"dateCreated": format_into_utc_date(mediation.dateCreated),
"dateModifiedAtLastProvider": format_into_utc_date(mediation.dateModifiedAtLastProvider),
"fieldsUpdated": [],
"id": humanize(mediation.id),
"idAtProviders": None,
"isActive": data["isActive"],
"lastProviderId": None,
"offerId": humanize(mediation.offer.id),
"thumbCount": 0,
"thumbUrl": None,
}
def test_patch_offer(self, app):
# Given
offer = offers_factories.OfferFactory()
offers_factories.UserOffererFactory(
user__email="*****@*****.**",
offerer=offer.venue.managingOfferer,
)
# When
client = TestClient(app.test_client()).with_auth("*****@*****.**")
data = {
"name": "New name",
"externalTicketOfficeUrl": "http://example.net",
"mentalDisabilityCompliant": True,
}
response = client.patch(f"/offers/{humanize(offer.id)}", json=data)
# Then
assert response.status_code == 200
assert response.json == {
"id": humanize(offer.id),
}
updated_offer = Offer.query.get(offer.id)
assert updated_offer.name == "New name"
assert updated_offer.externalTicketOfficeUrl == "http://example.net"
assert updated_offer.mentalDisabilityCompliant
def get_pro_validated_no_reset_password_token_user():
user_offerer = offers_factories.UserOffererFactory(
validationToken=None,
offerer__validationToken=None,
user__validationToken=None,
)
return {"user": get_pro_helper(user_offerer.user)}
def test_create_offer_from_existing_product(
self, mocked_offer_creation_notification_to_admin):
product = factories.ProductFactory(
name="An excellent offer",
type=str(offer_type.EventType.CINEMA),
)
venue = factories.VenueFactory()
offerer = venue.managingOfferer
user_offerer = factories.UserOffererFactory(offerer=offerer)
user = user_offerer.user
data = offers_serialize.PostOfferBodyModel(
venueId=humanize(venue.id),
productId=humanize(product.id),
externalTicketOfficeUrl="http://example.net",
audioDisabilityCompliant=True,
mentalDisabilityCompliant=True,
motorDisabilityCompliant=True,
visualDisabilityCompliant=True,
)
offer = api.create_offer(data, user)
assert offer.name == "An excellent offer"
assert offer.type == str(offer_type.EventType.CINEMA)
assert offer.product == product
assert offer.externalTicketOfficeUrl == "http://example.net"
assert offer.audioDisabilityCompliant
assert offer.mentalDisabilityCompliant
assert offer.motorDisabilityCompliant
assert offer.visualDisabilityCompliant
assert Offer.query.count() == 1
mocked_offer_creation_notification_to_admin.assert_called_once_with(
offer, user)
def test_results_are_filtered_by_given_period_ending_date(self, mocked_list_offers, app, db_session):
# given
pro = users_factories.ProFactory()
offerer = offers_factories.OffererFactory()
offers_factories.UserOffererFactory(user=pro, offerer=offerer)
# when
response = (
TestClient(app.test_client())
.with_session_auth(email=pro.email)
.get("/offers?periodEndingDate=2020-10-11T23:59:59Z")
)
# then
assert response.status_code == 200
mocked_list_offers.assert_called_once_with(
user_id=pro.id,
user_is_admin=pro.isAdmin,
offerer_id=None,
venue_id=None,
category_id=None,
name_keywords_or_isbn=None,
period_beginning_date=None,
period_ending_date="2020-10-11T23:59:59Z",
status=None,
creation_mode=None,
)
def test_fail_if_venue_is_not_found(self, app):
# Given
offers_factories.UserOffererFactory(user__email="*****@*****.**")
# When
client = TestClient(app.test_client()).with_auth("*****@*****.**")
data = {
"venueId": humanize(1),
"bookingEmail": "*****@*****.**",
"mediaUrls": ["http://example.com/media"],
"name": "Les lièvres pas malins",
"type": "ThingType.JEUX_VIDEO",
"url": "http://example.com/offer",
"audioDisabilityCompliant": True,
"mentalDisabilityCompliant": False,
"motorDisabilityCompliant": False,
"visualDisabilityCompliant": False,
}
response = client.post("/offers", json=data)
# Then
assert response.status_code == 400
assert response.json["global"] == [
"Aucun objet ne correspond à cet identifiant dans notre base de données"
]
def when_requested_booking_period_dates_are_iso_format(self, app):
booking_date = datetime(2020, 8, 12, 20, 00, tzinfo=timezone.utc)
booking_period_beginning_date_iso = "2020-08-10"
booking_period_ending_date_iso = "2020-08-12"
booking = bookings_factories.BookingFactory(dateCreated=booking_date, token="AAAAAA")
bookings_factories.BookingFactory(token="BBBBBB")
pro_user = users_factories.ProFactory(email="*****@*****.**")
offers_factories.UserOffererFactory(user=pro_user, offerer=booking.offerer)
client = TestClient(app.test_client()).with_session_auth(pro_user.email)
with assert_num_queries(
testing.AUTHENTICATION_QUERIES
+ 2
+ 1 # TODO: query for feature flag, to be removed when IMPROVE_BOOKINGS_PERF is definitely adopted
):
response = client.get(
"/bookings/pro?bookingPeriodBeginningDate=%s&bookingPeriodEndingDate=%s"
% (booking_period_beginning_date_iso, booking_period_ending_date_iso)
)
assert response.status_code == 200
assert len(response.json["bookings_recap"]) == 1
assert response.json["bookings_recap"][0]["booking_date"] == datetime.isoformat(
utc_datetime_to_department_timezone(booking.dateCreated, booking.venue.departementCode)
)
assert response.json["page"] == 1
assert response.json["pages"] == 1
assert response.json["total"] == 1
def should_filter_offers_by_given_offerer_id(self, mocked_list_offers, app, db_session):
# given
pro = users_factories.ProFactory()
offerer = offers_factories.OffererFactory()
offers_factories.UserOffererFactory(user=pro, offerer=offerer)
offers_factories.VenueFactory(managingOfferer=offerer)
# when
response = (
TestClient(app.test_client())
.with_session_auth(email=pro.email)
.get("/offers?offererId=" + humanize(offerer.id))
)
# then
assert response.status_code == 200
mocked_list_offers.assert_called_once_with(
user_id=pro.id,
user_is_admin=pro.isAdmin,
offerer_id=offerer.id,
venue_id=None,
category_id=None,
name_keywords_or_isbn=None,
period_beginning_date=None,
period_ending_date=None,
status=None,
creation_mode=None,
)
def when_creating_new_thing_offer(self, app):
# Given
venue = offers_factories.VirtualVenueFactory()
offerer = venue.managingOfferer
offers_factories.UserOffererFactory(offerer=offerer, user__email="*****@*****.**")
# When
client = TestClient(app.test_client()).with_auth("*****@*****.**")
data = {
"venueId": humanize(venue.id),
"bookingEmail": "*****@*****.**",
"mediaUrls": ["http://example.com/media"],
"name": "Les lièvres pas malins",
"type": "ThingType.JEUX_VIDEO",
"url": "http://example.com/offer",
}
response = client.post("/offers", json=data)
# Then
assert response.status_code == 201
offer_id = dehumanize(response.json["id"])
offer = Offer.query.get(offer_id)
assert offer.bookingEmail == "*****@*****.**"
assert offer.type == str(ThingType.JEUX_VIDEO)
assert offer.venue == venue
assert offer.product.name == "Les lièvres pas malins"
assert offer.product.url == "http://example.com/offer"
assert offer.url == "http://example.com/offer"
assert offer.isDigital
assert offer.isNational
assert offer.product.isNational
assert offer.product.owningOfferer == offerer
def test_create_event_offer(self, app):
# Given
venue = offers_factories.VenueFactory()
offerer = venue.managingOfferer
offers_factories.UserOffererFactory(offerer=offerer, user__email="*****@*****.**")
# When
data = {
"venueId": humanize(venue.id),
"bookingEmail": "*****@*****.**",
"durationMinutes": 60,
"name": "La pièce de théâtre",
"type": str(EventType.SPECTACLE_VIVANT),
"extraData": {"toto": "text"},
}
client = TestClient(app.test_client()).with_auth("*****@*****.**")
response = client.post("/offers", json=data)
# Then
assert response.status_code == 201
offer_id = dehumanize(response.json["id"])
offer = Offer.query.get(offer_id)
assert offer.bookingEmail == "*****@*****.**"
assert offer.type == str(EventType.SPECTACLE_VIVANT)
assert offer.extraData == {"toto": "text"}
assert offer.venue == venue
assert offer.product.durationMinutes == 60
assert offer.product.owningOfferer == offerer
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_mediation_is_created_with_bad_thumb_url(self, app):
# given
offer = offers_factories.ThingOfferFactory()
offerer = offer.venue.managingOfferer
offers_factories.UserOffererFactory(
user__email="*****@*****.**",
offerer=offerer,
)
# when
client = TestClient(
app.test_client()).with_auth(email="*****@*****.**")
data = {
"offerId": humanize(offer.id),
"offererId": humanize(offerer.id),
"thumbUrl": "https://example.com/image.jpg",
}
with requests_mock.Mocker() as mock:
mock.get("https://example.com/image.jpg", status_code=404)
response = client.post("/mediations", form=data)
# then
assert response.status_code == 400
assert response.json == {
"thumbUrl": ["L'adresse saisie n'est pas valide"]
}
def test_fail_when_offer_type_does_not_allow_virtual_offer_and_venue_is_virtuel(
self, app):
# Given
venue = offers_factories.VirtualVenueFactory()
offerer = venue.managingOfferer
offers_factories.UserOffererFactory(offerer=offerer,
user__email="*****@*****.**")
# When
data = {
"type": "ThingType.JEUX",
"name": "Le grand jeu",
"url": "http://legrandj.eu",
"mediaUrls": ["http://media.url"],
"venueId": humanize(venue.id),
"audioDisabilityCompliant": True,
"mentalDisabilityCompliant": False,
"motorDisabilityCompliant": False,
"visualDisabilityCompliant": False,
}
client = TestClient(app.test_client()).with_auth("*****@*****.**")
response = client.post("/offers", json=data)
# Then
assert response.status_code == 400
assert response.json["url"] == [
"Une offre de type Jeux (support physique) ne peut pas être numérique"
]
def test_admin_can_access_reimbursements_data_with_venue_filter(app, client):
# Given
beginning_date = date.today() - timedelta(days=2)
ending_date = date.today() + timedelta(days=2)
admin = users_factories.AdminFactory()
user_offerer = offers_factories.UserOffererFactory()
offerer = user_offerer.offerer
status = payments_factories.PaymentStatusFactory(
payment__booking__stock__offer__venue__managingOfferer=offerer,
status=TransactionStatus.SENT,
payment__transactionLabel=
"pass Culture Pro - remboursement 1ère quinzaine 06-21",
date=date.today(),
)
venue = status.payment.booking.venue
# When
admin_client = client.with_session_auth(admin.email)
response = admin_client.get(
"/reimbursements/csv?venueId={}&reimbursementPeriodBeginningDate={}&reimbursementPeriodEndingDate={}"
.format(humanize(venue.id), beginning_date.isoformat(),
ending_date.isoformat()))
# Then
assert response.status_code == 200
assert response.headers["Content-type"] == "text/csv; charset=utf-8;"
assert response.headers[
"Content-Disposition"] == "attachment; filename=remboursements_pass_culture.csv"
rows = response.data.decode("utf-8").splitlines()
assert len(rows) == 2 # header + payments
def test_when_user_is_logged_in_and_offer_is_educational_but_has_been_refused_by_institution(
self, client):
# Given
booking = bookings_factories.EducationalBookingFactory(
token="ABCDEF",
dateCreated=datetime.datetime.utcnow() -
datetime.timedelta(days=3),
educationalBooking__status=EducationalBookingStatus.REFUSED,
)
pro_user = users_factories.ProFactory(email="*****@*****.**")
offers_factories.UserOffererFactory(user=pro_user,
offerer=booking.offerer)
# When
url = f"/v2/bookings/use/token/{booking.token}"
response = client.with_session_auth("*****@*****.**").patch(url)
# Then
assert response.status_code == 403
assert (
response.json["educationalBooking"] ==
"Cette réservation pour une offre éducationnelle a été refusée par le chef d'établissement"
)
booking = Booking.query.get(booking.id)
assert booking.isUsed is False
assert booking.status is not BookingStatus.USED
def test_create_offer_from_scratch(
self, mocked_offer_creation_notification_to_admin):
venue = factories.VenueFactory()
offerer = venue.managingOfferer
user_offerer = factories.UserOffererFactory(offerer=offerer)
user = user_offerer.user
data = offers_serialize.PostOfferBodyModel(
venueId=humanize(venue.id),
name="A pretty good offer",
type=str(offer_type.EventType.CINEMA),
externalTicketOfficeUrl="http://example.net",
audioDisabilityCompliant=True,
mentalDisabilityCompliant=True,
motorDisabilityCompliant=True,
visualDisabilityCompliant=True,
)
offer = api.create_offer(data, user)
assert offer.name == "A pretty good offer"
assert offer.venue == venue
assert offer.type == str(offer_type.EventType.CINEMA)
assert offer.product.owningOfferer == offerer
assert offer.externalTicketOfficeUrl == "http://example.net"
assert offer.audioDisabilityCompliant
assert offer.mentalDisabilityCompliant
assert offer.motorDisabilityCompliant
assert offer.visualDisabilityCompliant
assert not offer.bookingEmail
assert Offer.query.count() == 1
mocked_offer_creation_notification_to_admin.assert_called_once_with(
offer, user)
def get_existing_pro_user_with_offerer():
user_offerer = offers_factories.UserOffererFactory(
user__validationToken=None, )
return {
"offerer": get_offerer_helper(user_offerer.offerer),
"user": get_pro_helper(user_offerer.user)
}
def test_does_not_have_access_if_not_validated(self, app):
user_offerer = offers_factories.UserOffererFactory(
validationToken="token")
offerer = user_offerer.offerer
user = user_offerer.user
assert not user.has_access(offerer.id)
def test_user_has_right_on_venue(self, app):
# Given
user = user_factories.ProFactory()
owner_offerer = offer_factories.UserOffererFactory()
offerer = owner_offerer.offerer
venue = offer_factories.VenueFactory(managingOfferer=offerer)
provider = offerers_factories.AllocineProviderFactory()
venue_provider = offerers_factories.AllocineVenueProviderFactory(
venue=venue,
provider=provider,
isDuo=False,
quantity=42,
)
offerers_factories.AllocineVenueProviderPriceRuleFactory(allocineVenueProvider=venue_provider, price=10)
updated_venue_provider_data = {
"providerId": humanize(provider.id),
"venueId": humanize(venue.id),
"isDuo": True,
"quantity": 77,
"price": 64,
}
auth_request = TestClient(app.test_client()).with_session_auth(email=user.email)
# When
response = auth_request.put("/venueProviders", json=updated_venue_provider_data)
# Then
assert response.status_code == 403
def test_invalid_offerer_id(mock_get_filtered_venues, app):
pro_user = users_factories.ProFactory(email="*****@*****.**")
offerer = offers_factories.OffererFactory()
offers_factories.UserOffererFactory(user=pro_user, offerer=offerer)
offers_factories.VenueFactory(managingOfferer=offerer)
query_params = [
f"offererId={humanize(666)}",
]
# when
response = TestClient(app.test_client()).with_session_auth(pro_user.email).get(f"/venues?{'&'.join(query_params)}")
# then
# then
assert response.status_code == 200
mock_get_filtered_venues.assert_called_once_with(
active_offerers_only=None,
offerer_id=666,
pro_user_id=pro_user.id,
user_is_admin=False,
validated_offerer=None,
validated_offerer_for_user=None,
)
assert "venues" in response.json
assert len(response.json["venues"]) == 0
def test_edit_one_stock(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,
)
# When
stock_data = {
"offerId": humanize(offer.id),
"stocks": [{
"id": humanize(existing_stock.id),
"price": 20
}],
}
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"])
edited_stock = Stock.query.get(
dehumanize(response_dict["stockIds"][0]["id"]))
assert edited_stock.price == 20
def test_allocine_venue_provider_is_successfully_updated(self, app):
# Given
user_offerer = offer_factories.UserOffererFactory()
user = user_offerer.user
offerer = user_offerer.offerer
venue = offer_factories.VenueFactory(managingOfferer=offerer)
provider = offerers_factories.AllocineProviderFactory()
venue_provider = offerers_factories.AllocineVenueProviderFactory(
venue=venue,
provider=provider,
isDuo=False,
quantity=42,
)
offerers_factories.AllocineVenueProviderPriceRuleFactory(allocineVenueProvider=venue_provider, price=10)
updated_venue_provider_data = {
"providerId": humanize(provider.id),
"venueId": humanize(venue.id),
"isDuo": True,
"quantity": 77,
"price": 64,
}
auth_request = TestClient(app.test_client()).with_session_auth(email=user.email)
# When
response = auth_request.put("/venueProviders", json=updated_venue_provider_data)
# Then
assert response.status_code == 200
assert response.json["provider"]["id"] == humanize(provider.id)
assert response.json["venueId"] == humanize(venue.id)
assert response.json["quantity"] == updated_venue_provider_data["quantity"]
assert response.json["price"] == updated_venue_provider_data["price"]
assert response.json["isDuo"] == updated_venue_provider_data["isDuo"]
def test_response_serialization(app):
user_offerer = offers_factories.UserOffererFactory(
user__email="*****@*****.**",
)
venue = offers_factories.VenueFactory(managingOfferer=user_offerer.offerer)
# when
response = TestClient(app.test_client()).with_session_auth(user_offerer.user.email).get("/venues")
# then
assert response.status_code == 200
assert "venues" in response.json
assert len(response.json["venues"]) == 1
assert response.json["venues"][0] == {
"id": humanize(venue.id),
"managingOffererId": humanize(venue.managingOffererId),
"name": venue.name,
"offererName": user_offerer.offerer.name,
"publicName": venue.publicName,
"isVirtual": venue.isVirtual,
"bookingEmail": venue.bookingEmail,
"withdrawalDetails": venue.withdrawalDetails,
"audioDisabilityCompliant": venue.audioDisabilityCompliant,
"mentalDisabilityCompliant": venue.mentalDisabilityCompliant,
"motorDisabilityCompliant": venue.motorDisabilityCompliant,
"visualDisabilityCompliant": venue.visualDisabilityCompliant,
}
def test_edit_venue_withdrawal_details_with_applied_on_all_offers(
self, mocked_update_all_venue_offers_withdrawal_details_job, app):
user_offerer = offers_factories.UserOffererFactory()
venue = offers_factories.VenueFactory(
name="old name",
managingOfferer=user_offerer.offerer,
)
auth_request = TestClient(
app.test_client()).with_session_auth(email=user_offerer.user.email)
venue_data = populate_missing_data_from_venue(
{
"name": "new name",
"withdrawalDetails":
"Ceci est un texte de modalités de retrait",
"isWithdrawalAppliedOnAllOffers": True,
},
venue,
)
response = auth_request.patch("/venues/%s" % humanize(venue.id),
json=venue_data)
assert response.status_code == 200
assert venue.withdrawalDetails == "Ceci est un texte de modalités de retrait"
mocked_update_all_venue_offers_withdrawal_details_job.assert_called_once_with(
venue, "Ceci est un texte de modalités de retrait")
def test_full_valid_call_with_false(mock_get_filtered_venues, app):
pro_user = users_factories.ProFactory(email="*****@*****.**")
offerer = offers_factories.OffererFactory()
offers_factories.UserOffererFactory(user=pro_user, offerer=offerer)
query_params = [
"validated=false",
"validatedForUser=false",
f"offererId={humanize(offerer.id)}",
"activeOfferersOnly=false",
]
# when
response = TestClient(app.test_client()).with_session_auth(pro_user.email).get(f"/venues?{'&'.join(query_params)}")
# then
assert response.status_code == 200
mock_get_filtered_venues.assert_called_once_with(
active_offerers_only=False,
offerer_id=offerer.id,
pro_user_id=pro_user.id,
user_is_admin=False,
validated_offerer=False,
validated_offerer_for_user=False,
)
