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