def test_find_filtered_venues_with_False_has_validated_user_param_return_filtered_venues(app):
# Given
validated_user = create_user()
not_validated_user1 = create_user(email="*****@*****.**", validation_token="hello token")
not_validated_user2 = create_user(email="*****@*****.**", validation_token="other token")
offerer1 = create_offerer()
offerer2 = create_offerer(siren="123456781")
offerer3 = create_offerer(siren="123456782")
user_offerer1 = create_user_offerer(validated_user, offerer1)
user_offerer2 = create_user_offerer(not_validated_user1, offerer2)
user_offerer3 = create_user_offerer(validated_user, offerer3)
user_offerer4 = create_user_offerer(not_validated_user2, offerer3)
venue_with_validated_user = create_venue(offerer1)
venue_with_not_validated_user = create_venue(offerer2, siret='12345678912346')
venue_with_both = create_venue(offerer3, siret='12345678912347')
PcObject.save(user_offerer1, user_offerer2, user_offerer3, user_offerer4, venue_with_not_validated_user,
venue_with_validated_user, venue_with_both)
# When
query_not_validated = find_filtered_venues(has_validated_user=False)
# Then
assert venue_with_not_validated_user in query_not_validated
assert venue_with_validated_user not in query_not_validated
assert venue_with_both not in query_not_validated
def create_industrial_user_offerers(users_by_name, offerers_by_name):
logger.info('create_industrial_user_offerers')
user_offerers_by_name = {}
# special validation
user = users_by_name['pro93 real-validation']
offerer = offerers_by_name['414819409 lat:48.8 lon:1.48']
user_offerers_by_name['pro93 real-validation / 414819409 lat:48.8 lon:1.48'] = create_user_offerer(
offerer=offerer,
user=user
)
# loop on users
for (user_name, user) in users_by_name.items():
for (offerer_name, offerer) in offerers_by_name.items():
if offerer.postalCode[:2] != user.departementCode or\
'real-validation' in user_name:
continue
user_offerers_by_name['{} / {}'.format(user_name, offerer_name)] = create_user_offerer(
offerer=offerer,
user=user
)
PcObject.save(*user_offerers_by_name.values())
logger.info('created {} user_offerers'.format(len(user_offerers_by_name)))
return user_offerers_by_name
def test_find_filtered_venues_with_False_has_validated_user_offerer_param_return_filtered_venues(app):
# Given
user = create_user()
user2 = create_user(email="*****@*****.**")
offerer1 = create_offerer()
offerer2 = create_offerer(siren="123456781")
offerer3 = create_offerer(siren="123456782")
validated_user_offerer = create_user_offerer(user, offerer1)
not_validated_user_offerer = create_user_offerer(user, offerer2, validation_token="a_token")
user_offerer_for_both1 = create_user_offerer(user, offerer3)
user_offerer_for_both2 = create_user_offerer(user2, offerer3, validation_token="other_token")
venue_with_validated_user_offerer = create_venue(offerer1, siret='12345678912346')
venue_with_not_validated_user_offerer = create_venue(offerer2, siret='12345678912347')
venue_with_both = create_venue(offerer3)
PcObject.save(validated_user_offerer, not_validated_user_offerer,
user_offerer_for_both1, user_offerer_for_both2, venue_with_not_validated_user_offerer,
venue_with_validated_user_offerer, venue_with_both)
# When
query_not_validated = find_filtered_venues(has_validated_user_offerer=False)
# Then
assert venue_with_not_validated_user_offerer in query_not_validated
assert venue_with_validated_user_offerer not in query_not_validated
assert venue_with_both not in query_not_validated
def when_param_validated_is_true_returns_all_info_of_validated_offerers(self, app):
# given
user = create_user()
offerer1 = create_offerer(siren='123456781', name='offreur C', validation_token=None)
offerer2 = create_offerer(siren='123456782', name='offreur A', validation_token='AZE123')
offerer3 = create_offerer(siren='123456783', name='offreur B', validation_token=None)
user_offerer1 = create_user_offerer(user, offerer1)
user_offerer2 = create_user_offerer(user, offerer2)
user_offerer3 = create_user_offerer(user, offerer3)
bank_information1 = create_bank_information(id_at_providers='123456781', offerer=offerer1)
bank_information2 = create_bank_information(id_at_providers='123456782', offerer=offerer2)
bank_information3 = create_bank_information(id_at_providers='123456783', offerer=offerer3)
PcObject.save(bank_information1, bank_information2, bank_information3, user_offerer1,
user_offerer2, user_offerer3)
# when
response = TestClient(app.test_client()) \
.with_auth(user.email) \
.get('/offerers?validated=true')
# then
assert response.status_code == 200
assert len(response.json) == 2
assert list(response.json[0].keys()) == [
'address', 'bic', 'city', 'dateCreated', 'dateModifiedAtLastProvider',
'firstThumbDominantColor', 'iban', 'id', 'idAtProviders', 'isActive',
'isValidated', 'lastProviderId', 'managedVenues', 'modelName', 'nOffers',
'name', 'postalCode', 'siren', 'thumbCount', 'userHasAccess'
]
def when_logged_in_and_return_a_list_of_offerers_including_non_validated_structures(self, app):
# given
user = create_user()
offerer1 = create_offerer(siren='123456781', name='offreur A')
offerer2 = create_offerer(siren='123456782', name='offreur B')
offerer3 = create_offerer(siren='123456783', name='offreur C')
user_offerer1 = create_user_offerer(user, offerer1, validation_token=None)
user_offerer2 = create_user_offerer(user, offerer2, validation_token='AZE123')
user_offerer3 = create_user_offerer(user, offerer3, validation_token=None)
PcObject.save(user_offerer1, user_offerer2, user_offerer3)
# when
response = TestClient(app.test_client()) \
.with_auth(user.email) \
.get('/offerers')
# then
assert response.status_code == 200
offerers = response.json
assert len(offerers) == 3
names = [offerer['name'] for offerer in offerers]
assert names == ['offreur A', 'offreur B', 'offreur C']
assert offerers[0]['userHasAccess'] is True
assert offerers[1]['userHasAccess'] is False
assert offerers[2]['userHasAccess'] is True
def when_user_has_an_offerer_attached_and_venue_id_argument_is_valid(
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')
offer1 = create_offer_with_event_product(venue1)
offer2 = create_offer_with_thing_product(venue1)
offer3 = create_offer_with_thing_product(venue2)
stock1 = create_stock_from_offer(offer1, available=100, price=20)
stock2 = create_stock_from_offer(offer2, available=150, price=16)
stock3 = create_stock_from_offer(offer3, available=150, price=18)
booking1 = create_booking(user,
stock1,
venue=venue1,
token='ABCDEF')
booking2 = create_booking(user,
stock1,
venue=venue1,
token='ABCDEG')
booking3 = create_booking(user,
stock2,
venue=venue2,
token='ABCDEH')
booking4 = create_booking(user,
stock3,
venue=venue3,
token='ABCDEI')
PcObject.save(deposit, booking1, booking2, booking3, booking4,
user_offerer1, user_offerer2)
url = '/bookings/csv?venueId=%s' % (humanize(venue1.id))
# When
response = TestClient(app.test_client()).with_auth(
user.email).get(url)
# Then
content_lines = response.data.decode('utf-8').split('\n')[1:-1]
assert response.status_code == 200
assert response.headers[
'Content-type'] == 'text/csv; charset=utf-8;'
assert response.headers[
'Content-Disposition'] == 'attachment; filename=reservations_pass_culture.csv'
assert len(content_lines) == 3
def test_find_offers_with_filter_parameters_with_partial_keywords_and_filter_by_venue(
app):
user = create_user(email='*****@*****.**')
offerer1 = create_offerer(siren='123456789')
offerer2 = create_offerer(siren='987654321')
ko_offerer3 = create_offerer(siren='123456780')
user_offerer1 = create_user_offerer(user, offerer1)
user_offerer2 = create_user_offerer(user, offerer2)
ok_product_event = create_product_with_event_type(
event_name='Rencontre avec Jacques Martin')
ok_product_thing = create_product_with_thing_type(
thing_name='Rencontrez Jacques Chirac')
event_product2 = create_product_with_event_type(
event_name='Concert de contrebasse')
thing1_product = create_product_with_thing_type(
thing_name='Jacques la fripouille')
thing2_product = create_product_with_thing_type(
thing_name='Belle du Seigneur')
offerer = create_offerer()
venue1 = create_venue(offerer1,
name='Bataclan',
city='Paris',
siret=offerer.siren + '12345')
venue2 = create_venue(offerer2,
name='Librairie la Rencontre',
city='Saint Denis',
siret=offerer.siren + '54321')
ko_venue3 = create_venue(
ko_offerer3,
name='Une librairie du méchant concurrent gripsou',
city='Saint Denis',
siret=ko_offerer3.siren + '54321')
ok_offer1 = create_offer_with_event_product(venue1, ok_product_event)
ok_offer2 = create_offer_with_thing_product(venue1, ok_product_thing)
ko_offer2 = create_offer_with_event_product(venue1, event_product2)
ko_offer3 = create_offer_with_thing_product(ko_venue3, thing1_product)
ko_offer4 = create_offer_with_thing_product(venue2, thing2_product)
PcObject.save(user_offerer1, user_offerer2, ko_offerer3, ok_offer1,
ko_offer2, ko_offer3, ko_offer4)
# when
offers = find_offers_with_filter_parameters(
user, venue_id=venue1.id, keywords_string='Jacq Rencon').all()
# then
offers_id = [offer.id for offer in offers]
assert ok_offer1.id in offers_id
assert ok_offer2.id in offers_id
assert ko_offer2.id not in offers_id
assert ko_offer3.id not in offers_id
assert ko_offer4.id not in offers_id
def test_find_one_or_none_by_user_id_raises_exception_when_several_are_found(
app):
# Given
user = create_user(email='*****@*****.**')
offerer1 = create_offerer(siren='123456789')
offerer2 = create_offerer(siren='987654321')
user_offerer1 = create_user_offerer(user, offerer1)
user_offerer2 = create_user_offerer(user, offerer2)
PcObject.save(user_offerer1, user_offerer2)
# When
with pytest.raises(MultipleResultsFound) as error:
first_user_offerer = find_one_or_none_by_user_id(user.id)
def test_pro_user_has_one_digital_venue_and_a_physical_venue(self, app):
# given
user = create_user()
offerer = create_offerer()
offerer2 = create_offerer(siren='123456788')
user_offerer = create_user_offerer(user, offerer)
user_offerer2 = create_user_offerer(user, offerer2)
offerer_virtual_venue = create_venue(offerer, is_virtual=True, siret=None)
offerer2_physical_venue = create_venue(offerer2, siret='12345678856734')
offerer2_virtual_venue = create_venue(offerer, is_virtual=True, siret=None)
PcObject.save(offerer_virtual_venue, offerer2_physical_venue, user_offerer, user_offerer2)
# then
assert user.hasPhysicalVenues is True
def test_save_user_offerer_raise_api_error_when_not_unique(app):
# Given
user = create_user()
offerer = create_offerer()
uo1 = create_user_offerer(user, offerer)
PcObject.save(user, offerer, uo1)
uo2 = create_user_offerer(user, offerer)
# When
with pytest.raises(ApiErrors) as error:
PcObject.save(uo2)
assert error.value.errors["global"] == [
'Une entrée avec cet identifiant existe déjà dans notre base de données'
]
def when_activating_all_venue_offers(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
offer2 = create_offer_with_thing_product(venue)
stock1 = create_stock_from_offer(offer)
offer.isActive = False
offer2.isActive = False
PcObject.save(offer2, stock1, user_offerer, venue)
api_url = API_URL + humanize(venue.id) + '/offers/activate'
# When
response = TestClient(app.test_client()) \
.with_auth('*****@*****.**') \
.put(api_url)
# Then
assert response.status_code == 200
assert response.json[0]['isActive'] == True
assert response.json[1]['isActive'] == True
offers = Offer.query.all()
assert offers[0].isActive == True
assert offers[1].isActive == True
def when_mediation_is_created_with_thumb_url_pointing_to_not_an_image(
self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
user_offerer = create_user_offerer(user, offerer)
PcObject.save(user, venue, user_offerer)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
data = {
'offerId': humanize(offer.id),
'offererId': humanize(offerer.id),
'thumbUrl': 'https://beta.gouv.fr/'
}
# when
response = auth_request.post('/mediations', form=data)
# then
assert response.status_code == 400
assert response.json['thumbUrl'] == [
"L'adresse saisie n'est pas valide"
]
def when_mediation_is_created_with_thumb_file(self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
user_offerer = create_user_offerer(user, offerer)
PcObject.save(offer)
PcObject.save(user, venue, offerer, user_offerer)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
with open(MODULE_PATH / '..' / 'files/mouette_full_size.jpg',
'rb') as f:
thumb = f.read()
files = {
'offerId': humanize(offer.id),
'offererId': humanize(offerer.id),
'thumb': (BytesIO(thumb), 'image.png')
}
# when
response = auth_request.post('/mediations', files=files)
# then
assert response.status_code == 201
def when_mediation_is_created_with_thumb_url(self, read_thumb, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
user_offerer = create_user_offerer(user, offerer)
PcObject.save(offer)
PcObject.save(user, venue, offerer, user_offerer)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
with open(MODULE_PATH / '..' / 'files/mouette_full_size.jpg',
'rb') as f:
read_thumb.return_value = f.read()
data = {
'offerId':
humanize(offer.id),
'offererId':
humanize(offerer.id),
'thumbUrl':
'https://www.deridet.com/photo/art/grande/8682609-13705793.jpg?v=1450665370'
}
# when
response = auth_request.post('/mediations', form=data)
# 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_latitude_out_of_range_and_longitude_wrong_format(self, app):
# given
offerer = create_offerer(siren='302559178')
user = create_user(email='*****@*****.**')
user_offerer = create_user_offerer(user, offerer)
PcObject.save(user_offerer)
data = {
'name': 'Ma venue',
'siret': '30255917810045',
'address': '75 Rue Charles Fourier, 75013 Paris',
'postalCode': '75200',
'bookingEmail': '*****@*****.**',
'city': 'Paris',
'managingOffererId': humanize(offerer.id),
'latitude': -98.82387,
'longitude': '112°3534',
'isVirtual': False
}
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
# when
response = auth_request.post('/venues', json=data)
# then
assert response.status_code == 400
assert response.json['latitude'] == [
'La latitude doit être comprise entre -90.0 et +90.0'
]
assert response.json['longitude'] == ['Format incorrect']
def test_pending_validation_return_200_and_validation_token(app):
# given
user = create_user(can_book_free_offers=False, is_admin=True)
user_pro = create_user(email='*****@*****.**',
can_book_free_offers=False,
is_admin=False)
offerer = create_offerer(validation_token="first_token")
user_offerer = create_user_offerer(user_pro,
offerer,
is_admin=True,
validation_token="a_token")
venue = create_venue(offerer,
siret=None,
comment="comment because no siret",
validation_token="venue_validation_token")
PcObject.save(user_offerer, user, venue)
auth_request = TestClient(app.test_client()).with_auth(email=user.email)
# when
response = auth_request.get('/exports/pending_validation')
# then
assert response.status_code == 200
assert response.json[0]["validationToken"] == "first_token"
assert response.json[0]["UserOfferers"][0]["validationToken"] == "a_token"
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 when_offerer_already_have_user_offerer_new_user_offerer_has_validation_token(
self, write_object_validation_email, app):
# Given
user = create_user(can_book_free_offers=False, is_admin=False)
user_2 = create_user(email="*****@*****.**",
is_admin=False)
offerer = create_offerer()
user_offerer = create_user_offerer(user_2,
offerer,
validation_token=None)
PcObject.save(user, user_2, offerer, user_offerer)
body = {
'name': 'Test Offerer',
'siren': '123456789',
'address': '123 rue de Paris',
'postalCode': '93100',
'city': 'Montreuil'
}
# when
response = TestClient(app.test_client()) \
.with_auth(user.email) \
.post('/offerers', json=body)
# then
assert response.status_code == 201
offerer = Offerer.query.first()
created_user_offerer = UserOfferer.query\
.filter(UserOfferer.offerer == offerer)\
.filter(UserOfferer.user == user)\
.one()
assert created_user_offerer.validationToken is not None
def when_creating_a_new_event_offer_without_booking_email(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
venue = create_venue(offerer)
user_offerer = create_user_offerer(user, offerer)
PcObject.save(user, user_offerer, venue)
json = {
'venueId': humanize(venue.id),
'name': 'La pièce de théâtre',
'durationMinutes': 60,
'type': str(EventType.SPECTACLE_VIVANT)
}
# When
response = TestClient(app.test_client()).with_auth(user.email).post(
f'{API_URL}/offers',
json=json)
# Then
offer_id = dehumanize(response.json['id'])
offer = Offer.query.filter_by(id=offer_id).first()
assert response.status_code == 201
assert offer.bookingEmail == None
def when_offer_type_is_unknown(self, app):
# Given
user = create_user(email='*****@*****.**')
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer)
venue = create_venue(offerer, is_virtual=False)
event_product = create_product_with_event_type()
PcObject.save(user, venue, event_product, user_offerer)
json = {
'type': '',
'name': 'Les lapins crétins',
'mediaUrls': ['http://media.url'],
'durationMinutes': 200,
'venueId': humanize(venue.id),
'bookingEmail': '*****@*****.**'
}
# When
response = TestClient(app.test_client()).with_auth(user.email).post(
f'{API_URL}/offers',
json=json)
# Then
assert response.status_code == 400
assert response.json['type'] == ['Le type de cette offre est inconnu']
def test_maybe_send_offerer_validation_email_sends_email_to_pass_culture_dev_when_objects_to_validate_and_send_email_disabled(
app):
# Given
offerer = create_offerer(siren='732075312', address='122 AVENUE DE FRANCE', city='Paris', postal_code='75013',
name='Accenture', validation_token='12345')
user = create_user(public_name='Test', departement_code='75', email='*****@*****.**',
can_book_free_offers=False, validation_token='98765')
user_offerer = create_user_offerer(user, offerer, validation_token=None)
mocked_send_email = Mock()
return_value = Mock()
return_value.status_code = 200
mocked_send_email.return_value = return_value
# When
with patch('utils.mailing.feature_send_mail_to_users_enabled', return_value=False):
maybe_send_offerer_validation_email(offerer, user_offerer, mocked_send_email)
# Then
mocked_send_email.assert_called_once()
args = mocked_send_email.call_args
email = args[1]['data']
assert email['To'] == '*****@*****.**'
assert 'This is a test' in email['Html-part']
def when_editing_non_authorised_fields(self, app):
# given
user = create_user()
offerer = create_offerer()
user_offerer = create_user_offerer(user, offerer, is_admin=True)
PcObject.save(user_offerer)
body = {
'thumbCount': 0,
'idAtProviders': 'zfeej',
'dateModifiedAtLastProvider': serialize(datetime(2016, 2, 1)),
'address': '123 nouvelle adresse',
'postalCode': '75001',
'city': 'Paris',
'validationToken': 'ozieghieof',
'id': humanize(10),
'dateCreated': serialize(datetime(2015, 2, 1)),
'name': 'Nouveau Nom',
'siren': '989807829',
'lastProviderId': humanize(1)
}
# when
response = TestClient(app.test_client()) \
.with_auth(user.email) \
.patch('/offerers/%s' % humanize(offerer.id), json=body)
# then
assert response.status_code == 400
for key in body:
assert response.json[key] == [
'Vous ne pouvez pas modifier ce champ'
]
def when_user_has_rights_on_managing_offerer_and_has_siret(self, app):
# given
offerer = create_offerer(siren='302559178')
user = create_user(email='*****@*****.**')
user_offerer = create_user_offerer(user, offerer)
PcObject.save(user_offerer)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
venue_data = {
'name': 'Ma venue',
'siret': '30255917810045',
'address': '75 Rue Charles Fourier, 75013 Paris',
'postalCode': '75200',
'bookingEmail': '*****@*****.**',
'city': 'Paris',
'managingOffererId': humanize(offerer.id),
'latitude': 48.82387,
'longitude': 2.35284,
'publicName': 'Ma venue publique'
}
# when
response = auth_request.post('/venues', json=venue_data)
# then
assert response.status_code == 201
id = response.json['id']
venue = Venue.query.filter_by(id=dehumanize(id)).one()
assert venue.name == 'Ma venue'
assert venue.publicName == 'Ma venue publique'
assert venue.siret == '30255917810045'
assert venue.isValidated
def when_user_has_rights_on_managing_offerer_does_not_have_siret_and_has_comment(
self, app):
# Given
offerer = create_offerer()
user = create_user()
user_offerer = create_user_offerer(user, offerer, is_admin=True)
PcObject.save(user_offerer)
venue_data = {
'name': 'Ma venue',
'comment': 'Je ne mets pas de SIRET pour une bonne raison',
'address': '75 Rue Charles Fourier, 75013 Paris',
'postalCode': '75200',
'bookingEmail': '*****@*****.**',
'city': 'Paris',
'managingOffererId': humanize(offerer.id),
'latitude': 48.82387,
'longitude': 2.35284
}
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
# when
response = auth_request.post('/venues', json=venue_data)
# Then
assert response.status_code == 201
venue = Venue.query.first()
assert not venue.isValidated
json = response.json
assert json['isValidated'] == False
assert 'validationToken' not in json
def expect_mediation_not_to_be_saved(self, PcObject, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
user_offerer = create_user_offerer(user, offerer)
PcObject.save(user, venue, user_offerer)
with open(MODULE_PATH / '..' / 'files/mouette_small.jpg',
'rb') as f:
thumb = f.read()
data = {
'offerId': humanize(offer.id),
'offererId': humanize(offerer.id),
'thumb': (BytesIO(thumb), 'image.png')
}
PcObject.reset_mock()
# when
TestClient(app.test_client()) \
.with_auth(email=user.email) \
.post('/mediations', form=data)
# then
PcObject.save.assert_not_called()
def when_mediation_is_created_with_file_upload_but_image_is_too_small(
self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
user_offerer = create_user_offerer(user, offerer)
PcObject.save(user, venue, user_offerer)
with open(MODULE_PATH / '..' / 'files/mouette_small.jpg',
'rb') as f:
thumb = f.read()
data = {
'offerId': humanize(offer.id),
'offererId': humanize(offerer.id),
'thumb': (BytesIO(thumb), 'image.png')
}
# when
response = TestClient(app.test_client()) \
.with_auth(email=user.email) \
.post('/mediations', form=data)
# then
assert response.status_code == 400
assert response.json['thumb'] == [
"L'image doit faire 100 ko minimum et 400 * 400 px minimum"
]
def when_mediation_is_edited(self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
user_offerer = create_user_offerer(user, offerer)
mediation = create_mediation(offer)
PcObject.save(mediation)
PcObject.save(user, venue, offerer, user_offerer)
mediation_id = mediation.id
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
data = {
'frontText': 'new front text',
'backText': 'new back text',
'isActive': False
}
# when
response = auth_request.patch('/mediations/%s' %
humanize(mediation.id),
json=data)
# then
mediation = Mediation.query.get(mediation_id)
assert response.status_code == 200
assert response.json['id'] == humanize(mediation.id)
assert response.json['frontText'] == mediation.frontText
assert response.json['backText'] == mediation.backText
assert response.json['isActive'] == mediation.isActive
assert response.json['thumbUrl'] == mediation.thumbUrl
assert mediation.isActive == data['isActive']
assert mediation.frontText == data['frontText']
assert mediation.backText == data['backText']
def when_mediation_is_created_with_file_upload_but_without_filename(
self, app):
# given
user = create_user()
offerer = create_offerer()
venue = create_venue(offerer)
offer = create_offer_with_event_product(venue)
user_offerer = create_user_offerer(user, offerer)
PcObject.save(user, venue, user_offerer)
data = {
'offerId': humanize(offer.id),
'offererId': humanize(offerer.id),
'thumb': (BytesIO(ONE_PIXEL_PNG), '')
}
# when
response = TestClient(app.test_client()) \
.with_auth(email=user.email) \
.post('/mediations', form=data)
# then
assert response.status_code == 400
assert response.json['thumb'] == [
"Vous devez fournir une image d'accroche"
]
def expect_no_new_deposits_when_the_linked_user_has_been_already_activated(
self, app):
# Given
user = create_user(can_book_free_offers=False, is_admin=False)
pro_user = create_user(email='*****@*****.**',
can_book_free_offers=False,
is_admin=True)
offerer = create_offerer()
user_offerer = create_user_offerer(pro_user, offerer)
venue = create_venue(offerer)
activation_offer = create_offer_with_event_product(
venue, event_type=EventType.ACTIVATION)
activation_event_occurrence = create_event_occurrence(
activation_offer)
stock = create_stock_from_event_occurrence(
activation_event_occurrence, price=0)
booking = create_booking(user, stock, venue=venue)
deposit = create_deposit(user, amount=500)
PcObject.save(booking, user_offerer, deposit)
user_id = user.id
url = '/bookings/token/{}'.format(booking.token)
# When
response = TestClient(
app.test_client()).with_auth('*****@*****.**').patch(url)
# Then
deposits_for_user = Deposit.query.filter_by(
userId=user_id).all()
assert response.status_code == 405
assert len(deposits_for_user) == 1
assert deposits_for_user[0].amount == 500
