[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]
[tor-commits] [ooni-probe/master] Implement working trial inspired OONIprobe refactoring
commit cbfcbdd0344d8e9a80d565ba01b64c7a40c97352
Author: Arturo Filastò <arturo@xxxxxxxxxxx>
Date: Thu Sep 20 19:26:46 2012 +0000
Implement working trial inspired OONIprobe refactoring
---
ooni/nettest.py | 41 +++----
ooni/oonicli.py | 66 ++++-------
ooni/plugoo/tests.py | 1 +
ooni/runner.py | 330 ++++++++++++-------------------------------------
4 files changed, 122 insertions(+), 316 deletions(-)
diff --git a/ooni/nettest.py b/ooni/nettest.py
index 4ab1e0f..0302d25 100644
--- a/ooni/nettest.py
+++ b/ooni/nettest.py
@@ -1,5 +1,4 @@
import itertools
-
from twisted.python import log
from twisted.trial import unittest, itrial
@@ -42,35 +41,29 @@ class TestSuiteFactory(object):
self._idx += 1
return new_test_suite
-class TestSuite(pyunit.TestSuite):
- def __init__(self, tests=()):
- self._tests = []
- self.input = None
- self._idx = 0
- self.addTests(tests)
-
- def __repr__(self):
- return "<%s input=%s tests=%s>" % (self.__class__,
- self.input, self._tests)
-
- def run(self, result):
- """
- Call C{run} on every member of the suite.
- """
- # we implement this because Python 2.3 unittest defines this code
- # in __call__, whereas 2.4 defines the code in run.
- for i, test in enumerate(self._tests):
+class InputTestSuite(pyunit.TestSuite):
+ def run(self, result, idx=0):
+ self._idx = idx
+ while self._tests:
if result.shouldStop:
break
- test.input = self.input
- test._idx = self._idx + i
- test(result)
-
+ test = self._tests.pop(0)
+ try:
+ test.input = self.input
+ test._idx = self._idx
+ print "IDX: %s" % self._idx
+ test(result)
+ except:
+ test(result)
+ self._idx += 1
return result
class TestCase(unittest.TestCase):
name = "DefaultTestName"
- inputs = [None]
+ inputs = []
+
+ def getOptions(self):
+ return {'inputs': self.inputs}
def __repr__(self):
return "<%s inputs=%s>" % (self.__class__, self.inputs)
diff --git a/ooni/oonicli.py b/ooni/oonicli.py
index be73d30..f0287b4 100644
--- a/ooni/oonicli.py
+++ b/ooni/oonicli.py
@@ -15,6 +15,15 @@
import sys, os, random, gc, time, warnings
+import unittest
+import inspect
+
+from ooni.input import InputUnitFactory
+from ooni.reporter import ReporterFactory
+from ooni.nettest import InputTestSuite
+from ooni.plugoo import tests
+from ooni import nettest, runner, reporter
+
from twisted.internet import defer
from twisted.application import app
from twisted.python import usage, reflect, failure, log
@@ -24,7 +33,6 @@ from twisted.python.util import spewer
from twisted.python.compat import set
from twisted.trial import itrial
from twisted.trial import runner as irunner
-from ooni import runner, reporter
def _parseLocalVariables(line):
@@ -132,11 +140,10 @@ class Options(usage.Options, app.ReactorSelectionMixin):
repeat=True)],
)
- fallbackReporter = reporter.OONIReporter
tracer = None
def __init__(self):
- self['tests'] = set()
+ self['test'] = None
usage.Options.__init__(self)
@@ -178,7 +185,10 @@ class Options(usage.Options, app.ReactorSelectionMixin):
if not os.path.isfile(filename):
sys.stderr.write("File %r doesn't exist\n" % (filename,))
return
+
filename = os.path.abspath(filename)
+ self['test'] = filename
+
if isTestFile(filename):
self['tests'].add(filename)
else:
@@ -248,7 +258,10 @@ class Options(usage.Options, app.ReactorSelectionMixin):
def parseArgs(self, *args):
- self['tests'].update(args)
+ try:
+ self['test'] = args[0]
+ except:
+ raise usage.UsageError("No test filename specified!")
def postOptions(self):
@@ -265,39 +278,6 @@ class Options(usage.Options, app.ReactorSelectionMixin):
"--nopm ")
failure.DO_POST_MORTEM = False
-
-def _initialDebugSetup(config):
- # do this part of debug setup first for easy debugging of import failures
- if config['debug']:
- failure.startDebugMode()
- if config['debug'] or config['debug-stacktraces']:
- defer.setDebugging(True)
-
-
-def _getSuitesAndInputs(config):
- #loader = irunner.TestLoader()
- loader = runner.NetTestLoader()
- recurse = not config['no-recurse']
- print "loadByNames %s" % config['tests']
- inputs, suites = loader.loadByNamesWithInput(config['tests'], recurse)
- return inputs, suites
-
-def _makeRunner(config):
- mode = None
- if config['debug']:
- mode = runner.OONIRunner.DEBUG
- print "using %s" % config['reporter']
- return runner.OONIRunner(config['reporter'],
- reportfile=config["reportfile"],
- mode=mode,
- logfile=config['logfile'],
- tracebackFormat=config['tbformat'],
- realTimeErrors=config['rterrors'],
- uncleanWarnings=config['unclean-warnings'],
- workingDirectory=config['temp-directory'],
- forceGarbageCollection=config['force-gc'])
-
-
def run():
if len(sys.argv) == 1:
sys.argv.append("--help")
@@ -307,10 +287,10 @@ def run():
except usage.error, ue:
raise SystemExit, "%s: %s" % (sys.argv[0], ue)
- _initialDebugSetup(config)
- trialRunner = _makeRunner(config)
- inputs, testSuites = _getSuitesAndInputs(config)
- log.startLogging(sys.stdout)
- for i, suite in enumerate(testSuites):
- test_result = trialRunner.run(suite, inputs[i])
+ file_name = os.path.abspath('nettests/simpletest.py')
+ classes = runner.findTestClassesFromFile(config['test'])
+ casesList, options = runner.loadTestsAndOptions(classes)
+ for idx, cases in enumerate(casesList):
+ orunner = runner.ORunner(cases, options[idx])
+ orunner.run()
diff --git a/ooni/plugoo/tests.py b/ooni/plugoo/tests.py
index 2b1e87c..e4ee187 100644
--- a/ooni/plugoo/tests.py
+++ b/ooni/plugoo/tests.py
@@ -133,6 +133,7 @@ class OONITest(object):
@param args: the asset(s) lines that we are working on.
"""
self.start_time = date.now()
+ print "FOWID"
log.msg("Starting test %s" % self.__class__)
return self._do_experiment(args)
diff --git a/ooni/runner.py b/ooni/runner.py
index 604942d..ddde83b 100644
--- a/ooni/runner.py
+++ b/ooni/runner.py
@@ -13,9 +13,16 @@ from twisted.trial.runner import filenameToModule, _importFromFile
from ooni.reporter import ReporterFactory
from ooni.input import InputUnitFactory
+from ooni.nettest import InputTestSuite
from ooni import nettest
from ooni.plugoo import tests as oonitests
+def isTestCase(thing):
+ try:
+ return issubclass(thing, unittest.TestCase)
+ except TypeError:
+ return False
+
def isLegacyTest(obj):
"""
Returns True if the test in question is written using the OONITest legacy
@@ -23,7 +30,10 @@ def isLegacyTest(obj):
We do this for backward compatibility of the OONIProbe API.
"""
try:
- return issubclass(obj, oonitests.OONITest)
+ if issubclass(obj, oonitests.OONITest) and not obj == oonitests.OONITest:
+ return True
+ else:
+ return False
except TypeError:
return False
@@ -36,267 +46,89 @@ def adaptLegacyTest(obj, inputs=[None]):
older test cases compatible with the new OONI.
"""
class LegacyOONITest(nettest.TestCase):
- inputs = [1]
+ inputs = [None]
original_test = obj
+ @defer.inlineCallbacks
def test_start_legacy_test(self):
print "bla bla bla"
- my_test = self.original_test()
- print my_test
- print "foobat"
- my_test.startTest(self.input)
- print "HHAHAHA"
+ print self.original_test
+ my_test = self.original_test(None, None, None)
+ yield my_test.startTest(self.input)
return LegacyOONITest
-class LoggedSuite(nettest.TestSuite):
- """
- Any errors logged in this suite will be reported to the L{TestResult}
- object.
- """
-
- def run(self, result):
- """
- Run the suite, storing all errors in C{result}. If an error is logged
- while no tests are running, then it will be added as an error to
- C{result}.
-
- @param result: A L{TestResult} object.
- """
- observer = unittest._logObserver
- observer._add()
- super(LoggedSuite, self).run(result)
- observer._remove()
- for error in observer.getErrors():
- result.addError(TestHolder(NOT_IN_TEST), error)
- observer.flushErrors()
+def findTestClassesFromFile(filename):
+ classes = []
+ print "FILENAME %s" % filename
+ module = filenameToModule(filename)
+ for name, val in inspect.getmembers(module):
+ if isTestCase(val):
+ classes.append(val)
+ elif isLegacyTest(val):
+ classes.append(adaptLegacyTest(val))
+ return classes
-class OONISuite(nettest.TestSuite):
- """
- Suite to wrap around every single test in a C{trial} run. Used internally
- by OONI to set up things necessary for OONI tests to work, regardless of
- what context they are run in.
- """
+def makeTestCases(klass, tests, methodPrefix):
+ cases = []
+ for test in tests:
+ cases.append(klass(methodPrefix+test))
+ return cases
- def __init__(self, tests=()):
- suite = LoggedSuite(tests)
- super(OONISuite, self).__init__([suite])
-
- def _bail(self):
- from twisted.internet import reactor
- d = defer.Deferred()
- reactor.addSystemEventTrigger('after', 'shutdown',
- lambda: d.callback(None))
- reactor.fireSystemEvent('shutdown') # radix's suggestion
- # As long as TestCase does crap stuff with the reactor we need to
- # manually shutdown the reactor here, and that requires util.wait
- # :(
- # so that the shutdown event completes
- nettest.TestCase('mktemp')._wait(d)
-
- def run(self, result):
- try:
- nettest.TestSuite.run(self, result)
- finally:
- self._bail()
-
-
-class NetTestLoader(TestLoader):
- """
- Reponsible for finding the modules that can work as tests and running them.
- If we detect that a certain test is written using the legacy OONI API we
- will wrap it around a next gen class to make it work here too.
-
- XXX This class needs to be cleaned up a *lot* of all the things we actually
- don't need.
- """
+def loadTestsAndOptions(classes):
methodPrefix = 'test'
- modulePrefix = 'test_'
-
- def __init__(self):
- self.suiteFactory = nettest.TestSuite
- self._importErrors = []
-
- def findTestClasses(self, module):
- classes = []
- for name, val in inspect.getmembers(module):
- if isTestCase(val):
- classes.append(val)
- # This is here to allow backward compatibility with legacy OONI
- # tests.
- elif isLegacyTest(val):
- print "adapting! %s" % val
- val = adaptLegacyTest(val)
- classes.append(val)
- return classes
-
- def loadClass(self, klass):
- """
- Given a class which contains test cases, return a sorted list of
- C{TestCase} instances.
- """
- if not (isinstance(klass, type) or isinstance(klass, types.ClassType)):
- raise TypeError("%r is not a class" % (klass,))
- if not isTestCase(klass):
- raise ValueError("%r is not a test case" % (klass,))
- names = self.getTestCaseNames(klass)
- tests = []
- for name in names:
- tests.append(self._makeCase(klass, self.methodPrefix+name))
-
- suite = self.suiteFactory(tests)
- print "**+*"
- print tests
- print "**+*"
-
- return suite
- loadTestsFromTestCase = loadClass
-
- def findAllInputs(self, thing):
- testClasses = self.findTestClasses(thing)
- # XXX will there ever be more than 1 test class with inputs?
- for klass in testClasses:
- try:
- inputs = klass.inputs
- except:
- pass
- return inputs
-
- def loadByNamesWithInput(self, names, recurse=False):
- """
- Construct a OONITestSuite containing all the tests found in 'names', where
- names is a list of fully qualified python names and/or filenames. The
- suite returned will have no duplicate tests, even if the same object
- is named twice.
-
- This test suite will have set the attribute inputs to the inputs found
- inside of the tests.
- """
- inputs = []
- things = []
- errors = []
- for name in names:
- try:
- thing = self.findByName(name)
- things.append(thing)
- except:
- errors.append(ErrorHolder(name, failure.Failure()))
- suites = []
- for thing in self._uniqueTests(things):
- inputs.append(self.findAllInputs(thing))
- suite = self.loadAnything(thing, recurse)
- suites.append(suite)
-
- suites.extend(errors)
- return inputs, suites
-
-class OONIRunner(object):
- """
- A specialised runner that is used by the ooniprobe frontend to run tests.
- Heavily inspired by the trial TrialRunner class.
- """
-
- DEBUG = 'debug'
- DRY_RUN = 'dry-run'
-
- def _getDebugger(self):
- dbg = pdb.Pdb()
+ suiteFactory = InputTestSuite
+ options = []
+ testCases = []
+ for klass in classes:
try:
- import readline
- except ImportError:
- print "readline module not available"
- sys.exc_clear()
- for path in ('.pdbrc', 'pdbrc'):
- if os.path.exists(path):
- try:
- rcFile = file(path, 'r')
- except IOError:
- sys.exc_clear()
- else:
- dbg.rcLines.extend(rcFile.readlines())
- return dbg
-
-
- def _setUpTestdir(self):
- self._tearDownLogFile()
- currentDir = os.getcwd()
- base = filepath.FilePath(self.workingDirectory)
- testdir, self._testDirLock = util._unusedTestDirectory(base)
- os.chdir(testdir.path)
- return currentDir
-
-
- def _tearDownTestdir(self, oldDir):
- os.chdir(oldDir)
- self._testDirLock.unlock()
-
-
- _log = log
- def _makeResult(self):
- reporter = self.reporterFactory(self.stream, self.tbformat,
- self.rterrors, self._log)
- if self.uncleanWarnings:
- reporter = UncleanWarningsReporterWrapper(reporter)
- return reporter
-
- def __init__(self, reporterFactory,
- reportfile="report.yaml",
- mode=None,
- logfile='test.log',
- stream=sys.stdout,
- profile=False,
- tracebackFormat='default',
- realTimeErrors=False,
- uncleanWarnings=False,
- workingDirectory=None,
- forceGarbageCollection=False):
- self.reporterFactory = reporterFactory
- self._reportfile = reportfile
- self.logfile = logfile
- self.mode = mode
- self.stream = stream
- self.tbformat = tracebackFormat
- self.rterrors = realTimeErrors
- self.uncleanWarnings = uncleanWarnings
- self._result = None
- self.workingDirectory = workingDirectory or '_trial_temp'
- self._logFileObserver = None
- self._logFileObject = None
- self._forceGarbageCollection = forceGarbageCollection
- if profile:
- self.run = util.profiled(self.run, 'profile.data')
-
- def _tearDownLogFile(self):
- if self._logFileObserver is not None:
- log.removeObserver(self._logFileObserver.emit)
- self._logFileObserver = None
- if self._logFileObject is not None:
- self._logFileObject.close()
- self._logFileObject = None
-
- def _setUpLogFile(self):
- self._tearDownLogFile()
- if self.logfile == '-':
- logFile = sys.stdout
+ k = klass()
+ options.append(k.getOptions())
+ except AttributeError:
+ options.append([])
+
+ tests = reflect.prefixedMethodNames(klass, methodPrefix)
+ if tests:
+ cases = makeTestCases(klass, tests, methodPrefix)
+ testCases.append(cases)
else:
- logFile = file(self.logfile, 'a')
- self._logFileObject = logFile
- self._logFileObserver = log.FileLogObserver(logFile)
- log.startLoggingWithObserver(self._logFileObserver.emit, 0)
+ options.pop()
+
+ return testCases, options
+
+class ORunner(object):
+ def __init__(self, cases, options=None):
+ self.baseSuite = InputTestSuite
+ self.cases = cases
+ self.options = options
+ self.inputs = options['inputs']
+ self.reporterFactory = ReporterFactory(open('foo.log', 'a+'),
+ testSuite=self.baseSuite(self.cases))
+
+ def runWithInputUnit(self, inputUnit):
+ idx = 0
+ result = self.reporterFactory.create()
+ for input in inputUnit:
+ suite = self.baseSuite(self.cases)
+ suite.input = input
+ suite(result, idx)
+
+ # XXX refactor all of this index bullshit to avoid having to pass
+ # this index around. Probably what I want to do is go and make
+ # changes to report to support the concept of having multiple runs
+ # of the same test.
+ # We currently need to do this addition in order to get the number
+ # of times the test cases that have run inside of the test suite.
+ idx += (suite._idx - idx)
+
+ result.done()
+
+ def run(self):
+ self.reporterFactory.writeHeader()
+
+ for inputUnit in InputUnitFactory(self.inputs):
+ self.runWithInputUnit(inputUnit)
- def run(self, tests, inputs=[None]):
- """
- Run the test or suite and return a result object.
- """
- reporterFactory = ReporterFactory(open(self._reportfile, 'a+'),
- testSuite=tests)
- reporterFactory.writeHeader()
- for inputUnit in InputUnitFactory(inputs):
- testSuiteFactory = nettest.TestSuiteFactory(inputUnit, tests, nettest.TestSuite)
- testUnitReport = reporterFactory.create()
- for suite in testSuiteFactory:
- suite(testUnitReport)
- testUnitReport.done()
_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits