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)