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 __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):
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 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 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):
self.enviro = environment.Environment()
self.logger = LogDispatcher(self.enviro)
self.helper = pkghelper.Pkghelper(self.logger, self.enviro)
self.pkg = "zsh"
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):
'''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()
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):
