def test_value_error_is_raised_if_payments_ids_do_not_match_payments(self):
# given
payments = [
create_payment(Booking(), Offerer(), 10, idx=111),
create_payment(Booking(), Offerer(), 10, idx=222)
]
ids_to_ban = [222, 333]
# when
with pytest.raises(UnmatchedPayments) as e:
apply_banishment(payments, ids_to_ban)
# then
assert e.value.payment_ids == {333}
def test_no_payments_to_retry_if_all_are_banned(self):
# given
payments = [
create_payment(Booking(), Offerer(), 10, idx=111),
create_payment(Booking(), Offerer(), 10, idx=222)
]
ids_to_ban = [111, 222]
# when
banned_payments, retry_payments = apply_banishment(
payments, ids_to_ban)
# then
assert len(banned_payments) == 2
assert retry_payments == []
def test_no_payments_are_returned_if_no_ids_are_provided(self):
# given
payments = [
create_payment(Booking(), Offerer(), 10, idx=111),
create_payment(Booking(), Offerer(), 10, idx=222)
]
ids_to_ban = []
# when
banned_payments, retry_payments = apply_banishment(
payments, ids_to_ban)
# then
assert banned_payments == []
assert retry_payments == []
def when_feature_send_mail_to_users_enabled_sends_email_to_all_users_linked_to_offerer(
self, app):
# Given
offerer = Offerer()
user_offerer = UserOfferer()
user_offerer.rights = RightsType.editor
user_offerer.user = User(email='*****@*****.**')
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',
return_value=True
), patch(
'domain.user_emails.make_validation_confirmation_email',
return_value={'Html-part': ''}
) as make_cancellation_email, patch(
'domain.user_emails.find_all_emails_of_user_offerers_admins',
return_value=['*****@*****.**', '*****@*****.**']):
# When
send_validation_confirmation_email(user_offerer, offerer,
mocked_send_email)
# Then
make_cancellation_email.assert_called_once_with(user_offerer, offerer)
mocked_send_email.assert_called_once()
args = mocked_send_email.call_args
assert args[1]['data']['To'] == '[email protected], [email protected]'
def test_payments_not_matching_given_ids_must_be_retried(self):
# given
payments = [
create_payment(Booking(), Offerer(), 10, idx=111),
create_payment(Booking(), Offerer(), 10, idx=222),
create_payment(Booking(), Offerer(), 10, idx=333),
create_payment(Booking(), Offerer(), 10, idx=444)
]
ids_to_ban = [222, 333]
# when
banned_payments, retry_payments = apply_banishment(
payments, ids_to_ban)
# then
assert len(retry_payments) == 2
for p in retry_payments:
assert p.currentStatus.status == TransactionStatus.RETRY
assert p.id not in ids_to_ban
def _generate_offerer(data):
offerer = Offerer()
offerer.populate_from_dict(data)
if not IS_INTEGRATION:
offerer.generate_validation_token()
return offerer
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 create_offerer():
siren = request.json['siren']
offerer = find_by_siren(siren)
if offerer is not None:
user_offerer = offerer.give_rights(current_user, RightsType.editor)
user_offerer.generate_validation_token()
PcObject.save(user_offerer)
else:
offerer = Offerer()
offerer.populate_from_dict(request.json)
digital_venue = create_digital_venue(offerer)
offerer.generate_validation_token()
user_offerer = offerer.give_rights(current_user, RightsType.editor)
PcObject.save(offerer, digital_venue, user_offerer)
try:
maybe_send_offerer_validation_email(offerer, user_offerer,
send_raw_email)
except MailServiceException as e:
app.logger.error('Mail service failure', e)
return jsonify(get_dict_offerer(offerer)), 201
def _validate_offerer(offerer: Offerer, user_offerer: UserOfferer):
offerer.validationToken = None
user_offerer.validationToken = None
PcObject.save(offerer, user_offerer)
def create_offerer(
siren='123456789',
address='123 rue de Paris',
city='Montreuil',
postal_code='93100',
name='Test Offerer',
validation_token=None,
idx=None,
is_active=True,
date_created=datetime.utcnow(),
latitude=None,
longitude=None
):
offerer = Offerer()
offerer.siren = siren
offerer.isActive = is_active
offerer.address = address
offerer.postalCode = postal_code
offerer.city = city
offerer.name = name
offerer.validationToken = validation_token
offerer.id = idx
offerer.dateCreated = date_created
offerer.latitude = latitude
offerer.longitude = longitude
return offerer