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