def _modulename(name): if name not in descriptors and "." in name: # The qualified name maybe refere a property # of the module, so it depends that module. module_name = utils.split_module_name(name)[0] assert module_name return module_name else: return name
def test_package_name(self): d = join(FILES_DIR, 'imports') d = abspath(d) resolver = ModuleNameResolver([d]) for f in utils.collect_files(d): assert f.startswith(d) if not f.endswith('.py'): continue modname, package = resolver.resolve(f) f = f[len(d):] if f[0] == '/': f = f[1:] f = splitext(f)[0] f = f.replace('/', '.') if f.endswith('.__init__'): f = utils.split_module_name(f)[0] self.assertEqual(f, modname) self.assertEqual(f, package) else: self.assertEqual(f, modname) self.assertEqual( utils.split_module_name(f)[0], package)
def has_subclass(module_descriptor, baseclass): """ Return ``True`` if the module has a class derived from *baseclass* """ # We can't use ``unittest.TestLoader`` to loading tests, # bacause ``TestLoader`` imports (execute) module code. # If imported/executed module have a statement such as # ``sys.exit()``, ...program exit! if not isinstance(baseclass, (type, types.ClassType)): raise TypeError( "The baseclass argument must be instance of type or class, " "but was instance of %s" % type(baseclass)) modcode = module_descriptor.module_code assert modcode # How to check unittest.TestCase # ============================================ # 1. For all class definition in module code # 2. Check class is derived from base class(s) # 3. Check base class(s) is imported from another module # 4. Load base class(s) from that module # Notes: Assume the module contains base class does not have # a dangerous code such as ``sys.exit``. # 5. Check loaded class is *baseclass* or its subclass # Construct imported symbols. # This is used in phase 3. symbols = dict([(imp[0], imp) for imp in modcode.context['imports']]) # 1. For all class definition in module code for klass in modcode.context['classdefs']: # 2. Check class is derived from base class(s) bases = klass[1] if not bases: continue # 3. Check base class(s) is imported from another module for base in bases: # Search imported symbol that is class name or module name if '.' in base: names = list(split_module_name(base)) else: names = [base] import_ = symbols.get(names[0]) if import_ is None: # Not an imported base class continue # Convert a name to a qualified module name # # 1. Resolve import alias if exists # 2. Qualify name as full module name # 3. Resolve relative module name # level = import_[2] names[0] = import_[1] fqn = '.'.join(names) fqn = resolve_relative_modulename(fqn, modcode.package_name, level) assert '.' in fqn, "fqn must be a qualified module fqn" LOGGER.debug("'%s' is derived from '%s'" % (module_descriptor.name, fqn)) try: try: klass = utils.import_component(fqn) except ImportError: if level == -1 and modcode.package_name: # The qualified name may be relative to current package. fqn = '.'.join((modcode.package_name, fqn)) klass = utils.import_component(fqn) else: raise except (ImportError, AttributeError): LOGGER.warn("Exception occurred " "while importing component '%s'" % fqn, exc_info=True) else: # 5. Check loaded class is specified class or its subclass if isinstance(klass, (type, types.ClassType)) and \ issubclass(klass, baseclass): return True return False
def has_subclass(module_descriptor, baseclass): """ Return ``True`` if the module has a class derived from *baseclass* """ # We can't use ``unittest.TestLoader`` to loading tests, # bacause ``TestLoader`` imports (execute) module code. # If imported/executed module have a statement such as # ``sys.exit()``, ...program exit! if not isinstance(baseclass, (type, types.ClassType)): raise TypeError( "The baseclass argument must be instance of type or class, " "but was instance of %s" % type(baseclass)) modcode = module_descriptor.module_code assert modcode # How to check unittest.TestCase # ============================================ # 1. For all class definition in module code # 2. Check class is derived from base class(s) # 3. Check base class(s) is imported from another module # 4. Load base class(s) from that module # Notes: Assume the module contains base class does not have # a dangerous code such as ``sys.exit``. # 5. Check loaded class is *baseclass* or its subclass # Construct imported symbols. # This is used in phase 3. symbols = dict([(imp[0], imp) for imp in modcode.context['imports']]) # 1. For all class definition in module code for klass in modcode.context['classdefs']: # 2. Check class is derived from base class(s) bases = klass[1] if not bases: continue # 3. Check base class(s) is imported from another module for base in bases: # Search imported symbol that is class name or module name symbol = base if '.' in symbol: symbol = split_module_name(symbol)[0] import_ = symbols.get(symbol) if import_ is None: continue # Convert name to a qualified module name name, level = base, import_[2] parent = split_module_name(import_[1])[0] if parent: name = '.'.join((parent, name)) name = resolve_relative_modulename( name, modcode.package_name, level) assert '.' in name, "name must be a qualified module name" LOGGER.debug("'%s' is derived from '%s'" % (base, name)) try: klass = utils.import_component(name) except ImportError: klass = None exc = sys.exc_info()[:] if level == -1 and modcode.package_name: # Try to resolve a name as relative module name. try: name2 = '.'.join((modcode.package_name, name)) klass = utils.import_component(name2) except: LOGGER.warn( "Exception occurred while importing module '%s'" % name2, exc_info=True) if not klass: LOGGER.warn( "Exception occurred while importing module '%s'" % name, exc_info=exc) # Make sure to delete the traceback to avoid creating cycles. del exc except AttributeError: LOGGER.warn( "Exception occurred while importing module '%s'" % name, exc_info=True) else: # 5. Check loaded class is specified class or its subclass if isinstance(klass, (type, types.ClassType)) and \ issubclass(klass, baseclass): return True return False