X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=tests%2FtestInterfaces.py;h=91606371d599a3ec127b5d0c3efa3231fa5dda7c;hb=1e95f8a388325499564df5f8eb6eb1fd10ca2d42;hp=ce2569682a8ff67bafa3572ffa8a72c4550613fa;hpb=b752074f09158c84597061fca2a09ad17ca4293f;p=sfa.git diff --git a/tests/testInterfaces.py b/tests/testInterfaces.py index ce256968..91606371 100755 --- a/tests/testInterfaces.py +++ b/tests/testInterfaces.py @@ -8,11 +8,11 @@ import sfa.util.xmlrpcprotocol as xmlrpc from unittest import TestCase from optparse import OptionParser from sfa.util.xmlrpcprotocol import ServerException -from sfa.util.namespace import * +from sfa.util.xrn import get_authority from sfa.util.config import * from sfa.trust.certificate import * from sfa.trust.credential import * -from sfa.trust.sfaticket import * +from sfa.trust.sfaticket import SfaTicket from sfa.client import sfi def random_string(size): @@ -23,7 +23,6 @@ class Client: aggregate = None sm = None cm = None - user = None key = None cert = None credential = None @@ -49,27 +48,29 @@ class Client: self.aggregate = xmlrpc.get_server(SFI_AGGREGATE, key_file, cert_file) self.sm = xmlrpc.get_server(config.SFI_SM, key_file, cert_file) self.cm = xmlrpc.get_server(SFI_CM, key_file, cert_file) - self.user = config.SFI_USER + self.hrn = config.SFI_USER # XX defaulting to user, but this should be configurable so we can # test from components persepctive self.type = 'user' + self.credential = self.get_credential(self.hrn) def get_credential(self, hrn = None, type = 'user'): - if not hrn: hrn = self.user - if hrn == self.user: + if not hrn: hrn = self.hrn + if hrn == self.hrn: cert = self.cert.save_to_string(save_parents=True) request_hash = self.key.compute_hash([cert, 'user', hrn]) - self.credential = self.registry.get_self_credential(cert, type, hrn, request_hash) - return self.credential + credential = self.registry.get_self_credential(cert, type, hrn, request_hash) + return credential else: if not self.credential: - self.get_credential(self.user, 'user') + self.credential = self.get_credential(self.hrn, 'user') return self.registry.get_credential(self.credential, type, hrn) class BasicTestCase(unittest.TestCase): - def __init__(self, testname, client): + def __init__(self, testname, client, test_slice=None): unittest.TestCase.__init__(self, testname) self.client = client + self.slice = test_slice def setUp(self): self.registry = self.client.registry @@ -77,7 +78,7 @@ class BasicTestCase(unittest.TestCase): self.sm = self.client.sm self.cm = self.client.cm self.credential = self.client.credential - self.hrn = self.client.user + self.hrn = self.client.hrn self.type = self.client.type # Registry tests @@ -96,42 +97,54 @@ class RegistryTest(BasicTestCase): def testRegister(self): authority = get_authority(self.hrn) - auth_record = {'hrn': ".".join([authority, random_string(10)]), + auth_cred = self.client.get_credential(authority, 'authority') + auth_record = {'hrn': '.'.join([authority, random_string(10).lower()]), 'type': 'authority'} - node_record = {'hrn': ".".join([authority, random_string(10)]), - 'type': 'node'} - slice_record = {'hrn': ".".join([authority, random_string(10)]), + node_record = {'hrn': '.'.join([authority, random_string(10)]), + 'type': 'node', + 'hostname': random_string(6) + '.' + random_string(6)} + slice_record = {'hrn': '.'.join([authority, random_string(10)]), 'type': 'slice', 'researcher': [self.hrn]} - user_record = {'hrn': ".".join([authority, random_string(10)]), - 'type': 'user'} + user_record = {'hrn': '.'.join([authority, random_string(10)]), + 'type': 'user', + 'email': random_string(6) +'@'+ random_string(5) +'.'+ random_string(3), + 'first_name': random_string(7), + 'last_name': random_string(7)} all_records = [auth_record, node_record, slice_record, user_record] for record in all_records: try: - self.registry.register(self.cred, record) - self.registry.resolve(self.cred, record['hrn']) + self.registry.register(auth_cred, record) + self.registry.resolve(self.credential, record['hrn']) except: raise finally: - try: self.registry.remove(record['hrn']) + try: self.registry.remove(auth_cred, record['type'], record['hrn']) + except: pass def testRegisterPeerObject(self): assert True def testUpdate(self): - record = self.registry.resolve(self.credential, self.hrn) - self.registry.update(record) + authority = get_authority(self.hrn) + auth_cred = self.client.get_credential(authority, 'authority') + records = self.registry.resolve(self.credential, self.hrn) + if not records: assert False + record = records[0] + self.registry.update(auth_cred, record) def testResolve(self): authority = get_authority(self.hrn) self.registry.resolve(self.credential, self.hrn) def testRemove(self): + authority = get_authority(self.hrn) + auth_cred = self.client.get_credential(authority, 'authority') record = {'hrn': ".".join([authority, random_string(10)]), - 'type': 'user'} - self.registry.register(self.credential, user_record) - self.registry.remove(self.credential, user_record['hrn']) + 'type': 'slice'} + self.registry.register(auth_cred, record) + self.registry.remove(auth_cred, record['type'], record['hrn']) # should generate an exception try: self.registry.resolve(self.credential, record['hrn']) @@ -143,7 +156,7 @@ class RegistryTest(BasicTestCase): assert True def testList(self): - authority = get_authority(self.client.user) + authority = get_authority(self.client.hrn) self.registry.list(self.credential, authority) def testGetRegistries(self): @@ -164,32 +177,19 @@ class RegistryTest(BasicTestCase): if self.type in ['user'] and not server_exception: assert False - - class AggregateTest(BasicTestCase): - slice = None def setUp(self): BasicTestCase.setUp(self) - # register a slice that will be used for some test - slice_record = {'hrn': ".".join([authority, random_string(10)]), - 'type': 'slice', 'researcher': [self.hrn]} - self.registry.register(self.credential, slice_record) - self.slice = slice_record - - def tearDown(self): - # remove the test slice - self.registry.remove(self.credential, self.slice['hrn']) - def testGetSlices(self): - self.aggregate.get_slices(self.credential) + self.aggregate.ListSlices(self.credential) def testGetResources(self): # available resources agg_rspec = self.aggregate.get_resources(self.credential) # resources used by a slice - slice_rspec self.aggregate.get_resources(self.credential, self.slice['hrn']) + slice_rspec = self.aggregate.get_resources(self.credential, self.slice['hrn']) # will raise an exception if the rspec isnt valid RSpec(xml=agg_rspec) RSpec(xml=slice_rspec) @@ -198,11 +198,11 @@ class AggregateTest(BasicTestCase): # get availabel resources rspec = self.aggregate.get_resources(self.credential) slice_credential = self.client.get_credential(self.slice['hrn'], 'slice') - self.aggregate.create_slice(slice_credential, rspec) + self.aggregate.CreateSliver(slice_credential, self.slice['hrn'], rspec) def testDeleteSlice(self): slice_credential = self.client.get_credential(self.slice['hrn'], 'slice') - self.aggregate.delete_slice(slice_credential, self.slice['hrn']) + self.aggregate.DeleteSliver(slice_credential, self.slice['hrn'],"call-id-delete-slice") def testGetTicket(self): slice_credential = self.client.get_credential(self.slice['hrn'], 'slice') @@ -218,40 +218,53 @@ class SlicemgrTest(AggregateTest): # force calls to go through slice manager self.aggregate = self.sm + # get the slice credential + + class ComponentTest(BasicTestCase): - slice = None def setUp(self): BasicTestCase.setUp(self) - AggregateTest.setUp(self) - - def tearDown(self): - AggregateTest.tearDown(self) + self.slice_cred = self.client.get_credential(self.slice['hrn'], 'slice') def testStartSlice(self): - self.cm.start_slice(self.slice['hrn']) + self.cm.start_slice(self.slice_cred, self.slice['hrn']) def testStopSlice(self): - self.cm.stop_slice(self.slice['hrn']) + self.cm.stop_slice(self.slice_cred, self.slice['hrn']) def testDeleteSlice(self): - self.cm.delete_slice(self.slice['hrn']) + self.cm.DeleteSliver(self.slice_cred, self.slice['hrn'],"call-id-delete-slice-cm") def testRestartSlice(self): - self.cm.restart_slice(self.slice['hrn']) + self.cm.restart_slice(self.slice_cred, self.slice['hrn']) def testGetSlices(self): - self.cm.get_slices(self.slice['hrn']) + self.cm.ListSlices(self.slice_cred, self.slice['hrn']) def testRedeemTicket(self): - slice_credential = self.client.get_credential(self.slice['hrn'], 'slice') rspec = self.aggregate.get_resources(self.credential) - ticket = self.aggregate.get_ticket(slice_credential, self.slice['hrn'], rspec) - self.cm.redeem_ticket(slice_credential, ticket) + ticket = self.aggregate.get_ticket(slice_cred, self.slice['hrn'], rspec) + self.cm.redeem_ticket(slice_cred, ticket) def test_names(testcase): return [name for name in dir(testcase) if name.startswith('test')] + +def CreateSliver(client): + # register a slice that will be used for some test + authority = get_authority(client.hrn) + auth_cred = client.get_credential(authority, 'authority') + slice_record = {'hrn': ".".join([authority, random_string(10)]), + 'type': 'slice', 'researcher': [client.hrn]} + client.registry.register(auth_cred, slice_record) + return slice_record +def DeleteSliver(client, slice): + authority = get_authority(client.hrn) + auth_cred = client.get_credential(authority, 'authority') + if slice: + client.registry.remove(auth_cred, 'slice', slice['hrn']) + if __name__ == '__main__': args = sys.argv @@ -277,8 +290,12 @@ if __name__ == '__main__': options, args = parser.parse_args() suite = unittest.TestSuite() client = Client(options) - # bootstrap the users credential - client.get_credential() + test_slice = {} + + # create the test slice if necessary + if options.all or options.slicemgr or options.aggregate \ + or options.component: + test_slice = CreateSliver(client) if options.registry or options.all: for name in test_names(RegistryTest): @@ -286,15 +303,18 @@ if __name__ == '__main__': if options.aggregate or options.all: for name in test_names(AggregateTest): - suite.addTest(AggregateTest(name, client)) + suite.addTest(AggregateTest(name, client, test_slice)) if options.slicemgr or options.all: for name in test_names(SlicemgrTest): - suite.addTest(SlicemgrTest(name, client)) + suite.addTest(SlicemgrTest(name, client, test_slice)) if options.component or options.all: for name in test_names(ComponentTest): - suite.addTest(ComponentTest(name, client)) - + suite.addTest(ComponentTest(name, client, test_slice)) + + # run tests unittest.TextTestRunner(verbosity=2).run(suite) + # remove teset slice + DeleteSliver(client, test_slice)