Author: brett.cannon Date: Mon Oct 30 03:21:21 2006 New Revision: 52553 Added: sandbox/trunk/import_in_py/mock_importer.py (contents, props changed) Modified: sandbox/trunk/import_in_py/importer.py sandbox/trunk/import_in_py/test_importer.py Log: Add substantive tests for PyPycHandler.handle_code(). This includes creating a mock object for the class and creating the mock_importer class to contain it. Also moved over other mock objects from test_importer into mock_importer. Modified: sandbox/trunk/import_in_py/importer.py ============================================================================== --- sandbox/trunk/import_in_py/importer.py (original) +++ sandbox/trunk/import_in_py/importer.py Mon Oct 30 03:21:21 2006 @@ -370,13 +370,13 @@ def code_from_source(self, source, path): """Create a code object from source.""" - return compile(source, path, 'exec') + return compile(source, str(path), 'exec') def create_pyc(self, bytecode, timestamp): """Create data for a .pyc file.""" #XXX Does not work properly until direct marshaling of longs is possible. - data = imp.get_magic() - data += str(timestamp) + data = imp.get_magic().zfill(4) + data += str(timestamp).zfill(4) data += marshal.dumps(bytecode) return data @@ -463,7 +463,7 @@ # If there is a possible path to bytecode, generate .pyc file. if bytecode_path: pyc = self.create_pyc(code, source_timestamp) - loader.write_data(pyc, path, True) + loader.write_data(pyc, bytecode_path, True) exec code in module.__dict__ return module Added: sandbox/trunk/import_in_py/mock_importer.py ============================================================================== --- (empty file) +++ sandbox/trunk/import_in_py/mock_importer.py Mon Oct 30 03:21:21 2006 @@ -0,0 +1,193 @@ +import sys +import marshal +import imp +from test import test_support + +def log_call(method): + """Log method calls to self.log.""" + def log_and_call(self, *args, **kwargs): + self.log.append(method.__name__) + return method(self, *args, **kwargs) + return log_and_call + + +class MockPyPycLoader(object): + + """Mock loader object for testing importer.PyPycHandler. + + Opaque path objects are two-item tuple consisting of a string representing + the base path and another string representing the type. + + """ + + def __init__(self, good_magic=True, good_timestamp=True, pyc_exists=True, + py_exists=True): + """Set up the mock loader based on possible scenarios of source and + bytecode combinations/issues.""" + self.module_name = 'test_module' + self.py_ext = "source" if py_exists else None + self.pyc_ext = "bytecode" if pyc_exists else None + self.base_path = "base path" + self.modification_time = 1 + # Needed for read_data on source path. + self.source = "test_attr = None" + code_object = compile(self.source, "<mock loader>", 'exec') + bytecode = marshal.dumps(code_object) + if good_magic: + pyc = str(imp.get_magic()) + else: + pyc += str(imp.get_magic()-1) + if good_timestamp: + pyc += str(1).zfill(4) + else: + pyc += str(0).zfill(4) + # XXX Not proper until can marshal longs. + # Needed for read_data on .pyc path. + self.pyc = pyc + bytecode + self.log = [] + + def _create_handler(self, handler): + if self.py_ext: + py_ext = (self.py_ext,) + else: + py_ext = tuple() + if self.pyc_ext: + pyc_ext = (self.pyc_ext,) + else: + pyc_ext = tuple() + return handler(py_ext, pyc_ext) + + def _handle_py(self, handler): + return handler.handle_code(self, self.module_name, + (self.base_path, self.py_ext)) + + def _handle_pyc(self, handler): + return handler.handle_code(self, self.module_name, + (self.base_path, self.pyc_ext)) + + def _verify_module(self, module): + if not hasattr(module, 'test_attr'): + raise test_support.TestFailed("test_attr attribute missing") + if not module.test_attr is None: + raise test_support.TestFailed("test_attr not set to None") + return True + + def load_module(self, fullname, path=None): + raise NotImplementedError + + @log_call + def split_path(self, path): + """'path' should be a two-item tuple, so just return it since the + caller expects two items back.""" + assert (path[0] == self.base_path and + path[1] in (self.py_ext, self.pyc_ext)) + + return path + + @log_call + def create_path(self, base, type_): + """Create a tuple from 'base' and type_.""" + assert base == self.base_path + assert type_ in (self.py_ext, self.pyc_ext) + + if type_ not in (self.py_ext, self.pyc_ext): + return None + else: + return (base, type_) + + @log_call + def mod_time(self, path): + """Consider self.modification_time the baseline modification time.""" + assert path[0] == self.base_path + assert path[1] == self.py_ext + + return self.modification_time + + @log_call + def read_data(self, path, binary): + """Return the proper source or binary data based on the path.""" + assert path[0] == self.base_path + assert path[1] in (self.py_ext, self.pyc_ext) + + if binary: + assert self.pyc_ext and path[1] == self.pyc_ext + return self.pyc + else: + assert self.py_ext and path[1] == self.py_ext + return self.source + + @log_call + def write_data(self, data, path, binary): + """Should only be requested to write to a bytecode path.""" + assert path[0] == self.base_path + assert self.pyc_ext + assert path[1] == self.pyc_ext, "%s != %s" % (path[1], self.pyc_ext) + assert binary + # XXX Assert proper magic number + # XXX Assert time stamp + module = imp.new_module(self.module_name) + code = marshal.loads(data[8:]) + exec code in module.__dict__ + assert self._verify_module(module) + + return None + + +class ErrorImporter(object): + + """Helper class to have a guaranteed error point.""" + + def find_module(self, fullname, path=None): + self.find_request = fullname, path + raise ImportError + + @classmethod + def set_on_sys_path(cls): + error_entry = '<error>' + sys.path.append(error_entry) + ins = cls() + sys.path_importer_cache[error_entry] = ins + return ins + + +class PassImporter(object): + + """Always pass on importing a module.""" + + def find_module(self, fullname, path=None): + self.find_request = fullname, path + return None + + @classmethod + def set_on_sys_path(cls): + pass_entry = '<pass>' + sys.path.append(pass_entry) + ins = cls() + sys.path_importer_cache[pass_entry] = ins + return ins + + +class SucceedImporter(object): + + """Always succeed by returning 'self'.""" + + module = 42 + + def __call__(self, path_entry): + return self + + def find_module(self, fullname, path=None): + self.find_request = fullname, path + return self + + def load_module(self, fullname, path=None): + self.load_request = fullname, path + return self.module + + @classmethod + def set_on_sys_path(cls): + succeed_entry = '<success>' + sys.path.append(succeed_entry) + ins = cls() + sys.path_importer_cache[succeed_entry] = ins + return ins \ No newline at end of file Modified: sandbox/trunk/import_in_py/test_importer.py ============================================================================== --- sandbox/trunk/import_in_py/test_importer.py (original) +++ sandbox/trunk/import_in_py/test_importer.py Mon Oct 30 03:21:21 2006 @@ -3,6 +3,7 @@ import unittest from test import test_support +import mock_importer import contextlib import imp @@ -351,15 +352,53 @@ # Test creating bytes for creating a .pyc file. # XXX Cannot test until marshaling longs is possible. pass - + class PyPycHandlerHandleCodeTests(unittest.TestCase): """Test PyPycHandler.handle_code().""" - # XXX - pass + def test_good_pyc_w_py(self): + loader = mock_importer.MockPyPycLoader() + handler = loader._create_handler(importer.PyPycHandler) + module = loader._handle_pyc(handler) + loader._verify_module(module) + # Source code should never be read, only bytecode. + self.failUnlessEqual(loader.log.count('read_data'), 1) + # Bytecode should not be written. + self.failUnless("write_data" not in loader.log) + + def test_bad_magic_no_py(self): + # XXX Can't test until can unmarshal magic number from pyc. + pass + + def test_bad_timestamp_no_py(self): + # XXX Can't test until can unmarshal timestamp from pyc. + pass + + def test_bad_magic_w_py(self): + # XXX Can't test until can unmarhsal magic number from pyc. + pass + + def test_bad_magic_w_py(self): + # XXX Can't test until can unmarshal timestamp from pyc. + pass + def test_py_no_pyc(self): + loader = mock_importer.MockPyPycLoader(pyc_exists=False) + handler = loader._create_handler(importer.PyPycHandler) + module = loader._handle_py(handler) + loader._verify_module(module) + self.failUnless('write_data' not in loader.log) + # No attempt should be made to read bytecode. + self.failUnlessEqual(loader.log.count('read_data'), 1) + + def test_py_w_pyc(self): + loader = mock_importer.MockPyPycLoader() + handler = loader._create_handler(importer.PyPycHandler) + module = loader._handle_py(handler) + loader._verify_module(module) + self.failUnless('write_data' in loader.log) class ExtensionHandlerTests(unittest.TestCase): @@ -392,64 +431,6 @@ if not attr.startswith('_'))) -class ErrorImporter(object): - - """Helper class to have a guaranteed error point.""" - - def find_module(self, fullname, path=None): - self.find_request = fullname, path - raise ImportError - - @classmethod - def set_on_sys_path(cls): - error_entry = '<error>' - sys.path.append(error_entry) - ins = cls() - sys.path_importer_cache[error_entry] = ins - return ins - -class PassImporter(object): - - """Always pass on importing a module.""" - - def find_module(self, fullname, path=None): - self.find_request = fullname, path - return None - - @classmethod - def set_on_sys_path(cls): - pass_entry = '<pass>' - sys.path.append(pass_entry) - ins = cls() - sys.path_importer_cache[pass_entry] = ins - return ins - -class SucceedImporter(object): - - """Always succeed by returning 'self'.""" - - module = 42 - - def __call__(self, path_entry): - return self - - def find_module(self, fullname, path=None): - self.find_request = fullname, path - return self - - def load_module(self, fullname, path=None): - self.load_request = fullname, path - return self.module - - @classmethod - def set_on_sys_path(cls): - succeed_entry = '<success>' - sys.path.append(succeed_entry) - ins = cls() - sys.path_importer_cache[succeed_entry] = ins - return ins - - class SimpleImportTests(unittest.TestCase): """Test Importer class with only direct module imports; no packages.""" @@ -477,26 +458,26 @@ def test_default_importer_factory(self): # Make sure that the object passed in during initialization is used # when sys.path_importer_cache has a value of None. - succeed_importer = SucceedImporter() + succeed_importer = mock_importer.SucceedImporter() import_ = importer.Importer(succeed_importer, ()) sys.meta_path = [] sys.path = ['<succeed>'] sys.path_importer_cache['<succeed>'] = None module = import_('sys') self.failUnlessEqual(succeed_importer.find_request, ('sys', None)) - self.failUnless(module is SucceedImporter.module) + self.failUnless(module is mock_importer.SucceedImporter.module) def test_extended_meta_path(self): # Default meta_path entries set during initialization should be # queried after sys.meta_path. - pass_importer = PassImporter() + pass_importer = mock_importer.PassImporter() sys.meta_path = [pass_importer] - succeed_importer = SucceedImporter() + succeed_importer = mock_importer.SucceedImporter() import_ = importer.Importer(extended_meta_path=(succeed_importer,)) module = import_('sys') for meta_importer in (pass_importer, succeed_importer): self.failUnlessEqual(meta_importer.find_request, ('sys', None)) - self.failUnless(module is SucceedImporter.module) + self.failUnless(module is mock_importer.SucceedImporter.module) def test_default_init(self): # The default initialization should work with a None entry for every @@ -533,7 +514,8 @@ self.failUnlessRaises(ImportError, import_.search_meta_path, 'sys') # Verify call order. - meta_path = PassImporter(), SucceedImporter() + meta_path = (mock_importer.PassImporter(), + mock_importer.SucceedImporter()) sys.meta_path = meta_path loader = import_.search_meta_path('sys') for entry in meta_path: @@ -545,18 +527,18 @@ sys.meta_path = [] import_ = importer.Importer(extended_meta_path=()) sys.path = [] - sys_path = (PassImporter.set_on_sys_path(), - SucceedImporter.set_on_sys_path()) + sys_path = (mock_importer.PassImporter.set_on_sys_path(), + mock_importer.SucceedImporter.set_on_sys_path()) module = import_('token') for entry in sys_path: self.failUnlessEqual(entry.find_request, ('token', None)) - self.failUnless(module is SucceedImporter.module) + self.failUnless(module is mock_importer.SucceedImporter.module) def test_importer_cache_preexisting(self): # A pre-existing importer should be returned if it exists in # sys.path_importer_cache. sys.path = [] - succeed_importer = SucceedImporter.set_on_sys_path() + succeed_importer = mock_importer.SucceedImporter.set_on_sys_path() loader = self.import_.search_sys_path('sys') self.failUnless(loader is succeed_importer) @@ -565,7 +547,7 @@ # then sys.path_hooks should be searched and if one is found then cache # it. path_entry = '<succeed>' - succeed_importer = SucceedImporter() + succeed_importer = mock_importer.SucceedImporter() sys.path = [path_entry] sys.path_importer_cache.clear() sys.path_hooks = [succeed_importer]