class TestAccountClient(unittest.TestCase):
@classmethod
def setUpClass(cls):
if config_get_bool('common', 'multi_vo', raise_exception=False, default=False):
cls.vo = {'vo': get_vo()}
cls.multi_vo = True
else:
cls.vo = {}
cls.multi_vo = False
# Add test account
cls.account = InternalAccount(''.join(random.choice(string.ascii_uppercase) for x in range(10)), **cls.vo)
add_account(account=cls.account, type_=AccountType.USER, email='*****@*****.**')
# Add test RSE
cls.rse1 = 'MOCK'
cls.rse2 = 'MOCK2'
cls.rse1_id = get_rse_id(rse=cls.rse1, **cls.vo)
cls.rse2_id = get_rse_id(rse=cls.rse2, **cls.vo)
cls.db_session = session.get_session()
@classmethod
def tearDownClass(cls):
cls.db_session.query(models.AccountLimit).delete()
cls.db_session.query(models.AccountGlobalLimit).delete()
cls.db_session.commit()
cls.db_session.close()
def setUp(self):
self.client = AccountClient()
self.alclient = AccountLimitClient()
self.db_session.query(models.AccountLimit).delete()
self.db_session.query(models.AccountGlobalLimit).delete()
self.db_session.commit()
def test_set_global_account_limit(self):
""" ACCOUNT_LIMIT (CLIENTS): Set global account limit """
self.alclient.set_global_account_limit(self.account.external, 'MOCK', 200000)
assert account_limit.get_global_account_limit(account=self.account, rse_expression='MOCK') == 200000
assert account_limit.get_global_account_limit(account=self.account, rse_expression='MOCK2') is None
def test_get_global_account_limits(self):
""" ACCOUNT_LIMIT (CLIENTS): Get global account limits """
expression = 'MOCK'
resolved_rses = ['MOCK']
resolved_rse_ids = [get_rse_id('MOCK', **self.vo)]
limit = 10
account_limit.set_global_account_limit(self.account, expression, limit)
results = self.client.get_global_account_limits(account=self.account.external)
assert len(results) == 1
assert results[expression]['resolved_rses'] == resolved_rses
assert results[expression]['resolved_rse_ids'] == resolved_rse_ids
assert results[expression]['limit'] == limit
def test_get_global_account_limit(self):
""" ACCOUNT_LIMIT (CLIENTS): Get global account limit. """
expression = 'MOCK'
limit = 10
account_limit.set_global_account_limit(self.account, expression, limit)
result = self.client.get_global_account_limit(account=self.account.external, rse_expression=expression)
assert result[expression] == limit
def test_get_local_account_limits(self):
""" ACCOUNT_LIMIT (CLIENTS): Get local account limits """
account_limit.set_local_account_limit(account=self.account, rse_id=self.rse1_id, bytes_=12345)
account_limit.set_local_account_limit(account=self.account, rse_id=self.rse2_id, bytes_=12345)
limits = self.client.get_local_account_limits(account=self.account.external)
assert (self.rse1, 12345) in limits.items()
assert (self.rse2, 12345) in limits.items()
account_limit.delete_local_account_limit(account=self.account, rse_id=self.rse1_id)
account_limit.delete_local_account_limit(account=self.account, rse_id=self.rse2_id)
def test_get_local_account_limit(self):
""" ACCOUNT_LIMIT (CLIENTS): Get local account limit """
account_limit.delete_local_account_limit(account=self.account, rse_id=self.rse1_id)
account_limit.set_local_account_limit(account=self.account, rse_id=self.rse1_id, bytes_=333)
limit = self.client.get_local_account_limit(account=self.account.external, rse=self.rse1)
assert limit == {self.rse1: 333}
account_limit.delete_local_account_limit(account=self.account, rse_id=self.rse1_id)
def test_set_local_account_limit(self):
""" ACCOUNTLIMIT (CLIENTS): Set local account limit """
self.alclient.set_local_account_limit(account=self.account.external, rse=self.rse1, bytes_=987)
limit = self.client.get_local_account_limit(account=self.account.external, rse=self.rse1)
assert limit[self.rse1] == 987
account_limit.delete_local_account_limit(account=self.account, rse_id=self.rse1_id)
def test_delete_local_account_limit(self):
""" ACCOUNTLIMIT (CLIENTS): Delete local account limit """
self.alclient.set_local_account_limit(account=self.account.external, rse=self.rse1, bytes_=786)
limit = self.client.get_local_account_limit(account=self.account.external, rse=self.rse1)
assert limit == {self.rse1: 786}
self.alclient.delete_local_account_limit(account=self.account.external, rse=self.rse1)
limit = self.client.get_local_account_limit(account=self.account.external, rse=self.rse1)
assert limit[self.rse1] is None
account_limit.delete_local_account_limit(account=self.account, rse_id=self.rse1_id)
def test_delete_global_account_limit(self):
""" ACCOUNTLIMIT (CLIENTS): Delete global account limit """
rse_exp = 'MOCK'
account_limit.set_global_account_limit(account=self.account, rse_expression=rse_exp, bytes_=10, session=self.db_session)
self.alclient.delete_global_account_limit(account=self.account.external, rse_expression=rse_exp)
result = account_limit.get_global_account_limit(account=self.account, rse_expression=rse_exp)
assert result is None
def test_subscriptions_at_different_vos(self):
""" MULTI VO (CLIENT): Test that subscriptions from 2nd vo don't interfere """
account_client = AccountClient()
usr_uuid = str(generate_uuid()).lower()[:16]
shr_acc = 'shr-%s' % usr_uuid
account_client.add_account(shr_acc, 'USER', '*****@*****.**')
add_account(shr_acc, 'USER', '*****@*****.**', 'root', **self.new_vo)
scope_client = ScopeClient()
scope_uuid = str(generate_uuid()).lower()[:16]
tst_scope = 'tst_%s' % scope_uuid
new_scope = 'new_%s' % scope_uuid
scope_client.add_scope('root', tst_scope)
add_scope(new_scope, 'root', 'root', **self.new_vo)
did_client = DIDClient()
did_uuid = str(generate_uuid()).lower()[:16]
tst_did = 'tstset_%s' % did_uuid
new_did = 'newset_%s' % did_uuid
rse_client = RSEClient()
rse_str = ''.join(choice(ascii_uppercase) for x in range(10))
tst_rse1 = 'TST1_%s' % rse_str
tst_rse2 = 'TST2_%s' % rse_str
new_rse1 = 'NEW1_%s' % rse_str
new_rse2 = 'NEW2_%s' % rse_str
rse_client.add_rse(tst_rse1)
rse_client.add_rse(tst_rse2)
add_rse(new_rse1, 'root', **self.new_vo)
add_rse(new_rse2, 'root', **self.new_vo)
acc_lim_client = AccountLimitClient()
acc_lim_client.set_local_account_limit(shr_acc, tst_rse1, 10)
acc_lim_client.set_local_account_limit(shr_acc, tst_rse2, 10)
set_local_account_limit(shr_acc, new_rse1, 10, 'root', **self.new_vo)
set_local_account_limit(shr_acc, new_rse2, 10, 'root', **self.new_vo)
did_client.add_did(tst_scope, tst_did, 'DATASET', rse=tst_rse1)
add_did(new_scope, new_did, 'DATASET', 'root', rse=new_rse1, **self.new_vo)
sub_client = SubscriptionClient()
sub_str = generate_uuid()
tst_sub = 'tstsub_' + sub_str
new_sub = 'newsub_' + sub_str
shr_sub = 'shrsub_' + sub_str
tst_sub_id = sub_client.add_subscription(tst_sub, shr_acc, {'scope': [tst_scope]},
[{'copies': 1, 'rse_expression': tst_rse2, 'weight': 0,
'activity': 'User Subscriptions'}],
'', None, 0, 0)
shr_tst_sub_id = sub_client.add_subscription(shr_sub, shr_acc, {'scope': [tst_scope]},
[{'copies': 1, 'rse_expression': tst_rse2, 'weight': 0,
'activity': 'User Subscriptions'}],
'', None, 0, 0)
new_sub_id = add_subscription(new_sub, shr_acc, {'scope': [new_scope]},
[{'copies': 1, 'rse_expression': new_rse2, 'weight': 0, 'activity': 'User Subscriptions'}],
'', False, 0, 0, 3, 'root', **self.new_vo)
shr_new_sub_id = add_subscription(shr_sub, shr_acc, {'scope': [new_scope]},
[{'copies': 1, 'rse_expression': new_rse2, 'weight': 0, 'activity': 'User Subscriptions'}],
'', False, 0, 0, 3, 'root', **self.new_vo)
tst_subs = [s['id'] for s in sub_client.list_subscriptions()]
assert_in(tst_sub_id, tst_subs)
assert_in(shr_tst_sub_id, tst_subs)
assert_not_in(new_sub_id, tst_subs)
assert_not_in(shr_new_sub_id, tst_subs)
new_subs = [s['id'] for s in list_subscriptions(**self.new_vo)]
assert_in(new_sub_id, new_subs)
assert_in(shr_new_sub_id, new_subs)
assert_not_in(tst_sub_id, new_subs)
assert_not_in(shr_tst_sub_id, new_subs)
shr_tst_subs = [s['id'] for s in sub_client.list_subscriptions(name=shr_sub)]
assert_in(shr_tst_sub_id, shr_tst_subs)
assert_not_in(shr_new_sub_id, shr_tst_subs)
shr_new_subs = [s['id'] for s in list_subscriptions(name=shr_sub, **self.new_vo)]
assert_in(shr_new_sub_id, shr_new_subs)
assert_not_in(shr_tst_sub_id, shr_new_subs)
acc_tst_subs = [s['id'] for s in sub_client.list_subscriptions(account=shr_acc)]
assert_in(tst_sub_id, acc_tst_subs)
assert_in(shr_tst_sub_id, acc_tst_subs)
assert_not_in(new_sub_id, acc_tst_subs)
assert_not_in(shr_new_sub_id, acc_tst_subs)
acc_new_subs = [s['id'] for s in list_subscriptions(account=shr_acc, **self.new_vo)]
assert_in(new_sub_id, acc_new_subs)
assert_in(shr_new_sub_id, acc_new_subs)
assert_not_in(tst_sub_id, acc_new_subs)
assert_not_in(shr_tst_sub_id, acc_new_subs)
class TestAccountClient():
@classmethod
def setUpClass(cls):
# Add test account
cls.account = InternalAccount(''.join(
random.choice(string.ascii_uppercase) for x in range(10)))
add_account(account=cls.account,
type=AccountType.USER,
email='*****@*****.**')
# Add test RSE
cls.rse1 = 'MOCK'
cls.rse2 = 'MOCK2'
cls.rse1_id = get_rse_id(rse=cls.rse1)
cls.rse2_id = get_rse_id(rse=cls.rse2)
cls.db_session = session.get_session()
@classmethod
def tearDownClass(cls):
cls.db_session.query(models.AccountLimit).delete()
cls.db_session.query(models.AccountGlobalLimit).delete()
cls.db_session.commit()
cls.db_session.close()
def setup(self):
self.client = AccountClient()
self.alclient = AccountLimitClient()
self.db_session.query(models.AccountLimit).delete()
self.db_session.query(models.AccountGlobalLimit).delete()
self.db_session.commit()
def test_set_global_account_limit(self):
""" ACCOUNT_LIMIT (CLIENTS): Set global account limit """
self.alclient.set_global_account_limit(self.account.external, 'MOCK',
200000)
assert_equal(
account_limit.get_global_account_limit(account=self.account,
rse_expression='MOCK'),
200000)
assert_equal(
account_limit.get_global_account_limit(account=self.account,
rse_expression='MOCK2'),
None)
def test_get_global_account_limits(self):
""" ACCOUNT_LIMIT (CLIENTS): Get global account limits """
expression = 'MOCK'
resolved_rses = ['MOCK']
resolved_rse_ids = [get_rse_id('MOCK')]
limit = 10
account_limit.set_global_account_limit(self.account, expression, limit)
results = self.client.get_global_account_limits(
account=self.account.external)
assert_equal(len(results), 1)
assert_equal(results[expression]['resolved_rses'], resolved_rses)
assert_equal(results[expression]['resolved_rse_ids'], resolved_rse_ids)
assert_equal(results[expression]['limit'], limit)
def test_get_global_account_limit(self):
""" ACCOUNT_LIMIT (CLIENTS): Get global account limit. """
expression = 'MOCK'
limit = 10
account_limit.set_global_account_limit(self.account, expression, limit)
result = self.client.get_global_account_limit(
account=self.account.external, rse_expression=expression)
assert_equal(result[expression], limit)
def test_get_local_account_limits(self):
""" ACCOUNT_LIMIT (CLIENTS): Get local account limits """
account_limit.set_local_account_limit(account=self.account,
rse_id=self.rse1_id,
bytes=12345)
account_limit.set_local_account_limit(account=self.account,
rse_id=self.rse2_id,
bytes=12345)
limits = self.client.get_local_account_limits(
account=self.account.external)
assert_in((self.rse1, 12345), limits.items())
assert_in((self.rse2, 12345), limits.items())
account_limit.delete_local_account_limit(account=self.account,
rse_id=self.rse1_id)
account_limit.delete_local_account_limit(account=self.account,
rse_id=self.rse2_id)
def test_get_local_account_limit(self):
""" ACCOUNT_LIMIT (CLIENTS): Get local account limit """
account_limit.delete_local_account_limit(account=self.account,
rse_id=self.rse1_id)
account_limit.set_local_account_limit(account=self.account,
rse_id=self.rse1_id,
bytes=333)
limit = self.client.get_local_account_limit(
account=self.account.external, rse=self.rse1)
assert_equal(limit, {self.rse1: 333})
account_limit.delete_local_account_limit(account=self.account,
rse_id=self.rse1_id)
def test_set_local_account_limit(self):
""" ACCOUNTLIMIT (CLIENTS): Set local account limit """
self.alclient.set_local_account_limit(account=self.account.external,
rse=self.rse1,
bytes=987)
limit = self.client.get_local_account_limit(
account=self.account.external, rse=self.rse1)
assert_equal(limit[self.rse1], 987)
account_limit.delete_local_account_limit(account=self.account,
rse_id=self.rse1_id)
def test_delete_local_account_limit(self):
""" ACCOUNTLIMIT (CLIENTS): Delete local account limit """
self.alclient.set_local_account_limit(account=self.account.external,
rse=self.rse1,
bytes=786)
limit = self.client.get_local_account_limit(
account=self.account.external, rse=self.rse1)
assert_equal(limit, {self.rse1: 786})
self.alclient.delete_local_account_limit(account=self.account.external,
rse=self.rse1)
limit = self.client.get_local_account_limit(
account=self.account.external, rse=self.rse1)
assert_equal(limit[self.rse1], None)
account_limit.delete_local_account_limit(account=self.account,
rse_id=self.rse1_id)
def test_delete_global_account_limit(self):
""" ACCOUNTLIMIT (CLIENTS): Delete global account limit """
rse_exp = 'MOCK'
account_limit.set_global_account_limit(account=self.account,
rse_expression=rse_exp,
bytes=10,
session=self.db_session)
self.alclient.delete_global_account_limit(
account=self.account.external, rse_expression=rse_exp)
result = account_limit.get_global_account_limit(account=self.account,
rse_expression=rse_exp)
assert_equal(result, None)
