def test_should_not_be_stuck_because_of_no_siren_offerer_and_print_a_list_of_errored_venues(
self, stub_read_venue_type_from_file, app, capsys):
# Given
offerer = create_offerer(siren=None)
old_venue_type = create_venue_type("old_type", 1)
new_venue_type = create_venue_type("new_type", 25)
venue1 = create_venue(offerer, name="CMOI", idx=121, venue_type_id=1)
venue2 = create_venue(offerer,
name="AUSSI MOI",
idx=99,
siret="12345678912354",
venue_type_id=1)
repository.save(venue1, venue2, old_venue_type, new_venue_type)
stub_read_venue_type_from_file.return_value = [("121", "new_type"),
("99", "new_type")]
# When
update_venue_type("fake/path")
# Then
captured = capsys.readouterr()
updated_venue1 = Venue.query.filter_by(id=121).one()
updated_venue2 = Venue.query.filter_by(id=99).one()
assert updated_venue1.venueTypeId == 1
assert updated_venue2.venueTypeId == 1
assert "0 venues have been updated" in captured.out
assert "Venues in error : 121, 99" in captured.out
def test_should_return_the_venue_types(self, app):
# Given
cinema = create_venue_type(label="Cinema", idx=1)
musee = create_venue_type(label="Musée", idx=2)
repository.save(cinema, musee)
# When
venue_types = get_all_venue_types()
# Then
assert len(venue_types) == 2
assert cinema in venue_types
assert musee in venue_types
def test_should_update_venue(self, app):
# given
offerer = create_offerer()
user = create_user()
venue_type = create_venue_type(label="Musée")
venue_label = create_venue_label(label="CAC - Centre d'art contemporain d'intérêt national")
venue = create_venue(offerer)
user_offerer = create_user_offerer(user, offerer)
repository.save(user_offerer, venue, venue_type, venue_label)
auth_request = TestClient(app.test_client()).with_auth(email=user.email)
venue_id = venue.id
# when
response = auth_request.patch(
"/venues/%s" % humanize(venue.id),
json={
"name": "Ma librairie",
"venueTypeId": humanize(venue_type.id),
"venueLabelId": humanize(venue_label.id),
},
)
# then
assert response.status_code == 200
venue = Venue.query.get(venue_id)
assert venue.name == "Ma librairie"
assert venue.venueTypeId == venue_type.id
json = response.json
assert json["isValidated"] is True
assert "validationToken" not in json
assert venue.isValidated
def test_should_consider_the_venue_to_be_permanent(self, app):
# given
offerer = create_offerer(siren="302559178")
user = create_user()
user_offerer = create_user_offerer(user, offerer)
venue_type = create_venue_type(label="Musée")
venue_label = create_venue_label(
label="CAC - Centre d'art contemporain d'intérêt national")
repository.save(user_offerer, venue_type, venue_label)
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",
"venueTypeId": humanize(venue_type.id),
"venueLabelId": humanize(venue_label.id),
}
# when
auth_request.post("/venues", json=venue_data)
# then
venue = Venue.query.one()
assert venue.isPermanent == True
def when_user_data_is_valid(self, app):
# Given
data = BASE_DATA_PRO.copy()
expected_response_json = {
"isBeneficiary": False,
"departementCode": "92",
"email": "*****@*****.**",
"firstName": "Toto",
"isAdmin": False,
"lastName": "Pro",
"phoneNumber": "0102030405",
"postalCode": "92000",
"publicName": "Toto Pro",
"dateOfBirth": None,
}
other_expected_keys = {"id", "dateCreated"}
venue_type = create_venue_type(label="Offre numérique")
repository.save(venue_type)
# When
response = TestClient(app.test_client()).post(
"/users/signup/pro", json=data, headers={"origin": "http://localhost:3000"}
)
# Then
assert response.status_code == 201
assert "Set-Cookie" not in response.headers
json = response.json
assert "dateCreated" in json
for key, value in expected_response_json.items():
if key != "dateCreated":
assert json[key] == value
for key in other_expected_keys:
assert key in json
def expect_send_pro_user_waiting_for_validation_by_admin_email_to_be_called_when_offerer_not_existing_yet(
self, mock_send_raw_email, mock_api_entreprise,
mock_send_pro_user_waiting_for_validation_by_admin_email, app):
# Given
mock_api_entreprise.return_value = MagicMock(
status_code=200,
text="",
json=MagicMock(
return_value=copy.deepcopy(api_entreprise_json_mock)))
user = create_user(is_beneficiary=False, is_admin=False)
digital_venue_type = create_venue_type(
label=DEFAULT_DIGITAL_VENUE_LABEL)
repository.save(user, digital_venue_type)
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()
mock_send_pro_user_waiting_for_validation_by_admin_email.assert_called_once_with(
user, mock_send_raw_email, offerer)
def expect_new_offerer_to_have_validation_token_but_user_offerer_dont(
self, mock_api_entreprise, make_validation_email_object, app):
# Given
make_validation_email_object.return_value = {"Html-part": None}
mock_api_entreprise.return_value = MagicMock(
status_code=200,
text="",
json=MagicMock(
return_value=copy.deepcopy(api_entreprise_json_mock)))
user = create_user(is_beneficiary=False, is_admin=False)
digital_venue_type = create_venue_type(
label=DEFAULT_DIGITAL_VENUE_LABEL)
repository.save(user, digital_venue_type)
body = {
"name": "Test Offerer",
"siren": "418166096",
"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()
assert offerer.validationToken is not None
assert offerer.UserOfferers[0].validationToken is None
def test_does_not_allow_the_creation_of_admins(self, app):
# Given
user_json = {
"email": "*****@*****.**",
"publicName": "Toto Pro",
"firstName": "Toto",
"lastName": "Pro",
"password": "******",
"contact_ok": "true",
"siren": "349974931",
"address": "12 boulevard de Pesaro",
"phoneNumber": "0102030405",
"postalCode": "92000",
"city": "Nanterre",
"name": "Crédit Coopératif",
"isAdmin": True,
}
venue_type = create_venue_type(label="Offre numérique")
repository.save(venue_type)
# When
response = TestClient(app.test_client()).post(
"/users/signup/pro", json=user_json, headers={"origin": "http://*****:*****@btmx.fr").one()
assert not created_user.isAdmin
def when_current_user_is_admin(self, mock_api_entreprise, app):
# Given
mock_api_entreprise.return_value = MagicMock(
status_code=200,
text="",
json=MagicMock(
return_value=copy.deepcopy(api_entreprise_json_mock)))
user = create_user(is_beneficiary=False, is_admin=True)
digital_venue_type = create_venue_type(
label=DEFAULT_DIGITAL_VENUE_LABEL)
repository.save(user, digital_venue_type)
body = {
"name": "Test Offerer",
"siren": "418166096",
"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
def when_creating_a_virtual_venue(self, mock_api_entreprise, app):
# given
mock_api_entreprise.return_value = MagicMock(
status_code=200,
text="",
json=MagicMock(
return_value=copy.deepcopy(api_entreprise_json_mock)))
user = create_user()
digital_venue_type = create_venue_type(
label=DEFAULT_DIGITAL_VENUE_LABEL)
repository.save(user, digital_venue_type)
body = {
"name": "Test Offerer",
"siren": "418166096",
"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
assert response.json["siren"] == "418166096"
assert response.json["name"] == "Test Offerer"
virtual_venues = list(
filter(lambda v: v["isVirtual"],
response.json["managedVenues"]))
assert len(virtual_venues) == 1
assert virtual_venues[0]["venueTypeId"] == humanize(
digital_venue_type.id)
def test_creates_user_offerer_digital_venue_and_userOfferer_and_does_not_log_user_in(self, app):
# Given
data_pro = BASE_DATA_PRO.copy()
venue_type = create_venue_type(label="Offre numérique")
repository.save(venue_type)
# When
response = TestClient(app.test_client()).post(
"/users/signup/pro", json=data_pro, headers={"origin": "http://*****:*****@btmx.fr").first()
assert user is not None
offerer = Offerer.query.filter_by(siren="349974931").first()
assert offerer is not None
assert offerer.validationToken is not None
assert len(offerer.managedVenues) == 1
assert offerer.managedVenues[0].isVirtual
assert offerer.managedVenues[0].venueTypeId == venue_type.id
user_offerer = UserOfferer.query.filter_by(user=user, offerer=offerer).first()
assert user_offerer is not None
assert user_offerer.validationToken is None
assert user_offerer.rights == RightsType.editor
def when_extra_data_is_given(self, app):
# Given
user_json = {
"email": "*****@*****.**",
"publicName": "Toto Pro",
"firstName": "Toto",
"lastName": "Pro",
"password": "******",
"siren": "349974931",
"address": "12 boulevard de Pesaro",
"phoneNumber": "0102030405",
"postalCode": "92000",
"city": "Nanterre",
"name": "Crédit Coopératif",
"isAdmin": True,
"contactOk": "true",
}
venue_type = create_venue_type(label="Offre numérique")
repository.save(venue_type)
# When
response = TestClient(app.test_client()).post("/users/signup/pro", json=user_json)
# Then
assert response.status_code == 400
created_user = User.query.filter_by(email="*****@*****.**").first()
assert created_user is None
def when_successful_and_existing_offerer_creates_editor_user_offerer_and_does_not_log_in(self, app):
# Given
json_offerer = {
"name": "Test Offerer",
"siren": "349974931",
"address": "Test adresse",
"postalCode": "75000",
"city": "Paris",
}
venue_type = create_venue_type(label="Offre numérique")
offerer = Offerer(from_dict=json_offerer)
offerer.generate_validation_token()
user = create_user(email="*****@*****.**", public_name="bobby")
user_offerer = create_user_offerer(user, offerer)
repository.save(venue_type, offerer, user_offerer)
data = BASE_DATA_PRO.copy()
# When
response = TestClient(app.test_client()).post("/users/signup/pro", json=data)
# Then
assert response.status_code == 204
assert "Set-Cookie" not in response.headers
user = User.query.filter_by(email="*****@*****.**").first()
assert user is not None
offerer = Offerer.query.filter_by(siren="349974931").first()
assert offerer is not None
user_offerer = UserOfferer.query.filter_by(user=user, offerer=offerer).first()
assert user_offerer is not None
assert user_offerer.validationToken is not None
def test_creates_user_offerer_digital_venue_and_userOfferer_and_does_not_log_user_in(self, app):
# Given
data_pro = BASE_DATA_PRO.copy()
data_pro["contactOk"] = "true"
venue_type = create_venue_type(label="Offre numérique")
repository.save(venue_type)
# When
response = TestClient(app.test_client()).post("/users/signup/pro", json=data_pro)
# Then
assert response.status_code == 204
assert "Set-Cookie" not in response.headers
user = User.query.filter_by(email="*****@*****.**").first()
assert user is not None
assert user.hasAllowedRecommendations is True
offerer = Offerer.query.filter_by(siren="349974931").first()
assert offerer is not None
assert offerer.validationToken is not None
assert len(offerer.managedVenues) == 1
assert offerer.managedVenues[0].isVirtual
assert offerer.managedVenues[0].venueTypeId == venue_type.id
user_offerer = UserOfferer.query.filter_by(user=user, offerer=offerer).first()
assert user_offerer is not None
assert user_offerer.validationToken is None
def create_industrial_venue_types() -> List[VenueType]:
logger.info("create_industrial_venue_types")
labels = [
"Arts visuels, arts plastiques et galeries",
"Centre culturel",
"Cours et pratique artistiques",
"Culture scientifique",
"Festival",
"Jeux / Jeux vidéos",
"Librairie",
"Bibliothèque ou médiathèque",
"Musée",
"Musique - Disquaire",
"Musique - Magasin d’instruments",
"Musique - Salle de concerts",
"Offre numérique",
"Patrimoine et tourisme",
"Cinéma - Salle de projections",
"Spectacle vivant",
"Autre",
]
venue_types = [create_venue_type(label=label) for label in labels]
repository.save(*venue_types)
logger.info("created %i venue types", len(venue_types))
return venue_types
def when_no_address_is_provided(self, mock_api_entreprise, app):
# given
mock_api_entreprise.return_value = MagicMock(
status_code=200,
text="",
json=MagicMock(
return_value=copy.deepcopy(api_entreprise_json_mock)))
user = create_user()
digital_venue_type = create_venue_type(
label=DEFAULT_DIGITAL_VENUE_LABEL)
repository.save(user, digital_venue_type)
body = {
"name": "Test Offerer",
"siren": "418166096",
"postalCode": "93100",
"city": "Montreuil"
}
# when
response = TestClient(app.test_client()).with_auth(
user.email).post("/offerers", json=body)
# then
assert response.status_code == 201
assert response.json["siren"] == "418166096"
assert response.json["name"] == "Test Offerer"
def test_when_physical_offer_returns_subject_with_departement_information_and_dictionary_with_given_content(
self, app
):
# Given
venue_type = create_venue_type(label="Custom Label")
repository.save(venue_type)
author = create_user(email="*****@*****.**", first_name="John", last_name="Doe", phone_number="0102030405")
offerer = create_offerer(name="Cinéma de Montreuil")
physical_venue = create_venue(offerer, venue_type_id=venue_type.id)
physical_offer = create_offer_with_thing_product(
venue=physical_venue, thing_type=ThingType.AUDIOVISUEL, thing_name="Le vent se lève", idx=1
)
repository.save(author, physical_offer)
# When
email = make_offer_creation_notification_email(physical_offer, author)
# Then
assert email["FromName"] == "pass Culture"
assert email["Subject"] == "[Création d’offre - 93] Le vent se lève"
parsed_email = BeautifulSoup(email["Html-part"], "html.parser")
offer_html = str(parsed_email.find("p", {"id": "offer"}))
assert 'Une nouvelle offre : "Le vent se lève"' in offer_html
offerer_html = str(parsed_email.find("p", {"id": "offerer"}))
assert "Vient d'être créée par : Cinéma de Montreuil" in offerer_html
webapp_offer_link = str(parsed_email.find("p", {"id": "webapp_offer_link"}))
assert (
f"Lien vers l'offre dans la Webapp :"
f" http://localhost:3000/offre/details/{humanize(physical_offer.id)}" in webapp_offer_link
)
pro_offer_link = str(parsed_email.find("p", {"id": "pro_offer_link"}))
assert (
f"Lien vers l'offre dans le portail PRO :"
f" http://localhost:3001/offres/{humanize(physical_offer.id)}" in pro_offer_link
)
offer_is_duo = str(parsed_email.find("p", {"id": "offer_is_duo"}))
assert "Offre duo : False" in offer_is_duo
venue_details = str(parsed_email.find("p", {"id": "venue_details"}))
assert f"Lien vers le lieu : http://localhost:3001/lieux/{humanize(physical_offer.venue.id)}" in venue_details
assert "Catégorie du lieu : Custom Label" in venue_details
assert "Adresse du lieu : Montreuil 93100" in venue_details
pro_user_information = str(parsed_email.find("p", {"id": "pro_user_information"}))
assert "Nom : Doe" in pro_user_information
assert "Prénom : John" in pro_user_information
assert "Téléphone : 0102030405" in pro_user_information
assert "Email : [email protected]" in pro_user_information
def test_should_update_venue_type_whith_type_from_read_file_when_id_match(
self, stub_read_venue_type_from_file, app, capsys):
# Given
offerer = create_offerer()
old_venue_type = create_venue_type("old_type", 1)
new_venue_type = create_venue_type("new_type", 2)
venue = create_venue(offerer, idx=121, venue_type_id=1)
repository.save(venue, old_venue_type, new_venue_type)
stub_read_venue_type_from_file.return_value = [("121", "new_type")]
# When
update_venue_type("fake/path")
# Then
captured = capsys.readouterr()
updated_venue = Venue.query.one()
assert updated_venue.venueTypeId == 2
assert "1 venues have been updated" in captured.out
def test_return_the_list(self, app):
# Given
list_of_types = [create_venue_type("Theatre")]
get_all_venue_types = Mock(return_value=list_of_types)
# When
result = get_types_of_venues(get_all_venue_types)
# Then
get_all_venue_types.assert_called_once()
assert result == list_of_types
def when_email_is_already_used(self, app):
# Given
data = BASE_DATA_PRO.copy()
venue_type = create_venue_type(label="Offre numérique")
repository.save(venue_type)
TestClient(app.test_client()).post("/users/signup/pro", json=data)
# When
response = TestClient(app.test_client()).post("/users/signup/pro", json=data)
# Then
assert response.status_code == 400
error = response.json
assert "email" in error
def when_public_name_is_too_long(self, app):
# Given
data = BASE_DATA_PRO.copy()
data["publicName"] = "x" * 300
venue_type = create_venue_type(label="Offre numérique")
repository.save(venue_type)
# When
response = TestClient(app.test_client()).post("/users/signup/pro", json=data)
# Then
assert response.status_code == 400
error = response.json
assert "publicName" in error
def when_the_user_is_authenticated(self, app):
# Given
user = create_user()
venue_types = [
create_venue_type(label="Centre culturel", idx=1),
create_venue_type(label="Musée", idx=2)
]
repository.save(user, *venue_types)
# When
response = TestClient(app.test_client()).with_auth(
user.email).get("/venue-types")
# then
assert response.status_code == 200
assert len(response.json) == 2
assert response.json == [{
"id": "AE",
"label": "Centre culturel"
}, {
"id": "A9",
"label": "Musée"
}]
def when_invalid_postal_code(self, app):
# Given
data = BASE_DATA_PRO.copy()
data["postalCode"] = "111"
venue_type = create_venue_type(label="Offre numérique")
repository.save(venue_type)
# When
response = TestClient(app.test_client()).post("/users/signup/pro", json=data)
# Then
assert response.status_code == 400
error = response.json
assert "postalCode" in error
def when_offerer_city_is_missing(self, app):
# Given
data = BASE_DATA_PRO.copy()
del data["city"]
venue_type = create_venue_type(label="Offre numérique")
repository.save(venue_type)
# When
response = TestClient(app.test_client()).post("/users/signup/pro", json=data)
# Then
assert response.status_code == 400
error = response.json
assert "city" in error
def when_postal_code_is_missing(self, app):
# Given
data = BASE_DATA_PRO.copy()
del data["postalCode"]
venue_type = create_venue_type(label="Offre numérique")
repository.save(venue_type)
# When
response = TestClient(app.test_client()).post(
"/users/signup/pro", json=data, headers={"origin": "http://localhost:3000"}
)
# Then
assert response.status_code == 400
error = response.json
assert "postalCode" in error
def test_should_not_update_venue_type_whith_type_from_read_file_when_type_label_does_not_match(
self, stub_read_venue_type_from_file, app, capsys):
# Given
offerer = create_offerer()
old_venue_type = create_venue_type("old_type", 1)
venue = create_venue(offerer, idx=121, venue_type_id=1)
repository.save(venue, old_venue_type)
stub_read_venue_type_from_file.return_value = [("121", "other_type")]
# When
update_venue_type("fake/path")
# Then
captured = capsys.readouterr()
updated_venue = Venue.query.one()
assert updated_venue.venueTypeId == 1
assert "venue type id not found for label : other_type and venueId : 121" in captured.out
assert "0 venues have been updated" in captured.out
def test_should_register_new_venue(self, app):
# given
offerer = create_offerer(siren="302559178")
user = create_user()
user_offerer = create_user_offerer(user, offerer)
venue_type = create_venue_type(label="Musée")
venue_label = create_venue_label(
label="CAC - Centre d'art contemporain d'intérêt national")
repository.save(user_offerer, venue_type, venue_label)
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",
"venueTypeId": humanize(venue_type.id),
"venueLabelId": humanize(venue_label.id),
}
# when
response = auth_request.post("/venues", json=venue_data)
# then
assert response.status_code == 201
idx = response.json["id"]
venue = Venue.query.filter_by(id=dehumanize(idx)).one()
assert venue.name == "Ma venue"
assert venue.publicName == "Ma venue publique"
assert venue.siret == "30255917810045"
assert venue.isValidated
assert venue.venueTypeId == venue_type.id
assert venue.venueLabelId == venue_label.id
def when_offerer_already_have_user_offerer_new_user_offerer_has_validation_token(
self, mock_api_entreprise, make_validation_email_object, app):
# Given
make_validation_email_object.return_value = {"Html-part": None}
mock_api_entreprise.return_value = MagicMock(
status_code=200,
text="",
json=MagicMock(
return_value=copy.deepcopy(api_entreprise_json_mock)))
user = create_user(is_beneficiary=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)
digital_venue_type = create_venue_type(
label=DEFAULT_DIGITAL_VENUE_LABEL)
repository.save(user, user_2, offerer, user_offerer,
digital_venue_type)
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 test_returns_created_user_offerer(self, app):
# given
blake = create_user(email="*****@*****.**", idx=123)
venue_type = create_venue_type(label="Offre numérique")
repository.save(venue_type)
blakes_company = create_offerer(siren="362521879",
name="MyBletcheyCompany",
idx=234)
self.find_user_query.side_effect = [blake]
self.find_offerer_query.side_effect = [blakes_company]
self.find_user_offerer_query.side_effect = [None]
# when
user_offerer = create_activated_user_offerer(
self.csv_row,
find_user=self.find_user_query,
find_offerer=self.find_offerer_query,
find_user_offerer=self.find_user_offerer_query,
)
# then
assert user_offerer.userId == 123
assert user_offerer.offererId == 234
def when_user_data_is_valid(self, app):
# Given
data = BASE_DATA_PRO.copy()
venue_type = create_venue_type(label="Offre numérique")
repository.save(venue_type)
# When
response = TestClient(app.test_client()).post("/users/signup/pro", json=data)
# Then
assert response.status_code == 204
assert "Set-Cookie" not in response.headers
user = User.query.filter_by(email="*****@*****.**").first()
assert user is not None
assert user.isBeneficiary is False
assert user.departementCode == "92"
assert user.email == "*****@*****.**"
assert user.firstName == "Toto"
assert user.isAdmin is False
assert user.lastName == "Pro"
assert user.phoneNumber == "0102030405"
assert user.postalCode == "92000"
assert user.publicName == "Toto Pro"
assert user.dateOfBirth is None
assert user.dateCreated is not None
assert user.hasAllowedRecommendations is False
offerer = Offerer.query.filter_by(siren="349974931").first()
assert offerer is not None
assert offerer.validationToken is not None
assert len(offerer.managedVenues) == 1
assert offerer.managedVenues[0].isVirtual
assert offerer.managedVenues[0].venueTypeId == venue_type.id
user_offerer = UserOfferer.query.filter_by(user=user, offerer=offerer).first()
assert user_offerer is not None
assert user_offerer.validationToken is None
