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'