"""A decorator ensuring no temporary file left when the function return

if isgeneratorfunction(callable):

def proxy(*args, **kwargs):

old_tmpdir = tempfile.gettempdir()

new_tmpdir = tempfile.mkdtemp(prefix="temp-lgc-")

tempfile.tempdir = new_tmpdir

try:

for x in callable(*args, **kwargs):

yield x

finally:

try:

rmtree(new_tmpdir, ignore_errors=True)

finally:

tempfile.tempdir = old_tmpdir

return proxy

@wraps(callable)

def proxy(*args, **kargs):

old_tmpdir = tempfile.gettempdir()

new_tmpdir = tempfile.mkdtemp(prefix="temp-lgc-")

tempfile.tempdir = new_tmpdir

try:

return callable(*args, **kargs)

finally:

try:

rmtree(new_tmpdir, ignore_errors=True)

finally:

tempfile.tempdir = old_tmpdir

"""A decorator moving the enclosed function inside the tempfile.tempfdir

@wraps(callable)

def proxy(*args, **kargs):

old_cwd = os.getcwd()

os.chdir(tempfile.tempdir)

try:

return callable(*args, **kargs)

finally:

os.chdir(old_cwd)

"""A decorator run the enclosed function inside a tmpdir removed after execution

proxy = with_tempdir(in_tempdir(callable))

proxy.__name__ = callable.__name__

prefixes=DEFAULT_PREFIXES, suffix=".py",

excludes=(),

remove_suffix=True):

"""

tests = []

for name in os.listdir(testdir):

if not suffix or name.endswith(suffix):

for prefix in prefixes:

if name.startswith(prefix):

if remove_suffix and name.endswith(suffix):

name = name[:-len(suffix)]

if name not in excludes:

tests.append(name)

tests.sort()

"""starts an interactive shell so that the user can inspect errors

debuggers = result.debuggers

descrs = result.error_descrs + result.fail_descrs

if len(debuggers) == 1:

# don't ask for test name if there's only one failure

debuggers[0].start()

else:

while True:

testindex = 0

print("Choose a test to debug:")

# order debuggers in the same way than errors were printed

print("\n".join(['\t%s : %s' % (i, descr) for i, (_, descr)

in enumerate(descrs)]))

print("Type 'exit' (or ^D) to quit")

print()

try:

todebug = input('Enter a test name: ')

if todebug.strip().lower() == 'exit':

print()

break

else:

try:

testindex = int(todebug)

debugger = debuggers[descrs[testindex][0]]

except (ValueError, IndexError):

print("ERROR: invalid test number %r" % (todebug, ))

else:

debugger.start()

except (EOFError, KeyboardInterrupt):

print()

def __init__(self, stream, descriptions, verbosity,

exitfirst=False, pdbmode=False, cvg=None, colorize=False):

super(SkipAwareTestResult, self).__init__(stream,

descriptions, verbosity)

self.skipped = []

self.debuggers = []

self.fail_descrs = []

self.error_descrs = []

self.exitfirst = exitfirst

self.pdbmode = pdbmode

self.cvg = cvg

self.colorize = colorize

self.pdbclass = Debugger

self.verbose = verbosity > 1

def descrs_for(self, flavour):

return getattr(self, '%s_descrs' % flavour.lower())

def _create_pdb(self, test_descr, flavour):

self.descrs_for(flavour).append( (len(self.debuggers), test_descr) )

if self.pdbmode:

self.debuggers.append(self.pdbclass(sys.exc_info()[2]))

def _iter_valid_frames(self, frames):

"""only consider non-testlib frames when formatting traceback"""

lgc_testlib = osp.abspath(__file__)

std_testlib = osp.abspath(unittest.__file__)

invalid = lambda fi: osp.abspath(fi[1]) in (lgc_testlib, std_testlib)

for frameinfo in dropwhile(invalid, frames):

yield frameinfo

def _exc_info_to_string(self, err, test):

"""Converts a sys.exc_info()-style tuple of values into a string.

exctype, exc, tb = err

output = ['Traceback (most recent call last)']

frames = inspect.getinnerframes(tb)

colorize = self.colorize

frames = enumerate(self._iter_valid_frames(frames))

for index, (frame, filename, lineno, funcname, ctx, ctxindex) in frames:

