def test_returns_real_balances(self, app): # given user1 = create_user(email="*****@*****.**") user2 = create_user(email="*****@*****.**") offerer = create_offerer() venue = create_venue(offerer) offer = create_offer_with_thing_product(venue) stock1 = create_stock(offer=offer, price=20) stock2 = create_stock(offer=offer, price=30) stock3 = create_stock(offer=offer, price=40) repository.save(stock1, stock2, stock3, user1, user2) _create_balances_for_user1(stock1, stock2, stock3, user1, venue) _create_balances_for_user2(stock3, user2, venue) # when balances = get_all_users_wallet_balances() # then assert balances[0].real_balance == 90 assert balances[1].real_balance == 200
def test_returns_min_year_if_no_beneficiary_import_exist(self, app): # given yesterday = datetime.utcnow() - timedelta(days=1) user = create_user(date_created=yesterday) repository.save(user) # when most_recent_creation_date = find_most_recent_beneficiary_creation_date_for_source( BeneficiaryImportSources.demarches_simplifiees, 1) # then assert most_recent_creation_date == datetime(MINYEAR, 1, 1)
def test_returns_nothing_if_one_criteria_does_not_match(self, app): # given user = create_user(date_of_birth=datetime(2000, 5, 1), first_name="Jean", last_name="DOe") repository.save(user) # when users = find_by_civility("john", "doe", datetime(2000, 5, 1)) # then assert not users
def test_titelive_stock_provider_available_stock_is_sum_of_updated_available_and_bookings( self, stub_get_stocks_information, app ): # Given stub_get_stocks_information.side_effect = [ iter( [ { "ref": "9780199536986", "available": 5, "price": 0, } ] ) ] offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") titelive_stocks_provider = activate_provider("TiteLiveStocks") venue_provider = create_venue_provider( venue, titelive_stocks_provider, is_active=True, venue_id_at_offer_provider="12345678912345" ) product = create_product_with_thing_type(id_at_providers="9780199536986") offer = create_offer_with_thing_product( venue, product=product, id_at_providers="9780199536986@12345678912345" ) stock = create_stock(id_at_providers="9780199536986@12345678912345", offer=offer, price=0, quantity=20) booking = create_booking(user=create_user(), quantity=1, stock=stock) repository.save(venue_provider, booking) stub_get_stocks_information.side_effect = [ iter( [ { "ref": "9780199536986", "available": 66, "price": 0, } ] ) ] titelive_stocks = TiteLiveStocks(venue_provider) # When titelive_stocks.updateObjects() # Then stock = Stock.query.one() assert stock.quantity == 67
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_should_prevent_a_used_booking_from_being_cancelled( self, app): # Given pro_user = create_user(email="Mr [email protected]", public_name="Mr Books") offerer = create_offerer(siren="793875030") user_offerer = create_user_offerer(pro_user, offerer) venue = create_venue(offerer) book_offer = create_offer_with_event_product(venue) stock = create_stock(offer=book_offer) user = create_user(email="*****@*****.**", public_name="J.F") create_deposit(user) booking = create_booking(user=user, stock=stock, is_used=True, venue=venue) repository.save(booking, user_offerer) api_key = random_token(64) offerer_api_key = create_api_key_for_offerer(offerer, api_key) repository.save(offerer_api_key) # When response = TestClient(app.test_client()).patch( "/v2/bookings/cancel/token/{}".format(booking.token), headers={ "Authorization": "Bearer " + api_key, "Origin": "http://localhost" }, ) # Then assert response.status_code == 403 assert response.json["global"] == [ "Impossible d'annuler une réservation consommée" ] updated_booking = Booking.query.first() assert updated_booking.isUsed assert updated_booking.isCancelled is False
def when_account_is_known(self, app): # given user = create_user( civility="M.", departement_code="93", email="*****@*****.**", first_name="Jean", last_name="Smisse", date_of_birth=datetime.datetime(2000, 1, 1), phone_number="0612345678", postal_code="93020", public_name="Toto", ) user.isEmailValidated = True repository.save(user) data = { "identifier": user.email, "password": user.clearTextPassword } # when response = TestClient(app.test_client()).post("/users/signin", json=data) # then assert response.status_code == 200 assert not any("password" in field.lower() for field in response.json) assert response.json == { "activity": None, "address": None, "city": None, "civility": "M.", "dateCreated": format_into_utc_date(user.dateCreated), "dateOfBirth": format_into_utc_date(user.dateOfBirth), "departementCode": "93", "email": "*****@*****.**", "firstName": "Jean", "hasAllowedRecommendations": False, "hasOffers": False, "hasPhysicalVenues": False, "id": humanize(user.id), "isAdmin": False, "isBeneficiary": True, "isEmailValidated": True, "lastConnectionDate": None, "lastName": "Smisse", "needsToFillCulturalSurvey": False, "phoneNumber": "0612345678", "postalCode": "93020", "publicName": "Toto", }
def when_list_show_types(self, app): # given user = create_user() repository.save(user) # when response = TestClient(app.test_client()).with_auth( user.email).get("/showTypes") # then response_json = response.json assert response.status_code == 200 assert response_json == show_types
def test_should_return_errors_when_invalid_user(mock_count_users_by_email, app): # Given user = create_user(public_name="Jo") mock_count_users_by_email.return_value = 0 # When api_errors = validate(user) # Then assert api_errors.errors == { "publicName": ["Tu dois saisir au moins 3 caractères."] }
def test_is_validated_property_when_still_offerer_has_validation_token( self, app): # Given offerer = create_offerer(siren="123456789", validation_token="AAZRER") user = create_user(postal_code=None) user_offerer = create_user_offerer(user, offerer) repository.save(user_offerer) # When isValidated = offerer.isValidated # Then assert isValidated is False
def when_user_is_logged_in_and_booking_payment_exists(self, app): # Given user = create_user() pro_user = create_user(email="*****@*****.**") offerer = create_offerer() user_offerer = create_user_offerer(pro_user, offerer) venue = create_venue(offerer) stock = create_stock_with_event_offer(offerer, venue, price=0) booking = create_booking(user=user, stock=stock, venue=venue, is_used=True) payment = create_payment(booking, offerer, Decimal(10), iban="CF13QSDFGH456789", bic="QSDFGH8Z555") repository.save(booking, user_offerer, payment) # When url = "/v2/bookings/keep/token/{}".format(booking.token) response = TestClient(app.test_client()).with_auth("*****@*****.**").patch(url) # Then assert response.status_code == 410 assert response.json["payment"] == ["Le remboursement est en cours de traitement"] assert Booking.query.get(booking.id).isUsed is True
def test_check_user_can_validate_bookings_returns_true_when_user_is_authenticated_and_has_editor_rights_on_booking( self, app): # Given user = create_user() offerer = create_offerer() user_offerer = create_user_offerer(user, offerer, None) repository.save(user, offerer, user_offerer) # When result = check_user_can_validate_bookings(user, offerer.id) # Then assert result is True
def test_should_return_error_message_when_user_public_name_is_empty( self, app): # Given user = create_user(public_name="") api_errors = ApiErrors() # When api_error = validate(user, api_errors) # Then assert api_error.errors["publicName"] == [ "Tu dois saisir au moins 3 caractères." ]
def when_user_not_logged_in_right_email_and_wrong_offer(self, app): # Given user = create_user(email="*****@*****.**") admin_user = create_user(email="*****@*****.**") offerer = create_offerer() venue = create_venue(offerer) stock = create_stock_with_thing_offer(offerer, venue, offer=None, price=0) booking = create_booking(user=user, stock=stock, venue=venue) repository.save(admin_user, booking) url = f"/bookings/token/{booking.token}[email protected]&offer_id={humanize(123)}" # When response = TestClient(app.test_client()).get(url) # Then assert response.status_code == 404 assert response.json["global"] == [ "Cette contremarque n'a pas été trouvée" ]
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) repository.save(user_offerer1, user_offerer2) # When with pytest.raises(MultipleResultsFound): find_one_or_none_by_user_id(user.id)
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) repository.save(user, offerer, uo1) uo2 = create_user_offerer(user, offerer) # When with pytest.raises(ApiErrors) as error: repository.save(uo2) assert error.value.errors["global"] == ["Une entrée avec cet identifiant existe déjà dans notre base de données"]
def when_the_api_key_is_not_linked_to_the_right_offerer(self, app): # Given pro_user = create_user(email="Mr [email protected]", public_name="Mr Books") offerer = create_offerer(siren="793875030") user_offerer = create_user_offerer(pro_user, offerer) venue = create_venue(offerer) book_offer = create_offer_with_event_product(venue) stock = create_stock(offer=book_offer) user = create_user(email="*****@*****.**", public_name="J.F") create_deposit(user) booking = create_booking(user=user, stock=stock, venue=venue) repository.save(booking, user_offerer) offerer_with_api_key = create_offerer() repository.save(offerer_with_api_key) api_key = random_token(64) offerer_api_key = create_api_key_for_offerer( offerer_with_api_key, api_key) repository.save(offerer_api_key) # When response = TestClient(app.test_client()).patch( "/v2/bookings/cancel/token/{}".format(booking.token), headers={ "Authorization": "Bearer " + api_key, "Origin": "http://localhost" }, ) # Then assert response.status_code == 403 assert response.json["user"] == [ "Vous n'avez pas les droits suffisants pour annuler cette réservation." ]
def test_find_email_of_user_offerer_should_returns_email(app): # Given offerer = create_offerer() pro_user = create_user(email="*****@*****.**") user_offerer = create_user_offerer(pro_user, offerer) repository.save(pro_user, user_offerer) # When result = find_new_offerer_user_email(offerer.id) # Then assert result == "*****@*****.**"
def test_return_dict_for_native_under_age_user(self): # Given user = create_user(email="*****@*****.**", date_of_birth=datetime(1995, 2, 5)) token = users_factories.EmailValidationToken.build(user=user) # When activation_email_data = beneficiary_activation.get_activation_email_data_for_native(user, token) # Then assert activation_email_data["Vars"]["nativeAppLink"] assert "email=fabien%2Btest%40example.net" in activation_email_data["Vars"]["nativeAppLink"] assert not activation_email_data["Vars"]["isEligible"] assert activation_email_data["Vars"]["isMinor"]
def test_when_user_is_admin_should_prevent_from_accessing_bookings_list( self): # Given user = create_user(is_admin=True, is_beneficiary=False) # When with pytest.raises(UnauthorizedForAdminUser) as exception: check_is_authorized_to_access_bookings_recap(user) # Then assert exception.value.errors["global"] == [ "Le statut d'administrateur ne permet pas d'accéder au suivi des réservations" ]
def test_should_return_subject_with_correct_departement_code(self): # Given user = create_user(departement_code="93") offerer = create_offerer(postal_code="95490") user_offerer = create_user_offerer(user=user, offerer=offerer) # When email_object = make_validation_email_object( user_offerer=user_offerer, offerer=offerer, get_by_siren=get_by_siren_stub ) # Then assert email_object.get("Subject") == "95 - inscription / rattachement PRO à valider : Test Offerer"
def test_should_return_error_message_when_user_password_is_less_than_8_characters( self, app): # Given user = create_user(password="******") api_errors = ApiErrors() # When api_error = validate(user, api_errors) # Then assert api_error.errors["password"] == [ "Tu dois saisir au moins 8 caractères." ]
def test_should_return_error_message_when_admin_user_is_beneficiary( self, app): # Given user = create_user(is_admin=True, is_beneficiary=True) api_errors = ApiErrors() # When api_error = validate(user, api_errors) # Then assert api_error.errors["isBeneficiary"] == [ "Admin ne peut pas être bénéficiaire" ]
def test_real_wallet_balance_is_the_sum_of_deposits_if_no_bookings( self, app): # given user = create_user() deposit1 = create_deposit(user, amount=100) deposit2 = create_deposit(user, amount=50) repository.save(deposit1, deposit2) # when balance = user.real_wallet_balance # then assert balance == Decimal(150)
def when_booking_user_email_with_special_character_not_url_encoded(self, app): # Given user = create_user(email="*****@*****.**") user_admin = create_user(email="*****@*****.**") offerer = create_offerer() user_offerer = create_user_offerer(user_admin, offerer, is_admin=True) venue = create_venue(offerer) offer = create_offer_with_event_product(venue, event_name="Event Name") event_occurrence = create_event_occurrence(offer, beginning_datetime=tomorrow) stock = create_stock_from_event_occurrence( event_occurrence, price=0, booking_limit_date=tomorrow_minus_one_hour ) booking = create_booking(user=user, stock=stock, venue=venue) repository.save(user_offerer, booking) url = "/bookings/token/{}?email={}".format(booking.token, user.email) # When response = TestClient(app.test_client()).with_auth("*****@*****.**").patch(url) # Then assert response.status_code == 404
def test_find_one_or_none_by_user_id_should_return_one_user_offerer_with_same_user_id(app): # Given user = create_user(email="*****@*****.**") offerer = create_offerer(siren="123456789") user_offerer = create_user_offerer(user, offerer) repository.save(user_offerer) # When first_user_offerer = find_one_or_none_by_user_id(user.id) # Then assert isinstance(first_user_offerer, UserOfferer) assert first_user_offerer.id == user_offerer.id
def should_return_empty_list_when_no_venues_exist(self, app: object): # given pro_user = create_user() offerer = create_offerer() user_offerer = create_user_offerer(user=pro_user, offerer=offerer) repository.save(user_offerer) # when found_venues = self.venue_sql_repository.get_by_pro_identifier( pro_user.id, False) # then assert found_venues == []
def test_should_not_return_error_when_user_count_raise_error_and_id_is_provided( self, mocked_count_users_by_email, app): # Given user = create_user(idx=1) mocked_count_users_by_email.return_value = IntegrityError( "mock", "mock", "mock") api_errors = ApiErrors() # When api_error = validate(user, api_errors) # Then assert api_error.errors == {}
def save_users_with_deposits(): user1 = create_user( is_beneficiary=True, email="*****@*****.**", reset_password_token_validity_limit=datetime.utcnow() + timedelta(hours=24), ) user2 = create_user( is_beneficiary=True, email="*****@*****.**", reset_password_token_validity_limit=datetime.utcnow() + timedelta(hours=24), ) user3 = create_user( is_beneficiary=True, email="*****@*****.**", reset_password_token_validity_limit=datetime.utcnow() + timedelta(hours=24), ) user4 = create_user( is_beneficiary=True, email="*****@*****.**", reset_password_token_validity_limit=datetime.utcnow() + timedelta(hours=24), ) user5 = create_user( is_beneficiary=True, email="*****@*****.**", reset_password_token_validity_limit=datetime.utcnow() + timedelta(hours=24), ) deposit1 = create_deposit(user1, amount=500) deposit2 = create_deposit(user2, amount=500) deposit3 = create_deposit(user3, amount=500) deposit4 = create_deposit(user4, amount=500) deposit5 = create_deposit(user5, amount=500) repository.save(deposit1, deposit2, deposit3, deposit4, deposit5) logger.info("created 5 users with 500 € deposits") return user1, user2, user3, user4, user5
def when_activation_token_exists(self, app): # given token = "U2NCXTNB2" user = create_user(reset_password_token=token) repository.save(user) # when request = TestClient(app.test_client()).get("/users/token/" + token) # then assert request.status_code == 200 assert request.json == {}