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)