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_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 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_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 when_feature_send_mail_to_users_enabled_and_not_offer_booking_email_sends_only_to_administration(
self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue, booking_email=None)
stock = create_stock_with_thing_offer(offerer,
venue,
offer,
booking_email=None)
booking = create_booking(user, stock)
mocked_send_email = Mock()
return_value = Mock()
return_value.status_code = 200
mocked_send_email.return_value = return_value
with patch('utils.mailing.feature_send_mail_to_users_enabled'
) as send_mail_to_users:
send_mail_to_users.return_value = True
# when
send_booking_recap_emails(booking, mocked_send_email)
# then
mocked_send_email.assert_called_once()
args = mocked_send_email.call_args
assert args[1]['data']['To'] == '*****@*****.**'
def when_feature_send_mail_to_users_disabled_sends_email_to_pass_culture_dev(
self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(
venue, booking_email='*****@*****.**')
stock = create_stock_with_thing_offer(offerer, venue, offer)
booking = create_booking(user, stock)
mocked_send_email = Mock()
return_value = Mock()
return_value.status_code = 200
mocked_send_email.return_value = return_value
with patch('utils.mailing.feature_send_mail_to_users_enabled'
) as send_mail_to_users:
send_mail_to_users.return_value = False
# when
send_booking_recap_emails(booking, mocked_send_email)
# then
mocked_send_email.assert_called_once()
args = mocked_send_email.call_args
assert args[1]['data']['To'] == '*****@*****.**'
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_is_cancelled(self, app):
# Given
user = create_user(email='*****@*****.**')
admin_user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
stock = create_stock_with_thing_offer(offerer,
venue,
offer=None,
price=0)
booking = create_booking(user,
stock,
venue=venue,
is_cancelled=True)
PcObject.save(admin_user, booking)
url = '/bookings/token/{}?email={}&offer_id={}'.format(
booking.token, '*****@*****.**', humanize(stock.offerId))
# When
response = TestClient(app.test_client()).get(url)
# Then
assert response.status_code == 410
assert response.json['booking'] == [
'Cette réservation a été annulée'
]
def test_returns_two_recommendations_with_one_event_and_one_thing(self, app):
# given
now = datetime.utcnow()
four_days_from_now = now + timedelta(days=4)
eight_days_from_now = now + timedelta(days=8)
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer_event = create_offer_with_event_product(venue, thumb_count=1, dominant_color=b'123')
event_occurrence = create_event_occurrence(
offer_event,
beginning_datetime=four_days_from_now,
end_datetime=eight_days_from_now
)
event_stock = create_stock_from_event_occurrence(event_occurrence, price=0, available=20)
offer_thing = create_offer_with_thing_product(venue, thumb_count=1, dominant_color=b'123')
stock_thing = create_stock_with_thing_offer(offerer, venue, offer_thing, price=0)
PcObject.save(user, event_stock, stock_thing)
auth_request = TestClient(app.test_client()).with_auth(user.email)
# when
response = auth_request.put(RECOMMENDATION_URL, json={'seenRecommendationIds': []})
# then
assert response.status_code == 200
assert len(response.json) == 2
def when_already_booked_by_user_but_cancelled(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
thing_offer = create_offer_with_thing_product(venue)
deposit_date = datetime.utcnow() - timedelta(minutes=2)
deposit = create_deposit(user, amount=200)
stock = create_stock_with_thing_offer(offerer,
venue,
thing_offer,
price=90)
booking = create_booking(user, stock, venue, is_cancelled=True)
PcObject.save(stock, user, booking)
booking_json = {
'stockId': humanize(stock.id),
'recommendationId': None,
'quantity': 1
}
# When
response = TestClient(
app.test_client()).with_auth('*****@*****.**').post(
'/bookings', json=booking_json)
# Then
assert response.status_code == 201
def test_generate_payment_details_csv_with_right_values(self, app):
# given
deactivate_feature(FeatureToggle.DEGRESSIVE_REIMBURSEMENT_RATE)
user = create_user(email='*****@*****.**')
deposit = create_deposit(user, amount=500, source='public')
offerer1 = create_offerer()
user_offerer1 = create_user_offerer(user, offerer1, validation_token=None)
venue1 = create_venue(offerer1)
bank_information1 = create_bank_information(id_at_providers='79387501900056', venue=venue1)
stock1 = create_stock_with_thing_offer(offerer=offerer1, venue=venue1, price=10)
booking1 = create_booking(user, stock1, venue=venue1, token='ABCDEF', is_used=True)
booking2 = create_booking(user, stock1, venue=venue1, token='ABCDEG')
PcObject.save(deposit, booking1, booking2, user_offerer1, bank_information1)
generate_new_payments()
reimbursement_details = find_all_offerer_reimbursement_details(offerer1.id)
# when
csv = generate_reimbursement_details_csv(reimbursement_details)
# then
assert _count_non_empty_lines(csv) == 2
assert _get_header(csv,
1) == "2019;Juillet : remboursement 1ère quinzaine;La petite librairie;12345678912345;123 rue de Paris;FR7630006000011234567890189;La petite librairie;Test Book;Doe;John;ABCDEF;;10.00;Remboursement initié"
def when_null_quantity(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
thing_offer = create_offer_with_thing_product(venue)
stock = create_stock_with_thing_offer(offerer,
venue,
thing_offer,
price=90)
PcObject.save(stock, user)
booking_json = {
'stockId': humanize(stock.id),
'recommendationId': None,
'quantity': 0
}
# When
response = TestClient(
app.test_client()).with_auth('*****@*****.**').post(
'/bookings', json=booking_json)
# Then
error_message = response.json
assert response.status_code == 400
assert error_message['quantity'] == [
'Vous devez préciser une quantité pour la réservation'
]
def when_stock_is_soft_deleted(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
thing_offer = create_offer_with_thing_product(venue)
stock = create_stock_with_thing_offer(offerer,
venue,
thing_offer,
price=90)
stock.isSoftDeleted = True
PcObject.save(stock, user)
booking_json = {
'stockId': humanize(stock.id),
'recommendationId': None,
'quantity': 1,
}
# When
response = TestClient(
app.test_client()).with_auth('*****@*****.**').post(
'/bookings', json=booking_json)
# Then
error_message = response.json
assert response.status_code == 400
assert error_message['stockId'] == [
"Cette date a été retirée. Elle n'est plus disponible."
]
def when_more_than_one_quantity(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
thing_offer = create_offer_with_thing_product(venue)
stock = create_stock_with_thing_offer(offerer,
venue,
thing_offer,
price=90)
PcObject.save(stock, user)
booking_json = {
'stockId': humanize(stock.id),
'recommendationId': None,
'quantity': 5
}
# When
response = TestClient(
app.test_client()).with_auth('*****@*****.**').post(
'/bookings', json=booking_json)
# Then
error_message = response.json
assert response.status_code == 400
assert error_message['quantity'] == [
"Vous ne pouvez pas réserver plus d'une offre à la fois"
]
def when_thing_booking_limit_datetime_has_expired(self, app):
# Given
four_days_ago = datetime.utcnow() - timedelta(days=4)
five_days_ago = datetime.utcnow() - timedelta(days=5)
user = create_user(email='*****@*****.**')
offerer = create_offerer()
deposit_date = datetime.utcnow() - timedelta(minutes=2)
deposit = create_deposit(user, amount=200)
venue = create_venue(offerer)
stock = create_stock_with_thing_offer(
offerer, venue, price=20, booking_limit_datetime=four_days_ago)
PcObject.save(deposit, stock, user)
booking_json = {
'stockId': humanize(stock.id),
'recommendationId': None,
'quantity': 1
}
# When
response = TestClient(
app.test_client()).with_auth('*****@*****.**').post(
'/bookings', json=booking_json)
# Then
error_message = response.json
assert response.status_code == 400
assert error_message['global'] == [
"La date limite de réservation de cette offre est dépassée"
]
def when_booking_limit_datetime_is_none(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
deposit = create_deposit(user, amount=200)
venue = create_venue(offerer)
thing_offer = create_offer_with_thing_product(venue)
stock = create_stock_with_thing_offer(offerer,
venue,
thing_offer,
price=20,
booking_limit_datetime=None)
PcObject.save(deposit, stock, user)
booking_json = {
'stockId': humanize(stock.id),
'recommendationId': None,
'quantity': 1
}
# When
response = TestClient(
app.test_client()).with_auth('*****@*****.**').post(
'/bookings', json=booking_json)
# Then
assert response.status_code == 201
def when_non_validated_venue(self, app):
# Given
user = create_user(email='*****@*****.**')
deposit = create_deposit(user)
offerer = create_offerer()
venue = create_venue(offerer)
venue.generate_validation_token()
thing_offer = create_offer_with_thing_product(venue)
stock = create_stock_with_thing_offer(offerer,
venue,
thing_offer,
price=10)
PcObject.save(stock, user, deposit)
booking_json = {
'stockId': humanize(stock.id),
'recommendationId': None,
'quantity': 1
}
# When
r_create = TestClient(app.test_client()) \
.with_auth(user.email) \
.post('/bookings', json=booking_json)
# Then
assert r_create.status_code == 400
assert r_create.json['stockId'] == [
'Vous ne pouvez pas encore réserver cette offre, son lieu est en attente de validation'
]
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_find_all_offerer_reimbursement_details(self, app):
# Given
user = create_user(email='*****@*****.**')
deposit = create_deposit(user, amount=500, source='public')
offerer1 = create_offerer()
user_offerer1 = create_user_offerer(user,
offerer1,
validation_token=None)
venue1 = create_venue(offerer1)
venue2 = create_venue(offerer1, siret='12345678912346')
bank_information1 = create_bank_information(
id_at_providers='79387501900056', venue=venue1)
bank_information2 = create_bank_information(
id_at_providers='79387501900057', venue=venue2)
offer1 = create_offer_with_thing_product(
venue1,
url='https://host/path/{token}?offerId={offerId}&email={email}')
offer2 = create_offer_with_thing_product(venue2)
stock1 = create_stock_with_thing_offer(offerer=offerer1,
venue=venue1,
price=10)
stock2 = create_stock_with_thing_offer(offerer=offerer1,
venue=venue2,
price=11)
booking1 = create_booking(user,
stock1,
venue=venue1,
token='ABCDEF',
is_used=True)
booking2 = create_booking(user, stock1, venue=venue1, token='ABCDEG')
booking3 = create_booking(user,
stock2,
venue=venue2,
token='ABCDEH',
is_used=True)
PcObject.save(deposit, booking1, booking2, booking3, user_offerer1,
bank_information1, bank_information2)
generate_new_payments()
# When
reimbursement_details = find_all_offerer_reimbursement_details(
offerer1.id)
# Then
assert len(reimbursement_details) == 2
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 save_sandbox():
offerer = create_offerer()
venue = create_venue(offerer, is_virtual=True, siret=None)
offer = create_offer_with_thing_product(venue,
thing_type=ThingType.ACTIVATION)
stock = create_stock_with_thing_offer(offerer,
venue,
offer=offer,
price=0,
available=10000)
PcObject.save(stock)
def when_user_has_an_offerer_attached(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')
bank_information1 = create_bank_information(id_at_providers='79387501900056', venue=venue1)
bank_information2 = create_bank_information(id_at_providers='79387501900057', venue=venue2)
stock1 = create_stock_with_thing_offer(offerer=offerer1, venue=venue1, price=10)
stock2 = create_stock_with_thing_offer(offerer=offerer1, venue=venue2, price=11)
stock3 = create_stock_with_thing_offer(offerer=offerer2, venue=venue3, price=12)
stock4 = create_stock_with_thing_offer(offerer=offerer2, venue=venue3, price=13)
booking1 = create_booking(user, stock1, venue=venue1, token='ABCDEF', is_used=True)
booking2 = create_booking(user, stock1, venue=venue1, token='ABCDEG')
booking3 = create_booking(user, stock2, venue=venue2, token='ABCDEH', is_used=True)
booking4 = create_booking(user, stock3, venue=venue3, token='ABCDEI', is_used=True)
booking5 = create_booking(user, stock4, venue=venue3, token='ABCDEJ', is_used=True)
booking6 = create_booking(user, stock4, venue=venue3, token='ABCDEK', is_used=True)
PcObject.save(deposit, booking1, booking2, booking3,
booking4, booking5, booking6, user_offerer1,
user_offerer2, bank_information1, bank_information2)
generate_new_payments()
# When
response = TestClient(app.test_client()).with_auth(user.email).get(
'/reimbursements/csv')
response_lines = response.data.decode('utf-8').split('\n')
# Then
assert response.status_code == 200
assert response.headers['Content-type'] == 'text/csv; charset=utf-8;'
assert response.headers['Content-Disposition'] == 'attachment; filename=remboursements_pass_culture.csv'
assert len(response_lines) == 7
def when_user_cannot_book_free_offers_but_has_enough_credit_for_paid_offer(
self, app):
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, 'Test offerer',
'*****@*****.**', '123 rue test',
'93000', 'Test city', '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=10)
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
r_create_json = r_create.json
assert r_create.status_code == 201
assert r_create_json['amount'] == 10.0
assert r_create_json['quantity'] == 1
def when_given_mediation_does_not_match_given_offer(self, app):
# given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer_thing_1 = create_offer_with_thing_product(venue, thumb_count=1, dominant_color=b'123')
offer_thing_2 = create_offer_with_thing_product(venue, thumb_count=1, dominant_color=b'123')
stock_thing_1 = create_stock_with_thing_offer(offerer, venue, offer_thing_1, price=0)
stock_thing_2 = create_stock_with_thing_offer(offerer, venue, offer_thing_2, price=0)
mediation_1 = create_mediation(offer_thing_1)
mediation_2 = create_mediation(offer_thing_2)
PcObject.save(user, stock_thing_1, stock_thing_2, mediation_1, mediation_2)
auth_request = TestClient(app.test_client()).with_auth(user.email)
# when
response = auth_request.put(RECOMMENDATION_URL +
"?offerId=" +
humanize(offer_thing_1.id) +
"?mediationId=" +
humanize(mediation_2.id), json={'seenRecommendationIds': []})
# then
assert response.status_code == 404
def when_too_many_bookings(self, app):
# given
offerer = create_offerer('987654321', 'Test address', 'Test city',
'93000', 'Test name')
venue = create_venue(offerer, 'Test offerer',
'*****@*****.**', '123 rue test',
'93000', 'Test city', '93')
too_many_bookings_stock = create_stock_with_thing_offer(
offerer=Offerer(), venue=venue, offer=None, available=2)
user = create_user(email='*****@*****.**')
user2 = create_user(email='*****@*****.**')
deposit = create_deposit(user, amount=500)
deposit2 = create_deposit(user2, amount=500)
recommendation = create_recommendation(
offer=too_many_bookings_stock.offer, user=user)
booking = create_booking(user2,
too_many_bookings_stock,
venue,
quantity=2)
PcObject.save(booking, recommendation, user, deposit, deposit2,
too_many_bookings_stock)
booking_json = {
'stockId': humanize(too_many_bookings_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 'global' in r_create.json
assert 'quantité disponible' in r_create.json['global'][0]
def when_user_has_enough_credit(self, app):
# Given
offerer = create_offerer('819202819', '1 Fake Address',
'Fake city', '93000', 'Fake offerer')
venue = create_venue(offerer, 'venue name', '*****@*****.**',
'1 fake street', '93000', 'False city', '93')
thing_offer = create_offer_with_thing_product(venue)
user = create_user(email='*****@*****.**')
PcObject.save(user)
stock = create_stock_with_thing_offer(offerer,
venue,
thing_offer,
price=50,
available=1)
PcObject.save(stock)
recommendation = create_recommendation(thing_offer, user)
PcObject.save(recommendation)
deposit = create_deposit(user, amount=50)
PcObject.save(deposit)
booking_json = {
'stockId': humanize(stock.id),
'recommendationId': humanize(recommendation.id),
'quantity': 1
}
# when
response = TestClient(app.test_client()) \
.with_auth('*****@*****.**') \
.post('/bookings', json=booking_json)
# then
assert response.status_code == 201
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']['venue']
def when_offer_is_known_and_mediation_is_unknown(self, app):
# given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer_thing = create_offer_with_thing_product(venue, thumb_count=1, dominant_color=b'123')
stock_thing = create_stock_with_thing_offer(offerer, venue, offer_thing, price=0)
mediation = create_mediation(offer_thing)
PcObject.save(user, stock_thing, mediation)
auth_request = TestClient(app.test_client()).with_auth(user.email)
# when
response = auth_request.put(RECOMMENDATION_URL +
"?offerId=" +
humanize(offer_thing.id) +
"?mediationId=" +
"ABCDE", json={'seenRecommendationIds': []})
# then
assert response.status_code == 404
def when_not_logged_in_and_give_right_email_and_offer_id_thing(
self, app):
# Given
user = create_user(email='*****@*****.**')
admin_user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
stock = create_stock_with_thing_offer(offerer,
venue,
offer=None,
price=0)
booking = create_booking(user, stock, venue=venue)
PcObject.save(admin_user, booking)
url = '/bookings/token/{}?email={}&offer_id={}'.format(
booking.token, '*****@*****.**', humanize(stock.offerId))
# When
response = TestClient(app.test_client()).get(url)
# Then
assert response.status_code == 204
def test_should_return_offers_that_occur_in_less_than_10_days_and_things_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')
stock2 = create_stock_with_event_offer(
offerer,
venue,
beginning_datetime=datetime.utcnow() + timedelta(days=4),
end_datetime=datetime.utcnow() + timedelta(days=4, hours=2),
name='event_occurs_soon',
thumb_count=1)
stock3 = create_stock_with_event_offer(
offerer,
venue,
beginning_datetime=datetime.utcnow() + timedelta(days=11),
end_datetime=datetime.utcnow() + timedelta(days=11, hours=2),
name='event_occurs_later',
thumb_count=1)
PcObject.save(stock3)
PcObject.save(stock2)
PcObject.save(stock1)
# When
offers = get_active_offers(user=create_user(email="*****@*****.**"),
departement_codes=['00'],
offer_id=None)
# Then
assert len(offers) == 3
assert (offers[0].name == 'event_occurs_soon'
and offers[1].name == 'thing') \
or (offers[1].name == 'event_occurs_soon'
and offers[0].name == 'thing')
assert offers[2].name == 'event_occurs_later'
def when_booking_limit_datetime_is_none_for_thing(self, app):
# Given
user = create_user(email='*****@*****.**', can_book_free_offers=False, is_admin=True)
offerer = create_offerer()
venue = create_venue(offerer)
stock = create_stock_with_thing_offer(offerer, venue)
PcObject.save(user, stock)
stock_id = stock.id
data = {
'price': 120,
'offerId': humanize(stock.offer.id),
'bookingLimitDatetime': None
}
# When
response = TestClient(app.test_client()).with_auth(user.email) \
.patch('/stocks/' + humanize(stock.id), json=data)
# Then
assert response.status_code == 200
assert Stock.query.get(stock_id).price == 120
