diff options
Diffstat (limited to 'src/software/test')
| -rw-r--r-- | src/software/test/README | 5 | ||||
| -rw-r--r-- | src/software/test/common.py | 109 | ||||
| -rwxr-xr-x | src/software/test/test_software_file_check.py | 289 | ||||
| -rwxr-xr-x | src/software/test/test_software_installed_package.py | 241 | ||||
| -rwxr-xr-x | src/software/test/test_software_package.py | 89 |
5 files changed, 733 insertions, 0 deletions
diff --git a/src/software/test/README b/src/software/test/README new file mode 100644 index 0000000..d60d1e8 --- /dev/null +++ b/src/software/test/README @@ -0,0 +1,5 @@ +Tests must be run as root on machine with sfcbd broker with +test dir as CWD. File common.py contains connection settings and +also test data. +This directory should contain all rpm packages, that will take part in testing +to speed it up. These packages are listed in common.py file. diff --git a/src/software/test/common.py b/src/software/test/common.py new file mode 100644 index 0000000..d88b2bb --- /dev/null +++ b/src/software/test/common.py @@ -0,0 +1,109 @@ +from collections import namedtuple +import os +import pywbem +import re +import subprocess +import unittest + +SCHEMA="http" +HOSTNAME="localhost" +PORT=5988 +USER='' +PASSWORD='' + +Package = namedtuple("Package", + "name, epoch, ver, rel, arch, " + "updatable, up_epoch, up_ver, up_rel") +# This is a database of packages used in tests. If you modify this, please +# ensure, that all corresponding rpm packages are present in test directory. +packages = [ Package(*args) for args in + ( ( "python-xlib-doc", "0", "0.15", "0.6.rc1.fc17", "noarch", False + , None, None, None) + , ( "slv2", "0", "0.6.6", "8.fc17", "x86_64", True + , "0", "0.6.6", "9.fc17") + ) ] + +pkg_files = ( + ( "bash-completion-1:2.0-1.fc17.noarch", + ( "/usr/share/bash-completion/completions/vgs" # symlink + , "/usr/share/doc/bash-completion-2.0/README" # file + , "/usr/share/doc/bash-completion-2.0" # directory + ) + , ) + , ) + +re_nevra = re.compile(r'^(?P<name>.+)-(?P<evra>(?P<epoch>\d+):(?P<ver>[^-]+)' + r'-(?P<rel>.+)\.(?P<arch>[^.]+))$') + +def make_nevra(name, epoch, ver, rel, arch, with_epoch='NOT_ZERO'): + """ + @param with_epoch may be one of: + "NOT_ZERO" - include epoch only if it's not zero + "ALWAYS" - include epoch always + "NEVER" - do not include epoch at all + """ + estr = '' + if with_epoch.lower() == "always": + estr = epoch + elif with_epoch.lower() == "not_zero": + if epoch != "0": + estr = epoch + if len(estr): estr += ":" + return "%s-%s%s-%s.%s" % (name, estr, ver, rel, arch) + +def remove_pkg(name, *args): + subprocess.call(["rpm", "--quiet"] + list(args) + ["-e", name]) + +def install_pkg(*args, **kwargs): + if len(args) > 1 or len(kwargs) > 0: + if kwargs.has_key('nevra'): + m = re_nevra.match(kwargs['nevra']) + args = [ m.group(k) for k in ( + 'name', 'epoch', 'ver', 'rel', 'arch') ] + nevra = make_nevra(*args, with_epoch="NEVER") + rpm_name = nevra + ".rpm" + if os.path.exists(rpm_name): + subprocess.call(["rpm", "--quiet", "-i", rpm_name]) + return + subprocess.call(["yum", "-q", "-y", "install", args[0]]) + +def is_installed(*args, **kwargs): + if len(args) == 1: + return subprocess.call(["rpm", "--quiet", "-q", args[0]]) == 0 + else: + if kwargs.has_key("nevra"): + nevra = kwargs["nevra"] + name = re_nevra.match(nevra).group('name') + else: + nevra = make_nevra(*args) + name = args[0] + try: + out = subprocess.check_output( + ["rpm", "-q", "--qf", "%{NEVRA}", name]) + return out == nevra + except subprocess.CalledProcessError: + return False + +def verify_pkg(name): + return subprocess.call(["rpm", "--quiet", "-Va", name]) == 0 + +class SoftwareBaseTestCase(unittest.TestCase): + + def setUp(self): + unittest.TestCase.setUp(self) + self.url = "%s://%s:%d" % (SCHEMA, HOSTNAME, PORT) + self.conn = pywbem.WBEMConnection(self.url, (USER, PASSWORD)) + self.op = pywbem.CIMInstanceName( + namespace="root/cimv2", classname=self.CLASS_NAME) + + def tearDown(self): + del self.conn + + def assertIsSubclass(self, cls, base_cls): + if not isinstance(cls, basestring): + raise TypeError("cls must be a string") + if not isinstance(base_cls, basestring): + raise TypeError("base_cls must be a string") + return self.assertTrue(pywbem.is_subclass(self.conn, + "root/cimv2", base_cls, cls)) + diff --git a/src/software/test/test_software_file_check.py b/src/software/test/test_software_file_check.py new file mode 100755 index 0000000..66b2452 --- /dev/null +++ b/src/software/test/test_software_file_check.py @@ -0,0 +1,289 @@ +#!/usr/bin/env python + +from common import * +import hashlib +import shutil +import socket +import stat + +re_checksum = re.compile(r'^([0-9a-fA-F]+)\s+.*') + +PassedFlags = namedtuple("PassedFlags", + "exists, type, size, mode, checksum, dev, ltarget, uid, gid, mtime") + +class TestSoftwareInstalledPackage(SoftwareBaseTestCase): + + CLASS_NAME = "LMI_SoftwareFileCheck" + KEYS = ( "CheckID", "Name", "SoftwareElementID", "SoftwareElementState" + , "TargetOperatingSystem", "Version") + + hash_num2algo = { + 1 : hashlib.md5, + 2 : hashlib.sha1, + 8 : hashlib.sha256, + 9 : hashlib.sha384, + 10 : hashlib.sha512, + 11 : hashlib.sha224 + } + + hash_num2cmd = { + 1 : "md5sum", + 2 : "sha1sum", + 8 : "sha256sum", + 9 : "sha384sum", + 10 : "sha512sum", + 11 : "sha224sum" + } + + hash_num2length = { + 1 : 32, + 2 : 40, + 8 : 64, + 9 : 96, + 10 : 128, + 11 : 56 + } + + def make_op(self, nevra, filename): + op = self.op.copy() + m = re_nevra.match(nevra) + name, version = [ m.group(k) for k in ("name", "ver") ] + op["Name"] = filename + op["Version"] = version + op["CheckID"] = "%s#%s" % (name, filename) + op["SoftwareElementState"] = pywbem.Uint16(2) + op["TargetOperatingSystem"] = pywbem.Uint16(36) + op["SoftwareElementID"] = nevra + return op + + def make_checksum_str(self, csumnum, filename): + return re_checksum.match(subprocess.check_output([ + self.hash_num2cmd[csumnum], filename])).group(1).lower() + + def do_test_symlink(self, op, nevra, f, inst): + target = os.readlink(f) + stats = os.lstat(f) + + self.assertEqual(inst["FileType"], pywbem.Uint16(3)) + self.assertEqual(inst["FileUserID"], stats.st_uid) + self.assertEqual(inst["FileGroupID"], stats.st_gid) + self.assertEqual(inst["FileMode"], stats.st_mode) + self.assertEqual(inst["FileSize"], stats.st_size) + self.assertEqual(inst["LinkTarget"], target) + self.assertEqual(inst["Checksum"], + "0"*self.hash_num2length[inst["ChecksumType"]]) + self.assertEqual(inst["LastModificationTime"], + int(stats.st_mtime)) + + # modify owner + prev_user = inst["FileUserID"] + prev_mtime = inst["LastModificationTime"] + prev_pflags = PassedFlags(*inst["PassedFlags"]) + os.lchown(f, stats.st_uid + 1, -1) + inst = self.conn.GetInstance(InstanceName=inst.path) + self.assertEqual(inst["FileUserID"], inst["ExpectedFileUserID"] + 1) + self.assertEqual(inst["FileUserID"], prev_user + 1) + self.assertEqual(inst["FileGroupID"], stats.st_gid) + cur_pflags = PassedFlags(*inst["PassedFlags"]) + #self.assertGreater(inst["LastModificationTime"], prev_mtime) + + self.assertTrue(cur_pflags.exists) + self.assertTrue(cur_pflags.type) + self.assertTrue(cur_pflags.size) + self.assertTrue(cur_pflags.mode) + self.assertTrue(cur_pflags.checksum) + self.assertTrue(cur_pflags.dev) + self.assertTrue(cur_pflags.ltarget) + self.assertFalse(cur_pflags.uid) + self.assertTrue(cur_pflags.gid) + self.assertTrue(cur_pflags.mtime) + + # modify link_target + os.remove(f) + os.symlink("wrong" + "*"*len(inst["ExpectedLinkTarget"]), f) + os.lchown(f, inst["ExpectedFileUserID"], inst["ExpectedFileGroupID"]) + + inst = self.conn.GetInstance(InstanceName=inst.path) + cur_pflags = PassedFlags(*inst["PassedFlags"]) + self.assertGreater(len(inst["LinkTarget"]), + len(inst["ExpectedLinkTarget"])) + + self.assertTrue(cur_pflags.exists) + self.assertTrue(cur_pflags.type) + self.assertFalse(cur_pflags.size) + self.assertTrue(cur_pflags.mode) + self.assertTrue(cur_pflags.checksum) + self.assertTrue(cur_pflags.dev) + self.assertFalse(cur_pflags.ltarget) + self.assertTrue(cur_pflags.uid) + self.assertTrue(cur_pflags.gid) + self.assertTrue(cur_pflags.mtime) + + def do_test_directory(self, op, nevra, f, inst): + stats = os.lstat(f) + + self.assertEqual(inst["FileType"], pywbem.Uint16(2)) + self.assertEqual(inst["FileUserID"], stats.st_uid) + self.assertEqual(inst["FileGroupID"], stats.st_gid) + self.assertEqual(inst["FileMode"], stats.st_mode) + self.assertEqual(inst["FileSize"], stats.st_size) + self.assertIs(inst["LinkTarget"], None) + self.assertEqual(inst["Checksum"], + "0"*self.hash_num2length[inst["ChecksumType"]]) + self.assertEqual(inst["LastModificationTime"], + int(stats.st_mtime)) + + def do_test_file(self, op, nevra, f, inst): + stats = os.lstat(f) + + self.assertEqual(inst["FileType"], pywbem.Uint16(1)) + self.assertEqual(inst["FileUserID"], stats.st_uid) + self.assertEqual(inst["FileGroupID"], stats.st_gid) + self.assertEqual(inst["FileMode"], stats.st_mode) + self.assertEqual(inst["FileSize"], stats.st_size) + self.assertIs(inst["LinkTarget"], None) + csum = self.make_checksum_str(inst['ChecksumType'], f) + self.assertEqual(inst["Checksum"].lower(), csum) + self.assertEqual(inst["ExpectedLastModificationTime"], + inst["LastModificationTime"]) + self.assertEqual(inst["LastModificationTime"], + int(stats.st_mtime)) + + # make it longer + with open(f, "a+") as fobj: + fobj.write("data\n") + inst = self.conn.GetInstance(InstanceName=inst.path) + cur_pflags = PassedFlags(*inst["PassedFlags"]) + self.assertGreater(inst["FileSize"], inst["ExpectedFileSize"]) + self.assertGreater(inst["LastModificationTime"], + inst["ExpectedLastModificationTime"]) + + self.assertTrue(cur_pflags.exists) + self.assertTrue(cur_pflags.type) + self.assertFalse(cur_pflags.size) + self.assertTrue(cur_pflags.mode) + self.assertFalse(cur_pflags.checksum) + self.assertTrue(cur_pflags.dev) + self.assertTrue(cur_pflags.ltarget) + self.assertTrue(cur_pflags.uid) + self.assertTrue(cur_pflags.gid) + self.assertFalse(cur_pflags.mtime) + + # change file type + os.remove(f) + os.symlink(f, f) + os.lchown(f, inst["ExpectedFileUserID"], inst["ExpectedFileGroupID"]) + inst = self.conn.GetInstance(InstanceName=inst.path) + cur_pflags = PassedFlags(*inst["PassedFlags"]) + self.assertNotEqual(inst["LinkTarget"], inst["ExpectedLinkTarget"]) + self.assertNotEqual(inst["FileSize"], inst["ExpectedFileSize"]) + self.assertGreater(inst["LastModificationTime"], + inst["ExpectedLastModificationTime"]) + self.assertNotEqual(inst["FileType"], inst["ExpectedFileType"]) + self.assertEqual(inst["FileType"], pywbem.Uint16(3)) + + self.assertTrue(cur_pflags.exists) + self.assertFalse(cur_pflags.type) + self.assertFalse(cur_pflags.size) + self.assertFalse(cur_pflags.mode) + self.assertFalse(cur_pflags.checksum) + self.assertTrue(cur_pflags.dev) + self.assertFalse(cur_pflags.ltarget) + self.assertTrue(cur_pflags.uid) + self.assertTrue(cur_pflags.gid) + self.assertFalse(cur_pflags.mtime) + + # remove it + os.remove(f) + inst = self.conn.GetInstance(InstanceName=inst.path) + cur_pflags = PassedFlags(*inst["PassedFlags"]) + self.assertEqual(inst["LinkTarget"], inst["ExpectedLinkTarget"]) + self.assertNotEqual(inst["FileSize"], inst["ExpectedFileSize"]) + self.assertIsNone(inst["LastModificationTime"]) + self.assertIsNone(inst["FileType"]) + self.assertIsNone(inst["Checksum"]) + self.assertIsNone(inst["FileMode"]) + self.assertIsNone(inst["FileUserID"]) + self.assertIsNone(inst["FileGroupID"]) + + self.assertFalse(cur_pflags.exists) + self.assertFalse(cur_pflags.type) + self.assertFalse(cur_pflags.size) + self.assertFalse(cur_pflags.mode) + self.assertFalse(cur_pflags.checksum) + self.assertFalse(cur_pflags.dev) + self.assertFalse(cur_pflags.ltarget) + self.assertFalse(cur_pflags.uid) + self.assertFalse(cur_pflags.gid) + self.assertFalse(cur_pflags.mtime) + + def test_get_instance(self): + for nevra, files in pkg_files: + m = re_nevra.match(nevra) + name, version = [ m.group(k) for k in ("name", "ver") ] + if is_installed(nevra=nevra) and not verify_pkg(name): + remove_pkg(name) + if not is_installed(name): + install_pkg(nevra=nevra) + self.assertTrue(is_installed(nevra=nevra)) + for f in files: + op = self.make_op(nevra, f) + + inst = self.conn.GetInstance(InstanceName=op, LocalOnly=False) + self.assertIsInstance(inst, pywbem.CIMInstance) + self.assertEqual(inst.path, op) + for key in self.KEYS: + self.assertEqual(inst[key], op[key]) + + self.assertTrue(inst["FileExists"]) + self.assertEqual(len(inst["PassedFlags"]), 10) + self.assertTrue(all(f is True for f in inst["PassedFlags"])) + for prop in ( "FileType", "FileUserID", "FileGroupID" + , "FileMode", "FileSize", "LinkTarget" + , "Checksum", "FileModeFlags"): + self.assertEqual(inst["Expected"+prop], inst[prop]) + if os.path.islink(f): + self.do_test_symlink(op, nevra, f, inst) + elif os.path.isdir(f): + self.do_test_directory(op, nevra, f, inst) + elif os.path.isfile(f): + self.do_test_file(op, nevra, f, inst) + + def test_invoke_method(self): + for nevra, files in pkg_files: + m = re_nevra.match(nevra) + name, version = [ m.group(k) for k in ("name", "ver") ] + if is_installed(nevra=nevra) and not verify_pkg(name): + remove_pkg(name) + if not is_installed(name): + install_pkg(nevra=nevra) + self.assertTrue(is_installed(nevra=nevra)) + for f in files: + op = self.make_op(nevra, f) + + (rval, oparms) = self.conn.InvokeMethod( + MethodName="Invoke", + ObjectName=op) + self.assertEqual(rval, pywbem.Uint32(0)) + + # modify file + if os.path.isfile(f): + os.remove(f) + else: + os.lchown(f, os.stat(f).st_uid + 1, -1) + (rval, oparms) = self.conn.InvokeMethod( + MethodName="Invoke", + ObjectName=op) + self.assertEqual(rval, pywbem.Uint32(2)) + + @classmethod + def tearDownClass(cls): + for pkg_nevra, files in pkg_files: + name = re_nevra.match(pkg_nevra).group('name') + if is_installed(name) and not verify_pkg(name): + remove_pkg(name) + if not is_installed(name): + install_pkg(nevra=pkg_nevra) + +if __name__ == "__main__": + unittest.main() diff --git a/src/software/test/test_software_installed_package.py b/src/software/test/test_software_installed_package.py new file mode 100755 index 0000000..5bcb9d2 --- /dev/null +++ b/src/software/test/test_software_installed_package.py @@ -0,0 +1,241 @@ +#!/usr/bin/env python + +from common import * +import shutil +import socket +import stat + +class TestSoftwareInstalledPackage(SoftwareBaseTestCase): + + CLASS_NAME = "LMI_SoftwareInstalledPackage" + KEYS = ( "Software", "System") + + def make_op(self, name, epoch, ver, rel, arch, ses=2): + op = self.op.copy() + pkg_op = pywbem.CIMInstanceName( + classname="LMI_SoftwarePackage", namespace="root/cimv2", + keybindings={ + "Name" : name, + "SoftwareElementID" : make_nevra( + name, epoch, ver, rel, arch, "ALWAYS"), + "SoftwareElementState" : pywbem.Uint16(ses), + "TargetOperatingSystem" : pywbem.Uint16(36), + "Version" : ver }) + system_op = pywbem.CIMInstanceName( + classname="CIM_ComputerSystem", namespace="root/cimv2", + keybindings={ + "CreationClassName" : "CIM_ComputerSystem", + "Name" : socket.gethostname() }) + op["Software"] = pkg_op + op["System"] = system_op + return op + + def test_get_instance(self): + for pkg in packages: + if not is_installed(*pkg[:5]): + install_pkg(*pkg[:5]) + op = self.make_op(*pkg[:5]) + inst = self.conn.GetInstance(InstanceName=op, LocalOnly=False) + self.assertIsSubclass(inst.path.classname, self.CLASS_NAME) + self.assertIsSubclass( + inst.path['System'].classname, op['System'].classname) + self.assertIsSubclass( + inst.path['Software'].classname, op['Software'].classname) + self.assertEqual(len(inst.path.keys()), 2) + for key in self.KEYS: + self.assertEqual(inst[key], inst.path[key]) + self.assertEqual(inst['Software'], op['Software']) + remove_pkg(pkg.name) + op['Software']['SoftwareElementState'] = pywbem.Uint16(1) + with self.assertRaises(pywbem.CIMError) as cm: + self.conn.GetInstance(InstanceName=op, LocalOnly=False) + self.assertEqual(cm.exception.args[0], pywbem.CIM_ERR_NOT_FOUND) + + def test_enum_instances(self): + pkg = packages[0] + if is_installed(*pkg[:5]): + remove_pkg(pkg.name) + insts1 = self.conn.EnumerateInstanceNames(ClassName=self.CLASS_NAME) + install_pkg(*pkg[:5]) + insts2 = self.conn.EnumerateInstanceNames(ClassName=self.CLASS_NAME) + self.assertEqual(len(insts1) + 1, len(insts2)) + + op = self.make_op(*pkg[:5]) + self.assertIn(op['Software'], (inst['Software'] for inst in insts2)) + self.assertTrue(all(isinstance(inst, pywbem.CIMInstanceName) + for inst in insts1)) + + insts1 = self.conn.EnumerateInstances(ClassName=self.CLASS_NAME) + remove_pkg(pkg.name) + insts2 = self.conn.EnumerateInstances(ClassName=self.CLASS_NAME) + + self.assertEqual(len(insts2) + 1, len(insts1)) + self.assertIn(op['Software'], (inst['Software'] for inst in insts1)) + self.assertTrue(all(inst['Software'] == inst.path['Software'] + for inst in insts1)) + self.assertTrue(all(inst['System'] == inst.path['System'] + for inst in insts1)) + + def test_create_instance(self): + for pkg in packages: + if is_installed(pkg.name): + remove_pkg(pkg.name) + self.assertFalse(is_installed(pkg.name)) + op = self.make_op(*(list(pkg[:5]) + [1])) + inst = pywbem.CIMInstance(classname=op.classname, path=op) + inst["Software"] = op["Software"] + inst["System"] = op["System"] + iname = self.conn.CreateInstance(NewInstance=inst) + self.assertIsInstance(iname, pywbem.CIMInstanceName) + op["Software"]["SoftwareElementState"] = pywbem.Uint16(2) + self.assertEqual(iname["Software"], op["Software"]) + self.assertIsInstance(iname["System"], pywbem.CIMInstanceName) + self.assertIsSubclass(iname["System"].classname, + op["System"].classname) + self.assertEqual(set(iname.keys()), set(op.keys())) + self.assertTrue(is_installed(pkg.name)) + + with self.assertRaises(pywbem.CIMError) as cm: + self.conn.CreateInstance(NewInstance=inst) + self.assertEqual(cm.exception.args[0], + pywbem.CIM_ERR_ALREADY_EXISTS) + + def test_delete_instance(self): + for pkg in packages: + if not is_installed(pkg.name): + install_pkg(*pkg[:5]) + self.assertTrue(is_installed(pkg.name)) + op = self.make_op(*pkg[:5]) + self.conn.DeleteInstance(op) + self.assertFalse(is_installed(pkg.name)) + with self.assertRaises(pywbem.CIMError) as cm: + self.conn.DeleteInstance(op) + self.assertEqual(cm.exception.args[0], pywbem.CIM_ERR_NOT_FOUND) + + def test_check_integrity(self): + for pkg_nevra, files in pkg_files: + m = re_nevra.match(pkg_nevra) + name, epoch, ver, rel, arch = [ m.group(k) for k in ( + "name", "epoch", "ver", "rel", "arch") ] + if ( (is_installed(nevra=pkg_nevra) and not verify_pkg(name)) + or (is_installed(name) and not is_installed(nevra=pkg_nevra))) : + remove_pkg(name) + if not is_installed(name): + install_pkg(name, epoch, ver, rel, arch) + self.assertTrue(is_installed(nevra=pkg_nevra)) + + op = self.make_op(name, epoch, ver, rel, arch) + (rval, oparms) = self.conn.InvokeMethod( + MethodName="CheckIntegrity", + ObjectName=op) + self.assertEqual(rval, pywbem.Uint32(0)) # check passed + self.assertEqual(len(oparms), 1) + self.assertIn("Failed", oparms) + self.assertEqual(len(oparms["Failed"]), 0) + + cnt_bad = 0 + for f in files: + stats = os.lstat(f) + if os.path.islink(f): # modify symbolic link + target = os.readlink(f) + os.remove(f) + os.symlink(target, f) # just touch symlink + (rval, oparms) = self.conn.InvokeMethod( + MethodName="CheckIntegrity", + ObjectName=op) + # symlink must pass + self.assertEqual(len(oparms["Failed"]), cnt_bad) + os.remove(f) + # now change target + os.symlink("wrong_link_target", f) + elif os.path.isdir(f): # check directory + os.chmod(f, stats.st_mode) # just touch dir + (rval, oparms) = self.conn.InvokeMethod( + MethodName="CheckIntegrity", + ObjectName=op) + # dir must pass + self.assertEqual(len(oparms["Failed"]), cnt_bad) + # modify read access of directory + os.chmod(f, stats.st_mode ^ stat.S_IROTH) + else: # modify regular file + # just touch file - this is enough to make it fail + with open(f, "w+") as fobj: pass + cnt_bad += 1 + (rval, oparms) = self.conn.InvokeMethod( + MethodName="CheckIntegrity", + ObjectName=op) + self.assertEqual(rval, pywbem.Uint32(1)) + self.assertEqual(len(oparms), 1) + self.assertIn("Failed", oparms) + self.assertEqual(len(oparms["Failed"]), cnt_bad) + self.assertIn(f, (p["Name"] for p in oparms["Failed"])) + + def test_method_update(self): + for pkg in packages: + if not pkg.updatable: continue + if is_installed(pkg.name) and not is_installed(*pkg[:5]): + remove_pkg(pkg.name) + if not is_installed(pkg.name): + install_pkg(*pkg[:5]) + self.assertTrue(is_installed(*pkg[:5])) + + op = self.make_op(*pkg[:5]) + op_up = self.make_op(pkg.name, pkg.up_epoch, + pkg.up_ver, pkg.up_rel, pkg.arch) + (rval, oparms) = self.conn.InvokeMethod( + MethodName="Update", + ObjectName=op) + self.assertEqual(rval, pywbem.Uint16(1)) + self.assertEqual(len(oparms), 1) + self.assertIn("Installed", oparms) + self.assertEqual(oparms["Installed"], op_up["Software"]) + self.assertTrue(is_installed(pkg.name, pkg.up_epoch, + pkg.up_ver, pkg.up_rel, pkg.arch)) + + (rval, oparms) = self.conn.InvokeMethod( + MethodName="Update", + ObjectName=op_up) + self.assertEqual(rval, pywbem.Uint16(0)) + self.assertEqual(len(oparms), 1) + self.assertEqual(oparms["Installed"], op_up["Software"]) + + with self.assertRaises(pywbem.CIMError) as cm: + self.conn.InvokeMethod( + MethodName="Update", + ObjectName=op) + self.assertEqual(cm.exception.args[0], + pywbem.CIM_ERR_NOT_FOUND) + + remove_pkg(pkg.name) + install_pkg(*pkg[:5]) + self.assertTrue(is_installed(*pkg[:5])) + + (rval, oparms) = self.conn.InvokeMethod( + MethodName="Update", + ObjectName=op, + Epoch=pkg.epoch, + Version=pkg.ver, + Release=pkg.rel) + self.assertEqual(rval, pywbem.Uint16(0)) + self.assertEqual(oparms["Installed"], op["Software"]) + + (rval, oparms) = self.conn.InvokeMethod( + MethodName="Update", + ObjectName=op, + Epoch=pkg.up_epoch, + Version=pkg.up_ver, + Release=pkg.up_rel) + self.assertEqual(rval, pywbem.Uint16(1)) + self.assertEqual(oparms["Installed"], op_up["Software"]) + + @classmethod + def tearDownClass(cls): + for pkg_nevra, files in pkg_files: + name = re_nevra.match(pkg_nevra).group('name') + if is_installed(name) and not verify_pkg(name): + remove_pkg(name) + if not is_installed(name): + install_pkg(nevra=pkg_nevra) + +if __name__ == "__main__": + unittest.main() diff --git a/src/software/test/test_software_package.py b/src/software/test/test_software_package.py new file mode 100755 index 0000000..cdaf04d --- /dev/null +++ b/src/software/test/test_software_package.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python + +from common import * + +class TestSoftwarePackage(SoftwareBaseTestCase): + + CLASS_NAME = "LMI_SoftwarePackage" + KEYS = ( "Name", "SoftwareElementID", "SoftwareElementState" + , "TargetOperatingSystem", "Version") + + def make_op(self, name, epoch, ver, rel, arch, ses=2): + op = self.op.copy() + op["Name"] = name + op["SoftwareElementID"] = make_nevra( + name, epoch, ver, rel, arch, "ALWAYS") + op["SoftwareElementState"] = pywbem.Uint16(ses) + op["TargetOperatingSystem"] = pywbem.Uint16(36) + op["Version"] = ver + return op + + def test_get_instance(self): + for pkg in packages: + if is_installed(pkg.name): + remove_pkg(pkg.name) + op = self.make_op(pkg.name, pkg.epoch, pkg.ver, + pkg.rel, pkg.arch, 1) + inst = self.conn.GetInstance(InstanceName=op, LocalOnly=False) + self.assertEqual(inst.path, op) + for key in self.KEYS: + self.assertTrue(inst.properties.has_key(key)) + self.assertEqual(inst.path[key], inst[key]) + self.assertEqual(inst['Release'], pkg.rel) + install_pkg(*pkg[:5]) + op['SoftwareElementState'] = pywbem.Uint16(2) + inst = self.conn.GetInstance(InstanceName=op, LocalOnly=False) + self.assertEqual(inst.path, op) + + # try to leave out epoch part + if pkg.epoch == "0": + op_no_epoch = op.copy() + op_no_epoch["SoftwareElementID"] = make_nevra(pkg.name, pkg.epoch, + pkg.ver, pkg.rel, pkg.arch, "NEVER") + self.assertNotIn(":", op_no_epoch["SoftwareElementID"]) + inst = self.conn.GetInstance( + InstanceName=op_no_epoch, LocalOnly=False) + self.assertIn(inst.path, (op, op_no_epoch)) + + def test_method_install(self): + for pkg in packages: + if is_installed(pkg.name): + remove_pkg(pkg.name) + op = self.make_op(pkg.name, pkg.epoch, pkg.ver, + pkg.rel, pkg.arch, 1) + (rval, oparms) = self.conn.InvokeMethod( + MethodName="Install", + ObjectName=op) + self.assertEqual(rval, pywbem.Uint32(1)) + self.assertEqual(len(oparms), 1) + self.assertTrue(oparms.has_key('Installed')) + op['SoftwareElementState'] = pywbem.Uint16(2) + self.assertEqual(oparms['Installed'], op) + self.assertTrue(is_installed(pkg.name)) + (rval, oparms) = self.conn.InvokeMethod( + MethodName="Install", + ObjectName=op) + self.assertEqual(rval, pywbem.Uint32(0)) + self.assertEqual(len(oparms), 1) + self.assertEqual(oparms['Installed'], op) + + def test_method_remove(self): + for pkg in packages: + if not is_installed(pkg.name): + install_pkg(*pkg[:5]) + op = self.make_op(*pkg[:5]) + (rval, oparms) = self.conn.InvokeMethod( + MethodName="Remove", + ObjectName=op) + self.assertEqual(rval, pywbem.Uint16(1)) + self.assertEqual(len(oparms), 0) + self.assertFalse(is_installed(pkg.name)) + op["SoftwareElementState"] = pywbem.Uint16(1) + (rval, oparms) = self.conn.InvokeMethod( + MethodName="Remove", + ObjectName=op) + self.assertEqual(rval, pywbem.Uint32(0)) + self.assertEqual(len(oparms), 0) + +if __name__ == '__main__': + unittest.main() |