def test_finds_all_payments_linked_to_offerer(self, app):
# Given
offerer = create_offerer()
other_offerer = create_offerer(siren='987654321')
venue = create_venue(offerer)
other_venue = create_venue(other_offerer, siret=other_offerer.siren + '12345')
bank_information = create_bank_information(offerer=offerer, id_at_providers=offerer.siren)
other_bank_information = create_bank_information(offerer=other_offerer, id_at_providers=other_venue.siret)
user = create_user()
offer = create_offer_with_thing_product(venue)
other_offer = create_offer_with_thing_product(other_venue)
stock = create_stock(offer=offer, price=0)
other_stock = create_stock(offer=other_offer, price=0)
booking = create_booking(user, stock, venue)
other_booking = create_booking(user, other_stock, other_venue)
payment = create_payment(booking, offerer, 10)
other_payment = create_payment(other_booking, other_offerer, 10)
payment.setStatus(TransactionStatus.NOT_PROCESSABLE)
other_payment.setStatus(TransactionStatus.NOT_PROCESSABLE)
PcObject.save(payment, other_payment)
# When
payments = find_all_with_status_not_processable_for_bank_information(bank_information)
# Then
assert len(payments) == 1
def test_should_return_multiple_departements_and_order_by_desc_booking_counts(self, app):
# Given
offerer93 = create_offerer(name='Offerer dans le 93', siren=111111111)
venue93 = create_venue(offerer93, departement_code='93', siret=11111111100001)
offer93 = create_offer_with_thing_product(venue93)
stock93 = create_stock(offer=offer93, price=10)
offerer95 = create_offerer(name='Offerer dans le 95', siren=222222222)
venue95 = create_venue(offerer95, departement_code='95', siret=22222222200001)
offer95 = create_offer_with_thing_product(venue95)
stock95 = create_stock(offer=offer95, price=10)
user_in_95 = create_user(departement_code='95', email="*****@*****.**")
create_deposit(user_in_95, amount=500)
booking_in_95 = create_booking(user_in_95, stock95, quantity=5)
user_in_93 = create_user(departement_code='93', email="*****@*****.**")
create_deposit(user_in_93, amount=500)
booking_in_93 = create_booking(user_in_93, stock93, quantity=2)
PcObject.save(booking_in_93, booking_in_95)
# When
bookings_by_departement = _query_get_non_cancelled_bookings_by_user_departement()
# Then
assert len(bookings_by_departement) == 2
assert bookings_by_departement == [('95', 5), ('93', 2)]
def test_returns_offerers_filtered_by_departement_based_on_venue(
self, app):
# Given
offerer1 = create_offerer(name='Small library', siren='111111111')
venue1 = create_venue(offerer1,
postal_code='33130',
siret='11111111100001')
offer1 = create_offer_with_thing_product(venue1)
stock1 = create_stock(offer=offer1, price=30)
offerer2 = create_offerer(name='National book store',
siren='222222222')
venue2 = create_venue(offerer2,
postal_code='33130',
siret='22222222200001')
offer2 = create_offer_with_thing_product(venue=venue2)
stock2 = create_stock(offer=offer2, price=10)
user_76 = create_user(departement_code='76')
user_77 = create_user(email='*****@*****.**', departement_code='77')
create_deposit(user_76, amount=500)
create_deposit(user_77, amount=500)
booking1 = create_booking(user_76, stock1, quantity=2)
booking2 = create_booking(user_76, stock2, quantity=2)
booking3 = create_booking(user_77, stock2, quantity=2)
PcObject.save(booking1, booking2, booking3)
# When
bookings_counts = _query_get_top_20_offerers_by_booking_amounts('76')
# Then
assert bookings_counts == [('Small library', 2, 60),
('National book store', 2, 20)]
def test_returns_false_if_all_stocks_have_no_booking_limit_datetime(self):
# given
offer = Offer()
stock1 = create_stock(booking_limit_datetime=None)
stock2 = create_stock(booking_limit_datetime=None)
stock3 = create_stock(booking_limit_datetime=None)
offer.stocks = [stock1, stock2, stock3]
# then
assert offer.isFinished is False
def test_returns_true_if_all_stocks_have_past_booking_limit_datetime(self):
# given
now = datetime.utcnow()
offer = Offer()
stock1 = create_stock(booking_limit_datetime=now - timedelta(weeks=3))
stock2 = create_stock(booking_limit_datetime=now - timedelta(weeks=2))
stock3 = create_stock(booking_limit_datetime=now - timedelta(weeks=1))
offer.stocks = [stock1, stock2, stock3]
# then
assert offer.isFinished is True
def test_returns_false_if_any_stock_has_future_booking_limit_datetime(
self):
# given
now = datetime.utcnow()
offer = Offer()
stock1 = create_stock(booking_limit_datetime=now - timedelta(weeks=3))
stock2 = create_stock(booking_limit_datetime=None)
stock3 = create_stock(booking_limit_datetime=now + timedelta(weeks=1))
offer.stocks = [stock1, stock2, stock3]
# then
assert offer.isFinished is False
def test_returns_false_if_stocks_have_none_available_quantity(self):
# given
offer = Offer()
user = create_user()
stock1 = create_stock(available=None)
stock2 = create_stock(available=None)
create_booking(user, stock=stock1, quantity=1)
create_booking(user, stock=stock2, quantity=1)
offer.stocks = [stock1, stock2]
# then
assert offer.isFullyBooked is False
def test_stocks_with_past_booking_limit_datetimes_are_ignored(self):
# given
offer = Offer()
user = create_user()
stock1 = create_stock(available=2,
booking_limit_datetime=datetime.utcnow() -
timedelta(weeks=3))
stock2 = create_stock(available=1)
stock3 = create_stock(available=1)
create_booking(user, stock=stock2, quantity=1)
create_booking(user, stock=stock3, quantity=1)
offer.stocks = [stock1, stock2, stock3]
# then
assert offer.isFullyBooked is True
def test_returns_true_ignoring_cancelled_bookings(self):
# given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
user = create_user()
stock1 = create_stock(available=2)
stock2 = create_stock(available=1)
create_booking(user, stock=stock1, quantity=1)
create_booking(user, stock=stock1, quantity=1, is_cancelled=True)
create_booking(user, stock=stock2, quantity=1)
offer.stocks = [stock1, stock2]
# then
assert offer.isFullyBooked is False
def test_returns_true_if_all_available_stocks_are_booked(self):
# given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
user = create_user()
stock1 = create_stock(available=2)
stock2 = create_stock(available=1)
create_booking(user, stock=stock1, quantity=1)
create_booking(user, stock=stock1, quantity=1)
create_booking(user, stock=stock2, quantity=1)
offer.stocks = [stock1, stock2]
# then
assert offer.isFullyBooked is True
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 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 save_reimbursable_thing_offer(venue: Venue):
paid_reimbursable_offer = create_offer_with_thing_product(
venue, thing_name='Roman cool', thing_type=ThingType.LIVRE_EDITION)
reimbursable_stock = create_stock(price=30, offer=paid_reimbursable_offer)
PcObject.save(reimbursable_stock)
logger.info('created 1 reimbursable thing offer with 1 paid stock of 30 €')
return reimbursable_stock
def test_returns_only_payment_total_by_department(self, app):
# Given
offerer = create_offerer(siren='111111111')
venue = create_venue(offerer,
postal_code='78490',
siret='11111111100002')
offer = create_offer_with_thing_product(venue)
stock = create_stock(price=10, offer=offer)
user_in_35 = create_user(email='*****@*****.**',
departement_code='35')
user_in_78 = create_user(email='*****@*****.**',
departement_code='78')
create_deposit(user_in_35, amount=500)
create_deposit(user_in_78, amount=500)
booking_in_35 = create_booking(user_in_35, stock=stock, venue=venue)
booking_in_78 = create_booking(user_in_78, stock=stock, venue=venue)
payment1 = create_payment(booking_in_35, offerer, amount=20)
payment2 = create_payment(booking_in_78, offerer, amount=10)
PcObject.save(user_in_35, venue, payment1, payment2)
# When
total_amount_to_pay = get_total_amount_to_pay('35')
# Then
assert total_amount_to_pay == 20
def test_delete_venue_and_offers_should_raise_an_attribute_error_when_at_least_one_offer_has_stocks(self, app):
# Given
offerer = create_offerer("123456789")
venue = create_venue(
offerer,
idx=1,
siret='12345678900002',
address='1 rue Vieille Adresse',
name='Vieux nom',
city='Vieilleville',
latitude='48.863',
longitude='2.36',
postal_code='75001')
offer1 = create_offer_with_event_product(venue)
offer2 = create_offer_with_event_product(venue)
stock = create_stock(offer=offer1)
PcObject.save(offer1, offer2, stock, venue)
# When
with pytest.raises(AttributeError) as e:
delete_venue_and_offers_for_venue_id(humanize(venue.id))
# Then
assert str(e.value) == 'Offres non supprimables car au moins une contient des stocks'
def when_stock_is_on_an_offer_from_provider(self, app):
# given
tite_live_provider = Provider \
.query \
.filter(Provider.localClass == 'TiteLiveThings') \
.first()
user = create_user(email='*****@*****.**')
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_thing_product(
venue, last_provider_id=tite_live_provider.id)
stock = create_stock(offer=offer)
PcObject.save(user, stock, user_offerer)
# when
response = TestClient(app.test_client()).with_auth('*****@*****.**') \
.delete('/stocks/' + humanize(stock.id))
# then
assert response.status_code == 400
assert response.json["global"] == [
"Les offres importées ne sont pas modifiables"
]
def test_create_payment_for_booking_when_no_iban_on_venue_should_take_payment_info_from_offerer(
app):
# given
user = create_user()
stock = create_stock(price=10, available=5)
offerer = create_offerer(name='Test Offerer')
venue = create_venue(offerer, name='Test Venue')
offerer_bank_information = create_bank_information(bic='QsdFGH8Z555',
iban='cf13QSDFGH456789',
offerer=offerer)
venue_bank_information = create_bank_information(bic=None,
iban=None,
venue=venue)
booking = create_booking(user, stock=stock, quantity=1)
booking.stock.offer = Offer()
booking.stock.offer.venue = venue
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.iban == 'CF13QSDFGH456789'
assert payment.bic == 'QSDFGH8Z555'
def test_create_payment_for_booking_when_iban_is_on_venue_should_take_payment_info_from_venue(
app):
# given
user = create_user()
stock = create_stock(price=10, available=5)
offerer = create_offerer(name='Test Offerer')
venue = create_venue(
offerer,
name='Test Venue',
)
booking = create_booking(user, stock=stock, quantity=1)
offerer_bank_information = create_bank_information(bic='Lajr93',
iban='B135TGGEG532TG',
offerer=offerer)
venue_bank_information = create_bank_information(bic='LokiJU76',
iban='KD98765RFGHZ788',
venue=venue)
booking.stock.offer = Offer()
booking.stock.offer.venue = venue
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.iban == 'KD98765RFGHZ788'
assert payment.bic == 'LOKIJU76'
def test_contains_info_on_offer(self):
# given
user = create_user(email='*****@*****.**', idx=3)
offerer = create_offerer(siren='987654321', name='Joe le Libraire')
venue = create_venue(offerer,
name='Jack le Sculpteur',
siret='1234567891234')
offer = create_offer_with_thing_product(venue)
stock = create_stock(price=12, available=5, offer=offer)
booking = create_booking(user,
stock,
date_created=datetime(2018, 2, 5),
quantity=2,
idx=5)
payment = create_payment(booking, offerer, 35)
find_date = Mock()
find_date.return_value = datetime(2018, 2, 19)
# when
details = create_payment_details(payment,
find_booking_date_used=find_date)
# then
assert details.offer_name == 'Test Book'
assert details.offer_type == 'Audiovisuel — films sur supports physiques et VOD'
def when_user_has_rights_on_managing_offerer(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock(offer=offer)
create_bank_information(venue=venue, id_at_providers=venue.siret)
create_bank_information(offerer=offerer,
id_at_providers=offerer.siren)
PcObject.save(user, stock)
# when
response = TestClient(app.test_client()).with_auth(email='*****@*****.**') \
.get(f'/offers/{humanize(offer.id)}')
# then
response_json = response.json
assert response.status_code == 200
assert 'iban' in response_json['venue']
assert 'bic' in response_json['venue']
assert 'iban' in response_json['venue']['managingOfferer']
assert 'bic' in response_json['venue']['managingOfferer']
assert 'validationToken' not in response_json['venue'][
'managingOfferer']
def test_create_payment_for_booking_with_common_information(app):
# given
user = create_user()
stock = create_stock(price=10, available=5)
booking = create_booking(user, stock=stock, quantity=1)
booking.stock.offer = Offer()
booking.stock.offer.venue = Venue()
offerer = create_offerer()
offerer_bank_information = create_bank_information(bic='QSDFGH8Z555',
iban='CF13QSDFGH456789',
offerer=offerer)
booking.stock.offer.venue.managingOfferer = offerer
booking_reimbursement = BookingReimbursement(
booking, ReimbursementRules.PHYSICAL_OFFERS, Decimal(10))
# when
payment = create_payment_for_booking(booking_reimbursement)
# then
assert payment.booking == booking
assert payment.amount == Decimal(10)
assert payment.reimbursementRule == ReimbursementRules.PHYSICAL_OFFERS.value.description
assert payment.reimbursementRate == ReimbursementRules.PHYSICAL_OFFERS.value.rate
assert payment.comment is None
assert payment.author == 'batch'
assert payment.transactionLabel == 'pass Culture Pro - remboursement 2nde quinzaine 10-2018'
def when_offer_come_from_provider(self, app):
# given
tite_live_provider = Provider \
.query \
.filter(Provider.localClass == 'TiteLiveThings') \
.first()
user = create_user(email='*****@*****.**')
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue, last_provider_id=tite_live_provider.id)
stock = create_stock(offer=offer, available=10)
PcObject.save(user, user_offerer, stock)
humanized_stock_id = humanize(stock.id)
# when
request_update = TestClient(app.test_client()).with_auth('*****@*****.**') \
.patch('/stocks/' + humanized_stock_id, json={'available': 5})
# then
assert request_update.status_code == 400
request_after_update = TestClient(app.test_client()).with_auth('*****@*****.**').get(
'/stocks/' + humanized_stock_id)
assert request_after_update.json['available'] == 10
assert request_update.json["global"] == ["Les offres importées ne sont pas modifiables"]
def test_is_True_when_booking_limit_datetime_is_in_the_future(self):
# Given
limit_datetime = datetime(2019, 7, 11)
# When
stock = create_stock(booking_limit_datetime=limit_datetime)
# Then
assert stock.isBookable is True
def test_returns_one_when_user_with_one_cancelled_and_one_non_cancelled_bookings(self, app):
# Given
user_having_booked = create_user(departement_code='73')
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_thing_product(venue)
offer2 = create_offer_with_thing_product(venue)
stock1 = create_stock(offer=offer1, price=0)
stock2 = create_stock(offer=offer2, price=0)
booking1 = create_booking(user_having_booked, stock1, is_cancelled=False)
booking2 = create_booking(user_having_booked, stock2, is_cancelled=True)
PcObject.save(booking1, booking2)
# When
number_of_users_having_booked = count_users_having_booked_by_departement_code('73')
# Then
assert number_of_users_having_booked == 1
def test_is_False_when_booking_limit_datetime_is_in_the_past(self):
# Given
limit_datetime = datetime(2019, 7, 9)
# When
stock = create_stock(booking_limit_datetime=limit_datetime)
# Then
assert stock.isBookable is False
def save_paid_online_book_offer(venue: Venue):
paid_reimbursable_offer = create_offer_with_thing_product(
venue,
thing_name='Roman cool',
thing_type=ThingType.LIVRE_EDITION,
url='https://mycoolbook.fr')
reimbursable_stock = create_stock(price=20, offer=paid_reimbursable_offer)
PcObject.save(reimbursable_stock)
logger.info('created 1 online book offer with 1 paid stock of 20 €')
return reimbursable_stock
def test_returns_zero_when_two_users_with_activation_bookings(self, app):
# Given
user_having_booked1 = create_user(departement_code='87')
user_having_booked2 = create_user(email='*****@*****.**', departement_code='87')
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_thing_product(venue, thing_type=ThingType.ACTIVATION)
offer2 = create_offer_with_event_product(venue, event_type=EventType.ACTIVATION)
stock1 = create_stock(offer=offer1, price=0)
stock2 = create_stock(offer=offer2, price=0)
booking1 = create_booking(user_having_booked1, stock1)
booking2 = create_booking(user_having_booked2, stock2)
PcObject.save(booking1, booking2)
# When
number_of_users_having_booked = count_users_having_booked_by_departement_code('87')
# Then
assert number_of_users_having_booked == 0
def test_does_not_count_users_having_booked_activation_offer(self, app):
# Given
user1 = create_user(can_book_free_offers=True, departement_code='74')
user2 = create_user(can_book_free_offers=True, departement_code='75', email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_thing_product(venue, thing_type=ThingType.ACTIVATION)
offer2 = create_offer_with_event_product(venue, event_type=EventType.ACTIVATION)
stock1 = create_stock(offer=offer1, price=0)
stock2 = create_stock(offer=offer2, price=0)
booking1 = create_booking(user1, stock1)
booking2 = create_booking(user2, stock2)
PcObject.save(booking1, booking2)
# When
count = count_users_having_booked()
# Then
assert count == 0
def test_returns_one_if_one_user_has_only_activation_booking_and_one_user_has_one_cinema_booking(self, app):
# Given
user1 = create_user()
user2 = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_thing_product(venue, thing_type=ThingType.ACTIVATION)
offer2 = create_offer_with_event_product(venue, event_type=EventType.CINEMA)
stock1 = create_stock(offer=offer1, price=0)
stock2 = create_stock(offer=offer2, price=0)
booking1 = create_booking(user1, stock1, is_cancelled=False)
booking2 = create_booking(user2, stock2, is_cancelled=False)
PcObject.save(booking1, booking2)
# When
mean_bookings = get_mean_number_of_bookings_per_user_having_booked()
# Then
assert mean_bookings == 1.0
def test_returns_average_amount_based_on_user_location(self, app):
# Given
user_having_booked_from_25 = create_user(departement_code='25', email='*****@*****.**')
user_having_booked_from_63 = create_user(departement_code='63', email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
stock = create_stock(offer=offer, price=10)
expensive_stock = create_stock(offer=offer, price=200)
booking_for_user_one = create_booking(user_having_booked_from_25, stock, is_cancelled=False)
booking_for_user_two = create_booking(user_having_booked_from_63, expensive_stock, is_cancelled=False)
firstDeposit = create_deposit(user=user_having_booked_from_25)
secondDeposit = create_deposit(user=user_having_booked_from_63)
PcObject.save(booking_for_user_one, booking_for_user_two)
# When
mean_amount_spent = get_mean_amount_spent_by_user('25')
# Then
assert mean_amount_spent == 10
