mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-08-14 10:29:31 +00:00
153 lines
4.6 KiB
Python
153 lines
4.6 KiB
Python
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
from unittest import TextTestRunner as _TestRunner, TestResult as _TestResult
|
|
import unittest
|
|
import inspect
|
|
from StringIO import StringIO
|
|
import os
|
|
|
|
'''Helper to make python unit tests report the way that the Mozilla
|
|
unit test infrastructure expects tests to report.
|
|
|
|
Usage:
|
|
|
|
import unittest
|
|
import mozunit
|
|
|
|
if __name__ == '__main__':
|
|
mozunit.main()
|
|
'''
|
|
|
|
class _MozTestResult(_TestResult):
|
|
def __init__(self, stream, descriptions):
|
|
_TestResult.__init__(self)
|
|
self.stream = stream
|
|
self.descriptions = descriptions
|
|
|
|
def getDescription(self, test):
|
|
if self.descriptions:
|
|
return test.shortDescription() or str(test)
|
|
else:
|
|
return str(test)
|
|
|
|
def addSuccess(self, test):
|
|
_TestResult.addSuccess(self, test)
|
|
filename = inspect.getfile(test.__class__)
|
|
testname = test._testMethodName
|
|
self.stream.writeln("TEST-PASS | {0} | {1}".format(filename, testname))
|
|
|
|
def addError(self, test, err):
|
|
_TestResult.addError(self, test, err)
|
|
self.printFail(test, err)
|
|
|
|
def addFailure(self, test, err):
|
|
_TestResult.addFailure(self, test, err)
|
|
self.printFail(test,err)
|
|
|
|
def printFail(self, test, err):
|
|
exctype, value, tb = err
|
|
# Skip test runner traceback levels
|
|
while tb and self._is_relevant_tb_level(tb):
|
|
tb = tb.tb_next
|
|
if not tb:
|
|
self.stream.writeln("TEST-UNEXPECTED-FAIL | NO TRACEBACK |")
|
|
_f, _ln, _t = inspect.getframeinfo(tb)[:3]
|
|
self.stream.writeln("TEST-UNEXPECTED-FAIL | {0} | line {1}, {2}: {3}"
|
|
.format(_f, _ln, _t, value.message))
|
|
|
|
def printErrorList(self):
|
|
for test, err in self.errors:
|
|
self.stream.writeln("ERROR: {0}".format(self.getDescription(test)))
|
|
self.stream.writeln("{0}".format(err))
|
|
|
|
|
|
class MozTestRunner(_TestRunner):
|
|
def _makeResult(self):
|
|
return _MozTestResult(self.stream, self.descriptions)
|
|
def run(self, test):
|
|
result = self._makeResult()
|
|
test(result)
|
|
result.printErrorList()
|
|
return result
|
|
|
|
class MockedFile(StringIO):
|
|
def __init__(self, context, filename, content = ''):
|
|
self.context = context
|
|
self.name = filename
|
|
StringIO.__init__(self, content)
|
|
|
|
def close(self):
|
|
self.context.files[self.name] = self.getvalue()
|
|
StringIO.close(self)
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, type, value, traceback):
|
|
self.close()
|
|
|
|
class MockedOpen(object):
|
|
'''
|
|
Context manager diverting the open builtin such that opening files
|
|
can open "virtual" file instances given when creating a MockedOpen.
|
|
|
|
with MockedOpen({'foo': 'foo', 'bar': 'bar'}):
|
|
f = open('foo', 'r')
|
|
|
|
will thus open the virtual file instance for the file 'foo' to f.
|
|
|
|
MockedOpen also masks writes, so that creating or replacing files
|
|
doesn't touch the file system, while subsequently opening the file
|
|
will return the recorded content.
|
|
|
|
with MockedOpen():
|
|
f = open('foo', 'w')
|
|
f.write('foo')
|
|
self.assertRaises(Exception,f.open('foo', 'r'))
|
|
'''
|
|
def __init__(self, files = {}):
|
|
self.files = {}
|
|
for name, content in files.iteritems():
|
|
self.files[os.path.abspath(name)] = content
|
|
|
|
def __call__(self, name, mode = 'r'):
|
|
absname = os.path.abspath(name)
|
|
if 'w' in mode:
|
|
file = MockedFile(self, absname)
|
|
elif absname in self.files:
|
|
file = MockedFile(self, absname, self.files[absname])
|
|
elif 'a' in mode:
|
|
file = MockedFile(self, absname, self.open(name, 'r').read())
|
|
else:
|
|
file = self.open(name, mode)
|
|
if 'a' in mode:
|
|
file.seek(0, os.SEEK_END)
|
|
return file
|
|
|
|
def __enter__(self):
|
|
import __builtin__
|
|
self.open = __builtin__.open
|
|
self._orig_path_exists = os.path.exists
|
|
__builtin__.open = self
|
|
os.path.exists = self._wrapped_exists
|
|
|
|
def __exit__(self, type, value, traceback):
|
|
import __builtin__
|
|
__builtin__.open = self.open
|
|
os.path.exists = self._orig_path_exists
|
|
|
|
def _wrapped_exists(self, p):
|
|
if p in self.files:
|
|
return True
|
|
|
|
abspath = os.path.abspath(p)
|
|
if abspath in self.files:
|
|
return True
|
|
|
|
return self._orig_path_exists(p)
|
|
|
|
def main(*args):
|
|
unittest.main(testRunner=MozTestRunner(),*args)
|