def test_default_commission(app_audited, redisdb_targeting):
"""
Test default value of commission value.
"""
trigger_cache_mappings()
check_commission(redisdb_targeting, constants.COMMISSION)
def test_strategy_audience_remove(redisdb_targeting, included):
strategy = Strategy.objects.first()
audiences = Audience.objects.all()
if included:
strategy.audiences = audiences
else:
strategy.audiences_exclude = audiences
strategy.save()
trigger_cache_mappings()
if included:
strategy.audiences.remove(audiences[0])
else:
strategy.audiences_exclude.remove(audiences[0])
strategy.save()
trigger_cache_mappings()
for advert in Advert.objects.all():
cache_ad = cPickle.loads(
redisdb_targeting.hget(redis_keys.ads, advert.public_id))
aud_include = frozenset(advert.strategy.get_audience_ids())
aud_exclude = frozenset(advert.strategy.get_audience_ids(exclude=True))
assert cache_ad.audiences_include == aud_include
assert cache_ad.audiences_exclude == aud_exclude
if included:
assert audiences[0] not in aud_include
else:
assert audiences[0] not in aud_exclude
def test_advert_mapping_landing_sites(redisdb_targeting):
trigger_cache_mappings()
for advert in Advert.objects.all():
target_ad = cPickle.loads(
redisdb_targeting.hget(redis_keys.ads, advert.public_id))
assert target_ad.landing_sites == [("http://google.pl", 1)]
def test_accountdetail_advert(app_audited, redisdb_profiles, redisdb_targeting,
redisdb_optimizer):
"""
Check if cached_ad has correct information stored on.
"""
trigger_cache_mappings()
for advert in Advert.objects.all():
cached_ad = cPickle.loads(
redisdb_targeting.hget(redis_keys.ads, advert.public_id))
assert cached_ad.account_budget == cast_currency_to_CPM(
advert.creative.owner.total_paid())
assert cached_ad.account_fees == cast_currency_to_CPM(
advert.creative.owner.audit_fees)
assert cached_ad.account_id == advert.creative.owner.public_id
account = Account.objects.first()
account.audit_fees = 1
account.save()
trigger_cache_mappings()
for advert in Advert.objects.all():
cached_ad = cPickle.loads(
redisdb_targeting.hget(redis_keys.ads, advert.public_id))
assert cached_ad.account_budget == cast_currency_to_CPM(
advert.creative.owner.total_paid())
assert cached_ad.account_fees == cast_currency_to_CPM(1)
assert cached_ad.account_id == advert.creative.owner.public_id
def test_different_commission(app_audited, redisdb_targeting, commission):
"""
Test different values for commission field.
"""
for account in Account.objects.all():
account.commission = commission
account.save()
trigger_cache_mappings()
check_commission(redisdb_targeting, commission)
def test_default_bid_cpm_strategy(app_audited, redisdb_targeting,
redisdb_profiles):
'''Checks if bid values are properly written to cache from strategy'''
budget_size = 99.
for strategy in Strategy.objects.all():
strategy.budget_bid_CPM = budget_size
strategy.save()
trigger_cache_mappings()
check_ads_bid_value(redisdb_targeting, budget_size)
def test_campaign_mapping_default_conv_values(campaigns, redisdb_adserver):
''' Test saving default conversion values to redis '''
for index, campaign in enumerate(Campaign.objects.all()):
conv = campaign.conversion_def
conv.value = index + 1
conv.save()
trigger_cache_mappings()
for index, campaign in enumerate(Campaign.objects.all()):
rv = redisdb_adserver.hget(constants.campaign_default_conv_value_key,
campaign.public_id)
assert cPickle.loads(rv) == float(index + 1)
def test_default_bid_cpm_advert(app_audited, redisdb_targeting,
redisdb_profiles):
'''Checks if bid values are properly written to cache from advert'''
budget_size = 989.
for advert in Advert.objects.all():
advert.custom_bid_CPM = budget_size
advert.save()
for strategy in Strategy.objects.all():
strategy.budget_bid_CPM = int(budget_size * 2)
strategy.save()
trigger_cache_mappings()
check_ads_bid_value(redisdb_targeting, budget_size)
def test_creative_audit_dirtify(creative_resource, audit_app, creative_type):
"""Test that Creative audit dirtifies the cache."""
if creative_type == 'video':
audit_app.setup_creative_videos()
creative_name = 'creative_%s_1' % creative_type
audit_app.setup_adverts(adverts=[
{
'name': 'ad_lemon',
'strategy': 'Hello this is Citrus',
'creative': creative_name,
'url': 'http://www.google.com/',
},
{
'name': 'ad_orange',
'strategy': 'Hello this is Citrus',
'creative': creative_name,
'url': 'http://www.wp.pl/',
},
{
'name': 'ad_carrot',
'strategy': 'han i has a pumpkin?',
'creative': creative_name,
'url': 'http://www.google.com/',
},
{
'name': 'ad_celery',
'strategy': 'han i has a pumpkin?',
'creative': creative_name,
'url': 'http://www.wp.pl/',
},
])
creative = audit_app.models['creative'][creative_name]
creative.appnexus_status = 'p'
creative.save()
trigger_cache_mappings()
assert len(creative.advert_set.all()) > 0
for ad in creative.advert_set.all():
assert not ad.cache_is_dirty
appnexus_update_status_all()
assert creative.cache_is_dirty
for ad in creative.advert_set.all():
assert ad.cache_is_dirty
def test_content_categories(app_audited, redisdb_targeting, redisdb_profiles):
"""
Checks redis targeting (content categories - include and exclude).
"""
content_categories = ContentCategory.objects.all()
for strategy in Strategy.objects.all():
strategy.content_category_values = content_categories
trigger_cache_mappings()
check_target_values(redisdb_targeting, content_categories)
for strategy in Strategy.objects.all():
strategy.content_category_values.clear()
strategy.content_category_values_exclude = content_categories
trigger_cache_mappings()
check_target_values(redisdb_targeting, content_categories, include=False)
def test_strategy_audience_is_ip(redisdb_targeting):
strategy = Strategy.objects.first()
audiences = Audience.objects.all()
strategy.audiences = audiences
strategy.save()
trigger_cache_mappings()
advert = strategy.advert_set.first()
cache_ad = cPickle.loads(
redisdb_targeting.hget(redis_keys.ads, advert.public_id))
assert cache_ad.has_ip_audiences is False
ip_audience = Audience.objects.first()
ip_audience.is_ip = True
ip_audience.save()
trigger_cache_mappings()
cache_ad = cPickle.loads(
redisdb_targeting.hget(redis_keys.ads, advert.public_id))
assert cache_ad.has_ip_audiences is True
def test_advert_capping(app_audited, redisdb_targeting, redisdb_profiles,
capping):
if capping:
for campaign in Campaign.objects.all():
for cap_obj, (cap_limit, cap_period) in capping.items():
if cap_obj == 'campaign':
campaign.cap_campaign_selected = True
campaign.cap_total = cap_limit
campaign.cap_total_period = cap_period
elif cap_obj == 'strategy':
campaign.cap_strategy_selected = True
campaign.cap_strategy = cap_limit
campaign.cap_strategy_period = cap_period
elif cap_obj == 'ad':
campaign.cap_creative_selected = True
campaign.cap_creative = cap_limit
campaign.cap_creative_period = cap_period
campaign.save()
trigger_cache_mappings()
check_ads_capping(redisdb_targeting, capping)
def handle(self, *args, **options):
trigger_cache_mappings(force=True)
def test_appnexus_profile_update(clean_strategy):
'''
1. Checking if celery task is setting the correct data through API.
2. Checking if celery task is fired (by cache mapper) after changing targeting in strategy
'''
# undeleting one strategy
strategy = Strategy.objects.all()[0]
strategy.is_paused = False
strategy.save()
expected_response = nothing_set_profile.copy()
expected_response['description'] = 'Automatic profile (on)'
expected_response[
'passthrough_percent'] = settings.appnexus_profile_passthrough
expected_response['supply_type_targets'] = list(
SUPPLY_TYPES[strategy.type])
# checking ads sizes
expected_response['size_targets'] = [{'height': 90, 'width': 728}]
check_update_response(expected_response)
# setting targeting on USA
usa_appnexus = TargetValue.objects.create(
exchange=EXCHANGES.appnexus,
category=dimensions.g_location,
value=TargetMap.pack(['USA', None, None]),
)
strategy.targeting_values.add(usa_appnexus)
# setting targeting on Germany in Nexage
germany_nexage = TargetValue.objects.create(
exchange=EXCHANGES.nexage,
category=dimensions.g_location,
value=TargetMap.pack(['Germany', None, None]),
)
# setting AppNexus representant for Nexage country
germany_appnexus = TargetValue.objects.create(
exchange=EXCHANGES.appnexus,
category=dimensions.g_location,
value=TargetMap.pack(['GER', None, None]),
representant=germany_nexage)
# setting targeting on Germany from Nexage
strategy.targeting_values.add(germany_nexage)
# checking countries targeting
expected_response['country_action'] = 'include'
expected_response['country_targets'] = [{
'country': 'GER'
}, {
'country': 'USA'
}]
check_update_response(expected_response)
# changing country to region
germany_nexage.value = TargetMap.pack(['Germany', 'LT', None])
germany_nexage.save()
germany_appnexus.value = TargetMap.pack(['GER', 'LT', None])
germany_appnexus.save()
# setting AppNexus representant for Nexage region in USA
# (chenging country to region)
usa_appnexus.value = TargetMap.pack(['USA', 'FL', None])
usa_appnexus.save()
expected_response['region_action'] = 'include'
expected_response['region_targets'] = [{
'region': 'USA:FL'
}, {
'region': 'GER:LT'
}]
check_update_response(expected_response)
# setting targeting on Proximic Safety Level segment
FAKE_APPNEXUS_ID = 330728
strategy.segment_proximic_safety_level.add(
SegmentProximicSafetyLevel.objects.create(appnexus_id=FAKE_APPNEXUS_ID,
name='Safe from Adult'))
# checking segments targeting
expected_response['segment_boolean_operator'] = 'or'
expected_response['segment_targets'] = [{
'id': FAKE_APPNEXUS_ID,
'action': 'include'
}]
check_update_response(expected_response)
# checking if celery task is triggered (inside cache mapper)
# after changes in strategy
with patch('ui.campaign.tasks.appnexus_update_profile.delay') as mock_task:
assert mock_task.call_count == 0
# strategy changes, we should update AppNexus profile
trigger_cache_mappings()
assert mock_task.call_count == 1
# no changes - no task
trigger_cache_mappings()
assert mock_task.call_count == 1
# Remove all adverts from strategies and check if profile is empty
for strategy in Strategy.objects.all():
for advert in strategy.advert_set.all():
advert.delete()
check_update_response(nothing_set_profile)