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
