def test_create_user_missing_parameter(self): """ ACCOUNT (REST): send a POST with a missing parameter""" mw = [] headers = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers, expect_errors=True) assert_equal(r.status, 200) token = str(r.header('X-Rucio-Auth-Token')) headers = {'X-Rucio-Auth-Token': str(token)} data = dumps({}) ret = TestApp(account_app.wsgifunc(*mw)).post('/account', headers=headers, params=data, expect_errors=True) assert_equal(ret.header('ExceptionClass'), 'KeyError') assert_equal(ret.normal_body, "KeyError: \'type\' not defined") assert_equal(ret.status, 400)
def test_create_user_not_json_dict(self): """ ACCOUNT (REST): send a POST with a non dictionary json body""" mw = [] headers = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers, expect_errors=True) assert_equal(r.status, 200) token = str(r.header('X-Rucio-Auth-Token')) headers = {'X-Rucio-Auth-Token': str(token)} data = dumps(('account', 'account')) r = TestApp(account_app.wsgifunc(*mw)).post('/testaccount', headers=headers, params=data, expect_errors=True) assert_equal(r.header('ExceptionClass'), 'TypeError') assert_equal(r.normal_body, "TypeError: body must be a json dictionary") assert_equal(r.status, 400)
def test_list_scope_account_not_found(self): """ SCOPE (REST): send a GET list all scopes for a not existing account """ mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) headers3 = {'X-Rucio-Auth-Token': str(token)} r3 = TestApp(account_app.wsgifunc(*mw)).get('/testaccount/scopes', headers=headers3, expect_errors=True) assert_equal(r3.status, 404) assert_equal(r3.header('ExceptionClass'), 'AccountNotFound')
def test_create_user_non_json_body(self): """ ACCOUNT (REST): send a POST with a non json body""" mw = [] headers = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers, expect_errors=True) assert_equal(r.status, 200) token = str(r.header('X-Rucio-Auth-Token')) headers = {'X-Rucio-Auth-Token': str(token)} data = {'type': 'USER'} ret = TestApp(account_app.wsgifunc(*mw)).post('/testuser', headers=headers, params=data, expect_errors=True) assert_equal(ret.header('ExceptionClass'), 'ValueError') assert_equal(ret.normal_body, 'ValueError: cannot decode json parameter dictionary') assert_equal(ret.status, 400)
def test_add_attribute(self): """ ACCOUNT (REST): add/get/delete attribute.""" mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) acntusr = account_name_generator() headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({'type': 'USER'}) r2 = TestApp(account_app.wsgifunc(*mw)).post('/' + acntusr, headers=headers2, params=data, expect_errors=True) assert_equal(r2.status, 201) key = account_name_generator() value = "true" data = dumps({'key': key, 'value': value}) r3 = TestApp(account_app.wsgifunc(*mw)).post('/{0}/attr/{1}'.format(acntusr, key), headers=headers2, params=data, expect_errors=True) assert_equal(r3.status, 201) r4 = TestApp(account_app.wsgifunc(*mw)).get('/' + acntusr + '/attr/', headers=headers2, expect_errors=True) assert_equal(r4.status, 200) r5 = TestApp(account_app.wsgifunc(*mw)).delete('/{0}/attr/{1}'.format(acntusr, key), headers=headers2, params=data, expect_errors=True) assert_equal(r5.status, 200)
def test_userpass_success(self): """AUTHENTICATION (REST): Username and password (correct credentials).""" mw = [] headers = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r = TestApp(app.wsgifunc(*mw)).get('/userpass', headers=headers, expect_errors=True) assert_equal(r.status, 200) assert_greater(len(r.header('X-Rucio-Auth-Token')), 32)
def test_create_and_update_and_list_subscription(self): """ SUBSCRIPTION (REST): Test the creation of a new subscription, update it, list it """ mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) subscription_name = uuid() headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({'name': subscription_name, 'filter': {'project': ['data12_900GeV', 'data12_8TeV', 'data13_900GeV', 'data13_8TeV'], 'datatype': ['AOD', ], 'excluded_pattern': '(_tid|physics_(Muons|JetTauEtmiss|Egamma)\..*\.ESD|express_express(?!.*NTUP|.*\.ESD|.*RAW)|(physics|express)(?!.*NTUP).* \ \.x|physics_WarmStart|calibration(?!_PixelBeam.merge.(NTUP_IDVTXLUMI|AOD))|merge.HIST|NTUP_MUONCALIB|NTUP_TRIG)', 'account': 'tier0'}, 'replication_rules': [(2, 'T1_DATATAPE', True, True), (1, 'T1_DATADISK', False, True)], 'lifetime': 100000, 'retroactive': 0, 'dry_run': 0, 'comments': 'blahblah'}) r2 = TestApp(subs_app.wsgifunc(*mw)).post('/root/%s' % (subscription_name), headers=headers2, params=data, expect_errors=True) assert_equal(r2.status, 201) data = dumps({'filter': {'project': ['toto', ]}}) r3 = TestApp(subs_app.wsgifunc(*mw)).put('/root/%s' % (subscription_name), headers=headers2, params=data, expect_errors=True) assert_equal(r3.status, 201) r4 = TestApp(subs_app.wsgifunc(*mw)).get('/root/%s' % (subscription_name), headers=headers2, expect_errors=True) print r4 print type(loads(r4.body)) assert_equal(r4.status, 200) assert_equal(loads(loads(r4.body)['filter'])['project'][0], 'toto')
def test_list_scope(self): """ SCOPE (REST): send a GET list all scopes for one account """ mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) tmp_val = account_name_generator() headers2 = {'Rucio-Type': 'user', 'X-Rucio-Account': 'root', 'X-Rucio-Auth-Token': str(token)} data = dumps({'type': 'USER'}) r2 = TestApp(account_app.wsgifunc(*mw)).post('/%s' % tmp_val, headers=headers2, params=data, expect_errors=True) assert_equal(r2.status, 201) headers3 = {'X-Rucio-Auth-Token': str(token)} for scope in self.scopes: data = dumps({}) r3 = TestApp(account_app.wsgifunc(*mw)).post('/%s/scopes/%s' % (tmp_val, scope), headers=headers3, params=data, expect_errors=True) assert_equal(r3.status, 201) r4 = TestApp(account_app.wsgifunc(*mw)).get('/%s/scopes/' % tmp_val, headers=headers3, expect_errors=True) assert_equal(r4.status, 200) svr_list = loads(r4.body) for scope in self.scopes: assert_in(scope, svr_list)
def test_update_nonexisting_subscription(self): """ SUBSCRIPTION (REST): Test the update of a non-existing subscription """ mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) subscription_name = uuid() headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({'name': subscription_name, 'filter': {'project': ['toto', ]}}) r2 = TestApp(subs_app.wsgifunc(*mw)).put('/root/' + subscription_name, headers=headers2, params=data, expect_errors=True) assert_equal(r2.status, 404) assert_equal(r2.header('ExceptionClass'), 'SubscriptionNotFound')
def test_del_user_failure(self): """ ACCOUNT (REST): send a DELETE with a wrong user to test the error """ mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) headers2 = {'X-Rucio-Auth-Token': str(token)} r2 = TestApp(account_app.wsgifunc(*mw)).delete('/wronguser', headers=headers2, expect_errors=True) assert_equal(r2.status, 404)
def test_whoami_account(self): """ ACCOUNT (REST): Test the whoami method.""" mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) headers2 = {'X-Rucio-Auth-Token': str(token)} r2 = TestApp(account_app.wsgifunc(*mw)).get('/whoami', headers=headers2, expect_errors=True) assert_equal(r2.status, 303)
def test_list_scope_no_scopes(self): """ SCOPE (REST): send a GET list all scopes for one account without scopes """ mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) headers2 = {'X-Rucio-Auth-Token': str(token)} acntusr = account_name_generator() data = dumps({'type': 'USER'}) r2 = TestApp(account_app.wsgifunc(*mw)).post('/' + acntusr, headers=headers2, params=data, expect_errors=True) assert_equal(r2.status, 201) headers3 = {'X-Rucio-Auth-Token': str(token)} r4 = TestApp(account_app.wsgifunc(*mw)).get('/%(acntusr)s/scopes/' % locals(), headers=headers3, params=data, expect_errors=True) assert_equal(r4.status, 404) assert_equal(r4.header('ExceptionClass'), 'ScopeNotFound')
def test_create_existing_subscription(self): """ SUBSCRIPTION (REST): Test the creation of a existing subscription """ mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) subscription_name = uuid() headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({'name': subscription_name, 'filter': {'project': ['data12_900GeV', 'data12_8TeV', 'data13_900GeV', 'data13_8TeV'], 'datatype': ['AOD', ], 'excluded_pattern': '(_tid|physics_(Muons|JetTauEtmiss|Egamma)\..*\.ESD|express_express(?!.*NTUP|.*\.ESD|.*RAW)|(physics|express)(?!.*NTUP).*\ \.x|physics_WarmStart|calibration(?!_PixelBeam.merge.(NTUP_IDVTXLUMI|AOD))|merge.HIST|NTUP_MUONCALIB|NTUP_TRIG)', 'account': 'tier0'}, 'replication_rules': [(2, 'T1_DATATAPE', True, True), (1, 'T1_DATADISK', False, True)], 'lifetime': 100000, 'retroactive': 0, 'dry_run': 0, 'comments': 'We are the knights who say Ni !'}) r2 = TestApp(subs_app.wsgifunc(*mw)).post('/root/' + subscription_name, headers=headers2, params=data, expect_errors=True) assert_equal(r2.status, 201) r3 = TestApp(subs_app.wsgifunc(*mw)).post('/root/' + subscription_name, headers=headers2, params=data, expect_errors=True) assert_equal(r3.header('ExceptionClass'), 'SubscriptionDuplicate') assert_equal(r3.status, 409)
def get_auth_token(account, username, password): """ Get's an authentication token from the server :param account: the account authenticating :param username:the username linked to the account :param password: the password linked to the account :returns: the authentication token """ mw = [] header = {'Rucio-Account': account, 'Rucio-Username': username, 'Rucio-Password': password} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=header, expect_errors=True) token = str(r1.header('Rucio-Auth-Token')) return token
def test_scope_failure(self): """ SCOPE (REST): send a POST to create a new scope for a not existing account to test the error""" mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) headers2 = {'X-Rucio-Auth-Token': str(token)} scopeusr = scope_name_generator() # NOQA acntusr = account_name_generator() # NOQA r2 = TestApp(account_app.wsgifunc(*mw)).post('/%(scopeusr)s/scopes/%(scopeusr)s' % locals(), headers=headers2, expect_errors=True) assert_equal(r2.status, 404)
def test_create_user_success(self): """ ACCOUNT (REST): send a POST to create a new user """ mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) acntusr = account_name_generator() headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({'type': 'USER'}) r2 = TestApp(account_app.wsgifunc(*mw)).post('/' + acntusr, headers=headers2, params=data, expect_errors=True) assert_equal(r2.status, 201)
def test_create_user_failure(self): """ ACCOUNT (REST): send a POST with an existing user to test the error case """ mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) headers = {'X-Rucio-Auth-Token': str(token)} data = dumps({'type': 'USER'}) r1 = TestApp(account_app.wsgifunc(*mw)).post('/jdoe', headers=headers, params=data, expect_errors=True) r1 = TestApp(account_app.wsgifunc(*mw)).post('/jdoe', headers=headers, params=data, expect_errors=True) assert_equal(r1.status, 409)
def test_list_rules_states(self): """ SUBSCRIPTION (REST): Test listing of rule states for subscription """ tmp_scope = 'mock_' + uuid()[:8] add_scope(tmp_scope, 'root') mw = [] site_a = 'RSE%s' % uuid().upper() site_b = 'RSE%s' % uuid().upper() add_rse(site_a) add_rse(site_b) # add a new dataset dsn = 'dataset-%s' % uuid() add_did(scope=tmp_scope, name=dsn, type=DIDType.DATASET, account='root') subscription_name = uuid() id = add_subscription(name=subscription_name, account='root', filter={'account': 'root'}, replication_rules=[(1, 'T1_DATADISK', False, True)], lifetime=100000, retroactive=0, dry_run=0, comments='We want a shrubbery') subscriptions = list_subscriptions(name=subscription_name, account='root') # workaround until add_subscription returns the id id = None for s in subscriptions: id = s['id'] # Add two rules add_rule(dids=[{'scope': tmp_scope, 'name': dsn}], account='root', copies=1, rse_expression=site_a, grouping='NONE', weight=None, lifetime=None, locked=False, subscription_id=id) add_rule(dids=[{'scope': tmp_scope, 'name': dsn}], account='root', copies=1, rse_expression=site_b, grouping='NONE', weight=None, lifetime=None, locked=False, subscription_id=id) headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) headers2 = {'X-Rucio-Auth-Token': str(token)} r2 = TestApp(subs_app.wsgifunc(*mw)).get('/%s/%s/Rules/States' % ('root', subscription_name), headers=headers2, expect_errors=True) for line in r2.body.split('\n'): print line rs = loads(line) if rs[1] == subscription_name: break assert_equal(rs[3], 2)
def test_scope_success(self): """ SCOPE (REST): send a POST to create a new account and scope """ mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) headers2 = {'X-Rucio-Auth-Token': str(token)} acntusr = account_name_generator() data = dumps({'type': 'USER'}) r2 = TestApp(account_app.wsgifunc(*mw)).post('/' + acntusr, headers=headers2, params=data, expect_errors=True) assert_equal(r2.status, 201) headers3 = {'X-Rucio-Auth-Token': str(token)} scopeusr = scope_name_generator() r3 = TestApp(account_app.wsgifunc(*mw)).post('/%s/scopes/%s' % (acntusr, scopeusr), headers=headers3, expect_errors=True) assert_equal(r3.status, 201)
def test_scope_duplicate(self): """ SCOPE (REST): send a POST to create a already existing scope to test the error""" mw = [] headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } res1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(res1.status, 200) token = str(res1.header('X-Rucio-Auth-Token')) headers2 = {'X-Rucio-Auth-Token': str(token)} acntusr = account_name_generator() data = dumps({'type': 'USER', 'email': '*****@*****.**'}) res2 = TestApp(account_app.wsgifunc(*mw)).post('/' + acntusr, headers=headers2, params=data, expect_errors=True) assert_equal(res2.status, 201) headers3 = {'X-Rucio-Auth-Token': str(token)} scopeusr = scope_name_generator() res3 = TestApp(account_app.wsgifunc(*mw)).post('/%s/scopes/%s' % (acntusr, scopeusr), headers=headers3, expect_errors=True) assert_equal(res3.status, 201) res3 = TestApp(account_app.wsgifunc(*mw)).post('/%s/scopes/%s' % (acntusr, scopeusr), headers=headers3, expect_errors=True) assert_equal(res3.status, 409)
def test_del_user_success(self): """ ACCOUNT (REST): send a DELETE to disable the new user """ mw = [] headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } res1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(res1.status, 200) token = str(res1.header('X-Rucio-Auth-Token')) acntusr = account_name_generator() headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({'type': 'USER', 'email': '*****@*****.**'}) res2 = TestApp(account_app.wsgifunc(*mw)).post('/' + acntusr, headers=headers2, params=data, expect_errors=True) assert_equal(res2.status, 201) headers3 = {'X-Rucio-Auth-Token': str(token)} res3 = TestApp(account_app.wsgifunc(*mw)).delete('/' + acntusr, headers=headers3, expect_errors=True) assert_equal(res3.status, 200) headers4 = {'X-Rucio-Auth-Token': str(token)} res4 = TestApp(account_app.wsgifunc(*mw)).get('/' + acntusr, headers=headers4, expect_errors=True) body = loads(res4.body.decode()) assert_true(body['status'] == AccountStatus.DELETED.description) # pylint: disable=no-member assert_equal(res3.status, 200)
def test_export_rest(self): """ EXPORT (REST): Test the export of data.""" mw = [] headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } headers1.update(self.vo_header) r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) token = str(r1.header('X-Rucio-Auth-Token')) headers2 = { 'X-Rucio-Type': 'user', 'X-Rucio-Account': 'root', 'X-Rucio-Auth-Token': str(token) } r2 = TestApp(export_app.wsgifunc(*mw)).get('/', headers=headers2, expect_errors=True) rses = export_rses() sanitised = {} for rse_id in rses: sanitised[get_rse_name(rse_id=rse_id)] = rses[rse_id] rses = sanitised assert_equal(r2.status, 200) assert_equal( json.loads(r2.body), json.loads( render_json(**{ 'rses': rses, 'distances': export_distances() })))
def test_create_user_success(self): """ ACCOUNT (REST): send a POST to create a new user """ mw = [] headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } res1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(res1.status, 200) token = str(res1.header('X-Rucio-Auth-Token')) acntusr = account_name_generator() headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({'type': 'USER', 'email': '*****@*****.**'}) res2 = TestApp(account_app.wsgifunc(*mw)).post('/' + acntusr, headers=headers2, params=data, expect_errors=True) assert_equal(res2.status, 201)
def test_export_import(self): """ IMPORT/EXPORT (REST): Test the export and import of data together to check same syntax.""" # Setup new RSE, distance, attribute, limits new_rse = rse_name_generator() add_rse(new_rse) # Get token mw = [] headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) token = str(r1.header('X-Rucio-Auth-Token')) headers2 = { 'X-Rucio-Type': 'user', 'X-Rucio-Account': 'root', 'X-Rucio-Auth-Token': str(token) } # Export data r2 = TestApp(export_app.wsgifunc(*mw)).get('/', headers=headers2, expect_errors=True) exported_data = parse_response(r2.body) # Import data r3 = TestApp(import_app.wsgifunc(*mw)).post( '/', headers=headers2, expect_errors=True, params=render_json(**exported_data)) assert_equal(r3.status, 201)
def test_create_and_update_and_list_subscription(self): """ SUBSCRIPTION (REST): Test the creation of a new subscription, update it, list it """ mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} res1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(res1.status, 200) token = str(res1.header('X-Rucio-Auth-Token')) subscription_name = uuid() headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({'options': {'filter': {'project': self.projects, 'datatype': ['AOD', ], 'excluded_pattern': self.pattern1, 'account': ['tier0', ]}, 'replication_rules': [{'lifetime': 86400, 'rse_expression': 'MOCK|MOCK2', 'copies': 2, 'activity': 'Data Brokering'}], 'lifetime': 100000, 'retroactive': 0, 'dry_run': 0, 'comments': 'blahblah'}}) res2 = TestApp(subs_app.wsgifunc(*mw)).post('/root/%s' % (subscription_name), headers=headers2, params=data, expect_errors=True) assert_equal(res2.status, 201) data = dumps({'options': {'filter': {'project': ['toto', ]}}}) res3 = TestApp(subs_app.wsgifunc(*mw)).put('/root/%s' % (subscription_name), headers=headers2, params=data, expect_errors=True) assert_equal(res3.status, 201) res4 = TestApp(subs_app.wsgifunc(*mw)).get('/root/%s' % (subscription_name), headers=headers2, expect_errors=True) assert_equal(res4.status, 200) assert_equal(loads(loads(res4.body)['filter'])['project'][0], 'toto')
def test_del_user_success(self): """ ACCOUNT (REST): send a DELETE to disable the new user """ mw = [] headers1 = {'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******'} r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(r1.status, 200) token = str(r1.header('X-Rucio-Auth-Token')) acntusr = account_name_generator() headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({'type': 'USER'}) r2 = TestApp(account_app.wsgifunc(*mw)).post('/' + acntusr, headers=headers2, params=data, expect_errors=True) assert_equal(r2.status, 201) headers3 = {'X-Rucio-Auth-Token': str(token)} r3 = TestApp(account_app.wsgifunc(*mw)).delete('/' + acntusr, headers=headers3, expect_errors=True) assert_equal(r3.status, 200) headers4 = {'X-Rucio-Auth-Token': str(token)} r4 = TestApp(account_app.wsgifunc(*mw)).get('/' + acntusr, headers=headers4, expect_errors=True) body = loads(r4.body) assert_true(body['status'] == AccountStatus.DELETED.description) assert_equal(r3.status, 200)
def test_scope_failure(self): """ SCOPE (REST): send a POST to create a new scope for a not existing account to test the error""" mw = [] headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } headers1.update(self.vo_header) res1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert res1.status == 200 token = str(res1.header('X-Rucio-Auth-Token')) headers2 = {'X-Rucio-Auth-Token': str(token)} scopeusr = scope_name_generator() account_name_generator() res2 = TestApp(account_app.wsgifunc(*mw)).post('/%s/scopes/%s' % (scopeusr, scopeusr), headers=headers2, expect_errors=True) assert res2.status == 404
def test_importer_rest(self): """ IMPORTER (REST): test import. """ mw = [] headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } headers1.update(self.vo_header) r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) token = str(r1.header('X-Rucio-Auth-Token')) headers2 = { 'X-Rucio-Type': 'user', 'X-Rucio-Account': 'root', 'X-Rucio-Auth-Token': str(token) } r2 = TestApp(import_app.wsgifunc(*mw)).post( '/', headers=headers2, expect_errors=True, params=render_json(**self.data1)) assert_equal(r2.status, 201, r2.body) # RSE that not existed before check_rse(self.new_rse, self.data1['rses']) check_protocols(self.new_rse, self.data1['rses']) new_rse_id = get_rse_id(rse=self.new_rse, **self.vo) protocols = get_rse_protocols(self.old_rse_id_1) protocols = [{ 'hostname': protocol['hostname'], 'scheme': protocol['scheme'], 'port': protocol['port'] } for protocol in protocols['protocols']] assert_true({ 'hostename': 'hostname3', 'port': 1000, 'scheme': 'scheme3' } not in protocols) attributes = list_rse_attributes(rse_id=new_rse_id) assert_equal(attributes['attr1'], 'test') limits = get_rse_limits(rse_id=new_rse_id) assert_equal(limits['MinFreeSpace'], 20000) # RSE 1 that already existed before check_rse(self.old_rse_1, self.data1['rses']) check_protocols(self.old_rse_1, self.data1['rses']) attributes = list_rse_attributes(rse_id=self.old_rse_id_1) assert_equal(attributes['attr1'], 'test1') assert_equal(attributes['attr2'], 'test2') limits = get_rse_limits(rse_id=self.old_rse_id_1) assert_equal(limits['MaxBeingDeletedFiles'], 1000) assert_equal(limits['MinFreeSpace'], 10000) distance = get_distances(self.old_rse_id_1, self.old_rse_id_2)[0] assert_equal(distance['ranking'], 10) distance = get_distances(self.old_rse_id_1, self.old_rse_id_3)[0] assert_equal(distance['ranking'], 4) with assert_raises(RSENotFound): get_rse(rse_id=self.old_rse_id_4) r2 = TestApp(import_app.wsgifunc(*mw)).post( '/', headers=headers2, expect_errors=True, params=render_json(**self.data2)) assert_equal(r2.status, 201) r2 = TestApp(import_app.wsgifunc(*mw)).post( '/', headers=headers2, expect_errors=True, params=render_json(**self.data3)) assert_equal(r2.status, 201)
def test_bad_replica_methods_for_UI(self): """ REPLICA (REST): Test the listing of bad and suspicious replicas """ mw = [] headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } result = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(result.status, 200) token = str(result.header('X-Rucio-Auth-Token')) headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({}) result = TestApp(rep_app.wsgifunc(*mw)).get('/bad/states', headers=headers2, params=data, expect_errors=True) assert_equal(result.status, 200) tot_files = [] for line in result.body.split('\n'): if line != '': tot_files.append(dumps(line)) nb_tot_files = len(tot_files) data = dumps({'state': 'B'}) result = TestApp(rep_app.wsgifunc(*mw)).get('/bad/states', headers=headers2, params=data, expect_errors=True) assert_equal(result.status, 200) tot_bad_files = [] for line in result.body.split('\n'): if line != '': tot_bad_files.append(dumps(line)) nb_tot_bad_files1 = len(tot_bad_files) data = dumps({'state': 'S', 'list_pfns': 'True'}) result = TestApp(rep_app.wsgifunc(*mw)).get('/bad/states', headers=headers2, params=data, expect_errors=True) assert_equal(result.status, 200) tot_suspicious_files = [] for line in result.body.split('\n'): if line != '': tot_suspicious_files.append(dumps(line)) nb_tot_suspicious_files = len(tot_suspicious_files) data = dumps({'state': 'T', 'list_pfns': 'True'}) result = TestApp(rep_app.wsgifunc(*mw)).get('/bad/states', headers=headers2, params=data, expect_errors=True) assert_equal(result.status, 200) tot_temporary_unavailable_files = [] for line in result.body.split('\n'): if line != '': tot_temporary_unavailable_files.append(dumps(line)) nb_tot_temporary_unavailable_files = len( tot_temporary_unavailable_files) assert_equal( nb_tot_files, nb_tot_bad_files1 + nb_tot_suspicious_files + nb_tot_temporary_unavailable_files) tomorrow = datetime.utcnow() + timedelta(days=1) data = dumps({'state': 'B', 'younger_than': tomorrow.isoformat()}) result = TestApp(rep_app.wsgifunc(*mw)).get('/bad/states', headers=headers2, params=data, expect_errors=True) assert_equal(result.status, 200) tot_bad_files = [] for line in result.body.split('\n'): if line != '': tot_bad_files.append(dumps(line)) nb_tot_bad_files = len(tot_bad_files) assert_equal(nb_tot_bad_files, 0) data = dumps({}) result = TestApp(rep_app.wsgifunc(*mw)).get('/bad/summary', headers=headers2, params=data, expect_errors=True) assert_equal(result.status, 200) nb_tot_bad_files2 = 0 for line in result.body.split('\n'): if line != '': line = loads(line) nb_tot_bad_files2 += int(line.get('BAD', 0)) assert_equal(nb_tot_bad_files1, nb_tot_bad_files2)
def test_list_rules_states(self): """ SUBSCRIPTION (REST): Test listing of rule states for subscription """ tmp_scope = InternalScope('mock_' + uuid()[:8]) root = InternalAccount('root') add_scope(tmp_scope, root) mw = [] site_a = 'RSE%s' % uuid().upper() site_b = 'RSE%s' % uuid().upper() site_a_id = add_rse(site_a) site_b_id = add_rse(site_b) # Add quota set_local_account_limit(root, site_a_id, -1) set_local_account_limit(root, site_b_id, -1) # add a new dataset dsn = 'dataset-%s' % uuid() add_did(scope=tmp_scope, name=dsn, type=DIDType.DATASET, account=root) subscription_name = uuid() subid = add_subscription(name=subscription_name, account='root', filter={ 'account': [ 'root', ], 'scope': [ tmp_scope.external, ] }, replication_rules=[{ 'lifetime': 86400, 'rse_expression': 'MOCK|MOCK2', 'copies': 2, 'activity': 'Data Brokering' }], lifetime=100000, retroactive=0, dry_run=0, comments='We want a shrubbery', issuer='root') # Add two rules add_rule(dids=[{ 'scope': tmp_scope, 'name': dsn }], account=root, copies=1, rse_expression=site_a, grouping='NONE', weight=None, lifetime=None, locked=False, subscription_id=subid) add_rule(dids=[{ 'scope': tmp_scope, 'name': dsn }], account=root, copies=1, rse_expression=site_b, grouping='NONE', weight=None, lifetime=None, locked=False, subscription_id=subid) headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } res1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(res1.status, 200) token = str(res1.header('X-Rucio-Auth-Token')) headers2 = {'X-Rucio-Auth-Token': str(token)} res2 = TestApp(subs_app.wsgifunc(*mw)).get('/%s/%s/Rules/States' % ('root', subscription_name), headers=headers2, expect_errors=True) for line in res2.body.decode().split('\n'): print(line) rs = loads(line) if rs[1] == subscription_name: break assert_equal(rs[3], 2)
def test_create_existing_subscription(self): """ SUBSCRIPTION (REST): Test the creation of a existing subscription """ mw = [] headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } res1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) assert_equal(res1.status, 200) token = str(res1.header('X-Rucio-Auth-Token')) subscription_name = uuid() headers2 = {'X-Rucio-Auth-Token': str(token)} data = dumps({ 'options': { 'name': subscription_name, 'filter': { 'project': self.projects, 'datatype': [ 'AOD', ], 'excluded_pattern': self.pattern1, 'account': [ 'tier0', ] }, 'replication_rules': [{ 'lifetime': 86400, 'rse_expression': 'MOCK|MOCK2', 'copies': 2, 'activity': 'Data Brokering' }], 'lifetime': 100000, 'retroactive': 0, 'dry_run': 0, 'comments': 'We are the knights who say Ni !' } }) res2 = TestApp(subs_app.wsgifunc(*mw)).post('/root/' + subscription_name, headers=headers2, params=data, expect_errors=True) assert_equal(res2.status, 201) res3 = TestApp(subs_app.wsgifunc(*mw)).post('/root/' + subscription_name, headers=headers2, params=data, expect_errors=True) assert_equal(res3.header('ExceptionClass'), 'SubscriptionDuplicate') assert_equal(res3.status, 409)
def test_importer_rest(self): """ IMPORTER (REST): test import. """ mw = [] headers1 = { 'X-Rucio-Account': 'root', 'X-Rucio-Username': '******', 'X-Rucio-Password': '******' } r1 = TestApp(auth_app.wsgifunc(*mw)).get('/userpass', headers=headers1, expect_errors=True) token = str(r1.header('X-Rucio-Auth-Token')) headers2 = { 'X-Rucio-Type': 'user', 'X-Rucio-Account': 'root', 'X-Rucio-Auth-Token': str(token) } r2 = TestApp(import_app.wsgifunc(*mw)).post( '/', headers=headers2, expect_errors=True, params=render_json(**self.data1)) assert_equal(r2.status, 201) # RSE that not existed before rse = get_rse(self.new_rse) assert_equal(rse['availability'], 5) assert_equal(rse['city'], 'NewCity') assert_equal(rse['rse_type'], RSEType.TAPE) protocols = [{ 'hostname': protocol['hostname'], 'scheme': protocol['scheme'], 'port': protocol['port'] } for protocol in get_rse_protocols(self.new_rse)['protocols']] assert_true({ 'scheme': 'scheme', 'hostname': 'hostname', 'port': 1000 } in protocols) attributes = list_rse_attributes(rse=self.new_rse) assert_equal(attributes['attr1'], 'test') limits = get_rse_limits(rse=self.new_rse) assert_equal(limits['limit1'], 0) transfer_limits = get_rse_transfer_limits(rse=self.new_rse) assert_equal( transfer_limits['activity1'][get_rse_id( self.new_rse)]['max_transfers'], 1) # RSE 1 that already existed before rse = get_rse(self.old_rse_1) assert_equal(rse['rse'], self.old_rse_1) protocols = [{ 'hostname': protocol['hostname'], 'scheme': protocol['scheme'], 'port': protocol['port'], 'impl': protocol['impl'], 'prefix': protocol['prefix'] } for protocol in get_rse_protocols(self.old_rse_1)['protocols']] assert_true({ 'scheme': 'scheme1', 'hostname': 'hostname1', 'port': 1000, 'prefix': 'prefix', 'impl': 'impl1' } in protocols) assert_true({ 'scheme': 'scheme2', 'hostname': 'hostname2', 'port': 1001, 'impl': 'impl', 'prefix': '' } in protocols) attributes = list_rse_attributes(rse=self.old_rse_1) assert_equal(attributes['attr1'], 'test1') assert_equal(attributes['attr2'], 'test2') limits = get_rse_limits(rse=self.old_rse_1) assert_equal(limits['limit1'], 0) assert_equal(limits['limit2'], 2) transfer_limits = get_rse_transfer_limits(rse=self.old_rse_1) assert_equal( transfer_limits['activity1'][get_rse_id( self.old_rse_1)]['max_transfers'], 1) assert_equal( transfer_limits['activity2'][get_rse_id( self.old_rse_1)]['max_transfers'], 2) # Distances distance = get_distances(self.old_rse_id_1, self.old_rse_id_2)[0] assert_equal(distance['ranking'], 10) distance = get_distances(self.old_rse_id_1, self.old_rse_id_3)[0] assert_equal(distance['ranking'], 4) r2 = TestApp(import_app.wsgifunc(*mw)).post( '/', headers=headers2, expect_errors=True, params=render_json(**self.data2)) assert_equal(r2.status, 201) r2 = TestApp(import_app.wsgifunc(*mw)).post( '/', headers=headers2, expect_errors=True, params=render_json(**self.data3)) assert_equal(r2.status, 201)