def test_search_with_several_partial_keywords_returns_things_and_events_with_name_containing_keywords(
self, app):
# Given
thing_ok = create_product_with_thing_type(
thing_name='Rencontre de michel')
thing_product = create_product_with_thing_type(
thing_name='Rencontre avec jean-luc')
event_product = create_product_with_event_type(
event_name='Rencontre avec jean-mimi chelou')
offerer = create_offerer()
venue = create_venue(offerer)
thing_ok_offer = create_offer_with_thing_product(venue, thing_ok)
thing_ko_offer = create_offer_with_thing_product(venue, thing_product)
event_ko_offer = create_offer_with_event_product(venue, event_product)
event_ko_occurrence = create_event_occurrence(event_ko_offer)
event_ko_stock = create_stock_from_event_occurrence(
event_ko_occurrence)
thing_ok_stock = create_stock_from_offer(thing_ok_offer)
thing_ko_stock = create_stock_from_offer(thing_ko_offer)
PcObject.save(event_ko_stock, thing_ok_stock, thing_ko_stock)
# When
offers = get_offers_for_recommendations_search(
keywords_string='renc michel')
# Then
assert thing_ok_offer in offers
assert thing_ko_offer not in offers
assert event_ko_offer not in offers
def test_create_filter_matching_all_keywords_in_any_models_with_several_keywords_at_just_event_or_just_thing_level(
app):
# given
ok_event1 = create_product_with_event_type(
event_name='Rencontre avec Jacques Martin')
event2 = create_product_with_event_type(
event_name='Concert de contrebasse')
ok_thing1 = create_product_with_thing_type(
thing_name='Rencontre avec vous savez qui',
description='Il s\'agit de Jacques')
thing2 = create_product_with_thing_type(
thing_name='Rencontre avec Belle du Seigneur')
offerer = create_offerer()
venue = create_venue(offerer)
ok_offer1 = create_offer_with_event_product(venue, ok_event1)
ko_offer2 = create_offer_with_event_product(venue, event2)
ok_offer3 = create_offer_with_thing_product(venue, ok_thing1)
ko_offer4 = create_offer_with_thing_product(venue, thing2)
PcObject.save(ok_offer1, ko_offer2, ok_offer3, ko_offer4)
# when
query = filter_offers_with_keywords_string(build_offer_search_base_query(),
'Rencontre Jacques')
# then
found_offers = query.all()
found_offers_id = [found_offer.id for found_offer in found_offers]
assert ok_offer1.id in found_offers_id
assert ko_offer2.id not in found_offers_id
assert ok_offer3.id in found_offers_id
assert ko_offer4.id not in found_offers_id
def test_create_filter_matching_all_keywords_in_any_models_with_several_partial_keywords_at_event_or_thing_or_venue_or_offerer_level(
app):
# given
ok_event1 = create_product_with_event_type(
event_name='Rencontre avec Jacques Martin')
event2 = create_product_with_event_type(
event_name='Concert de contrebasse')
thing1 = create_product_with_thing_type(thing_name='Jacques la fripouille')
thing2 = create_product_with_thing_type(thing_name='Belle du Seigneur')
offerer = create_offerer()
venue1 = create_venue(offerer,
name='Bataclan',
city='Paris',
siret=offerer.siren + '12345')
venue2 = create_venue(offerer,
name='Librairie la Rencontre',
city='Saint Denis',
siret=offerer.siren + '54321')
ok_offer1 = create_offer_with_event_product(venue1, ok_event1)
ko_offer2 = create_offer_with_event_product(venue1, event2)
ok_offer3 = create_offer_with_thing_product(venue2, thing1)
ko_offer4 = create_offer_with_thing_product(venue2, thing2)
PcObject.save(ok_offer1, ko_offer2, ok_offer3, ko_offer4)
# when
query = filter_offers_with_keywords_string(build_offer_search_base_query(),
'Jacq Rencon')
# then
found_offers = query.all()
found_offers_id = [found_offer.id for found_offer in found_offers]
assert ok_offer1.id in found_offers_id
assert ko_offer2.id not in found_offers_id
assert ok_offer3.id in found_offers_id
assert ko_offer4.id not in found_offers_id
def test_compute_first_thumb_dominant_color_even_if_not_first_file(self,
get_thumbs_zip_file_from_ftp,
get_ordered_thumbs_zip_files,
app):
# given
product1 = create_product_with_thing_type(id_at_providers='9780847858903', thumb_count=0)
product2 = create_product_with_thing_type(id_at_providers='9782016261903', thumb_count=0)
PcObject.save(product1, product2)
# mock TiteliveThingThumb
files = get_ordered_zip_thumbs_files_from_sandbox_files()
get_ordered_thumbs_zip_files.return_value = files
zip_files = []
for file in files:
zip_file = get_zip_file_from_sandbox(file)
zip_files.append(zip_file)
get_thumbs_zip_file_from_ftp.side_effect = zip_files
# Import thumbs for existing things
provider_test(app,
TiteLiveThingThumbs,
None,
checkedObjects=2,
createdObjects=0,
updatedObjects=0,
erroredObjects=0,
checkedThumbs=2,
createdThumbs=5,
updatedThumbs=0,
erroredThumbs=0,
Product=0
)
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 test_find_offers_with_filter_parameters_with_partial_keywords_and_filter_by_venue(
app):
user = create_user(email='*****@*****.**')
offerer1 = create_offerer(siren='123456789')
offerer2 = create_offerer(siren='987654321')
ko_offerer3 = create_offerer(siren='123456780')
user_offerer1 = create_user_offerer(user, offerer1)
user_offerer2 = create_user_offerer(user, offerer2)
ok_product_event = create_product_with_event_type(
event_name='Rencontre avec Jacques Martin')
ok_product_thing = create_product_with_thing_type(
thing_name='Rencontrez Jacques Chirac')
event_product2 = create_product_with_event_type(
event_name='Concert de contrebasse')
thing1_product = create_product_with_thing_type(
thing_name='Jacques la fripouille')
thing2_product = create_product_with_thing_type(
thing_name='Belle du Seigneur')
offerer = create_offerer()
venue1 = create_venue(offerer1,
name='Bataclan',
city='Paris',
siret=offerer.siren + '12345')
venue2 = create_venue(offerer2,
name='Librairie la Rencontre',
city='Saint Denis',
siret=offerer.siren + '54321')
ko_venue3 = create_venue(
ko_offerer3,
name='Une librairie du méchant concurrent gripsou',
city='Saint Denis',
siret=ko_offerer3.siren + '54321')
ok_offer1 = create_offer_with_event_product(venue1, ok_product_event)
ok_offer2 = create_offer_with_thing_product(venue1, ok_product_thing)
ko_offer2 = create_offer_with_event_product(venue1, event_product2)
ko_offer3 = create_offer_with_thing_product(ko_venue3, thing1_product)
ko_offer4 = create_offer_with_thing_product(venue2, thing2_product)
PcObject.save(user_offerer1, user_offerer2, ko_offerer3, ok_offer1,
ko_offer2, ko_offer3, ko_offer4)
# when
offers = find_offers_with_filter_parameters(
user, venue_id=venue1.id, keywords_string='Jacq Rencon').all()
# then
offers_id = [offer.id for offer in offers]
assert ok_offer1.id in offers_id
assert ok_offer2.id in offers_id
assert ko_offer2.id not in offers_id
assert ko_offer3.id not in offers_id
assert ko_offer4.id not in offers_id
def test_titelive_stock_provider_create_nothing_if_siret_is_not_in_titelive_database(app):
# given
offerer = create_offerer(siren='987654321')
venue = create_venue(offerer, name='Librairie Titelive', siret='12345678912345')
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 = '12345678912345'
PcObject.save(venue_provider)
product = create_product_with_thing_type(id_at_providers='0002730757438')
offer = create_offer_with_thing_product(venue=venue, product=product)
PcObject.save(product, offer)
# When / Then
provider_test(app,
TiteLiveStocks,
venue_provider,
checkedObjects=0,
createdObjects=0,
updatedObjects=0,
erroredObjects=0,
checkedThumbs=0,
createdThumbs=0,
updatedThumbs=0,
erroredThumbs=0,
Stock=0
)
def test_offer_remaining_stock_filter_filters_offer_with_no_remaining_stock(
app):
# Given
product = create_product_with_thing_type(thing_name='Lire un livre',
is_national=True)
offerer = create_offerer()
venue = create_venue(offerer, postal_code='34000', departement_code='34')
offer = create_offer_with_thing_product(venue, product)
stock = create_stock_from_offer(offer, available=2, price=0)
user = create_user()
booking1 = create_booking(user,
stock,
venue=venue,
quantity=2,
is_cancelled=True)
booking2 = create_booking(user, stock, venue=venue, quantity=2)
PcObject.save(booking1, booking2)
# When
nb_offers_with_remaining_stock = Offer.query \
.join(Stock) \
.filter(_has_remaining_stock_predicate()) \
.count()
# Then
assert nb_offers_with_remaining_stock == 0
def test_thing_offerType_returns_dict_matching_ThingType_enum():
# given
thing_product = create_product_with_thing_type(
thing_type=ThingType.LIVRE_EDITION)
expected_value = {
'conditionalFields': ["author", "isbn"],
'proLabel':
'Livre - format papier ou numérique, abonnements lecture',
'appLabel':
'Livres, cartes bibliothèque ou médiathèque',
'offlineOnly':
False,
'onlineOnly':
False,
'sublabel':
'Lire',
'description':
'S’abonner à un quotidien d’actualité ?'
' À un hebdomadaire humoristique ? '
'À un mensuel dédié à la nature ? '
'Acheter une BD ou un manga ? '
'Ou tout simplement ce livre dont tout le monde parle ?',
'value':
'ThingType.LIVRE_EDITION',
'type':
'Thing'
}
# when
offer_type = thing_product.offerType
# then
assert offer_type == expected_value
def when_user_updating_thing_offer_is_not_linked_to_owning_offerer(
self, app):
# Given
user = create_user(email='*****@*****.**')
owning_offerer = create_offerer(siren='123456789')
editor_offerer = create_offerer(siren='123456780')
editor_user_offerer = create_user_offerer(user, editor_offerer)
venue = create_venue(editor_offerer)
product = create_product_with_thing_type(
thing_name='Old Name', owning_offerer=owning_offerer)
offer = create_offer_with_thing_product(venue, product)
PcObject.save(offer, editor_user_offerer, owning_offerer)
offer_id = offer.id
product_id = product.id
json = {'name': 'New Name'}
# When
response = TestClient(app.test_client()).with_auth(
user.email).patch(f'{API_URL}/offers/{humanize(offer.id)}',
json=json)
# Then
assert response.status_code == 200
assert Offer.query.get(offer_id).name == 'New Name'
assert Product.query.get(product_id).name == 'Old Name'
def test_should_not_return_offers_with_no_stock(app):
# Given
product = create_product_with_thing_type(thing_name='Lire un livre',
is_national=True)
offerer = create_offerer()
venue = create_venue(offerer,
postal_code='34000',
departement_code='34')
offer = create_offer_with_thing_product(venue, product)
stock = create_stock_from_offer(offer, available=2, price=0)
user = create_user()
booking1 = create_booking(user,
stock,
venue=venue,
quantity=2,
is_cancelled=True)
booking2 = create_booking(user, stock, venue=venue, quantity=2)
PcObject.save(booking1, booking2)
# When
offers = get_active_offers(user=create_user(email="*****@*****.**"),
departement_codes=['00'],
offer_id=None)
# Then
assert len(offers) == 0
def when_venue_provider_exists(self, app):
# given
offerer = create_offerer(siren='775671464')
venue = create_venue(offerer,
name='Librairie Titelive',
siret='77567146400110')
PcObject.save(venue)
provider = activate_provider('TiteLiveStocks')
product = create_product_with_thing_type(
id_at_providers='0002730757438')
venue_provider_data = {
'providerId': humanize(provider.id),
'venueId': humanize(venue.id),
'venueIdAtOfferProvider': '77567146400110'
}
user = create_user(is_admin=True, can_book_free_offers=False)
PcObject.save(product, user)
auth_request = TestClient(app.test_client()) \
.with_auth(email=user.email)
# when
response = auth_request.post('/venueProviders',
json=venue_provider_data)
# then
assert response.status_code == 201
json_response = response.json
assert 'id' in json_response
venue_provider_id = json_response['id']
assert json_response['lastSyncDate'] is None
def when_searching_by_date_and_type_and_pagination_not_in_range(
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)
thing_product = create_product_with_thing_type(
thing_name='Lire un livre', is_national=True)
thingOffer = 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(thingOffer, user)
stock = create_stock_from_event_occurrence(event_occurrence)
thing_stock = create_stock(price=12, available=5, offer=thingOffer)
PcObject.save(stock, recommendation, recommendation2, thing_stock)
# When
response = TestClient(app.test_client()).with_auth(
user.email).get(RECOMMENDATION_URL +
'?categories=Lire%2CRegarder&days=1-5&page=2' +
'&date=%s' % strftime(self.now))
# Then
assert response.status_code == 200
assert len(response.json) == 0
def test_date_range_is_empty_if_offer_is_on_a_thing():
# given
offer = Offer()
offer.product = create_product_with_thing_type()
offer.stocks = []
# then
assert offer.dateRange == DateTimes()
def test_filter_query_where_user_is_user_offerer_and_is_validated(app):
# Given
user = create_user(email='*****@*****.**')
offerer1 = create_offerer(siren='123456789')
offerer2 = create_offerer(siren='987654321')
offerer3 = create_offerer(siren='123456780')
user_offerer1 = create_user_offerer(user, offerer1)
user_offerer2 = create_user_offerer(user, offerer2)
event1 = create_product_with_event_type(
event_name='Rencontre avec Jacques Martin')
event2 = create_product_with_event_type(
event_name='Concert de contrebasse')
thing1 = create_product_with_thing_type(thing_name='Jacques la fripouille')
thing2 = create_product_with_thing_type(thing_name='Belle du Seigneur')
venue1 = create_venue(offerer1,
name='Bataclan',
city='Paris',
siret=offerer1.siren + '12345')
venue2 = create_venue(offerer2,
name='Librairie la Rencontre',
city='Saint Denis',
siret=offerer2.siren + '54321')
venue3 = create_venue(offerer3,
name='Une librairie du méchant concurrent gripsou',
city='Saint Denis',
siret=offerer3.siren + '54321')
offer1 = create_offer_with_event_product(venue1, event1)
offer2 = create_offer_with_event_product(venue1, event2)
offer3 = create_offer_with_thing_product(venue2, thing1)
offer4 = create_offer_with_thing_product(venue3, thing2)
PcObject.save(user_offerer1, user_offerer2, offerer3, offer1, offer2,
offer3, offer4)
# When
offers = filter_query_where_user_is_user_offerer_and_is_validated(
Offer.query.join(Venue).join(Offerer), user).all()
# Then
offer_ids = [offer.id for offer in offers]
assert offer1.id in offer_ids
assert offer2.id in offer_ids
assert offer3.id in offer_ids
assert offer4.id not in offer_ids
def test_titelive_stock_provider_create_1_stock_and_1_offer(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"
}
]
}
offerer = create_offerer(siren='775671464')
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)
product = create_product_with_thing_type(id_at_providers='0002730757438')
PcObject.save(product)
# When / Then
provider_test(app,
TiteLiveStocks,
venue_provider,
checkedObjects=2,
createdObjects=2,
updatedObjects=0,
erroredObjects=0,
checkedThumbs=0,
createdThumbs=0,
updatedThumbs=0,
erroredThumbs=0,
Stock=1,
Offer=1
)
offer = Offer.query.one()
assert offer.type == product.type
assert offer.name == product.name
assert offer.description == product.description
assert offer.venue is not None
assert offer.bookingEmail is None
assert offer.extraData == product.extraData
stock = Stock.query.one()
assert stock.bookingLimitDatetime is None
assert stock.available == 10
assert stock.price == 45
def test_thing_offerType_returns_None_if_type_does_not_match_ThingType_enum():
# given
thing_product = create_product_with_thing_type(thing_type='')
# when
offer_type = thing_product.offerType
# then
assert offer_type == None
def when_creating_new_thing_offer(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer, is_virtual=True, siret=None)
thing_product = create_product_with_thing_type()
PcObject.save(user, venue, thing_product, user_offerer)
offerer_id = offerer.id
json = {
'type': 'ThingType.JEUX_VIDEO',
'name': 'Les lapins crétins',
'mediaUrls': ['http://media.url'],
'url': 'http://jeux.fr/offre',
'venueId': humanize(venue.id),
'bookingEmail': '*****@*****.**'
}
# When
response = TestClient(app.test_client()).with_auth(user.email).post(
f'{API_URL}/offers',
json=json)
# Then
assert response.status_code == 201
offer_id = dehumanize(response.json['id'])
offer = Offer.query.filter_by(id=offer_id).first()
assert offer.bookingEmail == '*****@*****.**'
assert response.json['product']['offerType'] == {
'conditionalFields': [],
'description': 'Résoudre l’énigme d’un jeu de piste dans votre ville ? '
'Jouer en ligne entre amis ? '
'Découvrir cet univers étrange avec une manette ?',
'proLabel': 'Jeux vidéo',
'appLabel': 'Jeux vidéo',
'offlineOnly': False,
'onlineOnly': True,
'sublabel': 'Jouer',
'type': 'Thing',
'value': 'ThingType.JEUX_VIDEO'
}
offer_id = dehumanize(response.json['id'])
offer = Offer.query.filter_by(id=offer_id).first()
assert offer.bookingEmail == '*****@*****.**'
assert offer.venueId == venue.id
thing_id = dehumanize(response.json['product']['id'])
thing_product = Product.query.filter_by(id=thing_id).first()
assert thing_product.name == 'Les lapins crétins'
assert offer.type == str(ThingType.JEUX_VIDEO)
assert thing_product.url == 'http://jeux.fr/offre'
assert offer.url == 'http://jeux.fr/offre'
assert offer.isDigital
assert offer.isNational
assert thing_product.isNational
assert offer.product.owningOfferer == Offerer.query.get(offerer_id)
def test_booking_on_thing_is_cancellable(self):
# Given
booking = Booking()
booking.stock = Stock()
booking.stock.offer = Offer()
booking.stock.offer.product = create_product_with_thing_type()
# When
is_cancellable = booking.isUserCancellable
# Then
assert is_cancellable == True
def test_does_not_raise_api_error_when_offerer_cancellation_not_used_and_thing(self):
# Given
booking = Booking()
booking.isUsed = False
booking.stock = Stock()
booking.stock.offer = Offer()
booking.stock.offer.product = create_product_with_thing_type()
# When
check_output = check_booking_is_cancellable(booking, is_user_cancellation=False)
# Then
assert check_output is None
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_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_thing_error_when_thing_type_is_offlineOnly_but_has_url(app):
# Given
thing_product = create_product_with_thing_type(
thing_type=ThingType.JEUX, url='http://mygame.fr/offre')
# When
with pytest.raises(ApiErrors) as errors:
PcObject.save(thing_product)
# Then
assert errors.value.errors['url'] == [
'Une offre de type Jeux (support physique) ne peut pas être numérique'
]
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_create_filter_matching_all_keywords_in_any_models_with_several_partial_keywords_at_mixed_venue_or_offerer_level(
app):
# given
event_product = create_product_with_event_type()
thing_product = create_product_with_thing_type()
offerer1 = create_offerer(name="Marxisme et Compagnie")
offerer2 = create_offerer(name='Test', siren='123456788')
offerer3 = create_offerer(name='Test', siren='123456787')
offerer4 = create_offerer(name='Test', siren='123456786')
ok_venue1 = create_venue(offerer1,
name='Librairie Mimosa',
siret=offerer1.siren + '54321')
ko_venue2 = create_venue(offerer2,
name='Pif et Hercule',
siret=offerer2.siren + '12345')
ko_venue3 = create_venue(offerer3,
name='Librairie la Rencontre',
city='Saint Denis',
siret=offerer3.siren + '54321')
ko_venue4 = create_venue(offerer4,
name='Bataclan',
city='Paris',
siret=offerer4.siren + '12345')
ok_offer1 = create_offer_with_event_product(ok_venue1, event_product)
ko_offer2 = create_offer_with_event_product(ko_venue2, event_product)
ok_offer3 = create_offer_with_thing_product(ok_venue1, thing_product)
ko_offer4 = create_offer_with_thing_product(ko_venue2, thing_product)
ko_offer5 = create_offer_with_event_product(ko_venue3, event_product)
ko_offer6 = create_offer_with_event_product(ko_venue4, event_product)
ko_offer7 = create_offer_with_thing_product(ko_venue3, thing_product)
ko_offer8 = create_offer_with_thing_product(ko_venue4, thing_product)
PcObject.save(ok_offer1, ko_offer2, ok_offer3, ko_offer4, ko_offer5,
ko_offer6, ko_offer7, ko_offer8)
# when
query = filter_offers_with_keywords_string(build_offer_search_base_query(),
'Libra Marx')
# then
found_offers = query.all()
found_offers_id = [found_offer.id for found_offer in found_offers]
assert ok_offer1.id in found_offers_id
assert ko_offer2.id not in found_offers_id
assert ok_offer3.id in found_offers_id
assert ko_offer4.id not in found_offers_id
assert ko_offer5.id not in found_offers_id
assert ko_offer6.id not in found_offers_id
assert ko_offer7.id not in found_offers_id
assert ko_offer8.id not in found_offers_id
def test_only_update_thing_when_known_id_at_providers_in_given_zip_file(
self, app):
# given
filename = 'tests/local_providers/Resume-full_01012019.zip'
thing_1 = create_product_with_thing_type(
id_at_providers='1234567029006')
thing_2 = create_product_with_thing_type(
id_at_providers='9782711029006')
thing_3 = create_product_with_thing_type(
id_at_providers='3760107140005')
init_titelive_thing_descriptions = InitTiteLiveThingDescriptions(
filename)
init_titelive_thing_descriptions.dbObject.isActive = True
PcObject.save(thing_1, thing_2, thing_3,
init_titelive_thing_descriptions.dbObject)
# when
init_titelive_thing_descriptions.updateObjects()
# then
assert init_titelive_thing_descriptions.checkedObjects == 2
assert init_titelive_thing_descriptions.updatedObjects == 2
def test_search_with_accents_matches_offer_without_accents_2(self, app):
# Given
thing_ok = create_product_with_thing_type(thing_name='Déjà')
offerer = create_offerer()
venue = create_venue(offerer)
thing_ok_offer = create_offer_with_thing_product(venue, thing_ok)
thing_ok_stock = create_stock_from_offer(thing_ok_offer)
PcObject.save(thing_ok_stock)
# When
offers = get_offers_for_recommendations_search(keywords_string='deja')
#
assert thing_ok_offer in offers
def test_search_by_one_thing_type_returns_only_offers_on_things_of_that_type(
self, app):
# Given
type_label_ok = ThingType.JEUX_VIDEO
type_label_ko = ThingType.LIVRE_EDITION
thing_ok1 = create_product_with_thing_type(thing_type=type_label_ok)
thing_ok2 = create_product_with_thing_type(thing_type=type_label_ok)
thing_ko = create_product_with_thing_type(thing_type=type_label_ko)
event_ko = create_product_with_event_type(event_type=EventType.CINEMA)
offerer = create_offerer()
venue = create_venue(offerer)
ok_offer_1 = create_offer_with_thing_product(venue, thing_ok1)
ok_offer_2 = create_offer_with_thing_product(venue, thing_ok2)
ko_offer = create_offer_with_thing_product(venue, thing_ko)
ko_event_offer = create_offer_with_event_product(venue, event_ko)
ko_event_occurrence = create_event_occurrence(ko_event_offer)
ok_stock1 = create_stock_from_offer(ok_offer_1)
ok_stock2 = create_stock_from_offer(ok_offer_2)
ko_stock1 = create_stock_from_offer(ko_offer)
ko_stock2 = create_stock_from_event_occurrence(ko_event_occurrence)
PcObject.save(ok_stock1, ok_stock2, ko_stock1, ko_stock2)
# When
offers = get_offers_for_recommendations_search(
type_values=[str(type_label_ok)], )
# Then
assert len(offers) == 2
assert ok_offer_1 in offers
assert ok_offer_2 in offers
def test_find_offers_by_venue_id_return_offers_matching_venue_id(app):
# Given
product = create_product_with_thing_type(thing_name='Lire un livre',
is_national=True)
offerer = create_offerer()
venue = create_venue(offerer, postal_code='34000', departement_code='34')
offer = create_offer_with_thing_product(venue, product)
PcObject.save(offer)
# When
offers = find_offers_by_venue_id(venue.id)
# Then
assert len(offers) == 1
assert offers[0].venueId == venue.id
def test_create_filter_matching_all_keywords_in_any_models_with_several_partial_keywords_at_venue_public_name_level(
app):
# given
event = create_product_with_event_type()
thing = create_product_with_thing_type()
ok_offerer1 = create_offerer(name="La Rencontre")
offerer2 = create_offerer(siren='123456788')
offerer3 = create_offerer(siren='123456787')
offerer4 = create_offerer(siren='123456786')
ok_venue1 = create_venue(ok_offerer1,
siret=ok_offerer1.siren + '54321',
publicName='Un lieu trop chouette de ouf')
venue2 = create_venue(offerer2, siret=offerer2.siren + '12345')
ok_venue3 = create_venue(offerer3,
name='Librairie la Rencontre',
city='Saint Denis',
siret=offerer3.siren + '54321',
publicName='chouette endroit de ouf')
venue4 = create_venue(offerer4,
name='Bataclan',
city='Paris',
siret=offerer4.siren + '12345')
ok_offer1 = create_offer_with_event_product(ok_venue1, event)
ko_offer2 = create_offer_with_event_product(venue2, event)
ok_offer3 = create_offer_with_thing_product(ok_venue1, thing)
ko_offer4 = create_offer_with_thing_product(venue2, thing)
ok_offer5 = create_offer_with_event_product(ok_venue3, event)
ko_offer6 = create_offer_with_event_product(venue4, event)
ok_offer7 = create_offer_with_thing_product(ok_venue3, thing)
ko_offer8 = create_offer_with_thing_product(venue4, thing)
PcObject.save(ok_offer1, ko_offer2, ok_offer3, ko_offer4, ok_offer5,
ko_offer6, ok_offer7, ko_offer8)
# when
query = filter_offers_with_keywords_string(build_offer_search_base_query(),
'chou ou')
# then
found_offers = query.all()
found_offers_id = [found_offer.id for found_offer in found_offers]
assert ok_offer1.id in found_offers_id
assert ko_offer2.id not in found_offers_id
assert ok_offer3.id in found_offers_id
assert ko_offer4.id not in found_offers_id
assert ok_offer5.id in found_offers_id
assert ko_offer6.id not in found_offers_id
assert ok_offer7.id in found_offers_id
assert ko_offer8.id not in found_offers_id
