def testTests(self): suite = unittest.TestSuite() suffixes = reflect.prefixedMethodNames(TestTests.Tests, "test") for suffix in suffixes: method = "test" + suffix testCase = self.Tests() # if one of these test cases fails, switch to TextReporter to # see what happened rep = reporter.Reporter() #reporter = reporter.TextReporter() #print "running '%s'" % method rep.start(1) result = unittest.Tester(testCase.__class__, testCase, getattr(testCase, method), lambda x: x()).run() rep.reportResults(testCase.__class__, getattr(self.Tests, method), *result) # TODO: verify that case.setUp == 1 and case.tearDown == 1 try: self.checkResults(rep, method) except unittest.FailTest: # with TextReporter, this will show the traceback print print "problem in method '%s'" % method reporter.stop() raise
def setupOptParameters(self): params = [] if hasattr(self.options, 'optParameters'): params.extend(self.options.optParameters) d = {} soFar = {} for meth in reflect.prefixedMethodNames(self.options.__class__, 'opt_'): full = 'opt_' + meth func = getattr(self.options, full) if usage.flagFunction(func) or soFar.has_key(func): continue soFar[func] = 1 existing = d.setdefault(func, meth) if existing != meth: if len(existing) < len(meth): d[func] = meth for (func, name) in d.items(): params.append((name, None, None, func.__doc__)) if len(params): self.paramFrame = Tkinter.Frame(self) self.paramLines = [] for (flag, _, default, desc) in params: try: default = self.options[flag] except KeyError: pass self.makeField(flag, default, desc) self.paramFrame.grid(row=1, column=2)
def __init__(self, textView): self.textView=textView self.rkeymap = {} self.history = History() for name in prefixedMethodNames(self.__class__, "key_"): keysymName = name.split("_")[-1] self.rkeymap[getattr(gtk.keysyms, keysymName)] = keysymName
def _get_provider_names(self): """ Find the names of all supported "providers" (eg Vagrant, Rackspace). :return: A ``list`` of ``str`` giving all such names. """ return prefixedMethodNames(self.__class__, "_runner_")
def __init__(self, textView): self.textView = textView self.rkeymap = {} self.history = History() for name in prefixedMethodNames(self.__class__, "key_"): keysymName = name.split("_")[-1] self.rkeymap[getattr(gtk.keysyms, keysymName)] = keysymName
def setupOptFlags(self): self.optFlags = [] flags = [] if hasattr(self.options, 'optFlags'): flags.extend(self.options.optFlags) d = {} soFar = {} for meth in reflect.prefixedMethodNames(self.options.__class__, 'opt_'): full = 'opt_' + meth func = getattr(self.options, full) if not usage.flagFunction(func) or meth in ('help', 'version'): continue if soFar.has_key(func): continue soFar[func] = 1 existing = d.setdefault(func, meth) if existing != meth: if len(existing) < len(meth): d[func] = meth for (func, name) in d.items(): flags.append((name, None, func.__doc__)) if len(flags): self.optFrame = f = Tkinter.Frame(self) for (flag, _, desc) in flags: b = Tkinter.BooleanVar() c = Tkinter.Checkbutton(f, text=desc, variable=b, wraplen=200) c.pack(anchor=Tkinter.W) self.optFlags.append((flag, b)) f.grid(row=1, column=1)
def ctcpQuery_CLIENTINFO(self, user, channel, data): """A master index of what CTCP tags this client knows. If no arguments are provided, respond with a list of known tags. If an argument is provided, provide human-readable help on the usage of that tag. """ nick = string.split(user,"!")[0] if not data: # XXX: prefixedMethodNames gets methods from my *class*, # but it's entirely possible that this *instance* has more # methods. names = reflect.prefixedMethodNames(self.__class__, 'ctcpQuery_') self.ctcpMakeReply(nick, [('CLIENTINFO', string.join(names, ' '))]) else: args = string.split(data) method = getattr(self, 'ctcpQuery_%s' % (args[0],), None) if not method: self.ctcpMakeReply(nick, [('ERRMSG', "CLIENTINFO %s :" "Unknown query '%s'" % (data, args[0]))]) return doc = getattr(method, '__doc__', '') self.ctcpMakeReply(nick, [('CLIENTINFO', doc)])
def listProcedures(self): """ Return a list of the names of all xmlrpc procedures. @since: 11.1 """ return reflect.prefixedMethodNames(self.__class__, 'xmlrpc_')
def ctcpQuery_CLIENTINFO(self, user, channel, data): """A master index of what CTCP tags this client knows. If no arguments are provided, respond with a list of known tags. If an argument is provided, provide human-readable help on the usage of that tag. """ nick = string.split(user, "!")[0] if not data: # XXX: prefixedMethodNames gets methods from my *class*, # but it's entirely possible that this *instance* has more # methods. names = reflect.prefixedMethodNames(self.__class__, 'ctcpQuery_') self.ctcpMakeReply(nick, [('CLIENTINFO', string.join(names, ' '))]) else: args = string.split(data) method = getattr(self, 'ctcpQuery_%s' % (args[0], ), None) if not method: self.ctcpMakeReply(nick, [('ERRMSG', "CLIENTINFO %s :" "Unknown query '%s'" % (data, args[0]))]) return doc = getattr(method, '__doc__', '') self.ctcpMakeReply(nick, [('CLIENTINFO', doc)])
def listProcedures(self): """ Return a list of the names of all xmlrpc procedures. @since: 11.1 """ return reflect.prefixedMethodNames(self.__class__, "xmlrpc_")
def test_inheritedMethod(self): """ L{prefixedMethodNames} returns a list included methods with the given prefix defined on base classes of the class passed to it. """ class Child(Separate): pass self.assertEqual(["method"], prefixedMethodNames(Child, "good_"))
def __init__(self, testClass): self.testClass = testClass self.methodNames = [] for prefix in self.methodPrefixes: self.methodNames.extend([ "%s%s" % (prefix, name) for name in reflect.prefixedMethodNames(testClass, prefix)]) # N.B.: --random will shuffle testClasses but not our methodNames[] self.methodNames.sort()
def _computeAllowedMethods(resource): """ Compute the allowed methods on a C{Resource} based on defined render_FOO methods. Used when raising C{UnsupportedMethod} but C{Resource} does not define C{allowedMethods} attribute. """ allowedMethods = [] for name in prefixedMethodNames(resource.__class__, "render_"): allowedMethods.append(name) return allowedMethods
def test_reverseKeymap(self): """ Verify that a L{ConsoleInput} has a reverse mapping of the keysym names it needs for event handling to their corresponding keysym. """ ci = ConsoleInput(None) for eventName in prefixedMethodNames(ConsoleInput, 'key_'): keysymName = eventName.split("_")[-1] keysymValue = getattr(gtk.keysyms, keysymName) self.assertEqual(ci.rkeymap[keysymValue], keysymName)
def getButtonList(self, prefix='button_', container=None): result = [] buttons = self.barButtons or \ reflect.prefixedMethodNames(self.__class__, prefix) for b in buttons: bName = string.replace(b, '_', ' ') result.append(cbutton(bName, getattr(self,prefix+b))) if container: map(container.add, result) return result
def getButtonList(self, prefix='button_', container=None): result = [] buttons = self.barButtons or \ reflect.prefixedMethodNames(self.__class__, prefix) for b in buttons: bName = string.replace(b, '_', ' ') result.append(cbutton(bName, getattr(self, prefix + b))) if container: map(container.add, result) return result
def applyTo(self, item): headers = {} for hdr in item.impl.getAllHeaders(): headers.setdefault(hdr.name, []).append(hdr.value) matchers = reflect.prefixedMethodNames(self.__class__, 'match_') for m in matchers: tag = getattr(self, 'match_' + m)(headers) if tag is not None: self.matchedMessages += 1 assert type(tag) is unicode, "%r was not unicode, came from %r" % (tag, m) return True, True, {"mailingListName": tag} return False, True, None
def _computeAllowedMethods(resource): """ Compute the allowed methods on a C{Resource} based on defined render_FOO methods. Used when raising C{UnsupportedMethod} but C{Resource} does not define C{allowedMethods} attribute. """ allowedMethods = [] for name in prefixedMethodNames(resource.__class__, "render_"): # Potentially there should be an API for encode('ascii') in this # situation - an API for taking a Python native string (bytes on Python # 2, text on Python 3) and returning a socket-compatible string type. allowedMethods.append(name.encode('ascii')) return allowedMethods
def _computeAllowedMethods(resource): """ Compute the allowed methods on a C{Resource} based on defined render_FOO methods. Used when raising C{UnsupportedMethod} but C{Resource} does not define C{allowedMethods} attribute. """ allowedMethods = [] for name in prefixedMethodNames(resource.__class__, "render_"): # Potentially there should be an API for encode('ascii') in this # situation - an API for taking a Python native string (bytes on Python # 2, text on Python 3) and returning a socket-compatible string type. allowedMethods.append(name.encode("ascii")) return allowedMethods
def do_EHLO(self, rest): extensions = reflect.prefixedMethodNames(self.__class__, 'ext_') peer = self.transport.getPeer()[1] self.__helo = (rest, peer) self.__from = None self.__to = [] self.sendCode( 250, '%s\n%s Hello %s, nice to meet you' % ( '\n'.join([ '%s %s' % (e, ' '.join(self.extArgs.get(e, []))) for e in extensions ]), self.host, peer ) )
def _get_test_methods(self, item): """ Look for test_ methods in subclasses of NetTestCase """ test_cases = [] try: assert issubclass(item, NetTestCase) methods = reflect.prefixedMethodNames(item, self.method_prefix) test_methods = [] for method in methods: test_methods.append(self.method_prefix + method) if test_methods: test_cases.append((item, test_methods)) except (TypeError, AssertionError): pass return test_cases
def loadTestsAndOptions(classes, cmd_line_options): """ Takes a list of test classes and returns their testcases and options. """ method_prefix = 'test' options = None test_cases = [] for klass in classes: tests = reflect.prefixedMethodNames(klass, method_prefix) if tests: test_cases = makeTestCases(klass, tests, method_prefix) test_klass = klass() options = test_klass._processOptions(cmd_line_options) return test_cases, options
def _allowed_methods(self): """ Compute allowable http methods to return in an Allowed-Methods header. This is to adhere to the HTTP standard. """ allowed_methods = ['HEAD'] # we always allow head fq_name = self.__module__ + '.' + self.__class__.__name__ name = '?' try: resource = self for n in prefixedMethodNames(resource.__class__, REST_METHOD_PREFIX): name = n allowed_methods.append(n.encode('ascii')) except UnicodeEncodeError: log.err('Resource (%s) method (%s) contains non-ascii characters' % (fq_name, name)) except Exception as e: log.err('Resource (%s) error resolving method names (%s)' % (fq_name, e)) return allowed_methods
def decorator(test_case): test_method_names = [ test_prefix + name for name in prefixedMethodNames(test_case, test_prefix) ] for test_method_name in test_method_names: if test_method_name not in supported_tests: test_method = getattr(test_case, test_method_name) new_message = [] existing_message = getattr(test_method, skip_or_todo, None) if existing_message is not None: new_message.append(existing_message) new_message.append('Not implemented yet') new_message = ' '.join(new_message) @wraps(test_method) def wrapper(*args, **kwargs): return test_method(*args, **kwargs) setattr(wrapper, skip_or_todo, new_message) setattr(test_case, test_method_name, wrapper) return test_case
def prefixedMethodClassDict(clazz, prefix): return { name: getattr(clazz, prefix + name) for name in prefixedMethodNames(clazz, prefix) }
def test_method(self): """ L{prefixedMethodNames} returns a list including methods with the given prefix defined on the class passed to it. """ self.assertEqual(["method"], prefixedMethodNames(Separate, "good_"))
def getTestCaseNames(self, klass): return reflect.prefixedMethodNames(klass, self.methodPrefix)
def getTestCaseNames(self, klass): """ Given a class that contains C{TestCase}s, return a list of names of methods that probably contain tests. """ return reflect.prefixedMethodNames(klass, self.methodPrefix)
def prefixedMethodClassDict(clazz, prefix): return dict([(name, getattr(clazz, prefix + name)) for name in prefixedMethodNames(clazz, prefix)])
def prefixedMethodObjDict(obj, prefix): return { name: getattr(obj, prefix + name) for name in prefixedMethodNames(obj.__class__, prefix) }
def _listFunctions(self): """Return a list of the names of all ebrpc methods.""" return reflect.prefixedMethodNames(self.__class__, 'ebrpc_')
def _listFunctions(self): return reflect.prefixedMethodNames(self.__class__, 'xmlrpc_')
def _listFunctions(self): """ Return a list of the names of all jsonrpc methods. """ return reflect.prefixedMethodNames(self.__class__, 'jsonrpc_')
def listFunctions(self): """ Return a list of the names of all jsonrpc methods. """ return reflect.prefixedMethodNames(self.__class__, self.prefix)
def prefixedMethodObjDict(obj, prefix): return dict([(name, getattr(obj, prefix + name)) for name in prefixedMethodNames(obj.__class__, prefix)])
def listProcedures(self): a = set(self._methods) b = set(reflect.prefixedMethodNames(self.__class__, 'dumbrpc_')) return sorted(a | b)
def connectionMade(self): self.resultHarvester = ResultHarvester() for fn in reflect.prefixedMethodNames(self.__class__, 'decode_'): setattr(self, 'handle_' + fn, self.resultHarvester)