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, )