def load_bytecode_processors(): """ Loading BytecodeProcessor from modipyd.BYTECODE_PROCESSORS settings. Return ChainedBytecodeProcessor instance holds all loaded processors. """ if (BYTECODE_PROCESSORS and (len(BYTECODE_PROCESSORS_CACHE) != len(BYTECODE_PROCESSORS))): del BYTECODE_PROCESSORS_CACHE[:] for i, name in enumerate(BYTECODE_PROCESSORS[:]): LOGGER.info("Loading BytecodeProcesser '%s'" % name) try: klass = utils.import_component(name) except (ImportError, AttributeError): LOGGER.warn( "Loading BytecodeProcesser '%s' failed. " "This setting is removed" % name, exc_info=True) del BYTECODE_PROCESSORS[i] else: BYTECODE_PROCESSORS_CACHE.append(klass) processors = [] for klass in BYTECODE_PROCESSORS_CACHE: processors.append(klass()) return bc.ChainedBytecodeProcessor(processors)
def collect_unittest(paths): suite = unittest.TestSuite() loader = unittest.defaultTestLoader resolver = resolve.ModuleNameResolver() paths = utils.sequence(paths) for filepath in paths: try: name, package = resolver.resolve(filepath) except ImportError: # .py file not in the search path name = filepath_to_identifier(filepath) package = None try: if package: module = utils.import_module(name) else: module = imp.load_source(name, filepath) except ImportError: LOGGER.warn("ImportError occurred while loading module", exc_info=True) else: tests = loader.loadTestsFromModule(module) if tests.countTestCases(): suite.addTest(tests) LOGGER.info("Found %d test(s) in module '%s'" % (tests.countTestCases(), module.__name__)) else: LOGGER.warn("No tests found in module '%s'" % module.__name__) return suite
def reload(self, descriptors, co=None): """ Reload module code, update dependency graph """ LOGGER.info("Reload module descriptor '%s' at %s" % (self.name, relativepath(self.filename))) try: self.module_code.reload(co) except SyntaxError: # SyntaxError is OK LOGGER.warn("SyntaxError found in %s" % self.filename, exc_info=True) else: self.update_dependencies(descriptors)
def invoke_plugins(self, event, monitor): context = dict(self.variables) for plugin in self.plugins: try: ret = plugin(event, monitor, context) # the plugin object can return (but not required) # a callable object. It is called with no arguments if callable(ret): ret() except StandardError: LOGGER.warn( "Exception occurred while invoking plugin", exc_info=True)
def read_module_code(filename, typebits=None, search_path=None, resolver=None, allow_compilation_failure=False, allow_standalone=False): """ Read python module file, and return ``ModuleCode`` instance. If *typebits* argument is not ``None``, *filename* must be filepath without file extention. If *typebits* argument is ``None``, it is detected by filename. """ if typebits is None: filename, _, typebits = module_file_typebits(filename) if resolver is None: resolver = ModuleNameResolver(search_path) code = None try: # Since editing .py files will not affect .pyc and .pyo files soon, # give priority to .py files. if typebits & PYTHON_SOURCE_MASK: # .py sourcepath = filename + '.py' code = compile_source(sourcepath) elif typebits & (PYTHON_OPTIMIZED_MASK | PYTHON_COMPILED_MASK): # .pyc, .pyo if typebits & PYTHON_OPTIMIZED_MASK: sourcepath = filename + '.pyo' else: sourcepath = filename + '.pyc' code = load_compiled(sourcepath) else: assert False, "illegal typebits: %d" % typebits except (SyntaxError, ImportError): LOGGER.warn( "Exception occurred while loading compiled bytecode", exc_info=True) if not allow_compilation_failure: raise try: module_name, package_name = resolver.resolve(sourcepath) except ImportError: if not allow_standalone: raise module_name = filepath_to_identifier(sourcepath) package_name = None return ModuleCode(module_name, package_name, sourcepath, code)
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