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 when_mediation_id_is_given(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
mediation1 = create_mediation(offer)
mediation2 = create_mediation(offer)
user = create_user(email='*****@*****.**')
recommendation1 = create_recommendation(offer,
user,
mediation=mediation1)
recommendation2 = create_recommendation(offer,
user,
mediation=mediation2)
PcObject.save(recommendation1, recommendation2)
# When
path = '/recommendations/offers/{}?mediationId={}'.format(
humanize(offer.id), humanize(recommendation1.mediationId))
response = TestClient(app.test_client()) \
.with_auth(email='*****@*****.**') \
.get(path)
# Then
assert response.status_code == 200
assert response.json['id'] == humanize(recommendation1.id)
assert response.json['offerId'] == humanize(offer.id)
assert response.json['mediationId'] == humanize(mediation1.id)
assert response.json['offer']['product']['offerType'][
'proLabel'] == 'Spectacle vivant'
def when_searching_by_type_with_two_types(self, app):
# given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_event_product(
venue, event_name='Training in Modern Jazz')
offer2 = create_offer_with_event_product(
venue,
event_name='Training in Modern Jazz',
event_type=EventType.CINEMA)
recommendation = create_recommendation(offer1, user)
recommendation2 = create_recommendation(offer2, user)
stock = create_stock_from_offer(
offer1,
beginning_datetime=TEN_DAYS_FROM_NOW,
end_datetime=TWENTY_DAYS_FROM_NOW)
stock2 = create_stock_from_offer(
offer2,
beginning_datetime=TEN_DAYS_FROM_NOW,
end_datetime=TWENTY_DAYS_FROM_NOW)
PcObject.save(stock, recommendation, stock2, recommendation2)
# when
response = TestClient(app.test_client()).with_auth(
user.email).get(RECOMMENDATION_URL +
'?categories=Applaudir%2CRegarder')
# then
assert response.status_code == 200
assert len(response.json) == 2
def when_mediation_is_deactivated(self, app):
# given
user_pro = create_user()
other_user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
user_offerer = create_user_offerer(user_pro, offerer)
mediation1 = create_mediation(offer)
mediation2 = create_mediation(offer)
original_validity_date = datetime.utcnow() + timedelta(days=7)
recommendation1 = create_recommendation(
offer,
user_pro,
mediation1,
valid_until_date=original_validity_date)
recommendation2 = create_recommendation(
offer,
other_user,
mediation1,
valid_until_date=original_validity_date)
other_recommendation = create_recommendation(
offer,
other_user,
mediation2,
valid_until_date=original_validity_date)
PcObject.save(other_user, user_offerer, recommendation1,
recommendation2, other_recommendation)
mediation1_id = mediation1.id
recommendation1_id = recommendation1.id
recommendation2_id = recommendation2.id
other_recommendation_id = other_recommendation.id
auth_request = TestClient(
app.test_client()).with_auth(email=user_pro.email)
data = {'isActive': False}
# when
response = auth_request.patch('/mediations/%s' %
humanize(mediation1.id),
json=data)
# then
mediation1 = Mediation.query.get(mediation1_id)
recommendation1 = Recommendation.query.get(recommendation1_id)
recommendation2 = Recommendation.query.get(recommendation2_id)
other_recommendation = Recommendation.query.get(
other_recommendation_id)
assert response.status_code == 200
assert response.json['isActive'] == mediation1.isActive
assert mediation1.isActive == data['isActive']
assert recommendation1.validUntilDate < datetime.utcnow()
assert recommendation2.validUntilDate < datetime.utcnow()
assert other_recommendation.validUntilDate == original_validity_date
def when_searching_by_keywords_and_distance_and_latitude_longitude(
self, app):
# Given
user = create_user(email='*****@*****.**')
concert_offer13 = create_offer_with_event_product(
self.venue13,
event_name='Funky Concert de Gael Faye',
event_type=EventType.MUSIQUE)
concert_offer75 = create_offer_with_event_product(
self.venue75,
event_name='Funky Concert de Gael Faye',
event_type=EventType.MUSIQUE)
concert_offer973 = create_offer_with_event_product(
self.venue973, event_name='Kiwi', event_type=EventType.MUSIQUE)
event_occurrence13 = create_event_occurrence(
concert_offer13,
beginning_datetime=self.in_one_hour,
end_datetime=self.ten_days_from_now)
event_occurrence75 = create_event_occurrence(
concert_offer75,
beginning_datetime=self.in_one_hour,
end_datetime=self.ten_days_from_now)
event_occurrence973 = create_event_occurrence(
concert_offer973,
beginning_datetime=self.in_one_hour,
end_datetime=self.ten_days_from_now)
recommendation13 = create_recommendation(concert_offer13, user)
recommendation75 = create_recommendation(concert_offer75, user)
recommendation973 = create_recommendation(concert_offer973, user)
stock13 = create_stock_from_event_occurrence(event_occurrence13)
stock75 = create_stock_from_event_occurrence(event_occurrence75)
stock973 = create_stock_from_event_occurrence(event_occurrence973)
PcObject.save(stock13, recommendation13, stock75, recommendation75,
stock973, recommendation973)
# When
response = TestClient(app.test_client()).with_auth(user.email).get(
RECOMMENDATION_URL +
'?distance=20000&latitude=48.8363788&longitude=2.4002701&keywords=Macouria'
)
# Then
assert response.status_code == 200
offers = response.json
assert len(offers) == 1
assert 'Kiwi' in offers[0]['offer']['product']['name']
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 when_tutos_are_already_read(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)
PcObject.save(stock1, stock2, stock3, stock4, user)
upsert_tuto_mediations()
tuto_mediation0 = Mediation.query.filter_by(tutoIndex=0).one()
tuto_mediation1 = Mediation.query.filter_by(tutoIndex=1).one()
tuto_recommendation0 = create_recommendation(
mediation=tuto_mediation0,
user=user
)
tuto_recommendation1 = create_recommendation(
mediation=tuto_mediation1,
user=user
)
PcObject.save(tuto_recommendation0, tuto_recommendation1)
humanized_tuto_recommendation0_id = humanize(tuto_recommendation0.id)
humanized_tuto_recommendation1_id = humanize(tuto_recommendation1.id)
reads = [
{
"id": humanized_tuto_recommendation0_id,
"dateRead": "2018-12-17T15:59:11.689Z"
},
{
"id": humanized_tuto_recommendation1_id,
"dateRead": "2018-12-17T15:59:15.689Z"
}
]
data = {'readRecommendations': reads}
auth_request = TestClient(app.test_client()).with_auth(user.email)
# when
response = auth_request.put(RECOMMENDATION_URL, json=data)
# then
assert response.status_code == 200
recommendations = response.json
recommendation_ids = [r['id'] for r in recommendations]
assert humanized_tuto_recommendation0_id not in recommendation_ids
assert humanized_tuto_recommendation1_id not in recommendation_ids
def when_searching_by_date_and_date_range(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(
venue, event_name='Training in Modern Jazz')
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)
stock = create_stock_from_event_occurrence(event_occurrence)
PcObject.save(stock, recommendation)
# When
response = TestClient(app.test_client()).with_auth(
user.email).get(RECOMMENDATION_URL +
'?date=%s&days=1-5' % strftime(self.now))
# Then
recommendations = response.json
assert response.status_code == 200
assert recommendations[0]['offer']['dateRange'] == [
strftime(self.three_days_from_now),
strftime(self.three_days_and_one_hour_from_now)
]
assert len(response.json) == 1
def when_searching_by_keywords_with_trailing_whitespaces(self, app):
# given
search = "keywords_string={}".format(" rencontres avec auteurs ")
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(
venue, event_name='Rencontres avec des auteurs')
recommendation = create_recommendation(offer, user, search=search)
stock = create_stock_from_offer(
offer,
beginning_datetime=TEN_DAYS_FROM_NOW,
end_datetime=TWENTY_DAYS_FROM_NOW)
PcObject.save(stock, recommendation)
# when
response = TestClient(app.test_client()).with_auth(user.email).get(
RECOMMENDATION_URL +
'?keywords={}'.format(" rencontres avec auteurs "))
# then
assert response.status_code == 200
recommendations = response.json
assert 'Rencontres' in recommendations[0]['offer']['product'][
'name']
def test_check_offer_with_one_unlimited_and_one_available_zero_stock(
self, app):
# given
user = create_user(email='*****@*****.**')
user2 = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
recommendation = create_recommendation(offer, user)
stock = create_stock_from_offer(offer, available=None)
stock2 = create_stock_from_offer(offer, available=0)
deposit = create_deposit(user2, amount=500)
booking = create_booking(user2,
stock,
venue,
recommendation,
quantity=3)
PcObject.save(booking, deposit, user, offer, stock, stock2, user2)
# when
result = offer.stockAlertMessage
# then
assert result == 'plus de stock pour 2 offres'
def test_check_offer_with_two_sold_out_one_unlimited_and_one_remaining_stocks(
self, app):
# given
user = create_user(email='*****@*****.**')
user2 = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
recommendation = create_recommendation(offer, user)
stock = create_stock_from_offer(offer, available=10)
stock2 = create_stock_from_offer(offer, available=5)
stock3 = create_stock_from_offer(offer, available=1)
stock4 = create_stock_from_offer(offer, available=None)
deposit = create_deposit(user2, amount=500)
booking = create_booking(user2,
stock2,
venue,
recommendation,
quantity=5)
booking2 = create_booking(user2,
stock3,
venue,
recommendation,
quantity=1)
PcObject.save(booking, booking2, deposit, user, offer, stock,
stock2, stock3, stock4, user2)
# when
result = offer.stockAlertMessage
# then
assert result == 'plus de places pour 3 offres'
def test_check_offer_with_all_remaining_stocks(self, app):
# given
user = create_user(email='*****@*****.**')
user2 = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
recommendation = create_recommendation(offer, user)
stock = create_stock_from_offer(offer, available=10)
stock2 = create_stock_from_offer(offer, available=40)
deposit = create_deposit(user2, amount=500)
booking = create_booking(user2,
stock,
venue,
recommendation,
quantity=3)
booking2 = create_booking(user2,
stock2,
venue,
recommendation,
quantity=11)
PcObject.save(booking, booking2, deposit, user, offer, stock,
stock2, user2)
# when
result = offer.stockAlertMessage
# then
assert result == 'encore 36 places'
def when_offer_is_added_as_favorite_for_current_user(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)
recommendation = create_recommendation(offer=offer,
user=user,
mediation=mediation,
is_clicked=False)
PcObject.save(recommendation, user)
json = {
'offerId': humanize(offer.id),
'mediationId': humanize(mediation.id),
}
# When
response = TestClient(app.test_client()).with_auth(
user.email).post(f'{API_URL}/favorites', json=json)
# Then
assert response.status_code == 201
favorite = Favorite.query.one()
assert favorite.offerId == offer.id
assert favorite.mediationId == mediation.id
assert favorite.userId == user.id
def when_deactivating_offer_and_makes_recommendations_outdated(
self, app):
# Given
seven_days_from_now = datetime.utcnow() + timedelta(days=7)
user = create_user()
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_thing_product(
venue, booking_email='*****@*****.**')
recommendation = create_recommendation(
offer, user, valid_until_date=seven_days_from_now)
PcObject.save(offer, user, user_offerer, recommendation)
recommendation_id = recommendation.id
json = {
'isActive': False,
}
# 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 Recommendation.query.get(
recommendation_id).validUntilDate < datetime.utcnow()
def when_searching_by_keywords_with_matching_case(self, app):
# given
keywords_string = "Training"
search = "keywords_string={}".format(keywords_string)
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(
venue, event_name='Training in Modern Jazz')
recommendation = create_recommendation(offer, user, search=search)
stock = create_stock_from_offer(
offer,
beginning_datetime=TEN_DAYS_FROM_NOW,
end_datetime=TWENTY_DAYS_FROM_NOW)
PcObject.save(stock, recommendation)
# when
response = TestClient(app.test_client()).with_auth(
user.email).get(RECOMMENDATION_URL +
'?keywords={}'.format(keywords_string))
# then
assert response.status_code == 200
recommendations = response.json
assert 'Training' in recommendations[0]['offer']['product']['name']
assert recommendations[0]['search'] == search
def expect_the_booking_to_have_good_includes(self, app):
offerer = create_offerer('987654321', 'Test address', 'Test city',
'93000', 'Test name')
venue = create_venue(offerer, 'Test offerer',
'*****@*****.**', '123 rue test',
'93000', 'Test city', '93')
ok_stock = create_stock_with_event_offer(offerer=offerer,
venue=venue,
price=0)
ok_stock.bookingLimitDatetime = datetime.utcnow() + timedelta(
minutes=2)
ok_stock.bookingLimitDatetime = datetime.utcnow() + timedelta(
minutes=2)
PcObject.save(ok_stock)
user = create_user(email='*****@*****.**')
PcObject.save(user)
recommendation = create_recommendation(offer=ok_stock.offer,
user=user)
PcObject.save(recommendation)
booking_json = {
'stockId': humanize(ok_stock.id),
'recommendationId': humanize(recommendation.id),
'quantity': 1
}
r_create = TestClient(app.test_client()).with_auth(
email='*****@*****.**').post('/bookings', json=booking_json)
assert r_create.status_code == 201
assert r_create.json['stock']['isBookable']
def when_user_has_booked_some_offers(self, app):
# Given
user = create_user(public_name='Test', departement_code='93', email='*****@*****.**')
offerer = create_offerer('999199987', '2 Test adress', 'Test city', '93000', 'Test offerer')
venue = create_venue(offerer)
thing_offer = create_offer_with_thing_product(venue=None)
stock = create_stock_with_thing_offer(offerer, venue, thing_offer, price=5)
recommendation = create_recommendation(thing_offer, user)
deposit_1_date = datetime.utcnow() - timedelta(minutes=2)
deposit_1 = create_deposit(user, amount=10)
deposit_2_date = datetime.utcnow() - timedelta(minutes=2)
deposit_2 = create_deposit(user, amount=10)
booking = create_booking(user, stock, venue, recommendation, quantity=1)
PcObject.save(user, venue, deposit_1, deposit_2, booking)
# when
response = TestClient(app.test_client()).with_auth('*****@*****.**').get('/users/current')
# Then
assert response.json['wallet_balance'] == 15
assert response.json['expenses'] == {
'all': {'max': 500, 'actual': 5.0},
'physical': {'max': 200, 'actual': 5.0},
'digital': {'max': 200, 'actual': 0}
}
def test_returns_stocks_with_isBookable_property(self, app):
# Given
expired_booking_limit_date = datetime(1970, 1, 1)
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue, thing_name='Guitar for dummies')
mediation = create_mediation(offer, is_active=True)
create_stock_from_offer(offer, price=14)
create_stock_from_offer(offer, price=26, booking_limit_datetime=expired_booking_limit_date)
recommendation = create_recommendation(offer=offer, user=user, mediation=mediation)
PcObject.save(user, recommendation)
auth_request = TestClient(app.test_client()).with_auth(user.email)
# When
recommendations_req = auth_request.put(RECOMMENDATION_URL, json={})
# Then
assert recommendations_req.status_code == 200
recommendations = recommendations_req.json
assert len(recommendations) == 1
recommendation = recommendations[0]
assert recommendation['offer']['name'] == 'Guitar for dummies'
stocks_response = recommendation['offer']['stocks']
assert len(stocks_response) == 2
assert all('isBookable' in stocks_response[i] for i in range(0, len(stocks_response)))
def test_returns_new_recommendation_with_active_mediation_for_already_existing_but_invalid_recommendations(
self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_thing_product(venue, thumb_count=0)
stock1 = create_stock_from_offer(offer1, price=0)
inactive_mediation = create_mediation(offer1, is_active=False)
active_mediation = create_mediation(offer1, is_active=True)
invalid_recommendation = create_recommendation(offer1, user, inactive_mediation,
valid_until_date=datetime.utcnow() - timedelta(hours=2))
PcObject.save(user, stock1, inactive_mediation, active_mediation, invalid_recommendation)
active_mediation_id = active_mediation.id
inactive_mediation_id = inactive_mediation.id
auth_request = TestClient(app.test_client()).with_auth(user.email)
data = {'seenRecommendationIds': []}
# when
response = auth_request.put(RECOMMENDATION_URL, json=data)
# then
assert response.status_code == 200
json = response.json
mediation_ids = list(map(lambda x: x['mediationId'], json))
assert humanize(active_mediation_id) in mediation_ids
assert humanize(inactive_mediation_id) not in mediation_ids
def test_create_recommendations_for_discovery_should_include_recommendations_on_offers_previously_displayed_in_search_results(
app):
# Given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_thing_product(venue, thumb_count=0)
stock1 = create_stock_from_offer(offer1, price=0)
mediation1 = create_mediation(offer1, is_active=True)
offer2 = create_offer_with_thing_product(venue, thumb_count=0)
stock2 = create_stock_from_offer(offer2, price=0)
mediation2 = create_mediation(offer2, is_active=True)
recommendation = create_recommendation(offer=offer2,
user=user,
mediation=mediation2,
search="bla")
PcObject.save(user, stock1, mediation1, stock2, mediation2, recommendation)
db.session.refresh(offer2)
# When
recommendations = create_recommendations_for_discovery(user=user)
# Then
assert len(recommendations) == 2
def test_discovery_recommendations_should_not_include_search_recommendations(self, app):
# Given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
venue_outside_dept = create_venue(offerer, postal_code='29100', siret='12345678912341')
offer1 = create_offer_with_thing_product(venue, thumb_count=0)
stock1 = create_stock_from_offer(offer1, price=0)
mediation1 = create_mediation(offer1, is_active=True)
offer2 = create_offer_with_thing_product(venue_outside_dept, thumb_count=0)
stock2 = create_stock_from_offer(offer2, price=0)
mediation2 = create_mediation(offer2, is_active=True)
recommendation = create_recommendation(offer=offer2, user=user, mediation=mediation2, search="bla")
PcObject.save(user, stock1, mediation1, stock2, mediation2, recommendation)
auth_request = TestClient(app.test_client()).with_auth(user.email)
# When
recommendations_req = auth_request.put(RECOMMENDATION_URL, json={})
# Then
assert recommendations_req.status_code == 200
recommendations = recommendations_req.json
assert len(recommendations) == 1
assert recommendations[0]['search'] is None
def when_searching_by_matching_date_and_non_matching_keywords(
self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(
venue, event_name='Training in Modern Jazz')
event_occurrence = create_event_occurrence(
offer,
beginning_datetime=self.in_one_hour,
end_datetime=self.ten_days_from_now)
recommendation = create_recommendation(offer, user)
stock = create_stock_from_event_occurrence(event_occurrence)
PcObject.save(stock, recommendation)
# When
response = TestClient(app.test_client()).with_auth(
user.email).get(RECOMMENDATION_URL +
'?date=%s&keywords=nekfeu' %
strftime(self.ten_days_from_now))
# Then
assert response.status_code == 200
assert len(response.json) == 0
def when_searching_by_keywords_and_distance(self, app):
# Given
user = create_user(email='*****@*****.**')
concert_offer13 = create_offer_with_event_product(
self.venue13,
event_name='Funky Concert de Gael Faye',
event_type=EventType.MUSIQUE)
concert_offer75 = create_offer_with_event_product(
self.venue75,
event_name='Funky Concert de Gael Faye',
event_type=EventType.MUSIQUE)
concert_offer973 = create_offer_with_event_product(
self.venue973, event_name='Kiwi', event_type=EventType.MUSIQUE)
event_occurrence13 = create_event_occurrence(
concert_offer13,
beginning_datetime=self.in_one_hour,
end_datetime=self.ten_days_from_now)
event_occurrence75 = create_event_occurrence(
concert_offer75,
beginning_datetime=self.in_one_hour,
end_datetime=self.ten_days_from_now)
event_occurrence973 = create_event_occurrence(
concert_offer973,
beginning_datetime=self.in_one_hour,
end_datetime=self.ten_days_from_now)
recommendation13 = create_recommendation(concert_offer13, user)
recommendation75 = create_recommendation(concert_offer75, user)
recommendation973 = create_recommendation(concert_offer973, user)
stock13 = create_stock_from_event_occurrence(event_occurrence13)
stock75 = create_stock_from_event_occurrence(event_occurrence75)
stock973 = create_stock_from_event_occurrence(event_occurrence973)
PcObject.save(stock13, recommendation13, stock75, recommendation75,
stock973, recommendation973)
# When
response = TestClient(app.test_client()).with_auth(
user.email).get(RECOMMENDATION_URL +
'?distance=1&keywords=funky')
# Then
assert len(response.json) == 2
def when_only_public_credit_and_limit_of_physical_thing_reached(
self, app):
# Given
user = create_user(email='*****@*****.**')
PcObject.save(user)
offerer = create_offerer()
PcObject.save(offerer)
venue = create_venue(offerer)
PcObject.save(venue)
thing_offer = create_offer_with_thing_product(venue)
PcObject.save(thing_offer)
thing_stock_price_190 = create_stock_with_thing_offer(offerer,
venue,
thing_offer,
price=190)
thing_stock_price_12 = create_stock_with_thing_offer(offerer,
venue,
thing_offer,
price=12)
PcObject.save(thing_stock_price_190, thing_stock_price_12)
deposit_date = datetime.utcnow() - timedelta(minutes=2)
deposit = create_deposit(user, amount=500, source='public')
PcObject.save(deposit)
booking_thing_price_190 = create_booking(user,
thing_stock_price_190,
venue,
recommendation=None)
PcObject.save(booking_thing_price_190)
recommendation = create_recommendation(thing_offer, user)
PcObject.save(recommendation)
booking_thing_price_12_json = {
"stockId": humanize(thing_stock_price_12.id),
"recommendationId": humanize(recommendation.id),
"quantity": 1
}
# When
response = TestClient(app.test_client()) \
.with_auth('*****@*****.**') \
.post('/bookings', json=booking_thing_price_12_json)
# Then
error_message = response.json
assert response.status_code == 400
assert error_message['global'] == ['Le plafond de 200 € pour les biens culturels ' \
'ne vous permet pas de réserver cette offre.']
def test_filter_out_recommendation_with_not_bookable_stocks_returns_recos_with_at_least_one_not_soft_deleted_stock(
app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
user = create_user()
event_offer = create_offer_with_event_product(venue)
soft_deleted_thing_offer = create_offer_with_thing_product(venue)
active_thing_offer = create_offer_with_thing_product(venue)
event_occurrence1 = create_event_occurrence(event_offer)
event_occurrence2 = create_event_occurrence(event_offer)
active_thing_stock = create_stock_from_offer(active_thing_offer)
active_event_stock = create_stock_from_event_occurrence(event_occurrence2)
soft_deleted_event_stock = create_stock_from_event_occurrence(
event_occurrence1)
soft_deleted_event_stock.isSoftDeleted = True
soft_deleted_thing_stock = create_stock_from_offer(
soft_deleted_thing_offer)
soft_deleted_thing_stock.isSoftDeleted = True
recommendation_on_active_thing_stock = create_recommendation(
active_thing_offer, user)
recommendation_on_both_soft_deleted_and_active_event_stocks = create_recommendation(
event_offer, user)
recommendation_on_soft_deleted_thing_stock = create_recommendation(
soft_deleted_thing_offer, user)
PcObject.save(soft_deleted_event_stock, active_event_stock,
soft_deleted_thing_stock, active_thing_stock,
recommendation_on_both_soft_deleted_and_active_event_stocks,
recommendation_on_soft_deleted_thing_stock,
recommendation_on_active_thing_stock)
# When
result = keep_only_bookable_stocks().all()
# Then
recommendation_ids = [r.id for r in result]
assert recommendation_on_both_soft_deleted_and_active_event_stocks.id in recommendation_ids
assert recommendation_on_soft_deleted_thing_stock.id not in recommendation_ids
assert recommendation_on_active_thing_stock.id in recommendation_ids
def test_update_read_recommendations(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)
# When
reads = [
{
"id": humanize(recommendation1.id),
"dateRead": "2018-12-17T15:59:11.689Z"
},
{
"id": humanize(recommendation2.id),
"dateRead": "2018-12-17T15:59:15.689Z"
},
{
"id": humanize(recommendation3.id),
"dateRead": "2018-12-17T15:59:21.689Z"
},
]
update_read_recommendations(reads)
# Then
assert recommendation1.dateRead == datetime(2018, 12, 17, 15, 59, 11,
689000)
assert recommendation2.dateRead == datetime(2018, 12, 17, 15, 59, 15,
689000)
assert recommendation3.dateRead == datetime(2018, 12, 17, 15, 59, 21,
689000)
def when_searching_by_keywords_ignores_soft_deleted_stocks(self, app):
# given
search = 'keywords={}'.format('rencontres')
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_event_product(
venue, event_name='Rencontres avec des peintres')
offer2 = create_offer_with_event_product(
venue, event_name='Rencontres avec des auteurs')
recommendation1 = create_recommendation(offer1,
user,
search=search)
recommendation2 = create_recommendation(offer2,
user,
search=search)
# NOTE: we need to create event occurrence and stock because
# GET recommendations filter offer without stock
event_occurrence1 = create_event_occurrence(offer1)
event_occurrence2 = create_event_occurrence(offer1)
event_occurrence3 = create_event_occurrence(offer2)
stock1 = create_stock_from_event_occurrence(event_occurrence1,
price=10,
soft_deleted=False)
stock2 = create_stock_from_event_occurrence(event_occurrence2,
price=20,
soft_deleted=True)
stock3 = create_stock_from_event_occurrence(event_occurrence3,
price=30,
soft_deleted=True)
PcObject.save(stock1, stock2, stock3, recommendation1,
recommendation2)
# when
response = TestClient(app.test_client()).with_auth(
user.email).get(RECOMMENDATION_URL +
'?keywords={}'.format('rencontres'))
# then
assert response.status_code == 200
assert len(response.json) == 1
def when_user_cannot_book_free_offers_and_free_offer(self, app):
# Given
user = create_user(email='*****@*****.**',
can_book_free_offers=False)
PcObject.save(user)
offerer = create_offerer(siren='899999768',
address='2 Test adress',
city='Test city',
postal_code='93000',
name='Test offerer')
PcObject.save(offerer)
venue = create_venue(offerer=offerer,
name='Venue name',
booking_email='*****@*****.**',
address='1 Test address',
postal_code='93000',
city='Test city',
departement_code='93')
PcObject.save(venue)
thing_offer = create_offer_with_thing_product(venue)
PcObject.save(thing_offer)
stock = create_stock_with_thing_offer(offerer,
venue,
thing_offer,
price=0)
PcObject.save(stock)
recommendation = create_recommendation(thing_offer, user)
PcObject.save(recommendation)
deposit_date = datetime.utcnow() - timedelta(minutes=2)
deposit = create_deposit(user, amount=500)
PcObject.save(deposit)
booking_json = {
'stockId': humanize(stock.id),
'recommendationId': humanize(recommendation.id),
'quantity': 1
}
# When
r_create = TestClient(app.test_client()) \
.with_auth('*****@*****.**') \
.post('/bookings', json=booking_json)
# Then
assert r_create.status_code == 400
assert 'cannotBookFreeOffers' in r_create.json
assert r_create.json['cannotBookFreeOffers'] == [
"Votre compte ne vous permet pas de faire de réservation."
]
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 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
