openkylin
/
virt-manager
mirror of https://gitee.com/openkylin/virt-manager.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

tests: Stop using deprecated assertEquals 

The recommended way is assertEqual
This commit is contained in:
Cole Robinson 2017-05-05 11:39:59 -04:00
parent ebd2f1dcee
commit fcebefd3bb
7 changed files with 74 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
tests/capabilities.py
View File

@ -39,7 +39,7 @@ class TestCapabilities(unittest.TestCase):
caps = self._buildCaps(filename) caps = self._buildCaps(filename)
for f in host_feature_list: for f in host_feature_list:
self.assertEquals(caps.host.cpu.has_feature(f), True) self.assertEqual(caps.host.cpu.has_feature(f), True)
def testCapsCPUFeaturesOldSyntaxSVM(self): def testCapsCPUFeaturesOldSyntaxSVM(self):
filename = "test-old-svm.xml" filename = "test-old-svm.xml"
@ -47,7 +47,7 @@ class TestCapabilities(unittest.TestCase):
caps = self._buildCaps(filename) caps = self._buildCaps(filename)
for f in host_feature_list: for f in host_feature_list:
self.assertEquals(caps.host.cpu.has_feature(f), True) self.assertEqual(caps.host.cpu.has_feature(f), True)
def testCapsCPUFeaturesNewSyntax(self): def testCapsCPUFeaturesNewSyntax(self):
filename = "test-qemu-with-kvm.xml" filename = "test-qemu-with-kvm.xml"
@ -56,13 +56,13 @@ class TestCapabilities(unittest.TestCase):
caps = self._buildCaps(filename) caps = self._buildCaps(filename)
for f in host_feature_list: for f in host_feature_list:
self.assertEquals(caps.host.cpu.has_feature(f), True) self.assertEqual(caps.host.cpu.has_feature(f), True)
self.assertEquals(caps.host.cpu.model, "core2duo") self.assertEqual(caps.host.cpu.model, "core2duo")
self.assertEquals(caps.host.cpu.vendor, "Intel") self.assertEqual(caps.host.cpu.vendor, "Intel")
self.assertEquals(caps.host.cpu.threads, 3) self.assertEqual(caps.host.cpu.threads, 3)
self.assertEquals(caps.host.cpu.cores, 5) self.assertEqual(caps.host.cpu.cores, 5)
self.assertEquals(caps.host.cpu.sockets, 7) self.assertEqual(caps.host.cpu.sockets, 7)
def testCapsUtilFuncs(self): def testCapsUtilFuncs(self):
caps_with_kvm = self._buildCaps("test-qemu-with-kvm.xml") caps_with_kvm = self._buildCaps("test-qemu-with-kvm.xml")
@ -71,8 +71,8 @@ class TestCapabilities(unittest.TestCase):
def test_utils(caps, has_guests, is_kvm): def test_utils(caps, has_guests, is_kvm):
if caps.guests: if caps.guests:
self.assertEquals(caps.guests[0].has_install_options(), has_guests) self.assertEqual(caps.guests[0].has_install_options(), has_guests)
self.assertEquals(caps.guests[0].is_kvm_available(), is_kvm) self.assertEqual(caps.guests[0].is_kvm_available(), is_kvm)
test_utils(caps_empty, False, False) test_utils(caps_empty, False, False)
test_utils(caps_with_kvm, True, True) test_utils(caps_with_kvm, True, True)
@ -80,9 +80,9 @@ class TestCapabilities(unittest.TestCase):
def testCapsNuma(self): def testCapsNuma(self):
cells = self._buildCaps("lxc.xml").host.topology.cells cells = self._buildCaps("lxc.xml").host.topology.cells
self.assertEquals(len(cells), 1) self.assertEqual(len(cells), 1)
self.assertEquals(len(cells[0].cpus), 8) self.assertEqual(len(cells[0].cpus), 8)
self.assertEquals(cells[0].cpus[3].id, '3') self.assertEqual(cells[0].cpus[3].id, '3')
################################################ ################################################
@ -106,7 +106,7 @@ class TestCapabilities(unittest.TestCase):
for c in cpus: for c in cpus:
self.assertTrue(c in cpunames) self.assertTrue(c in cpunames)
self.assertEquals(cpu_64, cpu_32) self.assertEqual(cpu_64, cpu_32)
x86_cpunames = [ x86_cpunames = [
'486', 'athlon', 'Conroe', 'core2duo', 'coreduo', 'n270', '486', 'athlon', 'Conroe', 'core2duo', 'coreduo', 'n270',
@ -136,10 +136,10 @@ class TestCapabilities(unittest.TestCase):
caps = DomainCapabilities(utils.open_testdriver(), xml) caps = DomainCapabilities(utils.open_testdriver(), xml)
self.assertEqual(caps.os.loader.supported, True) self.assertEqual(caps.os.loader.supported, True)
self.assertEquals(caps.os.loader.get_values(), self.assertEqual(caps.os.loader.get_values(),
["/foo/bar", "/tmp/my_path"]) ["/foo/bar", "/tmp/my_path"])
self.assertEquals(caps.os.loader.enum_names(), ["type", "readonly"]) self.assertEqual(caps.os.loader.enum_names(), ["type", "readonly"])
self.assertEquals(caps.os.loader.get_enum("type").get_values(), self.assertEqual(caps.os.loader.get_enum("type").get_values(),
["rom", "pflash"]) ["rom", "pflash"])

2
tests/checkprops.py
View File

@ -22,7 +22,7 @@ class CheckPropsTest(unittest.TestCase):
fail = [p for p in virtinst.xmlbuilder._allprops fail = [p for p in virtinst.xmlbuilder._allprops
if p not in virtinst.xmlbuilder._seenprops] if p not in virtinst.xmlbuilder._seenprops]
try: try:
self.assertEquals([], fail) self.assertEqual([], fail)
except AssertionError: except AssertionError:
msg = "".join(traceback.format_exc()) + "\n\n" msg = "".join(traceback.format_exc()) + "\n\n"
msg += ("This means that there are XML properties that are\n" msg += ("This means that there are XML properties that are\n"

2
tests/uitests/cli.py
View File

@ -32,7 +32,7 @@ class VMMCLI(unittest.TestCase):
win = uiutils.find_pattern(self.app.root, win = uiutils.find_pattern(self.app.root,
"test testdriver.xml Connection Details", "frame") "test testdriver.xml Connection Details", "frame")
self.assertEquals( self.assertEqual(
uiutils.find_fuzzy(win, None, "text", "Name:").text, uiutils.find_fuzzy(win, None, "text", "Name:").text,
"test testdriver.xml") "test testdriver.xml")
self.app.quit() self.app.quit()

6
tests/uitests/newvm.py
View File

@ -92,7 +92,7 @@ class NewVM(unittest.TestCase):
time.sleep(1) time.sleep(1)
self.assertFalse(browser.showing) self.assertFalse(browser.showing)
self.assertEquals( self.assertEqual(
uiutils.find_fuzzy(newvm, "os-version-label", "label").text, uiutils.find_fuzzy(newvm, "os-version-label", "label").text,
"Unknown") "Unknown")
@ -100,7 +100,7 @@ class NewVM(unittest.TestCase):
uiutils.find_fuzzy(newvm, "Automatically detect", "check").click() uiutils.find_fuzzy(newvm, "Automatically detect", "check").click()
version = uiutils.find_fuzzy(newvm, version = uiutils.find_fuzzy(newvm,
"install-os-version-entry", "text") "install-os-version-entry", "text")
self.assertEquals(version.text, "Generic") self.assertEqual(version.text, "Generic")
ostype = uiutils.find_fuzzy(newvm, "install-os-type", "combo") ostype = uiutils.find_fuzzy(newvm, "install-os-type", "combo")
ostype.click() ostype.click()
@ -155,7 +155,7 @@ class NewVM(unittest.TestCase):
version = uiutils.find_pattern(newvm, "install-os-version-label") version = uiutils.find_pattern(newvm, "install-os-version-label")
time.sleep(1) time.sleep(1)
uiutils.check_in_loop(lambda: "Detecting" not in version.text) uiutils.check_in_loop(lambda: "Detecting" not in version.text)
self.assertEquals(version.text, "Red Hat Enterprise Linux 5.5") self.assertEqual(version.text, "Red Hat Enterprise Linux 5.5")
uiutils.find_fuzzy(newvm, "Forward", "button").click() uiutils.find_fuzzy(newvm, "Forward", "button").click()
uiutils.find_fuzzy(newvm, "Forward", "button").click() uiutils.find_fuzzy(newvm, "Forward", "button").click()

20
tests/uriparse.py
View File

@ -29,16 +29,16 @@ class TestURI(unittest.TestCase):
hostname='', query='', fragment='', hostname='', query='', fragment='',
is_ipv6=False, host_is_ipv4_string=False): is_ipv6=False, host_is_ipv4_string=False):
uriinfo = URI(uri) uriinfo = URI(uri)
self.assertEquals(scheme, uriinfo.scheme) self.assertEqual(scheme, uriinfo.scheme)
self.assertEquals(transport, uriinfo.transport) self.assertEqual(transport, uriinfo.transport)
self.assertEquals(port, uriinfo.port) self.assertEqual(port, uriinfo.port)
self.assertEquals(username, uriinfo.username) self.assertEqual(username, uriinfo.username)
self.assertEquals(path, uriinfo.path) self.assertEqual(path, uriinfo.path)
self.assertEquals(hostname, uriinfo.hostname) self.assertEqual(hostname, uriinfo.hostname)
self.assertEquals(query, uriinfo.query) self.assertEqual(query, uriinfo.query)
self.assertEquals(fragment, uriinfo.fragment) self.assertEqual(fragment, uriinfo.fragment)
self.assertEquals(is_ipv6, uriinfo.is_ipv6) self.assertEqual(is_ipv6, uriinfo.is_ipv6)
self.assertEquals(host_is_ipv4_string, uriinfo.host_is_ipv4_string) self.assertEqual(host_is_ipv4_string, uriinfo.host_is_ipv4_string)
def testURIs(self): def testURIs(self):
self._compare("lxc://", scheme="lxc") self._compare("lxc://", scheme="lxc")

66
tests/xmlconfig.py
View File

@ -175,12 +175,12 @@ class TestXMLMisc(unittest.TestCase):
expect = base[:] expect = base[:]
expect[1] = expect[2] = expect[3] = True expect[1] = expect[2] = expect[3] = True
self.assertEquals(tuple(expect), self.assertEqual(tuple(expect),
virtinst.DomainNumatune.cpuset_str_to_tuple(conn, "1-3")) virtinst.DomainNumatune.cpuset_str_to_tuple(conn, "1-3"))
expect = base[:] expect = base[:]
expect[1] = expect[3] = expect[5] = expect[10] = expect[11] = True expect[1] = expect[3] = expect[5] = expect[10] = expect[11] = True
self.assertEquals(tuple(expect), self.assertEqual(tuple(expect),
virtinst.DomainNumatune.cpuset_str_to_tuple(conn, "1,3,5,10-11")) virtinst.DomainNumatune.cpuset_str_to_tuple(conn, "1,3,5,10-11"))
self.assertRaises(ValueError, self.assertRaises(ValueError,
@ -189,40 +189,40 @@ class TestXMLMisc(unittest.TestCase):
def testDiskNumbers(self): def testDiskNumbers(self):
# Various testing our target generation # Various testing our target generation
self.assertEquals("a", VirtualDisk.num_to_target(1)) self.assertEqual("a", VirtualDisk.num_to_target(1))
self.assertEquals("b", VirtualDisk.num_to_target(2)) self.assertEqual("b", VirtualDisk.num_to_target(2))
self.assertEquals("z", VirtualDisk.num_to_target(26)) self.assertEqual("z", VirtualDisk.num_to_target(26))
self.assertEquals("aa", VirtualDisk.num_to_target(27)) self.assertEqual("aa", VirtualDisk.num_to_target(27))
self.assertEquals("ab", VirtualDisk.num_to_target(28)) self.assertEqual("ab", VirtualDisk.num_to_target(28))
self.assertEquals("az", VirtualDisk.num_to_target(52)) self.assertEqual("az", VirtualDisk.num_to_target(52))
self.assertEquals("ba", VirtualDisk.num_to_target(53)) self.assertEqual("ba", VirtualDisk.num_to_target(53))
self.assertEquals("zz", VirtualDisk.num_to_target(27 * 26)) self.assertEqual("zz", VirtualDisk.num_to_target(27 * 26))
self.assertEquals("aaa", VirtualDisk.num_to_target(27 * 26 + 1)) self.assertEqual("aaa", VirtualDisk.num_to_target(27 * 26 + 1))
self.assertEquals(VirtualDisk.target_to_num("hda"), 0) self.assertEqual(VirtualDisk.target_to_num("hda"), 0)
self.assertEquals(VirtualDisk.target_to_num("hdb"), 1) self.assertEqual(VirtualDisk.target_to_num("hdb"), 1)
self.assertEquals(VirtualDisk.target_to_num("sdz"), 25) self.assertEqual(VirtualDisk.target_to_num("sdz"), 25)
self.assertEquals(VirtualDisk.target_to_num("sdaa"), 26) self.assertEqual(VirtualDisk.target_to_num("sdaa"), 26)
self.assertEquals(VirtualDisk.target_to_num("vdab"), 27) self.assertEqual(VirtualDisk.target_to_num("vdab"), 27)
self.assertEquals(VirtualDisk.target_to_num("vdaz"), 51) self.assertEqual(VirtualDisk.target_to_num("vdaz"), 51)
self.assertEquals(VirtualDisk.target_to_num("xvdba"), 52) self.assertEqual(VirtualDisk.target_to_num("xvdba"), 52)
self.assertEquals(VirtualDisk.target_to_num("xvdzz"), self.assertEqual(VirtualDisk.target_to_num("xvdzz"),
26 * (25 + 1) + 25) 26 * (25 + 1) + 25)
self.assertEquals(VirtualDisk.target_to_num("xvdaaa"), self.assertEqual(VirtualDisk.target_to_num("xvdaaa"),
26 * 26 * 1 + 26 * 1 + 0) 26 * 26 * 1 + 26 * 1 + 0)
disk = virtinst.VirtualDisk(_default_conn) disk = virtinst.VirtualDisk(_default_conn)
disk.bus = "ide" disk.bus = "ide"
self.assertEquals("hda", disk.generate_target([])) self.assertEqual("hda", disk.generate_target([]))
self.assertEquals("hdb", disk.generate_target(["hda"])) self.assertEqual("hdb", disk.generate_target(["hda"]))
self.assertEquals("hdc", disk.generate_target(["hdb", "sda"])) self.assertEqual("hdc", disk.generate_target(["hdb", "sda"]))
self.assertEquals("hdb", disk.generate_target(["hda", "hdd"])) self.assertEqual("hdb", disk.generate_target(["hda", "hdd"]))
disk.bus = "virtio-scsi" disk.bus = "virtio-scsi"
self.assertEquals("sdb", self.assertEqual("sdb",
disk.generate_target(["sda", "sdg", "sdi"], 0)) disk.generate_target(["sda", "sdg", "sdi"], 0))
self.assertEquals("sdh", disk.generate_target(["sda", "sdg"], 1)) self.assertEqual("sdh", disk.generate_target(["sda", "sdg"], 1))
def testQuickTreeinfo(self): def testQuickTreeinfo(self):
# Simple sanity test to make sure detect_distro works. test-urls # Simple sanity test to make sure detect_distro works. test-urls
@ -231,38 +231,38 @@ class TestXMLMisc(unittest.TestCase):
location="tests/cli-test-xml/fakefedoratree") location="tests/cli-test-xml/fakefedoratree")
g = _make_guest(i) g = _make_guest(i)
v = i.detect_distro(g) v = i.detect_distro(g)
self.assertEquals(v, "fedora17") self.assertEqual(v, "fedora17")
i = _make_installer( i = _make_installer(
location="tests/cli-test-xml/fakerhel6tree") location="tests/cli-test-xml/fakerhel6tree")
g = _make_guest(i) g = _make_guest(i)
v = i.detect_distro(g) v = i.detect_distro(g)
self.assertEquals(v, "rhel6.0") self.assertEqual(v, "rhel6.0")
def testCPUTopology(self): def testCPUTopology(self):
# Test CPU topology determining # Test CPU topology determining
cpu = virtinst.CPU(_default_conn) cpu = virtinst.CPU(_default_conn)
cpu.sockets = "2" cpu.sockets = "2"
cpu.set_topology_defaults(6) cpu.set_topology_defaults(6)
self.assertEquals([cpu.sockets, cpu.cores, cpu.threads], [2, 3, 1]) self.assertEqual([cpu.sockets, cpu.cores, cpu.threads], [2, 3, 1])
cpu = virtinst.CPU(_default_conn) cpu = virtinst.CPU(_default_conn)
cpu.cores = "4" cpu.cores = "4"
cpu.set_topology_defaults(9) cpu.set_topology_defaults(9)
self.assertEquals([cpu.sockets, cpu.cores, cpu.threads], [2, 4, 1]) self.assertEqual([cpu.sockets, cpu.cores, cpu.threads], [2, 4, 1])
cpu = virtinst.CPU(_default_conn) cpu = virtinst.CPU(_default_conn)
cpu.threads = "3" cpu.threads = "3"
cpu.set_topology_defaults(14) cpu.set_topology_defaults(14)
self.assertEquals([cpu.sockets, cpu.cores, cpu.threads], [4, 1, 3]) self.assertEqual([cpu.sockets, cpu.cores, cpu.threads], [4, 1, 3])
cpu = virtinst.CPU(_default_conn) cpu = virtinst.CPU(_default_conn)
cpu.sockets = 5 cpu.sockets = 5
cpu.cores = 2 cpu.cores = 2
self.assertEquals(cpu.vcpus_from_topology(), 10) self.assertEqual(cpu.vcpus_from_topology(), 10)
cpu = virtinst.CPU(_default_conn) cpu = virtinst.CPU(_default_conn)
self.assertEquals(cpu.vcpus_from_topology(), 1) self.assertEqual(cpu.vcpus_from_topology(), 1)
def testAC97(self): def testAC97(self):
# Test setting ac97 version given various version combos # Test setting ac97 version given various version combos

18
tests/xmlparse.py
View File

@ -72,12 +72,12 @@ class XMLParseTest(unittest.TestCase):
set newval, and make sure it is returned properly set newval, and make sure it is returned properly
""" """
curval = getattr(obj, param) curval = getattr(obj, param)
self.assertEquals(initval, curval) self.assertEqual(initval, curval)
for newval in args: for newval in args:
setattr(obj, param, newval) setattr(obj, param, newval)
curval = getattr(obj, param) curval = getattr(obj, param)
self.assertEquals(newval, curval) self.assertEqual(newval, curval)
def _make_checker(self, obj): def _make_checker(self, obj):
def check(name, initval, *args): def check(name, initval, *args):
@ -181,7 +181,7 @@ class XMLParseTest(unittest.TestCase):
check("policy", "force", "disable") check("policy", "force", "disable")
rmfeat = guest.cpu.features[3] rmfeat = guest.cpu.features[3]
guest.cpu.remove_feature(rmfeat) guest.cpu.remove_feature(rmfeat)
self.assertEquals(rmfeat.get_xml_config(), self.assertEqual(rmfeat.get_xml_config(),
"""<feature name="foo" policy="bar"/>\n""") """<feature name="foo" policy="bar"/>\n""")
guest.cpu.add_feature("addfeature") guest.cpu.add_feature("addfeature")
@ -423,7 +423,7 @@ class XMLParseTest(unittest.TestCase):
"""<target dev="hda" bus="ide"/></disk>\n""") """<target dev="hda" bus="ide"/></disk>\n""")
d = virtinst.VirtualDisk(conn, parsexml=xml) d = virtinst.VirtualDisk(conn, parsexml=xml)
self._set_and_check(d, "target", "hda", "hdb") self._set_and_check(d, "target", "hda", "hdb")
self.assertEquals(xml.replace("hda", "hdb"), d.get_xml_config()) self.assertEqual(xml.replace("hda", "hdb"), d.get_xml_config())
def testAlterChars(self): def testAlterChars(self):
guest, outfile = self._get_test_content("change-chars") guest, outfile = self._get_test_content("change-chars")
@ -1035,8 +1035,8 @@ class XMLParseTest(unittest.TestCase):
outfile = "tests/xmlparse-xml/interface-%s-out.xml" % basename outfile = "tests/xmlparse-xml/interface-%s-out.xml" % basename
iface = virtinst.Interface(conn, parsexml=file(infile).read()) iface = virtinst.Interface(conn, parsexml=file(infile).read())
self.assertEquals(len(iface.protocols), 2) self.assertEqual(len(iface.protocols), 2)
self.assertEquals(len(iface.interfaces), 3) self.assertEqual(len(iface.interfaces), 3)
check = self._make_checker(iface) check = self._make_checker(iface)
check("type", "bridge", "foo", "bridge") check("type", "bridge", "foo", "bridge")
@ -1048,7 +1048,7 @@ class XMLParseTest(unittest.TestCase):
check("family", "ipv4", "foo", "ipv4") check("family", "ipv4", "foo", "ipv4")
check("dhcp_peerdns", True, False) check("dhcp_peerdns", True, False)
check("gateway", "1.2.3.4", "5.5.5.5") check("gateway", "1.2.3.4", "5.5.5.5")
self.assertEquals(iface.protocols[0].ips[1].address, "255.255.255.0") self.assertEqual(iface.protocols[0].ips[1].address, "255.255.255.0")
check = self._make_checker(iface.protocols[1]) check = self._make_checker(iface.protocols[1])
check("dhcp", True, False) check("dhcp", True, False)
@ -1064,7 +1064,7 @@ class XMLParseTest(unittest.TestCase):
check = self._make_checker(child_iface) check = self._make_checker(child_iface)
check("name", "bond-brbond") check("name", "bond-brbond")
self.assertEquals(len(child_iface.interfaces), 2) self.assertEqual(len(child_iface.interfaces), 2)
utils.diff_compare(iface.get_xml_config(), outfile) utils.diff_compare(iface.get_xml_config(), outfile)
utils.test_create(conn, iface.get_xml_config(), "interfaceDefineXML") utils.test_create(conn, iface.get_xml_config(), "interfaceDefineXML")
@ -1256,7 +1256,7 @@ class XMLParseTest(unittest.TestCase):
check("outbound_peak", "5000", "3000") check("outbound_peak", "5000", "3000")
check("outbound_burst", "5120", "5120") check("outbound_burst", "5120", "5120")
self.assertEquals(len(net.portgroups), 2) self.assertEqual(len(net.portgroups), 2)
check = self._make_checker(net.portgroups[0]) check = self._make_checker(net.portgroups[0])
check("name", "engineering", "foo") check("name", "engineering", "foo")
check("default", True, False) check("default", True, False)