def __init__(self, params, options):
self.params = utils_params.Params(params)
self.bindir = data_dir.get_root_dir()
self.virtdir = os.path.join(self.bindir, 'shared')
self.builddir = os.path.join(self.bindir, 'backends', params.get("vm_type"))
self.srcdir = os.path.join(self.builddir, 'src')
if not os.path.isdir(self.srcdir):
os.makedirs(self.srcdir)
self.tmpdir = os.path.join(self.bindir, 'tmp')
if not os.path.isdir(self.tmpdir):
os.makedirs(self.tmpdir)
self.iteration = 0
if options.vt_config:
self.tag = params.get("shortname")
else:
self.tag = params.get("_short_name_map_file")["subtests.cfg"]
self.debugdir = None
self.outputdir = None
self.resultsdir = None
self.logfile = None
self.file_handler = None
self.background_errors = Queue.Queue()
def init_modules():
params = utils_params.Params('utils_modules')
modules_file = params.get('test_scenarios')
for file in modules_file:
common_dir = os.path.abspath(os.path.join(BASE_FILE, file))
#print common_dir
sys.path.extend([common_dir])
def __init__(self, params, options):
self.params = utils_params.Params(params)
self.bindir = data_dir.get_root_dir()
self.testdir = os.path.join(self.bindir, 'tests')
self.virtdir = os.path.join(self.bindir, 'shared')
self.builddir = os.path.join(self.bindir, params.get("vm_type"))
self.srcdir = os.path.join(self.builddir, 'src')
if not os.path.isdir(self.srcdir):
os.makedirs(self.srcdir)
self.tmpdir = os.path.join(self.bindir, 'tmp')
if not os.path.isdir(self.tmpdir):
os.makedirs(self.tmpdir)
self.iteration = 0
if options.config is None and options.type in TEST_TYPES_STRIP_NAMES:
self.tag = ".".join(params['name'].split(".")[12:])
else:
self.tag = ".".join(params['shortname'].split("."))
self.debugdir = None
self.outputdir = None
self.resultsdir = None
self.logfile = None
self.file_handler = None
self.background_errors = Queue.Queue()
def test_04_VirtNet(self):
"""
Populate database with max - 1 mac addresses
"""
try:
os.unlink(self.db_filename)
except OSError:
pass
self.zero_counter(25)
# setup() method already set LASTBYTE to '-1'
for lastbyte in xrange(0, 0xFF):
# test_07_VirtNet demands last byte in name and mac match
vm_name = "vm%d" % lastbyte
if lastbyte < 16:
mac = "%s0%x" % (self.mac_prefix, lastbyte)
else:
mac = "%s%x" % (self.mac_prefix, lastbyte)
params = utils_params.Params({
"nics": "nic1",
"vms": vm_name,
"mac_nic1": mac,
})
virtnet = utils_net.VirtNet(params, vm_name,
vm_name, self.db_filename)
virtnet.mac_prefix = self.mac_prefix
self.assertEqual(virtnet['nic1'].mac, mac)
self.assertEqual(virtnet.get_mac_address(0), mac)
# Confirm only lower-case macs are stored
self.assertEqual(virtnet.get_mac_address(0).lower(),
virtnet.get_mac_address(0))
self.assertEqual(virtnet.mac_list(), [mac])
self.print_and_inc()
def setup_modules(require_id):
init_modules()
params = utils_params.Params(require_id)
params.build_dict_from_yaml()
test_modules = {}
for t_type in params.get('test_cases'):
# Load the test module
f, p, d = imp.find_module(t_type)
test_modules[t_type] = imp.load_module(t_type, f, p, d)
f.close()
return test_modules
def test_07_VirtNet(self):
"""
Release mac from beginning, midle, and end, re-generate + verify value
"""
self.zero_counter(1)
beginning_params = utils_params.Params({
"nics": "nic1 nic2",
"vms": "vm0"
})
middle_params = utils_params.Params({
"nics": "nic1 nic2",
"vms": "vm127"
})
end_params = utils_params.Params({
"nics": "nic1 nic2",
"vms": "vm255",
})
for params in (beginning_params, middle_params, end_params):
vm_name = params['vms']
virtnet = utils_net.VirtNet(params, vm_name,
vm_name, self.db_filename)
virtnet.mac_prefix = self.mac_prefix
iface = virtnet['nic1']
last_db_mac_byte = iface.mac_str_to_int_list(iface.mac)[-1]
last_vm_name_byte = int(vm_name[2:])
# Sequential generation from test_04_VirtNet guarantee
self.assertEqual(last_db_mac_byte, last_vm_name_byte)
# only try 300 times, guarantees LASTBYTE counter will loop once
self.assertRaises(
utils_net.NetError, virtnet.generate_mac_address, 1, 300)
virtnet.free_mac_address(0)
virtnet.free_mac_address(1)
# generate new on nic1 to verify mac_index generator catches it
# and to signify database updated after generation
virtnet.generate_mac_address(1, 300)
last_db_mac_byte = virtnet['nic2'].mac_str_to_int_list(
virtnet['nic2'].mac)[-1]
self.assertEqual(last_db_mac_byte, last_vm_name_byte)
self.assertEqual(virtnet.get_mac_address(1), virtnet[1].mac)
self.print_and_inc()
def test_register_vm(self):
"""
1) Create an env object.
2) Create a VM and register it from env.
3) Get the vm back from the env.
4) Verify that the 2 objects are the same.
"""
env = utils_env.Env()
params = utils_params.Params({"main_vm": 'rhel7-migration'})
vm1 = FakeVm(params['main_vm'], params)
vm1.is_alive()
env.register_vm(params['main_vm'], vm1)
vm2 = env.get_vm(params['main_vm'])
vm2.is_alive()
assert vm1 == vm2
def test_06_VirtNet(self):
"""
Generate last possibly mac and verify value.
DEPENDS ON test_05_VirtNet running first
"""
self.zero_counter(25)
# test two nics, second mac generation should fail (pool exhausted)
params = utils_params.Params({"nics": "nic1 nic2", "vms": "vm255"})
virtnet = utils_net.VirtNet(params, 'vm255', 'vm255', self.db_filename)
virtnet.mac_prefix = self.mac_prefix
self.assertRaises(AttributeError, virtnet.get_mac_address, 'nic1')
mac = "%s%x" % (self.mac_prefix, 255)
# This will grab the last available address
# only try 300 times, guarantees LASTBYTE counter will loop once
self.assertEqual(virtnet.generate_mac_address(0, 300), mac)
# This will fail allocation
self.assertRaises(utils_net.NetError, virtnet.generate_mac_address, 1,
300)
def test_unregister_vm(self):
"""
1) Create an env object.
2) Register 2 vms to the env.
3) Verify both vms are in the env.
4) Remove one of those vms.
5) Verify that the removed vm is no longer in env.
"""
env = utils_env.Env()
params = utils_params.Params({"main_vm": 'rhel7-migration'})
vm1 = FakeVm(params['main_vm'], params)
vm1.is_alive()
vm2 = FakeVm('vm2', params)
vm2.is_alive()
env.register_vm(params['main_vm'], vm1)
env.register_vm('vm2', vm2)
assert vm1 in env.get_all_vms()
assert vm2 in env.get_all_vms()
env.unregister_vm('vm2')
assert vm1 in env.get_all_vms()
assert vm2 not in env.get_all_vms()
def test_get_all_vms(self):
"""
1) Create an env object.
2) Create 2 vms and register them in the env.
3) Create a SyncListenServer and register it in the env.
4) Verify that the 2 vms are in the output of get_all_vms.
5) Verify that the sync server is not in the output of get_all_vms.
"""
env = utils_env.Env()
params = utils_params.Params({"main_vm": 'rhel7-migration'})
vm1 = FakeVm(params['main_vm'], params)
vm1.is_alive()
vm2 = FakeVm('vm2', params)
vm2.is_alive()
env.register_vm(params['main_vm'], vm1)
env.register_vm('vm2', vm2)
sync1 = FakeSyncListenServer(port=333)
env.register_syncserver(333, sync1)
assert vm1 in env.get_all_vms()
assert vm2 in env.get_all_vms()
assert sync1 not in env.get_all_vms()
def test_05_VirtNet(self):
"""
Load max - 1 entries from db, overriding params.
DEPENDS ON test_04_VirtNet running first
"""
self.zero_counter(25)
# second loop forces db load from disk
# also confirming params merge with db data
for lastbyte in xrange(0, 0xFF):
vm_name = "vm%d" % lastbyte
params = utils_params.Params({"nics": "nic1", "vms": vm_name})
virtnet = utils_net.VirtNet(params, vm_name, vm_name,
self.db_filename)
if lastbyte < 16:
mac = "%s0%x" % (self.mac_prefix, lastbyte)
else:
mac = "%s%x" % (self.mac_prefix, lastbyte)
self.assertEqual(virtnet['nic1'].mac, mac)
self.assertEqual(virtnet.get_mac_address(0), mac)
self.print_and_inc()
def test_save(self):
"""
1) Verify that calling env.save() with no filename where env doesn't
specify a filename will throw an EnvSaveError.
2) Register a VM in environment, save env to a file, recover env from
that file, get the vm and verify that the instance attribute of the
2 objects is the same.
3) Register a SyncListenServer and don't save env. Restore env from
file and try to get the syncserver, verify it doesn't work.
4) Now save env to a file, restore env from file and verify that
the syncserver can be found there, and that the sync server
instance attribute is equal to the initial sync server instance.
"""
fname = "/dev/shm/EnvUnittest"
env = utils_env.Env()
self.assertRaises(utils_env.EnvSaveError, env.save, {})
params = utils_params.Params({"main_vm": 'rhel7-migration'})
vm1 = FakeVm(params['main_vm'], params)
vm1.is_alive()
env.register_vm(params['main_vm'], vm1)
env.save(filename=fname)
env2 = utils_env.Env(filename=fname)
vm2 = env2.get_vm(params['main_vm'])
vm2.is_alive()
assert vm1.instance == vm2.instance
sync1 = FakeSyncListenServer(port=222)
env.register_syncserver(222, sync1)
env3 = utils_env.Env(filename=fname)
syncnone = env3.get_syncserver(222)
assert syncnone is None
env.save(filename=fname)
env4 = utils_env.Env(filename=fname)
sync2 = env4.get_syncserver(222)
assert sync2.instance == sync1.instance
if os.path.isfile(fname):
os.unlink(fname)
def test_cmp_Virtnet(self):
self.zero_counter()
to_test = 600 # Random generator slows this test way down
for fakevm1 in self.fakevm_generator():
to_test -= 1
if to_test < 1:
break
fvm1p = fakevm1.get_params()
fakevm1.virtnet = utils_net.VirtNet(fvm1p, fakevm1.name,
fakevm1.instance,
self.db_filename)
if len(fakevm1.virtnet) < 2:
continue
fakevm2 = FakeVm(fakevm1.name + "_2", fvm1p)
fakevm2.virtnet = utils_net.VirtNet(fvm1p, fakevm2.name,
fakevm2.instance,
self.db_filename)
# Verify nic order doesn't matter
fvm3p = utils_params.Params(fvm1p.items()) # work on copy
nic_list = fvm1p.object_params(fakevm1.name).get(
"nics", fvm1p.get('nics', "")).split()
random.shuffle(nic_list)
fvm3p['nics'] = " ".join(nic_list)
fakevm3 = FakeVm(fakevm1.name + "_3", fvm3p)
fakevm3.virtnet = utils_net.VirtNet(fvm3p, fakevm3.name,
fakevm3.instance,
self.db_filename)
self.assertTrue(fakevm1.virtnet == fakevm1.virtnet)
self.assertTrue(fakevm1.virtnet == fakevm2.virtnet)
self.assertTrue(fakevm1.virtnet == fakevm3.virtnet)
self.assertTrue(fakevm2.virtnet == fakevm3.virtnet)
if len(fakevm1.virtnet) > 1:
del fakevm1.virtnet[0]
self.assertFalse(fakevm1.virtnet == fakevm2.virtnet)
self.assertFalse(fakevm1.virtnet == fakevm3.virtnet)
self.assertTrue(fakevm1.virtnet != fakevm2.virtnet)
self.assertTrue(fakevm1.virtnet != fakevm3.virtnet)
self.print_and_inc()
def setUp(self):
"""
Runs before every test
"""
logging.disable(logging.INFO)
logging.disable(logging.WARNING)
# MAC generator produces from incrementing byte list
# at random starting point (class property).
# make sure it starts counting at zero before every test
utils_net.VirtIface.LASTBYTE = -1
# These warnings are annoying during testing
utils_net.VMNet.DISCARD_WARNINGS - 1
parser = cartesian_config.Parser()
parser.parse_string(self.nettests_cartesian)
self.CartesianResult = []
for d in parser.get_dicts():
params = utils_params.Params(d)
self.CartesianResult.append(params)
for vm_name in params.objects('vms'):
vm = params.object_params(vm_name)
nics = vm.get('nics')
if nics and len(nics.split()) > 0:
self.db_item_count += 1
def __init__(self, params, options):
self.params = utils_params.Params(params)
self.bindir = data_dir.get_root_dir()
self.testdir = os.path.join(self.bindir, 'tests')
self.virtdir = os.path.join(self.bindir, 'shared')
self.builddir = os.path.join(self.bindir, params.get("vm_type"))
self.srcdir = os.path.join(self.builddir, 'src')
if not os.path.isdir(self.srcdir):
os.makedirs(self.srcdir)
self.tmpdir = os.path.join(self.bindir, 'tmp')
if not os.path.isdir(self.tmpdir):
os.makedirs(self.tmpdir)
self.iteration = 0
tag_index = get_tag_index(options, params)
self.tag = get_tag(params, tag_index)
self.debugdir = None
self.outputdir = None
self.resultsdir = None
self.logfile = None
self.file_handler = None
self.background_errors = Queue.Queue()
def __init__(self, params, options):
self.params = utils_params.Params(params)
#ting test
#sys.stdout.restore()
#print "Test params class : ",self.params.__class__,"\n\n"
#print "Test params : ",self.params,"\n\n"
#end test
self.bindir = data_dir.get_root_dir()
self.testdir = os.path.join(self.bindir, 'tests')
self.virtdir = os.path.join(self.bindir, 'shared')
self.builddir = os.path.join(self.bindir, params.get("vm_type"))
self.srcdir = os.path.join(self.builddir, 'src')
if not os.path.isdir(self.srcdir):
os.makedirs(self.srcdir)
self.tmpdir = os.path.join(self.bindir, 'tmp')
if not os.path.isdir(self.tmpdir):
os.makedirs(self.tmpdir)
self.iteration = 0
tag_index = get_tag_index(options, params)
self.tag = get_tag(params, tag_index)
#ting test
#sys.stdout.restore()
#print "Test self.params",self.params,"\n\n\n"
#print "tag_index: ",tag_index,"\n\n\n"
#print "self.tag: ",self.tag,"\n\n\n"
#end test
self.debugdir = None
self.outputdir = None
self.resultsdir = None
self.logfile = None
self.file_handler = None
self.background_errors = Queue.Queue()
def setUp(self):
self.params = utils_params.Params(BASE_DICT)
import utils_params
import runner
import utils_log
from utils_options import Options
if __name__ == "__main__":
test_modules = {}
requirement_id = ''
case_list = []
options = Options()
if options.has_key('--test_requirement') \
and options.options['--test_requirement']:
requirement_id = options.options['--test_requirement']
else:
print("Please Check the command again.")
options.usage()
sys.exit(1)
if options.has_key('--test_cases') and options.options['--test_cases']:
case_list = options.options['--test_cases'].split(",")
params = utils_params.Params(requirement_id, case_list)
log_dir = utils_log.create_log_file(requirement_id)
params.get('log_dir', log_dir)
options.set_pramas(params)
params.convert_variables()
runner = runner.CaseRunner(params)
runner.main_run()
