def test_compute_first_thumb_dominant_color_even_if_not_first_file( self, get_thumbs_zip_file_from_ftp, get_ordered_thumbs_zip_files, app ): # given product1 = create_product_with_thing_type(id_at_providers="9780847858903", thumb_count=0) product2 = create_product_with_thing_type(id_at_providers="9782016261903", thumb_count=0) repository.save(product1, product2) zip_thumb_file = get_zip_with_2_usable_thumb_files() get_ordered_thumbs_zip_files.return_value = [zip_thumb_file] get_thumbs_zip_file_from_ftp.side_effect = [get_zip_file_from_sandbox(zip_thumb_file)] # Import thumbs for existing things provider_test( app, TiteLiveThingThumbs, None, checkedObjects=2, createdObjects=0, updatedObjects=2, erroredObjects=0, checkedThumbs=2, createdThumbs=5, updatedThumbs=0, erroredThumbs=0, Product=0, )
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 test_titelive_stock_provider_iterates_over_pagination(self, stub_get_stocks_information, app): # Given stub_get_stocks_information.side_effect = [ iter([{"ref": "0002730757438", "available": 0, "price": 4500, "validUntil": "2019-10-31T15:10:27Z"}]), iter([{"ref": "0002736409898", "available": 2, "price": 100, "validUntil": "2019-10-31T15:10:27Z"}]), ] offerer = create_offerer() venue = create_venue(offerer, siret="77567146400110") titelive_stocks_provider = activate_provider("TiteLiveStocks") venue_provider = create_venue_provider( venue, titelive_stocks_provider, is_active=True, venue_id_at_offer_provider="77567146400110" ) product1 = create_product_with_thing_type(id_at_providers="0002730757438") product2 = create_product_with_thing_type(id_at_providers="0002736409898") repository.save(product1, product2, venue_provider) titelive_stocks = TiteLiveStocks(venue_provider) # When titelive_stocks.updateObjects() # Then assert Offer.query.count() == 2 assert Stock.query.count() == 2 assert stub_get_stocks_information.call_args_list == [ call("77567146400110", "", None), call("77567146400110", "0002730757438", None), call("77567146400110", "0002736409898", None), ]
def test_titelive_stock_provider_create_2_stocks_and_2_offers_even_if_existing_offer_on_same_product( self, mock_stocks_information, app ): # Given mock_stocks_information.return_value = iter( [ {"ref": "0002730757438", "available": 10, "price": 4500, "validUntil": "2019-10-31T15:10:27Z"}, {"ref": "0002736409898", "available": 2, "price": 100, "validUntil": "2019-10-31T15:10:27Z"}, ] ) offerer = create_offerer() venue = create_venue(offerer, siret="77567146400110") titelive_stocks_provider = activate_provider("TiteLiveStocks") venue_provider = create_venue_provider( venue, titelive_stocks_provider, is_active=True, venue_id_at_offer_provider="77567146400110" ) product1 = create_product_with_thing_type(id_at_providers="0002730757438") product2 = create_product_with_thing_type(id_at_providers="0002736409898") offer = create_offer_with_thing_product(venue, product=product1, id_at_providers="not_titelive") repository.save(product1, product2, venue_provider, offer) titelive_stocks = TiteLiveStocks(venue_provider) # When titelive_stocks.updateObjects() # Then assert Offer.query.filter_by(lastProviderId=titelive_stocks_provider.id).count() == 2 assert Stock.query.count() == 2
def test_filter_query_where_user_is_user_offerer_and_is_validated(app): # Given user = create_user(email="*****@*****.**") offerer1 = create_offerer(siren="123456789") offerer2 = create_offerer(siren="987654321") offerer3 = create_offerer(siren="123456780") user_offerer1 = create_user_offerer(user, offerer1) user_offerer2 = create_user_offerer(user, offerer2) event1 = create_product_with_event_type(event_name="Rencontre avec Jacques Martin") event2 = create_product_with_event_type(event_name="Concert de contrebasse") thing1 = create_product_with_thing_type(thing_name="Jacques la fripouille") thing2 = create_product_with_thing_type(thing_name="Belle du Seigneur") venue1 = create_venue(offerer1, name="Bataclan", city="Paris", siret=offerer1.siren + "12345") venue2 = create_venue(offerer2, name="Librairie la Rencontre", city="Saint Denis", siret=offerer2.siren + "54321") venue3 = create_venue( offerer3, name="Une librairie du méchant concurrent gripsou", city="Saint Denis", siret=offerer3.siren + "54321" ) offer1 = create_offer_with_event_product(venue=venue1, product=event1) offer2 = create_offer_with_event_product(venue=venue1, product=event2) offer3 = create_offer_with_thing_product(venue=venue2, product=thing1) offer4 = create_offer_with_thing_product(venue=venue3, product=thing2) repository.save(user_offerer1, user_offerer2, offerer3, offer1, offer2, offer3, offer4) # When offers = filter_query_where_user_is_user_offerer_and_is_validated(Offer.query.join(Venue).join(Offerer), user).all() # Then offer_ids = [offer.id for offer in offers] assert offer1.id in offer_ids assert offer2.id in offer_ids assert offer3.id in offer_ids assert offer4.id not in offer_ids
def test_should_deactivate_offers_with_inappropriate_content( self, mocked_redis, app): # Given offerer = create_offerer() product_1 = create_product_with_thing_type( description="premier produit inapproprié") product_2 = create_product_with_thing_type( description="second produit inapproprié") venue = create_venue(offerer) offer_1 = create_offer_with_thing_product(product=product_1, venue=venue) offer_2 = create_offer_with_thing_product(product=product_2, venue=venue) repository.save(offer_1, offer_2) # When deactivate_inappropriate_offers([offer_1.id, offer_2.id]) # Then products = Product.query.all() offers = Offer.query.all() first_product = products[0] second_product = products[1] first_offer = offers[0] second_offer = offers[1] assert not first_product.isGcuCompatible assert not second_product.isGcuCompatible assert not first_offer.isActive assert not second_offer.isActive for o in offers: mocked_redis.add_offer_id.assert_any_call(client=app.redis_client, offer_id=o.id)
def test_stock_provider_praxiel_iterates_over_pagination( self, mock_praxiel_api_response, app): # Given mock_praxiel_api_response.side_effect = [ iter([{ "ref": "9780199536986", "available": 4, "price": 16 }]), iter([{ "ref": "1550199555555", "available": 5, "price": 14 }]), ] offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") praxiel_stocks_provider = activate_provider("PraxielStocks") venue_provider = create_venue_provider( venue, praxiel_stocks_provider, is_active=True, venue_id_at_offer_provider="12345678912345", last_sync_date=datetime(2020, 2, 4), ) product_1 = create_product_with_thing_type( id_at_providers="9780199536986") product_2 = create_product_with_thing_type( id_at_providers="1550199555555") repository.save(product_1, product_2, venue_provider) praxiel_stocks_provider = PraxielStocks(venue_provider) # When praxiel_stocks_provider.updateObjects() # Then offers = Offer.query.all() stocks = Stock.query.all() assert len(stocks) == 2 assert len(offers) == 2 assert mock_praxiel_api_response.call_args_list == [ call("12345678912345", "", datetime(2020, 2, 4)), call("12345678912345", "9780199536986", datetime(2020, 2, 4)), call("12345678912345", "1550199555555", datetime(2020, 2, 4)), ]
def test_titelive_stock_provider_create_1_stock_and_1_offer_with_wanted_attributes( self, stub_get_stocks_information, app ): # Given stub_get_stocks_information.return_value = iter( [{"ref": "0002730757438", "available": 10, "price": 4500, "validUntil": "2019-10-31T15:10:27Z"}] ) offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") titelive_provider = activate_provider("TiteLiveStocks") venue_provider = create_venue_provider( venue, titelive_provider, venue_id_at_offer_provider=venue.siret, last_sync_date=datetime(2020, 2, 4) ) product = create_product_with_thing_type(id_at_providers="0002730757438") repository.save(product, venue_provider) titelive_stocks = TiteLiveStocks(venue_provider) # When titelive_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 == 45.00 assert stock.quantity == 10 assert stock.bookingLimitDatetime is None
def should_call_api_with_venue_siret_and_last_sync_date(self, stub_get_stocks_information, app): # Given stub_get_stocks_information.side_effect = [ iter([{"ref": "0002730757438", "available": 0, "price": 4500, "validUntil": "2019-10-31T15:10:27Z"}]) ] offerer = create_offerer() venue = create_venue(offerer, siret="77567146400110") titelive_stocks_provider = activate_provider("TiteLiveStocks") last_sync_date = datetime.strptime("27/08/2020 09:15:32", "%d/%m/%Y %H:%M:%S") venue_provider = create_venue_provider( venue, titelive_stocks_provider, is_active=True, venue_id_at_offer_provider="77567146400110", last_sync_date=last_sync_date, ) product = create_product_with_thing_type(id_at_providers="0002730757438") repository.save(product, venue_provider) titelive_stocks = TiteLiveStocks(venue_provider) # When titelive_stocks.updateObjects() # Then assert stub_get_stocks_information.call_args_list == [ call("77567146400110", "", last_sync_date), call("77567146400110", "0002730757438", last_sync_date), ]
def test_should_return_providable_infos_with_correct_data(self, mock_titelive_api_response, app): # Given mock_titelive_api_response.return_value = iter( [{"ref": "0002730757438", "available": 10, "price": 4500, "validUntil": "2019-10-31T15:10:27Z"}] ) offerer = create_offerer() venue = create_venue(offerer, siret="12345678912345") titelive_provider = activate_provider("TiteLiveStocks") venue_provider = create_venue_provider( venue, titelive_provider, venue_id_at_offer_provider=venue.siret, last_sync_date=datetime(2020, 2, 4) ) product = create_product_with_thing_type(id_at_providers="0002730757438") repository.save(product, venue_provider) titelive_stocks = TiteLiveStocks(venue_provider) # When titelive_providable_infos = next(titelive_stocks) # Then assert mock_titelive_api_response.call_args_list == [call("12345678912345", "", datetime(2020, 2, 4))] assert len(titelive_providable_infos) == 2 offer_providable_info = titelive_providable_infos[0] stock_providable_info = titelive_providable_infos[1] assert offer_providable_info.type == Offer assert offer_providable_info.id_at_providers == "0002730757438@12345678912345" assert stock_providable_info.type == Stock assert stock_providable_info.id_at_providers == "0002730757438@12345678912345"
def test_titelive_stock_provider_create_nothing_if_titelive_api_returns_no_results( self, stub_get_stocks_information, app ): # Given stub_get_stocks_information.return_value = iter([]) offerer = create_offerer() venue = create_venue(offerer, siret="77567146400110") titelive_stocks_provider = activate_provider("TiteLiveStocks") venue_provider = create_venue_provider( venue, titelive_stocks_provider, is_active=True, venue_id_at_offer_provider="77567146400110" ) product = create_product_with_thing_type(id_at_providers="0002730757438") offer = create_offer_with_thing_product(venue, product=product) repository.save(product, venue_provider, offer) titelive_stocks = TiteLiveStocks(venue_provider) # When titelive_stocks.updateObjects() # Then assert Offer.query.filter_by(lastProviderId=titelive_stocks_provider.id).count() == 0 assert Stock.query.count() == 0
def test_titelive_stock_provider_create_1_stock_and_update_1_existing_offer( self, stub_get_stocks_information, app ): # Given stub_get_stocks_information.return_value = iter( [{"ref": "0002730757438", "available": 10, "price": 4500, "validUntil": "2019-10-31T15:10:27Z"}] ) offerer = create_offerer() venue = create_venue(offerer, siret="77567146400110") titelive_stocks_provider = activate_provider("TiteLiveStocks") venue_provider = create_venue_provider( venue, titelive_stocks_provider, is_active=True, venue_id_at_offer_provider="77567146400110" ) product = create_product_with_thing_type(id_at_providers="0002730757438") offer = create_offer_with_thing_product( venue, product=product, id_at_providers="0002730757438@77567146400110" ) repository.save(product, venue_provider, offer) titelive_stocks = TiteLiveStocks(venue_provider) # When titelive_stocks.updateObjects() # Then assert Stock.query.count() == 1 assert Offer.query.count() == 1
def test_should_set_isGcuCompatible_at_false_in_product_and_deactivate_offer_when_bookings_related_to_offer( self, app): # Given isbn = "1111111111111" user = create_user() offerer = create_offerer(siren="775671464") venue = create_venue(offerer, name="Librairie Titelive", siret="77567146400110") product = create_product_with_thing_type(id_at_providers=isbn, is_gcu_compatible=True) offer = create_offer_with_thing_product(venue, product=product, is_active=True) stock = create_stock(offer=offer, price=0) booking = create_booking(user=user, is_cancelled=True, stock=stock) repository.save(venue, product, offer, stock, booking, user) # When with pytest.raises(Exception): delete_unwanted_existing_product("1111111111111") # Then offer = Offer.query.one() assert offer.isActive is False assert Product.query.one() == product assert not product.isGcuCompatible
def test_should_delete_product_when_related_offer_is_on_user_favorite_list( self, app): # Given isbn = "1111111111111" user = create_user() offerer = create_offerer(siren="775671464") venue = create_venue(offerer, name="Librairie Titelive", siret="77567146400110") product = create_product_with_thing_type(id_at_providers=isbn) offer = create_offer_with_thing_product(venue, product=product) stock = create_stock(offer=offer, price=0) mediation = create_mediation(offer=offer) favorite = create_favorite(mediation=mediation, offer=offer, user=user) repository.save(venue, product, offer, stock, user, mediation, favorite) # When delete_unwanted_existing_product("1111111111111") # Then assert Product.query.count() == 0 assert Offer.query.count() == 0 assert Stock.query.count() == 0 assert Mediation.query.count() == 0 assert FavoriteSQLEntity.query.count() == 0
def test_titelive_stock_provider_skips_stock_update_when_price_is_null(self, stub_get_stocks_information, app): # Given stub_get_stocks_information.return_value = iter( [{"ref": "0002730757438", "available": 10, "price": None, "validUntil": "2019-10-31T15:10:27Z"}] ) offerer = create_offerer() venue = create_venue(offerer, siret="77567146400110") titelive_stocks_provider = activate_provider("TiteLiveStocks") venue_provider = create_venue_provider( venue, titelive_stocks_provider, is_active=True, venue_id_at_offer_provider="77567146400110" ) product = create_product_with_thing_type(id_at_providers="0002730757438") offer = create_offer_with_thing_product( venue, product=product, id_at_providers="0002730757438@77567146400110" ) stock = create_stock(id_at_providers="0002730757438@77567146400110", offer=offer, quantity=10, price=12.34) repository.save(product, venue_provider, stock) titelive_stocks = TiteLiveStocks(venue_provider) # When titelive_stocks.updateObjects() # Then stock = Stock.query.one() assert stock.quantity == 10 assert stock.price == Decimal("12.34") assert Offer.query.count() == 1
def test_save_chunks_insert_1_offer_and_1_stock_in_chunk(self, app): # Given offerer = create_offerer() venue = create_venue(offerer) product = create_product_with_thing_type() repository.save(venue, product) offer = create_offer_with_thing_product( venue, product=product, id_at_providers="1%12345678912345") offer.venueId = venue.id offer_id = db.session.execute(Sequence("offer_id_seq")) offer.id = offer_id stock = create_stock(offer=offer) stock.offerId = offer_id chunk_to_insert = { "1|Offer": offer, "1|Stock": stock, } db.session.expunge(offer) db.session.expunge(stock) chunk_to_update = {} # When save_chunks(chunk_to_insert, chunk_to_update) # Then assert Offer.query.count() == 1 assert Stock.query.count() == 1
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 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_should_return_1_offer_when_there_are_one_full_stock_and_one_empty_stock( self): # Given product = create_product_with_thing_type(thing_name="Lire un livre", is_national=True) offerer = create_offerer() venue = create_venue(offerer, postal_code="34000", departement_code="34") offer = create_offer_with_thing_product(venue=venue, product=product) stock1 = create_stock_from_offer(offer, price=0, quantity=2) stock2 = create_stock_from_offer(offer, price=0, quantity=2) user = create_user() booking1 = create_booking(user=user, stock=stock1, quantity=2, venue=venue) repository.save(booking1, stock2) bookings_quantity = _build_bookings_quantity_subquery() # When offers_count = (Offer.query.join(Stock).outerjoin( bookings_quantity, Stock.id == bookings_quantity.c.stockId).filter((Stock.quantity == None) | ( (Stock.quantity - func.coalesce(bookings_quantity.c.quantity, 0)) > 0)).count()) # Then assert offers_count == 1
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 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 test_should_return_empty_isbn_when_product_does_not_contain_isbn(self): # Given user = create_user(email="*****@*****.**", public_name="John Doe") offerer = create_offerer() venue = create_venue(offerer, name="Venue name", address="Venue address") product = create_product_with_thing_type( thing_name="Event Name", thing_type=ThingType.CINEMA_ABO, extra_data={}) offer = create_offer_with_thing_product(venue, product=product, idx=999) stock = create_stock(offer=offer, price=12) booking = create_booking(user=user, quantity=3, stock=stock, venue=venue) # When response = serialize_booking(booking) # Then assert response["ean13"] == ""
def test_should_raise_error_when_pc_object_already_exists(self, app): # Given product = create_product_with_thing_type() repository.save(product) # When / Then with pytest.raises(IntegrityError): bulk_insert_pc_objects([product], Product)
def test_should_raise_error_when_pc_object_does_not_exist(self, app): # Given product_to_update = create_product_with_thing_type() product_to_update.thumbCount = 5 # When / Then with pytest.raises(StaleDataError): bulk_update_pc_objects([product_to_update], Product)
def test_should_return_errors_when_valid_product(): # Given product = create_product_with_thing_type() # When api_errors = validate(product) # Then assert api_errors.errors == {}
def test_should_return_errors_when_invalid_product(): # Given product = create_product_with_thing_type(is_offline_only=True, is_digital=True) # When api_errors = validate(product) # Then assert api_errors.errors == {"url": ["Une offre de type Cinéma - cartes d'abonnement ne peut pas être numérique"]}
def test_thing_offerType_returns_None_if_type_does_not_match_ThingType_enum(): # given thing_product = create_product_with_thing_type(thing_type="") # when offer_type = thing_product.offerType # then assert offer_type == None
def test_should_return_error_message_when_product_is_digital_and_offline(): # Given product = create_product_with_thing_type(is_offline_only=True, is_digital=True) api_errors = ApiErrors() # When api_error = validate(product, api_errors) # Then assert api_error.errors["url"] == ["Une offre de type Cinéma - cartes d'abonnement ne peut pas être numérique"]
def test_should_insert_pc_object_list_in_database(self, app): # Given product = create_product_with_thing_type(thumb_count=5) # When bulk_insert_pc_objects([product], Product) # Then modified_product = Product.query.one() assert modified_product.thumbCount == 5
def test_should_return_None_if_not_match(self, app): # Given product = create_product_with_thing_type() repository.save(product) # When existing_product = get_pc_object_by_id_in_database(45, Product) # Then assert existing_product is None