def test_should_iterate_over_2_zip_files(
self, mock_get_date_from_filename, mock_get_zip_file_from_ftp,
mock_get_files_to_process_from_titelive):
# Given
titelive_description_provider = get_provider_by_local_class(
"TiteLiveThingDescriptions")
mock_get_files_to_process_from_titelive.return_value = [
"Resume191012.zip", "Resume191013.zip"
]
mock_get_zip_file_from_ftp.side_effect = [
MockZipFile(filename="Resume191012.zip"),
MockZipFile(filename="Resume191013.zip"),
]
mock_get_date_from_filename.side_effect = {"191012", "191013"}
repository.save(titelive_description_provider)
titelive_description_provider = TiteLiveThingDescriptions()
# When
with pytest.raises(StopIteration):
next(titelive_description_provider)
# Then
mock_get_files_to_process_from_titelive.assert_called_once_with(
"ResumesLivres", re.compile(r"Resume(\d{6}).zip"))
assert mock_get_zip_file_from_ftp.call_count == 2
assert mock_get_date_from_filename.call_count == 3
def synchronize_fnac_stocks(app) -> None:
if not feature_queries.is_active(FeatureToggle.FNAC_SYNCHRONIZATION_V2):
fnac_stocks_provider_id = get_provider_by_local_class("FnacStocks").id
synchronize_venue_providers_for_provider(fnac_stocks_provider_id)
return
synchronize_fnac_venues_stocks()
def when_listing_all_venues_with_a_valid_venue_id(self, app):
# given
offerer = create_offerer(siren="775671464")
venue = create_venue(offerer,
name="Librairie Titelive",
siret="77567146400110")
titelive_things_provider = get_provider_by_local_class(
"TiteLiveThings")
venue_provider = create_venue_provider(
venue=venue, provider=titelive_things_provider)
repository.save(venue_provider)
user = create_user()
repository.save(user)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
# when
response = auth_request.get("/venueProviders?venueId=" +
humanize(venue.id))
# then
assert response.status_code == 200
assert response.json[0].get("id") == humanize(venue_provider.id)
assert response.json[0].get("venueId") == humanize(venue.id)
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 delete_corrupted_allocine_stocks():
new_stock_id_at_providers_format = "%#%"
allocine_provider = get_provider_by_local_class("AllocineStocks")
stocks_to_delete = (Stock.query.filter_by(
lastProviderId=allocine_provider.id
).filter_by(isSoftDeleted=True).filter(
Stock.idAtProviders.notilike(new_stock_id_at_providers_format)).all())
repository.delete(*stocks_to_delete)
def __init__(self, venue_provider=None, **options):
self.venue_provider = venue_provider
self.updatedObjects = 0
self.createdObjects = 0
self.checkedObjects = 0
self.erroredObjects = 0
self.createdThumbs = 0
self.updatedThumbs = 0
self.checkedThumbs = 0
self.erroredThumbs = 0
self.provider = get_provider_by_local_class(self.__class__.__name__)
def synchronize_fnac_venues_stocks() -> None:
fnac_provider_id = get_provider_by_local_class("FnacStocks").id
venues = (Venue.query.join(VenueProvider).filter(
VenueProvider.providerId == fnac_provider_id).filter(
VenueProvider.isActive == True).all())
for venue in venues:
try:
synchronize_fnac_stocks.synchronize_venue_stocks_from_fnac(venue)
except Exception as exc: # pylint: disable=broad-except
logger.exception("Could not synchronize stock of venue=%s: %s",
venue.id, exc)
def test_should_return_provider_matching_local_class(self, app):
# Given
existing_provider = create_provider(local_class="OpenAgenda",
is_active=True,
is_enable_for_pro=True)
repository.save(existing_provider)
# When
provider = get_provider_by_local_class("OpenAgenda")
# Then
assert provider == existing_provider
def install_local_providers():
for class_name in pcapi.local_providers.__all__:
provider_class = getattr(pcapi.local_providers, class_name)
db_provider = get_provider_by_local_class(class_name)
if not db_provider:
provider = Provider()
provider.name = provider_class.name
provider.localClass = class_name
provider.isActive = False
db.session.add(provider)
db.session.commit()
def test_should_add_price_rules_to_venue_provider(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
allocine_provider = get_provider_by_local_class("AllocineStocks")
allocine_provider.isActive = True
allocine_venue_provider = create_allocine_venue_provider(
venue, allocine_provider)
allocine_venue_provider_price_rule = create_allocine_venue_provider_price_rule(
allocine_venue_provider, price_rule=PriceRule.default, price=10)
# When
repository.save(allocine_venue_provider_price_rule)
# Then
assert len(allocine_venue_provider.priceRules) == 1
def test_should_not_delete_stock_from_allocine_when_not_sof_deleted(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
allocine_provider = get_provider_by_local_class("AllocineStocks")
offer = create_offer_with_thing_product(venue)
stock = create_stock(
id_at_providers="TW92aWU6MjczNjU5%38986972800011-1",
is_soft_deleted=False,
last_provider_id=allocine_provider.id,
offer=offer,
)
repository.save(stock)
# When
delete_corrupted_allocine_stocks()
# Then
assert Stock.query.count() == 1
def test_should_raise_error_when_price_is_negative(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
allocine_provider = get_provider_by_local_class("AllocineStocks")
allocine_provider.isActive = True
allocine_venue_provider = create_allocine_venue_provider(
venue, allocine_provider)
venue_provider_price_rule = create_allocine_venue_provider_price_rule(
allocine_venue_provider, price_rule=PriceRule.default, price=-4)
# When
with pytest.raises(ApiErrors) as error:
repository.save(venue_provider_price_rule)
# Then
assert error.value.errors["global"] == [
"Vous ne pouvez renseigner un prix négatif"
]
def test_should_raise_error_when_saving_wrong_format_price(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
allocine_provider = get_provider_by_local_class("AllocineStocks")
allocine_venue_provider = create_allocine_venue_provider(
venue, allocine_provider)
price = "wrong_price_format"
venue_provider_price_rule = create_allocine_venue_provider_price_rule(
allocine_venue_provider, price_rule=PriceRule.default, price=price)
# When
with pytest.raises(ApiErrors) as error:
repository.save(venue_provider_price_rule)
# Then
assert error.value.errors == {
"global": ["Le prix doit être un nombre décimal"]
}
def test_should_call_titelive_ftp_to_get_files_list(
self, mock_get_files_to_process_from_titelive, app):
# Given
titelive_description_provider = get_provider_by_local_class(
"TiteLiveThingDescriptions")
mock_get_files_to_process_from_titelive.return_value = [
"Resume191012.zip", "Resume201012.zip"
]
repository.save(titelive_description_provider)
# When
titelive_description_provider = TiteLiveThingDescriptions()
# Then
mock_get_files_to_process_from_titelive.assert_called_once_with(
"ResumesLivres", re.compile(r"Resume(\d{6}).zip"))
titelive_description_provider.zips = [
"Resume191012.zip", "Resume201012.zip"
]
def test_should_not_delete_stock_from_allocine_with_new_id_format(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
allocine_provider = get_provider_by_local_class("AllocineStocks")
offer = create_offer_with_thing_product(venue)
stock = create_stock(
id_at_providers="TW92aWU6MjczNTc5%31940406700021#LOCAL/2020-01-18T14:00:00",
is_soft_deleted=True,
last_provider_id=allocine_provider.id,
offer=offer,
)
repository.save(stock)
# When
delete_corrupted_allocine_stocks()
# Then
assert Stock.query.count() == 1
def when_listing_all_allocine_venues_with_a_valid_venue_id(self, app):
# given
offerer = create_offerer()
venue = create_venue(offerer)
allocine_stocks_provider = get_provider_by_local_class(
"AllocineStocks")
allocine_venue_provider = create_allocine_venue_provider(
venue, allocine_stocks_provider)
repository.save(allocine_venue_provider)
user = create_user()
repository.save(user)
auth_request = TestClient(
app.test_client()).with_auth(email=user.email)
# when
response = auth_request.get("/venueProviders?venueId=" +
humanize(venue.id))
# then
assert response.status_code == 200
assert response.json[0].get("id") == humanize(
allocine_venue_provider.id)
assert response.json[0].get("venueId") == humanize(venue.id)
def activate_provider(provider_classname: str) -> Provider:
provider = get_provider_by_local_class(provider_classname)
provider.isActive = True
provider.enabledForPro = True
repository.save(provider)
return provider
def synchronize_allocine_stocks(app) -> None:
allocine_stocks_provider_id = get_provider_by_local_class("AllocineStocks").id
synchronize_venue_providers_for_provider(allocine_stocks_provider_id)
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 = (
"9782895026310"
"~2895026319"
"~nouvelles du Chili"
"~"
"~0203"
"~1"
"~"
"~"
"~"
"~18,99"
"~LES EDITIONS DE L'INSTANT MEME"
"~EPAGINE"
"~11/05/2011"
"~BL"
"~2"
"~0"
"~0,0"
"~0,0"
"~0,0"
"~0"
"~0"
"~0"
"~0"
"~Collectif"
"~15/01/2013"
"~02/03/2018"
"~5,50"
"~Littérature Hispano-Portugaise"
"~"
"~"
"~"
"~"
"~"
"~1"
"~3012420280013"
"~"
"~"
"~"
"~"
"~"
"~0"
"~"
"~369"
"~860"
"~3694440"
"~"
)
get_lines_from_thing_file.return_value = iter([data_line])
titelive_things_provider = get_provider_by_local_class("TiteLiveThings")
product = create_product_with_thing_type(
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_return_provider_when_no_local_class_matches(self, app):
# When
provider = get_provider_by_local_class("NonExistingProvider")
# Then
assert provider is None
def synchronize_libraires_stocks(app) -> None:
libraires_stocks_provider_id = get_provider_by_local_class("LibrairesStocks").id
synchronize_venue_providers_for_provider(libraires_stocks_provider_id)
def synchronize_titelive_stocks(app):
titelive_stocks_provider_id = get_provider_by_local_class(
"TiteLiveStocks").id
update_venues_for_specific_provider(titelive_stocks_provider_id)
def synchronize_praxiel_stocks(app) -> None:
praxiel_stocks_provider_id = get_provider_by_local_class("PraxielStocks").id
synchronize_venue_providers_for_provider(praxiel_stocks_provider_id)
def synchronize_fnac_stocks(app) -> None:
fnac_stocks_provider_id = get_provider_by_local_class("FnacStocks").id
synchronize_venue_providers_for_provider(fnac_stocks_provider_id)
