author B2G Bumper Bot <>
Tue, 23 Feb 2016 00:46:33 -0800
changeset 325577 495ccf9c91cd59d7d0b5844b1ad9c529b1323357
parent 320757 17132c8ff5f4b67b319478899a8e0763448337e1
child 336647 2148df37953cb6dddf9f9a0ac95a38734b49e415
permissions -rw-r--r--
Bumping manifests a=b2g-bump

# 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

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.


import unittest
import mozunit

if __name__ == '__main__':

class _MozTestResult(_TestResult):
    def __init__(self, stream, descriptions):
        _TestResult.__init__(self) = stream
        self.descriptions = descriptions

    def getDescription(self, test):
        if self.descriptions:
            return test.shortDescription() or str(test)
            return str(test)

    def printStatus(self, status, test, message=''):
        line = "{status} | {file} | {klass}.{test}{sep}{message}".format(
            sep=', ' if message else '',

    def addSuccess(self, test):
        _TestResult.addSuccess(self, test)
        self.printStatus('TEST-PASS', test)

    def addSkip(self, test, reason):
        _TestResult.addSkip(self, test, reason)
        self.printStatus('TEST-SKIP', test)

    def addExpectedFailure(self, test, err):
        _TestResult.addExpectedFailure(self, test, err)
        self.printStatus('TEST-KNOWN-FAIL', test)

    def addUnexpectedSuccess(self, test):
        _TestResult.addUnexpectedSuccess(self, test)
        self.printStatus('TEST-UNEXPECTED-PASS', test)

    def addError(self, test, err):
        _TestResult.addError(self, test, err)
        self.printFail(test, err)"ERROR: {0}".format(self.getDescription(test)))[-1][1])

    def addFailure(self, test, err):
        _TestResult.addFailure(self, test, err)
        self.printFail(test,err)"FAIL: {0}".format(self.getDescription(test)))[-1][1])

    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:
        _f, _ln, _t = inspect.getframeinfo(tb)[:3]
        self.printStatus('TEST-UNEXPECTED-FAIL', test,
                         'line {0}: {1}'.format(_ln, value.message))

class MozTestRunner(_TestRunner):
    def _makeResult(self):
        return _MozTestResult(, self.descriptions)
    def run(self, test):
        result = self._makeResult()
        return result

class MockedFile(StringIO):
    def __init__(self, context, filename, content = ''):
        self.context = context = filename
        StringIO.__init__(self, content)

    def close(self):
        self.context.files[] = self.getvalue()

    def __enter__(self):
        return self

    def __exit__(self, type, value, traceback):

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')
    self.assertRaises(Exception,'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,, 'r').read())
            file =, mode)
        if 'a' in mode:
  , os.SEEK_END)
        return file

    def __enter__(self):
        import __builtin__ =
        self._orig_path_exists = os.path.exists = self
        os.path.exists = self._wrapped_exists

    def __exit__(self, type, value, traceback):
        import __builtin__ =
        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):