def __init__(self, path, templateFilter, outputPath, reports, jUnitPackagePrefix):
sys.setrecursionlimit(10000)
self.caduceusPath = CaduceusHelper.getPackagePath()
self.path = os.path.abspath(path)
self.rootPath = self.path
if templateFilter:
print("Filtering templates using '%s'" % templateFilter)
self._templateFilter = re.compile(templateFilter)
else:
self._templateFilter = None
self.outputPath = os.path.abspath(outputPath)
self._reports = reports
self._jUnitPackagePrefix = jUnitPackagePrefix
self.results = CaduceusResults()
os.environ["CADUCEUS_OUTPUT"] = self.outputPath
os.environ["CADUCEUS_SRC"] = self.rootPath
class CaduceusGenerator:
REPORT_HTML = 0
REPORT_JUNIT = 1
def __init__(self, path, templateFilter, outputPath, reports, jUnitPackagePrefix):
sys.setrecursionlimit(10000)
self.caduceusPath = CaduceusHelper.getPackagePath()
self.path = os.path.abspath(path)
self.rootPath = self.path
if templateFilter:
print("Filtering templates using '%s'" % templateFilter)
self._templateFilter = re.compile(templateFilter)
else:
self._templateFilter = None
self.outputPath = os.path.abspath(outputPath)
self._reports = reports
self._jUnitPackagePrefix = jUnitPackagePrefix
self.results = CaduceusResults()
os.environ["CADUCEUS_OUTPUT"] = self.outputPath
os.environ["CADUCEUS_SRC"] = self.rootPath
def run(self):
if os.path.isfile(self.path):
print("Output must be a directory !")
#path, filename = os.path.split(self.path)
#self._processFile(path, filename, self.outputPath)
return
if os.path.isdir(self.path):
self._processDirectory(self.path, self.outputPath)
# copy css file to output path
CaduceusHelper.copyResource(self.caduceusPath, self.outputPath, "caduceus.css")
# Print statistics
print("Assertions: %d" % self.results.getAssertionCount())
print("Success: %d" % self.results.getAssertionTypeCount(CaduceusTemplateResults.SUCCESS))
print("Failures: %d" % self.results.getAssertionTypeCount(CaduceusTemplateResults.FAILURE))
print("Errors: %d" % self.results.getAssertionTypeCount(CaduceusTemplateResults.ERROR))
# Generate execution report
if self._reports[self.REPORT_HTML]:
report = ReportHtml(self.results, self.outputPath, self.caduceusPath)
report.generate()
if self._reports[self.REPORT_JUNIT]:
report = ReportJUnit(self.results, self.outputPath, self.caduceusPath, self._jUnitPackagePrefix)
report.generate()
return self.results.failures == 0 and self.results.errors == 0
def _processDirectory(self, path, outPath):
print(" Processing path %s..." % path)
entries = os.listdir(path)
for entry in entries:
entryFullPath = os.path.join(path, entry)
if os.path.isfile(entryFullPath):
self._processFile(path, entry, outPath)
elif os.path.isdir(entryFullPath) and (entry != ".svn"):
self._processDirectory(entryFullPath, os.path.join(outPath, entry))
else:
print("Not handling %s" % entryFullPath)
def _processFile(self, filePath, fileName, outFilePath):
inputFullPath = os.path.join(filePath, fileName)
inputBasenamePath, ext = os.path.splitext(inputFullPath)
outputFullPath = os.path.join(outFilePath, fileName)
if ext == ".html":
if self.allowedTemplateFile(filePath, fileName):
print(" Processing file %s..." % inputFullPath)
template = CaduceusTemplateParser.parseTemplateFile(inputFullPath, self.rootPath, self.caduceusPath)
if template:
CaduceusHelper.ensurePathExists(outFilePath)
outputFile = open(outputFullPath, 'w')
try:
# Load controller for file
dictGlob = {}
dictLoc = {}
try:
controllerName, _ext = os.path.splitext(fileName)
controllerName = controllerName + "Test"
sys.path.append(os.path.dirname(inputFullPath))
#exec ("from %s import %s" % (controllerName, controllerName)) in dictGlob, dictLoc
exec ("from %s import %s" % (controllerName, controllerName), dictGlob, dictLoc)
# We must copy local dictionnary into global, to allow some symbols resolution
dictGlob.update(dictLoc)
# Instanciate a controller in parsing context
#exec ("__caduceus_controler__ = %s()" % controllerName) in dictGlob, dictLoc
exec ("__caduceus_controler__ = %s()" % controllerName, dictGlob, dictLoc)
os.environ["CADUCEUS_TEMPLATE_PATH"] = inputFullPath
# Bind all controller public methods as global methods
for key in dir(dictLoc[controllerName]):
if key[0] != "_":
proc = eval("__caduceus_controler__.%s" % key, dictGlob, dictLoc)
dictLoc[key] = proc
except IOError:
print("Warning: No controller file for '%s'" % inputFullPath)
except ImportError:
print("Warning: No controller file for '%s'" % inputFullPath)
import traceback
traceback.print_exc()
# Render template using context
tmplResults = CaduceusTemplateResults(outputFullPath)
result = template.render(dictGlob, dictLoc, tmplResults)
self.results.addTemplateResult(tmplResults)
outputFile.write(result)
finally:
outputFile.close()
elif ext not in [".py", ".pyc"]:
# File may be stylesheet, javasript or other resource
# copy as it
print(" Copy file %s..." % inputFullPath)
CaduceusHelper.ensurePathExists(outFilePath)
shutil.copyfile(inputFullPath, outputFullPath)
def allowedTemplateFile(self, filePath, fileName):
inputFullPath = os.path.join(filePath, fileName)
if fileName[0] == "_":
print(" Skipping partial %s" % inputFullPath)
return False
if self._templateFilter:
if not self._templateFilter.match(inputFullPath):
print(" Skipping filtered template %s" % inputFullPath)
return False
return True
@staticmethod
def main():
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-o", "--output", dest="outputPath", help="Output path", metavar="OUTPUT", default="")
parser.add_option("-s", "--src", dest="srcPath", help="Base directory", metavar="INPUT", default=None)
parser.add_option("-r", "--report-html", action="store_true", dest="reportHtml", help="Generate HTML report", default=True)
parser.add_option("-q", "--no-report-html", action="store_false", dest="reportHtml", help="Do not generate HTML report")
parser.add_option("-j", "--junit", action="store_true", dest="reportJUnit", help="Generate JUnit report", default=False)
parser.add_option("-p", "--junit-package-prefix", dest="jUnitPackagePrefix", help="JUnit report package prefix", default="")
parser.add_option("", "--filter", dest="templateFilter", help="regexp to filter templates", default="")
(options, args) = parser.parse_args()
if options.srcPath and options.outputPath:
caduceus = CaduceusGenerator(options.srcPath,
options.templateFilter,
options.outputPath,
[options.reportHtml, options.reportJUnit],
options.jUnitPackagePrefix)
sys.exit([1, 0][caduceus.run()])
else:
parser.print_help()
