def setupFitGlobalForTests(env, opts=[]):
# Run Level Globals
FG.specificationLevel = "1.1"
FG.Environment = env
FG.RunAppConfigModule = None
FG.RunAppConfig = None
FG.RunDiagnosticOptions = {}
FG.RunLevelSymbols = {}
if env == "Batch":
FG.RunOptions = Options(["FileRunner", "+v"] + opts,
SO.BatchBase.parmDict)
elif env == "FitNesseOnline":
FG.RunOptions = Options(["FitServer", "+v"] + opts,
SO.FitServer.parmDict)
FG.Environment = "FitNesse"
elif env == "FitNesseBatch":
FG.RunOptions = Options(["TestRunner", "+v"] + opts,
SO.TestRunner.parmDict)
FG.Environment = "FitNesse"
FG.FitNesseRoot = SO.OptionsBase.fitNesse_Root
# Test Level Globals
FG.Options = FG.RunOptions
FG.appConfigModule = FG.RunAppConfigModule
FG.appConfig = FG.RunAppConfig
FG.diagnosticOptions = copy.copy(FG.RunDiagnosticOptions)
FG.annotationStyleVariation = Variations.returnVariation(FG.Environment)
FG.inFileName = ""
FG.outFileName = ""
FG.testLevelSymbols = copy.copy(FG.RunLevelSymbols)
def testAddNewOptions(self):
optList = ["FolderRunner.py", "-v", "+q", "et", "-r", "+v"]
obj = Options(optList, SiteOptions.BatchBase.parmDict)
self.obj = obj
assert obj.recursive is False
obj.addNewOptions(["", "+r"])
assert obj.verbose is True
assert obj.recursive is True
assert obj.quietMode == "et"
assert obj.isValid
assert len(obj.vMsgs) == 5
assert len(obj.eMsgs) == 0
def testAddNewOptions(self):
optList = ["FolderRunner.py", "-v", "+q", "et", "-r", "+v"]
obj = Options(optList, SiteOptions.BatchBase.parmDict)
self.obj = obj
assert obj.recursive is False
obj.addNewOptions(["", "+r"])
assert obj.verbose is True
assert obj.recursive is True
assert obj.quietMode == "et"
assert obj.isValid
assert len(obj.vMsgs) == 5
assert len(obj.eMsgs) == 0
def setUp(self):
print '%s %s' % (self.id(), self.shortDescription())
setupFitGlobalForTests("Batch", ["+e"])
self.options = Options(["FileRunner", "+v", "+e", "foo", "bar"],
BatchBase.parmDict)
self.fixture = Fixture()
self.fixture.fixtureLoader = MockFixtureLoader()
def args(self, argv):
self.options = Options(argv, SiteOptions.FitServer.parmDict)
FG.CommandOptions = self.options
opts = self.options
errMsgs = opts.eMsgs
vMsgs = opts.vMsgs
pos = opts.posParms
if not opts.isValid:
for aMsg in errMsgs:
conMsg.emsg(aMsg)
self.usage()
return False
numIOArgs = net.getNumArgs() # may be testing mock.
self._renameFileName = ""
self._addToPythonPath = []
if len(pos) == numIOArgs + 1:
self._addToPythonPath, self._renameFileName = (
self.extractPythonPath(pos[0], opts))
pos = pos[1:]
if len(pos) != numIOArgs:
conMsg.emsg("wrong number of positional parameters")
self.usage()
return False
fitnesseParmStatus, self.host, self.port, self.socketToken = net.extractParameters(
pos)
if fitnesseParmStatus is False:
self.usage()
return False
conMsg.setVerbose(opts.verbose)
if opts.verbose:
for aMsg in vMsgs:
conMsg.smsg(aMsg)
return True
def testOptionError(self):
optList = ["TestRunner.py", "-$"]
obj = Options(optList, SiteOptions.TestRunner.parmDict)
self.obj = obj
assert not obj.isValid
assert len(obj.eMsgs) == 1
assert obj.eMsgs[0].startswith("Parameter $ not recognized")
def testPositionalParameters(self):
optList = ["TestRunner.py", "-v", "great file"]
obj = Options(optList, SiteOptions.TestRunner.parmDict)
self.obj = obj
assert obj.isValid
assert len(obj.posParms) == 1
assert obj.posParms[0] == "great file"
def args(self, optv):
self.options = Options(optv, SiteOptions.TestRunner.parmDict)
opts = self.options
conMsg.setVerbose(opts.verbose)
errMsgs = opts.eMsgs
pos = opts.posParms
if not opts.isValid:
for aMsg in errMsgs:
conMsg.emsg(aMsg)
self._usage()
return False
if len(pos) == 3 and not opts.listOfFiles:
self._host, self._port, self._pageName = pos
elif len(pos) == 2 and opts.listOfFiles:
self._host, self._port = pos
self._pageName = ""
else:
conMsg.emsg("wrong number of positional arguements\n")
conMsg.emsg("%s" % pos)
self._usage()
return False
self._port = int(self._port)
self._pythonPath = ""
self._renamesFileName = ""
if self.options.pythonPath:
self._pythonPath, self._renamesFileName = self.extractPythonPath(
self.options.pythonPath, copy.copy(opts))
if opts.outputDir != "":
if not FG.fsa.isdir(opts.outputDir):
conMsg.emsg("-o operand '%s' is not a directory\n" %
opts.outputDir)
self._usage()
return False
self.listOfFiles = []
if opts.listOfFiles:
if not FG.fsa.exists(opts.listOfFiles):
conMsg.emsg("-u operand '%s' must exist\n" % opts.listOfFiles)
self._usage()
return False
aFile = FG.fsa.open(opts.listOfFiles, "rt")
self.listOfFiles = aFile.readlines()
aFile.close()
if ((opts.rawOutput or opts.stats) and not opts.outputDir):
conMsg.emsg("No output directory for raw or XML options.\n")
self._usage()
return False
if (opts.HTMLOutput and not opts.outputDir):
opts.HTMLOutput = False
self._statsHandler = StatsHandler(opts.outputDir, self._pageName,
self._host, self._port)
return True
def testTwoListItems(self):
optList = ["TestRunner.py", "+x", "-v"]
obj = Options(optList, SiteOptions.TestRunner.parmDict)
self.obj = obj
assert obj.verbose is False
assert obj.stats is True
assert obj.isValid
assert len(obj.vMsgs) == 2
assert len(obj.eMsgs) == 0
def testFourListItems(self):
optList = ["FolderRunner.py", "-v", "+q", "yt", "-r", "+v"]
obj = Options(optList, SiteOptions.BatchBase.parmDict)
self.obj = obj
assert obj.verbose is True
assert obj.recursive is False
assert obj.quietMode == "yt"
assert obj.isValid
assert len(obj.vMsgs) == 4
assert len(obj.eMsgs) == 0
def setUp(self):
print '%s %s' % (self.id(), self.shortDescription())
self.options = Options(["FileRunner", "+v", "foo", "bar"],
BatchBase.parmDict)
self.saveFitGlobal = (FitGlobal.RunOptions, FitGlobal.Options,
FitGlobal.Environment)
FitGlobal.RunOptions = self.options
FitGlobal.Options = self.options
FitGlobal.Environment = "Batch"
Variations.returnVariation()
def setUp(self):
print '%s %s' % (self.id(), self.shortDescription())
setupFitGlobalForTests("FitNesseOnline")
self.savePath = copy.copy(sys.path)
self.fits = fsi.ServerBase()
self.options = Options(["fubar"], SiteOptions.FitServer.parmDict)
self.saveNet = fsi.net
fsi.netIn = fsi.netOut = fsi.net = ioMock()
self.saveMsg = fsi.conMsg
fsi.conMsg = fsi.TestMsgWriter()
def testInvalidRunner(self):
optList = [
"NotARunner.py", "-a", "AppModule.py", "-b", "foo", "-v", "+b",
"bar"
]
obj = Options(optList, SiteOptions.BatchBase.parmDict)
print dir(obj)
self.obj = obj
assert obj.appConfigurationModule == "AppModule.py"
assert obj.appConfigurationParms == ["foo", "bar"]
assert obj.verbose is False
def setUp(self):
print '%s %s' % (self.id(), self.shortDescription())
self.options = Options(["FileRunner", "+v", "+e", "foo", "bar"],
BatchBase.parmDict)
self.saveFitGlobal = (FitGlobal.RunOptions, FitGlobal.Options,
FitGlobal.Environment)
FitGlobal.RunOptions = self.options
FitGlobal.Options = self.options
FitGlobal.Environment = "Batch"
Variations.returnVariation()
## it = getattr(FixtureLoader, "__it__", None)
## if it is not None:
## del FixtureLoader.__it__
self.obj = FixtureLoader()
FixtureLoader.clearFixtureRenameTable()
def setUp(self):
print '%s %s' % (self.id(), self.shortDescription())
self.options = Options(["FileRunner", "+v", "+e", "foo", "bar"],
BatchBase.parmDict)
self.saveFitGlobal = (FitGlobal.RunOptions, FitGlobal.Options,
FitGlobal.Environment)
self.saveAppExit = (FitGlobal.appConfigModule, FitGlobal.appConfig)
FitGlobal.RunOptions = self.options
FitGlobal.Options = self.options
FitGlobal.Environment = "Batch"
FitGlobal.appConfigModule = MockAppConfigMapFixture
FitGlobal.appConfig = MockAppConfigMapFixture()
Variations.returnVariation()
self.obj = FixtureLoader()
FixtureLoader.clearFixtureRenameTable()
def parms(self, optv):
self.options = Options(optv, BatchBase.parmDict, "BatchBase")
# was self._parmDict
opts = self.options
FG.RunOptions = opts
FG.Options = opts
conMsg.setVerbose(opts.verbose)
errMsgs = opts.eMsgs
fileList = opts.posParms
if not opts.isValid:
for msg in errMsgs:
conMsg.err(msg)
self._usage()
return False
if opts.standardsLevel == "":
FG.SpecificationLevel = "1.1"
elif opts.standardsLevel != "1.1":
conMsg.err("Standards level must be 1.1")
FG.SpecificationLevel = "1.1"
else:
FG.SpecificationLevel = opts.standardsLevel
if opts.standardMode is True:
if opts.useCSS is True:
conMsg.err("Standards mode requested. CSS output suppressed")
opts.useCSS = False
parmEditOK = ParmEditStatus()
runType = "?"
result = self._loadAppConfigurationModule(opts)
if result is not True:
conMsg.err(result)
parmEditOK += False
if 2 <= len(fileList) <= 3:
self.inDir = FG.fsa.abspath(fileList[0])
self.outDir = FG.fsa.abspath(fileList[1])
statFile = FG.fsa.join(self.outDir, "FitStatistics.xml")
if FG.fsa.isdir(self.inDir):
self.inFile = None
runType = "d"
self._runObj = DirectoryRunner(self.inDir, self.outDir,
self.options)
if not FG.fsa.isdir(self.outDir):
conMsg.err(
"Output must be existing directory for input directory option")
parmEditOK += False
elif (FG.fsa.isfile(self.inDir)):
self.inFile = self.inDir
self.inDir, tail = FG.fsa.split(self.inFile)
root, ext = FG.fsa.splitext(self.inFile)
if ext == ".txt":
if len(fileList) > 2:
conMsg.err(
"Rename File not allowed for list of files option")
parmEditOK += False
runType = "l"
self._runObj = FileListRunner(self.inFile, self.outDir,
self.options)
if not self.options.isValid:
for msg in self.options.eMsgs:
conMsg.err(msg)
self._usage()
return False
parmEditOK += FG.appConfigInterface("listOfFilesOptions",
self.options)
if not FG.fsa.isdir(self.outDir):
conMsg.err(
"Output must be existing directory for List of Files option")
parmEditOK += False
else:
runType = "h"
self._runObj = HTMLRunner(self.inFile, self.outDir,
self.options)
statFile = ""
head, tail = FG.fsa.split(self.outDir)
if not FG.fsa.isdir(head):
conMsg.err(
"Output directory for result file must exist.")
parmEditOK += False
else:
if FG.fsa.exists(self.outDir) and not FG.fsa.isfile(self.outDir):
conMsg.err(
"Output for single file option must be a file.")
parmEditOK += False
else:
conMsg.err("'%s' does not exist!\n" % self.inDir)
parmEditOK += False
else:
conMsg.err("Wrong number of positional parameters\n")
parmEditOK += False
# options from the "list of files" have been merged at this point
parmEditOK += self._extractDiagnosticOptions(opts,
FG.RunDiagnosticOptions)
result = self._extractRunLevelSymbols(opts,
FG.RunLevelSymbols)
parmEditOK += result
if len(fileList) == 3:
loadOK = self._loadRenameFile(fileList[2])
if not loadOK:
conMsg.err("Rename file '%s' failed to load" % fileList[2])
parmEditOK += loadOK
else:
default = FG.fsa.join(self.inDir, "FixtureRenames.txt")
self._loadRenameFile(default)
self.runType = runType
Variations.returnVariation()
if parmEditOK:
self._setupStatisticsFile(runType, opts, statFile)
self._setupConsoleStatisticsPrint(opts, runType)
stack.init(opts)
return True
self._usage()
return False
def testInvalidEncodingOption(self):
optList = ["FileRunner.py", "+d", "enigma"]
obj = Options(optList, SiteOptions.BatchBase.parmDict)
self.obj = obj
assert not obj.isValid
assert obj.defaultEncoding == ""
def setUp(self):
print '%s %s' % (self.id(), self.shortDescription())
setupFitGlobalForTests("Batch")
self.options = Options(["FileRunner", "+v", "foo", "bar"],
BatchBase.parmDict)
def testInstantiation(self):
optList = ["FileRunner.py", "-a", "+bc"]
optTable = {"a": ("bx", "saveOption")}
unused = Options(optList, optTable)
def testOneSwitchOn(self):
optList = ["TestRunner.py", "+v"]
obj = Options(optList, SiteOptions.TestRunner.parmDict)
self.obj = obj
assert obj.verbose is True
assert obj.isValid
def testInvalidConsoleMode(self):
optList = ["FolderRunner.py", "+q", "xx"]
obj = Options(optList, SiteOptions.BatchBase.parmDict)
self.obj = obj
assert not obj.quietMode == "yn"
assert not obj.isValid
# InitEnvironment module from Python FIT
#LegalStuff jr2005
#endLegalStuff
import copy
from fit import FitGlobal as FG
from fit import Variations
from fit.Options import Options
from fit import SiteOptions as SO
if FG.RunOptions is None:
FG.RunOptions = Options(["FileRunner", "+v"], SO.BatchBase.parmDict)
FG.Options = FG.RunOptions
FG.annotationStyleVariation = Variations.returnVariation("Batch")
# following is invoked by many of the test classes in the SetUp routine.
def setupFitGlobalForTests(env, opts=[]):
# Run Level Globals
FG.specificationLevel = "1.1"
FG.Environment = env
FG.RunAppConfigModule = None
FG.RunAppConfig = None
FG.RunDiagnosticOptions = {}
FG.RunLevelSymbols = {}
if env == "Batch":
FG.RunOptions = Options(["FileRunner", "+v"] + opts,
SO.BatchBase.parmDict)
elif env == "FitNesseOnline":
FG.RunOptions = Options(["FitServer", "+v"] + opts,
SO.FitServer.parmDict)
