from greentest import walk_modules, BaseTestCase, main
import six
class TestExec(BaseTestCase):
pass
def make_exec_test(path, module):
def test(self):
#sys.stderr.write('%s %s\n' % (module, path))
f = open(path)
src = f.read()
f.close()
six.exec_(src, {})
name = "test_" + module.replace(".", "_")
test.__name__ = name
setattr(TestExec, name, test)
for path, module in walk_modules():
make_exec_test(path, module)
if __name__ == '__main__':
main()
from greentest import walk_modules, BaseTestCase, main
import six
class TestExec(BaseTestCase):
pass
def make_exec_test(path, module):
def test(self):
#sys.stderr.write('%s %s\n' % (module, path))
f = open(path)
src = f.read()
f.close()
six.exec_(src, {})
name = "test_" + module.replace(".", "_")
test.__name__ = name
setattr(TestExec, name, test)
for path, module in walk_modules():
make_exec_test(path, module)
if __name__ == '__main__':
main()
class Test(unittest.TestCase):
def check_all(self):
"Check that __all__ is present and does not contain invalid entries"
if not hasattr(self.module, '__all__'):
assert self.modname in NO_ALL
return
names = {}
six.exec_("from %s import *" % self.modname, names)
names.pop('__builtins__', None)
self.assertEqual(sorted(names), sorted(self.module.__all__))
def check_all_formula(self):
"Check __all__ = __implements__ + __extensions__ + __imported__"
all_calculated = self.__implements__ + self.__imports__ + self.__extensions__
self.assertEqual(sorted(all_calculated), sorted(self.module.__all__))
def check_implements_presence_justified(self):
"Check that __implements__ is present only if the module is modeled after a module from stdlib (like gevent.socket)."
if self.__implements__ is not None and self.stdlib_module is None:
raise AssertionError(
'%r has __implements__ but no stdlib counterpart' %
self.modname)
def set_stdlib_all(self):
assert self.stdlib_module is not None
self.stdlib_has_all = True
self.stdlib_all = getattr(self.stdlib_module, '__all__', None)
if self.stdlib_all is None:
self.stdlib_has_all = False
self.stdlib_all = dir(self.stdlib_module)
self.stdlib_all = [
name for name in self.stdlib_all if not name.startswith('_')
]
self.stdlib_all = [
name for name in self.stdlib_all if not isinstance(
getattr(self.stdlib_module, name), types.ModuleType)
]
def check_implements_subset_of_stdlib_all(self):
"Check that __implements__ + __imports__ is a subset of the corresponding standard module __all__ or dir()"
for name in self.__implements__ + self.__imports__:
if name in self.stdlib_all:
continue
if name in COULD_BE_MISSING.get(self.stdlib_name, ()):
continue
if name in dir(
self.stdlib_module
): # like thread._local which is not in thread.__all__
continue
raise AssertionError(
'%r is not found in %r.__all__ nor in dir(%r)' %
(name, self.stdlib_module, self.stdlib_module))
def check_implements_actually_implements(self):
"""Check that the module actually implements the entries from __implements__"""
for name in self.__implements__:
item = getattr(self.module, name)
try:
stdlib_item = getattr(self.stdlib_module, name)
assert item is not stdlib_item, (name, item, stdlib_item)
except AttributeError:
if name not in COULD_BE_MISSING.get(self.stdlib_name, []):
raise
def check_imports_actually_imports(self):
"""Check that the module actually imports the entries from __imports__"""
for name in self.__imports__:
item = getattr(self.module, name)
stdlib_item = getattr(self.stdlib_module, name)
assert item is stdlib_item, (name, item, stdlib_item)
def check_extensions_actually_extend(self):
"""Check that the module actually defines new entries in __extensions__"""
if self.modname in EXTRA_EXTENSIONS:
return
for name in self.__extensions__:
if hasattr(self.stdlib_module, name):
raise AssertionError(
"'%r' is not an extension, it is found in %r" %
(name, self.stdlib_module))
def check_completeness(self):
"""Check that __all__ (or dir()) of the corresponsing stdlib is a subset of __all__ of this module"""
missed = []
for name in self.stdlib_all:
if name not in getattr(self.module, '__all__', []):
missed.append(name)
# handle stuff like ssl.socket and ssl.socket_error which have no reason to be in gevent.ssl.__all__
if not self.stdlib_has_all:
for name in missed[:]:
if hasattr(self.module, name):
missed.remove(name)
# remove known misses
not_implemented = NOT_IMPLEMENTED.get(self.stdlib_name)
if not_implemented is not None:
result = []
for name in missed[:]:
if name in not_implemented:
print('IncompleteImplWarning: %s.%s' %
(self.modname, name))
else:
result.append(name)
missed = result
if missed:
if self.stdlib_has_all:
msg = '''The following items
in %r.__all__
are missing from %r:
%r''' % (self.stdlib_module, self.module, missed)
else:
msg = '''The following items
in dir(%r)
are missing from %r:
%r''' % (self.stdlib_module, self.module, missed)
raise AssertionError(msg)
def _test(self, modname):
for x in PLATFORM_SPECIFIC_SUFFIXES:
if modname.endswith(x):
return
self.modname = modname
six.exec_("import %s" % modname, {})
self.module = sys.modules[modname]
self.check_all()
self.__implements__ = getattr(self.module, '__implements__', None)
self.__imports__ = getattr(self.module, '__imports__', [])
self.__extensions__ = getattr(self.module, '__extensions__', [])
self.stdlib_name = MAPPING.get(modname)
self.stdlib_module = None
if self.stdlib_name is not None:
try:
self.stdlib_module = __import__(self.stdlib_name)
except ImportError:
pass
self.check_implements_presence_justified()
if self.stdlib_module is None:
return
# use __all__ as __implements__
if self.__implements__ is None:
self.__implements__ = sorted(self.module.__all__)
self.set_stdlib_all()
self.check_implements_subset_of_stdlib_all()
self.check_implements_actually_implements()
self.check_imports_actually_imports()
self.check_extensions_actually_extend()
self.check_completeness()
for path, modname in walk_modules(include_so=True):
modname = modname.replace('gevent.', '').split('.')[0]
exec('''def test_%s(self): self._test("gevent.%s")''' %
(modname, modname))
del path, modname
