def __init__(self, userName="", userShell="/bin/bash", userComment="", userUid=10000, userPriGid=20, userHomeDir="/tmp", logger=False): self.module_version = '20160225.125554.540679' ##### # Set up logging self.logger = LogDispatcher() ##### # THIS IS A LIBRARY, SO LOGS SHOULD BE INITIALIZED ELSEWHERE... # self.logger.initializeLogs() self.logger.log(lp.INFO, "Logger: " + str(self.logger)) """
def setUpClass(self): '''Test initializer''' self.environ = Environment() self.environ.setdebugmode(True) # Start timer in miliseconds self.test_start_time = datetime.now() self.logger = LogDispatcher(self.environ) self.logger.initializeLogs() self.sh = SHlaunchdTwo(self.environ, self.logger) self.logger.log(lp.DEBUG, "test " + __file__ + " initialized...")
def setUp(self): ''' Setup what we need for the test. @author: ekkehard j. koch @param self:essential if you override this definition ''' self.environ = Environment() self.environ.setverbosemode(True) self.environ.setdebugmode(True) self.config = Configuration(self.environ) self.logdispatch = LogDispatcher(self.environ) self.statechglogger = StateChgLogger(self.logdispatch, self.environ) self.rule = None self.rulename = "" self.rulenumber = ""
def setUp(self): '''initialize and set class variables and objects''' self.environ = Environment() self.environ.setdebugmode(True) self.logger = LogDispatcher(self.environ) self.mysh = ServiceHelper(self.environ, self.logger) # set service name self.myservice = 'crond' self.myservicename = "" if self.environ.getosfamily() == 'darwin': self.myservice = "/Library/LaunchDaemons/gov.lanl.stonix.report.plist" self.myservicename = "gov.lanl.stonix.report" elif self.environ.getosfamily() == 'solaris': self.myservice = 'svc:/system/cron:default' elif self.environ.getosfamily() == 'freebsd': self.myservice = 'cron' elif os.path.exists('/usr/lib/systemd/system/cron.service'): self.myservice = 'cron.service' elif os.path.exists('/usr/lib/systemd/system/crond.service'): self.myservice = 'crond.service' elif os.path.exists('/etc/init.d/vixie-cron'): self.myservice = 'vixie-cron' elif os.path.exists('/etc/init.d/cron'): self.myservice = 'cron' if self.environ.getosfamily() == "darwin": self.service = self.myservice, self.myservicename else: self.service = [self.myservice] # store system initial state self.orig_enabled = self.mysh.auditService(*self.service)
def setUp(self): ''' ''' self.enviro = Environment() self.enviro.setdebugmode(True) self.logger = LogDispatcher(self.enviro) self.commandhelper = CommandHelper(self.logger)
def setUp(self): '''set up handlers and objects and any other conditions for use in the class''' self.environ = Environment() self.logger = LogDispatcher(self.environ) # build proxy (if needed), handlers and opener for urllib2.urlopen connections context = ssl._create_unverified_context() if PROXY: proxy = urllib.request.ProxyHandler({ "http": PROXY, "https": PROXY }) opener = urllib.request.build_opener( urllib.request.HTTPHandler(), urllib.request.HTTPSHandler(context=context), proxy) else: opener = urllib.request.build_opener( urllib.request.HTTPHandler(), urllib.request.HTTPSHandler(context=context)) urllib.request.install_opener(opener)
def setUp(self): kvtype = "defaults" data = { "CatalogURL": [APPLESOFTUPDATESERVER, APPLESOFTUPDATESERVER], "LastResultCode": ["100", "100"] } path = "/Library/Preferences/com.apple.SoftwareUpdate" self.environ = Environment() if not self.environ.getosfamily() == "darwin": return self.logger = LogDispatcher(self.environ) stchglogger = StateChgLogger(self.logger, self.environ) self.editor = KVEditorStonix.KVEditorStonix(stchglogger, self.logger, kvtype, path, path + ".tmp", data, "present", "openeq")
def setUpClass(self): ''' Test initializer ''' self.environ = Environment() self.environ.setdebugmode(True) # Start timer in miliseconds self.test_start_time = datetime.now() self.logger = LogDispatcher(self.environ) self.logger.initializeLogs() self.sh = SHlaunchdTwo(self.environ, self.logger) self.logger.log(lp.DEBUG, "test " + __file__ + " initialized...")
def setUp(self): """ set up handlers and objects and any other conditions for use in the class """ self.environ = Environment() self.logger = LogDispatcher(self.environ) # build proxy (if needed), handlers and opener for urllib2.urlopen connections context = ssl._create_unverified_context() if PROXY: proxy = urllib2.ProxyHandler({"http": PROXY, "https": PROXY}) opener = urllib2.build_opener(urllib2.HTTPHandler(), urllib2.HTTPSHandler(context=context), proxy) else: opener = urllib2.build_opener(urllib2.HTTPHandler(), urllib2.HTTPSHandler(context=context)) urllib2.install_opener(opener)
def setUp(self): self.enviro = Environment() self.enviro.setdebugmode(True) self.logger = LogDispatcher(self.enviro) self.ch = CommandHelper(self.logger) self.changedDir = False # stonixtest must currently be run from the stonixroot directory, so # that is the best bet for the cwd if os.path.exists("src/Macbuild"): os.chdir("src/Macbuild") self.changedDir = True # Cannot guarantee that test will end in self.myDir = os.getcwd() # this dir, so we record it first self.mb = build.SoftwareBuilder(options=optparse.Values({ "compileGui": True, "version": "0.dev-UT", "clean": False, "test": True }))
def setUpClass(self): """ """ self.macPackageName = "testStonixMacPkgr-0.0.3.pkg" self.reporoot = MACREPOROOT self.environ = Environment() self.logger = LogDispatcher(self.environ) self.pkgr = MacPkgr(self.environ, self.logger) if not self.environ.osfamily == "darwin": sys.exit(255) self.pkg_dirs = ["/tmp/testStonixMacPkgr-0.0.3/one/two/three/3.5", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/three", \ "/tmp/testStonixMacPkgr-0.0.3/one/two", \ "/tmp/testStonixMacPkgr-0.0.3/one", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/four/five", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/four", \ "/tmp/testStonixMacPkgr-0.0.3/one/two", \ "/tmp/testStonixMacPkgr-0.0.3/one/six/seven"] self.pkg_files = ["/tmp/testStonixMacPkgr-0.0.3/one/two/testfile1", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/four/five/testfile2", \ "/tmp/testStonixMacPkgr-0.0.3/one/testfile3", \ "/tmp/testStonixMacPkgr-0.0.3/one/testfile4", \ "/tmp/testStonixMacPkgr-0.0.3/one/six/seven/testfile"] self.post_files = ["/tmp/testStonixMacPkgr-0.0.3/one/postfile2", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/three/3.5/postfile3"] self.post_dirs = ["/tmp/testStonixMacPkgr-0.0.3/one/six/6.5"] self.all_files = [self.pkg_files, self.post_files] self.all_dirs = [self.pkg_dirs, self.post_dirs] self.allowed_files_and_dirs = [self.pkg_dirs, self.pkg_dirs, self.post_dirs] self.ch = CommandHelper(self.logger) self.connection = Connectivity(self.logger) self.testDomain = "gov.lanl.testStonixMacPkgr.0.0.3.testStonixMacPkgr"
class zzzTestFrameworkMacPkgr(unittest.TestCase): """ Class for testing the macpkgr. """ @classmethod def setUpClass(self): """ """ self.macPackageName = "testStonixMacPkgr-0.0.3.pkg" self.reporoot = MACREPOROOT self.environ = Environment() self.logger = LogDispatcher(self.environ) self.pkgr = MacPkgr(self.environ, self.logger) if not self.environ.osfamily == "darwin": sys.exit(255) self.pkg_dirs = ["/tmp/testStonixMacPkgr-0.0.3/one/two/three/3.5", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/three", \ "/tmp/testStonixMacPkgr-0.0.3/one/two", \ "/tmp/testStonixMacPkgr-0.0.3/one", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/four/five", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/four", \ "/tmp/testStonixMacPkgr-0.0.3/one/two", \ "/tmp/testStonixMacPkgr-0.0.3/one/six/seven"] self.pkg_files = ["/tmp/testStonixMacPkgr-0.0.3/one/two/testfile1", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/four/five/testfile2", \ "/tmp/testStonixMacPkgr-0.0.3/one/testfile3", \ "/tmp/testStonixMacPkgr-0.0.3/one/testfile4", \ "/tmp/testStonixMacPkgr-0.0.3/one/six/seven/testfile"] self.post_files = ["/tmp/testStonixMacPkgr-0.0.3/one/postfile2", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/three/3.5/postfile3"] self.post_dirs = ["/tmp/testStonixMacPkgr-0.0.3/one/six/6.5"] self.all_files = [self.pkg_files, self.post_files] self.all_dirs = [self.pkg_dirs, self.post_dirs] self.allowed_files_and_dirs = [self.pkg_dirs, self.pkg_dirs, self.post_dirs] self.ch = CommandHelper(self.logger) self.connection = Connectivity(self.logger) self.testDomain = "gov.lanl.testStonixMacPkgr.0.0.3.testStonixMacPkgr" @classmethod def tearDownClass(self): """ Make sure the appropriate files are removed.. """ pass def test_inLinearFlow(self): """ Run methods or functionality that requires order, ie a happens before b Like ensure a package is installed before testing if uninstall works. @author: Roy Nielsen """ if not self.connection.isPageAvailable(): self.logger.log(LogPriority.INFO, "This test fails without a " + \ "properly configured Mac " + \ "repository, so we are not " + \ "running actual tests...") else: ##### # Remove the package in case it is installed, so we have a sane, # consistent starting point for the test. self.removeCompletePackage() ##### # Install the package self.assertTrue(self.pkgr.installPackage(self.macPackageName), "Problem with pkgr.installpackage...") ##### # Use the macpkgr method to check if the package is installed self.assertTrue(self.pkgr.checkInstall(self.macPackageName), "Problem with pkgr.checkInstall...") ##### # Manual check to see if the package is installed self.assertTrue(self.isInstalled(), "Problem with installation...") ##### # Make sure it isn't a partial install... self.assertTrue(self.isFullInstall(), "Partial install...") ##### # Remove the package, assert that it worked. self.assertTrue(self.pkgr.removePackage(self.macPackageName), "Problem removing package...") ##### # Check that checkInstall returns the correct value self.assertFalse(self.pkgr.checkInstall(self.macPackageName), "Problem with pkgr.checkinstall...") ##### # Hand verify that self.pkgr.checkInstall worked. self.assertTrue(self.isMissing(), "Problem with package removal...") ##### # Remove any presence of the package installed. self.removeCompletePackage() def testCheckInstall(self): """ Test the checkInstall method. 1 - make sure the test .pkg is NOT installed 2 - download the package and check the md5 3 - use custom installer command to install the package 4 - call the checkInstall method @author: Roy Nielsen """ if not self.connection.isPageAvailable(): self.logger.log(LogPriority.INFO, "This test fails without a " + \ "properly configured Mac " + \ "repository, so we are not " + \ "running actual tests...") else: ##### # make sure the test .pkg is NOT installed self.pkgr.removePackage(self.macPackageName) ##### # Test the checkInstall with the package removed self.assertFalse(self.pkgr.checkInstall(self.macPackageName)) self.assertFalse(self.isInstalled()) ##### # Install the package self.pkgr.installPackage(self.macPackageName) ##### # run checkInstall again self.assertTrue(self.pkgr.checkInstall(self.macPackageName)) self.assertTrue(self.isInstalled()) def testCheckAvailable(self): """ Check if a package is available on the reporoot. Must have both the file AND the md5 checksum file on the server of the format: .<filename>.<UPPER-md5sum> Steps for this test: 1 - set up self.pkgr.pkgUrl 2 - run self.pkgr.downloadPackage 3 - Make sure the checksum matches, otherwise there is a bad md5 for the download, and the package should not be trusted, let alone installed. This covers two test cases - checkAvailable downloadPackage @author: Roy Nielsen """ if not self.connection.isPageAvailable(): self.logger.log(LogPriority.INFO, "This test fails without a " + \ "properly configured Mac " + \ "repository, so we are not " + \ "running actual tests...") else: self.assertTrue(self.reporoot + self.macPackageName) self.pkgr.setPkgUrl(self.reporoot + self.macPackageName) self.pkgr.package = self.macPackageName self.assertTrue(self.pkgr.downloadPackage(), "Package: " + \ str(self.pkgr.getPkgUrl()) + " FAILED download...") self.assertTrue(self.pkgr.checkMd5(), "MD5 checksum didn't match - " + \ "package: " + str(self.pkgr.hashUrl) + " is NOT " + \ "available...") def testFindDomain(self): """ Test the findDomain function. The domain is required to do a reverse lookup in the local client package receipt database. It should find all the files that have been installed by the PACKAGE, not the postflight. Will remove the test package if it exists, install the package then use the test package to make sure the package file list is accurate. @author: Roy Nielsen """ if not self.connection.isPageAvailable(): self.logger.log(LogPriority.INFO, "This test fails without a " + \ "properly configured Mac " + \ "repository, so we are not " + \ "running actual tests...") else: ##### # Make sure the package is installed self.pkgr.installPackage("testStonixMacPkgr-0.0.3.pkg") ##### # Assert findDomain works properly when the package is installed self.assertEqual(self.testDomain, self.pkgr.findDomain("testStonixMacPkgr-0.0.3.pkg")) def testUnArchive(self): """ Download a tar package with the test pkg in it. Will test doing a download and checksum of the following by downloading the file and doing a checksum, then unzipping the file, and check the internal filename: testStonixMacPkgr.zip @Note: *** Functionality needs approval *** @author: Roy Nielsen """ pass def testCopyInstall(self): """ Tests the copyInstall method. Will test by: Downloading the test .tar file with a .app in it, doing a checksum of the .tar file then performing a copyInstall. Will test by checking the existence of the .app being in the right place. @author: Roy Nielsen """ pass def testInstallPkg(self): """ Tests the installPkg method. Will: Make sure the test pkg is not installed Download and checksum the file. install the .pkg with the installPkg method. @author: Roy Nielsen """ pass def testIsMacPlatform(self): """ Make sure we are on the Mac platform. @author: Roy Nielsen """ if not self.connection.isPageAvailable(): self.logger.log(LogPriority.INFO, "This test fails without a " + \ "properly configured Mac " + \ "repository, so we are not " + \ "running actual tests...") else: self.assertTrue(self.environ.osfamily == "darwin", "Wrong OS...") def isFullInstall(self): """ Make sure that all files and directories including those installed from the package and the postinstall script exist. @Note: In future, this should also do a receipt test as well. This would include getting the files from the receipt and checking for their existence and perhaps their permissions. @author: Roy Nielsen """ files = self.doFilesExistTest(self.all_files) dirs = self.doDirsExist(self.all_dirs) if files and dirs: return True return False def isInstalled(self): """ Test to make sure just the files and directories installed by the package are installed. Doesn't care about the files and directories installed by the postinstall script. @author: Roy Nielsen """ files = self.doFilesExistTest([self.pkg_files]) dirs = self.doDirsExist([self.pkg_dirs]) if files and dirs: return True return False def isMissing(self): """ Test to make sure all the files have been removed that were Installed by the package. Ignore, but note directories installed by the package that exist, as well as files and directories installed by the postinstall script. @Note: In future, this test should check for a package receipt, and make sure the files in the package receipt do not exist. This is only valid for this package, as in the case of some software, like Adobe products, some of the files are shared libraries between different products. @author: Roy Nielsen """ removed = [] exists = [] ##### # Cycle through each subset of files in the for myfile in self.pkg_files: if os.path.isfile(myfile): self.logger.log(LogPriority.WARNING, "File: " + \ str(myfile) + " exists...") removed.append(False) exists.append(myfile) self.assertFalse(False in removed, "Some files exist: " + str(exists)) ##### # cycle through each set of directories in all_dirs for myset in self.allowed_files_and_dirs: ##### # Cycle through each subset of files in the for myfile in myset: if os.path.isdir(myfile): self.logger.log(LogPriority.INFO, "Item: " + \ str(myfile) + " exists...") if False in removed: return False return True def removeCompletePackage(self): """ Remove all files, used to set the stage for install tests. @author: Roy Nielsen """ success = False try: testPath = "/tmp/testStonixMacPkgr-0.0.3" if os.path.exists(testPath): shutil.rmtree(testPath) except Exception, err: self.logger.log(LogPriority.INFO, "Test set already missing?") raise err else:
def setUp(self): self.environ = Environment() self.logdispatcher = LogDispatcher(self.environ) self.conn = Connectivity(self.logdispatcher)
def setUp(self): ''' ''' self.environ = Environment() self.logdispatcher = LogDispatcher(self.environ) self.conn = Connectivity(self.logdispatcher, use_proxy=True)
def setUpClass(self): """ """ self.environ = Environment() self.logger = LogDispatcher(self.environ) self.osfamily = self.environ.getosfamily() self.logger.log(LogPriority.DEBUG, "##################################") self.logger.log(LogPriority.DEBUG, "### OS Family: " + str(self.osfamily)) self.logger.log(LogPriority.DEBUG, "##################################") self.libc = ctypes.CDLL("/usr/lib/libc.dylib") self.logger = LogDispatcher(self.environ) self.macPackageName = "testStonixMacPkgr-0.0.3.pkg" self.reporoot = MACREPOROOT ##### # Create a class variable that houses the whole URL if self.reporoot.endswith("/"): self.pkgUrl = self.reporoot + self.macPackageName else: self.pkgUrl = self.reporoot + "/" + self.macPackageName message = "self.pkgUrl: " + str(self.pkgUrl) self.pkgr = MacPkgr(self.environ, self.logger) self.pkg_dirs = ["/tmp/testStonixMacPkgr-0.0.3/one/two/three/3.5", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/three", \ "/tmp/testStonixMacPkgr-0.0.3/one/two", \ "/tmp/testStonixMacPkgr-0.0.3/one", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/four/five", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/four", \ "/tmp/testStonixMacPkgr-0.0.3/one/two", \ "/tmp/testStonixMacPkgr-0.0.3/one/six/seven"] self.pkg_files = ["/tmp/testStonixMacPkgr-0.0.3/one/two/testfile1", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/four/five/testfile2", \ "/tmp/testStonixMacPkgr-0.0.3/one/testfile3", \ "/tmp/testStonixMacPkgr-0.0.3/one/testfile4", \ "/tmp/testStonixMacPkgr-0.0.3/one/six/seven/testfile"] self.post_files = ["/tmp/testStonixMacPkgr-0.0.3/one/postfile2", \ "/tmp/testStonixMacPkgr-0.0.3/one/two/three/3.5/postfile3"] self.post_dirs = ["/tmp/testStonixMacPkgr-0.0.3/one/six/6.5"] self.all_files = [self.pkg_files, self.post_files] self.all_dirs = [self.pkg_dirs, self.post_dirs] self.allowed_files_and_dirs = [self.pkg_dirs, self.pkg_dirs, self.post_dirs] self.ch = CommandHelper(self.logger) self.connection = Connectivity(self.logger) self.testDomain = "gov.lanl.testStonixMacPkgr.0.0.3.testStonixMacPkgr" ############################################################################ """
from distutils.version import LooseVersion sys.path.append("../../../..") from src.stonix_resources.FileStateManager import FileStateManager from src.stonix_resources.environment import Environment from src.stonix_resources.CommandHelper import CommandHelper from src.tests.lib.logdispatcher_lite import LogDispatcher, LogPriority from src.stonix_resources.get_libc import getLibc lp = LogPriority LIBC = getLibc() environ = Environment() environ.stonixversion = "1.2.3" logger = LogDispatcher(debug_mode=True) logger.initializeLogs("/tmp/zzzTestFrameworkFileStateManager", extension_type="time", syslog=False, myconsole=False) class NotApplicableToThisOS(Exception): """ Custom Exception """ def __init__(self, *args, **kwargs): Exception.__init__(self, *args, **kwargs) class zzzTestFrameworkFileStateManager(unittest.TestCase): """ Class for testing the FileStateManager. """ def setUp(self):
class zzzTestFrameworkSHlaunchdTwoHelperMethods(unittest.TestCase): ''' Test the launchd version 2 service helper. @author: Roy Nielsen ''' @classmethod def setUpClass(self): ''' Test initializer ''' self.environ = Environment() self.environ.setdebugmode(True) # Start timer in miliseconds self.test_start_time = datetime.now() self.logger = LogDispatcher(self.environ) self.logger.initializeLogs() self.sh = SHlaunchdTwo(self.environ, self.logger) self.logger.log(lp.DEBUG, "test " + __file__ + " initialized...") def test_isValidServicePath(self): ''' ''' for test_key, test_values in service_path_test_data.iteritems(): if re.match("^valid_service_paths", test_key): for test_item in test_values: self.assertTrue(self.sh.isValidServicePath(test_item), "Invalid service path: " + str(test_item)) if re.match("^invalid_service_paths", test_key): for test_item in test_values: self.assertFalse(self.sh.isValidServicePath(test_item), "Valid service path: " + str(test_item)) def test_getServiceNameFromService(self): ''' ''' for test_key, test_values in name_from_service_test_data.iteritems(): if re.match("^valid_service_plists", test_key): for test_item in test_values: self.assertTrue(self.sh.isValidServicePath(test_item), "Invalid service plist: " + str(test_item)) if re.match("^invalid_service_plists", test_key): for test_item in test_values: self.assertFalse(self.sh.isValidServicePath(test_item), "Valid service plist: " + str(test_item)) def test_targetValid(self): ''' ''' for test_key, test_values in target_valid_test_data.iteritems(): if re.match("^valid_target_data", test_key): for test_item in test_values: params = {test_item[1]['serviceName'][0]: test_item[1]['serviceName'][1]} self.assertEqual(self.sh.targetValid(test_item[0], **params), test_item[2], "Target data: " + str(test_item) + " is not valid.") if re.match("^invalid_target_data", test_key): for test_item in test_values: params = {test_item[1]['serviceName'][0]: test_item[1]['serviceName'][1]} self.assertNotEqual(self.sh.targetValid(test_item[0], **params), test_item[2], "Target data: " + str(test_item) + " is good!") @classmethod def tearDownClass(self): ''' Test destructor ''' ##### # capture end time test_end_time = datetime.now() ##### # Calculate and log how long it took... test_time = (test_end_time - self.test_start_time) self.logger.log(lp.DEBUG, self.__module__ + " took " + str(test_time) + " time to complete...")
class RuleTest(unittest.TestCase): def setUp(self): ''' Setup what we need for the test. @author: ekkehard j. koch @param self:essential if you override this definition ''' self.environ = Environment() self.environ.setverbosemode(True) self.environ.setdebugmode(True) self.config = Configuration(self.environ) self.logdispatch = LogDispatcher(self.environ) self.statechglogger = StateChgLogger(self.logdispatch, self.environ) self.rule = None self.rulename = "" self.rulenumber = "" self.checkUndo = False self.ignoreresults = False ############################################################################### def tearDown(self): ''' Release anything we no longer need what we need for the test. @author: ekkehard j. koch @param self:essential if you override this definition ''' pass ############################################################################### def simpleRuleTest(self): ''' Run a simple Report, Fix, Report Cycle @author: ekkehard j. koch @param self:essential if you override this definition ''' nextstep = True prefixHeadline = "################################################### " prefixRuleInfo = self.rulename + "(" + str(self.rulenumber) + "): " messagestring = "" # Make Rule Is supposed to run in this environment if nextstep: messagestring = "Make sure Rule Is supposed to run in this " + \ "environment" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) isapplicable = self.rule.isapplicable() messagestring = "rule.isapplicable() = " + str(isapplicable) self.logdispatch.log(LogPriority.DEBUG, prefixRuleInfo + messagestring) valueIsInList = isapplicable in [True, False] messagestring = "Invalid isapplicable Type!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) messagestring = "rule.isapplicable() = " + str(isapplicable) + \ " and should be True." self.assertTrue(isapplicable, prefixRuleInfo + messagestring) nextstep = isapplicable # Check to see if we are running in the right context if nextstep: messagestring = "Check to see if we are running in the " + \ "right context" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) effectiveUserID = self.environ.geteuid() messagestring = "environ.geteuid() = " + str(effectiveUserID) self.logdispatch.log(LogPriority.DEBUG, prefixRuleInfo + messagestring) isRootRequired = self.rule.getisrootrequired() messagestring = "rule.getisrootrequired() = " + str(isRootRequired) self.logdispatch.log(LogPriority.DEBUG, prefixRuleInfo + messagestring) if effectiveUserID == 0 and isRootRequired: nextstep = True elif not isRootRequired: nextstep = True else: nextstep = False messagestring = "Rule requires root and effective uid ='" + \ str(effectiveUserID) + "'" self.assertTrue(nextstep, prefixRuleInfo + messagestring) # Run setConditionsForRule to configure system for test if nextstep: messagestring = "Run setConditionsForRule to configure " + \ "system for test" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) setTestConditions = self.setConditionsForRule() self.logdispatch.log(LogPriority.DEBUG, "setConditionsForRule()" + " = " + str(setTestConditions)) if setTestConditions: nextstep = True else: nextstep = False messagestring = "setConditionsForRule() = " + \ str(setTestConditions) + "." self.assertTrue(setTestConditions, prefixRuleInfo + messagestring) # Run rule.report() if nextstep: messagestring = "Run rule.report()" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) report = self.rule.report() self.logdispatch.log(LogPriority.DEBUG, "rule.report() = " + str(report)) rulesuccess = self.rule.getrulesuccess() originalResults = self.rule.getdetailedresults() self.logdispatch.log(LogPriority.DEBUG, "rule.getrulesuccess() = " + str(rulesuccess)) valueIsInList = rulesuccess in [True, False] messagestring = "Invalid rule.getrulesuccess() Value'" + \ str(rulesuccess) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) if not rulesuccess: nextstep = False messagestring = ": rule.getrulesuccess() is '" + \ str(rulesuccess) + "'" self.assertTrue(rulesuccess, prefixRuleInfo + messagestring) rulecompliance = self.rule.iscompliant() self.logdispatch.log(LogPriority.DEBUG, "rule.iscompliant() = " + str(rulecompliance)) valueIsInList = rulecompliance in [True, False] messagestring = "Invalid rule.iscompliant() Value'" + \ str(rulecompliance) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) # Run checkReportForRule() messagestring = "Run checkReportForRule(" + str(rulecompliance) + \ ", " + str(rulesuccess) + ")" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) checkReportConditions = self.checkReportForRule(rulecompliance, rulesuccess) self.logdispatch.log(LogPriority.DEBUG, "checkReportForRule() = " + str(checkReportConditions)) if checkReportConditions and not rulecompliance: nextstep = True else: nextstep = False messagestring = ": Rule checkReportForRule() = " + \ str(checkReportConditions) + "." self.assertTrue(checkReportConditions, self.rulename + "(" + str(self.rulenumber) + "): Rule checkReportForRule() = " + str(checkReportConditions) + ".") # Run rule.fix() if nextstep: messagestring = "Run rule.fix()" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) fix = self.rule.fix() self.logdispatch.log(LogPriority.DEBUG, "rule.fix() = " + str(fix)) rulesuccess = self.rule.getrulesuccess() self.logdispatch.log(LogPriority.DEBUG, "rule.getrulesuccess() = " + str(rulesuccess)) valueIsInList = rulesuccess in [True, False] messagestring = "Invalid rule.rulesuccess() Value'" + \ str(rulesuccess) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) messagestring = "rule.getrulesuccess() = '" + \ str(rulesuccess) + "'" self.assertTrue(rulesuccess, prefixRuleInfo + messagestring) # Run checkFixForRule() messagestring = "Run checkFixForRule(" + str(rulesuccess) + ")" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) checkFixConditions = self.checkFixForRule(rulesuccess) self.logdispatch.log(LogPriority.DEBUG, "checkFixForRule(" + str(rulesuccess) + ")" + " = " + str(checkFixConditions)) if checkFixConditions and rulesuccess: nextstep = True else: nextstep = False messagestring = "Rule checkFixForRule() = " + \ str(checkFixConditions) + "." self.assertTrue(nextstep, prefixRuleInfo + messagestring) # Run rule.report() if nextstep: messagestring = "Run rule.report()" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) report = self.rule.report() self.logdispatch.log(LogPriority.DEBUG, "rule.report() = " + str(report)) rulesuccess = self.rule.getrulesuccess() self.logdispatch.log(LogPriority.DEBUG, "rule.getrulesuccess() = " + str(rulesuccess)) valueIsInList = rulesuccess in [True, False] messagestring = "Invalid rule.getrulesuccess() Value'" + \ str(rulesuccess) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) if not rulesuccess: nextstep = False self.assertTrue(rulesuccess, self.rulename + "(" + str(self.rulenumber) + "): rule.getrulesuccess() is '" + str(rulesuccess) + "' with reported error '" + str(self.rule.getdetailedresults()) + "'") rulecompliance = self.rule.iscompliant() self.logdispatch.log(LogPriority.DEBUG, "rule.iscompliant() = " + str(rulecompliance)) valueIsInList = rulecompliance in [True, False] messagestring = "Invalid rule.iscompliant() Value'" + \ str(rulecompliance) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) messagestring = "rule.iscompliant() is '" + \ str(rulecompliance) + "' after rule.fix() and " + \ "rule.report() have run." if not self.ignoreresults: self.assertTrue(rulecompliance, prefixRuleInfo + messagestring) # Run checkReportFinalForRule() messagestring = "Run checkReportFinalForRule(" + \ str(rulecompliance) + ", " + str(rulesuccess) + ")" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) checkReportFinalConditions = self.checkReportFinalForRule(rulecompliance, rulesuccess) self.logdispatch.log(LogPriority.DEBUG, "checkReportFinalForRule() = " + str(checkReportFinalConditions)) if checkReportFinalConditions and rulecompliance: nextstep = True else: nextstep = False self.assertTrue(checkReportFinalConditions, self.rulename + "(" + str(self.rulenumber) + "): Rule checkReportFinalForRule() = " + str(checkReportFinalConditions) + ".") # Run rule.undo() if nextstep and self.checkUndo: messagestring = "Run rule.undo()" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) undo = self.rule.undo() self.logdispatch.log(LogPriority.DEBUG, "rule.undo() = " + str(undo)) self.rule.report() postUndoResults = self.rule.getdetailedresults() # In order to get detailed, well-formatted error information, this # has been turned into a short procedure to produce the most # helpful information, rather than simply using the assert # statement if originalResults != postUndoResults: orlines = originalResults.splitlines() pulines = postUndoResults.splitlines() orlinestmp = orlines[:] # [:] to copy by value r/t reference for line in orlinestmp: if line in pulines: orlines.remove(line) pulines.remove(line) error = "After undo, the report results were not the same " + \ "as the initial pre-fix report." if orlines: error += "\nOnly in original:\n" + "\n".join(orlines) if pulines: error += "\nOnly in post-undo:\n" + "\n".join(pulines) self.assertTrue(False, error) # Run checkUndoForRule() messagestring = "Run checkUndoForRule(" + str(rulesuccess) + ")" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) checkUndoConditions = self.checkUndoForRule(rulesuccess) self.logdispatch.log(LogPriority.DEBUG, "checkUndoForRule()" + " = " + str(checkUndoConditions)) if checkUndoConditions and not rulecompliance: nextstep = True else: nextstep = False self.assertTrue(checkUndoConditions, self.rulename + "(" + str(self.rulenumber) + "): Rule checkUndoForRule() = " + str(checkUndoConditions) + ".") return nextstep ############################################################################### def setConditionsForRule(self): return True ############################################################################### def checkReportForRule(self, pCompliance, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pCompliance = " + str(pCompliance) + ".") self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + str(pRuleSuccess) + ".") return True ############################################################################### def checkFixForRule(self, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + str(pRuleSuccess) + ".") return True ############################################################################### def checkReportFinalForRule(self, pCompliance, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pCompliance = " + str(pCompliance) + ".") self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + str(pRuleSuccess) + ".") return True ############################################################################### def checkUndoForRule(self, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + str(pRuleSuccess) + ".") return True ############################################################################### def setCheckUndo(self, checkUndo): self.checkUndo = checkUndo ############################################################################### def getCheckUndo(self): return self.checkUndo ############################################################################### def runDestructive(self): return os.path.exists("/etc/stonix-destructive")
class ManageUser(object): """ Class to manage user properties. @author: Roy Nielsen """ def __init__(self, userName="", userShell="/bin/bash", userComment="", userUid=10000, userPriGid=20, userHomeDir="/tmp", logger=False): self.module_version = '20160225.125554.540679' ##### # Set up logging self.logger = LogDispatcher() ##### # THIS IS A LIBRARY, SO LOGS SHOULD BE INITIALIZED ELSEWHERE... # self.logger.initializeLogs() self.logger.log(lp.INFO, "Logger: " + str(self.logger)) """ if self.isSaneUserName(userName): self.userName = userName else: raise BadUserInfoError("Need a valid user name...") if self.isSaneUserShell(userShell): self.userShell = userShell else: raise BadUserInfoError("Need a valid user shell...") if self.isSaneUserComment(userComment): self.userComment = userComment else: self.userComment="" if self.isSaneUserUid(str(userUid)): self.userUid = self.userUid else: raise BadUserInfoError("Need a valid user UID...") if self.isSaneUserPriGid(str(userPriGid)): self.userUid = userUid else: raise BadUserInfoError("Need a valid user Primary GID...") if self.isSaneUserHomeDir(userHomeDir): self.userHomeDir = userHomeDir else: raise BadUserInfoError("Need a user Home Directory...") """ def isSaneUserName(self, userName=""): """ """ sane = False if userName and isinstance(userName, basestring): if re.match("^[A-Za-z][A-Za-z0-9]*", userName): sane = True return sane def isSaneGroupName(self, groupName=""): """ """ sane = False if groupName and isinstance(groupName, basestring): if re.match("^[A-Za-z][A-Za-z0-9]*", groupName): sane = True return sane def isSaneUserShell(self, userShell=""): """ """ sane = False if userShell and isinstance(userShell, basestring): if re.match("^[A-Za-z/][A-Za-z0-9/]*", userShell): sane = True return sane def isSaneUserComment(self, userComment=""): """ """ sane = False if userComment and isinstance(userComment, basestring): if re.match("^[A-Za-z][A-Za-z0-9]*", userComment): sane = True return sane def isSaneUserUid(self, userUid=""): """ """ sane = False if userUid and isinstance(userUid, [basestring, int]): if re.match("^\d+", str(userUid)): sane = True return sane def isSaneUserPriGid(self, userPriGid=1000): """ """ sane = False if userPriGid and isinstance(userPriGid, [basestring, int]): if re.match("^\d+", str(userPriGid)): sane = True return sane def isSaneUserHomeDir(self, userHomeDir=""): """ """ sane = False if userHomeDir and isinstance(userHomeDir, basestring): if re.match("^[A-Za-z/][A-Za-z0-9/]*", userHomeDir): sane = True return sane def setUserName(self, userName=""): """ """ sane = False if self.isSaneUserName(userName): sane = True self.userName = userName return sane def setUserShell(self, user="", shell=""): """ """ pass def setUserComment(self, user="", comment=""): """ """ pass def setUserUid(self, user="", uid=""): """ """ pass def setUserPriGid(self, user="", priGid=""): """ """ pass def setUserHomeDir(self, user="", userHome = ""): """ """ pass def addUserToGroup(self, user="", group=""): """ """ pass def setUserPassword(self, user="", password=""): """ """ pass
class zzzTestFrameworkRamdisk(unittest.TestCase): @classmethod def setUpClass(self): """ Initializer """ self.environ = Environment() # Start timer in miliseconds self.test_start_time = datetime.now() self.logger = LogDispatcher(self.environ) ##### # setting up to call ctypes to do a filesystem sync if self.environ.getosfamily() == "redhat" : self.libc = C.CDLL("/lib/libc.so.6") elif self.environ.getosfamily() == "darwin" : self.libc = C.CDLL("/usr/lib/libc.dylib") else: self.libc = None self.subdirs = ["two", "three" "one/four"] """ Set up a ramdisk and use that random location as a root to test the filesystem functionality of what is being tested. """ #Calculate size of ramdisk to make for this unit test. size_in_mb = 1800 ramdisk_size = size = size_in_mb self.mnt_pnt_requested = "" self.success = False self.mountPoint = False self.ramdiskDev = False self.mnt_pnt_requested = False self.logger.log(LogPriority.DEBUG, "::::::::Ramdisk Mount Point: " + str(self.mountPoint)) self.logger.log(LogPriority.DEBUG, "::::::::Ramdisk Device : " + str(self.ramdiskDev)) if self.environ.getosfamily().lower() == "darwin": # import appropriate ramdisk library #from src.MacBuild.macRamdisk import Ramdisk, detach # get a ramdisk of appropriate size, with a secure random mountpoint self.my_ramdisk = RamDisk(str(ramdisk_size), self.mnt_pnt_requested) (self.success, self.mountPoint, self.ramdiskDev) = \ self.my_ramdisk.get_data() else: self.logger.log(LogPriority.INFO, "Not applicable to this OS") self.success = False if not self.success: raise IOError("Cannot get a ramdisk for some reason. . .") ##### # Create a temp location on disk to run benchmark tests against self.fs_dir = tempfile.mkdtemp() def setUp(self): """ This method runs before each test run. @author: Roy Nielsen """ self.libcPath = None # initial initialization ##### # setting up to call ctypes to do a filesystem sync if sys.platform.startswith("darwin"): ##### # For Mac self.libc = C.CDLL("/usr/lib/libc.dylib") elif sys.platform.startswith("linux"): ##### # For Linux self.findLinuxLibC() self.libc = C.CDLL(self.libcPath) else: self.libc = self._pass() ############################################################################### ##### Helper Classes def findLinuxLibC(self): """ Find Linux Libc library... @author: Roy Nielsen """ possible_paths = ["/lib/x86_64-linux-gnu/libc.so.6", "/lib/i386-linux-gnu/libc.so.6"] for path in possible_paths: if os.path.exists(path): self.libcPath = path break def _pass(self): """ Filler if a library didn't load properly """ pass def touch(self, fname="", message_level="normal") : """ Python implementation of the touch command.. inspiration: http://stackoverflow.com/questions/1158076/implement-touch-using-python @author: Roy Nielsen """ if re.match("^\s*$", str(fname)): self.logger.log(LogPriority.DEBUG, "Cannot touch a file without a filename....") else : try: os.utime(fname, None) except: try : open(fname, 'a').close() except Exception, err: self.logger.log(LogPriority.INFO,"Cannot open to touch: " + str(fname))
class zzzTestFrameworkHelpLinks(unittest.TestCase): """ Class for testing the HelpLinks """ def setUp(self): """ set up handlers and objects and any other conditions for use in the class """ self.environ = Environment() self.logger = LogDispatcher(self.environ) # build proxy (if needed), handlers and opener for urllib2.urlopen connections context = ssl._create_unverified_context() if PROXY: proxy = urllib2.ProxyHandler({"http": PROXY, "https": PROXY}) opener = urllib2.build_opener(urllib2.HTTPHandler(), urllib2.HTTPSHandler(context=context), proxy) else: opener = urllib2.build_opener(urllib2.HTTPHandler(), urllib2.HTTPSHandler(context=context)) urllib2.install_opener(opener) def get_links(self): """ return a (unique) list of all web links in all html help files in stonix help folder @return: help_files_list @rtype: list @author: Breen Malmberg """ help_files_list = self.get_help_files() help_links = [] # search each file for web links for hf in help_files_list: f = open(hf, "r") contentlines = f.readlines() f.close() # append web link help_links when found for line in contentlines: urls = re.findall("https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+", line) for u in urls: help_links.append(u) # remove any duplicates from links list # (we don't need to check each link more than once...) help_links = list(dict.fromkeys(help_links)) return help_links def get_help_files(self): """ return a list of all html help files within stonix help folder @return: help_files_list @rtype: list @author: Breen Malmberg """ help_files_list = [] # set help directory path from stonix source tree currpath = os.path.abspath(os.path.dirname(__file__)) helpdir = os.path.join(currpath, "../../../stonix_resources/help/") # add all html files in help directory for dir,_,filen in os.walk(helpdir): for f in filen: full_file_path = os.path.join(dir, f) try: if os.path.splitext(full_file_path)[1] == ".html": help_files_list.append(full_file_path) except IndexError: pass except: raise return help_files_list def test_links(self): """ test all web links to make sure each one is reachable/valid @author: Breen Malmberg """ help_links = self.get_links() try: for link in help_links: connection = urllib2.urlopen(link) print("\nTESTING CONNECTION TO: " + link + "\n") if not self.assertIsNotNone(connection): print("connection established\n") print("\nTESTING GETURL() OF CONNECTION\n") url = connection.geturl() self.assertNotEqual(url, "") self.assertIsNotNone(url) print("url = " + url + "\n") # close each connection after use if connection: connection.close() # test output separator print("=================================================") except AttributeError: # python version 2.6* and earlier does not support assertIsNotNone() self.logger.log(LogPriority.DEBUG, "Current system's version of python does not support the assertion calls used in this unit test") pass except: raise
from distutils.version import LooseVersion sys.path.append("../../../..") from src.stonix_resources.FileStateManager import FileStateManager from src.stonix_resources.environment import Environment from src.stonix_resources.CommandHelper import CommandHelper from src.tests.lib.logdispatcher_lite import LogDispatcher, LogPriority from src.stonix_resources.get_libc import getLibc lp = LogPriority LIBC = getLibc() environ = Environment() environ.stonixversion = "1.2.3" logger = LogDispatcher(debug_mode=True) logger.initializeLogs("/tmp/zzzTestFrameworkFileStateManager", extension_type="time", syslog=False, myconsole=False) class NotApplicableToThisOS(Exception): '''Custom Exception''' def __init__(self, *args, **kwargs): Exception.__init__(self, *args, **kwargs) class zzzTestFrameworkFileStateManager(unittest.TestCase): '''Class for testing the FileStateManager.''' def setUp(self):
class zzzTestFrameworkSHlaunchdTwoHelperMethods(unittest.TestCase): '''Test the launchd version 2 service helper. @author: Roy Nielsen ''' @classmethod def setUpClass(self): '''Test initializer''' self.environ = Environment() self.environ.setdebugmode(True) # Start timer in miliseconds self.test_start_time = datetime.now() self.logger = LogDispatcher(self.environ) self.logger.initializeLogs() self.sh = SHlaunchdTwo(self.environ, self.logger) self.logger.log(lp.DEBUG, "test " + __file__ + " initialized...") def test_isValidServicePath(self): ''' ''' for test_key, test_values in list(service_path_test_data.items()): if re.match("^valid_service_paths", test_key): for test_item in test_values: self.assertTrue( self.sh.isValidServicePath(test_item), "Invalid service path: " + str(test_item)) if re.match("^invalid_service_paths", test_key): for test_item in test_values: self.assertFalse( self.sh.isValidServicePath(test_item), "Valid service path: " + str(test_item)) def test_getServiceNameFromService(self): ''' ''' for test_key, test_values in list( name_from_service_test_data.items()): if re.match("^valid_service_plists", test_key): for test_item in test_values: self.assertTrue( self.sh.isValidServicePath(test_item), "Invalid service plist: " + str(test_item)) if re.match("^invalid_service_plists", test_key): for test_item in test_values: self.assertFalse( self.sh.isValidServicePath(test_item), "Valid service plist: " + str(test_item)) def test_targetValid(self): ''' ''' for test_key, test_values in list(target_valid_test_data.items()): if re.match("^valid_target_data", test_key): for test_item in test_values: params = { test_item[1]['serviceName'][0]: test_item[1]['serviceName'][1] } self.assertEqual( self.sh.targetValid(test_item[0], **params), test_item[2], "Target data: " + str(test_item) + " is not valid.") if re.match("^invalid_target_data", test_key): for test_item in test_values: params = { test_item[1]['serviceName'][0]: test_item[1]['serviceName'][1] } self.assertNotEqual( self.sh.targetValid(test_item[0], **params), test_item[2], "Target data: " + str(test_item) + " is good!") @classmethod def tearDownClass(self): '''Test destructor''' ##### # capture end time test_end_time = datetime.now() ##### # Calculate and log how long it took... test_time = (test_end_time - self.test_start_time) self.logger.log( lp.DEBUG, self.__module__ + " took " + str(test_time) + " time to complete...")
class zzzTestFrameworkHelpLinks(unittest.TestCase): '''Class for testing the HelpLinks''' def setUp(self): '''set up handlers and objects and any other conditions for use in the class''' self.environ = Environment() self.logger = LogDispatcher(self.environ) # build proxy (if needed), handlers and opener for urllib2.urlopen connections context = ssl._create_unverified_context() if PROXY: proxy = urllib.request.ProxyHandler({ "http": PROXY, "https": PROXY }) opener = urllib.request.build_opener( urllib.request.HTTPHandler(), urllib.request.HTTPSHandler(context=context), proxy) else: opener = urllib.request.build_opener( urllib.request.HTTPHandler(), urllib.request.HTTPSHandler(context=context)) urllib.request.install_opener(opener) def get_links(self): '''return a (unique) list of all web links in all html help files in stonix help folder :returns: help_files_list :rtype: list @author: Breen Malmberg ''' help_files_list = self.get_help_files() help_links = [] # search each file for web links for hf in help_files_list: f = open(hf, "r") contentlines = f.readlines() f.close() # append web link help_links when found for line in contentlines: urls = re.findall("https?://(?:[-\w.]|(?:%[\da-fA-F]{2}))+", line) for u in urls: help_links.append(u) # remove any duplicates from links list # (we don't need to check each link more than once...) help_links = list(dict.fromkeys(help_links)) return help_links def get_help_files(self): '''return a list of all html help files within stonix help folder :returns: help_files_list :rtype: list @author: Breen Malmberg ''' help_files_list = [] # set help directory path from stonix source tree currpath = os.path.abspath(os.path.dirname(__file__)) helpdir = os.path.join(currpath, "../../../stonix_resources/help/") # add all html files in help directory for dir, _, filen in os.walk(helpdir): for f in filen: full_file_path = os.path.join(dir, f) try: if os.path.splitext(full_file_path)[1] == ".html": help_files_list.append(full_file_path) except IndexError: pass except: raise return help_files_list def test_links(self): '''test all web links to make sure each one is reachable/valid @author: Breen Malmberg ''' help_links = self.get_links() try: for link in help_links: connection = urllib.request.urlopen(link) print(("\nTESTING CONNECTION TO: " + link + "\n")) if not self.assertIsNotNone(connection): print("connection established\n") print("\nTESTING GETURL() OF CONNECTION\n") url = connection.geturl() self.assertNotEqual(url, "") self.assertIsNotNone(url) print(("url = " + url + "\n")) # close each connection after use if connection: connection.close() # test output separator print("=================================================") except AttributeError: # python version 2.6* and earlier does not support assertIsNotNone() self.logger.log( LogPriority.DEBUG, "Current system's version of python does not support the assertion calls used in this unit test" ) pass except: raise
class RuleTest(unittest.TestCase): def setUp(self): '''Setup what we need for the test. @author: ekkehard j. koch :param self: essential if you override this definition ''' self.environ = Environment() self.environ.setverbosemode(True) self.environ.setdebugmode(True) self.config = Configuration(self.environ) self.logdispatch = LogDispatcher(self.environ) self.statechglogger = StateChgLogger(self.logdispatch, self.environ) self.rule = None self.rulename = "" self.rulenumber = "" self.checkUndo = False self.ignoreresults = False ############################################################################### def tearDown(self): '''Release anything we no longer need what we need for the test. @author: ekkehard j. koch :param self: essential if you override this definition ''' pass ############################################################################### def simpleRuleTest(self): '''Run a simple Report, Fix, Report Cycle @author: ekkehard j. koch :param self: essential if you override this definition ''' nextstep = True prefixHeadline = "################################################### " prefixRuleInfo = self.rulename + "(" + str(self.rulenumber) + "): " messagestring = "" # Make Rule Is supposed to run in this environment if nextstep: messagestring = "Make sure Rule Is supposed to run in this " + \ "environment" self.logdispatch.log( LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) isapplicable = self.rule.isapplicable() messagestring = "rule.isapplicable() = " + str(isapplicable) self.logdispatch.log(LogPriority.DEBUG, prefixRuleInfo + messagestring) valueIsInList = isapplicable in [True, False] messagestring = "Invalid isapplicable Type!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) messagestring = "rule.isapplicable() = " + str(isapplicable) + \ " and should be True." self.assertTrue(isapplicable, prefixRuleInfo + messagestring) nextstep = isapplicable # Check to see if we are running in the right context if nextstep: messagestring = "Check to see if we are running in the " + \ "right context" self.logdispatch.log( LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) effectiveUserID = self.environ.geteuid() messagestring = "environ.geteuid() = " + str(effectiveUserID) self.logdispatch.log(LogPriority.DEBUG, prefixRuleInfo + messagestring) isRootRequired = self.rule.getisrootrequired() messagestring = "rule.getisrootrequired() = " + str(isRootRequired) self.logdispatch.log(LogPriority.DEBUG, prefixRuleInfo + messagestring) if effectiveUserID == 0 and isRootRequired: nextstep = True elif not isRootRequired: nextstep = True else: nextstep = False messagestring = "Rule requires root and effective uid ='" + \ str(effectiveUserID) + "'" self.assertTrue(nextstep, prefixRuleInfo + messagestring) # Run setConditionsForRule to configure system for test if nextstep: messagestring = "Run setConditionsForRule to configure " + \ "system for test" self.logdispatch.log( LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) setTestConditions = self.setConditionsForRule() self.logdispatch.log( LogPriority.DEBUG, "setConditionsForRule()" + " = " + str(setTestConditions)) if setTestConditions: nextstep = True else: nextstep = False messagestring = "setConditionsForRule() = " + \ str(setTestConditions) + "." self.assertTrue(setTestConditions, prefixRuleInfo + messagestring) # Run rule.report() if nextstep: messagestring = "Run rule.report()" self.logdispatch.log( LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) report = self.rule.report() self.logdispatch.log(LogPriority.DEBUG, "rule.report() = " + str(report)) rulesuccess = self.rule.getrulesuccess() originalResults = self.rule.getdetailedresults() self.logdispatch.log(LogPriority.DEBUG, "rule.getrulesuccess() = " + str(rulesuccess)) valueIsInList = rulesuccess in [True, False] messagestring = "Invalid rule.getrulesuccess() Value'" + \ str(rulesuccess) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) if not rulesuccess: nextstep = False messagestring = ": rule.getrulesuccess() is '" + \ str(rulesuccess) + "'" self.assertTrue(rulesuccess, prefixRuleInfo + messagestring) rulecompliance = self.rule.iscompliant() self.logdispatch.log(LogPriority.DEBUG, "rule.iscompliant() = " + str(rulecompliance)) valueIsInList = rulecompliance in [True, False] messagestring = "Invalid rule.iscompliant() Value'" + \ str(rulecompliance) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) # Run checkReportForRule() messagestring = "Run checkReportForRule(" + str(rulecompliance) + \ ", " + str(rulesuccess) + ")" self.logdispatch.log( LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) checkReportConditions = self.checkReportForRule( rulecompliance, rulesuccess) self.logdispatch.log( LogPriority.DEBUG, "checkReportForRule() = " + str(checkReportConditions)) if checkReportConditions and not rulecompliance: nextstep = True else: nextstep = False messagestring = ": Rule checkReportForRule() = " + \ str(checkReportConditions) + "." self.assertTrue( checkReportConditions, self.rulename + "(" + str(self.rulenumber) + "): Rule checkReportForRule() = " + str(checkReportConditions) + ".") # Run rule.fix() if nextstep: messagestring = "Run rule.fix()" self.logdispatch.log( LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) fix = self.rule.fix() self.logdispatch.log(LogPriority.DEBUG, "rule.fix() = " + str(fix)) rulesuccess = self.rule.getrulesuccess() self.logdispatch.log(LogPriority.DEBUG, "rule.getrulesuccess() = " + str(rulesuccess)) valueIsInList = rulesuccess in [True, False] messagestring = "Invalid rule.rulesuccess() Value'" + \ str(rulesuccess) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) messagestring = "rule.getrulesuccess() = '" + \ str(rulesuccess) + "'" self.assertTrue(rulesuccess, prefixRuleInfo + messagestring) # Run checkFixForRule() messagestring = "Run checkFixForRule(" + str(rulesuccess) + ")" self.logdispatch.log( LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) checkFixConditions = self.checkFixForRule(rulesuccess) self.logdispatch.log( LogPriority.DEBUG, "checkFixForRule(" + str(rulesuccess) + ")" + " = " + str(checkFixConditions)) if checkFixConditions and rulesuccess: nextstep = True else: nextstep = False messagestring = "Rule checkFixForRule() = " + \ str(checkFixConditions) + "." self.assertTrue(nextstep, prefixRuleInfo + messagestring) # Run rule.report() if nextstep: messagestring = "Run rule.report()" self.logdispatch.log( LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) report = self.rule.report() self.logdispatch.log(LogPriority.DEBUG, "rule.report() = " + str(report)) rulesuccess = self.rule.getrulesuccess() self.logdispatch.log(LogPriority.DEBUG, "rule.getrulesuccess() = " + str(rulesuccess)) valueIsInList = rulesuccess in [True, False] messagestring = "Invalid rule.getrulesuccess() Value'" + \ str(rulesuccess) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) if not rulesuccess: nextstep = False self.assertTrue( rulesuccess, self.rulename + "(" + str(self.rulenumber) + "): rule.getrulesuccess() is '" + str(rulesuccess) + "' with reported error '" + str(self.rule.getdetailedresults()) + "'") rulecompliance = self.rule.iscompliant() self.logdispatch.log(LogPriority.DEBUG, "rule.iscompliant() = " + str(rulecompliance)) valueIsInList = rulecompliance in [True, False] messagestring = "Invalid rule.iscompliant() Value'" + \ str(rulecompliance) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) messagestring = "rule.iscompliant() is '" + \ str(rulecompliance) + "' after rule.fix() and " + \ "rule.report() have run." if not self.ignoreresults: self.assertTrue(rulecompliance, prefixRuleInfo + messagestring) # Run checkReportFinalForRule() messagestring = "Run checkReportFinalForRule(" + \ str(rulecompliance) + ", " + str(rulesuccess) + ")" self.logdispatch.log( LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) checkReportFinalConditions = self.checkReportFinalForRule( rulecompliance, rulesuccess) self.logdispatch.log( LogPriority.DEBUG, "checkReportFinalForRule() = " + str(checkReportFinalConditions)) if checkReportFinalConditions and rulecompliance: nextstep = True else: nextstep = False self.assertTrue( checkReportFinalConditions, self.rulename + "(" + str(self.rulenumber) + "): Rule checkReportFinalForRule() = " + str(checkReportFinalConditions) + ".") # Run rule.undo() if nextstep and self.checkUndo: messagestring = "Run rule.undo()" self.logdispatch.log( LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) undo = self.rule.undo() self.logdispatch.log(LogPriority.DEBUG, "rule.undo() = " + str(undo)) self.rule.report() postUndoResults = self.rule.getdetailedresults() # In order to get detailed, well-formatted error information, this # has been turned into a short procedure to produce the most # helpful information, rather than simply using the assert # statement if originalResults != postUndoResults: orlines = originalResults.splitlines() pulines = postUndoResults.splitlines() orlinestmp = orlines[:] # [:] to copy by value r/t reference for line in orlinestmp: if line in pulines: orlines.remove(line) pulines.remove(line) error = "After undo, the report results were not the same " + \ "as the initial pre-fix report." if orlines: error += "\nOnly in original:\n" + "\n".join(orlines) if pulines: error += "\nOnly in post-undo:\n" + "\n".join(pulines) self.assertTrue(False, error) # Run checkUndoForRule() messagestring = "Run checkUndoForRule(" + str(rulesuccess) + ")" self.logdispatch.log( LogPriority.DEBUG, prefixHeadline + prefixRuleInfo + messagestring) checkUndoConditions = self.checkUndoForRule(rulesuccess) self.logdispatch.log( LogPriority.DEBUG, "checkUndoForRule()" + " = " + str(checkUndoConditions)) if checkUndoConditions and not rulecompliance: nextstep = True else: nextstep = False self.assertTrue( checkUndoConditions, self.rulename + "(" + str(self.rulenumber) + "): Rule checkUndoForRule() = " + str(checkUndoConditions) + ".") return nextstep ############################################################################### def setConditionsForRule(self): return True ############################################################################### def checkReportForRule(self, pCompliance, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pCompliance = " + str(pCompliance) + ".") self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + str(pRuleSuccess) + ".") return True ############################################################################### def checkFixForRule(self, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + str(pRuleSuccess) + ".") return True ############################################################################### def checkReportFinalForRule(self, pCompliance, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pCompliance = " + str(pCompliance) + ".") self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + str(pRuleSuccess) + ".") return True ############################################################################### def checkUndoForRule(self, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + str(pRuleSuccess) + ".") return True ############################################################################### def setCheckUndo(self, checkUndo): self.checkUndo = checkUndo ############################################################################### def getCheckUndo(self): return self.checkUndo ############################################################################### def runDestructive(self): return os.path.exists("/etc/stonix-destructive")
class RuleTest(unittest.TestCase): ############################################################################### def setUp(self): ''' Setup what we need for the test. @author: ekkehard j. koch @param self:essential if you override this definition ''' self.environ = Environment() self.environ.setverbosemode(True) self.environ.setdebugmode(True) self.config = Configuration(self.environ) self.logdispatch = LogDispatcher(self.environ) self.statechglogger = StateChgLogger(self.logdispatch, self.environ) self.rule = None self.rulename = "" self.rulenumber = "" ############################################################################### def tearDown(self): ''' Release anything we no longer need what we need for the test. @author: ekkehard j. koch @param self:essential if you override this definition ''' pass ############################################################################### def simpleRuleTest(self): ''' Run a simple Report, Fix, Report Cycle @author: ekkehard j. koch @param self:essential if you override this definition ''' nextstep = True prefixHeadline = "################################################### " prefixRuleInfo = self.rulename + "(" + str(self.rulenumber) + "): " messagestring = "" # Make Rule Is supposed to run in this environment if nextstep: messagestring = "Make sure Rule Is supposed to run in this " + \ "environment" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) isapplicable = self.rule.isapplicable() messagestring = "rule.isapplicable() = " + str(isapplicable) self.logdispatch.log(LogPriority.DEBUG, prefixRuleInfo + \ messagestring) valueIsInList = isapplicable in [True, False] messagestring = "Invalid isapplicable Type!" self.assertTrue(valueIsInList, prefixRuleInfo + \ messagestring) messagestring = "rule.isapplicable() = " + str(isapplicable) + \ " and should be True." self.assertTrue(isapplicable, prefixRuleInfo + \ messagestring) nextstep = isapplicable # Check to see if we are running in the right context if nextstep: messagestring = "Check to see if we are running in the " + \ "right context" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) effectiveUserID = self.environ.geteuid() messagestring = "environ.geteuid() = " + str(effectiveUserID) self.logdispatch.log(LogPriority.DEBUG, prefixRuleInfo + \ messagestring) isRootRequired = self.rule.getisrootrequired() messagestring = "rule.getisrootrequired() = " + str(isRootRequired) self.logdispatch.log(LogPriority.DEBUG, prefixRuleInfo + \ messagestring) if effectiveUserID == 0 and isRootRequired: nextstep = True elif not isRootRequired: nextstep = True else: nextstep = False messagestring = "Rule requires root and effective uid ='" + \ str(effectiveUserID) + "'" self.assertTrue(nextstep, prefixRuleInfo + \ messagestring) # Run setConditionsForRule to configure system for test if nextstep: messagestring = "Run setConditionsForRule to configure " + \ "system for test" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) setTestConditions = self.setConditionsForRule() self.logdispatch.log(LogPriority.DEBUG, "setConditionsForRule()" + \ " = " + \ str(setTestConditions)) if setTestConditions: nextstep = True else: nextstep = False messagestring = "setConditionsForRule() = " + \ str(setTestConditions) + "." self.assertTrue(setTestConditions, prefixRuleInfo + \ messagestring) # Run rule.report() if nextstep: messagestring = "Run rule.report()" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) report = self.rule.report() self.logdispatch.log(LogPriority.DEBUG, "rule.report() = " + \ str(report)) rulesuccess = self.rule.getrulesuccess() self.logdispatch.log(LogPriority.DEBUG, "rule.getrulesuccess() = " + \ str(rulesuccess)) valueIsInList = rulesuccess in [True, False] messagestring = "Invalid rule.getrulesuccess() Value'" + \ str(rulesuccess) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) if not rulesuccess: nextstep = False messagestring = ": rule.getrulesuccess() is '" + \ str(rulesuccess) + "'" self.assertTrue(rulesuccess, prefixRuleInfo + messagestring) rulecompliance = self.rule.iscompliant() self.logdispatch.log(LogPriority.DEBUG, "rule.iscompliant() = " + \ str(rulecompliance)) valueIsInList = rulecompliance in [True, False] messagestring = "Invalid rule.iscompliant() Value'" + \ str(rulecompliance) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) # Run checkReportForRule() messagestring = "Run checkReportForRule(" + str(rulecompliance) + \ ", " + str(rulesuccess) + ")" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) checkReportConditions = self.checkReportForRule( rulecompliance, rulesuccess) self.logdispatch.log(LogPriority.DEBUG, "checkReportForRule()" + \ " = " + \ str(checkReportConditions)) if checkReportConditions and not rulecompliance: nextstep = True else: nextstep = False messagestring = ": Rule checkReportForRule() = " + \ str(checkReportConditions) + "." self.assertTrue(checkReportConditions, prefixRuleInfo + \ messagestring) self.assertTrue(checkReportConditions, self.rulename + "(" + str(self.rulenumber) + ")" + ": Rule " + \ "checkReportForRule() = " + \ str(checkReportConditions) + ".") # Run rule.fix() if nextstep: messagestring = "Run rule.fix()" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) fix = self.rule.fix() self.logdispatch.log(LogPriority.DEBUG, "rule.fix() = " + \ str(fix)) rulesuccess = self.rule.getrulesuccess() self.logdispatch.log(LogPriority.DEBUG, "rule.getrulesuccess() = " + \ str(rulesuccess)) valueIsInList = rulesuccess in [True, False] messagestring = "Invalid rule.rulesuccess() Value'" + \ str(rulesuccess) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) messagestring = "rule.getrulesuccess() = '" + \ str(rulesuccess) + "'" self.assertTrue(rulesuccess, prefixRuleInfo + messagestring) # Run checkFixForRule() messagestring = "Run checkFixForRule(" + str(rulesuccess) + ")" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) checkFixConditions = self.checkFixForRule(rulesuccess) self.logdispatch.log(LogPriority.DEBUG, "checkFixForRule(" + str(rulesuccess) + \ ")" + " = " + \ str(checkFixConditions)) if checkFixConditions and rulesuccess: nextstep = True else: nextstep = False messagestring = "Rule checkFixForRule() = " + \ str(checkFixConditions) + "." self.assertTrue(nextstep, prefixRuleInfo + messagestring) # Run rule.report() if nextstep: messagestring = "Run rule.report()" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) report = self.rule.report() self.logdispatch.log(LogPriority.DEBUG, "rule.report() = " + \ str(report)) rulesuccess = self.rule.getrulesuccess() self.logdispatch.log(LogPriority.DEBUG, "rule.getrulesuccess() = " + \ str(rulesuccess)) valueIsInList = rulesuccess in [True, False] messagestring = "Invalid rule.getrulesuccess() Value'" + \ str(rulesuccess) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) if not rulesuccess: nextstep = False self.assertTrue(rulesuccess, self.rulename + "(" + str(self.rulenumber) + ")" + ": rule.getrulesuccess() is '" + \ str(rulesuccess) + "' with reported error '" + \ str(self.rule.getdetailedresults())) rulecompliance = self.rule.iscompliant() self.logdispatch.log(LogPriority.DEBUG, "rule.iscompliant() = " + \ str(rulecompliance)) valueIsInList = rulecompliance in [True, False] messagestring = "Invalid rule.iscompliant() Value'" + \ str(rulecompliance) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) messagestring = "rule.iscompliant() is '" + \ str(rulecompliance) + "' after rule.fix() and rule.report() " + \ "have run." self.assertTrue(rulecompliance, prefixRuleInfo + messagestring) if rulecompliance: nextstep = False return nextstep ############################################################################### def setConditionsForRule(self): return True ############################################################################### def checkReportForRule(self, pCompliance, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pCompliance = " + \ str(pCompliance) + ".") self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + \ str(pRuleSuccess) + ".") return True ############################################################################### def checkFixForRule(self, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + \ str(pRuleSuccess) + ".") return True ############################################################################### def checkUndoForRule(self, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + \ str(pRuleSuccess) + ".") return True
class zzzTestFrameworkRamdisk(unittest.TestCase): @classmethod def setUpClass(self): '''Initializer''' self.environ = Environment() # Start timer in miliseconds self.test_start_time = datetime.now() self.logger = LogDispatcher(self.environ) ##### # setting up to call ctypes to do a filesystem sync if self.environ.getosfamily() == "redhat": self.libc = C.CDLL("/lib/libc.so.6") elif self.environ.getosfamily() == "darwin": self.libc = C.CDLL("/usr/lib/libc.dylib") else: self.libc = None self.subdirs = ["two", "three" "one/four"] """ Set up a ramdisk and use that random location as a root to test the filesystem functionality of what is being tested. """ #Calculate size of ramdisk to make for this unit test. size_in_mb = 1800 ramdisk_size = size = size_in_mb self.mnt_pnt_requested = "" self.success = False self.mountPoint = False self.ramdiskDev = False self.mnt_pnt_requested = False self.logger.log(LogPriority.DEBUG, "::::::::Ramdisk Mount Point: " + str(self.mountPoint)) self.logger.log(LogPriority.DEBUG, "::::::::Ramdisk Device : " + str(self.ramdiskDev)) if self.environ.getosfamily().lower() == "darwin": # import appropriate ramdisk library #from src.MacBuild.macRamdisk import Ramdisk, detach # get a ramdisk of appropriate size, with a secure random mountpoint self.my_ramdisk = RamDisk(str(ramdisk_size), self.mnt_pnt_requested) (self.success, self.mountPoint, self.ramdiskDev) = \ self.my_ramdisk.get_data() else: self.logger.log(LogPriority.INFO, "Not applicable to this OS") self.success = False if not self.success: raise IOError("Cannot get a ramdisk for some reason. . .") ##### # Create a temp location on disk to run benchmark tests against self.fs_dir = tempfile.mkdtemp() def setUp(self): '''This method runs before each test run. @author: Roy Nielsen ''' self.libcPath = None # initial initialization ##### # setting up to call ctypes to do a filesystem sync if sys.platform.startswith("darwin"): ##### # For Mac self.libc = C.CDLL("/usr/lib/libc.dylib") elif sys.platform.startswith("linux"): ##### # For Linux self.findLinuxLibC() self.libc = C.CDLL(self.libcPath) else: self.libc = self._pass() ############################################################################### ##### Helper Classes def findLinuxLibC(self): '''Find Linux Libc library... @author: Roy Nielsen ''' possible_paths = [ "/lib/x86_64-linux-gnu/libc.so.6", "/lib/i386-linux-gnu/libc.so.6" ] for path in possible_paths: if os.path.exists(path): self.libcPath = path break def _pass(self): '''Filler if a library didn't load properly''' pass def touch(self, fname="", message_level="normal"): '''Python implementation of the touch command.. inspiration: http://stackoverflow.com/questions/1158076/implement-touch-using-python @author: Roy Nielsen :param fname: (Default value = "") :param message_level: (Default value = "normal") ''' if re.match("^\s*$", str(fname)): self.logger.log(LogPriority.DEBUG, "Cannot touch a file without a filename....") else: try: os.utime(fname, None) except: try: open(fname, 'a').close() except Exception as err: self.logger.log(LogPriority.INFO, "Cannot open to touch: " + str(fname)) def mkdirs(self, path=""): '''A function to do an equivalent of "mkdir -p" :param path: (Default value = "") ''' if not path: self.logger.log(LogPriority.INFO, "Bad path...") else: if not os.path.exists(str(path)): try: os.makedirs(str(path)) except OSError as err1: self.logger.log( LogPriority.INFO, "OSError exception attempting to create directory: " + str(path)) self.logger.log(LogPriority.INFO, "Exception: " + str(err1)) except Exception as err2: self.logger.log( LogPriority.INFO, "Unexpected Exception trying to makedirs: " + str(err2)) def mkfile(self, file_path="", file_size=0, pattern="rand", block_size=512, mode=0o777): '''Create a file with "file_path" and "file_size". To be used in file creation benchmarking - filesystem vs ramdisk. :param eter: file_path - Full path to the file to create :param eter: file_size - Size of the file to create, in Mba :param eter: pattern - "rand": write a random pattern "0xXX": where XX is a hex value for a byte :param eter: block_size - size of blocks to write in bytes :param eter: mode - file mode, default 0o777 :param file_path: (Default value = "") :param file_size: (Default value = 0) :param pattern: (Default value = "rand") :param block_size: (Default value = 512) :param mode: (Default value = 0o777) :returns: s: time in miliseconds the write took @author: Roy Nielsen ''' total_time = 0 if file_path and file_size: self.libc.sync() file_size = file_size * 1024 * 1024 if os.path.isdir(file_path): tmpfile_path = os.path.join(file_path, "testfile") else: tmpfile_path = file_path self.logger.log(LogPriority.DEBUG, "Writing to: " + tmpfile_path) try: # Get the number of blocks to create blocks = file_size / block_size # Start timer in miliseconds start_time = datetime.now() # do low level file access... tmpfile = os.open(tmpfile_path, os.O_WRONLY | os.O_CREAT, mode) # do file writes... for i in range(blocks): tmp_buffer = os.urandom(block_size) os.write(tmpfile, str(tmp_buffer)) os.fsync(tmpfile) self.libc.sync() os.close(tmpfile) self.libc.sync() os.unlink(tmpfile_path) self.libc.sync() # capture end time end_time = datetime.now() except Exception as err: self.logger.log( LogPriority.INFO, "Exception trying to write temp file for benchmarking...") self.logger.log(LogPriority.INFO, "Exception thrown: " + str(err)) total_time = 0 else: total_time = end_time - start_time return total_time def format_ramdisk(self): '''Format Ramdisk''' self.my_ramdisk._format() ############################################################################### ##### Tests ################################## def test_files_n_dirs(self): '''Should work when files exist in ramdisk.''' # Do file setup for this test for subdir in self.subdirs: dirpath = self.mountPoint + "/" + subdir self.logger.log(LogPriority.DEBUG, "DIRPATH: : " + str(dirpath)) self.mkdirs(dirpath) self.touch(dirpath + "/" + "test") # Do the tests for subdir in self.subdirs: # CANNOT use os.path.join this way. os.path.join cannot deal with # absolute directories. May work with mounting ramdisk in local # relative directories. self.assertTrue( os.path.exists(self.mountPoint + "/" + subdir + "/" + "test")) ################################## def test_four_file_sizes(self): '''Test file creation of various sizes, ramdisk vs. filesystem''' ##### # Clean up the ramdisk self.my_ramdisk._format() ##### # 100Mb file size oneHundred = 100 ##### # 100Mb file size twoHundred = 200 ##### # 500Mb file size fiveHundred = 500 ##### # 1Gb file size oneGig = 1000 my_fs_array = [oneHundred, twoHundred, fiveHundred, oneGig] time.sleep(1) for file_size in my_fs_array: ##### # Create filesystem file and capture the time it takes... fs_time = self.mkfile(os.path.join(self.fs_dir, "testfile"), file_size) self.logger.log(LogPriority.DEBUG, "fs_time: " + str(fs_time)) time.sleep(1) ##### # get the time it takes to create the file in ramdisk... ram_time = self.mkfile(os.path.join(self.mountPoint, "testfile"), file_size) self.logger.log(LogPriority.DEBUG, "ram_time: " + str(ram_time)) time.sleep(1) speed = fs_time - ram_time self.logger.log(LogPriority.DEBUG, "ramdisk: " + str(speed) + " faster...") self.assertTrue((fs_time - ram_time).days > -1) def test_many_small_files_creation(self): ''' ''' ##### # Clean up the ramdisk self.my_ramdisk._format() ##### # ramdisk_starttime = datetime.now() for i in range(1000): self.mkfile(os.path.join(self.mountPoint, "testfile" + str(i)), 1) ramdisk_endtime = datetime.now() rtime = ramdisk_endtime - ramdisk_starttime fs_starttime = datetime.now() for i in range(1000): self.mkfile(os.path.join(self.fs_dir, "testfile" + str(i)), 1) fsdisk_endtime = datetime.now() fstime = fsdisk_endtime - fs_starttime self.assertTrue((fstime - rtime).days > -11) ############################################################################### ##### unittest Tear down @classmethod def tearDownClass(self): '''disconnect ramdisk''' if self.my_ramdisk.unmount(): self.logger.log(LogPriority.DEBUG, r"Successfully detached disk: " + \ str(self.my_ramdisk.mntPoint).strip()) else: self.logger.log(LogPriority.DEBUG,r"Couldn't detach disk: " + \ str(self.my_ramdisk.myRamdiskDev).strip() + \ " : mntpnt: " + str(self.my_ramdisk.mntPoint)) raise Exception(r"Cannot eject disk: " + \ str(self.my_ramdisk.myRamdiskDev).strip() + \ " : mntpnt: " + str(self.my_ramdisk.mntPoint)) ##### # capture end time test_end_time = datetime.now() ##### # Calculate and log how long it took... test_time = (test_end_time - self.test_start_time) self.logger.log(LogPriority.DEBUG,self.__module__ + " took " + str(test_time) + \ " time to complete...")
def setUpClass(self): """ Initializer """ self.environ = Environment() # Start timer in miliseconds self.test_start_time = datetime.now() self.logger = LogDispatcher(self.environ) ##### # setting up to call ctypes to do a filesystem sync if self.environ.getosfamily() == "redhat" : self.libc = C.CDLL("/lib/libc.so.6") elif self.environ.getosfamily() == "darwin" : self.libc = C.CDLL("/usr/lib/libc.dylib") else: self.libc = None self.subdirs = ["two", "three" "one/four"] """ Set up a ramdisk and use that random location as a root to test the filesystem functionality of what is being tested. """ #Calculate size of ramdisk to make for this unit test. size_in_mb = 1800 ramdisk_size = size = size_in_mb self.mnt_pnt_requested = "" self.success = False self.mountPoint = False self.ramdiskDev = False self.mnt_pnt_requested = False self.logger.log(LogPriority.DEBUG, "::::::::Ramdisk Mount Point: " + str(self.mountPoint)) self.logger.log(LogPriority.DEBUG, "::::::::Ramdisk Device : " + str(self.ramdiskDev)) if self.environ.getosfamily().lower() == "darwin": # import appropriate ramdisk library #from src.MacBuild.macRamdisk import Ramdisk, detach # get a ramdisk of appropriate size, with a secure random mountpoint self.my_ramdisk = RamDisk(str(ramdisk_size), self.mnt_pnt_requested) (self.success, self.mountPoint, self.ramdiskDev) = \ self.my_ramdisk.get_data() else: self.logger.log(LogPriority.INFO, "Not applicable to this OS") self.success = False if not self.success: raise IOError("Cannot get a ramdisk for some reason. . .") ##### # Create a temp location on disk to run benchmark tests against self.fs_dir = tempfile.mkdtemp()
class RuleTest(unittest.TestCase): ############################################################################### def setUp(self): ''' Setup what we need for the test. @author: ekkehard j. koch @param self:essential if you override this definition ''' self.environ = Environment() self.environ.setverbosemode(True) self.environ.setdebugmode(True) self.config = Configuration(self.environ) self.logdispatch = LogDispatcher(self.environ) self.statechglogger = StateChgLogger(self.logdispatch, self.environ) self.rule = None self.rulename = "" self.rulenumber = "" ############################################################################### def tearDown(self): ''' Release anything we no longer need what we need for the test. @author: ekkehard j. koch @param self:essential if you override this definition ''' pass ############################################################################### def simpleRuleTest(self): ''' Run a simple Report, Fix, Report Cycle @author: ekkehard j. koch @param self:essential if you override this definition ''' nextstep = True prefixHeadline = "################################################### " prefixRuleInfo = self.rulename + "(" + str(self.rulenumber) + "): " messagestring = "" # Make Rule Is supposed to run in this environment if nextstep: messagestring = "Make sure Rule Is supposed to run in this " + \ "environment" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) isapplicable = self.rule.isapplicable() messagestring = "rule.isapplicable() = " + str(isapplicable) self.logdispatch.log(LogPriority.DEBUG, prefixRuleInfo + \ messagestring) valueIsInList = isapplicable in [True, False] messagestring = "Invalid isapplicable Type!" self.assertTrue(valueIsInList, prefixRuleInfo + \ messagestring) messagestring = "rule.isapplicable() = " + str(isapplicable) + \ " and should be True." self.assertTrue(isapplicable, prefixRuleInfo + \ messagestring) nextstep = isapplicable # Check to see if we are running in the right context if nextstep: messagestring = "Check to see if we are running in the " + \ "right context" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) effectiveUserID = self.environ.geteuid() messagestring = "environ.geteuid() = " + str(effectiveUserID) self.logdispatch.log(LogPriority.DEBUG, prefixRuleInfo + \ messagestring) isRootRequired = self.rule.getisrootrequired() messagestring = "rule.getisrootrequired() = " + str(isRootRequired) self.logdispatch.log(LogPriority.DEBUG, prefixRuleInfo + \ messagestring) if effectiveUserID == 0 and isRootRequired: nextstep = True elif not isRootRequired: nextstep = True else: nextstep = False messagestring = "Rule requires root and effective uid ='" + \ str(effectiveUserID) + "'" self.assertTrue(nextstep, prefixRuleInfo + \ messagestring) # Run setConditionsForRule to configure system for test if nextstep: messagestring = "Run setConditionsForRule to configure " + \ "system for test" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) setTestConditions = self.setConditionsForRule() self.logdispatch.log(LogPriority.DEBUG, "setConditionsForRule()" + \ " = " + \ str(setTestConditions)) if setTestConditions: nextstep = True else: nextstep = False messagestring = "setConditionsForRule() = " + \ str(setTestConditions) + "." self.assertTrue(setTestConditions, prefixRuleInfo + \ messagestring) # Run rule.report() if nextstep: messagestring = "Run rule.report()" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) report = self.rule.report() self.logdispatch.log(LogPriority.DEBUG, "rule.report() = " + \ str(report)) rulesuccess = self.rule.getrulesuccess() self.logdispatch.log(LogPriority.DEBUG, "rule.getrulesuccess() = " + \ str(rulesuccess)) valueIsInList = rulesuccess in [True, False] messagestring = "Invalid rule.getrulesuccess() Value'" + \ str(rulesuccess) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) if not rulesuccess: nextstep = False messagestring = ": rule.getrulesuccess() is '" + \ str(rulesuccess) + "'" self.assertTrue(rulesuccess, prefixRuleInfo + messagestring) rulecompliance = self.rule.iscompliant() self.logdispatch.log(LogPriority.DEBUG, "rule.iscompliant() = " + \ str(rulecompliance)) valueIsInList = rulecompliance in [True, False] messagestring = "Invalid rule.iscompliant() Value'" + \ str(rulecompliance) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) # Run checkReportForRule() messagestring = "Run checkReportForRule(" + str(rulecompliance) + \ ", " + str(rulesuccess) + ")" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) checkReportConditions = self.checkReportForRule(rulecompliance, rulesuccess) self.logdispatch.log(LogPriority.DEBUG, "checkReportForRule()" + \ " = " + \ str(checkReportConditions)) if checkReportConditions and not rulecompliance: nextstep = True else: nextstep = False messagestring = ": Rule checkReportForRule() = " + \ str(checkReportConditions) + "." self.assertTrue(checkReportConditions, prefixRuleInfo + \ messagestring) self.assertTrue(checkReportConditions, self.rulename + "(" + str(self.rulenumber) + ")" + ": Rule " + \ "checkReportForRule() = " + \ str(checkReportConditions) + ".") # Run rule.fix() if nextstep: messagestring = "Run rule.fix()" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) fix = self.rule.fix() self.logdispatch.log(LogPriority.DEBUG, "rule.fix() = " + \ str(fix)) rulesuccess = self.rule.getrulesuccess() self.logdispatch.log(LogPriority.DEBUG, "rule.getrulesuccess() = " + \ str(rulesuccess)) valueIsInList = rulesuccess in [True, False] messagestring = "Invalid rule.rulesuccess() Value'" + \ str(rulesuccess) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) messagestring = "rule.getrulesuccess() = '" + \ str(rulesuccess) + "'" self.assertTrue(rulesuccess, prefixRuleInfo + messagestring) # Run checkFixForRule() messagestring = "Run checkFixForRule(" + str(rulesuccess) + ")" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) checkFixConditions = self.checkFixForRule(rulesuccess) self.logdispatch.log(LogPriority.DEBUG, "checkFixForRule(" + str(rulesuccess) + \ ")" + " = " + \ str(checkFixConditions)) if checkFixConditions and rulesuccess: nextstep = True else: nextstep = False messagestring = "Rule checkFixForRule() = " + \ str(checkFixConditions) + "." self.assertTrue(nextstep, prefixRuleInfo + messagestring) # Run rule.report() if nextstep: messagestring = "Run rule.report()" self.logdispatch.log(LogPriority.DEBUG, prefixHeadline + \ prefixRuleInfo + messagestring) report = self.rule.report() self.logdispatch.log(LogPriority.DEBUG, "rule.report() = " + \ str(report)) rulesuccess = self.rule.getrulesuccess() self.logdispatch.log(LogPriority.DEBUG, "rule.getrulesuccess() = " + \ str(rulesuccess)) valueIsInList = rulesuccess in [True, False] messagestring = "Invalid rule.getrulesuccess() Value'" + \ str(rulesuccess) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) if not rulesuccess: nextstep = False self.assertTrue(rulesuccess, self.rulename + "(" + str(self.rulenumber) + ")" + ": rule.getrulesuccess() is '" + \ str(rulesuccess) + "' with reported error '" + \ str(self.rule.getdetailedresults())) rulecompliance = self.rule.iscompliant() self.logdispatch.log(LogPriority.DEBUG, "rule.iscompliant() = " + \ str(rulecompliance)) valueIsInList = rulecompliance in [True, False] messagestring = "Invalid rule.iscompliant() Value'" + \ str(rulecompliance) + "'!" self.assertTrue(valueIsInList, prefixRuleInfo + messagestring) messagestring = "rule.iscompliant() is '" + \ str(rulecompliance) + "' after rule.fix() and rule.report() " + \ "have run." self.assertTrue(rulecompliance, prefixRuleInfo + messagestring) if rulecompliance: nextstep = False return nextstep ############################################################################### def setConditionsForRule(self): return True ############################################################################### def checkReportForRule(self, pCompliance, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pCompliance = " + \ str(pCompliance) + ".") self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + \ str(pRuleSuccess) + ".") return True ############################################################################### def checkFixForRule(self, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + \ str(pRuleSuccess) + ".") return True ############################################################################### def checkUndoForRule(self, pRuleSuccess): self.logdispatch.log(LogPriority.DEBUG, "pRuleSuccess = " + \ str(pRuleSuccess) + ".") return True
def setUpClass(self): '''Initializer''' self.environ = Environment() # Start timer in miliseconds self.test_start_time = datetime.now() self.logger = LogDispatcher(self.environ) ##### # setting up to call ctypes to do a filesystem sync if self.environ.getosfamily() == "redhat": self.libc = C.CDLL("/lib/libc.so.6") elif self.environ.getosfamily() == "darwin": self.libc = C.CDLL("/usr/lib/libc.dylib") else: self.libc = None self.subdirs = ["two", "three" "one/four"] """ Set up a ramdisk and use that random location as a root to test the filesystem functionality of what is being tested. """ #Calculate size of ramdisk to make for this unit test. size_in_mb = 1800 ramdisk_size = size = size_in_mb self.mnt_pnt_requested = "" self.success = False self.mountPoint = False self.ramdiskDev = False self.mnt_pnt_requested = False self.logger.log(LogPriority.DEBUG, "::::::::Ramdisk Mount Point: " + str(self.mountPoint)) self.logger.log(LogPriority.DEBUG, "::::::::Ramdisk Device : " + str(self.ramdiskDev)) if self.environ.getosfamily().lower() == "darwin": # import appropriate ramdisk library #from src.MacBuild.macRamdisk import Ramdisk, detach # get a ramdisk of appropriate size, with a secure random mountpoint self.my_ramdisk = RamDisk(str(ramdisk_size), self.mnt_pnt_requested) (self.success, self.mountPoint, self.ramdiskDev) = \ self.my_ramdisk.get_data() else: self.logger.log(LogPriority.INFO, "Not applicable to this OS") self.success = False if not self.success: raise IOError("Cannot get a ramdisk for some reason. . .") ##### # Create a temp location on disk to run benchmark tests against self.fs_dir = tempfile.mkdtemp()
def setUp(self): self.enviro = environment.Environment() self.logger = LogDispatcher(self.enviro) self.helper = pkghelper.Pkghelper(self.logger, self.enviro) self.pkg = "zsh"
class ManageUser(object): '''Class to manage user properties. @author: Roy Nielsen ''' def __init__(self, userName="", userShell="/bin/bash", userComment="", userUid=10000, userPriGid=20, userHomeDir="/tmp", logger=False): self.module_version = '20160225.125554.540679' ##### # Set up logging self.logger = LogDispatcher() ##### # THIS IS A LIBRARY, SO LOGS SHOULD BE INITIALIZED ELSEWHERE... # self.logger.initializeLogs() self.logger.log(lp.INFO, "Logger: " + str(self.logger)) """ if self.isSaneUserName(userName): self.userName = userName else: raise BadUserInfoError("Need a valid user name...") if self.isSaneUserShell(userShell): self.userShell = userShell else: raise BadUserInfoError("Need a valid user shell...") if self.isSaneUserComment(userComment): self.userComment = userComment else: self.userComment="" if self.isSaneUserUid(str(userUid)): self.userUid = self.userUid else: raise BadUserInfoError("Need a valid user UID...") if self.isSaneUserPriGid(str(userPriGid)): self.userUid = userUid else: raise BadUserInfoError("Need a valid user Primary GID...") if self.isSaneUserHomeDir(userHomeDir): self.userHomeDir = userHomeDir else: raise BadUserInfoError("Need a user Home Directory...") """ def isSaneUserName(self, userName=""): ''' :param userName: (Default value = "") ''' sane = False if userName and isinstance(userName, str): if re.match("^[A-Za-z][A-Za-z0-9]*", userName): sane = True return sane def isSaneGroupName(self, groupName=""): ''' :param groupName: (Default value = "") ''' sane = False if groupName and isinstance(groupName, str): if re.match("^[A-Za-z][A-Za-z0-9]*", groupName): sane = True return sane def isSaneUserShell(self, userShell=""): ''' :param userShell: (Default value = "") ''' sane = False if userShell and isinstance(userShell, str): if re.match("^[A-Za-z/][A-Za-z0-9/]*", userShell): sane = True return sane def isSaneUserComment(self, userComment=""): ''' :param userComment: (Default value = "") ''' sane = False if userComment and isinstance(userComment, str): if re.match("^[A-Za-z][A-Za-z0-9]*", userComment): sane = True return sane def isSaneUserUid(self, userUid=""): ''' :param userUid: (Default value = "") ''' sane = False if userUid and isinstance(userUid, [str, int]): if re.match("^\d+", str(userUid)): sane = True return sane def isSaneUserPriGid(self, userPriGid=1000): ''' :param userPriGid: (Default value = 1000) ''' sane = False if userPriGid and isinstance(userPriGid, [str, int]): if re.match("^\d+", str(userPriGid)): sane = True return sane def isSaneUserHomeDir(self, userHomeDir=""): ''' :param userHomeDir: (Default value = "") ''' sane = False if userHomeDir and isinstance(userHomeDir, str): if re.match("^[A-Za-z/][A-Za-z0-9/]*", userHomeDir): sane = True return sane def setUserName(self, userName=""): ''' :param userName: (Default value = "") ''' sane = False if self.isSaneUserName(userName): sane = True self.userName = userName return sane def setUserShell(self, user="", shell=""): ''' :param user: (Default value = "") :param shell: (Default value = "") ''' pass def setUserComment(self, user="", comment=""): ''' :param user: (Default value = "") :param comment: (Default value = "") ''' pass def setUserUid(self, user="", uid=""): ''' :param user: (Default value = "") :param uid: (Default value = "") ''' pass def setUserPriGid(self, user="", priGid=""): ''' :param user: (Default value = "") :param priGid: (Default value = "") ''' pass def setUserHomeDir(self, user="", userHome = ""): ''' :param user: (Default value = "") :param userHome: (Default value = "") ''' pass def addUserToGroup(self, user="", group=""): ''' :param user: (Default value = "") :param group: (Default value = "") ''' pass def setUserPassword(self, user="", password=""): ''' :param user: (Default value = "") :param password: (Default value = "") ''' pass