def when_offers_have_active_mediations(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)
mediation1 = create_mediation(offer1, is_active=False)
offer2 = create_offer_with_thing_product(venue, thumb_count=0)
stock2 = create_stock_from_offer(offer2, price=0)
mediation2 = create_mediation(offer2, is_active=False)
mediation3 = create_mediation(offer2, is_active=True)
PcObject.save(user, stock1, mediation1, stock2, mediation2, mediation3)
auth_request = TestClient(app.test_client()).with_auth(user.email)
mediation3_id = mediation3.id
mediation2_id = mediation2.id
mediation1_id = mediation1.id
# when
response = auth_request.put(RECOMMENDATION_URL, json={'seenRecommendationIds': []})
# then
assert response.status_code == 200
json = response.json
mediation_ids = list(map(lambda x: x['mediationId'], json))
assert humanize(mediation3_id) in mediation_ids
assert humanize(mediation2_id) not in mediation_ids
assert humanize(mediation1_id) not in mediation_ids
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_user_is_logged_in_and_has_two_favorite_offers(self, app):
# Given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer,
postal_code='29100',
siret='12345678912341')
offer1 = create_offer_with_thing_product(venue, thumb_count=0)
mediation1 = create_mediation(offer1, is_active=True)
favorite1 = create_favorite(mediation1, offer1, user)
offer2 = create_offer_with_thing_product(venue, thumb_count=0)
mediation2 = create_mediation(offer2, is_active=True)
favorite2 = create_favorite(mediation2, offer2, user)
PcObject.save(user, favorite1, favorite2)
# When
response = TestClient(app.test_client()).with_auth(user.email) \
.get(API_URL + '/favorites')
# Then
assert response.status_code == 200
assert len(response.json) == 2
first_favorite = response.json[0]
assert 'offer' in first_favorite
assert 'venue' in first_favorite['offer']
assert 'validationToken' not in first_favorite['offer']['venue']
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 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_returns_none_if_all_mediations_are_deactivated(self):
# given
offer = Offer()
offer.mediations = [
create_mediation(offer, is_active=False),
create_mediation(offer, is_active=False)
]
# then
assert offer.activeMediation is None
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_offers_have_no_thumb_count_for_event_and_no_mediation(
self, app):
# given
now = datetime.utcnow()
four_days_from_now = now + timedelta(days=4)
eight_days_from_now = now + timedelta(days=8)
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
event_occurrence = create_event_occurrence(
offer,
beginning_datetime=four_days_from_now,
end_datetime=eight_days_from_now
)
mediation = create_mediation(offer)
stock = create_stock_from_event_occurrence(event_occurrence, price=0, available=20)
PcObject.save(user, stock, mediation)
auth_request = TestClient(app.test_client()).with_auth(user.email)
# when
response = auth_request.put(RECOMMENDATION_URL, json={'seenRecommendationIds': []})
# then
assert response.status_code == 200
assert len(response.json) == 1
def test_should_return_offers_with_mediations_first(app):
# Given
offerer = create_offerer()
venue = create_venue(offerer,
postal_code='34000',
departement_code='34')
stock1 = create_stock_with_thing_offer(offerer,
venue,
name='thing_with_mediation')
mediation = create_mediation(stock1.offer)
stock2 = create_stock_with_thing_offer(offerer,
venue,
name='thing_without_mediation')
PcObject.save(stock2, mediation)
PcObject.save(stock1)
# When
offers = get_active_offers(user=create_user(email="*****@*****.**"),
departement_codes=['00'],
offer_id=None)
# Then
assert len(offers) == 2
assert offers[0].name == 'thing_with_mediation'
assert offers[1].name == 'thing_without_mediation'
def test_only_returns_both_EventType_and_ThingType(app):
# Given
user = create_user(departement_code='93')
offerer = create_offerer()
venue = create_venue(offerer, departement_code='93')
offer1 = create_offer_with_thing_product(venue, thumb_count=1)
offer2 = create_offer_with_event_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,
booking_limit_date=now +
timedelta(days=2))
PcObject.save(user, stock1, stock2, mediation)
# When
offers = get_active_offers(user=user, departement_codes=['93'])
# Then
assert len(offers) == 2
def when_mediation_is_edited(self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
user_offerer = create_user_offerer(user, offerer)
mediation = create_mediation(offer)
PcObject.save(mediation)
PcObject.save(user, venue, offerer, user_offerer)
mediation_id = mediation.id
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
data = {
'frontText': 'new front text',
'backText': 'new back text',
'isActive': False
}
# when
response = auth_request.patch('/mediations/%s' %
humanize(mediation.id),
json=data)
# then
mediation = Mediation.query.get(mediation_id)
assert response.status_code == 200
assert response.json['id'] == humanize(mediation.id)
assert response.json['frontText'] == mediation.frontText
assert response.json['backText'] == mediation.backText
assert response.json['isActive'] == mediation.isActive
assert response.json['thumbUrl'] == mediation.thumbUrl
assert mediation.isActive == data['isActive']
assert mediation.frontText == data['frontText']
assert mediation.backText == data['backText']
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 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 test_returns_the_most_recent_active_mediation(self):
# given
offer = Offer()
offer.mediations = [
create_mediation(offer,
front_text='1st',
date_created=four_days_ago,
is_active=True),
create_mediation(offer,
front_text='2nd',
date_created=now,
is_active=False),
create_mediation(offer,
front_text='3rd',
date_created=two_days_ago,
is_active=True)
]
# then
assert offer.activeMediation.frontText == '3rd'
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_filter_unseen_valid_recommendations_for_user_only_keeps_non_tuto_recommendations_that_have_not_expired(
app):
# Given
now = datetime.utcnow()
five_minutes_ago = now - timedelta(minutes=5)
tomorrow = now + timedelta(days=1)
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
user = create_user()
mediation = create_mediation(offer)
tuto_mediation = create_mediation(offer, tuto_index=1)
invalid_recommendation = create_recommendation(
offer, user, mediation, valid_until_date=five_minutes_ago)
recommendation_with_no_validity_date = create_recommendation(
offer, user, mediation, valid_until_date=None)
valid_recommendation = create_recommendation(offer,
user,
mediation,
valid_until_date=tomorrow)
tuto_recommendation = create_recommendation(offer,
user,
tuto_mediation,
valid_until_date=None)
PcObject.save(invalid_recommendation, valid_recommendation,
recommendation_with_no_validity_date, tuto_recommendation)
query = Recommendation.query
# When
recommendation_query = filter_unseen_valid_recommendations_for_user(
query, user, seen_recommendation_ids=[])
# Then
recommendations = recommendation_query.all()
assert len(recommendations) == 2
assert valid_recommendation in recommendations
assert recommendation_with_no_validity_date in recommendations
def when_given_mediation_does_not_match_given_offer(self, app):
# given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer_thing_1 = create_offer_with_thing_product(venue, thumb_count=1, dominant_color=b'123')
offer_thing_2 = create_offer_with_thing_product(venue, thumb_count=1, dominant_color=b'123')
stock_thing_1 = create_stock_with_thing_offer(offerer, venue, offer_thing_1, price=0)
stock_thing_2 = create_stock_with_thing_offer(offerer, venue, offer_thing_2, price=0)
mediation_1 = create_mediation(offer_thing_1)
mediation_2 = create_mediation(offer_thing_2)
PcObject.save(user, stock_thing_1, stock_thing_2, mediation_1, mediation_2)
auth_request = TestClient(app.test_client()).with_auth(user.email)
# when
response = auth_request.put(RECOMMENDATION_URL +
"?offerId=" +
humanize(offer_thing_1.id) +
"?mediationId=" +
humanize(mediation_2.id), json={'seenRecommendationIds': []})
# then
assert response.status_code == 404
def test_create_recommendations_for_discovery_does_not_put_mediation_ids_of_inactive_mediations(
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=False)
offer2 = create_offer_with_thing_product(venue, thumb_count=0)
stock2 = create_stock_from_offer(offer2, price=0)
mediation2 = create_mediation(offer2, is_active=False)
mediation3 = create_mediation(offer2, is_active=True)
PcObject.save(user, stock1, mediation1, stock2, mediation2, mediation3)
# When
recommendations = create_recommendations_for_discovery(user=user)
# Then
mediations = list(map(lambda x: x.mediationId, recommendations))
assert len(recommendations) == 1
assert mediation3.id in mediations
assert humanize(mediation2.id) not in mediations
assert humanize(mediation1.id) not in mediations
def test_model_should_use_environment_variable(get_storage_base_url):
# given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
mediation = create_mediation(offer)
mediation.id = 1
# when
recommendation = create_recommendation(offer, user, mediation=mediation)
recommendation.mediationId = 1
# then
assert recommendation.thumbUrl == "https://passculture.app/storage/v2/thumbs/mediations/AE"
def test_model_should_use_mediation_first_as_thumbUrl(get_storage_base_url):
# given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
mediation = create_mediation(offer)
mediation.id = 1
# when
recommendation = create_recommendation(offer, user, mediation=mediation)
recommendation.mediationId = 1
# then
assert recommendation.thumbUrl == "http://localhost/storage/thumbs/mediations/AE"
def test_model_should_return_false_if_no_favorite_exists_for_offer_mediation_and_user(
app):
# given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
mediation = create_mediation(offer)
# when
recommendation = create_recommendation(offer, user, mediation=mediation)
PcObject.save(recommendation)
# then
assert recommendation.isFavorite is False
def test_returns_included_properties_on_joined_relationships(self, app):
# given
offerer = create_offerer()
venue = create_venue(offerer)
event_product = create_product_with_event_type(event_name='My Event')
offer = create_offer_with_event_product(venue, product=event_product)
mediation = create_mediation(offer)
PcObject.save(mediation)
EVENT_INCLUDES = [{"key": "mediations", "includes": ["thumbUrl"]}]
# when
dict_result = as_dict(offer, includes=EVENT_INCLUDES)
# then
assert 'thumbUrl' in dict_result['mediations'][0]
def when_returns_an_active_mediation(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
mediation = create_mediation(offer, is_active=True)
PcObject.save(user, mediation)
# when
response = TestClient(app.test_client()).with_auth(email='*****@*****.**') \
.get(f'/offers/{humanize(offer.id)}')
# then
assert response.status_code == 200
assert response.json['activeMediation'] is not None
def when_user_has_already_seen_recommendation(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)
mediation = create_mediation(offer, is_active=True)
stock = create_stock_from_offer(offer)
recommendation = create_recommendation(offer=offer, user=user, mediation=mediation, is_clicked=False)
PcObject.save(stock, recommendation)
# when
response = TestClient(app.test_client()).with_auth(user.email) \
.put(RECOMMENDATION_URL, json={'seenRecommendationIds': [humanize(recommendation.id)]})
# then
assert response.status_code == 200
assert response.json == []
def when_offers_have_no_thumb_count_for_thing_and_a_mediation(
self, app):
# given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue, thumb_count=0)
stock = create_stock_from_offer(offer, price=0)
mediation = create_mediation(offer)
PcObject.save(user, stock, mediation)
auth_request = TestClient(app.test_client()).with_auth(user.email)
# when
response = auth_request.put(RECOMMENDATION_URL, json={'seenRecommendationIds': []})
# then
assert response.status_code == 200
assert len(response.json) == 1
def test_when_recommendation_exists_returns_it(self, app):
# Given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer_ok = create_offer_with_thing_product(venue, thumb_count=0)
stock = create_stock_from_offer(offer_ok, price=0)
mediation = create_mediation(offer_ok, is_active=False)
reco_ok = create_recommendation(offer=offer_ok,
user=user,
mediation=mediation)
PcObject.save(reco_ok, stock)
# When
result_reco = give_requested_recommendation_to_user(
user, offer_ok.id, mediation.id)
# Then
assert result_reco.id == reco_ok.id
def when_offer_is_known_and_mediation_is_unknown(self, app):
# given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer_thing = create_offer_with_thing_product(venue, thumb_count=1, dominant_color=b'123')
stock_thing = create_stock_with_thing_offer(offerer, venue, offer_thing, price=0)
mediation = create_mediation(offer_thing)
PcObject.save(user, stock_thing, mediation)
auth_request = TestClient(app.test_client()).with_auth(user.email)
# when
response = auth_request.put(RECOMMENDATION_URL +
"?offerId=" +
humanize(offer_thing.id) +
"?mediationId=" +
"ABCDE", json={'seenRecommendationIds': []})
# then
assert response.status_code == 404
def when_a_file_is_uploaded_for_a_mediation(self, app):
# given
user = create_user()
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
mediation = create_mediation(offer)
PcObject.save(user_offerer, mediation)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
# when
response = auth_request.post(
'/storage/thumb/%s/%s/%s' %
('mediations', humanize(mediation.id), '0'),
files={'file': (BytesIO(ONE_PIXEL_PNG), '1.png')})
# then
assert response.status_code == 200
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