filename = osp.abspath(filename)

if ctx is None: # pyc files or C extensions for instance

source = '<no source available>'

else:

source = ''.join(ctx)

if colorize:

filename = textutils.colorize_ansi(filename, 'magenta')

source = colorize_source(source)

output.append(' File "%s", line %s, in %s' % (filename, lineno, funcname))

output.append(' %s' % source.strip())

if self.verbose:

output.append('%r == %r' % (dir(frame), test.__module__))

output.append('')

output.append(' ' + ' local variables '.center(66, '-'))

for varname, value in sorted(frame.f_locals.items()):

output.append(' %s: %r' % (varname, value))

if varname == 'self': # special handy processing for self

for varname, value in sorted(vars(value).items()):

output.append(' self.%s: %r' % (varname, value))

output.append(' ' + '-' * 66)

output.append('')

output.append(''.join(traceback.format_exception_only(exctype, exc)))

return '\n'.join(output)

def addError(self, test, err):

"""err -> (exc_type, exc, tcbk)"""

exc_type, exc, _ = err

if isinstance(exc, SkipTest):

assert exc_type == SkipTest

self.addSkip(test, exc)

else:

if self.exitfirst:

self.shouldStop = True

descr = self.getDescription(test)

super(SkipAwareTestResult, self).addError(test, err)

self._create_pdb(descr, 'error')

def addFailure(self, test, err):

if self.exitfirst:

self.shouldStop = True

descr = self.getDescription(test)

super(SkipAwareTestResult, self).addFailure(test, err)

self._create_pdb(descr, 'fail')

def addSkip(self, test, reason):

self.skipped.append((test, reason))

if self.showAll:

self.stream.writeln("SKIPPED")

elif self.dots:

self.stream.write('S')

def printErrors(self):

super(SkipAwareTestResult, self).printErrors()

self.printSkippedList()

def printSkippedList(self):

# format (test, err) compatible with unittest2

for test, err in self.skipped:

descr = self.getDescription(test)

self.stream.writeln(self.separator1)

self.stream.writeln("%s: %s" % ('SKIPPED', descr))

self.stream.writeln("\t%s" % err)

def printErrorList(self, flavour, errors):

for (_, descr), (test, err) in zip(self.descrs_for(flavour), errors):

self.stream.writeln(self.separator1)

self.stream.writeln("%s: %s" % (flavour, descr))

self.stream.writeln(self.separator2)

self.stream.writeln(err)

self.stream.writeln('no stdout'.center(len(self.separator2)))

"Used by the TestSuite to hold previous class when running in debug."

_previousTestClass = None

_moduleSetUpFailed = False

args = []

varargs = ()

kwargs = {}

flags = 0 # 2 <=> starargs, 4 <=> kwargs

for param in params:

if isinstance(param, starargs):

varargs = param

if flags:

raise TypeError('found starargs after keywords !')

flags |= 2

args += list(varargs)

elif isinstance(param, keywords):

kwargs = param

if flags & 4:

raise TypeError('got multiple keywords parameters')

flags |= 4

elif flags & 2 or flags & 4:

raise TypeError('found parameters after kwargs or args')

else:

args.append(param)

def __new__(cls, name, *data):

instance = tuple.__new__(cls, data)

instance.name = name

"""A set of tag able validate an expression"""

def __init__(self, *tags, **kwargs):

self.inherit = kwargs.pop('inherit', True)

if kwargs:

raise TypeError("%s are an invalid keyword argument for this function" % kwargs.keys())

if len(tags) == 1 and not isinstance(tags[0], string_types):

tags = tags[0]

super(Tags, self).__init__(tags, **kwargs)

def __getitem__(self, key):

return key in self

def match(self, exp):

return eval(exp, {}, self)

def __or__(self, other):

def deprecated_func(*args, **kwargs):

warnings.warn(

('Please use %s instead.' % original_func.__name__),

DeprecationWarning, 2)

return original_func(*args, **kwargs)

"""A unittest.TestCase extension with some additional methods."""

maxDiff = None

pdbclass = Debugger

tags = Tags()

def __init__(self, methodName='runTest'):

super(TestCase, self).__init__(methodName)

self.__exc_info = sys.exc_info

self.__testMethodName = self._testMethodName

self._current_test_descr = None

