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'),
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:CdtrAgt/ns:FinInstnId/ns:BIC',
xml)[0] == 'QSDFGH8Z555'
assert find_all_nodes(
'//ns:PmtInf/ns:CdtTrfTxInf/ns:CdtrAgt/ns:FinInstnId/ns:BIC',
xml)[1] == 'WXCVBN7B444'
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 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_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_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_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 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'
]
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)
offer = create_offer_with_thing_product(venue)
PcObject.save(user, offer)
data = {
'price': 0,
'offerId': humanize(offer.id),
'bookingLimitDatetime': None
}
# When
response = TestClient(app.test_client()).with_auth(user.email) \
.post('/stocks', json=data)
# Then
assert response.status_code == 201
assert response.json["price"] == 0
assert response.json["bookingLimitDatetime"] is None
id = response.json['id']
stock = Stock.query.filter_by(id=dehumanize(id)).first()
assert stock.price == 0
assert stock.bookingLimitDatetime is None
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_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_offers_have_a_thumb_count_for_event_and_no_mediation(
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 = create_offer_with_event_product(venue, thumb_count=1, dominant_color=b'123')
event_occurrence = create_event_occurrence(
offer,
beginning_datetime=four_days_from_now,
end_datetime=eight_days_from_now
)
stock = create_stock_from_event_occurrence(event_occurrence, price=0, available=20)
PcObject.save(user, stock)
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) == 1
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_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 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 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_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_setting_beginning_and_end_datetimes_on_offer_with_thing(self, app):
# Given
user = create_user(email='*****@*****.**', can_book_free_offers=False, is_admin=True)
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_thing_product(venue)
PcObject.save(user, offer)
beginningDatetime = datetime(2019, 2, 14)
data = {
'price': 0,
'offerId': humanize(offer.id),
'beginningDatetime': serialize(beginningDatetime),
'endDatetime': serialize(beginningDatetime + timedelta(days=1)),
'bookingLimitDatetime': serialize(beginningDatetime - timedelta(days=2))
}
# When
response = TestClient(app.test_client()).with_auth(user.email) \
.post('/stocks', json=data)
# Then
assert response.status_code == 400
assert response.json['global'] == [
'Impossible de mettre des dates de début et fin si l\'offre ne porte pas sur un évenement'
]
def test_returns_new_recommendation_with_active_mediation_for_already_existing_but_invalid_recommendations(
self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer1 = create_offer_with_thing_product(venue, thumb_count=0)
stock1 = create_stock_from_offer(offer1, price=0)
inactive_mediation = create_mediation(offer1, is_active=False)
active_mediation = create_mediation(offer1, is_active=True)
invalid_recommendation = create_recommendation(offer1, user, inactive_mediation,
valid_until_date=datetime.utcnow() - timedelta(hours=2))
PcObject.save(user, stock1, inactive_mediation, active_mediation, invalid_recommendation)
active_mediation_id = active_mediation.id
inactive_mediation_id = inactive_mediation.id
auth_request = TestClient(app.test_client()).with_auth(user.email)
data = {'seenRecommendationIds': []}
# when
response = auth_request.put(RECOMMENDATION_URL, json=data)
# then
assert response.status_code == 200
json = response.json
mediation_ids = list(map(lambda x: x['mediationId'], json))
assert humanize(active_mediation_id) in mediation_ids
assert humanize(inactive_mediation_id) not in mediation_ids
def when_booking_limit_datetime_after_beginning_datetime(self, app):
# Given
user = create_user(email='*****@*****.**', can_book_free_offers=False, is_admin=True)
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
PcObject.save(user, offer)
beginningDatetime = datetime(2019, 2, 14)
data = {
'price': 1222,
'offerId': humanize(offer.id),
'beginningDatetime': serialize(beginningDatetime),
'endDatetime': serialize(beginningDatetime + timedelta(days=1)),
'bookingLimitDatetime': serialize(beginningDatetime + timedelta(days=2))
}
# When
response = TestClient(app.test_client()).with_auth(user.email) \
.post('/stocks', json=data)
# Then
assert response.status_code == 400
assert response.json['bookingLimitDatetime'] == [
'La date limite de réservation pour cette offre est postérieure à la date de début de l\'évènement'
]
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_listing_all_venues_with_a_valid_venue_id(self, app):
# given
offerer = create_offerer(siren='775671464')
venue = create_venue(offerer,
name='Librairie Titelive',
siret='77567146400110')
titelive_things_provider = get_provider_by_local_class(
'TiteLiveThings')
venue_provider = create_venue_provider(
venue=venue, provider=titelive_things_provider)
PcObject.save(venue_provider)
user = create_user()
PcObject.save(user)
auth_request = TestClient(app.test_client()) \
.with_auth(email=user.email)
# when
response = auth_request.get('/venueProviders?venueId=' +
humanize(venue.id))
# then
assert response.status_code == 200
logger.info(response.json)
assert response.json[0].get('id') == humanize(venue_provider.id)
assert response.json[0].get('venueId') == humanize(venue.id)
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 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_mediation_id_is_given(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
mediation1 = create_mediation(offer)
mediation2 = create_mediation(offer)
user = create_user(email='*****@*****.**')
recommendation1 = create_recommendation(offer,
user,
mediation=mediation1)
recommendation2 = create_recommendation(offer,
user,
mediation=mediation2)
PcObject.save(recommendation1, recommendation2)
# When
path = '/recommendations/offers/{}?mediationId={}'.format(
humanize(offer.id), humanize(recommendation1.mediationId))
response = TestClient(app.test_client()) \
.with_auth(email='*****@*****.**') \
.get(path)
# Then
assert response.status_code == 200
assert response.json['id'] == humanize(recommendation1.id)
assert response.json['offerId'] == humanize(offer.id)
assert response.json['mediationId'] == humanize(mediation1.id)
assert response.json['offer']['product']['offerType'][
'proLabel'] == 'Spectacle vivant'
def when_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 test_send_transactions_should_send_an_email_with_xml_attachment(app):
# given
offerer1 = create_offerer(name='first offerer')
user = create_user()
venue1 = create_venue(offerer1)
stock1 = create_stock_from_offer(create_offer_with_thing_product(venue1))
booking1 = create_booking(user, stock1)
booking2 = create_booking(user, stock1)
booking3 = create_booking(user, stock1)
deposit = create_deposit(user, amount=500)
PcObject.save(deposit)
payments = [
create_payment(booking1, offerer1, Decimal(10)),
create_payment(booking2, offerer1, Decimal(20)),
create_payment(booking3, offerer1, Decimal(20))
]
app.mailjet_client.send.create.return_value = Mock(status_code=200)
# when
send_transactions(payments, 'BD12AZERTY123456', 'AZERTY9Q666', '0000',
['*****@*****.**'])
# then
app.mailjet_client.send.create.assert_called_once()
args = app.mailjet_client.send.create.call_args
assert len(args[1]['data']['Attachments']) == 1
def expect_the_booking_to_have_good_includes(self, app):
offerer = create_offerer('987654321', 'Test address', 'Test city',
'93000', 'Test name')
venue = create_venue(offerer, 'Test offerer',
'*****@*****.**', '123 rue test',
'93000', 'Test city', '93')
ok_stock = create_stock_with_event_offer(offerer=offerer,
venue=venue,
price=0)
ok_stock.bookingLimitDatetime = datetime.utcnow() + timedelta(
minutes=2)
ok_stock.bookingLimitDatetime = datetime.utcnow() + timedelta(
minutes=2)
PcObject.save(ok_stock)
user = create_user(email='*****@*****.**')
PcObject.save(user)
recommendation = create_recommendation(offer=ok_stock.offer,
user=user)
PcObject.save(recommendation)
booking_json = {
'stockId': humanize(ok_stock.id),
'recommendationId': humanize(recommendation.id),
'quantity': 1
}
r_create = TestClient(app.test_client()).with_auth(
email='*****@*****.**').post('/bookings', json=booking_json)
assert r_create.status_code == 201
assert r_create.json['stock']['isBookable']
def test_send_transactions_with_malformed_iban_on_payments_gives_them_an_error_status_with_a_cause(
app):
# given
offerer = create_offerer(name='first offerer')
user = create_user()
venue = create_venue(offerer)
stock = create_stock_from_offer(create_offer_with_thing_product(venue))
booking = create_booking(user, stock)
deposit = create_deposit(user, amount=500)
payments = [
create_payment(booking,
offerer,
Decimal(10),
iban='CF 13QSDFGH45 qbc //',
bic='QSDFGH8Z555'),
]
PcObject.save(deposit, *payments)
app.mailjet_client.send.create.return_value = Mock(status_code=400)
# when
with pytest.raises(DocumentInvalid):
send_transactions(payments, 'BD12AZERTY123456', 'AZERTY9Q666', '0000',
['*****@*****.**'])
# then
updated_payments = Payment.query.all()
for payment in updated_payments:
assert len(payment.statuses) == 2
assert payment.currentStatus.status == TransactionStatus.NOT_PROCESSABLE
assert payment.currentStatus.detail == "Element '{urn:iso:std:iso:20022:tech:xsd:pain.001.001.03}IBAN': " \
"[facet 'pattern'] The value 'CF 13QSDFGH45 qbc //' is not accepted " \
"by the pattern '[A-Z]{2,2}[0-9]{2,2}[a-zA-Z0-9]{1,30}'., line 76"
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_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'
