def _clean_all(self): """ Cleans all disks and machines """ machine = TestMachine() prefix = '{0}_{1}_'.format(DataObject.NAMESPACE, machine._classname) keys = self.persistent.prefix(prefix) for key in keys: try: guid = key.replace(prefix, '') machine = TestMachine(guid) for disk in machine.disks: disk.delete() machine.delete() except (ObjectNotFoundException, ValueError): pass for prefix in ['ovs_reverseindex_{0}', 'ovs_unique_{0}', 'ovs_index_{0}']: for key in self.persistent.prefix(prefix.format(machine._classname)): self.persistent.delete(key) disk = TestDisk() prefix = '{0}_{1}_'.format(DataObject.NAMESPACE, disk._classname) keys = self.persistent.prefix(prefix) for key in keys: try: guid = key.replace(prefix, '') disk = TestDisk(guid) disk.delete() except (ObjectNotFoundException, ValueError): pass for prefix in ['ovs_reverseindex_{0}', 'ovs_unique_{0}', 'ovs_index_{0}']: for key in self.persistent.prefix(prefix.format(disk._classname)): self.persistent.delete(key)
def _clean_all(self): """ Cleans all disks and machines """ machine = TestMachine() keys = DataList.get_pks(machine._namespace, machine._classname) for guid in keys: try: machine = TestMachine(guid) for disk in machine.disks: disk.delete() machine.delete() except (ObjectNotFoundException, ValueError): pass disk = TestDisk() keys = DataList.get_pks(disk._namespace, disk._classname) for guid in keys: try: disk = TestDisk(guid) disk.delete() except (ObjectNotFoundException, ValueError): pass
def test_lotsofobjects(self): """ A test creating, linking and querying a lot of objects """ print '' print 'cleaning up' self._clean_all() print 'preparing' if getattr(LotsOfObjects, 'amount_of_machines', None) is None: LotsOfObjects.amount_of_machines = 50 else: LotsOfObjects.amount_of_machines = int(LotsOfObjects.amount_of_machines) if getattr(LotsOfObjects, 'amount_of_disks', None) is None: LotsOfObjects.amount_of_disks = 5 else: LotsOfObjects.amount_of_disks = int(LotsOfObjects.amount_of_disks) if getattr(LotsOfObjects, 'repetition_scan', None) is None: LotsOfObjects.repetition_scan = 32 else: LotsOfObjects.repetition_scan = int(LotsOfObjects.repetition_scan) total_amount_of_disks = LotsOfObjects.amount_of_machines * LotsOfObjects.amount_of_disks mguids = [] uuids = [str(uuid.uuid4()) for _ in xrange(total_amount_of_disks)] counter = 0 repetition = [] for i in xrange(LotsOfObjects.repetition_scan): repetition.append([]) dguids = [] print 'start test' tstart = time.time() print '\nstart loading data' start = time.time() runtimes = [] for i in xrange(LotsOfObjects.amount_of_machines): mstart = time.time() machine = TestMachine() machine.name = 'machine_{0}'.format(i) machine.save() mguids.append(machine.guid) for ii in xrange(LotsOfObjects.amount_of_disks): current_uuid = uuids[counter] disk = TestDisk() disk.name = 'disk_{0}_{1}'.format(i, ii) disk.description = 'disk_{0}'.format(i) disk.size = ii * 100 disk.machine = machine disk.something = current_uuid disk.save() dguids.append(disk.guid) random.choice(repetition).append(current_uuid) counter += 1 avgitemspersec = ((i + 1) * LotsOfObjects.amount_of_disks) / (time.time() - start) itemspersec = LotsOfObjects.amount_of_disks / (time.time() - mstart) runtimes.append(itemspersec) LotsOfObjects._print_progress('* machine {0}/{1} (run: {2:.2f} dps, avg: {3:.2f} dps)'.format(i + 1, LotsOfObjects.amount_of_machines, itemspersec, avgitemspersec)) runtimes.sort() print '\nloading done ({0:.2f}s). min: {1:.2f} dps, max: {2:.2f} dps'.format(time.time() - tstart, runtimes[1], runtimes[-2]) test_queries = True if test_queries: print '\nstart queries' start = time.time() runtimes = [] for i in xrange(LotsOfObjects.amount_of_machines): mstart = time.time() machine = TestMachine(mguids[i]) assert len(machine.disks) == LotsOfObjects.amount_of_disks, 'Not all disks were retrieved ({0})'.format(len(machine.disks)) avgitemspersec = ((i + 1) * LotsOfObjects.amount_of_disks) / (time.time() - start) itemspersec = LotsOfObjects.amount_of_disks / (time.time() - mstart) runtimes.append(itemspersec) LotsOfObjects._print_progress('* machine {0}/{1} (run: {2:.2f} dps, avg: {3:.2f} dps)'.format(i + 1, LotsOfObjects.amount_of_machines, itemspersec, avgitemspersec)) runtimes.sort() print '\ncompleted ({0:.2f}s). min: {1:.2f} dps, max: {2:.2f} dps'.format(time.time() - tstart, runtimes[1], runtimes[-2]) print '\nstart full query on disk property' start = time.time() dlist = DataList(TestDisk, {'type': DataList.where_operator.AND, 'items': [('size', DataList.operator.GT, 100), ('size', DataList.operator.LT, (LotsOfObjects.amount_of_disks - 1) * 100)]}) amount = len(dlist) assert amount == (max(0, LotsOfObjects.amount_of_disks - 3)) * LotsOfObjects.amount_of_machines, 'Incorrect amount of disks. Found {0} instead of {1}'.format(amount, int((max(0, LotsOfObjects.amount_of_disks - 3)) * LotsOfObjects.amount_of_machines)) seconds_passed = time.time() - start print 'completed ({0:.2f}s) in {1:.2f} seconds (avg: {2:.2f} dps)'.format(time.time() - tstart, seconds_passed, total_amount_of_disks / seconds_passed) print '\nloading disks (all)' start = time.time() for i in xrange(LotsOfObjects.amount_of_machines): machine = TestMachine(mguids[i]) _ = [_ for _ in machine.disks] seconds_passed = time.time() - start print 'completed ({0:.2f}s) in {1:.2f} seconds (avg: {2:.2f} dps)'.format(time.time() - tstart, seconds_passed, total_amount_of_disks / seconds_passed) print '\nstart full query on disk property (using cached objects)' dlist._volatile.delete(dlist._key) start = time.time() dlist = DataList(TestDisk, {'type': DataList.where_operator.AND, 'items': [('size', DataList.operator.GT, 100), ('size', DataList.operator.LT, (LotsOfObjects.amount_of_disks - 1) * 100)]}) amount = len(dlist) assert amount == (max(0, LotsOfObjects.amount_of_disks - 3)) * LotsOfObjects.amount_of_machines, 'Incorrect amount of disks. Found {0} instead of {1}'.format(amount, int((max(0, LotsOfObjects.amount_of_disks - 3)) * LotsOfObjects.amount_of_machines)) seconds_passed = time.time() - start print 'completed ({0:.2f}s) in {1:.2f} seconds (avg: {2:.2f} dps)'.format(time.time() - tstart, seconds_passed, total_amount_of_disks / seconds_passed) print '\nindexed single query' dlist = DataList(TestDisk, {'type': DataList.where_operator.AND, 'items': [('something', DataList.operator.EQUALS, repetition[0][0])]}) start = time.time() assert len(dlist) == 1, 'One disk should be found' seconds_passed = time.time() - start print 'completed ({0:.2f}s) in {1:.3f} seconds (avg: {2:.2f} dps)'.format(time.time() - tstart, seconds_passed, total_amount_of_disks / seconds_passed) print '\nstart property sort' dlist = DataList(TestDisk, {'type': DataList.where_operator.AND, 'items': []}) start = time.time() dlist.sort(key=lambda a: DalToolbox.extract_key(a, 'size')) seconds_passed = time.time() - start print 'completed ({0:.2f}s) in {1:.2f} seconds (avg: {2:.2f} dps)'.format(time.time() - tstart, seconds_passed, total_amount_of_disks / seconds_passed) print '\nstart dynamic sort' dlist._volatile.delete(dlist._key) dlist = DataList(TestDisk, {'type': DataList.where_operator.AND, 'items': []}) start = time.time() dlist.sort(key=lambda a: DalToolbox.extract_key(a, 'predictable')) seconds_passed = time.time() - start print 'completed ({0:.2f}s) in {1:.2f} seconds (avg: {2:.2f} dps)'.format(time.time() - tstart, seconds_passed, total_amount_of_disks / seconds_passed) print '\nrepetition scan' start = time.time() times = [] for i in xrange(LotsOfObjects.repetition_scan): dlist = DataList(TestDisk, {'type': DataList.where_operator.AND, 'items': [('something', DataList.operator.IN, repetition[i])]}) run_start = time.time() assert len(repetition[i]) == len(dlist), 'Incorrect amount of found disks. Found {0} instead of {1}'.format(len(dlist), len(repetition[i])) times.append(time.time() - run_start) seconds_passed = time.time() - start print 'completed ({0:.2f}s) in {1:.2f} seconds (run avg: {2:.3f}s, avg: {3:.2f} dps)'.format(time.time() - tstart, seconds_passed, sum(times) / float(LotsOfObjects.repetition_scan), LotsOfObjects.repetition_scan * total_amount_of_disks / seconds_passed) print '\nguid index query' start = time.time() guids = dguids[len(dguids)/2:] dlist = DataList(TestDisk, {'type': DataList.where_operator.AND, 'items': [('guid', DataList.operator.IN, guids)]}) assert len(dlist) == len(guids), 'Incorrect amount of found disks. Found {0} instead of {1}'.format(len(dlist), len(guids)) seconds_passed = time.time() - start print 'completed ({0:.2f}s) in {1:.2f} seconds (avg: {2:.2f} dps)'.format(time.time() - tstart, seconds_passed, total_amount_of_disks / seconds_passed) clean_data = True if clean_data: print '\ncleaning up' start = time.time() runtimes = [] for i in xrange(0, int(LotsOfObjects.amount_of_machines)): mstart = time.time() machine = TestMachine(mguids[i]) for disk in machine.disks: disk.delete() machine.delete() avgitemspersec = ((i + 1) * LotsOfObjects.amount_of_disks) / (time.time() - start) itemspersec = LotsOfObjects.amount_of_disks / (time.time() - mstart) runtimes.append(itemspersec) LotsOfObjects._print_progress('* machine {0}/{1} (run: {2:.2f} dps, avg: {3:.2f} dps)'.format(i + 1, LotsOfObjects.amount_of_machines, itemspersec, avgitemspersec)) runtimes.sort() print '\ncompleted ({0:.2f}s). min: {1:.2f} dps, max: {2:.2f} dps'.format(time.time() - tstart, runtimes[1], runtimes[-2])
def test_pk_stretching(self): """ Validates whether the primary key lists scale correctly. * X entries will be added (e.g. 10000) * X/2 random entries will be deleted (5000) * X/2 entries will be added again (5000) * X entries will be removed (10000) No entries should be remaining """ print '' print 'starting test' amount_of_objects = 10000 # Must be an even number! machine = TestMachine() runtimes = [] # First fill start = time.time() keys = DataList._get_pks(machine._namespace, machine._name) self.assertEqual( len(list(keys)), 0, 'There should be no primary keys yet ({0})'.format( len(list(keys)))) guids = [] mstart = time.time() for i in xrange(0, amount_of_objects): guid = str(uuid.uuid4()) guids.append(guid) DataList.add_pk(machine._namespace, machine._name, guid) keys = DataList._get_pks(machine._namespace, machine._name) self.assertEqual( len(list(keys)), len(guids), 'There should be {0} primary keys instead of {1}'.format( len(guids), len(list(keys)))) if i % 100 == 99: avgitemspersec = (i + 1) / (time.time() - start) itemspersec = 100 / (time.time() - mstart) runtimes.append(itemspersec) self._print_progress( '* adding object {0}/{1} (run: {2} ops, avg: {3} ops)'. format(i + 1, int(amount_of_objects), round(itemspersec, 2), round(avgitemspersec, 2))) mstart = time.time() print '' # First delete amount_of_objects /= 2 shuffle(guids) # Make the test a bit more realistic guids_copy = guids[:] dstart = time.time() mstart = time.time() for i in xrange(0, amount_of_objects): guid = guids_copy[i] guids.remove(guid) DataList.delete_pk(machine._namespace, machine._name, guid) keys = DataList._get_pks(machine._namespace, machine._name) self.assertEqual( len(list(keys)), len(guids), 'There should be {0} primary keys instead of {1}'.format( len(guids), len(list(keys)))) if i % 100 == 99: avgitemspersec = (i + 1) / (time.time() - dstart) itemspersec = 100 / (time.time() - mstart) runtimes.append(itemspersec) self._print_progress( '* delete object {0}/{1} (run: {2} ops, avg: {3} ops)'. format(i + 1, int(amount_of_objects), round(itemspersec, 2), round(avgitemspersec, 2))) mstart = time.time() keys = DataList._get_pks(machine._namespace, machine._name) self.assertEqual( len(list(keys)), amount_of_objects, 'There should be {0} primary keys ({1})'.format( amount_of_objects, len(list(keys)))) print '' # Second round sstart = time.time() mstart = time.time() for i in xrange(0, amount_of_objects): guid = str(uuid.uuid4()) guids.append(guid) DataList.add_pk(machine._namespace, machine._name, guid) keys = DataList._get_pks(machine._namespace, machine._name) self.assertEqual( len(list(keys)), len(guids), 'There should be {0} primary keys instead of {1}'.format( len(guids), len(list(keys)))) if i % 100 == 99: avgitemspersec = (i + 1) / (time.time() - sstart) itemspersec = 100 / (time.time() - mstart) runtimes.append(itemspersec) self._print_progress( '* adding object {0}/{1} (run: {2} ops, avg: {3} ops)'. format(i + 1, int(amount_of_objects), round(itemspersec, 2), round(avgitemspersec, 2))) mstart = time.time() print '' # Second delete amount_of_objects *= 2 shuffle(guids) # Make the test a bit more realistic guids_copy = guids[:] dstart = time.time() mstart = time.time() for i in xrange(0, amount_of_objects): guid = guids_copy[i] guids.remove(guid) DataList.delete_pk(machine._namespace, machine._name, guid) keys = DataList._get_pks(machine._namespace, machine._name) self.assertEqual( len(list(keys)), len(guids), 'There should be {0} primary keys instead of {1}'.format( len(guids), len(list(keys)))) if i % 100 == 99: avgitemspersec = (i + 1) / (time.time() - dstart) itemspersec = 100 / (time.time() - mstart) runtimes.append(itemspersec) self._print_progress( '* delete object {0}/{1} (run: {2} ops, avg: {3} ops)'. format(i + 1, int(amount_of_objects), round(itemspersec, 2), round(avgitemspersec, 2))) mstart = time.time() keys = DataList._get_pks(machine._namespace, machine._name) self.assertEqual( len(guids), 0, 'All guids should be removed. {0} left'.format(len(guids))) self.assertEqual( len(list(keys)), 0, 'There should be no primary keys ({0})'.format(len(list(keys)))) seconds_passed = (time.time() - start) runtimes.sort() print '\ncompleted in {0} seconds (avg: {1} ops, min: {2} ops, max: {3} ops)'.format( round(seconds_passed, 2), round((amount_of_objects * 3) / seconds_passed, 2), round(runtimes[1], 2), round(runtimes[-2], 2))
def test_lotsofobjects(self): """ A test creating, linking and querying a lot of objects """ print '' print 'cleaning up' self._clean_all() print 'start test' tstart = time.time() if getattr(LotsOfObjects, 'amount_of_machines', None) is None: LotsOfObjects.amount_of_machines = 50 if getattr(LotsOfObjects, 'amount_of_disks', None) is None: LotsOfObjects.amount_of_disks = 5 load_data = True mguids = [] if load_data: print '\nstart loading data' start = time.time() runtimes = [] for i in xrange(0, int(LotsOfObjects.amount_of_machines)): mstart = time.time() machine = TestMachine() machine.name = 'machine_{0}'.format(i) machine.save() mguids.append(machine.guid) for ii in xrange(0, int(LotsOfObjects.amount_of_disks)): disk = TestDisk() disk.name = 'disk_{0}_{1}'.format(i, ii) disk.size = ii * 100 disk.machine = machine disk.save() avgitemspersec = ((i + 1) * LotsOfObjects.amount_of_disks) / ( time.time() - start) itemspersec = LotsOfObjects.amount_of_disks / (time.time() - mstart) runtimes.append(itemspersec) LotsOfObjects._print_progress( '* machine {0}/{1} (run: {2} dps, avg: {3} dps)'.format( i + 1, int(LotsOfObjects.amount_of_machines), round(itemspersec, 2), round(avgitemspersec, 2))) runtimes.sort() print '\nloading done ({0}s). min: {1} dps, max: {2} dps'.format( round(time.time() - tstart, 2), round(runtimes[1], 2), round(runtimes[-2], 2)) test_queries = True if test_queries: print '\nstart queries' start = time.time() runtimes = [] for i in xrange(0, int(LotsOfObjects.amount_of_machines)): mstart = time.time() machine = TestMachine(mguids[i]) assert len( machine.disks ) == LotsOfObjects.amount_of_disks, 'Not all disks were retrieved ({0})'.format( len(machine.disks)) avgitemspersec = ((i + 1) * LotsOfObjects.amount_of_disks) / ( time.time() - start) itemspersec = LotsOfObjects.amount_of_disks / (time.time() - mstart) runtimes.append(itemspersec) LotsOfObjects._print_progress( '* machine {0}/{1} (run: {2} dps, avg: {3} dps)'.format( i + 1, int(LotsOfObjects.amount_of_machines), round(itemspersec, 2), round(avgitemspersec, 2))) runtimes.sort() print '\ncompleted ({0}s). min: {1} dps, max: {2} dps'.format( round(time.time() - tstart, 2), round(runtimes[1], 2), round(runtimes[-2], 2)) print '\nstart full query on disk property' start = time.time() dlist = DataList( TestDisk, { 'type': DataList.where_operator.AND, 'items': [('size', DataList.operator.GT, 100), ('size', DataList.operator.LT, (LotsOfObjects.amount_of_disks - 1) * 100)] }) amount = len(dlist) assert amount == ( LotsOfObjects.amount_of_disks - 3 ) * LotsOfObjects.amount_of_machines, 'Incorrect amount of disks. Found {0} instead of {1}'.format( amount, int((LotsOfObjects.amount_of_disks - 3) * LotsOfObjects.amount_of_machines)) seconds_passed = (time.time() - start) print 'completed ({0}s) in {1} seconds (avg: {2} dps)'.format( round(time.time() - tstart, 2), round(seconds_passed, 2), round( LotsOfObjects.amount_of_machines * LotsOfObjects.amount_of_disks / seconds_passed, 2)) print '\nloading disks (all)' start = time.time() for i in xrange(0, int(LotsOfObjects.amount_of_machines)): machine = TestMachine(mguids[i]) _ = [_ for _ in machine.disks] seconds_passed = (time.time() - start) print 'completed ({0}s) in {1} seconds (avg: {2} dps)'.format( round(time.time() - tstart, 2), round(seconds_passed, 2), round( LotsOfObjects.amount_of_machines * LotsOfObjects.amount_of_disks / seconds_passed, 2)) print '\nstart full query on disk property (using cached objects)' dlist._volatile.delete(dlist._key) start = time.time() dlist = DataList( TestDisk, { 'type': DataList.where_operator.AND, 'items': [('size', DataList.operator.GT, 100), ('size', DataList.operator.LT, (LotsOfObjects.amount_of_disks - 1) * 100)] }) amount = len(dlist) assert amount == ( LotsOfObjects.amount_of_disks - 3 ) * LotsOfObjects.amount_of_machines, 'Incorrect amount of disks. Found {0} instead of {1}'.format( amount, int((LotsOfObjects.amount_of_disks - 3) * LotsOfObjects.amount_of_machines)) seconds_passed = (time.time() - start) print 'completed ({0}s) in {1} seconds (avg: {2} dps)'.format( round(time.time() - tstart, 2), round(seconds_passed, 2), round( LotsOfObjects.amount_of_machines * LotsOfObjects.amount_of_disks / seconds_passed, 2)) print '\nstart property sort' dlist = DataList(TestDisk, { 'type': DataList.where_operator.AND, 'items': [] }) start = time.time() dlist.sort(key=lambda a: Toolbox.extract_key(a, 'size')) seconds_passed = (time.time() - start) print 'completed ({0}s) in {1} seconds (avg: {2} dps)'.format( round(time.time() - tstart, 2), round(seconds_passed, 2), round( LotsOfObjects.amount_of_machines * LotsOfObjects.amount_of_disks / seconds_passed, 2)) print '\nstart dynamic sort' dlist._volatile.delete(dlist._key) dlist = DataList(TestDisk, { 'type': DataList.where_operator.AND, 'items': [] }) start = time.time() dlist.sort(key=lambda a: Toolbox.extract_key(a, 'predictable')) seconds_passed = (time.time() - start) print 'completed ({0}s) in {1} seconds (avg: {2} dps)'.format( round(time.time() - tstart, 2), round(seconds_passed, 2), round( LotsOfObjects.amount_of_machines * LotsOfObjects.amount_of_disks / seconds_passed, 2)) clean_data = True if clean_data: print '\ncleaning up' start = time.time() runtimes = [] for i in xrange(0, int(LotsOfObjects.amount_of_machines)): mstart = time.time() machine = TestMachine(mguids[i]) for disk in machine.disks: disk.delete() machine.delete() avgitemspersec = ((i + 1) * LotsOfObjects.amount_of_disks) / ( time.time() - start) itemspersec = LotsOfObjects.amount_of_disks / (time.time() - mstart) runtimes.append(itemspersec) LotsOfObjects._print_progress( '* machine {0}/{1} (run: {2} dps, avg: {3} dps)'.format( i + 1, int(LotsOfObjects.amount_of_machines), round(itemspersec, 2), round(avgitemspersec, 2))) runtimes.sort() print '\ncompleted ({0}s). min: {1} dps, max: {2} dps'.format( round(time.time() - tstart, 2), round(runtimes[1], 2), round(runtimes[-2], 2))
def test_lotsofobjects(self): """ A test creating, linking and querying a lot of objects """ print '' print 'cleaning up' self._clean_all() print 'start test' tstart = time.time() if getattr(LotsOfObjects, 'amount_of_machines', None) is None: LotsOfObjects.amount_of_machines = 50 if getattr(LotsOfObjects, 'amount_of_disks', None) is None: LotsOfObjects.amount_of_disks = 5 load_data = True if load_data: print 'start loading data' start = time.time() mguids = [] runtimes = [] for i in xrange(0, int(LotsOfObjects.amount_of_machines)): mstart = time.time() machine = TestMachine() machine.name = 'machine_{0}'.format(i) machine.save() mguids.append(machine.guid) for ii in xrange(0, int(LotsOfObjects.amount_of_disks)): disk = TestDisk() disk.name = 'disk_{0}_{1}'.format(i, ii) disk.size = ii * 100 disk.machine = machine disk.save() avgitemspersec = ((i + 1) * LotsOfObjects.amount_of_disks) / (time.time() - start) itemspersec = LotsOfObjects.amount_of_disks / (time.time() - mstart) runtimes.append(itemspersec) self._print_progress('* machine {0}/{1} (run: {2} dps, avg: {3} dps)'.format(i + 1, int(LotsOfObjects.amount_of_machines), round(itemspersec, 2), round(avgitemspersec, 2))) runtimes.sort() print '\nloading done ({0}s). min: {1} dps, max: {2} dps'.format(round(time.time() - tstart, 2), round(runtimes[1], 2), round(runtimes[-2], 2)) test_queries = True if test_queries: print 'start queries' start = time.time() runtimes = [] for i in xrange(0, int(LotsOfObjects.amount_of_machines)): mstart = time.time() machine = TestMachine(mguids[i]) self.assertEqual(len(machine.disks), LotsOfObjects.amount_of_disks, 'Not all disks were retreived ({0})'.format(len(machine.disks))) avgitemspersec = ((i + 1) * LotsOfObjects.amount_of_disks) / (time.time() - start) itemspersec = LotsOfObjects.amount_of_disks / (time.time() - mstart) runtimes.append(itemspersec) self._print_progress('* machine {0}/{1} (run: {2} dps, avg: {3} dps)'.format(i + 1, int(LotsOfObjects.amount_of_machines), round(itemspersec, 2), round(avgitemspersec, 2))) runtimes.sort() print '\ncompleted ({0}s). min: {1} dps, max: {2} dps'.format(round(time.time() - tstart, 2), round(runtimes[1], 2), round(runtimes[-2], 2)) print 'start full query on disk property' start = time.time() amount = DataList({'object': TestDisk, 'data': DataList.select.COUNT, 'query': {'type': DataList.where_operator.AND, 'items': [('size', DataList.operator.GT, 100), ('size', DataList.operator.LT, (LotsOfObjects.amount_of_disks - 1) * 100)]}}).data self.assertEqual(amount, (LotsOfObjects.amount_of_disks - 3) * LotsOfObjects.amount_of_machines, 'Incorrect amount of disks. Found {0} instead of {1}'.format(amount, int((LotsOfObjects.amount_of_disks - 3) * LotsOfObjects.amount_of_machines))) seconds_passed = (time.time() - start) print 'completed ({0}s) in {1} seconds (avg: {2} dps)'.format(round(time.time() - tstart, 2), round(seconds_passed, 2), round(LotsOfObjects.amount_of_machines * LotsOfObjects.amount_of_disks / seconds_passed, 2)) clean_data = True if clean_data: print 'cleaning up' start = time.time() runtimes = [] for i in xrange(0, int(LotsOfObjects.amount_of_machines)): mstart = time.time() machine = TestMachine(mguids[i]) for disk in machine.disks: disk.delete() machine.delete() avgitemspersec = ((i + 1) * LotsOfObjects.amount_of_disks) / (time.time() - start) itemspersec = LotsOfObjects.amount_of_disks / (time.time() - mstart) runtimes.append(itemspersec) self._print_progress('* machine {0}/{1} (run: {2} dps, avg: {3} dps)'.format(i + 1, int(LotsOfObjects.amount_of_machines), round(itemspersec, 2), round(avgitemspersec, 2))) runtimes.sort() print '\ncompleted ({0}s). min: {1} dps, max: {2} dps'.format(round(time.time() - tstart, 2), round(runtimes[1], 2), round(runtimes[-2], 2))
def setUpClass(cls): """ Sets up the unittest, mocking a certain set of 3rd party libraries and extensions. This makes sure the unittests can be executed without those libraries installed """ DalHelper.setup(fake_sleep=True) admin_group = Group() admin_group.name = 'administrators' admin_group.description = 'Administrators' admin_group.save() viewers_group = Group() viewers_group.name = 'viewers' viewers_group.description = 'Viewers' viewers_group.save() # Create users admin = User() admin.username = '******' admin.password = hashlib.sha256('admin').hexdigest() admin.is_active = True admin.group = admin_group admin.save() admin_npg = User() admin_npg.username = '******' admin_npg.password = hashlib.sha256('admin_npg').hexdigest() admin_npg.is_active = True admin_npg.group = admin_group admin_npg.save() admin_na = User() admin_na.username = '******' admin_na.password = hashlib.sha256('admin_na').hexdigest() admin_na.is_active = False admin_na.group = admin_group admin_na.save() user = User() user.username = '******' user.password = hashlib.sha256('user').hexdigest() user.is_active = True user.group = viewers_group user.save() sort_combinations = [('bb', 'aa'), ('aa', 'cc'), ('bb', 'dd'), ('aa', 'bb')] # No logical ordering for name, description in sort_combinations: machine = TestMachine() machine.name = name machine.description = description machine.save() # Create internal OAuth 2 clients admin_client = Client() admin_client.ovs_type = 'INTERNAL' admin_client.grant_type = 'PASSWORD' admin_client.user = admin admin_client.save() admin_na_client = Client() admin_na_client.ovs_type = 'INTERNAL' admin_na_client.grant_type = 'PASSWORD' admin_na_client.user = admin_na admin_na_client.save() user_client = Client() user_client.ovs_type = 'INTERNAL' user_client.grant_type = 'PASSWORD' user_client.user = user user_client.save() # Create roles read_role = Role() read_role.code = 'read' read_role.name = 'Read' read_role.description = 'Can read objects' read_role.save() write_role = Role() write_role.code = 'write' write_role.name = 'Write' write_role.description = 'Can write objects' write_role.save() manage_role = Role() manage_role.code = 'manage' manage_role.name = 'Manage' manage_role.description = 'Can manage the system' manage_role.save() # Attach groups to roles mapping = [(admin_group, [read_role, write_role, manage_role]), (viewers_group, [read_role])] for setting in mapping: for role in setting[1]: rolegroup = RoleGroup() rolegroup.group = setting[0] rolegroup.role = role rolegroup.save() for user in setting[0].users: for role in setting[1]: for client in user.clients: roleclient = RoleClient() roleclient.client = client roleclient.role = role roleclient.save() from django.conf import settings settings.VERSION = (1, 2, 3) from django.test import RequestFactory cls.factory = RequestFactory()