self._options_ = None

@classproperty

@cached

def datadir(cls): # pylint: disable=E0213

"""helper attribute holding the standard test's data directory

mod = sys.modules[cls.__module__]

return osp.join(osp.dirname(osp.abspath(mod.__file__)), 'data')

# cache it (use a class method to cache on class since TestCase is

# instantiated for each test run)

@classmethod

def datapath(cls, *fname):

"""joins the object's datadir and `fname`"""

return osp.join(cls.datadir, *fname)

def set_description(self, descr):

"""sets the current test's description.

self._current_test_descr = descr

# override default's unittest.py feature

def shortDescription(self):

"""override default unittest shortDescription to handle correctly

if self._current_test_descr is not None:

return self._current_test_descr

return super(TestCase, self).shortDescription()

def quiet_run(self, result, func, *args, **kwargs):

try:

func(*args, **kwargs)

except (KeyboardInterrupt, SystemExit):

raise

except unittest.SkipTest as e:

if hasattr(result, 'addSkip'):

result.addSkip(self, str(e))

else:

warnings.warn("TestResult has no addSkip method, skips not reported",

RuntimeWarning, 2)

result.addSuccess(self)

return False

except:

result.addError(self, self.__exc_info())

return False

return True

def _get_test_method(self):

"""return the test method"""

return getattr(self, self._testMethodName)

def optval(self, option, default=None):

"""return the option value or default if the option is not define"""

return getattr(self._options_, option, default)

def __call__(self, result=None, runcondition=None, options=None):

"""rewrite TestCase.__call__ to support generative tests

from logilab.common.pytest import FILE_RESTART

if result is None:

result = self.defaultTestResult()

result.pdbclass = self.pdbclass

self._options_ = options

# if result.cvg:

# result.cvg.start()

testMethod = self._get_test_method()

if (getattr(self.__class__, "__unittest_skip__", False) or

getattr(testMethod, "__unittest_skip__", False)):

# If the class or method was skipped.

try:

skip_why = (getattr(self.__class__, '__unittest_skip_why__', '')

or getattr(testMethod, '__unittest_skip_why__', ''))

self._addSkip(result, skip_why)

finally:

result.stopTest(self)

return

if runcondition and not runcondition(testMethod):

return # test is skipped

result.startTest(self)

try:

if not self.quiet_run(result, self.setUp):

return

generative = isgeneratorfunction(testMethod)

# generative tests

if generative:

self._proceed_generative(result, testMethod,

runcondition)

else:

status = self._proceed(result, testMethod)

success = (status == 0)

if not self.quiet_run(result, self.tearDown):

return

if not generative and success:

if hasattr(options, "exitfirst") and options.exitfirst:

# add this test to restart file

try:

restartfile = open(FILE_RESTART, 'a')

try:

descr = '.'.join((self.__class__.__module__,

self.__class__.__name__,

self._testMethodName))

restartfile.write(descr+os.linesep)

finally:

restartfile.close()

except Exception:

print("Error while saving succeeded test into",

osp.join(os.getcwd(), FILE_RESTART),

file=sys.__stderr__)

raise

result.addSuccess(self)

finally:

# if result.cvg:

# result.cvg.stop()

result.stopTest(self)

def _proceed_generative(self, result, testfunc, runcondition=None):

# cancel startTest()'s increment

result.testsRun -= 1

success = True

try:

for params in testfunc():

if runcondition and not runcondition(testfunc,

skipgenerator=False):

if not (isinstance(params, InnerTest)

and runcondition(params)):

continue

if not isinstance(params, (tuple, list)):

params = (params, )

func = params[0]

args, kwargs = parse_generative_args(params[1:])

# increment test counter manually

result.testsRun += 1

status = self._proceed(result, func, args, kwargs)

if status == 0:

result.addSuccess(self)

success = True

else:

success = False

# XXX Don't stop anymore if an error occured

#if status == 2:

# result.shouldStop = True

if result.shouldStop: # either on error or on exitfirst + error

break

except:

# if an error occurs between two yield

result.addError(self, self.__exc_info())

success = False

return success

def _proceed(self, result, testfunc, args=(), kwargs=None):

"""proceed the actual test

kwargs = kwargs or {}

try:

testfunc(*args, **kwargs)

