def test_should_return_all_user_emails(self, app):
# Given
first_day_after_quarantine = datetime(2020, 4, 16)
today = datetime(2020, 4, 10)
tomorrow = today + timedelta(days=1)
pro = users_factories.ProFactory(email="*****@*****.**")
pro1 = users_factories.ProFactory(email="*****@*****.**")
offerer = create_offerer(siren="123456789")
user_offerer = create_user_offerer(user=pro, offerer=offerer)
venue = create_venue(offerer, siret="1234567899876")
offer = create_offer_with_event_product(venue)
stock = create_stock(beginning_datetime=tomorrow, offer=offer)
offerer1 = create_offerer(siren="987654321")
user_offerer1 = create_user_offerer(user=pro1, offerer=offerer1)
venue1 = create_venue(offerer1, siret="9876543216543")
offer1 = create_offer_with_event_product(venue1)
stock1 = create_stock(beginning_datetime=tomorrow, offer=offer1)
repository.save(stock1, stock, user_offerer, user_offerer1)
# When
pro_emails = fetch_user_emails_for_offers_with_max_stock_date_between_today_and_end_of_quarantine(
first_day_after_quarantine, today)
# Then
assert len(pro_emails) == 2
assert set(pro_emails) == {
"*****@*****.**", "*****@*****.**"
}
def should_book_an_offer_even_if_physical_offer_capping_is_exeeded(
self, mocked_redis, app):
# Given
user = create_user()
deposit = create_deposit(user)
offerer = create_offerer()
venue = create_venue(offerer)
old_offer = create_offer_with_thing_product(
venue, thing_type=ThingType.INSTRUMENT)
old_stock = create_stock(offer=old_offer, price=200)
old_booking = create_booking(user,
stock=old_stock,
amount=old_stock.price)
new_offer = create_offer_with_thing_product(
venue, thing_type=ThingType.LIVRE_EDITION)
new_stock = create_stock(offer=new_offer, price=10)
repository.save(old_booking, new_stock)
# When
create_booking_for_user_on_specific_stock_bypassing_capping_limits(
user.id, new_stock.id)
# Then
assert Booking.query.filter_by(stockId=new_stock.id,
userId=user.id).one() is not None
mocked_redis.add_offer_id.assert_called_once_with(
client=app.redis_client, offer_id=new_offer.id)
def test_should_return_event_beginning_times_in_seconds(self, app):
# Given
in_three_days_at_eighteen_thirty = datetime.utcnow() + timedelta(
days=3)
in_four_days_at_eighteen_thirty = datetime.utcnow() + timedelta(days=4)
in_five_days_at_twenty_one_thirty = datetime.utcnow() + timedelta(
days=5, hours=3, seconds=18)
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer = create_offer_with_event_product(venue=venue)
stock1 = create_stock(
beginning_datetime=in_three_days_at_eighteen_thirty, offer=offer)
stock2 = create_stock(
beginning_datetime=in_five_days_at_twenty_one_thirty, offer=offer)
stock3 = create_stock(
beginning_datetime=in_four_days_at_eighteen_thirty, offer=offer)
repository.save(stock1, stock2, stock3)
# When
result = AlgoliaBackend.serialize_offer(offer)
# Then
eighteen_thirty_in_seconds = 66600
twenty_one_thirty_in_seconds = 77418
assert sorted(result["offer"]["times"]) == sorted(
[eighteen_thirty_in_seconds, twenty_one_thirty_in_seconds])
def test_wallet_balance_does_not_count_cancelled_bookings(self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
deposit1 = create_deposit(user, amount=100)
deposit2 = create_deposit(user, amount=50)
stock1 = create_stock(offer=offer, price=20)
stock2 = create_stock(offer=offer, price=30)
booking1 = create_booking(user=user,
is_cancelled=False,
quantity=1,
stock=stock1,
venue=venue)
booking2 = create_booking(user=user,
is_cancelled=True,
quantity=2,
stock=stock2,
venue=venue)
repository.save(deposit1, deposit2, booking1, booking2)
# when
balance = user.wallet_balance
# then
assert balance == Decimal(130)
def test_should_return_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)
stock2 = create_stock(beginning_datetime=datetime(2020, 4, 16),
offer=offer)
booking1 = create_booking(stock=stock1,
user=beneficiary,
is_cancelled=True)
booking2 = create_booking(stock=stock2,
user=beneficiary,
is_cancelled=True)
payment = create_payment(offerer=offerer, booking=booking1)
repository.save(payment, booking2)
# When
bookings_result = get_bookings_cancelled_during_quarantine_with_payment(
)
# Then
assert bookings_result == [booking1]
def should_not_return_activation_bookings(self, app):
# Given
user = create_user()
create_deposit(user)
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_event_product(
venue, event_type="ThingType.ACTIVATION")
offer2 = create_offer_with_event_product(
venue, event_type="EventType.ACTIVATION")
offer3 = create_offer_with_event_product(venue,
event_type="ThingType.ANY")
stock1 = create_stock(offer=offer1)
stock2 = create_stock(offer=offer2)
stock3 = create_stock(offer=offer3)
booking1 = create_booking(user=user, stock=stock1)
booking2 = create_booking(user=user, stock=stock2)
booking3 = create_booking(user=user, stock=stock3)
repository.save(booking1, booking2, booking3)
# When
result = BeneficiaryBookingsSQLRepository().get_beneficiary_bookings(
beneficiary_id=user.id)
# Then
assert len(result.bookings) == 1
assert result.bookings[0].id == booking3.id
def should_return_get_stocks_information(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue, url="http://url.com")
stock1 = create_stock(
beginning_datetime=datetime(2020, 3, 5),
booking_limit_datetime=datetime(2020, 1, 6),
date_created=datetime(2020, 1, 4),
date_modified=datetime(2020, 1, 7),
offer=offer,
price=0,
)
stock2 = create_stock(
beginning_datetime=datetime(2020, 4, 5),
booking_limit_datetime=datetime(2020, 2, 6),
date_created=datetime(2020, 2, 4),
date_modified=datetime(2020, 2, 7),
offer=offer,
price=12,
)
repository.save(stock1, stock2)
# When
results = _get_stocks_information(offers_ids=[offer.id])
# Then
assert set(results) == {
(
datetime(2020, 1, 4, 0, 0),
datetime(2020, 3, 5, 0, 0),
datetime(2020, 1, 6, 0, 0),
datetime(2020, 1, 7, 0, 0),
offer.id,
None,
0.00,
stock1.id,
False,
True,
),
(
datetime(2020, 2, 4, 0, 0),
datetime(2020, 4, 5, 0, 0),
datetime(2020, 2, 6, 0, 0),
datetime(2020, 2, 7, 0, 0),
offer.id,
None,
12.00,
stock2.id,
False,
True,
),
}
def test_should_delete_objects_when_objects_are_not_eligible_and_were_already_indexed(
self,
mock_build_object,
mock_add_objects,
mock_delete_objects,
mock_add_to_indexed_offers,
mock_check_offer_exists,
mock_delete_indexed_offers,
mock_add_offer_ids_in_error,
app,
):
# Given
client = MagicMock()
client.pipeline = MagicMock()
client.pipeline.return_value = MagicMock()
mock_pipeline = client.pipeline()
mock_pipeline.execute = MagicMock()
mock_pipeline.reset = MagicMock()
offerer = create_offerer(is_active=True, validation_token=None)
venue = create_venue(offerer=offerer, validation_token=None)
offer1 = create_offer_with_thing_product(venue=venue, is_active=True)
stock1 = create_stock(booking_limit_datetime=TOMORROW,
offer=offer1,
quantity=0)
offer2 = create_offer_with_thing_product(venue=venue, is_active=True)
stock2 = create_stock(booking_limit_datetime=TOMORROW,
offer=offer2,
quantity=0)
repository.save(stock1, stock2)
mock_check_offer_exists.side_effect = [True, True]
# When
process_eligible_offers(client=client,
offer_ids=[offer1.id, offer2.id],
from_provider_update=False)
# Then
mock_build_object.assert_not_called()
mock_add_objects.assert_not_called()
mock_add_to_indexed_offers.assert_not_called()
mock_delete_objects.assert_called_once()
assert mock_delete_objects.call_args_list == [
call(object_ids=[humanize(offer1.id),
humanize(offer2.id)])
]
mock_delete_indexed_offers.assert_called_once()
assert mock_delete_indexed_offers.call_args_list == [
call(client=client, offer_ids=[offer1.id, offer2.id])
]
mock_pipeline.execute.assert_not_called()
mock_pipeline.reset.assert_not_called()
mock_add_offer_ids_in_error.assert_not_called()
def test_should_not_return_event_beginning_datetimes_as_timestamp_when_thing(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer = create_offer_with_thing_product(venue=venue)
stock1 = create_stock(offer=offer)
stock2 = create_stock(offer=offer)
repository.save(stock1, stock2)
# When
result = build_object(offer)
# Then
assert result["offer"]["dates"] == []
def test_should_return_the_first_stock_price(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer = create_offer_with_thing_product(venue=venue)
stock1 = create_stock(offer=offer, price=7)
stock2 = create_stock(offer=offer, price=5)
stock3 = create_stock(offer=offer, price=10.3)
repository.save(stock1, stock2, stock3)
# When
result = build_object(offer)
# Then
assert result["offer"]["prices"] == [Decimal("5.00"), Decimal("7.00"), Decimal("10.30")]
def test_create_payment_for_booking_when_iban_is_on_venue_should_take_payment_info_from_venue(
app):
# given
user = create_user()
stock = create_stock(price=10, quantity=5)
offerer = create_offerer(name="Test Offerer")
venue = create_venue(
offerer,
name="Test Venue",
)
booking = create_booking(user=user, quantity=1, stock=stock)
create_bank_information(bic="Lajr93",
iban="B135TGGEG532TG",
offerer=offerer)
create_bank_information(bic="LokiJU76",
iban="KD98765RFGHZ788",
venue=venue)
booking.stock.offer = Offer()
booking.stock.offer.venue = venue
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.iban == "KD98765RFGHZ788"
assert payment.bic == "LOKIJU76"
def test_contains_info_on_offer(self):
# given
user = create_user(email="*****@*****.**", idx=3)
offerer = create_offerer(siren="987654321", name="Joe le Libraire")
venue = create_venue(offerer,
name="Jack le Sculpteur",
siret="1234567891234")
offer = create_offer_with_thing_product(venue)
stock = create_stock(offer=offer, price=12, quantity=5)
booking = create_booking(user=user,
stock=stock,
date_created=datetime(2018, 2, 5),
idx=5,
quantity=2)
payment = create_payment(booking, offerer, 35)
find_date = Mock()
find_date.return_value = datetime(2018, 2, 19)
# when
details = create_payment_details(payment,
find_booking_date_used=find_date)
# then
assert details.offer_name == "Test Book"
assert details.offer_type == "Audiovisuel - films sur supports physiques et VOD"
def test_contains_info_on_venue(self):
# given
user = create_user(email="*****@*****.**", idx=3)
offerer = create_offerer(siren="987654321", name="Joe le Libraire")
venue = create_venue(offerer,
name="Jack le Sculpteur",
siret="1234567891234",
idx=1)
offer = create_offer_with_thing_product(venue)
stock = create_stock(offer=offer, price=12, quantity=5)
booking = create_booking(user=user,
stock=stock,
date_created=datetime(2018, 2, 5),
idx=5,
quantity=2)
payment = create_payment(booking, offerer, 35)
find_date = Mock()
find_date.return_value = datetime(2018, 2, 19)
# when
details = create_payment_details(payment,
find_booking_date_used=find_date)
# then
assert details.venue_name == "Jack le Sculpteur"
assert details.venue_siret == "1234567891234"
assert details.venue_humanized_id == humanize(venue.id)
def test_create_payment_for_booking_with_common_information(app):
# given
user = create_user()
stock = create_stock(price=10, quantity=5)
booking = create_booking(user=user, quantity=1, stock=stock)
booking.stock.offer = Offer()
booking.stock.offer.venue = VenueSQLEntity()
offerer = create_offerer()
create_bank_information(bic="QSDFGH8Z555",
iban="CF13QSDFGH456789",
offerer=offerer)
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.booking == booking
assert payment.amount == Decimal(10)
assert payment.reimbursementRule == ReimbursementRules.PHYSICAL_OFFERS.value.description
assert payment.reimbursementRate == ReimbursementRules.PHYSICAL_OFFERS.value.rate
assert payment.comment is None
assert payment.author == "batch"
assert payment.transactionLabel == "pass Culture Pro - remboursement 2nde quinzaine 10-2018"
def when_the_booking_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)
api_key = "A_MOCKED_API_KEY"
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/FAKETOKEN",
headers={
"Authorization": f"Bearer {api_key}",
"Origin": "http://localhost"
},
)
# Then
assert response.status_code == 404
assert response.json["global"] == [
"Cette contremarque n'a pas été trouvée"
]
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 save_reimbursable_thing_offer(venue: VenueSQLEntity):
paid_reimbursable_offer = create_offer_with_thing_product(
venue, thing_name="Roman cool", thing_type=ThingType.LIVRE_EDITION)
reimbursable_stock = create_stock(offer=paid_reimbursable_offer, price=30)
repository.save(reimbursable_stock)
logger.info("created 1 reimbursable thing offer with 1 paid stock of 30 €")
return reimbursable_stock
def test_titelive_stock_provider_update_1_stock_and_1_offer(self, stub_get_stocks_information, app):
# Given
stub_get_stocks_information.return_value = iter(
[{"ref": "0002730757438", "available": 10, "price": 4500, "validUntil": "2019-10-31T15:10:27Z"}]
)
offerer = create_offerer()
venue = create_venue(offerer, siret="77567146400110")
titelive_stocks_provider = activate_provider("TiteLiveStocks")
venue_provider = create_venue_provider(
venue, titelive_stocks_provider, is_active=True, venue_id_at_offer_provider="77567146400110"
)
product = create_product_with_thing_type(id_at_providers="02730757438")
offer = create_offer_with_thing_product(
venue, product=product, id_at_providers="0002730757438@77567146400110"
)
stock = create_stock(id_at_providers="0002730757438@77567146400110", offer=offer, quantity=10)
repository.save(product, venue_provider, stock)
titelive_stocks = TiteLiveStocks(venue_provider)
# When
titelive_stocks.updateObjects()
# Then
stock = Stock.query.one()
assert stock.quantity == 10
assert Offer.query.count() == 1
def test_delete_venue_and_offers_should_raise_an_attribute_error_when_at_least_one_offer_has_stocks(
self, app):
# Given
offerer = create_offerer(siren="123456789")
venue = create_venue(
offerer,
idx=1,
siret="12345678900002",
address="1 rue Vieille Adresse",
name="Vieux nom",
city="Vieilleville",
latitude="48.863",
longitude="2.36",
postal_code="75001",
)
offer1 = create_offer_with_event_product(venue)
offer2 = create_offer_with_event_product(venue)
stock = create_stock(offer=offer1)
repository.save(offer1, offer2, stock, venue)
# When
with pytest.raises(AttributeError) as e:
delete_venue_and_offers_for_venue_id(humanize(venue.id))
# Then
assert str(
e.value
) == "Offres non supprimables car au moins une contient des stocks"
def test_save_chunks_insert_1_offer_and_1_stock_in_chunk(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
product = create_product_with_thing_subcategory()
repository.save(venue, product)
offer = create_offer_with_thing_product(
venue, product=product, id_at_providers="1%12345678912345")
offer.venueId = venue.id
offer_id = db.session.execute(Sequence("offer_id_seq"))
offer.id = offer_id
stock = create_stock(offer=offer)
stock.offerId = offer_id
chunk_to_insert = {
"1|Offer": offer,
"1|Stock": stock,
}
db.session.expunge(offer)
db.session.expunge(stock)
chunk_to_update = {}
# When
save_chunks(chunk_to_insert, chunk_to_update)
# Then
assert Offer.query.count() == 1
assert Stock.query.count() == 1
def when_user_is_logged_in_and_a_favorite_booked_offer_exist(self, app):
# Given
user = create_user()
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)
favorite = create_favorite(mediation=mediation, offer=offer, user=user)
stock = create_stock(offer=offer, price=0)
booking = create_booking(user=user, stock=stock)
repository.save(booking, favorite)
# When
response = TestClient(app.test_client()).with_auth(user.email).get("/favorites")
# Then
assert response.status_code == 200
assert len(response.json) == 1
favorite = response.json[0]
assert "offer" in favorite
assert "venue" in favorite["offer"]
assert "stocks" in favorite["offer"]
assert stock.price == favorite["offer"]["stocks"][0]["price"]
assert booking.quantity == favorite["booking"]["quantity"]
assert humanize(booking.id) in favorite["booking"]["id"]
assert "validationToken" not in favorite["offer"]["venue"]
def test_should_returns_204_with_lowercase_token(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 = users_factories.UserFactory()
booking = create_booking(user=user, stock=stock, 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
token = booking.token.lower()
response = TestClient(app.test_client()).patch(
"/v2/bookings/cancel/token/{}".format(token),
headers={
"Authorization": "Bearer " + api_key,
"Origin": "http://localhost"
},
)
# Then
assert response.status_code == 204
updated_booking = Booking.query.first()
assert updated_booking.isCancelled
def test_cancel_a_booking_already_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_thing_product(venue)
stock = create_stock(offer=book_offer)
user = users_factories.UserFactory()
booking = create_booking(user=user,
stock=stock,
is_cancelled=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 == 410
assert response.json["global"] == [
"Cette contremarque a déjà été annulée"
]
def test_should_not_revert_booking_dateused_if_booking_already_has_one(
self, stub_get_bookings_cancelled_during_quarantine_with_payment,
app):
# Given
dateused = datetime(2020, 7, 3, 20, 4, 4)
beneficiary = create_user()
create_deposit(user=beneficiary)
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
stock = create_stock(beginning_datetime=datetime(2020, 4, 16),
offer=offer)
booking = create_booking(
stock=stock,
user=beneficiary,
is_cancelled=True,
date_created=datetime(2019, 7, 3, 20, 4, 4),
date_used=dateused,
)
payment = create_payment(offerer=offerer, booking=booking)
repository.save(payment)
stub_get_bookings_cancelled_during_quarantine_with_payment.return_value = [
booking
]
# When
correct_booking_status()
# Then
corrected_booking = Booking.query.get(booking.id)
assert corrected_booking.isCancelled is False
assert corrected_booking.cancellationDate is None
assert corrected_booking.isUsed is True
assert corrected_booking.dateUsed == dateused
def expect_the_booking_to_be_cancelled_by_current_user(self, app):
# Given
in_four_days = datetime.utcnow() + timedelta(days=4)
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
stock = create_stock(beginning_datetime=in_four_days, offer=offer)
booking = create_booking(user=user, stock=stock, venue=venue)
create_deposit(user, amount=500)
repository.save(booking)
# When
response = (TestClient(app.test_client()).with_auth(
user.email).put(f"/bookings/{humanize(booking.id)}/cancel"))
# Then
assert response.status_code == 200
assert Booking.query.get(booking.id).isCancelled
assert response.json == {
"amount": 10.0,
"completedUrl": None,
"id": humanize(booking.id),
"isCancelled": True,
"quantity": booking.quantity,
"stock": {
"price": 10.0
},
"stockId": humanize(stock.id),
"token": booking.token,
}
def test_should_return_empty_isbn_when_product_does_not_contain_isbn(self):
# Given
user = create_user(email="*****@*****.**", public_name="John Doe")
offerer = create_offerer()
venue = create_venue(offerer,
name="Venue name",
address="Venue address")
product = create_product_with_thing_type(
thing_name="Event Name",
thing_type=ThingType.CINEMA_ABO,
extra_data={})
offer = create_offer_with_thing_product(venue,
product=product,
idx=999)
stock = create_stock(offer=offer, price=12)
booking = create_booking(user=user,
quantity=3,
stock=stock,
venue=venue)
# When
response = serialize_booking(booking)
# Then
assert response["ean13"] == ""
def test_fnac_stock_provider_available_stock_is_sum_of_updated_available_and_bookings(
self, mock_fnac_api_response, app
):
# Given
mock_fnac_api_response.return_value = iter([{"ref": "9780199536986", "available": 5, "price": 0}])
offerer = create_offerer()
venue = create_venue(offerer, siret="12345678912345")
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, price=0, quantity=20)
booking = create_booking(user=create_user(), quantity=1, stock=stock)
repository.save(venue_provider, booking)
mock_fnac_api_response.return_value = iter([{"ref": "9780199536986", "available": 66, "price": 0}])
fnac_stocks = FnacStocks(venue_provider)
# When
fnac_stocks.updateObjects()
# Then
stock = Stock.query.one()
assert stock.quantity == 67
def test_create_payment_for_booking_when_no_iban_on_venue_should_take_payment_info_from_offerer(
app):
# given
user = create_user()
stock = create_stock(price=10, quantity=5)
offerer = create_offerer(name="Test Offerer")
venue = create_venue(offerer, name="Test Venue")
create_bank_information(bic="QsdFGH8Z555",
iban="cf13QSDFGH456789",
offerer=offerer)
create_bank_information(bic=None, iban=None, venue=venue)
booking = create_booking(user=user, quantity=1, stock=stock)
booking.stock.offer = Offer()
booking.stock.offer.venue = venue
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.iban == "CF13QSDFGH456789"
assert payment.bic == "QSDFGH8Z555"
def test_create_payment_for_booking_takes_recipient_name_and_siren_from_offerer(
app):
# given
user = create_user()
stock = create_stock(price=10, quantity=5)
booking = create_booking(user=user, quantity=1, stock=stock)
booking.stock.offer = Offer()
offerer = create_offerer(name="Test Offerer", siren="123456789")
venue = create_venue(offerer, name="Test Venue")
create_bank_information(bic="QSDFGH8Z555",
iban="CF13QSDFGH456789",
offerer=offerer)
create_bank_information(bic=None, iban=None, venue=venue)
booking.stock.offer.venue = venue
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.recipientName == "Test Offerer"
assert payment.recipientSiren == "123456789"
def when_the_logged_user_has_not_rights_on_offerer(self, app):
# Given
pro_user = create_user(email="*****@*****.**",
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 = users_factories.UserFactory()
booking = create_booking(user=user, stock=stock, venue=venue)
repository.save(booking, user_offerer)
offerer_with_api_key = create_offerer()
repository.save(offerer_with_api_key)
api_key = random_token(64)
offerer_api_key = create_api_key_for_offerer(
offerer_with_api_key, api_key)
repository.save(offerer_api_key)
# When
response = (TestClient(app.test_client()).with_auth(
user.email).patch("/v2/bookings/cancel/token/{}".format(
booking.token)))
# 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."
]
