def when_booking_already_validated(self, app):
# Given
user = create_user()
admin_user = create_user(email='*****@*****.**')
offerer = create_offerer()
user_offerer = create_user_offerer(admin_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(
offerer,
venue,
price=0,
beginning_datetime=Patch.tomorrow,
end_datetime=Patch.tomorrow_plus_one_hour,
booking_limit_datetime=Patch.tomorrow_minus_one_hour)
booking = create_booking(user, stock, venue=venue)
booking.isUsed = True
PcObject.save(booking, user_offerer)
booking_id = booking.id
url = '/bookings/token/{}'.format(booking.token)
# When
response = TestClient(
app.test_client()).with_auth('*****@*****.**').patch(url)
# Then
assert response.status_code == 410
assert response.json['booking'] == [
'Cette réservation a déjà été validée'
]
assert Booking.query.get(booking_id).isUsed
def when_searching_by_keywords_with_partial_keyword(self, app):
# given
search = "keywords_string={}".format("rencon")
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("rencon"))
# then
assert response.status_code == 200
recommendations = response.json
assert 'Rencontres' in recommendations[0]['offer']['product'][
'name']
assert recommendations[0]['search'] == search
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 test_offer_remaining_stock_filter_filters_offer_with_no_remaining_stock(
app):
# Given
product = create_product_with_thing_type(thing_name='Lire un livre',
is_national=True)
offerer = create_offerer()
venue = create_venue(offerer, postal_code='34000', departement_code='34')
offer = create_offer_with_thing_product(venue, product)
stock = create_stock_from_offer(offer, available=2, price=0)
user = create_user()
booking1 = create_booking(user,
stock,
venue=venue,
quantity=2,
is_cancelled=True)
booking2 = create_booking(user, stock, venue=venue, quantity=2)
PcObject.save(booking1, booking2)
# When
nb_offers_with_remaining_stock = Offer.query \
.join(Stock) \
.filter(_has_remaining_stock_predicate()) \
.count()
# Then
assert nb_offers_with_remaining_stock == 0
def test_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_find_activation_offers_returns_activation_offers_in_given_departement(
app):
# given
offerer = create_offerer()
venue1 = create_venue(offerer,
siret=offerer.siren + '12345',
postal_code='34000',
departement_code='34')
venue2 = create_venue(offerer,
siret=offerer.siren + '54321',
postal_code='93000',
departement_code='93')
offer1 = create_offer_with_event_product(venue1,
event_type=EventType.ACTIVATION)
offer2 = create_offer_with_event_product(
venue1, event_type=EventType.SPECTACLE_VIVANT)
offer3 = create_offer_with_event_product(venue2,
event_type=EventType.ACTIVATION)
stock1 = create_stock_from_offer(offer1)
stock2 = create_stock_from_offer(offer2)
stock3 = create_stock_from_offer(offer3)
PcObject.save(stock1, stock2, stock3)
# when
offers = find_activation_offers('34').all()
# then
assert len(offers) == 1
def test_find_activation_offers_returns_activation_offers_in_all_ile_de_france_if_departement_is_93(
app):
# given
offerer = create_offerer()
venue1 = create_venue(offerer,
siret=offerer.siren + '12345',
postal_code='34000',
departement_code='34')
venue2 = create_venue(offerer,
siret=offerer.siren + '67890',
postal_code='75000',
departement_code='75')
venue3 = create_venue(offerer,
siret=offerer.siren + '54321',
postal_code='78000',
departement_code='78')
offer1 = create_offer_with_event_product(venue1,
event_type=EventType.ACTIVATION)
offer2 = create_offer_with_event_product(venue2,
event_type=EventType.ACTIVATION)
offer3 = create_offer_with_event_product(venue3,
event_type=EventType.ACTIVATION)
stock1 = create_stock_from_offer(offer1)
stock2 = create_stock_from_offer(offer2)
stock3 = create_stock_from_offer(offer3)
PcObject.save(stock1, stock2, stock3)
# when
offers = find_activation_offers('93').all()
# then
assert len(offers) == 2
def test_order_by_base_score(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer,
postal_code='34000',
departement_code='34')
criterion_negative = create_criterion(name='negative', score_delta=-1)
criterion_positive = create_criterion(name='positive', score_delta=1)
offer1 = create_offer_with_thing_product(venue)
offer2 = create_offer_with_thing_product(venue)
offer1.criteria = [criterion_negative]
offer2.criteria = [criterion_negative, criterion_positive]
PcObject.save(offer1, offer2)
# When
offers = Offer.query \
.order_by(Offer.baseScore.desc()) \
.all()
# Then
assert offers == [offer2, offer1]
def test_get_active_offers_with_no_order_by_should_return_same_number_of_recos(
self, 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',
thing_type=ThingType.JEUX_VIDEO)
stock2 = create_stock_with_thing_offer(offerer,
venue,
name='thing',
thing_type=ThingType.JEUX_VIDEO)
stock3 = create_stock_with_thing_offer(
offerer, venue, name='thing', thing_type=ThingType.AUDIOVISUEL)
stock4 = create_stock_with_thing_offer(offerer,
venue,
name='thing',
thing_type=ThingType.JEUX)
PcObject.save(stock1, stock2, stock3, stock4)
# When
offers = get_active_offers(departement_codes=['00'], offer_id=None)
# Then
assert len(offers) == 4
def test_generate_bookings_details_csv_with_headers_and_three_bookings_lines(
self, app):
# given
user = create_user(email='*****@*****.**', idx=3)
offerer = create_offerer(siren='987654321', name='Joe le Libraire')
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock(price=12, available=5, offer=offer)
booking = create_booking(user,
stock,
date_created=datetime(2010, 1, 1, 0, 0, 0, 0))
deposit1 = create_deposit(user, amount=100)
PcObject.save(user, offerer, venue, offer, stock, booking, deposit1)
bookings = Booking.query.all()
expected_line = 'La petite librairie;Test Book;Doe;John;[email protected];2010-01-01 00:00:00;12;En attente'
# when
csv = generate_bookings_details_csv(bookings)
# then
assert _count_non_empty_lines(csv) == 2
assert csv.split('\r\n')[1] == expected_line
def deactivate_venue_offers(venueId):
venue = load_or_404(Venue, venueId)
ensure_current_user_has_rights(RightsType.editor, venue.managingOffererId)
offers = venue.offers
deactivated_offers = update_is_active_status(offers, False)
PcObject.save(*deactivated_offers)
return jsonify([as_dict(offer, includes=OFFER_INCLUDES) for offer in deactivated_offers]), 200
def expect_booking_to_have_completed_url(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(
venue,
url='https://host/path/{token}?offerId={offerId}&email={email}'
)
stock = create_stock_with_thing_offer(offerer=offerer,
venue=venue,
offer=offer,
price=0)
booking = create_booking(user, stock, venue=venue, token='ABCDEF')
PcObject.save(booking)
# When
response = TestClient(app.test_client()).with_auth(
user.email).get('/bookings/' + humanize(booking.id))
# Then
assert response.status_code == 200
response_json = response.json
assert response_json[
'completedUrl'] == 'https://host/path/ABCDEF?offerId=%s&[email protected]' % humanize(
offer.id)
assert 'recommendation' in response_json
assert 'offer' in response_json['recommendation']
assert 'venue' in response_json['recommendation']['offer']
assert 'validationToken' not in response_json['recommendation'][
'offer']
def when_booking_user_email_has_special_character_url_encoded(
self, app):
# Given
user = create_user(email='*****@*****.**')
user_admin = create_user(email='*****@*****.**')
offerer = create_offerer()
user_offerer = create_user_offerer(user_admin,
offerer,
is_admin=True)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue,
event_name='Event Name')
event_occurrence = create_event_occurrence(
offer,
beginning_datetime=Patch.tomorrow,
end_datetime=Patch.tomorrow_plus_one_hour)
stock = create_stock_from_event_occurrence(
event_occurrence,
price=0,
booking_limit_date=Patch.tomorrow_minus_one_hour)
booking = create_booking(user, stock, venue=venue)
PcObject.save(user_offerer, booking)
url_email = urlencode({'email': '*****@*****.**'})
url = '/bookings/token/{}?{}'.format(booking.token, url_email)
# When
response = TestClient(
app.test_client()).with_auth('*****@*****.**').patch(url)
# Then
assert response.status_code == 204
def when_header_is_not_standard_but_request_is_valid(self, app):
# Given
user = create_user()
admin_user = create_user(email='*****@*****.**')
offerer = create_offerer()
user_offerer = create_user_offerer(admin_user, offerer)
venue = create_venue(offerer)
stock = create_stock_with_event_offer(
offerer,
venue,
price=0,
beginning_datetime=Patch.tomorrow,
end_datetime=Patch.tomorrow_plus_one_hour,
booking_limit_datetime=Patch.tomorrow_minus_one_hour)
booking = create_booking(user, stock, venue=venue)
PcObject.save(booking, user_offerer)
booking_id = booking.id
url = '/bookings/token/{}'.format(booking.token)
# When
response = TestClient(app.test_client()) \
.with_auth('*****@*****.**') \
.patch(url, headers={'origin': 'http://random_header.fr'})
# Then
assert response.status_code == 204
assert Booking.query.get(booking_id).isUsed
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_get_active_offers_with_criteria_should_return_offer_with_highest_base_score_first_bust_keep_the_partition(
self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer,
postal_code='34000',
departement_code='34')
offer1 = create_offer_with_thing_product(
venue, thing_type=ThingType.CINEMA_ABO, thumb_count=1)
stock1 = create_stock_from_offer(offer1, price=0)
offer1.criteria = [create_criterion(name='negative', score_delta=1)]
offer2 = create_offer_with_thing_product(
venue, thing_type=ThingType.CINEMA_ABO, thumb_count=1)
stock2 = create_stock_from_offer(offer2, price=0)
offer2.criteria = [create_criterion(name='positive', score_delta=2)]
offer3 = create_offer_with_thing_product(
venue, thing_type=ThingType.JEUX_VIDEO, thumb_count=1)
stock3 = create_stock_from_offer(offer3, price=0)
offer3.criteria = []
PcObject.save(stock1, stock2, stock3)
# When
offers = get_active_offers(departement_codes=['00'],
offer_id=None,
order_by=order_by_with_criteria)
# Then
assert offers == [offer2, offer3, offer1]
def test_should_not_return_offers_with_no_stock(app):
# Given
product = create_product_with_thing_type(thing_name='Lire un livre',
is_national=True)
offerer = create_offerer()
venue = create_venue(offerer,
postal_code='34000',
departement_code='34')
offer = create_offer_with_thing_product(venue, product)
stock = create_stock_from_offer(offer, available=2, price=0)
user = create_user()
booking1 = create_booking(user,
stock,
venue=venue,
quantity=2,
is_cancelled=True)
booking2 = create_booking(user, stock, venue=venue, quantity=2)
PcObject.save(booking1, booking2)
# When
offers = get_active_offers(user=create_user(email="*****@*****.**"),
departement_codes=['00'],
offer_id=None)
# Then
assert len(offers) == 0
def test_search_by_datetime_only_returns_recommendations_starting_during_time_interval(
self, app):
# Duplicate
# Given
offerer = create_offerer()
venue = create_venue(offerer)
ok_stock = _create_event_stock_and_offer_for_date(
venue, datetime(2018, 1, 6, 12, 30))
ko_stock_before = _create_event_stock_and_offer_for_date(
venue, datetime(2018, 1, 1, 12, 30))
ko_stock_after = _create_event_stock_and_offer_for_date(
venue, datetime(2018, 1, 10, 12, 30))
ok_stock_with_thing = create_stock_with_thing_offer(offerer, venue)
PcObject.save(ok_stock, ko_stock_before, ko_stock_after)
# When
search_result_offers = get_offers_for_recommendations_search(
days_intervals=[[
datetime(2018, 1, 6, 12, 0),
datetime(2018, 1, 6, 13, 0)
]], )
# Then
assert ok_stock.resolvedOffer in search_result_offers
assert ok_stock_with_thing.resolvedOffer in search_result_offers
assert ko_stock_before.resolvedOffer not in search_result_offers
assert ko_stock_after.resolvedOffer not in search_result_offers
def test_find_activation_offers_returns_activation_offers_if_offer_is_national(
app):
# given
offerer = create_offerer()
venue1 = create_venue(offerer,
siret=offerer.siren + '12345',
postal_code='34000',
departement_code='34')
venue2 = create_venue(offerer,
siret=offerer.siren + '54321',
postal_code='93000',
departement_code='93')
offer1 = create_offer_with_event_product(venue1,
event_type=EventType.ACTIVATION)
offer2 = create_offer_with_thing_product(venue1,
thing_type=ThingType.AUDIOVISUEL)
offer3 = create_offer_with_event_product(venue2,
event_type=EventType.ACTIVATION,
is_national=True)
offer4 = create_offer_with_event_product(venue2,
event_type=EventType.ACTIVATION,
is_national=True)
stock1 = create_stock_from_offer(offer1)
stock2 = create_stock_from_offer(offer2)
stock3 = create_stock_from_offer(offer3)
stock4 = create_stock_from_offer(offer4)
PcObject.save(stock1, stock2, stock3, stock4)
# when
offers = find_activation_offers('34').all()
# then
assert len(offers) == 3
def test_search_with_several_partial_keywords_returns_things_and_events_with_name_containing_keywords(
self, app):
# Given
thing_ok = create_product_with_thing_type(
thing_name='Rencontre de michel')
thing_product = create_product_with_thing_type(
thing_name='Rencontre avec jean-luc')
event_product = create_product_with_event_type(
event_name='Rencontre avec jean-mimi chelou')
offerer = create_offerer()
venue = create_venue(offerer)
thing_ok_offer = create_offer_with_thing_product(venue, thing_ok)
thing_ko_offer = create_offer_with_thing_product(venue, thing_product)
event_ko_offer = create_offer_with_event_product(venue, event_product)
event_ko_occurrence = create_event_occurrence(event_ko_offer)
event_ko_stock = create_stock_from_event_occurrence(
event_ko_occurrence)
thing_ok_stock = create_stock_from_offer(thing_ok_offer)
thing_ko_stock = create_stock_from_offer(thing_ko_offer)
PcObject.save(event_ko_stock, thing_ok_stock, thing_ko_stock)
# When
offers = get_offers_for_recommendations_search(
keywords_string='renc michel')
# Then
assert thing_ok_offer in offers
assert thing_ko_offer not in offers
assert event_ko_offer not in offers
def test_find_activation_offers_returns_activation_offers_with_available_stocks(
app):
# given
offerer = create_offerer()
venue1 = create_venue(offerer,
siret=offerer.siren + '12345',
postal_code='93000',
departement_code='93')
venue2 = create_venue(offerer,
siret=offerer.siren + '67890',
postal_code='93000',
departement_code='93')
venue3 = create_venue(offerer,
siret=offerer.siren + '54321',
postal_code='93000',
departement_code='93')
offer1 = create_offer_with_event_product(venue1,
event_type=EventType.ACTIVATION)
offer2 = create_offer_with_event_product(venue2,
event_type=EventType.ACTIVATION)
offer3 = create_offer_with_event_product(venue3,
event_type=EventType.ACTIVATION)
offer4 = create_offer_with_event_product(venue3,
event_type=EventType.ACTIVATION)
stock1 = create_stock_from_offer(offer1, price=0, available=0)
stock2 = create_stock_from_offer(offer2, price=0, available=10)
stock3 = create_stock_from_offer(offer3, price=0, available=1)
booking = create_booking(create_user(), stock3, venue=venue3, quantity=1)
PcObject.save(stock1, stock2, stock3, booking, offer4)
# when
offers = find_activation_offers('93').all()
# then
assert len(offers) == 1
def test_search_return_offers_by_types_with_some_but_not_all_beginning_datetime_passed_and_no_booking_limit_datetime(
self, app):
# Given
three_hours_ago = datetime.utcnow() - timedelta(hours=3)
in_three_hours = datetime.utcnow() + timedelta(hours=3)
in_four_hours = datetime.utcnow() + timedelta(hours=4)
type_label = EventType.MUSEES_PATRIMOINE
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue, event_type=type_label)
outdated_event_occurrence = create_event_occurrence(
offer,
beginning_datetime=three_hours_ago,
end_datetime=datetime.utcnow())
future_event_occurrence = create_event_occurrence(
offer,
beginning_datetime=in_three_hours,
end_datetime=in_four_hours)
future_stock = create_stock_from_event_occurrence(
future_event_occurrence, booking_limit_date=None)
outdated_stock = create_stock_from_event_occurrence(
outdated_event_occurrence, booking_limit_date=None)
PcObject.save(future_stock, outdated_stock)
# When
search_result_offers = get_offers_for_recommendations_search(
type_values=[str(type_label)], )
# Then
assert offer in search_result_offers
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 test_when_departement_code_00(app):
# Given
offerer = create_offerer()
venue_34 = create_venue(offerer,
postal_code='34000',
departement_code='34',
siret=offerer.siren + '11111')
venue_93 = create_venue(offerer,
postal_code='93000',
departement_code='93',
siret=offerer.siren + '22222')
venue_75 = create_venue(offerer,
postal_code='75000',
departement_code='75',
siret=offerer.siren + '33333')
offer_34 = create_offer_with_thing_product(venue_34)
offer_93 = create_offer_with_thing_product(venue_93)
offer_75 = create_offer_with_thing_product(venue_75)
stock_34 = create_stock_from_offer(offer_34)
stock_93 = create_stock_from_offer(offer_93)
stock_75 = create_stock_from_offer(offer_75)
user = create_user(departement_code='00')
PcObject.save(user, stock_34, stock_93, stock_75)
# When
offers = get_active_offers(departement_codes=['00'], offer_id=None)
# Then
assert offer_34 in offers
assert offer_93 in offers
assert offer_75 in offers
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_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_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 test_should_not_return_activation_event(app):
# Given
offerer = create_offerer()
venue_93 = create_venue(offerer,
postal_code='93000',
departement_code='93',
siret=offerer.siren + '33333')
offer_93 = create_offer_with_event_product(venue_93, thumb_count=1)
offer_activation_93 = create_offer_with_event_product(
venue_93, event_type=EventType.ACTIVATION, thumb_count=1)
event_occurrence_93 = create_event_occurrence(offer_93)
event_occurrence_activation_93 = create_event_occurrence(
offer_activation_93)
stock_93 = create_stock_from_event_occurrence(event_occurrence_93)
stock_activation_93 = create_stock_from_event_occurrence(
event_occurrence_activation_93)
user = create_user(departement_code='00')
PcObject.save(user, stock_93, stock_activation_93)
# When
offers = get_active_offers(user=user,
departement_codes=['00'],
offer_id=None)
# Then
assert offer_93 in offers
assert offer_activation_93 not in offers
def when_searching_by_non_matching_date_and_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_type=EventType.CINEMA)
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=Jazz' %
strftime(self.thirty_days_from_now))
# Then
assert response.status_code == 200
assert len(response.json) == 0
def when_user_patching_is_global_admin_is_activation_offer_and_existing_deposit_for_booking_user(
self, app):
# Given
user = create_user(is_admin=False, can_book_free_offers=False)
pro_user = create_user(email='*****@*****.**',
is_admin=True,
can_book_free_offers=False)
offerer = create_offerer()
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
activation_offer = create_offer_with_event_product(
venue, event_type=EventType.ACTIVATION)
activation_event_occurrence = create_event_occurrence(
activation_offer,
beginning_datetime=Patch.tomorrow,
end_datetime=Patch.tomorrow_plus_one_hour)
stock = create_stock_from_event_occurrence(
activation_event_occurrence,
price=0,
booking_limit_date=Patch.tomorrow_minus_one_hour)
booking = create_booking(user, stock, venue=venue)
deposit = create_deposit(user, amount=500)
PcObject.save(booking, user_offerer, deposit)
user_id = user.id
url = '/bookings/token/{}'.format(booking.token)
# When
response = TestClient(
app.test_client()).with_auth('*****@*****.**').patch(url)
# Then
deposits_for_user = Deposit.query.filter_by(userId=user_id).all()
assert response.status_code == 405
assert len(deposits_for_user) == 1
assert deposits_for_user[0].amount == 500