except self.failureException:

result.addFailure(self, self.__exc_info())

return 1

except KeyboardInterrupt:

raise

except InnerTestSkipped as e:

result.addSkip(self, e)

return 1

except SkipTest as e:

result.addSkip(self, e)

return 0

except:

result.addError(self, self.__exc_info())

return 2

return 0

def defaultTestResult(self):

"""return a new instance of the defaultTestResult"""

return SkipAwareTestResult()

skip = _deprecate(unittest.TestCase.skipTest)

assertEquals = _deprecate(unittest.TestCase.assertEqual)

assertNotEquals = _deprecate(unittest.TestCase.assertNotEqual)

assertAlmostEquals = _deprecate(unittest.TestCase.assertAlmostEqual)

assertNotAlmostEquals = _deprecate(unittest.TestCase.assertNotAlmostEqual)

def innerSkip(self, msg=None):

"""mark a generative test as skipped for the <msg> reason"""

msg = msg or 'test was skipped'

raise InnerTestSkipped(msg)

@deprecated('Please use assertDictEqual instead.')

def assertDictEquals(self, dict1, dict2, msg=None, context=None):

"""compares two dicts

dict1 = dict(dict1)

msgs = []

for key, value in dict2.items():

try:

if dict1[key] != value:

msgs.append('%r != %r for key %r' % (dict1[key], value,

key))

del dict1[key]

except KeyError:

msgs.append('missing %r key' % key)

if dict1:

msgs.append('dict2 is lacking %r' % dict1)

if msg:

self.failureException(msg)

elif msgs:

if context is not None:

base = '%s\n' % context

else:

base = ''

self.fail(base + '\n'.join(msgs))

@deprecated('Please use assertCountEqual instead.')

def assertUnorderedIterableEquals(self, got, expected, msg=None):

"""compares two iterable and shows difference between both

got, expected = list(got), list(expected)

self.assertSetEqual(set(got), set(expected), msg)

if len(got) != len(expected):

if msg is None:

msg = ['Iterable have the same elements but not the same number',

'\t<element>\t<expected>i\t<got>']

got_count = {}

expected_count = {}

for element in got:

got_count[element] = got_count.get(element, 0) + 1

for element in expected:

expected_count[element] = expected_count.get(element, 0) + 1

# we know that got_count.key() == expected_count.key()

# because of assertSetEqual

for element, count in got_count.iteritems():

other_count = expected_count[element]

if other_count != count:

msg.append('\t%s\t%s\t%s' % (element, other_count, count))

self.fail(msg)

assertUnorderedIterableEqual = assertUnorderedIterableEquals

assertUnordIterEquals = assertUnordIterEqual = assertUnorderedIterableEqual

@deprecated('Please use assertSetEqual instead.')

def assertSetEquals(self,got,expected, msg=None):

"""compares two sets and shows difference between both

if not(isinstance(got, set) and isinstance(expected, set)):

warnings.warn("the assertSetEquals function if now intended for set only."\

"use assertUnorderedIterableEquals instead.",

DeprecationWarning, 2)

return self.assertUnorderedIterableEquals(got, expected, msg)

items={}

items['missing'] = expected - got

items['unexpected'] = got - expected

if any(items.itervalues()):

if msg is None:

msg = '\n'.join('%s:\n\t%s' % (key, "\n\t".join(str(value) for value in values))

for key, values in items.iteritems() if values)

self.fail(msg)

@deprecated('Please use assertListEqual instead.')

def assertListEquals(self, list_1, list_2, msg=None):

"""compares two lists

_l1 = list_1[:]

for i, value in enumerate(list_2):

try:

if _l1[0] != value:

from pprint import pprint

pprint(list_1)

pprint(list_2)

self.fail('%r != %r for index %d' % (_l1[0], value, i))

del _l1[0]

except IndexError:

if msg is None:

msg = 'list_1 has only %d elements, not %s '\

'(at least %r missing)'% (i, len(list_2), value)

self.fail(msg)

if _l1:

if msg is None:

msg = 'list_2 is lacking %r' % _l1

self.fail(msg)

@deprecated('Non-standard. Please use assertMultiLineEqual instead.')

def assertLinesEquals(self, string1, string2, msg=None, striplines=False):

"""compare two strings and assert that the text lines of the strings

lines1 = string1.splitlines()

lines2 = string2.splitlines()

if striplines:

lines1 = [l.strip() for l in lines1]

lines2 = [l.strip() for l in lines2]

self.assertListEqual(lines1, lines2, msg)

assertLineEqual = assertLinesEquals

@deprecated('Non-standard: please copy test method to your TestCase class')

def assertXMLWellFormed(self, stream, msg=None, context=2):

"""asserts the XML stream is well-formed (no DTD conformance check)

try:

from xml.etree.ElementTree import parse

self._assertETXMLWellFormed(stream, parse, msg)

except ImportError:

from xml.sax import make_parser, SAXParseException

parser = make_parser()

try:

parser.parse(stream)

except SAXParseException as ex:

if msg is None:

stream.seek(0)

for _ in range(ex.getLineNumber()):

line = stream.readline()

pointer = ('' * (ex.getLineNumber() - 1)) + '^'

msg = 'XML stream not well formed: %s\n%s%s' % (ex, line, pointer)

self.fail(msg)

@deprecated('Non-standard: please copy test method to your TestCase class')

def assertXMLStringWellFormed(self, xml_string, msg=None, context=2):

"""asserts the XML string is well-formed (no DTD conformance check)

try:

from xml.etree.ElementTree import fromstring

except ImportError:

from elementtree.ElementTree import fromstring

self._assertETXMLWellFormed(xml_string, fromstring, msg)

def _assertETXMLWellFormed(self, data, parse, msg=None, context=2):

"""internal function used by /assertXML(String)?WellFormed/ functions

from xml.parsers.expat import ExpatError

try:

from xml.etree.ElementTree import ParseError

except ImportError:

# compatibility for <python2.7

ParseError = ExpatError

try:

parse(data)

except (ExpatError, ParseError) as ex:

if msg is None:

if hasattr(data, 'readlines'): #file like object

data.seek(0)

lines = data.readlines()

else:

lines = data.splitlines(True)

nb_lines = len(lines)

context_lines = []

# catch when ParseError doesn't set valid lineno

if ex.lineno is not None:

if context < 0:

start = 1

end = nb_lines

else:

start = max(ex.lineno-context, 1)

end = min(ex.lineno+context, nb_lines)

line_number_length = len('%i' % end)

line_pattern = " %%%ii: %%s" % line_number_length

for line_no in range(start, ex.lineno):

context_lines.append(line_pattern % (line_no, lines[line_no-1]))

context_lines.append(line_pattern % (ex.lineno, lines[ex.lineno-1]))

context_lines.append('%s^\n' % (' ' * (1 + line_number_length + 2 +ex.offset)))

for line_no in range(ex.lineno+1, end+1):

context_lines.append(line_pattern % (line_no, lines[line_no-1]))

rich_context = ''.join(context_lines)

msg = 'XML stream not well formed: %s\n%s' % (ex, rich_context)

self.fail(msg)

@deprecated('Non-standard: please copy test method to your TestCase class')

def assertXMLEqualsTuple(self, element, tup):

"""compare an ElementTree Element to a tuple formatted as follow:

# check tag

self.assertTextEquals(element.tag, tup[0])

# check attrib

if len(element.attrib) or len(tup)>1:

if len(tup)<=1:

self.fail( "tuple %s has no attributes (%s expected)"%(tup,

dict(element.attrib)))

self.assertDictEqual(element.attrib, tup[1])

# check children

if len(element) or len(tup)>2:

if len(tup)<=2:

self.fail( "tuple %s has no children (%i expected)"%(tup,

len(element)))

if len(element) != len(tup[2]):

self.fail( "tuple %s has %i children%s (%i expected)"%(tup,

len(tup[2]),

('', 's')[len(tup[2])>1], len(element)))

for index in range(len(tup[2])):

self.assertXMLEqualsTuple(element[index], tup[2][index])

#check text

if element.text or len(tup)>3:

if len(tup)<=3:

self.fail( "tuple %s has no text value (%r expected)"%(tup,

element.text))

self.assertTextEquals(element.text, tup[3])

#check tail

if element.tail or len(tup)>4:

if len(tup)<=4:

self.fail( "tuple %s has no tail value (%r expected)"%(tup,

element.tail))

self.assertTextEquals(element.tail, tup[4])

def _difftext(self, lines1, lines2, junk=None, msg_prefix='Texts differ'):

junk = junk or (' ', '\t')

# result is a generator

result = difflib.ndiff(lines1, lines2, charjunk=lambda x: x in junk)

read = []

for line in result:

read.append(line)

# lines that don't start with a ' ' are diff ones

if not line.startswith(' '):

self.fail('\n'.join(['%s\n'%msg_prefix]+read + list(result)))

@deprecated('Non-standard. Please use assertMultiLineEqual instead.')

def assertTextEquals(self, text1, text2, junk=None,

msg_prefix='Text differ', striplines=False):

"""compare two multiline strings (using difflib and splitlines())

