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