def generate_schema(pkg_loader, context_manager, class_name, method_names=None, class_version=None, package_name=None): """Generate JSON schema JSON Schema is generated either for the class with all model builders or for specified model builders only. The return value is a dictionary with keys being model builder names and the values are JSON schemas for them. The class itself is represented by an empty string key. """ if method_names and not isinstance(method_names, (list, tuple)): method_names = (method_names,) version = helpers.parse_version_spec(class_version) if package_name: package = pkg_loader.load_package(package_name, version) else: package = pkg_loader.load_class_package(class_name, version) cls = package.find_class(class_name, search_requirements=False) exc = executor.MuranoDslExecutor(pkg_loader, context_manager) with helpers.with_object_store(exc.object_store): context = exc.create_object_context(cls) model_builders = set(list_model_builders(cls, context)) method_names = model_builders.intersection( method_names or model_builders) result = { name: generate_entity_schema( get_entity(cls, name), context, cls, get_meta(cls, name, context)) for name in method_names } return result
def execute(self): token, tenant_id = self.environment.token, self.environment.tenant_id with package_loader.ApiPackageLoader(token, tenant_id) as pkg_loader: class_loader = package_class_loader.PackageClassLoader(pkg_loader) system_objects.register(class_loader, pkg_loader) exc = executor.MuranoDslExecutor(class_loader, self.environment) obj = exc.load(self.model) try: # Skip execution of action in case of no action is provided. # Model will be just loaded, cleaned-up and unloaded. # Most of the time this is used for deletion of environments. if self.action: self._invoke(exc) except Exception as e: if isinstance(e, dsl_exception.MuranoPlException): LOG.error('\n' + e.format(prefix=' ')) else: LOG.exception(e) reporter = status_reporter.StatusReporter() reporter.initialize(obj) reporter.report_error(obj, str(e)) return results_serializer.serialize(obj, exc)
def execute(self): with package_loader.CombinedPackageLoader(self._session) as pkg_loader: get_plugin_loader().register_in_loader(pkg_loader) executor = dsl_executor.MuranoDslExecutor(pkg_loader, ContextManager()) action_result = self._invoke(executor) action_result = serializer.serialize(action_result, executor) return action_result
def run_tests(args): provided_pkg_name = args.package load_packages_from = args.load_packages_from tests_to_run = args.tests if not provided_pkg_name: msg = _('Package name is required parameter.') sys.stderr.write("ERROR: {msg}".format(msg=msg)) sys.exit(1) ks_opts = _validate_keystone_opts(args) client = ks_client.Client(**ks_opts) test_env = environment.Environment() test_env.token = client.auth_token test_env.tenant_id = client.auth_tenant_id test_env.clients = client_manager.ClientManager(test_env) murano_client_factory = lambda: \ test_env.clients.get_murano_client(test_env) # Replace location of loading packages with provided from command line. if load_packages_from: cfg.CONF.engine.load_packages_from = load_packages_from with package_loader.CombinedPackageLoader(murano_client_factory, client.tenant_id) as pkg_loader: engine.get_plugin_loader().register_in_loader(pkg_loader) exc = executor.MuranoDslExecutor(pkg_loader, engine.ContextManager(), test_env) package = _load_package(pkg_loader, provided_pkg_name) class_to_methods, class_to_obj = _get_all_test_methods(exc, package) run_set = _get_methods_to_run(package, tests_to_run, class_to_methods) if run_set: LOG.debug('Starting test execution.') else: msg = _('No tests found for execution.') LOG.error(msg) sys.stderr.write("ERROR: {msg}".format(msg=msg)) sys.exit(1) for pkg_class, methods in run_set.iteritems(): obj = class_to_obj[pkg_class] for m in methods: _call_service_method('setUp', exc, obj) obj.type.methods[m].usage = 'Action' test_env.start() try: obj.type.invoke(m, exc, obj, (), {}) LOG.debug('\n.....{0}.{1}.....OK'.format(obj.type.name, m)) _call_service_method('tearDown', exc, obj) except Exception: LOG.exception('\n.....{0}.{1}.....FAILURE\n' ''.format(obj.type.name, m)) finally: test_env.finish()
def _execute(self, pkg_loader): get_plugin_loader().register_in_loader(pkg_loader) executor = dsl_executor.MuranoDslExecutor(pkg_loader, ContextManager(), self.session) try: obj = executor.load(self.model) except Exception as e: return self.exception_result(e, None, '<load>') if obj is not None: try: self._validate_model(obj.object, pkg_loader, executor) except Exception as e: return self.exception_result(e, obj, '<validate>') try: LOG.debug('Invoking pre-cleanup hooks') self.session.start() executor.cleanup(self._model) except Exception as e: return self.exception_result(e, obj, '<GC>') finally: LOG.debug('Invoking post-cleanup hooks') self.session.finish() self._model['ObjectsCopy'] = copy.deepcopy(self._model.get('Objects')) action_result = None if self.action: try: LOG.debug('Invoking pre-execution hooks') self.session.start() try: action_result = self._invoke(executor) finally: try: self._model, alive_object_ids = \ serializer.serialize_model(obj, executor) LOG.debug('Cleaning up orphan objects') n = executor.cleanup_orphans(alive_object_ids) LOG.debug('{} orphan objects were destroyed'.format(n)) except Exception as e: return self.exception_result(e, None, '<model>') except Exception as e: return self.exception_result(e, obj, self.action['method']) finally: LOG.debug('Invoking post-execution hooks') self.session.finish() try: action_result = serializer.serialize(action_result, executor) except Exception as e: return self.exception_result(e, None, '<result>') pkg_loader.compact_fixation_table() return {'action': {'result': action_result, 'isException': False}}
def run_tests(self): exit_code = 0 provided_pkg_name = self.args.package load_packages_from = self.args.load_packages_from tests_to_run = self.args.tests ks_opts = self._validate_keystone_opts(self.args) client = ks_client.Client(**ks_opts) test_session = execution_session.ExecutionSession() test_session.token = client.auth_token test_session.project_id = client.project_id # Replace location of loading packages with provided from command line. if load_packages_from: cfg.CONF.packages_opts.load_packages_from = load_packages_from with package_loader.CombinedPackageLoader(test_session) as pkg_loader: engine.get_plugin_loader().register_in_loader(pkg_loader) package = self._load_package(pkg_loader, provided_pkg_name) class_to_methods = self._get_test_cases_by_classes(package) run_set = self._get_methods_to_run(package, tests_to_run, class_to_methods) if run_set: LOG.debug('Starting test execution.') else: msg = _('No tests found for execution.') LOG.error(msg) self.error(msg) for pkg_class, test_cases in six.iteritems(run_set): for m in test_cases: # Create new executor for each test case to provide # pure test environment dsl_executor = executor.MuranoDslExecutor( pkg_loader, mock_context_manager.MockContextManager(), test_session) obj = package.find_class(pkg_class, False).new( None, dsl_executor.object_store, dsl_executor)(None) self._call_service_method('setUp', dsl_executor, obj) obj.type.methods[m].usage = 'Action' test_session.start() try: obj.type.invoke(m, dsl_executor, obj, (), {}) LOG.debug('\n.....{0}.{1}.....OK'.format( obj.type.name, m)) self._call_service_method('tearDown', dsl_executor, obj) except Exception: LOG.exception('\n.....{0}.{1}.....FAILURE\n' ''.format(obj.type.name, m)) exit_code = 1 finally: test_session.finish() return exit_code
def _execute(self, pkg_loader): get_plugin_loader().register_in_loader(pkg_loader) executor = dsl_executor.MuranoDslExecutor( pkg_loader, ContextManager(), self.environment) try: obj = executor.load(self.model) except Exception as e: return self.exception_result(e, None, '<load>') if obj is not None: try: self._validate_model(obj.object, pkg_loader) except Exception as e: return self.exception_result(e, obj, '<validate>') try: LOG.debug('Invoking pre-cleanup hooks') self.environment.start() executor.cleanup(self._model) except Exception as e: return self.exception_result(e, obj, '<GC>') finally: LOG.debug('Invoking post-cleanup hooks') self.environment.finish() self._model['ObjectsCopy'] = copy.deepcopy(self._model.get('Objects')) action_result = None if self.action: try: LOG.debug('Invoking pre-execution hooks') self.environment.start() try: action_result = self._invoke(executor) finally: try: self._model = serializer.serialize_model(obj, executor) except Exception as e: return self.exception_result(e, None, '<model>') except Exception as e: return self.exception_result(e, obj, self.action['method']) finally: LOG.debug('Invoking post-execution hooks') self.environment.finish() try: action_result = serializer.serialize(action_result) except Exception as e: return self.exception_result(e, None, '<result>') return { 'action': { 'result': action_result, 'isException': False } }
def __init__(self, model, package_loader, functions): if isinstance(model, six.string_types): model = om.Object(model) model = om.build_model(model) if 'Objects' not in model: model = {'Objects': model} self.executor = executor.MuranoDslExecutor( package_loader, TestMockContextManager(functions), execution_session.ExecutionSession()) self._root = self.executor.load(model).object
def __init__(self, model, class_loader): if isinstance(model, types.StringTypes): model = object_model.Object(model) model = object_model.build_model(model) if 'Objects' not in model: model = {'Objects': model} self.executor = executor.MuranoDslExecutor( class_loader, environment.Environment()) self._root = self.executor.load(model)
def __init__(self, model, package_loader, functions): if isinstance(model, types.StringTypes): model = object_model.Object(model) model = object_model.build_model(model) if 'Objects' not in model: model = {'Objects': model} self.executor = executor.MuranoDslExecutor( package_loader, TestContextManager(functions), environment.Environment()) self._root = self.executor.load(model).object
def __init__(self, model, package_loader, functions): if isinstance(model, str): model = object_model.Object(model) model = object_model.build_model(model) if 'Objects' not in model: model = {'Objects': model} self.executor = executor.MuranoDslExecutor( package_loader, TestContextManager(functions), execution_session.ExecutionSession()) self._root = self.executor.load(model) if self._root: self._root = self._root.object if 'ObjectsCopy' in model: self.executor.object_store.cleanup()
def run_tests(self): exit_code = 0 provided_pkg_name = self.args.package load_packages_from = self.args.load_packages_from tests_to_run = self.args.tests ks_opts = self._validate_keystone_opts(self.args) client = ks_client.Client(**ks_opts) test_session = execution_session.ExecutionSession() test_session.token = client.auth_token test_session.project_id = client.project_id # Replace location of loading packages with provided from command line. if load_packages_from: cfg.CONF.engine.load_packages_from = load_packages_from with package_loader.CombinedPackageLoader(test_session) as pkg_loader: engine.get_plugin_loader().register_in_loader(pkg_loader) package = self._load_package(pkg_loader, provided_pkg_name) class_to_methods = self._get_test_cases_by_classes(package) run_set = self._get_methods_to_run(package, tests_to_run, class_to_methods) max_length = 0 num_tests = 0 for pkg_class, test_cases in six.iteritems(run_set): for m in test_cases: max_length = max(max_length, len(pkg_class) + len(m) + 1) num_tests += len(test_cases) max_length += 3 if run_set: LOG.debug('Starting test execution.') self.message('About to execute {0} tests(s)'.format(num_tests)) else: msg = _('No tests found for execution.') LOG.error(msg) self.error(msg) run_count = 0 error_count = 0 started = timeutils.utcnow() for pkg_class, test_cases in six.iteritems(run_set): for m in test_cases: # Create new executor for each test case to provide # pure test environment dsl_executor = executor.MuranoDslExecutor( pkg_loader, mock_context_manager.MockContextManager(), test_session) obj = dsl_executor.object_store.load( {}, None, default_type=package.find_class(pkg_class, False)) test_name = "{0}.{1}".format(obj.type.name, m) dots_number = max_length - len(test_name) msg = "{0} {1} ".format(test_name, '.' * dots_number) sys.stdout.write(msg) sys.stdout.flush() self._call_service_method('setUp', dsl_executor, obj) obj.type.methods[m].usage = 'Action' test_session.start() try: run_count += 1 dsl_executor.run(obj.type, m, obj, (), {}) self._call_service_method('tearDown', dsl_executor, obj) msg = '{0}{1}{2}\n'.format(OK_COLOR, 'OK', END_COLOR) LOG.debug('Test {0} successful'.format(test_name)) sys.stdout.write(msg) sys.stdout.flush() except Exception as e: error_count += 1 msg = ''.join((FAIL_COLOR, 'FAIL!', END_COLOR, '\n')) sys.stdout.write(msg) if isinstance(e, dsl_exception.MuranoPlException): tb = e.format() else: tb = traceback.format_exc() sys.stdout.write(''.join( (FAIL_COLOR, tb, END_COLOR, '\n'))) sys.stdout.flush() LOG.exception('Test {0} failed'.format(test_name)) exit_code = 1 finally: test_session.finish() completed = timeutils.utcnow() self.message('Executed {0} tests in {1} seconds: ' '{2} passed, ' '{3} failed'.format( run_count, timeutils.delta_seconds(started, completed), run_count - error_count, error_count)) return exit_code
def _execute(self, pkg_loader): class_loader = package_class_loader.PackageClassLoader(pkg_loader) system_objects.register(class_loader, pkg_loader) get_plugin_loader().register_in_loader(class_loader) exc = executor.MuranoDslExecutor(class_loader, self.environment) obj = exc.load(self.model) self._validate_model(obj, self.action, class_loader) action_result = None exception = None exception_traceback = None try: LOG.info(_LI('Invoking pre-cleanup hooks')) self.environment.start() exc.cleanup(self._model) except Exception as e: exception = e exception_traceback = TaskExecutor._log_exception(e, obj, '<GC>') finally: LOG.info(_LI('Invoking post-cleanup hooks')) self.environment.finish() if exception is None and self.action: try: LOG.info(_LI('Invoking pre-execution hooks')) self.environment.start() action_result = self._invoke(exc) except Exception as e: exception = e exception_traceback = TaskExecutor._log_exception( e, obj, self.action['method']) finally: LOG.info(_LI('Invoking post-execution hooks')) self.environment.finish() model = serializer.serialize_model(obj, exc) model['SystemData'] = self._environment.system_attributes result = { 'model': model, 'action': { 'result': None, 'isException': False } } if exception is not None: result['action'] = TaskExecutor.exception_result( exception, exception_traceback) # NOTE(kzaitsev): Exception here means that it happened during # cleanup. ObjectsCopy and Attributes would be empty if obj # is empty. This would cause failed env to be deleted. # Therefore restore these attrs from self._model for attr in ['ObjectsCopy', 'Attributes']: if not model.get(attr): model[attr] = self._model[attr] else: result['action']['result'] = serializer.serialize_object( action_result) return result