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_only_returns_payments_with_given_message(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
paying_stock = create_stock_from_offer(offer)
free_stock = create_stock_from_offer(offer, price=0)
user = create_user()
deposit = create_deposit(user, amount=500)
booking1 = create_booking(user, paying_stock, venue, is_used=True)
booking2 = create_booking(user, paying_stock, venue, is_used=True)
booking3 = create_booking(user, paying_stock, venue, is_used=True)
booking4 = create_booking(user, free_stock, venue, is_used=True)
payment1 = create_payment(booking1, offerer, 10, payment_message_name="ABCD123")
payment2 = create_payment(booking2, offerer, 10, payment_message_name="EFGH456")
PcObject.save(payment1, payment2)
PcObject.save(deposit, booking1, booking3, booking4)
# When
payements_by_id = get_payments_by_message_id('ABCD123')
# Then
assert len(payements_by_id) == 1
assert payements_by_id[0].paymentMessage.name == 'ABCD123'
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_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_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_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_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_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_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_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_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 when_tutos_are_not_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()
# when
auth_request = TestClient(app.test_client()).with_auth(user.email)
response = auth_request.put(RECOMMENDATION_URL, json={})
# then
assert response.status_code == 200
recommendations = response.json
assert recommendations[0]['mediation']['tutoIndex'] == 0
assert recommendations[1]['mediation']['tutoIndex'] == 1
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_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_find_online_activation_stock(app):
# given
offerer = create_offerer(siren='123456789', name='pass Culture')
venue_online = create_venue(offerer, siret=None, is_virtual=True)
venue_physical = create_venue(offerer,
siret='12345678912345',
is_virtual=False)
activation_offer = create_offer_with_thing_product(
venue_online, thing_type=ThingType.ACTIVATION)
other_thing_offer = create_offer_with_thing_product(
venue_physical, thing_type=ThingType.ACTIVATION)
event_offer = create_offer_with_event_product(venue_physical)
activation_stock = create_stock_from_offer(activation_offer,
available=200,
price=0)
other_thing_stock = create_stock_from_offer(other_thing_offer,
available=100,
price=10)
event_stock = create_stock_from_offer(event_offer, available=50, price=20)
PcObject.save(other_thing_stock, activation_stock, event_stock)
# when
stock = find_online_activation_stock()
# then
assert stock.offer.venue.isVirtual == True
assert stock.offer.product.type == 'ThingType.ACTIVATION'
assert stock.available == 200
assert stock.price == 0
def when_offers_have_non_validated_venues(self, app):
# Given
offerer = create_offerer()
venue_not_validated = create_venue(offerer, siret=None, comment='random reason')
venue_not_validated.generate_validation_token()
venue_validated = create_venue(offerer, siret=None, comment='random reason')
offer_venue_not_validated = create_offer_with_thing_product(venue_not_validated, thumb_count=1)
offer_venue_validated = create_offer_with_thing_product(venue_validated, thumb_count=1)
stock_venue_not_validated = create_stock_from_offer(offer_venue_not_validated)
stock_venue_validated = create_stock_from_offer(offer_venue_validated)
user = create_user(email='*****@*****.**')
PcObject.save(stock_venue_not_validated, stock_venue_validated, user)
venue_validated_id = venue_validated.id
venue_not_validated_id = venue_not_validated.id
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
recommendations = response.json
venue_ids = set(map(lambda x: x['offer']['venue']['id'], recommendations))
assert humanize(venue_validated_id) in venue_ids
assert humanize(venue_not_validated_id) not in venue_ids
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_user_has_no_offer_in_his_department(self, app):
# given
user = create_user(departement_code='973', can_book_free_offers=True, is_admin=False)
offerer = create_offerer()
venue29 = create_venue(offerer, siret=offerer.siren + '98765', postal_code='29000', departement_code='29')
venue34 = create_venue(offerer, siret=offerer.siren + '12345', postal_code='34000', departement_code='34')
venue93 = create_venue(offerer, siret=offerer.siren + '54321', postal_code='93000', departement_code='93')
venue67 = create_venue(offerer, siret=offerer.siren + '56789', postal_code='67000', departement_code='67')
thing_offer1 = create_offer_with_thing_product(venue93, thing_name='thing 93', url=None, is_national=False)
thing_offer2 = create_offer_with_thing_product(venue67, thing_name='thing 67', url=None, is_national=False)
thing_offer3 = create_offer_with_thing_product(venue29, thing_name='thing 29', url=None, is_national=False)
thing_offer4 = create_offer_with_thing_product(venue34, thing_name='thing 34', url=None, is_national=False)
stock1 = create_stock_from_offer(thing_offer1)
stock2 = create_stock_from_offer(thing_offer2)
stock3 = create_stock_from_offer(thing_offer3)
stock4 = create_stock_from_offer(thing_offer4)
PcObject.save(user, stock1, stock2, stock3, stock4)
# when
response = TestClient(app.test_client()).with_auth(user.email) \
.put(RECOMMENDATION_URL, json={'readRecommendations': []})
# then
assert response.status_code == 200
assert len(response.json) == 0
def when_user_has_one_offer_in_his_department(self, app):
# given
user = create_user(departement_code='93', can_book_free_offers=True, is_admin=False)
offerer = create_offerer()
venue93 = create_venue(offerer, siret=offerer.siren + '54321', postal_code='93000', departement_code='93')
venue67 = create_venue(offerer, siret=offerer.siren + '56789', postal_code='67000', departement_code='67')
thing_offer1 = create_offer_with_thing_product(venue93, thing_name='thing 93', url=None, is_national=False)
thing_offer2 = create_offer_with_thing_product(venue67, thing_name='thing 67', url=None, is_national=False)
stock1 = create_stock_from_offer(thing_offer1)
stock2 = create_stock_from_offer(thing_offer2)
PcObject.save(user, stock1, stock2)
# when
response = TestClient(app.test_client()).with_auth(user.email) \
.put(RECOMMENDATION_URL, json={'readRecommendations': []})
# then
assert response.status_code == 200
assert len(response.json) == 1
recommendation_response = response.json[0]
assert 'offer' in recommendation_response
assert 'venue' in recommendation_response['offer']
assert 'validationToken' not in recommendation_response['offer']['venue']
assert 'managingOfferer' in recommendation_response['offer']['venue']
assert 'validationToken' not in recommendation_response['offer']['venue']['managingOfferer']
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_records_new_payment_lines_in_database(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
paying_stock = create_stock_from_offer(offer)
free_stock = create_stock_from_offer(offer, price=0)
user = create_user()
deposit = create_deposit(user, amount=500)
booking1 = create_booking(user, paying_stock, venue, is_used=True)
booking2 = create_booking(user, paying_stock, venue, is_used=True)
booking3 = create_booking(user, paying_stock, venue, is_used=True)
booking4 = create_booking(user, free_stock, venue, is_used=True)
payment1 = create_payment(booking2,
offerer,
10,
payment_message_name="ABCD123")
PcObject.save(payment1)
PcObject.save(deposit, booking1, booking3, booking4)
initial_payment_count = Payment.query.count()
# When
generate_new_payments()
# Then
assert Payment.query.count() - initial_payment_count == 2
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 when_user_has_an_offerer_attached_and_venue_id_argument_is_valid(
self, app):
# Given
user = create_user(email='*****@*****.**')
deposit = create_deposit(user, amount=500, source='public')
offerer1 = create_offerer()
offerer2 = create_offerer(siren='123456788')
user_offerer1 = create_user_offerer(user,
offerer1,
validation_token=None)
user_offerer2 = create_user_offerer(user,
offerer2,
validation_token=None)
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer1, siret='12345678912346')
venue3 = create_venue(offerer2, siret='12345678912347')
offer1 = create_offer_with_event_product(venue1)
offer2 = create_offer_with_thing_product(venue1)
offer3 = create_offer_with_thing_product(venue2)
stock1 = create_stock_from_offer(offer1, available=100, price=20)
stock2 = create_stock_from_offer(offer2, available=150, price=16)
stock3 = create_stock_from_offer(offer3, available=150, price=18)
booking1 = create_booking(user,
stock1,
venue=venue1,
token='ABCDEF')
booking2 = create_booking(user,
stock1,
venue=venue1,
token='ABCDEG')
booking3 = create_booking(user,
stock2,
venue=venue2,
token='ABCDEH')
booking4 = create_booking(user,
stock3,
venue=venue3,
token='ABCDEI')
PcObject.save(deposit, booking1, booking2, booking3, booking4,
user_offerer1, user_offerer2)
url = '/bookings/csv?venueId=%s' % (humanize(venue1.id))
# When
response = TestClient(app.test_client()).with_auth(
user.email).get(url)
# Then
content_lines = response.data.decode('utf-8').split('\n')[1:-1]
assert response.status_code == 200
assert response.headers[
'Content-type'] == 'text/csv; charset=utf-8;'
assert response.headers[
'Content-Disposition'] == 'attachment; filename=reservations_pass_culture.csv'
assert len(content_lines) == 3
def test_list_activation_offers_returns_offers_of_event_type(
self, app):
# given
user = create_user()
PcObject.save(user)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
now = datetime.utcnow()
five_days_ago = now - timedelta(days=5)
next_week = now + timedelta(days=7)
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)
stock1 = create_stock_from_offer(
offer1, price=0, booking_limit_datetime=five_days_ago)
stock2 = create_stock_from_offer(offer2,
price=0,
booking_limit_datetime=next_week)
stock3 = create_stock_from_offer(offer3,
price=0,
booking_limit_datetime=None)
PcObject.save(stock1, stock2, stock3)
# when
response = auth_request.get('/offers/activation')
# then
json = response.json
event_ids = [
info['productId'] for info in json
if ProductType.is_event(info['type'])
]
assert len(json) == 2
assert response.status_code == 200
assert humanize(offer2.productId) in event_ids
assert humanize(offer3.productId) in event_ids
def test_file_has_recipient_name_and_siren_in_creditor_info(self, app):
# Given
offerer1 = create_offerer(name='first offerer', siren='123456789')
offerer2 = create_offerer(name='second offerer', siren='987654321')
offerer3 = create_offerer()
user = create_user()
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
venue3 = create_venue(offerer3)
stock1 = create_stock_from_offer(
create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(
create_offer_with_thing_product(venue2))
stock3 = create_stock_from_offer(
create_offer_with_thing_product(venue3))
booking1 = create_booking(user, stock1)
booking2 = create_booking(user, stock2)
booking3 = create_booking(user, stock3)
payments = [
create_payment(booking1,
offerer1,
Decimal(10),
iban='CF13QSDFGH456789',
bic='QSDFGH8Z555'),
create_payment(booking2,
offerer2,
Decimal(20),
iban='FR14WXCVBN123456',
bic='WXCVBN7B444'),
create_payment(booking3,
offerer3,
Decimal(20),
iban=None,
bic=None)
]
# When
xml = generate_message_file(payments, 'BD12AZERTY123456',
'AZERTY9Q666', MESSAGE_ID, '0000')
# Then
assert find_all_nodes('//ns:PmtInf/ns:CdtTrfTxInf/ns:Cdtr/ns:Nm',
xml)[0] == 'first offerer'
assert find_all_nodes(
'//ns:PmtInf/ns:CdtTrfTxInf/ns:Cdtr/ns:Id/ns:OrgId/ns:Othr/ns:Id',
xml)[0] == '123456789'
assert find_all_nodes('//ns:PmtInf/ns:CdtTrfTxInf/ns:Cdtr/ns:Nm',
xml)[1] == 'second offerer'
assert find_all_nodes(
'//ns:PmtInf/ns:CdtTrfTxInf/ns:Cdtr/ns:Id/ns:OrgId/ns:Othr/ns:Id',
xml)[1] == '987654321'
def test_file_has_bic_in_credit_transfer_transaction_info(self, app):
# Given
offerer1 = create_offerer(name='first offerer')
offerer2 = create_offerer(name='second offerer')
offerer3 = create_offerer(name='third offerer')
user = create_user()
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
venue3 = create_venue(offerer3)
stock1 = create_stock_from_offer(
create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(
create_offer_with_thing_product(venue2))
stock3 = create_stock_from_offer(
create_offer_with_thing_product(venue3))
booking1 = create_booking(user, stock1)
booking2 = create_booking(user, stock2)
booking3 = create_booking(user, stock3)
payments = [
create_payment(
booking1,
offerer1,
Decimal(10),
iban='CF13QSDFGH456789',
bic='QSDFGH8Z555',
transaction_label='remboursement 1ère quinzaine 09-2018'),
create_payment(
booking2,
offerer2,
Decimal(20),
iban='FR14WXCVBN123456',
bic='WXCVBN7B444',
transaction_label='remboursement 1ère quinzaine 09-2018'),
create_payment(
booking3,
offerer3,
Decimal(20),
iban=None,
bic=None,
transaction_label='remboursement 1ère quinzaine 09-2018')
]
# When
xml = generate_message_file(payments, 'BD12AZERTY123456',
'AZERTY9Q666', MESSAGE_ID, '0000')
# Then
assert find_all_nodes('//ns:PmtInf/ns:CdtTrfTxInf/ns:RmtInf/ns:Ustrd', xml)[0] \
== 'remboursement 1ère quinzaine 09-2018'
assert find_all_nodes('//ns:PmtInf/ns:CdtTrfTxInf/ns:RmtInf/ns:Ustrd', xml)[1] \
== 'remboursement 1ère quinzaine 09-2018'
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 test_reimburses_95_percent_for_book_product_when_bookings_exceed_100000_euros(
self, app):
# Given
offerer1 = create_offerer(siren='123456789')
PcObject.save(offerer1)
bank_information = create_bank_information(
bic='BDFEFR2LCCB',
iban='FR7630006000011234567890189',
id_at_providers='123456789',
offerer=offerer1)
venue1 = create_venue(offerer1, siret='12345678912345')
venue2 = create_venue(offerer1, siret='98765432154321')
venue3 = create_venue(offerer1, siret='98123432154321')
offer1 = create_offer_with_thing_product(
venue1, thing_type=ThingType.LIVRE_EDITION, url=None)
offer2 = create_offer_with_thing_product(
venue2, thing_type=ThingType.LIVRE_EDITION, url=None)
offer3 = create_offer_with_thing_product(
venue3, thing_type=ThingType.LIVRE_EDITION, url=None)
paying_stock1 = create_stock_from_offer(offer1, price=10000)
paying_stock2 = create_stock_from_offer(offer2, price=10000)
paying_stock3 = create_stock_from_offer(offer3, price=100000)
user = create_user()
deposit = create_deposit(user, amount=120000)
booking1 = create_booking(user,
paying_stock1,
venue1,
quantity=1,
is_used=True)
booking2 = create_booking(user,
paying_stock2,
venue2,
quantity=1,
is_used=True)
booking3 = create_booking(user,
paying_stock3,
venue3,
quantity=1,
is_used=True)
PcObject.save(deposit, booking1, booking2, booking3,
bank_information)
# When
pending, not_processable = generate_new_payments()
# Then
assert len(pending) == 3
assert len(not_processable) == 0
assert sum(p.amount for p in pending) == 115000
def test_file_has_iban_in_credit_transfer_transaction_info(self, app):
# Given
offerer1 = create_offerer()
offerer2 = create_offerer()
offerer3 = create_offerer()
user = create_user()
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer2)
venue3 = create_venue(offerer3)
stock1 = create_stock_from_offer(
create_offer_with_thing_product(venue1))
stock2 = create_stock_from_offer(
create_offer_with_thing_product(venue2))
stock3 = create_stock_from_offer(
create_offer_with_thing_product(venue3))
booking1 = create_booking(user, stock1)
booking2 = create_booking(user, stock2)
booking3 = create_booking(user, stock3)
payments = [
create_payment(booking1,
offerer1,
Decimal(10),
iban='CF13QSDFGH456789',
bic='QSDFGH8Z555'),
create_payment(booking2,
offerer2,
Decimal(20),
iban='FR14WXCVBN123456',
bic='WXCVBN7B444'),
create_payment(booking3,
offerer3,
Decimal(20),
iban=None,
bic=None)
]
# When
xml = generate_message_file(payments, 'BD12AZERTY123456',
'AZERTY9Q666', MESSAGE_ID, '0000')
# Then
assert find_all_nodes(
'//ns:PmtInf/ns:CdtTrfTxInf/ns:CdtrAcct/ns:Id/ns:IBAN',
xml)[0] == 'CF13QSDFGH456789'
assert find_all_nodes(
'//ns:PmtInf/ns:CdtTrfTxInf/ns:CdtrAcct/ns:Id/ns:IBAN',
xml)[1] == 'FR14WXCVBN123456'
def test_raises_error_on_booking_when_existing_booking_is_used_and_booking_date_is_after_last_update_on_stock(
app):
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock_from_offer(offer, price=0, available=1)
user1 = create_user(email='*****@*****.**')
user2 = create_user(email='*****@*****.**')
PcObject.save(stock)
date_after_stock_last_update = datetime.utcnow()
booking1 = create_booking(user1,
stock,
date_used=date_after_stock_last_update,
is_cancelled=False,
is_used=True)
PcObject.save(booking1)
date_after_last_booking = datetime.utcnow()
booking2 = create_booking(user2,
stock,
date_used=date_after_last_booking,
is_cancelled=False,
is_used=False)
# When
with pytest.raises(ApiErrors) as e:
PcObject.save(booking2)
# Then
assert e.value.errors['global'] == [
'la quantité disponible pour cette offre est atteinte'
]
