def test_should_not_return_offer_ids_when_venue_id_do_not_matches_but_last_provider_id_matches(
self, app):
# Given
provider1 = create_provider(idx=1,
local_class="OpenAgenda",
is_active=False,
is_enable_for_pro=False)
provider2 = create_provider(idx=2,
local_class="TiteLive",
is_active=False,
is_enable_for_pro=False)
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer1 = create_offer_with_thing_product(last_provider_id=provider1.id,
venue=venue)
offer2 = create_offer_with_thing_product(last_provider_id=provider2.id,
venue=venue)
repository.save(provider1, provider2, offer1, offer2)
# When
offer_ids = get_paginated_offer_ids_by_venue_id_and_last_provider_id(
last_provider_id=provider1.id, limit=2, page=0, venue_id=10)
# Then
assert len(offer_ids) == 0
def test_nOffers_with_two_venue_providers_from_different_providers(app):
# given
provider1 = create_provider(local_class="OpenAgenda")
provider2 = create_provider(local_class="TiteLive")
repository.save(provider1, provider2)
offerer = create_offerer()
venue = create_venue(offerer)
venue_provider1 = create_venue_provider(venue, provider1)
venue_provider2 = create_venue_provider(venue, provider2)
offer_1 = create_offer_with_thing_product(
venue, last_provider_id=provider1.id, id_at_providers="offer1", last_provider=provider1
)
offer_2 = create_offer_with_event_product(
venue, last_provider_id=provider2.id, id_at_providers="offer2", last_provider=provider2
)
offer_3 = create_offer_with_event_product(
venue, last_provider_id=provider1.id, id_at_providers="offer3", last_provider=provider1
)
offer_4 = create_offer_with_thing_product(
venue, last_provider_id=provider1.id, id_at_providers="offer4", last_provider=provider1
)
repository.save(offer_1, offer_2, offer_3, offer_4, venue_provider1, venue_provider2)
# when
n_offers_for_venue_provider1 = venue_provider1.nOffers
n_offers_for_venue_provider2 = venue_provider2.nOffers
# then
assert n_offers_for_venue_provider1 == 3
assert n_offers_for_venue_provider2 == 1
def test_get_enabled_providers_for_pro(self, app):
# Given
provider1 = create_provider(local_class="OpenAgenda",
is_active=False,
is_enable_for_pro=False)
provider2 = create_provider(local_class="TiteLive",
is_active=True,
is_enable_for_pro=True)
repository.save(provider1, provider2)
# When
enabled_providers = get_enabled_providers_for_pro()
# Then
assert enabled_providers == [provider2]
def test_should_get_actives_and_enabled_providers_for_pro(self, app):
# Given
provider1 = create_provider(local_class="OpenAgenda",
is_active=False,
is_enable_for_pro=False)
provider2 = create_provider(local_class="TiteLive",
is_active=True,
is_enable_for_pro=True)
repository.save(provider1, provider2)
# When
providers = get_providers_enabled_for_pro_excluding_specific_provider(
"AllocineStocks")
# Then
assert providers == [provider2]
def should_raise_an_error(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
provider = create_provider(local_class="TestLocalProvider")
repository.save(venue, provider)
self.find_by_id.return_value = venue
stock_repository = MagicMock()
provider_type = TestLocalProvider
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"] == [
"Provider non pris en charge"
]
def test_nOffers_with_one_venue_provider(app):
# given
provider = create_provider()
repository.save(provider)
offerer = create_offerer()
venue = create_venue(offerer)
venue_provider = create_venue_provider(venue, provider)
offer_1 = create_offer_with_thing_product(venue,
last_provider_id=provider.id,
id_at_providers="offer1",
last_provider=provider)
offer_2 = create_offer_with_event_product(venue,
last_provider_id=provider.id,
id_at_providers="offer2",
last_provider=provider)
offer_3 = create_offer_with_event_product(venue,
last_provider_id=provider.id,
id_at_providers="offer3",
last_provider=provider)
offer_4 = create_offer_with_thing_product(venue,
last_provider_id=provider.id,
id_at_providers="offer4",
last_provider=provider)
repository.save(offer_1, offer_2, offer_3, offer_4, venue_provider)
# when
n_offers = venue_provider.nOffers
# then
assert n_offers == 4
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_should_return_all_providers_actives_and_enabled_for_pro_except_excluded_provider(
self, app):
# Given
provider1 = create_provider(local_class="OpenAgenda",
is_active=True,
is_enable_for_pro=True)
provider2 = create_provider(local_class="TiteLive",
is_active=True,
is_enable_for_pro=True)
repository.save(provider1, provider2)
# When
providers = get_providers_enabled_for_pro_excluding_specific_provider(
"OpenAgenda")
# Then
assert providers == [provider2]
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 test_should_return_no_provider_when_provider_is_not_active(self, app):
# Given
provider = create_provider(local_class="OpenAgenda",
is_active=False,
is_enable_for_pro=True)
repository.save(provider)
# When
provider = get_provider_enabled_for_pro_by_id(provider.id)
# Then
assert provider is None
def test_should_call_do_update_for_specified_provider(
self, mock_get_provider_class, mock_do_update, app):
# Given
provider_test = create_provider(local_class="TestLocalProvider")
repository.save(provider_test)
mock_get_provider_class.return_value = TestLocalProvider
# When
synchronize_data_for_provider(provider_test.__class__.__name__, None)
# Then
mock_get_provider_class.assert_called_once()
mock_do_update.assert_called_once_with(fake(TestLocalProvider), None)
def test_should_return_provider_when_provider_is_enabled_for_pro_and_active(
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_enabled_for_pro_by_id(existing_provider.id)
# Then
assert provider == existing_provider
def test_should_call_synchronize_venue_provider(
self, mock_synchronize_venue_provider, app):
# Given
provider_test = create_provider(local_class="TestLocalProvider")
offerer = create_offerer()
venue = create_venue(offerer)
venue_provider = create_venue_provider(venue, provider_test)
repository.save(venue_provider)
# When
synchronize_venue_providers_for_provider(provider_test.id, 10)
# Then
mock_synchronize_venue_provider.assert_called_once()
def should_raise_an_error(self, app):
# Given
offerer = create_offerer()
venue = create_venue(offerer)
provider = create_provider(local_class="TestLocalProvider")
repository.save(venue, provider)
self.find_by_id.return_value = venue
# When
with pytest.raises(ProviderWithoutApiImplementation):
connect_venue_to_provider(venue, provider)
# Then
assert not VenueProvider.query.first()
def test_should_synchronize_venue_provider_with_defined_limit(
self, mock_get_provider_class, mock_do_update, app):
# Given
provider_test = create_provider(local_class="TestLocalProvider")
offerer = create_offerer()
venue = create_venue(offerer)
venue_provider = create_venue_provider(venue, provider_test)
repository.save(venue_provider)
mock_get_provider_class.return_value = TestLocalProvider
# When
synchronize_venue_providers_for_provider(provider_test.id, 10)
# Then
mock_get_provider_class.assert_called_once()
mock_do_update.assert_called_once_with(fake(TestLocalProvider), 10)
def test_should_start_synchronization_with_linked_provider(
self, mock_do_update, mock_get_provider_class, app):
# Given
limit = 10
offerer = create_offerer()
venue = create_venue(offerer)
provider = create_provider(local_class="TestLocalProvider")
venue_provider = create_venue_provider(venue, provider)
repository.save(venue_provider)
mock_get_provider_class.return_value = TestLocalProvider
# When
synchronize_venue_provider(venue_provider, limit)
# Then
mock_do_update.assert_called_once_with(fake(TestLocalProvider), limit)
def test_should_log_exception_when_one_is_raised_during_provider_initilization(
self, mock_build_cron_log_message, mock_get_provider_class, app):
# Given
provider_test = create_provider(local_class="TestLocalProvider")
offerer = create_offerer()
venue = create_venue(offerer)
venue_provider = create_venue_provider(venue, provider_test)
repository.save(venue_provider)
mock_get_provider_class.return_value = mock_init_provider
# When
synchronize_venue_provider(venue_provider, 10)
# Then
mock_build_cron_log_message.assert_called_once_with(
name="mock_init_provider", status=ANY)
def test_should_init_provider_with_expected_venue_provider(
self, mock_do_update, mock_get_provider_class, app):
# Given
limit = 10
offerer = create_offerer()
venue = create_venue(offerer)
provider = create_provider(local_class="TestLocalProvider")
venue_provider = create_venue_provider(venue, provider)
repository.save(venue_provider)
mock_provider_class = MagicMock()
mock_get_provider_class.return_value = mock_provider_class
# When
synchronize_venue_provider(venue_provider, limit)
# Then
mock_provider_class.assert_called_once_with(venue_provider)
def should_not_update_allocine_price_rule_when_there_is_no_allocine_price_rule_associated_to_the_venue(
self, app):
# Given
new_price = Decimal(8)
offerer = create_offerer()
venue = create_venue(offerer)
allocine_provider = create_provider(local_class="TestLocalProvider")
allocine_venue_provider = create_allocine_venue_provider(
venue, allocine_provider)
repository.save(allocine_venue_provider)
# When
modify_allocine_price_rule_for_venue_by_siret(venue.siret, new_price)
# Then
assert AllocineVenueProviderPriceRule.query.count() == 0
def test_should_add_venue_provider(self, app):
# Given
client = MagicMock()
client.rpush = MagicMock()
provider = create_provider(idx=1, local_class="OpenAgenda", is_active=False, is_enable_for_pro=False)
user = create_user()
offerer = create_offerer()
user_offerer = create_user_offerer(user=user, offerer=offerer)
venue = create_venue(idx=1, offerer=offerer)
venue_provider = create_venue_provider(idx=1, provider=provider, venue=venue)
repository.save(user_offerer, venue_provider)
# When
_add_venue_provider(client=client, venue_provider=venue_provider)
# Then
client.rpush.assert_called_once_with("venue_providers", '{"id": 1, "providerId": 1, "venueId": 1}')
def test_should_remove_worker_id_value(self, app):
# Given
provider_test = create_provider(local_class="TestLocalProvider")
offerer = create_offerer()
venue = create_venue(offerer)
venue_provider = create_venue_provider(venue,
provider_test,
sync_worker_id="1234567")
repository.save(venue_provider)
provider = TestLocalProvider(venue_provider)
# When
_remove_worker_id_after_venue_provider_sync_error(provider)
# Then
updated_venue_provider = VenueProvider.query.one()
assert updated_venue_provider.syncWorkerId is None
def test_send_venue_provider_should_call_add_venue_provider_with_redis_client_and_venue_provider(
self, mock_redis, mock_add_venue_provider, app
):
# Given
mock_redis.from_url = MagicMock()
mock_redis.from_url.return_value = MagicMock()
provider = create_provider(idx=1, local_class="OpenAgenda", is_active=False, is_enable_for_pro=False)
offerer = create_offerer()
venue = create_venue(idx=1, offerer=offerer)
venue_provider = create_venue_provider(idx=1, provider=provider, venue=venue)
repository.save(venue_provider)
# When
send_venue_provider_data_to_redis(venue_provider=venue_provider)
# Then
mock_add_venue_provider.assert_called_once_with(
client=mock_redis.from_url.return_value, venue_provider=venue_provider
)
def should_update_allocine_price_rule_for_venue_with_given_id(self, app):
# Given
initial_price = Decimal(7.5)
new_price = Decimal(8)
offerer = create_offerer()
venue = create_venue(offerer)
allocine_provider = create_provider(local_class="TestLocalProvider")
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=initial_price)
repository.save(allocine_venue_provider_price_rule)
# When
modify_allocine_price_rule_for_venue_by_id(venue.id, new_price)
# Then
assert allocine_venue_provider_price_rule.price == new_price
def test_returns_true_when_all_information_are_present_and_well_formed(
self, app):
# given
provider = create_provider()
offerer = create_offerer()
user = create_user()
user_offerer = create_user_offerer(user, offerer, is_admin=True)
venue = create_venue(offerer,
name="Librairie Titelive",
siret="77567146400110")
repository.save(provider, user_offerer, venue)
payload = {
"providerId": humanize(provider.id),
"venueId": humanize(venue.id),
}
# when
try:
check_new_venue_provider_information(payload)
except ApiErrors:
# then
assert False
def test_should_return_one_offer_id_when_exist_and_venue_id_and_last_provider_id_match_from_second_page_only(
self, app):
# Given
provider1 = create_provider(idx=1,
local_class="OpenAgenda",
is_active=False,
is_enable_for_pro=False)
offerer = create_offerer()
venue = create_venue(offerer=offerer)
offer1 = create_offer_with_thing_product(last_provider_id=provider1.id,
venue=venue,
last_provider=provider1)
offer2 = create_offer_with_thing_product(last_provider_id=provider1.id,
venue=venue,
last_provider=provider1)
repository.save(provider1, offer1, offer2)
# When
offer_ids = get_paginated_offer_ids_by_venue_id_and_last_provider_id(
last_provider_id=provider1.id, limit=1, page=1, venue_id=venue.id)
# Then
assert len(offer_ids) == 1
assert offer_ids[0] == (offer2.id, )
