def test_email_is_sent_to_dev_at_passculture_when_not_production_environment(
self, mock_send_mail_enabled, mock_format_env, app
):
# Given
user = create_user(email="*****@*****.**", first_name="Bobby", reset_password_token="ABCDEFG")
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
repository.save(user_offerer)
# When
reset_password_email_data = retrieve_data_for_reset_password_user_email(user=user)
# Then
assert reset_password_email_data == {
"FromEmail": "*****@*****.**",
"MJ-TemplateID": 912168,
"MJ-TemplateLanguage": True,
"To": "*****@*****.**",
"Vars": {"prenom_user": "******", "token": user.resetPasswordToken, "env": "-testing"},
}
def when_latitude_out_of_range_and_longitude_wrong_format(self, app):
# given
offerer = create_offerer()
user = create_user()
venue = create_venue(offerer, is_virtual=False)
user_offerer = create_user_offerer(user, offerer)
repository.save(user_offerer, venue)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
data = {"latitude": -98.82387, "longitude": "112°3534"}
# when
response = auth_request.patch("/venues/%s" % humanize(venue.id),
json=data)
# then
assert response.status_code == 400
assert response.json["latitude"] == [
"La latitude doit être comprise entre -90.0 et +90.0"
]
assert response.json["longitude"] == ["Format incorrect"]
def when_there_is_already_one_equal_siret(self, app):
# Given
offerer = create_offerer()
user = create_user()
user_offerer = create_user_offerer(user, offerer, is_admin=True)
siret = offerer.siren + "11111"
venue = create_venue(offerer, siret=siret)
repository.save(user_offerer, venue)
venue_data = {
"siret": siret,
}
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
# when
response = auth_request.patch("/venues/%s" % humanize(venue.id),
json=venue_data)
# Then
assert response.status_code == 200
assert response.json["siret"] == siret
def test_should_not_set_not_processable_payments_to_retry_when_bank_information_status_is_not_accepted(
self):
# Given
offerer = create_offerer(name="first offerer")
user = create_user()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, price=0)
booking = create_booking(user=user, stock=stock)
bank_information = create_bank_information(
offerer=offerer,
iban=None,
bic=None,
status=BankInformationStatus.DRAFT)
not_processable_payment = create_payment(
booking,
offerer,
10,
status=TransactionStatus.NOT_PROCESSABLE,
iban=None,
bic=None)
sent_payment = create_payment(booking,
offerer,
10,
status=TransactionStatus.SENT)
repository.save(bank_information, not_processable_payment,
sent_payment)
# When
set_not_processable_payments_with_bank_information_to_retry()
# Then
queried_not_processable_payment = Payment.query.filter_by(
id=not_processable_payment.id).one()
queried_sent_payment = Payment.query.filter_by(
id=sent_payment.id).one()
assert queried_not_processable_payment.iban == None
assert queried_not_processable_payment.bic == None
assert queried_not_processable_payment.currentStatus.status == TransactionStatus.NOT_PROCESSABLE
assert queried_sent_payment.currentStatus.status == TransactionStatus.SENT
def test_only_returns_payments_with_given_message(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
paying_stock = create_stock_from_offer(offer)
free_stock = create_stock_from_offer(offer, price=0)
user = users_factories.UserFactory()
booking1 = create_booking(user=user,
stock=paying_stock,
venue=venue,
is_used=True)
booking2 = create_booking(user=user,
stock=paying_stock,
venue=venue,
is_used=True)
booking3 = create_booking(user=user,
stock=paying_stock,
venue=venue,
is_used=True)
booking4 = create_booking(user=user,
stock=free_stock,
venue=venue,
is_used=True)
payment1 = create_payment(booking1,
offerer,
10,
payment_message_name="ABCD123")
payment2 = create_payment(booking2,
offerer,
10,
payment_message_name="EFGH456")
repository.save(payment1, payment2, booking3, booking4)
# When
payements_by_id = payment_queries.get_payments_by_message_id("ABCD123")
# Then
assert len(payements_by_id) == 1
assert payements_by_id[0].paymentMessage.name == "ABCD123"
def test_should_prevent_a_used_booking_from_being_cancelled(
self, app):
# Given
pro_user = create_user(email="Mr [email protected]",
public_name="Mr Books")
offerer = create_offerer(siren="793875030")
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
book_offer = create_offer_with_event_product(venue)
stock = create_stock(offer=book_offer)
user = create_user(email="*****@*****.**", public_name="J.F")
create_deposit(user)
booking = create_booking(user=user,
stock=stock,
is_used=True,
venue=venue)
repository.save(booking, user_offerer)
api_key = random_token(64)
offerer_api_key = create_api_key_for_offerer(offerer, api_key)
repository.save(offerer_api_key)
# When
response = TestClient(app.test_client()).patch(
"/v2/bookings/cancel/token/{}".format(booking.token),
headers={
"Authorization": "Bearer " + api_key,
"Origin": "http://localhost"
},
)
# Then
assert response.status_code == 403
assert response.json["global"] == [
"Impossible d'annuler une réservation consommée"
]
updated_booking = Booking.query.first()
assert updated_booking.isUsed
assert updated_booking.isCancelled is False
def test_should_return_providable_infos_with_correct_data(
self, mock_fnac_api_response, app):
# Given
mock_fnac_api_response.return_value = iter([{
"ref": "9780199536986",
"available": 1,
"price": 6.36
}])
offerer = create_offerer()
venue = create_venue(offerer, siret="12345678912345")
fnac_provider = activate_provider("FnacStocks")
venue_provider = create_venue_provider(
venue,
fnac_provider,
venue_id_at_offer_provider=venue.siret,
last_sync_date=datetime(2020, 2, 4))
product = create_product_with_thing_type(
id_at_providers="9780199536986")
repository.save(venue_provider, product)
fnac_stocks_provider = FnacStocks(venue_provider)
# When
fnac_providable_infos = next(fnac_stocks_provider)
# Then
assert mock_fnac_api_response.call_args_list == [
call("12345678912345", "", datetime(2020, 2, 4))
]
assert len(fnac_providable_infos) == 2
offer_providable_info = fnac_providable_infos[0]
stock_providable_info = fnac_providable_infos[1]
assert offer_providable_info.type == Offer
assert offer_providable_info.id_at_providers == "9780199536986@12345678912345"
assert stock_providable_info.type == Stock
assert stock_providable_info.id_at_providers == "9780199536986@12345678912345"
def test_fnac_stock_provider_update_one_stock_and_update_matching_offer(
self, mock_fnac_api_response, app):
# Given
mock_fnac_api_response.return_value = iter([{
"ref": "9780199536986",
"available": 10,
"price": 16
}])
offerer = create_offerer()
venue = create_venue(offerer)
fnac_stocks_provider = activate_provider("FnacStocks")
venue_provider = create_venue_provider(
venue,
fnac_stocks_provider,
is_active=True,
venue_id_at_offer_provider="12345678912345")
product = create_product_with_thing_type(
id_at_providers="9780199536986")
offer = create_offer_with_thing_product(
venue,
product=product,
id_at_providers="9780199536986@12345678912345")
stock = create_stock(
id_at_providers="9780199536986@12345678912345",
offer=offer,
quantity=20)
repository.save(product, offer, stock)
fnac_stocks = FnacStocks(venue_provider)
# When
fnac_stocks.updateObjects()
# Then
stock = Stock.query.one()
assert stock.quantity == 10
assert Offer.query.count() == 1
def test_should_update_bank_informations_when_bank_informations_already_exist_for_venue(
self, app):
# given
offerer = create_offerer()
venue = create_venue(offerer=offerer)
bank_informations_sql = create_bank_information(
venue=venue,
application_id=9,
status=BankInformationStatus.DRAFT,
iban=None,
bic=None)
repository.save(bank_informations_sql)
bank_informations_to_save = BankInformations(
status=BankInformationStatus.ACCEPTED,
application_id=9,
iban="FR7630006000011234567890189",
bic="QSDFGH8Z555",
venue_id=venue.id,
date_modified=datetime(2018, 2, 3),
)
# when
bank_informations_saved = self.bank_informations_sql_repository.update_by_venue_id(
bank_informations_to_save)
# then
assert BankInformationsSQLEntity.query.count() == 1
sql_bank_informations_saved = BankInformationsSQLEntity.query.first()
assert sql_bank_informations_saved.offererId == None
assert sql_bank_informations_saved.venueId == venue.id
assert sql_bank_informations_saved.iban == bank_informations_to_save.iban
assert sql_bank_informations_saved.bic == bank_informations_to_save.bic
assert sql_bank_informations_saved.applicationId == bank_informations_to_save.application_id
assert sql_bank_informations_saved.status == bank_informations_to_save.status
assert sql_bank_informations_saved.dateModified == bank_informations_to_save.date_modified
assert bank_informations_saved.iban == bank_informations_to_save.iban
assert bank_informations_saved.bic == bank_informations_to_save.bic
def test_offerer_cannot_create_a_second_virtual_venue(app):
# Given
offerer = create_offerer(siren="123456789",
address="1 rue Test",
city="Test city",
postal_code="93000",
name="Test offerer")
repository.save(offerer)
venue = create_venue(
offerer,
name="Venue_name",
booking_email="*****@*****.**",
address=None,
postal_code=None,
city=None,
departement_code=None,
is_virtual=True,
siret=None,
)
repository.save(venue)
new_venue = create_venue(
offerer,
name="Venue_name",
booking_email="*****@*****.**",
address=None,
postal_code=None,
city=None,
departement_code=None,
is_virtual=True,
siret=None,
)
# When
with pytest.raises(ApiErrors) as errors:
repository.save(new_venue)
# Then
assert errors.value.errors["isVirtual"] == [
"Un lieu pour les offres numériques existe déjà pour cette structure"
]
def test_should_register_new_venue(self, app):
# given
offerer = create_offerer(siren="302559178")
user = create_user()
user_offerer = create_user_offerer(user, offerer)
venue_type = create_venue_type(label="Musée")
venue_label = create_venue_label(
label="CAC - Centre d'art contemporain d'intérêt national")
repository.save(user_offerer, venue_type, venue_label)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
venue_data = {
"name": "Ma venue",
"siret": "30255917810045",
"address": "75 Rue Charles Fourier, 75013 Paris",
"postalCode": "75200",
"bookingEmail": "*****@*****.**",
"city": "Paris",
"managingOffererId": humanize(offerer.id),
"latitude": 48.82387,
"longitude": 2.35284,
"publicName": "Ma venue publique",
"venueTypeId": humanize(venue_type.id),
"venueLabelId": humanize(venue_label.id),
}
# when
response = auth_request.post("/venues", json=venue_data)
# then
assert response.status_code == 201
idx = response.json["id"]
venue = Venue.query.filter_by(id=dehumanize(idx)).one()
assert venue.name == "Ma venue"
assert venue.publicName == "Ma venue publique"
assert venue.siret == "30255917810045"
assert venue.isValidated
assert venue.venueTypeId == venue_type.id
assert venue.venueLabelId == venue_label.id
def test_records_new_payment_lines_in_database(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
paying_stock = create_stock_from_offer(offer)
free_stock = create_stock_from_offer(offer, price=0)
user = create_user()
deposit = create_deposit(user, amount=500)
booking1 = create_booking(user=user,
stock=paying_stock,
venue=venue,
is_used=True)
booking2 = create_booking(user=user,
stock=paying_stock,
venue=venue,
is_used=True)
booking3 = create_booking(user=user,
stock=paying_stock,
venue=venue,
is_used=True)
booking4 = create_booking(user=user,
stock=free_stock,
venue=venue,
is_used=True)
payment1 = create_payment(booking2,
offerer,
10,
payment_message_name="ABCD123")
repository.save(payment1)
repository.save(deposit, booking1, booking3, booking4)
initial_payment_count = Payment.query.count()
# When
generate_new_payments()
# Then
assert Payment.query.count() - initial_payment_count == 2
def test_stock_provider_praxiel_create_one_stock_and_one_offer_with_wanted_attributes(
self, mock_praxiel_api_response, app):
# Given
mock_praxiel_api_response.return_value = iter([{
"ref": "9780199536986",
"available": 10,
"price": 16.5
}])
offerer = create_offerer()
venue = create_venue(offerer, siret="77567146400110")
praxiel_stocks_provider = activate_provider("PraxielStocks")
venue_provider = create_venue_provider(
venue,
praxiel_stocks_provider,
is_active=True,
venue_id_at_offer_provider="77567146400110")
product = create_product_with_thing_type(
id_at_providers="9780199536986")
repository.save(product, venue_provider)
praxiel_stocks_provider = PraxielStocks(venue_provider)
# When
praxiel_stocks_provider.updateObjects()
# Then
offer = Offer.query.first()
stock = Stock.query.first()
assert offer.type == product.type
assert offer.description == product.description
assert offer.venue is not None
assert offer.bookingEmail == venue.bookingEmail
assert offer.extraData == product.extraData
assert stock.price == 16.5
assert stock.quantity == 10
assert stock.bookingLimitDatetime is None
def when_offerer_already_have_user_offerer_new_user_offerer_has_validation_token(
self, mock_api_entreprise, make_validation_email_object, app):
# Given
make_validation_email_object.return_value = {"Html-part": None}
mock_api_entreprise.return_value = MagicMock(
status_code=200,
text="",
json=MagicMock(
return_value=copy.deepcopy(api_entreprise_json_mock)))
user = create_user(is_beneficiary=False, is_admin=False)
user_2 = create_user(email="*****@*****.**",
is_admin=False)
offerer = create_offerer()
user_offerer = create_user_offerer(user_2,
offerer,
validation_token=None)
digital_venue_type = create_venue_type(
label=DEFAULT_DIGITAL_VENUE_LABEL)
repository.save(user, user_2, offerer, user_offerer,
digital_venue_type)
body = {
"name": "Test Offerer",
"siren": "123456789",
"address": "123 rue de Paris",
"postalCode": "93100",
"city": "Montreuil",
}
# when
response = TestClient(app.test_client()).with_auth(
user.email).post("/offerers", json=body)
# then
assert response.status_code == 201
offerer = Offerer.query.first()
created_user_offerer = (UserOfferer.query.filter(
UserOfferer.offerer == offerer).filter(
UserOfferer.user == user).one())
assert created_user_offerer.validationToken is not None
def test_contains_info_on_bank_transaction(self):
# given
user = create_user()
booking = create_booking(user=user)
offerer = create_offerer()
payment = create_payment(booking,
offerer,
35,
payment_message_name="1234",
transaction_end_to_end_id=uuid.uuid4(),
iban="123456789")
# when
details = create_payment_details(payment,
find_booking_date_used=Mock())
# then
assert details.payment_iban == "123456789"
assert details.payment_message_name == "1234"
assert details.transaction_end_to_end_id == payment.transactionEndToEndId
assert details.reimbursed_amount == 35
assert details.reimbursement_rate == 0.5
def test_it_returns_an_empty_list_if_everything_has_no_not_processable_payment(
self):
# given
user = create_user()
booking = create_booking(user=user)
offerer = create_offerer()
payments = [
create_payment(booking, offerer, 30,
status=TransactionStatus.SENT),
create_payment(booking, offerer, 30,
status=TransactionStatus.SENT),
create_payment(booking,
offerer,
30,
status=TransactionStatus.ERROR),
]
# when
pending_payments = keep_only_not_processable_payments(payments)
# then
assert pending_payments == []
def test_should_return_error_messages_when_offer_is_digital_and_offline_and_venue_is_not_virtual(
):
# Given
offerer = create_offerer()
venue = create_venue(offerer, is_virtual=False)
thing_offer = create_offer_with_thing_product(venue,
is_digital=True,
is_offline_only=True)
api_errors = ApiErrors()
# When
api_error = validate(thing_offer, api_errors)
# Then
assert api_error.errors == {
"url": [
"Une offre de sous-catégorie Carte cinéma multi-séances ne peut pas être numérique"
],
"venue": [
'Une offre numérique doit obligatoirement être associée au lieu "Offre numérique"'
],
}
def test_raise_errors_if_venue_provider_already_exists_with_same_information(
app):
# given
provider = activate_provider("TiteLiveStocks")
offerer = create_offerer()
venue = create_venue(offerer,
name="Librairie Titelive",
siret="77567146400110")
venue_provider = create_venue_provider(
venue, provider, venue_id_at_offer_provider="775671464")
repository.save(venue_provider)
venue_provider2 = create_venue_provider(
venue, provider, venue_id_at_offer_provider="775671464")
# when
with pytest.raises(ApiErrors) as errors:
repository.save(venue_provider2)
# then
assert errors.value.errors["global"] == [
"Votre lieu est déjà lié à cette source"
]
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, is_admin=True)
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_user_not_logged_in_right_email_and_wrong_offer(self, app):
# Given
user = create_user(email="*****@*****.**")
admin_user = create_user(email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer)
stock = create_stock_with_thing_offer(offerer,
venue,
offer=None,
price=0)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(admin_user, booking)
url = f"/bookings/token/{booking.token}[email protected]&offer_id={humanize(123)}"
# When
response = TestClient(app.test_client()).get(url)
# Then
assert response.status_code == 404
assert response.json["global"] == [
"Cette contremarque n'a pas été trouvée"
]
def test_should_generate_non_editable_venues_csv_with_correct_header_and_correct_informations(
self, app):
# given
offerer = create_offerer(siren="123456788")
venue = create_venue(offerer, siret="88345678899999")
repository.save(venue)
# when
csv = generate_non_editable_venues_csv()
# Then
csv_as_lines = csv.splitlines()
assert (
csv_as_lines[0] ==
"offerer_id,offerer_humanized_id,offerer_siren,offerer_name,venue_id,venue_humanized_id,venue_siret,venue_name,venue_departement"
)
assert (
csv_as_lines[1] ==
f"{offerer.id},{humanize(offerer.id)},123456788,Test Offerer,{venue.id},{humanize(venue.id)},88345678899999,La petite librairie,93"
)
def when_favorite_exists_with_offerId(self, app):
# Given
user = users_factories.BeneficiaryGrant18Factory(
email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer,
postal_code="29100",
siret="12345678912341")
offer = create_offer_with_thing_product(venue, thumb_count=0)
mediation = None
favorite = create_favorite(mediation=mediation, offer=offer, user=user)
repository.save(favorite)
# When
response = (TestClient(app.test_client()).with_session_auth(
user.email).delete(f"/favorites/{humanize(offer.id)}"))
# Then
assert response.status_code == 200
assert "id" in response.json
deleted_favorite = Favorite.query.first()
assert deleted_favorite is None
def when_user_not_logged_in_and_existing_api_key_given_with_no_bearer_prefix(
self, app):
# Given
pro = create_user(email="*****@*****.**")
offerer = create_offerer()
user_offerer = create_user_offerer(pro, offerer)
repository.save(user_offerer)
offerer_api_key = create_api_key(offerer_id=offerer.id)
repository.save(offerer_api_key)
url = "/v2/bookings/token/FAKETOKEN"
# When
response = TestClient(app.test_client()).get(url,
headers={
"Authorization":
API_KEY_VALUE,
"Origin":
"http://localhost"
})
# Then
assert response.status_code == 401
def when_mediation_is_not_found(self, app):
# Given
user = create_user(email="*****@*****.**")
offerer = create_offerer()
venue = create_venue(offerer,
postal_code="29100",
siret="12345678912341")
offer = create_offer_with_thing_product(venue, thumb_count=0)
mediation = create_mediation(offer, is_active=True)
repository.save(user, mediation)
json = {
"offerId": humanize(offer.id),
"mediationId": "ABCD",
}
# When
response = TestClient(app.test_client()).with_auth(
user.email).post("/favorites", json=json)
# Then
assert response.status_code == 404
def test_payments_are_grouped_by_current_statuses_names(self):
# given
user = create_user()
booking = create_booking(user=user)
offerer = create_offerer()
payment1 = create_payment(booking, offerer, 10)
payment2 = create_payment(booking, offerer, 20)
payment3 = create_payment(booking, offerer, 30)
payment4 = create_payment(booking, offerer, 40)
payment1.setStatus(TransactionStatus.SENT)
payment2.setStatus(TransactionStatus.NOT_PROCESSABLE)
payment3.setStatus(TransactionStatus.ERROR)
payment4.setStatus(TransactionStatus.ERROR)
payments = [payment1, payment2, payment3, payment4]
# when
groups = group_payments_by_status(payments)
# then
assert len(groups["SENT"]) == 1
assert len(groups["NOT_PROCESSABLE"]) == 1
assert len(groups["ERROR"]) == 2
def expect_user_offerer_attachment_not_to_be_validated_with_same_token(
self, app):
user_offerer_token = secrets.token_urlsafe(20)
offerer_token = secrets.token_urlsafe(20)
offerer = create_offerer(
siren="349974931",
address="12 boulevard de Pesaro",
city="Nanterre",
postal_code="92000",
name="Crédit Coopératif",
validation_token=offerer_token,
)
user = create_user()
user_offerer = create_user_offerer(
user, offerer, validation_token=user_offerer_token)
repository.save(offerer, user_offerer)
user_offerer_id = offerer.id
# When
TestClient(app.test_client()).get(
"/validate/user-offerer/" + user_offerer_token,
headers={"origin": "http://localhost:3000"})
response = TestClient(app.test_client()).get(
"/validate/user-offerer/" + user_offerer_token,
headers={"origin": "http://localhost:3000"})
# Then
assert response.status_code == 404
user_offerer = UserOfferer.query.filter_by(
offererId=user_offerer_id).first()
assert (
response.json["validation"][0] ==
"Aucun(e) objet ne correspond à ce code de validation ou l'objet est déjà validé"
)
assert user_offerer.isValidated
def test_should_not_return_non_cancelled_booking_with_payment(self, app):
# Given
beneficiary = create_user()
create_deposit(user=beneficiary)
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
stock1 = create_stock(beginning_datetime=datetime(2020, 4, 16),
offer=offer)
booking1 = create_booking(stock=stock1,
user=beneficiary,
is_cancelled=False)
payment = create_payment(offerer=offerer, booking=booking1)
repository.save(payment)
# When
bookings_result = get_bookings_cancelled_during_quarantine_with_payment(
)
# Then
assert len(bookings_result) == 0
def when_listing_all_venues_without_venue_id_argument(self, app):
# given
offerer = create_offerer(siren="775671464")
venue = create_venue(offerer,
name="Librairie Titelive",
siret="77567146400110")
titelive_things_provider = get_provider_by_local_class(
"TiteLiveThings")
venue_provider = create_venue_provider(
venue=venue, provider=titelive_things_provider)
repository.save(venue_provider)
user = create_user()
repository.save(user)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
# when
response = auth_request.get("/venueProviders")
# then
assert response.status_code == 400
def should_update_allocine_price_rule_for_venue_with_given_siret(
self, app):
# Given
initial_price = Decimal(7.5)
new_price = Decimal(8)
offerer = create_offerer()
venue = create_venue(offerer)
allocine_provider = create_provider(local_class="TestLocalProvider")
allocine_venue_provider = create_allocine_venue_provider(
venue, allocine_provider)
allocine_venue_provider_price_rule = create_allocine_venue_provider_price_rule(
allocine_venue_provider,
price_rule=PriceRule.default,
price=initial_price)
repository.save(allocine_venue_provider_price_rule)
# When
modify_allocine_price_rule_for_venue_by_siret(venue.siret, new_price)
# Then
assert allocine_venue_provider_price_rule.price == new_price
def when_giving_an_api_key_that_does_not_exists(self, app):
# Given
user = users_factories.UserFactory()
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
stock = create_stock(offer=offer)
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(user_offerer, booking)
# When
url = "/v2/bookings/cancel/token/{}".format(booking.token)
wrong_api_key = "Bearer WrongApiKey1234567"
response = TestClient(app.test_client()).patch(
url,
headers={
"Authorization": wrong_api_key,
"Origin": "http://localhost"
})
assert response.status_code == 401
