#!/usr/bin/env python # # Copyright 2007 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # """Tests for google.appengine.tools.devappserver2.python.sandbox.""" import __builtin__ import imp import os import re import sys import types import urllib import unittest import google try: import lxml except ImportError: raise unittest.SkipTest('sandbox_test could not import lxml') try: import PIL except ImportError: raise unittest.SkipTest('sandbox_test could not import PIL') import mox from google.appengine.tools.devappserver2 import runtime_config_pb2 from google.appengine.tools.devappserver2.python import sandbox from google.appengine.tools.devappserver2.python import stubs class SandboxTest(unittest.TestCase): def setUp(self): super(SandboxTest, self).setUp() self.mox = mox.Mox() self.old_path = sys.path self.old_meta_path = sys.meta_path self.old_library_format_string = sandbox._THIRD_PARTY_LIBRARY_FORMAT_STRING self.config = runtime_config_pb2.Config() self.app_root = 'test/app/root' self.config.application_root = self.app_root self.config.app_id = 'app' self.config.version_id = '1' self.builtins = __builtin__.__dict__.copy() self.modules = sys.modules.copy() def tearDown(self): sys.modules.clear() sys.modules.update(self.modules) __builtin__.__dict__.update(self.builtins) sys.meta_path = self.old_meta_path sys.path = self.old_path sandbox._THIRD_PARTY_LIBRARY_FORMAT_STRING = self.old_library_format_string self.mox.UnsetStubs() super(SandboxTest, self).tearDown() def test_enable_libraries(self): sandbox._THIRD_PARTY_LIBRARY_FORMAT_STRING = ( 'name=%(name)s-version=%(version)s') libs = self.config.libraries libs.add(name='foo', version='12345') libs.add(name='webapp2', version='2.5.1') self.assertEqual( [os.path.join(os.path.dirname(os.path.dirname( google.__file__)), 'name=foo-version=12345'), os.path.join(os.path.dirname(os.path.dirname( google.__file__)), 'name=webapp2-version=2.5.1')], sandbox._enable_libraries(libs)) def test_enable_libraries_no_libraries(self): libs = self.config.libraries self.assertEqual([], sandbox._enable_libraries(libs)) self.assertEqual(self.old_path, sys.path) class ModuleOverrideImportHookTest(unittest.TestCase): def setUp(self): super(ModuleOverrideImportHookTest, self).setUp() self.test_policies = {} self.path = sys.path[:] self.hook = sandbox.ModuleOverrideImportHook(self.test_policies) sys.path_importer_cache = {} sys.modules.pop('distutils', None) __import__('distutils').__path__.insert(0, 'dummy/path') sys.modules.pop('distutils.util', None) sys.modules.pop('thread', None) self.imported_modules = set(sys.modules) self.path_hooks = sys.path_hooks def tearDown(self): sys.path_hooks = self.path_hooks sys.path_importer_cache = {} sys.path = self.path added_modules = set(sys.modules) - self.imported_modules for name in added_modules: del sys.modules[name] distutils_modules = [module for module in sys.modules if module.startswith('distutils')] for name in distutils_modules: del sys.modules[name] sys.modules.pop('thread', None) super(ModuleOverrideImportHookTest, self).tearDown() def test_load_builtin_pass_through(self): symbols = dir(__import__('thread')) del sys.modules['thread'] self.test_policies['thread'] = sandbox.ModuleOverridePolicy( None, [], {}, default_pass_through=True) thread = self.hook.load_module('thread') self.assertTrue(isinstance(thread, types.ModuleType)) self.assertTrue(isinstance(thread.__doc__, str)) self.assertItemsEqual(symbols + ['__loader__'], dir(thread)) self.assertEqual(self.hook, thread.__loader__) def test_load_builtin_no_pass_through(self): self.test_policies['thread'] = sandbox.ModuleOverridePolicy( None, [], {}, default_pass_through=False) thread = self.hook.load_module('thread') self.assertTrue(isinstance(thread, types.ModuleType)) self.assertItemsEqual( ['__doc__', '__name__', '__package__', '__loader__'], dir(thread)) self.assertEqual(self.hook, thread.__loader__) def test_load_with_path_hook(self): class DummyPathHook(object): def __init__(self, path): if path != 'dummy/path': raise ImportError def find_module(self, unused_fullname): return self def load_module(self, fullname): return imp.new_module('fake name: %s' % fullname) self.test_policies['distutils.util'] = sandbox.ModuleOverridePolicy( None, [], {}, default_pass_through=True) sys.path_hooks = [DummyPathHook] util = self.hook.load_module('distutils.util') self.assertEqual('fake name: distutils.util', util.__name__) def test_load_with_path_hook_cant_find(self): class DummyPathHook(object): def __init__(self, path): if path != 'dummy/path': raise ImportError def find_module(self, unused_fullname): return None def load_module(self, fullname): raise ImportError self.test_policies['distutils.util'] = sandbox.ModuleOverridePolicy( None, [], {}, default_pass_through=True) sys.path_hooks = [DummyPathHook] util = self.hook.load_module('distutils.util') self.assertEqual('distutils.util', util.__name__) def test_load_without_path_hook(self): self.test_policies['urllib'] = sandbox.ModuleOverridePolicy( None, [], {}, default_pass_through=True) urllib = self.hook.load_module('urllib') self.assertIn('urlopen', urllib.__dict__) self.assertEqual('urllib', urllib.__name__) def test_load_without_path_hook_not_found(self): self.test_policies['urllib'] = sandbox.ModuleOverridePolicy( None, [], {}, default_pass_through=True) self.assertRaises(ImportError, self.hook.load_module, 'fake_module') def test_load_already_in_sys_modules(self): module = imp.new_module('foo') sys.modules['foo'] = module self.assertEqual(module, self.hook.load_module('foo')) def test_is_package(self): self.assertTrue(self.hook.is_package('distutils')) def test_is_package_standard_lib(self): self.assertTrue(self.hook.is_package('email')) def test_is_package_not_package_standard_lib(self): self.assertFalse(self.hook.is_package('urllib')) def test_is_package_not_package(self): self.assertFalse(self.hook.is_package('distutils.util')) def test_is_package_does_not_exist(self): self.assertRaises(ImportError, self.hook.is_package, 'foo.bar') def test_get_source(self): with open(__import__('distutils').__file__.replace('.pyc', '.py')) as f: source = f.read() self.assertEqual(source, self.hook.get_source('distutils')) def test_get_source_does_not_exist(self): self.assertRaises(ImportError, self.hook.get_source, 'foo.bar') def test_get_source_standard_library(self): # The expected value is hard to find if the standard library might or might # not be zipped so just check that a value is found. self.assertTrue(self.hook.get_source('urllib')) def test_get_code(self): filename = __import__('distutils').__file__.replace('.pyc', '.py') with open(filename) as f: expected_code = compile(f.read(), filename, 'exec') self.assertEqual(expected_code, self.hook.get_code('distutils')) def test_get_code_does_not_exist(self): self.assertRaises(ImportError, self.hook.get_code, 'foo.bar') def test_get_code_standard_library(self): # The expected value is hard to find if the standard library might or might # not be zipped so just check that a value is found. self.assertTrue(self.hook.get_code('urllib')) def test_os_module_policy(self): hooked_os = imp.new_module('os') hooked_os.__dict__.update(os.__dict__) sandbox._MODULE_OVERRIDE_POLICIES['os'].apply_policy(hooked_os.__dict__) self.assertEqual(stubs.return_minus_one, hooked_os.getpid) self.assertNotIn('execv', hooked_os.__dict__) self.assertEqual(stubs.os_error_not_implemented, hooked_os.unlink) self.assertEqual(os.walk, hooked_os.walk) class CModuleImportHookTest(unittest.TestCase): def test_find_module_enabled_module(self): hook = sandbox.CModuleImportHook([re.compile(r'lxml\.')]) self.assertIsNone(hook.find_module('lxml')) lxml = __import__('lxml') self.assertIsNone(hook.find_module('lxml.etree', lxml.__path__)) def test_find_module_disabled_module(self): hook = sandbox.CModuleImportHook([re.compile(r'numpy\.')]) self.assertIsNone(hook.find_module('lxml')) lxml = __import__('lxml') self.assertEqual(hook, hook.find_module('lxml.etree', lxml.__path__)) def test_find_module_not_c_module(self): hook = sandbox.CModuleImportHook([]) self.assertIsNone(hook.find_module('httplib')) def test_find_module_whitelisted(self): hook = sandbox.CModuleImportHook([]) for name in sandbox._WHITE_LIST_C_MODULES: self.assertIsNone(hook.find_module(name)) def test_find_module_not_whitelisted(self): hook = sandbox.CModuleImportHook([]) self.assertEqual(hook, hook.find_module('__builtin__')) def test_find_module_not_whitelisted_enabled_via_libaries(self): hook = sandbox.CModuleImportHook([re.compile(r'__builtin__')]) self.assertIsNone(hook.find_module('__builtin__')) def test_load_module(self): hook = sandbox.CModuleImportHook([]) self.assertRaises(ImportError, hook.load_module, 'lxml') class PathOverrideImportHookTest(unittest.TestCase): def setUp(self): self.saved_lxml = lxml self.saved_pil = PIL self.saved_urllib = urllib def tearDown(self): sys.modules['urllib'] = self.saved_urllib sys.modules['PIL'] = self.saved_pil sys.modules['lxml'] = self.saved_lxml def test_package_success(self): hook = sandbox.PathOverrideImportHook(['lxml']) self.assertEqual(hook, hook.find_module('lxml')) del sys.modules['lxml'] hooked_lxml = hook.load_module('lxml') self.assertEqual(hooked_lxml.__file__, lxml.__file__) self.assertEqual(hooked_lxml.__path__, lxml.__path__) self.assertEqual(hooked_lxml.__loader__, hook) self.assertEqual([os.path.dirname(self.saved_lxml.__file__)], hook.extra_accessible_paths) self.assertFalse(hook.extra_sys_paths) def test_package_success_pil_in_sys_path(self): hook = sandbox.PathOverrideImportHook(['PIL']) self.assertEqual(hook, hook.find_module('PIL')) del sys.modules['PIL'] hooked_pil = hook.load_module('PIL') self.assertEqual(hooked_pil.__file__, PIL.__file__) self.assertEqual(hooked_pil.__path__, PIL.__path__) self.assertEqual(hooked_pil.__loader__, hook) self.assertFalse(hook.extra_accessible_paths) self.assertEqual([os.path.dirname(self.saved_pil.__file__)], hook.extra_sys_paths) def test_module_success(self): hook = sandbox.PathOverrideImportHook(['urllib']) self.assertEqual(hook, hook.find_module('urllib')) del sys.modules['urllib'] hooked_urllib = hook.load_module('urllib') self.assertEqual(hooked_urllib.__file__.replace('.pyc', '.py'), urllib.__file__.replace('.pyc', '.py')) self.assertEqual(hooked_urllib.__loader__, hook) self.assertNotIn('__path__', hooked_urllib.__dict__) self.assertFalse(hook.extra_accessible_paths) self.assertFalse(hook.extra_sys_paths) def test_disabled_modules(self): hook = sandbox.PathOverrideImportHook(['lxml']) self.assertFalse(hook.find_module('lxml.foo')) self.assertFalse(hook.find_module('numpy')) self.assertFalse(hook.find_module('os')) def test_module_not_installed(self): hook = sandbox.PathOverrideImportHook(['foo']) self.assertFalse(hook.find_module('foo')) self.assertFalse(hook.extra_accessible_paths) self.assertFalse(hook.extra_sys_paths) def test_import_alread_in_sys_modules(self): hook = sandbox.PathOverrideImportHook(['lxml']) self.assertEqual(os, hook.load_module('os')) class PathRestrictingImportHookTest(unittest.TestCase): def setUp(self): self.mox = mox.Mox() self.mox.StubOutWithMock(imp, 'find_module') self.mox.StubOutWithMock(stubs.FakeFile, 'is_file_accessible') self.hook = sandbox.PathRestrictingImportHook([re.compile(r'lxml(\..*)?$')]) def tearDown(self): self.mox.UnsetStubs() def test_accessible(self): imp.find_module('bar', ['foo']).AndReturn((None, 'foo/bar.py', (None, None, imp.PY_SOURCE))) stubs.FakeFile.is_file_accessible('foo/bar.py').AndReturn(True) self.mox.ReplayAll() self.assertIsNone(self.hook.find_module('foo.bar', ['foo'])) def test_not_accessible(self): imp.find_module('bar', ['foo']).AndReturn((None, 'foo/bar.py', (None, None, imp.PY_SOURCE))) stubs.FakeFile.is_file_accessible('foo/bar.py').AndReturn(False) self.mox.ReplayAll() self.assertEqual(self.hook, self.hook.find_module('foo.bar', ['foo'])) def test_c_module_accessible(self): imp.find_module('bar', ['foo']).AndReturn((None, 'foo/bar.so', (None, None, imp.C_EXTENSION))) stubs.FakeFile.is_file_accessible('foo/bar.so').AndReturn(True) self.mox.ReplayAll() self.assertIsNone(self.hook.find_module('foo.bar', ['foo'])) def test_c_module_not_accessible(self): imp.find_module('bar', ['foo']).AndReturn((None, 'foo/bar.so', (None, None, imp.C_EXTENSION))) stubs.FakeFile.is_file_accessible('foo/bar.so').AndReturn(False) self.mox.ReplayAll() self.assertEqual(self.hook, self.hook.find_module('foo.bar', ['foo'])) def test_compiled_python_accessible(self): imp.find_module('bar', ['foo']).AndReturn((None, 'foo/bar.pyc', (None, None, imp.PY_COMPILED))) stubs.FakeFile.is_file_accessible('foo/bar.pyc').AndReturn(True) self.mox.ReplayAll() self.assertIsNone(self.hook.find_module('foo.bar', ['foo'])) def test_compiled_python_not_accessible(self): imp.find_module('bar', ['foo']).AndReturn((None, 'foo/bar.pyc', (None, None, imp.PY_COMPILED))) stubs.FakeFile.is_file_accessible('foo/bar.pyc').AndReturn(False) self.mox.ReplayAll() self.assertEqual(self.hook, self.hook.find_module('foo.bar', ['foo'])) def test_c_builtin(self): imp.find_module('bar', ['foo']).AndReturn((None, 'bar', (None, None, imp.C_BUILTIN))) self.mox.ReplayAll() self.assertIsNone(self.hook.find_module('foo.bar', ['foo'])) def test_py_frozen(self): imp.find_module('bar', ['foo']).AndReturn((None, 'bar', (None, None, imp.PY_FROZEN))) self.mox.ReplayAll() self.assertIsNone(self.hook.find_module('foo.bar', ['foo'])) def test_enabled_c_library(self): imp.find_module('lxmla', ['foo']).AndReturn((None, 'lxmla.py', (None, None, imp.PY_SOURCE))) stubs.FakeFile.is_file_accessible('lxmla.py').AndReturn(False) self.mox.ReplayAll() self.assertEqual(self.hook, self.hook.find_module('lxmla', ['foo'])) self.assertIsNone(self.hook.find_module('lxml', None)) self.assertIsNone(self.hook.find_module('lxml.html', None)) def test_load_module(self): self.assertRaises(ImportError, self.hook.load_module, 'os') class PyCryptoRandomImportHookTest(unittest.TestCase): def test_find_module(self): self.assertIsInstance( sandbox.PyCryptoRandomImportHook.find_module( 'Crypto.Random.OSRNG.posix'), sandbox.PyCryptoRandomImportHook) self.assertIsNone( sandbox.PyCryptoRandomImportHook.find_module('Crypto.Random.OSRNG.nt')) if __name__ == '__main__': unittest.main()