The Tor Browser: config/mozunit.py@97036ab72558 (annotated)

config/mozunit.py@97036ab72558 (annotated)

config/mozunit.py

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 # 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)

The Tor Browser / annotate

config/mozunit.py@97036ab72558 (annotated)

config/mozunit.py