def test_device_type_mobile():
data = api.public_get(VOD_ID, context['partner'],
device_type='mobile').json()
assert_equal(deep_get(data, 'preroll'),
deep_get(VOD_SETTINGS, 'preroll.mobile'), 'preroll_url')
assert_equal(deep_get(data, 'intervalroll.url'),
deep_get(VOD_SETTINGS, 'intervalroll.url.mobile'),
'intervalroll_url')
def test_update_invalid_schema():
api.internal_delete(partner_id, playable_id).status_code
assert_equal(
api.internal_create(partner_id, playable_id, playable_type,
viewable_id, ad_settings).status_code, 200)
assert_equal(
api.internal_update(
partner_id, playable_id,
'{"foo": "this-is-not-a-valid-schema"}').status_code, 400,
'status for invalid schema')
def test_defaults():
partner_id = context['partner']['id']
defaults = {'preroll': {'mobile': 'http://defaults.preroll.mobile'}}
api.internal_defaults_delete(partner_id)
api.internal_defaults_create(partner_id, defaults)
data = api.public_get(NON_EXISTANT_ID, context['partner']).json()
assert_equal(data, api.ad_settings_for_device(defaults),
'should be default ad settings with default device URLs')
api.internal_defaults_delete(partner_id)
def test_setup():
email, password, _, _ = config.credentials()
context['partner'] = partner_api.get(PARTNER_ID).json()
context['clientApiToken'] = context['partner']['clientApiToken']
api.internal_delete(PARTNER_ID, VOD_ID)
assert_equal(
api.internal_create(PARTNER_ID, VOD_ID, 'vod', 'api-test-viewable-id',
VOD_SETTINGS).status_code, 200,
'create test VOD status')
user = user_api.login(context['clientApiToken'], email, password).json()
context['user_id'] = user['userId']
context['user_token'] = user['token']
print('user_id=%s, user_token=%s' %
(context['user_id'], context['user_token']))
context['user_info'] = {'gender': 'm', 'yearOfBirth': 1974}
user_api.set_dynamic(context['user_id'], context['clientApiToken'],
context['user_token'], context['user_info'])
def test_crud_defaults():
api.internal_defaults_delete(partner_id)
api.internal_defaults_create(partner_id, ad_settings)
defaults = api.internal_defaults_list().json()
partner_ids = map(lambda o: o['partnerId'], defaults)
assert_equal(partner_id in partner_ids, True, 'partner_id_in_list')
defaults = api.internal_defaults_get(partner_id).json()
assert_equal(defaults['partnerId'], partner_id)
assert_equal(defaults['adSettings'], ad_settings)
api.internal_defaults_update(partner_id, updated_ad_settings)
defaults = api.internal_defaults_get(partner_id).json()
assert_equal(defaults['adSettings'], updated_ad_settings)
api.internal_defaults_delete(partner_id)
response = api.internal_defaults_get(partner_id)
assert_equal(response.status_code, 404, 'get should be 404 after delete')
def test_vast_wrapper():
device = 'unknown'
vast_url = 'https://search.spotxchange.com/vast/2.00/218908?VPI=MP4&app[name]=REPLACE_ME&app[bundle]=REPLACE_ME&app[storeurl]=REPLACE_ME&device[ifa]=REPLACE_ME&ip_addr=REPLACE_ME&cb=REPLACE_ME&player_width=REPLACE_ME&player_height=REPLACE_ME'
response = api.public_get_vast_wrapper(context['partner'],
context['user_id'], device,
vast_url)
assert_equal(response.status_code, 200, 'vast wrapper status_code')
assert_equal(response.headers['content-type'],
'application/xml;charset=utf-8', 'vast wrapper content-type')
assert_equal(vast_url in response.text, True,
f'vast_url={vast_url} should be in response')
trackingUrl = config.api_global_url(
) + f'/ads/v1/vast-tracking/{context["partner"]["id"]}/{context["user_id"]}/{device}'
assert_equal(trackingUrl in response.text, True,
f'trackingUrl={trackingUrl} should be in response',
response.text)
def test_add_and_cancel():
cancel_data = {
'productIds': [PRODUCT_ID],
'hardCancel': True,
'message': 'api-test ([email protected]): test cancel',
'source': 'internal',
'billingPeriods': [],
'sendEmail': False
}
api.cancel(context['user_id'], context['partner']['id'], cancel_data)
data = api.get_history(context['user_id'], context['partner']['id']).json()
product_ids = current_product_ids(data)
print('user product IDS', current_product_ids(data))
assert_equal(PRODUCT_ID in product_ids, False, 'user does not have product yet')
add_data = {
'productIds': (product_ids + [PRODUCT_ID]),
'message': 'api-test ([email protected])',
'source': 'internal',
'sendEmail': False
}
api.add(context['user_id'], context['partner']['id'], add_data)
data = api.get_history(context['user_id'], context['partner']['id']).json()
print('user product IDS', current_product_ids(data))
assert_equal(PRODUCT_ID in current_product_ids(data), True, 'user has product after add')
cancel_data = {
'productIds': [PRODUCT_ID],
'hardCancel': True,
'message': 'api-test ([email protected]): test cancel',
'source': 'internal',
'billingPeriods': [],
'sendEmail': False
}
api.cancel(context['user_id'], context['partner']['id'], cancel_data)
data = api.get_history(context['user_id'], context['partner']['id']).json()
print('user product IDS', current_product_ids(data))
assert_equal(PRODUCT_ID in product_ids, False, 'user does not have product after cancel')
assert_equal(current_product_ids(data), product_ids, 'user has same products after cancel as when we started')
def test_user_with_missing_age_gender():
empty_user_info = {}
user_api.set_dynamic(context['user_id'], context['clientApiToken'],
context['user_token'], empty_user_info)
data = api.public_get(VOD_ID,
context['partner'],
user_token=context['user_token']).json()
api_url = urlparse(deep_get(data, 'preroll'))
url = urlparse(parse_qs(api_url.query)['vastUrl'][0])
assert_equal(api_url.hostname,
urlparse(config.api_global_url()).hostname,
'api url hostname')
query = parse_qs(url.query)
expected_url = urlparse(deep_get(VOD_SETTINGS, 'preroll.mobile'))
assert_equal(url.scheme, expected_url.scheme, 'url scheme')
assert_equal(url.hostname, expected_url.hostname, 'url hostname')
expected_query = {'user[yob]': None, 'user[gender]': None}
for param in expected_query:
assert_equal(deep_get(query, [param, 0]), expected_query[param],
'expected param %s' % param)
def test_frequency_cap():
frequencyCap = 3
device = 'unknown'
updated_vod_settings = deep_set(VOD_SETTINGS, 'frequencyCap', frequencyCap)
api.internal_update(context['partner']['id'], VOD_ID, updated_vod_settings)
assert_equal(
deep_get(
api.internal_get(context['partner']['id'], VOD_ID).json(),
'adSettings.frequencyCap'), frequencyCap,
'internal_get after update of frequencyCap')
response = api.public_get(VOD_ID,
context['partner'],
user_token=context['user_token'])
assert_equal(response.status_code, 200, 'status_code API user first time')
api.public_get_tracking(context['partner'], context['user_id'], device)
response = api.public_get(VOD_ID,
context['partner'],
user_token=context['user_token'])
assert_equal(response.status_code, 404, 'status_code API user second time')
def test_free_users_only():
response = api.public_get(VOD_ID,
context['partner'],
user_token=context['user_token'])
assert_equal(response.status_code, 200,
'status_code before setting freeUsersOnly=true')
updated_vod_settings = deep_set(VOD_SETTINGS, 'freeUsersOnly', True)
api.internal_update(context['partner']['id'], VOD_ID, updated_vod_settings)
assert_equal(
deep_get(
api.internal_get(context['partner']['id'], VOD_ID).json(),
'adSettings.freeUsersOnly'), True,
'internal_get after update of freeUsersOnly')
response = api.public_get(VOD_ID,
context['partner'],
user_token=context['user_token'])
assert_equal(response.status_code, 404,
'status_code after setting freeUsersOnly=true')
def test_create_invalid_schema():
api.internal_delete(partner_id, playable_id)
response = api.internal_create(partner_id, playable_id, playable_type,
viewable_id,
'{"foo": "this-is-not-a-valid-schema"}')
assert_equal(response.status_code, 400, 'status for invalid schema')
def test_create_double():
api.internal_delete(partner_id, playable_id)
api.internal_create(partner_id, playable_id, playable_type, viewable_id,
ad_settings)
response = api.internal_create(partner_id, playable_id, playable_type,
viewable_id, {})
assert_equal(response.status_code, 400, 'status on double create')
override = api.internal_get(partner_id, playable_id).json()
assert_equal(override['playableId'], playable_id, 'playable_id_in_get')
assert_equal(override['partnerId'], partner_id)
assert_equal(override['playableType'], playable_type)
assert_equal(override['viewableId'], viewable_id)
assert_equal(override['adSettings'], ad_settings)
api.internal_delete(partner_id, playable_id)
def test_create_full():
api.internal_delete(partner_id, playable_id)
response = api.internal_create(partner_id, playable_id, playable_type,
viewable_id, ad_settings_full)
assert_equal(response.status_code, 200, "create full status")
override = api.internal_get(partner_id, playable_id).json()
assert_equal(override['playableId'], playable_id, 'playable_id_in_get')
assert_equal(override['partnerId'], partner_id)
assert_equal(override['playableType'], playable_type)
assert_equal(override['viewableId'], viewable_id)
assert_equal(override['adSettings'], ad_settings_full)
def test_404():
partner_id = 'this-partner-does-not-exist-surely'
response = api.get(partner_id)
assert_equal(
response.status_code, 404,
('get should be 404 for non-existant partner ID %s' % partner_id))
def test_override():
data = api.public_get(VOD_ID, context['partner']).json()
assert_equal(deep_get(data, 'preroll'),
deep_get(VOD_SETTINGS, 'preroll.mobile'), 'preroll_url')
def test_device_type_other():
data = api.public_get(VOD_ID, context['partner'],
device_type='foobar').json()
assert_equal(deep_get(data, 'preroll'),
deep_get(VOD_SETTINGS, 'preroll.mobile'), 'preroll_url')
def test_crud():
viewable_ids = list(api.search(partner_id).json())
assert len(viewable_ids) > 1
pack = {'name': 'API Test Pack' + digest(), 'viewables': [viewable_ids[0]]}
result = api.create_pack(partner_id, pack)
assert_equal(result.status_code, 201)
pack_id = result.json()['id']
assert pack_id
created_at = parse_datetime(result.json()['createdAt'])
assert created_at <= now()
result = api.get_pack(partner_id, pack_id)
assert_equal(result.status_code, 200)
assert_equal(result.json()['id'], pack_id)
assert_equal(result.json()['name'], pack['name'])
assert_equal(result.json()['viewables'], pack['viewables'])
result = api.list_packs(partner_id)
assert_equal(result.status_code, 200)
pack_ids = set([p['id'] for p in result.json()])
assert pack_id in pack_ids
update = {'action': 'add', 'viewables': [viewable_ids[1]]}
result = api.update_pack(partner_id, pack_id, update)
assert_equal(result.status_code, 200)
update = {'action': 'remove', 'viewables': [viewable_ids[0]]}
result = api.update_pack(partner_id, pack_id, update)
assert_equal(result.status_code, 200)
pack['viewables'] = [viewable_ids[1]]
result = api.get_pack(partner_id, pack_id)
assert_equal(result.status_code, 200)
assert_equal(result.json()['id'], pack_id)
assert_equal(result.json()['name'], pack['name'])
assert_equal(result.json()['viewables'], pack['viewables'])
timing = {
'purchaseAvailableSince': '2012-12-20T00:00:00.00Z',
'purchaseAvailableUntil': '2012-12-24T00:00:00.00Z'
}
pricing = {'upfrontPriceCents': 4900, 'currency': 'SEK'}
offer = {
'packId': pack_id,
'type': 'est',
'timing': timing,
'pricing': pricing,
'regions': ['SE']
}
result = api.create_offer(partner_id, offer)
assert_equal(result.status_code, 201)
print('create offer', result.json())
offer['offerId'] = result.json()['offerId']
result = api.get_offer(partner_id, offer['offerId'])
assert_equal(result.status_code, 200)
assert_equal(result.json()['offerId'], offer['offerId'])
assert_equal(result.json()['type'], offer['type'])
assert_equal(result.json()['disabled'], False)
result = api.list_offers(partner_id, pack_id)
offer_ids = set([o['offerId'] for o in result.json()])
assert offer['offerId'] in offer_ids
result = api.update_offer(partner_id, offer['offerId'], {'disabled': True})
assert_equal(result.status_code, 200)
result = api.get_offer(partner_id, offer['offerId'])
assert_equal(result.json()['disabled'], True)
def test_no_default_404():
partner_id = context['partner']['id']
api.internal_defaults_delete(partner_id)
response = api.public_get(NON_EXISTANT_ID, context['partner'])
assert_equal(response.status_code, 404, 'status_code')
def test_get():
partner_id = 'my-app'
partner = api.get(partner_id).json()
assert_equal(partner['id'], partner_id, 'partner_id')
def check_status_code(response, valid_codes={200, 204, 404}):
message = 'status_code in %s, actual %s' % (valid_codes, response.status_code)
if response.status_code not in valid_codes:
print('Invalid response', response.status_code, response.reason)
print_response_body(response)
assert_equal(response.status_code in valid_codes, True, message)
def test_create_empty_allowed():
api.internal_delete(partner_id, playable_id)
assert_equal(
api.internal_create(partner_id, playable_id, playable_type,
viewable_id, None).status_code, 200,
'create empty status code')
def test_query():
result = api.query(partner_id, 'kind:channel')
assert_equal(result.status_code, 200)
assert len(result.json()['items']) > 0
assert result.json()['items'][0]['assetId']
assert result.json()['items'][0]['title_en']
def test_create_invalid_json():
api.internal_delete(partner_id, playable_id)
response = api.internal_create(partner_id, playable_id, playable_type,
viewable_id, "{this-is-not-valid-json")
assert_equal(response.status_code, 400, 'status for invalid json')
def test_client_api_get_subscription():
data = client_api.get_subscription(context['user_id'], context['partner']['clientApiToken'], context['user_token']).json()
assert_equal(data['status'] in STATUSES, True, 'user should have a subscription status')
def test_create_invalid_playable_type():
api.internal_delete(partner_id, playable_id)
response = api.internal_create(partner_id, playable_id, 'foobar',
viewable_id, ad_settings)
assert_equal(response.status_code, 400, 'status for invalid playable type')
def test_get_subscription():
data = api.get_subscription(context['user_id'], context['partner']['id']).json()
assert_equal(data['status'] in STATUSES, True, 'user should have a subscription status')
def test_crud_overrides():
api.internal_delete(partner_id, playable_id)
api.internal_create(partner_id, playable_id, playable_type, viewable_id,
ad_settings)
overrides = api.internal_list(partner_id).json()
override_ids = map(lambda o: o['playableId'], overrides)
assert_equal(playable_id in override_ids, True, 'playable_id_in_list')
override = api.internal_get(partner_id, playable_id).json()
assert_equal(override['playableId'], playable_id, 'playable_id_in_get')
assert_equal(override['partnerId'], partner_id)
assert_equal(override['playableType'], playable_type)
assert_equal(override['viewableId'], viewable_id)
assert_equal(override['adSettings'], ad_settings)
api.internal_update(partner_id, playable_id, updated_ad_settings)
override = api.internal_get(partner_id, playable_id).json()
assert_equal(override['adSettings'], updated_ad_settings)
api.internal_delete(partner_id, playable_id)
response = api.internal_get(partner_id, playable_id)
assert_equal(response.status_code, 404, 'get should be 404 after delete')
def test_get_history():
data = api.get_history(context['user_id'], context['partner']['id']).json()
print('user product IDS', current_product_ids(data))
assert_equal(len(current_product_ids(data)) > 0, True, 'user should have current product IDs')
def test_create_defaults_invalid_url():
api.internal_defaults_delete(partner_id)
assert_equal(
api.internal_defaults_create(partner_id,
ad_settings_invalid_url).status_code, 400,
'invalid url create defaults')
def test_user_age_gender():
data = api.public_get(VOD_ID,
context['partner'],
user_token=context['user_token']).json()
# http://client-api.tvoli.com/api/ads/v1/vast-tracking/my-app/DQQ1O0YK89N9J99K302FRZUIGUSR/unknown?vastUrl=http%3A%2F%2Fpreroll.mobile%3Fuser%5Bgender%5D%3Dm%26user%5Byob%5D%3D1974', 'intervalroll': {'url': 'http://client-api.tvoli.com/api/ads/v1/vast-tracking/my-app/DQQ1O0YK89N9J99K302FRZUIGUSR/unknown?vastUrl=http%3A%2F%2Fintervalroll.mobile%3Fuser%5Bgender%5D%3Dm%26user%5Byob%5D%3D1974
api_url = urlparse(deep_get(data, 'preroll'))
assert_equal(api_url.hostname,
urlparse(config.api_global_url()).hostname,
'api url hostname')
assert_equal(
api_url.path,
f'/api/ads/v1/vast-wrapper/{context["partner"]["id"]}/{context["user_id"]}/unknown',
'api url path')
url_string = parse_qs(api_url.query)['vastUrl'][0]
url = urlparse(url_string)
preroll_url = VOD_SETTINGS['preroll']['mobile']
yob = str(context['user_info']['yearOfBirth'])
gender = str(context['user_info']['gender'])
url_string_expect = f'{preroll_url}&user[gender]={gender}&user[yob]={yob}'
assert_equal(url_string, url_string_expect,
'vastUrl query param should be correct')
query = parse_qs(url.query)
expected_url = urlparse(deep_get(VOD_SETTINGS, 'preroll.mobile'))
assert_equal(url.scheme, expected_url.scheme, 'url scheme')
assert_equal(url.hostname, expected_url.hostname, 'url hostname')
expected_query = {'user[yob]': yob, 'user[gender]': gender}
for param in expected_query:
assert_equal(deep_get(query, [param, 0]), expected_query[param],
'expected param %s' % param)