msg = []

if not isinstance(text1, string_types):

msg.append('text1 is not a string (%s)'%(type(text1)))

if not isinstance(text2, string_types):

msg.append('text2 is not a string (%s)'%(type(text2)))

if msg:

self.fail('\n'.join(msg))

lines1 = text1.strip().splitlines(True)

lines2 = text2.strip().splitlines(True)

if striplines:

lines1 = [line.strip() for line in lines1]

lines2 = [line.strip() for line in lines2]

self._difftext(lines1, lines2, junk, msg_prefix)

assertTextEqual = assertTextEquals

@deprecated('Non-standard: please copy test method to your TestCase class')

def assertStreamEquals(self, stream1, stream2, junk=None,

msg_prefix='Stream differ'):

"""compare two streams (using difflib and readlines())"""

# if stream2 is stream2, readlines() on stream1 will also read lines

# in stream2, so they'll appear different, although they're not

if stream1 is stream2:

return

# make sure we compare from the beginning of the stream

stream1.seek(0)

stream2.seek(0)

# compare

self._difftext(stream1.readlines(), stream2.readlines(), junk,

msg_prefix)

assertStreamEqual = assertStreamEquals

@deprecated('Non-standard: please copy test method to your TestCase class')

def assertFileEquals(self, fname1, fname2, junk=(' ', '\t')):

"""compares two files using difflib"""

self.assertStreamEqual(open(fname1), open(fname2), junk,

msg_prefix='Files differs\n-:%s\n+:%s\n'%(fname1, fname2))

assertFileEqual = assertFileEquals

@deprecated('Non-standard: please copy test method to your TestCase class')

def assertDirEquals(self, path_a, path_b):

"""compares two files using difflib"""

assert osp.exists(path_a), "%s doesn't exists" % path_a

assert osp.exists(path_b), "%s doesn't exists" % path_b

all_a = [ (ipath[len(path_a):].lstrip('/'), idirs, ifiles)

for ipath, idirs, ifiles in os.walk(path_a)]

all_a.sort(key=itemgetter(0))

all_b = [ (ipath[len(path_b):].lstrip('/'), idirs, ifiles)

for ipath, idirs, ifiles in os.walk(path_b)]

all_b.sort(key=itemgetter(0))

iter_a, iter_b = iter(all_a), iter(all_b)

partial_iter = True

ipath_a, idirs_a, ifiles_a = data_a = None, None, None

while True:

try:

ipath_a, idirs_a, ifiles_a = datas_a = next(iter_a)

partial_iter = False

ipath_b, idirs_b, ifiles_b = datas_b = next(iter_b)

partial_iter = True

self.assertTrue(ipath_a == ipath_b,

"unexpected %s in %s while looking %s from %s" %

(ipath_a, path_a, ipath_b, path_b))

errors = {}

sdirs_a = set(idirs_a)

sdirs_b = set(idirs_b)

errors["unexpected directories"] = sdirs_a - sdirs_b

errors["missing directories"] = sdirs_b - sdirs_a

sfiles_a = set(ifiles_a)

sfiles_b = set(ifiles_b)

errors["unexpected files"] = sfiles_a - sfiles_b

errors["missing files"] = sfiles_b - sfiles_a

msgs = [ "%s: %s"% (name, items)

for name, items in errors.items() if items]

if msgs:

msgs.insert(0, "%s and %s differ :" % (

osp.join(path_a, ipath_a),

osp.join(path_b, ipath_b),

))

self.fail("\n".join(msgs))

for files in (ifiles_a, ifiles_b):

files.sort()