def test_returns_a_tuple_of_pending_and_not_processable_payments(
self, app):
# Given
offerer1 = create_offerer(siren='123456789')
offerer2 = create_offerer(siren='987654321')
PcObject.save(offerer1)
bank_information = create_bank_information(
bic='BDFEFR2LCCB',
iban='FR7630006000011234567890189',
id_at_providers='123456789',
offerer=offerer1)
venue1 = create_venue(offerer1, siret='12345678912345')
venue2 = create_venue(offerer2, siret='98765432154321')
offer1 = create_offer_with_thing_product(venue1)
offer2 = create_offer_with_thing_product(venue2)
paying_stock1 = create_stock_from_offer(offer1)
paying_stock2 = create_stock_from_offer(offer2)
free_stock1 = create_stock_from_offer(offer1, price=0)
user = create_user()
deposit = create_deposit(user, amount=500)
booking1 = create_booking(user,
paying_stock1,
venue1,
is_used=True)
booking2 = create_booking(user,
paying_stock1,
venue1,
is_used=True)
booking3 = create_booking(user,
paying_stock2,
venue2,
is_used=True)
booking4 = create_booking(user, free_stock1, venue1, is_used=True)
PcObject.save(deposit, booking1, booking2, booking3, booking4,
bank_information)
# When
pending, not_processable = generate_new_payments()
# Then
assert len(pending) == 2
assert len(not_processable) == 1
def when_read_recommendations_are_given(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
user = create_user(email='*****@*****.**')
event_occurrence1 = create_event_occurrence(offer)
event_occurrence2 = create_event_occurrence(offer)
stock1 = create_stock_from_event_occurrence(event_occurrence1, soft_deleted=True)
stock2 = create_stock_from_event_occurrence(event_occurrence2, soft_deleted=False)
thing_offer1 = create_offer_with_thing_product(venue)
thing_offer2 = create_offer_with_thing_product(venue)
stock3 = create_stock_from_offer(thing_offer1, soft_deleted=True)
stock4 = create_stock_from_offer(thing_offer2, soft_deleted=False)
recommendation1 = create_recommendation(offer, user)
recommendation2 = create_recommendation(thing_offer1, user)
recommendation3 = create_recommendation(thing_offer2, user)
PcObject.save(
stock1, stock2, stock3, stock4,
recommendation1, recommendation2, recommendation3
)
read_recommendation_data = [
{
"dateRead": "2018-12-17T15:59:11.689000Z",
"id": humanize(recommendation1.id)
},
{
"dateRead": "2018-12-17T15:59:14.689000Z",
"id": humanize(recommendation2.id)
}
]
# When
response = TestClient(app.test_client()).with_auth('*****@*****.**') \
.put('{}/read'.format(RECOMMENDATION_URL), json=read_recommendation_data)
# Then
read_recommendation_date_reads = [r['dateRead'] for r in response.json]
assert len(read_recommendation_date_reads) == 2
assert {"2018-12-17T15:59:11.689000Z", "2018-12-17T15:59:14.689000Z"} == set(read_recommendation_date_reads)
def save_sandbox():
offerer = create_offerer()
venue = create_venue(offerer, is_virtual=True, siret=None)
offer = create_offer_with_thing_product(venue,
thing_type=ThingType.ACTIVATION)
stock = create_stock_with_thing_offer(offerer,
venue,
offer=offer,
price=0,
available=10000)
PcObject.save(stock)
def test_returns_has_physical_venues_and_has_offers(self, app):
# given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
offerer2 = create_offerer(siren='123456788')
user_offerer = create_user_offerer(user, offerer)
user_offerer2 = create_user_offerer(user, offerer2)
offerer_virtual_venue = create_venue(offerer, is_virtual=True, siret=None)
offerer2_physical_venue = create_venue(offerer2, siret='12345678856734')
offerer2_virtual_venue = create_venue(offerer, is_virtual=True, siret=None)
offer = create_offer_with_thing_product(offerer_virtual_venue, thing_type=ThingType.JEUX_VIDEO_ABO, url='http://fake.url')
offer2 = create_offer_with_thing_product(offerer2_physical_venue)
PcObject.save(offer, offer2, offerer2_virtual_venue, user_offerer, user_offerer2)
# when
response = TestClient(app.test_client()).with_auth('*****@*****.**').get('/users/current')
# Then
assert response.json['hasPhysicalVenues'] is True
assert response.json['hasOffers'] is True
def test_thing_offer_offerType_returns_None_if_type_does_not_match_ThingType_enum(
):
# given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue, thing_type='')
# when
offer_type = offer.offerType
# then
assert offer_type == None
def test_stock_can_have_an_available_stock_equal_to_zero(app):
# given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, available=0)
# when
PcObject.save(stock)
# then
assert stock.available == 0
def test_should_return_zero_bookings_if_they_are_on_activation_offers(self, app):
# Given
offerer = create_offerer(name='Offerer dans le 93')
venue = create_venue(offerer, departement_code='93')
offer1 = create_offer_with_thing_product(venue, thing_type=ThingType.ACTIVATION)
offer2 = create_offer_with_thing_product(venue, thing_type=EventType.ACTIVATION)
stock1 = create_stock(offer=offer1, price=10)
stock2 = create_stock(offer=offer2, price=10)
user_in_93 = create_user(departement_code='93')
create_deposit(user_in_93, amount=500)
booking1 = create_booking(user_in_93, stock1, quantity=1)
booking2 = create_booking(user_in_93, stock2, quantity=1)
PcObject.save(booking1, booking2)
# When
bookings_by_departement = _query_get_non_cancelled_bookings_by_user_departement()
# Then
print(bookings_by_departement)
assert len(bookings_by_departement) == 0
def test_offer_is_neither_event_nor_thing(self):
# Given
event_product = Product()
offerer = create_offerer()
digital_venue = create_venue(offerer, is_virtual=False, siret=None)
# When
offer = create_offer_with_thing_product(digital_venue, event_product)
# Then
assert offer.isEvent == False
assert offer.isThing == False
def _create_and_save_stock_for_offererer_in_departements(
offerer: Offerer, departement_codes: List[str]) -> Stock:
stock_list = []
for i, departement_code in enumerate(departement_codes):
siret = f'{offerer.siren}{99999 - i}'
venue = create_venue(offerer,
postal_code="{:<5}".format(departement_code),
siret=siret)
offer = create_offer_with_thing_product(venue)
stock = create_stock(offer=offer, available=10)
stock_list.append(stock)
return stock_list
def _create_departement_booking_for_users(departement_code, user_email, booking_count, siren):
user_having_booked = create_user(departement_code=departement_code, email=user_email)
offerer = create_offerer(siren=siren)
venue = create_venue(offerer, siret=siren + '12345')
offer = create_offer_with_thing_product(venue)
stock = create_stock(offer=offer, price=0)
for i in range(booking_count):
create_booking(user_having_booked, stock, is_cancelled=False)
PcObject.save(stock)
def test_titelive_stock_provider_create_2_stock_and_2_offer_even_if_existing_offer_on_same_product(get_data, app):
# given
get_data.return_value = {
'total': 'null',
'limit': 5000,
'stocks': [
{
"ref": "0002730757438",
"available": 10,
"price": 4500,
"validUntil": "2019-10-31T15:10:27Z"
},
{
"ref": "0002736409898",
"available": 2,
"price": 100,
"validUntil": "2019-10-31T15:10:27Z"
}
]
}
offerer = create_offerer(siren='987654321')
venue = create_venue(offerer, name='Librairie Titelive', siret='77567146400110')
PcObject.save(venue)
tite_live_things_provider = get_provider_by_local_class('TiteLiveThings')
venue_provider = VenueProvider()
venue_provider.venue = venue
venue_provider.provider = tite_live_things_provider
venue_provider.isActive = True
venue_provider.venueIdAtOfferProvider = '77567146400110'
PcObject.save(venue_provider)
thing_1 = create_product_with_thing_type(id_at_providers='0002730757438')
thing_2 = create_product_with_thing_type(id_at_providers='0002736409898')
offer = create_offer_with_thing_product(venue=venue, product=thing_1, id_at_providers="not_titelive")
PcObject.save(thing_1, offer, thing_2)
# When / Then
provider_test(app,
TiteLiveStocks,
venue_provider,
checkedObjects=4,
createdObjects=4,
updatedObjects=0,
erroredObjects=0,
checkedThumbs=0,
createdThumbs=0,
updatedThumbs=0,
erroredThumbs=0,
Stock=2,
Offer=2
)
def save_non_reimbursable_thing_offer(venue: Venue):
paid_non_reimbursable_offer = create_offer_with_thing_product(
venue,
thing_name='Concert en ligne',
thing_type=ThingType.JEUX_VIDEO,
url='http://my.game.fr')
non_reimbursable_stock = create_stock(price=30,
offer=paid_non_reimbursable_offer)
PcObject.save(non_reimbursable_stock)
logger.info(
'created 1 non reimbursable thing offer with 1 paid stock of 30 €')
return non_reimbursable_stock
def _create_bookings_with_quantities(quantities: List[int]):
siren = 111111111
bookings = []
for i, quantity in enumerate(quantities):
offerer = create_offerer(siren=str(siren), name=f'Offerer {i}')
venue = create_venue(offerer, siret=offerer.siren + '12345')
offer = create_offer_with_thing_product(venue, thing_name=f'{i}')
stock = create_stock(offer=offer, price=0, available=1000)
user = create_user(email=f'{i}@mail.com')
bookings.append(create_booking(user, stock, quantity=quantity))
siren += 1
return bookings
def test_remaining_quantity_for_stock_is_2_when_there_is_no_booking(app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, available=2, price=0)
# When
PcObject.save(stock)
# Then
assert Stock.query.get(stock.id).remainingQuantity == 2
def test_file_has_hexadecimal_uuids_as_end_to_end_ids_in_transaction_info(
self, mocked_uuid, app):
# Given
user = create_user()
offerer1 = create_offerer(name='first offerer')
offerer2 = create_offerer(name='second offerer')
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
stock1 = create_stock_from_offer(
create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(
create_offer_with_thing_product(venue2))
booking1 = create_booking(user, stock1)
booking2 = create_booking(user, stock2)
uuid1 = UUID(hex='abcd1234abcd1234abcd1234abcd1234', version=4)
uuid2 = UUID(hex='cdef5678cdef5678cdef5678cdef5678', version=4)
mocked_uuid.side_effect = [uuid1, uuid2]
payments = [
create_payment(booking1,
offerer1,
Decimal(10),
iban='CF13QSDFGH456789',
bic='QSDFGH8Z555'),
create_payment(booking2,
offerer1,
Decimal(20),
iban='FR14WXCVBN123456',
bic='WXCVBN7B444'),
]
# When
xml = generate_message_file(payments, 'BD12AZERTY123456',
'AZERTY9Q666', MESSAGE_ID, '0000')
# Then
nodes_id = find_all_nodes(
'//ns:PmtInf/ns:CdtTrfTxInf/ns:PmtId/ns:EndToEndId', xml)
assert nodes_id[0] == uuid1.hex
assert nodes_id[1] == uuid2.hex
def when_a_recommendation_is_requested(self, app):
# given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_thing_product(venue, thumb_count=1)
offer2 = create_offer_with_event_product(venue, thumb_count=1)
offer3 = create_offer_with_thing_product(venue, thumb_count=1)
offer4 = create_offer_with_thing_product(venue, thumb_count=1)
now = datetime.utcnow()
event_occurrence = create_event_occurrence(offer2, beginning_datetime=now + timedelta(hours=72),
end_datetime=now + timedelta(hours=74))
mediation = create_mediation(offer2)
stock1 = create_stock_from_offer(offer1, price=0)
stock2 = create_stock_from_event_occurrence(event_occurrence, price=0, available=10, soft_deleted=False,
booking_limit_date=now + timedelta(days=3))
stock3 = create_stock_from_offer(offer3, price=0)
stock4 = create_stock_from_offer(offer4, price=0)
PcObject.save(user, stock1, stock2, stock3, stock4, mediation)
offer1_id = offer1.id
offer2_id = offer2.id
offer3_id = offer3.id
offer4_id = offer4.id
auth_request = TestClient(app.test_client()).with_auth(user.email)
# when
response = auth_request.put(RECOMMENDATION_URL + '?offerId=%s' % humanize(offer1.id),
json={'seenRecommendationIds': []})
# then
assert response.status_code == 200
response_json = response.json
assert len(response_json) == 4
offer_ids = set(map(lambda x: x['offer']['id'], response_json))
assert response_json[0]['offer']['id'] == humanize(offer1_id)
assert humanize(offer1_id) in offer_ids
assert humanize(offer2_id) in offer_ids
assert humanize(offer3_id) in offer_ids
assert humanize(offer4_id) in offer_ids
def test_nOffers_with_two_venue_providers_from_different_providers(app):
# given
provider1 = Provider()
provider1.name = 'Open Agenda'
provider1.localClass = 'OpenAgenda'
provider1.isActive = True
provider1.enabledForPro = True
provider2 = Provider()
provider2.name = 'TiteLive'
provider2.localClass = 'TiteLive'
provider2.isActive = True
provider2.enabledForPro = True
PcObject.save(provider1, provider2)
offerer = create_offerer()
venue = create_venue(offerer)
venue_provider1 = create_venue_provider(venue, provider1)
venue_provider2 = create_venue_provider(venue, provider2)
offer_1 = create_offer_with_thing_product(venue,
last_provider_id=provider1.id,
id_at_providers='offer1')
offer_2 = create_offer_with_event_product(venue,
last_provider_id=provider2.id,
id_at_providers='offer2')
offer_3 = create_offer_with_event_product(venue,
last_provider_id=provider1.id,
id_at_providers='offer3')
offer_4 = create_offer_with_thing_product(venue,
last_provider_id=provider1.id,
id_at_providers='offer4')
PcObject.save(offer_1, offer_2, offer_3, offer_4, venue_provider1,
venue_provider2)
# when
n_offers_for_venue_provider1 = venue_provider1.nOffers
n_offers_for_venue_provider2 = venue_provider2.nOffers
# then
assert n_offers_for_venue_provider1 == 3
assert n_offers_for_venue_provider2 == 1
def test_model_should_have_thumbUrl_using_productId(get_storage_base_url):
# given
product = create_product_with_thing_type()
product.id = 2
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer = create_offer_with_thing_product(product=product, venue=venue)
# when
recommendation = create_recommendation(offer)
# then
assert recommendation.thumbUrl == "http://localhost/storage/thumbs/products/A9"
def test_does_not_call_save_thumb(self, save_thumb_mock, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
mediation = create_mediation(offer, tuto_index=0)
PcObject.save(mediation)
# When
_upsert_tuto_mediation(0)
# Then
save_thumb_mock.assert_not_called()
def test_raises_error_with_end_datetime_only(self):
# Given
offer = create_offer_with_thing_product(Venue())
data = {'endDatetime': serialize(datetime(2019, 2, 14))}
# When
with pytest.raises(ApiErrors) as e:
check_dates_are_allowed_on_existing_stock(data, offer)
# Then
assert e.value.errors['global'] == [
'Impossible de mettre des dates de début et fin si l\'offre ne porte pas sur un évenement'
]
def test_full_reimburses_book_product_when_bookings_are_below_20000_euros(
self, app):
# Given
offerer1 = create_offerer(siren='123456789')
PcObject.save(offerer1)
bank_information = create_bank_information(
bic='BDFEFR2LCCB',
iban='FR7630006000011234567890189',
id_at_providers='123456789',
offerer=offerer1)
venue1 = create_venue(offerer1, siret='12345678912345')
venue2 = create_venue(offerer1, siret='98765432154321')
offer1 = create_offer_with_thing_product(
venue1, thing_type=ThingType.LIVRE_EDITION, url=None)
offer2 = create_offer_with_thing_product(
venue2, thing_type=ThingType.LIVRE_EDITION, url=None)
paying_stock1 = create_stock_from_offer(offer1, price=10000)
paying_stock2 = create_stock_from_offer(offer2, price=19990)
user = create_user()
deposit = create_deposit(user, amount=50000)
booking1 = create_booking(user,
paying_stock1,
venue1,
quantity=1,
is_used=True)
booking2 = create_booking(user,
paying_stock2,
venue2,
quantity=1,
is_used=True)
PcObject.save(deposit, booking1, booking2, bank_information)
# When
pending, not_processable = generate_new_payments()
# Then
assert len(pending) == 2
assert len(not_processable) == 0
assert sum(p.amount for p in pending) == 29990
def create_n_mixed_offers_with_same_venue(venue, n=10):
offers = []
for i in range(n // 2, 0, -1):
date_created = datetime.utcnow() - timedelta(days=i)
offers.append(
create_offer_with_thing_product(venue,
date_created=date_created,
thing_name='Thing Offer %s' % i))
offers.append(
create_offer_with_event_product(venue,
event_name='Event Offer %s' % i,
date_created=date_created))
return offers
def test_offer_is_marked_as_isevent_property(self):
# Given
physical_thing = create_product_with_thing_type(
thing_type=ThingType.JEUX_VIDEO, url=None)
offerer = create_offerer()
digital_venue = create_venue(offerer, is_virtual=True, siret=None)
# When
offer = create_offer_with_thing_product(digital_venue, physical_thing)
# Then
assert offer.isEvent == False
assert offer.isThing == True
def test_offer_is_marked_as_isthing_property(self):
# Given
event_product = create_product_with_event_type(
event_type=EventType.CINEMA)
offerer = create_offerer()
digital_venue = create_venue(offerer, is_virtual=False, siret=None)
# When
offer = create_offer_with_thing_product(digital_venue, event_product)
# Then
assert offer.isEvent == True
assert offer.isThing == False
def when_updating_read_recommendations(self, app):
# given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
user = create_user()
event_occurrence1 = create_event_occurrence(offer)
event_occurrence2 = create_event_occurrence(offer)
stock1 = create_stock_from_event_occurrence(event_occurrence1)
stock2 = create_stock_from_event_occurrence(event_occurrence2)
thing_offer1 = create_offer_with_thing_product(venue)
thing_offer2 = create_offer_with_thing_product(venue)
stock3 = create_stock_from_offer(thing_offer1)
stock4 = create_stock_from_offer(thing_offer2)
recommendation1 = create_recommendation(offer, user)
recommendation2 = create_recommendation(thing_offer1, user)
recommendation3 = create_recommendation(thing_offer2, user)
PcObject.save(stock1, stock2, stock3, stock4, recommendation1, recommendation2, recommendation3)
auth_request = TestClient(app.test_client()).with_auth(user.email)
reads = [
{"id": humanize(recommendation1.id), "dateRead": "2018-12-17T15:59:11.689000Z"},
{"id": humanize(recommendation2.id), "dateRead": "2018-12-17T15:59:15.689000Z"},
{"id": humanize(recommendation3.id), "dateRead": "2018-12-17T15:59:21.689000Z"},
]
data = {'readRecommendations': reads}
# when
response = auth_request.put(RECOMMENDATION_URL, json=data)
# then
assert response.status_code == 200
assert recommendation1.dateRead is None
assert recommendation2.dateRead is None
assert recommendation3.dateRead is None
unread_recos = Recommendation.query.filter(Recommendation.dateRead != None).all()
assert len(unread_recos) == 3
def test_stock_cannot_have_a_negative_available_stock(app):
# given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, available=-4)
# when
with pytest.raises(ApiErrors) as e:
PcObject.save(stock)
# then
assert e.value.errors['available'] == ["Le stock doit être positif"]
def test_stock_cannot_have_a_negative_price(app):
# given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, price=-10)
# when
with pytest.raises(ApiErrors) as e:
PcObject.save(stock)
# then
assert e.value.errors['global'] is not None
def test_file_has_control_sum_in_payment_info(self, app):
# Given
user = create_user()
offerer1 = create_offerer()
offerer2 = create_offerer()
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
stock1 = create_stock_from_offer(
create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(
create_offer_with_thing_product(venue2))
booking1 = create_booking(user, stock1)
booking2 = create_booking(user, stock2)
payments = [
create_payment(booking1,
offerer1,
Decimal(10),
iban='CF13QSDFGH456789',
bic='QSDFGH8Z555'),
create_payment(booking1,
offerer1,
Decimal(20),
iban='CF13QSDFGH456789',
bic='QSDFGH8Z555'),
create_payment(booking2,
offerer2,
Decimal(30),
iban=None,
bic=None)
]
# When
xml = generate_message_file(payments, 'BD12AZERTY123456',
'AZERTY9Q666', MESSAGE_ID, '0000')
# Then
assert find_node('//ns:PmtInf/ns:CtrlSum', xml) == '30', \
'The control sum should match the total amount of money to pay'
def when_searching_by_date_and_date_range_and_type(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(
venue, event_name='The new film', event_type=EventType.CINEMA)
offer2 = create_offer_with_event_product(
venue,
event_name='Spectacle',
event_type=EventType.SPECTACLE_VIVANT)
thing_product = create_product_with_thing_type(
thing_name='Lire un livre', is_national=True)
thing_offer = create_offer_with_thing_product(venue, thing_product)
event_occurrence = create_event_occurrence(
offer,
beginning_datetime=self.three_days_from_now,
end_datetime=self.three_days_and_one_hour_from_now)
recommendation = create_recommendation(offer, user)
recommendation2 = create_recommendation(thing_offer, user)
recommendation3 = create_recommendation(offer2, user)
stock = create_stock_from_event_occurrence(event_occurrence)
stock1 = create_stock_from_offer(offer2)
thing_stock = create_stock(price=12,
available=5,
offer=thing_offer)
PcObject.save(stock, recommendation, recommendation2,
recommendation3, thing_stock, stock1)
# When
response = TestClient(app.test_client()).with_auth(
user.email).get(RECOMMENDATION_URL +
'?categories=Lire%2CRegarder' +
'&date=%s&days=1-5' % strftime(self.now))
# Then
assert response.status_code == 200
recommendations = response.json
assert len(recommendations) == 2
recommendation_names = [
recommendation['offer']['product']['name']
for recommendation in recommendations
]
assert 'The new film' in recommendation_names
assert 'Lire un livre' in recommendation_names
assert 'Spectacle' not in recommendation_names
def test_filter_out_recommendation_with_not_bookable_stocks_returns_recos_with_valid_booking_date(
app):
# Given
one_day_ago = datetime.utcnow() - timedelta(days=1)
tomorrow = datetime.utcnow() + timedelta(days=1)
offerer = create_offerer()
venue = create_venue(offerer)
user = create_user()
invalid_booking_date_offer = create_offer_with_thing_product(venue)
valid_booking_date_offer = create_offer_with_thing_product(venue)
invalid_booking_date_stock = create_stock_from_offer(
invalid_booking_date_offer, booking_limit_datetime=one_day_ago)
valid_booking_date_stock_valid = create_stock_from_offer(
valid_booking_date_offer, booking_limit_datetime=tomorrow)
valid_booking_date_stock_invalid = create_stock_from_offer(
valid_booking_date_offer, booking_limit_datetime=one_day_ago)
recommendation_on_invalid_booking_date_stock = create_recommendation(
invalid_booking_date_offer, user)
recommendation_on_valid_booking_date_stock = create_recommendation(
valid_booking_date_offer, user)
PcObject.save(invalid_booking_date_stock,
recommendation_on_invalid_booking_date_stock,
recommendation_on_valid_booking_date_stock,
valid_booking_date_stock_valid,
valid_booking_date_stock_invalid)
# When
result = keep_only_bookable_stocks().all()
# Then
recommendation_ids = [r.id for r in result]
assert len(recommendation_ids) == 1
assert recommendation_on_valid_booking_date_stock.id in recommendation_ids
