[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]
[tor-commits] [ooni-probe/master] * Still working on NetTestAdaptor
commit 743e6f57cf72058a253134cce092aad9ea95379a
Author: Isis Lovecruft <isis@xxxxxxxxxxxxxx>
Date: Sun Nov 4 12:28:36 2012 +0000
* Still working on NetTestAdaptor
* Fixed so many errors in pretty much everything that I can't even count.
---
ooni/nettest.py | 136 ++++++++++++++++++++++------------
ooni/runner.py | 187 ++++++++++++++-------------------------------
ooni/templates/scapyt.py | 4 +-
3 files changed, 148 insertions(+), 179 deletions(-)
diff --git a/ooni/nettest.py b/ooni/nettest.py
index 7f9f72c..03e391e 100644
--- a/ooni/nettest.py
+++ b/ooni/nettest.py
@@ -25,6 +25,7 @@ from ooni.utils import log
pyunit = __import__('unittest')
+
class InputTestSuite(pyunit.TestSuite):
"""
This in an extension of a unittest test suite. It adds support for inputs
@@ -70,13 +71,14 @@ class NetTestAdaptor(unittest.TestCase):
XXX fill me in
"""
- @classmethod
- def __new__(cls, *args, **kwargs):
- if hasattr(cls, "setUpClass"):
- super( NetTestAdaptor, cls ).setUpClass(cls)
- else:
- log.debug("NetTestAdaptor: constructor could not find setUpClass")
- return super( NetTestAdaptor, cls ).__new__(cls, *args, **kwargs)
+ # @classmethod
+ # def __new__(cls, *args, **kwargs):
+ # try:
+ # setUpClass()
+ # except Exception, e:
+ # log.debug("NetTestAdaptor: constructor could not find setUpClass")
+ # log.err(e)
+ # return super( NetTestAdaptor, cls ).__new__(cls, *args, **kwargs)
def __init__(self, *args, **kwargs):
"""
@@ -114,10 +116,12 @@ class NetTestAdaptor(unittest.TestCase):
#self._input_parser = copyattr("inputParser", alt=__input_parser__)
#self._nettest_name = copyattr("name", alt="NetTestAdaptor"))
- if self.parsed_inputs:
- self.inputs = self.parsed_inputs
- else:
- log.debug("Unable to find parsed inputs")
+ #self.setUpClass(self.__class__)
+
+ #if hasattr(self, parsed_inputs):
+ # self.inputs = self.parsed_inputs
+ #else:
+ # log.debug("Unable to find parsed inputs")
@staticmethod
def __copyattr__(obj, old, new=None, alt=None):
@@ -220,7 +224,8 @@ class NetTestAdaptor(unittest.TestCase):
pass ## don't burn cycles on testing null inputs
else:
log.msg("Received direct inputs:\n%s" % cls._raw_inputs)
- parsed.extend([cls._input_parser(x) for x in cls._raw_inputs])
+ parsed.extend(
+ [cls._input_parser(x) for x in cls._raw_inputs])
elif isinstance(cls._raw_inputs, str):
separated = cls._raw_inputs.translate(None, ',') ## space delineates
inputlist = separated.split(' ')
@@ -229,43 +234,83 @@ class NetTestAdaptor(unittest.TestCase):
log.debug("inputs not string or list; type: %s"
% type(cls._raw_inputs))
+ if cls.subarg_inputs:
+ log.debug("NetTestAdaptor: __get_inputs__ found subarg_inputs=%s"
+ % cls.subarg_inputs)
+ parsed.extend([cls._input_parser(x) for x in cls.subarg_inputs])
+
if cls._input_file:
try:
- log.debug("Opening input file")
+ log.debug("NetTestAdaptor: __get_inputs__ Opening input file")
fp = open(cls._input_file)
except:
- log.debug("Couldn't open input file")
+ log.debug("NetTestAdaptor: __get_inputs__ Couldn't open input file")
else:
- log.debug("Running input file processor")
+ log.debug("NetTestAdaptor: __get_inputs__ Running input file processor")
lines = [line.strip() for line in fp.readlines()]
fp.close()
## add to what we've already parsed, if any:
- log.debug("Parsing lines from input file")
+ log.debug("NetTestAdaptor: __get_inputs__ Parsing lines from input file")
parsed.extend([cls._input_parser(ln) for ln in lines])
else:
- log.debug("%s specified that it doesn't need inputFile."
+ log.debug("NetTestAdaptor: %s specified that it doesn't need inputFile."
% cls._nettest_name)
return parsed
@classmethod
- def __optstruct__(cls):
+ def __getopt__(cls, parseArgs=None):
"""
Constuctor for a custom t.p.usage.Options class, per NetTestCase.
+
+ old code from runner.py:
+ opts = Options()
+ opts.parseOptions(config['subArgs'])
+ cls.localOptions = opts
"""
- #if cls._opt_parameters is None:
- # cls._opt_parameters = [ list() ]
+ if cls._testopt_params or cls._input_file:
+ if not cls._testopt_params:
+ cls._testopt_params = []
+
+ if cls._input_file:
+ cls._testopt_params.append(cls.input_file)
class NetTestOptions(usage.Options):
"""Per NetTestCase Options class."""
- optParameters = cls._testopt_params
- optFlags = cls._testopt_flags
- subOptions = cls._sub_options
- subCommands = cls._sub_command
+ optParameters = cls._testopt_params
+ optFlags = cls._testopt_flags
+ subOptions = cls._sub_options
+ subCommands = cls._sub_commands
+ defaultSubCommand = cls._default_subcmd
+ ## XXX i'm not sure if this part will work:
+ parseArgs = lambda a: cls.subarg_inputs.append(a)
+
+ def opt_version(self):
+ """Display test version and exit."""
+ print "Test version: ", cls._nettest_version
+ sys.exit(0)
+
+ options = NetTestOptions()
+ return options
- def buildUsageOptions(self, *args, **kwargs):
- pass
+ #if cls._input_file:
+ # cls._input_file = cls.options[cls._input_file[0]]
+
+ @classmethod
+ def addSubArgToInputs(cls, subarg):
+ cls.subarg_inputs.append(subarg)
+
+ @classmethod
+ def buildOptions(cls, from_global):
+ log.debug("NetTestAdaptor: getTestOptions called")
+ options = cls.__getopt__()
+ log.debug("NetTestAdaptor: getTestOptions: cls.options = %s"
+ % options)
+ options.parseOptions(from_global)
+ setattr(cls, "local_options", options)
+ log.debug("NetTestAdaptor: getTestOptions: cls.local_options = %s"
+ % cls.local_options)
@classmethod
def setUpClass(cls):
@@ -278,24 +323,29 @@ class NetTestAdaptor(unittest.TestCase):
subclass of :class:`ooni.nettest.NetTestCase`, so that the calling
functions during NetTestCase class setup can handle them correctly.
"""
+
+ log.debug("NetTestAdaptor: setUpClass called")
+
## These internal inputs are for handling inputs and inputFile
- cls._raw_inputs = __copyattr__(cls, "inputs")
- cls._input_file = __copyattr__(cls, "inputFile")
- cls._input_parser = __copyattr__(cls, "inputParser", alt=__input_parser__)
- cls._nettest_name = __copyattr__(cls, "name", alt="NetTestAdaptor")
+ cls._raw_inputs = cls.__copyattr__(cls, "inputs")
+ cls._input_file = cls.__copyattr__(cls, "inputFile")
+ cls._input_parser = cls.__copyattr__(cls, "inputParser",
+ alt=cls.__input_parser__)
+ cls._nettest_name = cls.__copyattr__(cls, "name", alt="NetTestAdaptor")
## This creates a class attribute with all of the parsed inputs,
## which the instance will later set to be `self.inputs`.
- cls.parsed_inputs = __get_inputs__(cls)
+ cls.parsed_inputs = cls.__get_inputs__()
+ cls.subarg_inputs = cls.__copyattr__(cls, "subarg_inputs",
+ alt=[])
## XXX we should handle options generation here
- cls._testopt_params = __copyattr__(cls, "optParameters")
- cls._testopt_flags = __copyattr__(cls, "optFlags")
- cls._sub_options = __copyattr__(cls, "subOptions")
- cls._sub_command = __copyattr__(cls, "subCommand")
- cls._default_subcmd = __copyattr__(cls, "defaultSubCommand")
- cls._nettest_version = __copyattr__(cls, "version")
-
+ cls._testopt_params = cls.__copyattr__(cls, "optParameters")
+ cls._testopt_flags = cls.__copyattr__(cls, "optFlags")
+ cls._sub_options = cls.__copyattr__(cls, "subOptions")
+ cls._sub_commands = cls.__copyattr__(cls, "subCommands")
+ cls._default_subcmd = cls.__copyattr__(cls, "defaultSubCommand")
+ cls._nettest_version = cls.__copyattr__(cls, "version")
class NetTestCase(NetTestAdaptor):
"""
@@ -376,15 +426,6 @@ class NetTestCase(NetTestAdaptor):
return inputs
def getOptions(self):
- '''
- for attr in attributes:
- if not attr.name is 'optParameters' or attr.name is 'optFlags':
- continue
- elif attr.name is 'optParameters':
- cls._optParameters = attr.object
- else:
- log.debug("How did we get here? attr.name = %s" % attr.name)
- '''
log.debug("Getting options for test")
if self.localOptions:
@@ -408,4 +449,3 @@ class NetTestCase(NetTestAdaptor):
def __repr__(self):
return "<%s inputs=%s>" % (self.__class__, self.inputs)
-
diff --git a/ooni/runner.py b/ooni/runner.py
index a7973dc..f6db105 100644
--- a/ooni/runner.py
+++ b/ooni/runner.py
@@ -25,6 +25,13 @@ from ooni.utils import log, date
from ooni.utils.legacy import LegacyOONITest
from ooni.utils.legacy import start_legacy_test, adapt_legacy_test
+
+def isTemplate(obj):
+ origin = obj.__module__
+ if origin.find('templates') >= 0:
+ return True
+ return False
+
def isLegacyTest(obj):
"""
Returns True if the test in question is written using the OONITest legacy
@@ -36,48 +43,6 @@ def isLegacyTest(obj):
except TypeError:
return False
-def processTest(obj, config):
- """
- Process the parameters and :class:`twisted.python.usage.Options` of a
- :class:`ooni.nettest.Nettest`.
-
- :param obj:
- An uninstantiated old test, which should be a subclass of
- :class:`ooni.plugoo.tests.OONITest`.
- :param config:
- A configured and instantiated :class:`twisted.python.usage.Options`
- class.
- """
-
- input_file = obj.inputFile
- if obj.requiresRoot:
- if os.getuid() != 0:
- raise Exception("This test requires root to run")
-
- if obj.optParameters or input_file:
- if not obj.optParameters:
- obj.optParameters = []
-
- if input_file:
- obj.optParameters.append(input_file)
-
- class Options(usage.Options):
- optParameters = obj.optParameters
-
- options = Options()
- options.parseOptions(config['subArgs'])
- obj.localOptions = options
-
- if input_file:
- obj.inputFile = options[input_file[0]]
- try:
- tmp_obj = obj()
- tmp_obj.getOptions()
- except usage.UsageError:
- options.opt_help()
-
- return obj
-
def findTestClassesFromConfig(config):
"""
Takes as input the command line config parameters and returns the test
@@ -98,24 +63,32 @@ def findTestClassesFromConfig(config):
module = filenameToModule(filename)
for name, val in inspect.getmembers(module):
if isTestCase(val):
- log.debug("Detected TestCase %s" % val)
- classes.append(val)
+ if val != NetTestCase and not isTemplate(val):
+ log.debug("findTestClassesFromConfig: detected %s"
+ % val.__name__)
+ classes.append(val)
elif isLegacyTest(val):
log.debug("Detected Legacy Test %s" % val)
classes.append(adapt_legacy_test(val, config))
return classes
-def makeTestCases(klass, tests, method_prefix):
+def makeTestCases(klass, tests, method_prefix=None):
"""
Takes a class some tests and returns the test cases. method_prefix is how
the test case functions should be prefixed with.
"""
+ if not method_prefix:
+ method_prefix = 'test'
+
cases = []
for test in tests:
- cases.append(klass(method_prefix+test))
+ log.debug("makeTestCases: making test case for %s" % test)
+ method_name = str(method_prefix)+str(test)
+ log.debug("makeTestCases: using methodName=%s" % method_name)
+ cases.append(klass(methodName=method_name))
return cases
-def processTestOptions(cls, config):
+def getTestOptions(cls, subargs):
"""
Process the parameters and :class:`twisted.python.usage.Options` of a
:class:`ooni.nettest.Nettest`.
@@ -126,48 +99,16 @@ def processTestOptions(cls, config):
A configured and instantiated :class:`twisted.python.usage.Options`
class.
"""
- #if cls.optParameters or cls.inputFile:
- if not cls.optParameters:
- cls.optParameters = []
-
- if cls.inputFile:
- cls.optParameters.append(cls.inputFile)
-
- log.debug("CLS IS %s" % cls)
- log.debug("CLS OPTPARAM IS %s" % cls.optParameters)
-
- #if not hasattr(cls, subCommands):
- # cls.subCommands = []
-
- if not cls.subCommands:
- cls.subCommands = []
-
- class Options(usage.Options):
- optParameters = cls.optParameters
- parseArgs = lambda a: cls.subCommands.append(a)
-
- opts = Options()
- opts.parseOptions(config['subArgs'])
- cls.localOptions = opts
+ if cls.requiresRoot:
+ if os.getuid() != 0:
+ raise Exception("This test requires root to run")
- if cls.inputFile:
- cls.inputFile = opts[cls.inputFile[0]]
- """
try:
- log.debug("%s: trying %s.localoptions.getOptions()..."
- % (__name__, cls.name))
- try:
- assert hasattr(cls, 'getOptions')
- except AssertionError, ae:
- options = opts.opt_help()
- raise Exception, "Cannot find %s.getOptions()" % cls.name
- else:
- options = cls.getOptions()
- except usage.UsageError:
- options = opts.opt_help()
- else:
- """
- return cls.localOptions
+ cls.buildOptions(subargs)
+ except Exception, e:
+ log.err(e)
+
+ return cls.local_options
def loadTestsAndOptions(classes, config):
"""
@@ -184,15 +125,14 @@ def loadTestsAndOptions(classes, config):
for klass in classes:
if isinstance(klass, DEPRECATED):
- #not issubclass(klass, TestCase):
try:
cases, opts = processLegacyTest(klass, config)
if cases:
- log.debug("Processing cases: %s" % str(cases))
+ log.debug("loadTestsAndOptions: processing cases %s"
+ % str(cases))
return [], []
test_cases.append(cases)
- except Exception, e:
- log.err(e)
+ except Exception, e: log.err(e)
else:
try:
opts = klass.local_options
@@ -214,45 +154,37 @@ def loadTestsAndOptions(classes, config):
def processNetTest(klass, config, method_prefix):
try:
- log.debug("Processing cases and options for OONI %s test"
- % (klass.name if hasattr(klass, 'name') else 'Network Test'))
+ klass.setUpClass()
+ except Exception, e:
+ log.err(e)
+
+ subargs_from_config = config['subArgs']
+ log.debug("processNetTest: received subargs from config: %s"
+ % str(subargs_from_config))
+ try:
+ opts = getTestOptions(klass, subargs_from_config)
+ except Exception, e:
+ opts = []
+ log.err(e)
+ try:
+ log.debug("processNetTest: processing cases for %s"
+ % (klass.name if hasattr(klass, 'name') else 'Network Test'))
tests = reflect.prefixedMethodNames(klass, method_prefix)
+ except Exception, e:
+ cases = []
+ opts = []
+ log.err(e)
+ else:
if tests:
cases = makeTestCases(klass, tests, method_prefix)
- log.debug("loadTestsAndOptions(): test %s found cases=%s"% (tests, cases))
- try:
- k = klass()
- opts = processTestOptions(k, config)
- except Exception, e:
- opts = []
- log.err(e)
+ log.debug("processNetTest: test %s found cases %s"
+ % (tests, cases))
else:
cases = []
- except Exception, e:
- log.err(e)
return cases, opts
-'''
- if hasattr(klass, 'optParameters') or hasattr(klass, 'inputFile'):
- try:
- opts = processTestOptions(klass, config)
- except:
- opts = []
- finally:
- try:
- k = klass()
- inputs = k._getInputs()
- except Exception, e:
- inputs = []
- log.err(e)
- else:
- if opts and len(inputs) != 0:
- opts.append(['inputs', '', inputs, "cmdline inputs"])
- log.debug("loadTestsAndOptions(): inputs=%s" % inputs)
-'''
-
def processLegacyTest(klass, config):
log.msg("Processing cases and options for legacy test %s"
% ( klass.shortName if hasattr(klass, shortName) else 'oonitest' ))
@@ -277,22 +209,19 @@ def processLegacyTest(klass, config):
opts = {}
elif hasattr(klass, local_options): ## we've been initialized already
- log.debug("%s.local_options found" % klass)
+ log.debug("processLegacyTest: %s.local_options found" % str(klass))
try:
- assert klass.local_options is not None
opts = klass.local_options
- except AttributeError, ae:
- opts = {}; log.err(ae)
+ except AttributeError, ae: opts = {}; log.err(ae)
+ log.debug("processLegacyTest: opts set to %s" % str(opts))
try:
cases = start_legacy_test(klass)
## XXX we need to get these results into the reporter
if cases:
+ log.debug("processLegacyTest: found cases: %s" % str(cases))
return [], []
- except Exception, e:
- cases = []; log.err(e)
- finally:
- log.debug(str(cases))
+ except Exception, e: cases = []; log.err(e)
return cases, opts
diff --git a/ooni/templates/scapyt.py b/ooni/templates/scapyt.py
index f71ab57..1b19dbf 100644
--- a/ooni/templates/scapyt.py
+++ b/ooni/templates/scapyt.py
@@ -32,7 +32,7 @@ class ScapyTest(NetTestCase):
receive = True
timeout = 1
pcapfile = None
- input = IP()/TCP()
+ packet = IP()/TCP()
reactor = None
def setUp(self):
if not self.reactor:
@@ -56,5 +56,5 @@ class ScapyTest(NetTestCase):
"""
Override this method to build scapy packets.
"""
- return self.input
+ return self.packet
_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits