def test_should_not_create_product_when_school_related_product( self, get_lines_from_thing_file, get_files_to_process_from_titelive_ftp, app ): # Given files_list = list() files_list.append("Quotidien30.tit") get_files_to_process_from_titelive_ftp.return_value = files_list DATA_LINE_PARTS = BASE_DATA_LINE_PARTS[:] DATA_LINE_PARTS[2] = "livre scolaire" DATA_LINE_PARTS[4] = "2704" DATA_LINE_PARTS[27] = "Littérature scolaire" DATA_LINE_PARTS[40] = "" data_line = "~".join(DATA_LINE_PARTS) get_lines_from_thing_file.return_value = iter([data_line]) activate_provider("TiteLiveThings") titelive_things = TiteLiveThings() # When titelive_things.updateObjects() # Then assert Product.query.count() == 0
def when_venue_has_no_allocine_id(self, app): # Given user = create_user(email="*****@*****.**") offerer = create_offerer() venue = create_venue(offerer) repository.save(user, venue) titelive_stocks = activate_provider("TiteLiveStocks") activate_provider("AllocineStocks") # When response = (TestClient(app.test_client()).with_auth( email="*****@*****.**").get(f"/providers/{humanize(venue.id)}")) # Then assert response.status_code == 200 response_json = response.json assert response_json == [{ "enabledForPro": True, "id": humanize(titelive_stocks.id), "isActive": True, "localClass": "TiteLiveStocks", "name": "TiteLive Stocks (Epagine / Place des libraires.com)", "requireProviderIdentifier": True, }]
def test_update_1_thing_from_one_data_line_in_one_file( self, get_lines_from_thing_file, get_files_to_process_from_titelive_ftp, app ): # Given files_list = list() files_list.append("Quotidien30.tit") get_files_to_process_from_titelive_ftp.return_value = files_list data_line = "~".join(BASE_DATA_LINE_PARTS) get_lines_from_thing_file.return_value = iter([data_line]) titelive_things_provider = get_provider_by_local_class("TiteLiveThings") product = create_product_with_thing_subcategory( id_at_providers="9782895026310", thing_name="Toto à la playa", date_modified_at_last_provider=datetime(2001, 1, 1), last_provider_id=titelive_things_provider.id, ) activate_provider("TiteLiveThings") repository.save(product) titelive_things = TiteLiveThings() # When titelive_things.updateObjects() # Then updated_product = Product.query.first() assert updated_product.name == "nouvelles du Chili" assert updated_product.extraData.get("bookFormat") == BookFormat.BEAUX_LIVRES.value
def test_should_not_create_product_when_product_is_paper_press( self, get_lines_from_thing_file, get_files_to_process_from_titelive_ftp, app ): # Given files_list = list() files_list.append("Quotidien30.tit") get_files_to_process_from_titelive_ftp.return_value = files_list DATA_LINE_PARTS = BASE_DATA_LINE_PARTS[:] DATA_LINE_PARTS[1] = "9136205982" DATA_LINE_PARTS[13] = "R" DATA_LINE_PARTS[26] = "2,10" data_line_1 = "~".join(DATA_LINE_PARTS) DATA_LINE_PARTS = BASE_DATA_LINE_PARTS[:] DATA_LINE_PARTS[26] = "2,10" data_line_2 = "~".join(DATA_LINE_PARTS) get_lines_from_thing_file.return_value = iter([data_line_1, data_line_2]) activate_provider("TiteLiveThings") titelive_things = TiteLiveThings() # When titelive_things.updateObjects() products = Product.query.all() product = products[0] # Then assert len(products) == 1 assert product.extraData["isbn"] == "9782895026310"
def test_does_not_create_thing_when_too_many_columns_in_data_line( self, get_lines_from_thing_file, get_files_to_process_from_titelive_ftp, app ): # Given files_list = list() files_list.append("Quotidien30.tit") get_files_to_process_from_titelive_ftp.return_value = files_list DATA_LINE_PARTS = BASE_DATA_LINE_PARTS[:] DATA_LINE_PARTS[13] = "LE" DATA_LINE_PARTS[27] = "Littérature scolaire" DATA_LINE_PARTS[39] = "1" DATA_LINE_PARTS[40] = "0" data_line = "~".join(DATA_LINE_PARTS) get_lines_from_thing_file.return_value = iter([data_line]) activate_provider("TiteLiveThings") titelive_things = TiteLiveThings() # When titelive_things.updateObjects() # Then assert Product.query.count() == 0
def save_allocine_sandbox() -> None: sirene = Sirene() create_industrial_admin_users() user = create_user( first_name="Didier", last_name="Champion", public_name="Didier Champion", email="*****@*****.**", is_beneficiary=False, ) offerer = create_offerer( address="145, rue Chaplin", city="Paris 17", name="Le Royal - Cinéma d'essai", postal_code="75017", siren=sirene.siren, ) user_offerer = create_user_offerer( offerer=offerer, user=user, ) venue = create_venue( offerer, address=offerer.address, booking_email="*****@*****.**", city=offerer.city, comment="Salle de cinéma", name=offerer.name + " - Salle 1", postal_code=offerer.postalCode, siret=sirene.siret, ) activate_provider("AllocineStocks") provider = get_provider_by_local_class("AllocineStocks") venue_provider = create_venue_provider(venue, provider=provider, is_active=True) repository.save(user, offerer, user_offerer, venue, provider, venue_provider) offer = create_offer_with_event_product( venue, event_type=EventType.CINEMA, last_provider_id=provider.id, id_at_providers="TW92aWU6MjQ4MTAy%34007977100028-VF", last_provider=provider, ) repository.save(offer)
def test_does_not_create_thing_when_no_files_found(self, get_files_to_process_from_titelive_ftp, app): # Given files_list = list() get_files_to_process_from_titelive_ftp.return_value = files_list activate_provider("TiteLiveThings") titelive_things = TiteLiveThings() # When titelive_things.updateObjects() # Then assert Product.query.count() == 0
def test_should_return_only_venue_provider_for_specified_provider(self, app): # Given offerer = create_offerer() venue = create_venue(offerer) titelive_provider = activate_provider("TiteLiveStocks") allocine_provider = activate_provider("AllocineStocks") venue_provider_titelive = create_venue_provider(venue, titelive_provider) venue_provider_allocine = create_venue_provider(venue, allocine_provider) repository.save(venue_provider_titelive, venue_provider_allocine) # When venue_providers = get_venue_providers_to_sync(titelive_provider.id) # Then assert venue_providers == [venue_provider_titelive]
def should_not_connect_venue_when_venue_has_no_siret(self, app): # Given offerer = create_offerer() venue = create_venue(offerer, siret=None, is_virtual=True) provider = activate_provider("LibrairesStocks") repository.save(venue) self.find_by_id.return_value = venue stock_repository = MagicMock() provider_type = LibrairesStocks venue_provider_payload = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } # when with pytest.raises(ApiErrors) as error: connect_venue_to_provider(provider_type, stock_repository, venue_provider_payload, self.find_by_id) # then assert error.value.errors["provider"] == [ "L’importation d’offres avec LesLibraires n’est pas disponible sans SIRET associé au lieu. Ajoutez un SIRET pour pouvoir importer les offres." ]
def when_add_allocine_stocks_provider_with_no_price(self, app): # Given venue = offer_factories.VenueFactory( managingOfferer__siren="775671464") user = user_factories.AdminFactory() AllocinePivotFactory(siret=venue.siret) provider = activate_provider("AllocineStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } auth_request = TestClient( app.test_client()).with_session_auth(email=user.email) # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 400 assert response.json["price"] == [ "Il est obligatoire de saisir un prix." ] assert VenueProvider.query.count() == 0
def when_add_allocine_pivot_is_missing(self, app): # Given venue = offer_factories.VenueFactory( managingOfferer__siren="775671464") user = user_factories.AdminFactory() provider = activate_provider("AllocineStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } auth_request = TestClient( app.test_client()).with_session_auth(email=user.email) # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 404 assert response.json == { "allocine": [ "Ce lieu n'est pas autorisé à être synchronisé avec Allociné. Veuillez contacter le support si vous souhaitez le faire." ] } assert VenueProvider.query.count() == 0
def when_venue_provider_is_successfully_created( self, stubbed_find_by_id, stubbed_check, mock_synchronize_venue_provider, app ): # Given user = create_user(is_admin=True, is_beneficiary=False) offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") repository.save(venue, user) stubbed_find_by_id.return_value = venue provider = activate_provider("LibrairesStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } auth_request = TestClient(app.test_client()).with_auth(email=user.email) stubbed_check.return_value = True # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 201 venue_provider = VenueProvider.query.one() assert venue_provider.venueId == venue.id assert venue_provider.providerId == provider.id assert venue_provider.venueIdAtOfferProvider == "12345678912345" assert "id" in response.json venue_provider_id = response.json["id"] mock_synchronize_venue_provider.assert_called_once_with(dehumanize(venue_provider_id))
def should_inject_the_appropriate_repository_to_the_usecase( self, mocked_connect_venue_to_provider, stubbed_find_by_id, stubbed_check, app ): # Given user = create_user(is_admin=True, is_beneficiary=False) offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") repository.save(venue, user) stubbed_find_by_id.return_value = venue provider = activate_provider("LibrairesStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } auth_request = TestClient(app.test_client()).with_auth(email=user.email) stubbed_check.return_value = True # When auth_request.post("/venueProviders", json=venue_provider_data) # Then mocked_connect_venue_to_provider.assert_called_once_with( LibrairesStocks, api_libraires_stocks, {"providerId": humanize(provider.id), "venueId": humanize(venue.id)}, stubbed_find_by_id, )
def when_provider_api_not_available(self, stubbed_find_by_id, stubbed_check, app): # Given user = create_user(is_admin=True, is_beneficiary=False) offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") repository.save(venue, user) stubbed_find_by_id.return_value = venue provider = activate_provider("LibrairesStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } auth_request = TestClient(app.test_client()).with_auth(email=user.email) errors = ApiErrors() errors.status_code = 422 errors.add_error( "provider", "L’importation d’offres avec LesLibraires n’est pas disponible " "pour le SIRET 12345678912345", ) stubbed_check.side_effect = [errors] # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 422 assert response.json["provider"] == [ "L’importation d’offres avec LesLibraires n’est pas disponible pour le SIRET 12345678912345" ] assert VenueProvider.query.count() == 0
def test_fnac_stock_provider_create_one_stock_and_one_offer_with_wanted_attributes( self, mock_fnac_api_response, app ): # Given mock_fnac_api_response.return_value = iter([{"ref": "9780199536986", "available": 10, "price": 16.5}]) offerer = create_offerer() venue = create_venue(offerer, siret="77567146400110") fnac_stocks_provider = activate_provider("FnacStocks") venue_provider = create_venue_provider( venue, fnac_stocks_provider, is_active=True, venue_id_at_offer_provider="77567146400110" ) product = create_product_with_thing_type(id_at_providers="9780199536986") repository.save(product, venue_provider) fnac_stocks = FnacStocks(venue_provider) # When fnac_stocks.updateObjects() # Then offer = Offer.query.first() stock = Stock.query.first() assert offer.type == product.type assert offer.description == product.description assert offer.venue is not None assert offer.bookingEmail == venue.bookingEmail assert offer.extraData == product.extraData assert stock.price == 16.5 assert stock.quantity == 10 assert stock.bookingLimitDatetime is None
def test_query_venue_provider_load_allocine_venue_provider_attributes_when_connected_to_allocine( self, app): offerer = create_offerer() venue = create_venue(offerer) provider_allocine = activate_provider("AllocineStocks") provider = create_provider(local_class="TestLocalProvider") venue_provider = create_venue_provider(venue, provider) allocine_venue_provider = create_allocine_venue_provider( venue, provider_allocine, is_duo=True) repository.save(venue_provider, allocine_venue_provider) assert VenueProvider.query.count() == 2 assert AllocineVenueProvider.query.count() == 1 created_venue_provider = VenueProvider.query.filter( VenueProvider.providerId == provider.id).first() assert isinstance(created_venue_provider, VenueProvider) created_allocine_venue_provider = VenueProvider.query.filter( VenueProvider.providerId == provider_allocine.id).first() assert isinstance(created_allocine_venue_provider, AllocineVenueProvider)
def test_fnac_stock_provider_available_stock_is_sum_of_updated_available_and_bookings( self, mock_fnac_api_response, app ): # Given mock_fnac_api_response.return_value = iter([{"ref": "9780199536986", "available": 5, "price": 0}]) offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") fnac_stocks_provider = activate_provider("FnacStocks") venue_provider = create_venue_provider( venue, fnac_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) mock_fnac_api_response.return_value = iter([{"ref": "9780199536986", "available": 66, "price": 0}]) fnac_stocks = FnacStocks(venue_provider) # When fnac_stocks.updateObjects() # Then stock = Stock.query.one() assert stock.quantity == 67
def should_connect_to_allocine( self, app, ): # Given user = user_factories.AdminFactory() venue = offer_factories.VenueFactory(siret="12345678912345") AllocinePivotFactory(siret=venue.siret) provider = activate_provider("AllocineStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), "price": "33.33" } auth_request = TestClient( app.test_client()).with_session_auth(email=user.email) # When auth_request.post("/venueProviders", json=venue_provider_data) # Then assert len(venue.venueProviders) == 1 assert venue.venueProviders[0].provider == provider
def should_not_connect_venue_when_synchronization_is_not_allowed( self, app): # Given offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") provider = activate_provider("LibrairesStocks") repository.save(venue) self.find_by_id.return_value = venue stock_repository = MagicMock() stock_repository.can_be_synchronized.return_value = False provider_class = LibrairesStocks venue_provider_payload = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } # when with pytest.raises(ApiErrors) as error: print( connect_venue_to_provider(provider_class, stock_repository, venue_provider_payload, self.find_by_id)) # then assert error.value.errors["provider"] == [ "L’importation d’offres avec LesLibraires n’est pas disponible pour le SIRET 12345678912345" ]
def should_connect_venue_when_synchronization_is_allowed(self, app): # Given offerer = create_offerer() venue = create_venue(offerer) provider = activate_provider("PraxielStocks") repository.save(venue) self.find_by_id.return_value = venue stock_repository = MagicMock() stock_repository.can_be_synchronized.return_value = True provider_type = PraxielStocks venue_provider_payload = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), } # When connect_venue_to_provider(provider_type, stock_repository, venue_provider_payload, self.find_by_id) # Then praxiel_venue_provider = VenueProvider.query.one() assert praxiel_venue_provider.venue == venue
def when_add_allocine_stocks_provider_with_default_settings_at_import( self, app): # Given venue = offer_factories.VenueFactory( managingOfferer__siren="775671464") user = user_factories.AdminFactory() AllocinePivotFactory(siret=venue.siret) provider = activate_provider("AllocineStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), "price": "9.99", "quantity": 50, "isDuo": True, } auth_request = TestClient( app.test_client()).with_session_auth(email=user.email) # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 201 assert response.json["isDuo"] assert response.json["price"] == 9.99 assert response.json["quantity"] == 50
def when_add_allocine_stocks_provider_with_price_but_no_isDuo_config( self, app): # Given venue = offer_factories.VenueFactory( managingOfferer__siren="775671464") user = user_factories.AdminFactory() AllocinePivotFactory(siret=venue.siret) provider = activate_provider("AllocineStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), "price": "9.99" } auth_request = TestClient( app.test_client()).with_session_auth(email=user.email) # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 201 json = response.json assert "_sa_polymorphic_on" not in json venue_provider = VenueProvider.query.one() assert json["venueId"] == humanize(venue_provider.venueId)
def test_should_delete_product_when_it_changes_to_paper_press_product( self, get_lines_from_thing_file, get_files_to_process_from_titelive_ftp, app ): # Given files_list = list() files_list.append("Quotidien30.tit") DATA_LINE_PARTS = BASE_DATA_LINE_PARTS[:] DATA_LINE_PARTS[13] = "R" DATA_LINE_PARTS[26] = "2,10" data_line = "~".join(DATA_LINE_PARTS) get_files_to_process_from_titelive_ftp.return_value = files_list get_lines_from_thing_file.return_value = iter([data_line]) titelive_provider = activate_provider("TiteLiveThings") repository.save(titelive_provider) product = create_product_with_thing_subcategory( id_at_providers="9782895026310", thing_name="Presse papier", date_modified_at_last_provider=datetime(2001, 1, 1), last_provider_id=titelive_provider.id, ) repository.save(product) titelive_things = TiteLiveThings() # When titelive_things.updateObjects() # Then assert Product.query.count() == 0
def should_connect_venue_to_allocine_provider(self, app): # Given offerer = create_offerer() venue = create_venue(offerer) provider = activate_provider("AllocineStocks") allocine_pivot = create_allocine_pivot(siret=venue.siret) repository.save(venue, allocine_pivot) self.find_by_id.return_value = venue self.get_theaterid_for_venue.return_value = allocine_pivot.theaterId venue_provider_payload = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), "price": "9.99", "isDuo": True, "quantity": 50, } # When connect_venue_to_allocine(venue_provider_payload, self.find_by_id, self.get_theaterid_for_venue) # Then allocine_venue_provider = AllocineVenueProvider.query.one() venue_provider_price_rule = AllocineVenueProviderPriceRule.query.one() assert allocine_venue_provider.venue == venue assert allocine_venue_provider.isDuo assert allocine_venue_provider.quantity == 50 assert venue_provider_price_rule.price == Decimal("9.99")
def test_fnac_stocks_create_2_stocks_and_2_offers_even_if_existing_offer_on_same_product( self, mock_fnac_api_response, app ): # Given mock_fnac_api_response.return_value = iter( [ {"ref": "9780199536986", "available": 5, "price": 16}, {"ref": "1550199555555", "available": 4, "price": 18}, ] ) offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") fnac_stocks_provider = activate_provider("FnacStocks") venue_provider = create_venue_provider( venue, fnac_stocks_provider, is_active=True, venue_id_at_offer_provider="12345678912345" ) product_1 = create_product_with_thing_type(id_at_providers="9780199536986") product_2 = create_product_with_thing_type(id_at_providers="1550199555555") offer = create_offer_with_thing_product(venue, product=product_2, id_at_providers="everything_but_fnac_id") repository.save(offer, product_1, product_2, venue_provider) fnac_stocks = FnacStocks(venue_provider) # When fnac_stocks.updateObjects() # Then assert Stock.query.count() == 2 assert Offer.query.filter_by(lastProviderId=fnac_stocks_provider.id).count() == 2 assert fnac_stocks.last_processed_isbn == "1550199555555"
def when_add_allocine_stocks_provider_with_price_but_no_isDuo_config( self, stubbed_get_theaterid_for_venue, stubbed_find_by_id, app ): # Given offerer = create_offerer(siren="775671464") venue = create_venue(offerer) user = create_user(is_admin=True, is_beneficiary=False) allocine_pivot = create_allocine_pivot(siret=venue.siret) repository.save(venue, user, allocine_pivot) stubbed_find_by_id.return_value = venue stubbed_get_theaterid_for_venue.return_value = allocine_pivot.theaterId provider = activate_provider("AllocineStocks") venue_provider_data = {"providerId": humanize(provider.id), "venueId": humanize(venue.id), "price": "9.99"} auth_request = TestClient(app.test_client()).with_auth(email=user.email) # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 201 json = response.json assert "_sa_polymorphic_on" not in json venue_provider = VenueProvider.query.one() assert json["venueId"] == humanize(venue_provider.venueId)
def test_should_return_providable_infos_with_correct_data(self, mock_fnac_api_response, app): # Given mock_fnac_api_response.return_value = iter([{"ref": "9780199536986", "available": 1, "price": 6.36}]) offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") fnac_provider = activate_provider("FnacStocks") venue_provider = create_venue_provider( venue, fnac_provider, venue_id_at_offer_provider=venue.siret, last_sync_date=datetime(2020, 2, 4) ) product = create_product_with_thing_type(id_at_providers="9780199536986") repository.save(venue_provider, product) fnac_stocks_provider = FnacStocks(venue_provider) # When fnac_providable_infos = next(fnac_stocks_provider) # Then assert mock_fnac_api_response.call_args_list == [call("12345678912345", "", datetime(2020, 2, 4))] assert len(fnac_providable_infos) == 2 offer_providable_info = fnac_providable_infos[0] stock_providable_info = fnac_providable_infos[1] assert offer_providable_info.type == Offer assert offer_providable_info.id_at_providers == "9780199536986@12345678912345" assert stock_providable_info.type == Stock assert stock_providable_info.id_at_providers == "9780199536986@12345678912345"
def when_add_allocine_stocks_provider_with_default_settings_at_import(self, stubbed_find_by_id, app): # Given offerer = create_offerer(siren="775671464") venue = create_venue(offerer) user = create_user(is_admin=True, is_beneficiary=False) repository.save(venue, user) stubbed_find_by_id.return_value = venue provider = activate_provider("AllocineStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), "price": "9.99", "available": 50, "isDuo": True, } auth_request = TestClient(app.test_client()).with_auth(email=user.email) # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 201
def test_fnac_stock_provider_update_one_stock_and_update_matching_offer(self, mock_fnac_api_response, app): # Given mock_fnac_api_response.return_value = iter([{"ref": "9780199536986", "available": 10, "price": 16}]) offerer = create_offerer() venue = create_venue(offerer) fnac_stocks_provider = activate_provider("FnacStocks") venue_provider = create_venue_provider( venue, fnac_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, quantity=20) repository.save(product, offer, stock) fnac_stocks = FnacStocks(venue_provider) # When fnac_stocks.updateObjects() # Then stock = Stock.query.one() assert stock.quantity == 10 assert Offer.query.count() == 1
def when_add_allocine_stocks_provider_with_wrong_format_price(self, stubbed_find_by_id, app): # Given offerer = create_offerer(siren="775671464") venue = create_venue(offerer) user = create_user(is_admin=True, is_beneficiary=False) repository.save(venue, user) stubbed_find_by_id.return_value = venue provider = activate_provider("AllocineStocks") venue_provider_data = { "providerId": humanize(provider.id), "venueId": humanize(venue.id), "price": "wrong_price", } auth_request = TestClient(app.test_client()).with_auth(email=user.email) # When response = auth_request.post("/venueProviders", json=venue_provider_data) # Then assert response.status_code == 400 assert response.json["global"] == ["Le prix doit être un nombre décimal"] assert VenueProvider.query.count() == 0