pytest-dsl 0.12.1__py3-none-any.whl → 0.14.0__py3-none-any.whl

pytest_dsl/cli.py

@@ -78,7 +78,7 @@ def parse_args():
         list_parser.add_argument(
             '--category',
             choices=[
-                'builtin', 'plugin', 'custom', 
+                'builtin', 'plugin', 'custom',
                 'project_custom', 'remote', 'all'
             ],
             default='all',
@@ -108,7 +108,7 @@ def parse_args():
             parser.add_argument(
                 '--category',
                 choices=[
-                    'builtin', 'plugin', 'custom', 
+                    'builtin', 'plugin', 'custom',
                     'project_custom', 'remote', 'all'
                 ],
                 default='all'
@@ -157,6 +157,29 @@ def load_all_keywords(include_remote=False):
     # 扫描本地关键字
     scan_local_keywords()
 
+    # 自动导入项目中的resources目录
+    try:
+        from pytest_dsl.core.custom_keyword_manager import (
+            custom_keyword_manager)
+
+        # 尝试从多个可能的项目根目录位置导入resources
+        possible_roots = [
+            os.getcwd(),  # 当前工作目录
+            os.path.dirname(os.getcwd()),  # 上级目录
+        ]
+
+        # 尝试每个可能的根目录
+        for project_root in possible_roots:
+            if project_root and os.path.exists(project_root):
+                resources_dir = os.path.join(project_root, "resources")
+                if (os.path.exists(resources_dir) and
+                        os.path.isdir(resources_dir)):
+                    custom_keyword_manager.auto_import_resources_directory(
+                        project_root)
+                    break
+    except Exception as e:
+        print(f"自动导入resources目录时出现警告: {str(e)}")
+
     # 扫描项目中的自定义关键字（.resource文件中定义的）
     project_custom_keywords = scan_project_custom_keywords()
     if project_custom_keywords:
@@ -701,12 +724,17 @@ def list_keywords(output_format='json', name_filter=None,
 
 def load_yaml_variables(args):
     """从命令行参数加载YAML变量"""
-    # 使用统一的加载函数，包含远程服务器自动连接功能
+    # 使用统一的加载函数，包含远程服务器自动连接功能和hook支持
     try:
+        # 尝试从环境变量获取环境名称
+        environment = (os.environ.get('PYTEST_DSL_ENVIRONMENT') or
+                       os.environ.get('ENVIRONMENT'))
+
         load_yaml_variables_from_args(
             yaml_files=args.yaml_vars,
             yaml_vars_dir=args.yaml_vars_dir,
-            project_root=os.getcwd()  # CLI模式下使用当前工作目录作为项目根目录
+            project_root=os.getcwd(),  # CLI模式下使用当前工作目录作为项目根目录
+            environment=environment
         )
     except Exception as e:
         print(f"加载YAML变量失败: {str(e)}")
@@ -751,6 +779,33 @@ def run_dsl_tests(args):
     # 加载YAML变量（包括远程服务器自动连接）
     load_yaml_variables(args)
 
+    # 支持hook机制的执行
+    from pytest_dsl.core.hookable_executor import hookable_executor
+
+    # 检查是否有hook提供的用例列表
+    hook_cases = hookable_executor.list_dsl_cases()
+    if hook_cases:
+        # 如果有hook提供的用例，优先执行这些用例
+        print(f"通过Hook发现 {len(hook_cases)} 个DSL用例")
+        failures = 0
+        for case in hook_cases:
+            case_id = case.get('id') or case.get('name', 'unknown')
+            try:
+                print(f"执行用例: {case.get('name', case_id)}")
+                hookable_executor.execute_dsl(str(case_id))
+                print(f"✓ 用例 {case.get('name', case_id)} 执行成功")
+            except Exception as e:
+                print(f"✗ 用例 {case.get('name', case_id)} 执行失败: {e}")
+                failures += 1
+
+        if failures > 0:
+            print(f"总计 {failures}/{len(hook_cases)} 个测试失败")
+            sys.exit(1)
+        else:
+            print(f"所有 {len(hook_cases)} 个测试成功完成")
+        return
+
+    # 如果没有hook用例，使用传统的文件执行方式
     lexer = get_lexer()
     parser = get_parser()
     executor = DSLExecutor()

pytest_dsl/core/custom_keyword_manager.py

@@ -15,6 +15,7 @@ class CustomKeywordManager:
         """初始化自定义关键字管理器"""
         self.resource_cache = {}  # 缓存已加载的资源文件
         self.resource_paths = []  # 资源文件搜索路径
+        self.auto_imported_resources = set()  # 记录已自动导入的资源文件
 
     def add_resource_path(self, path: str) -> None:
         """添加资源文件搜索路径
@@ -25,6 +26,141 @@ class CustomKeywordManager:
         if path not in self.resource_paths:
             self.resource_paths.append(path)
 
+    def auto_import_resources_directory(
+            self, project_root: str = None) -> None:
+        """自动导入项目中的resources目录
+
+        Args:
+            project_root: 项目根目录，默认为当前工作目录
+        """
+        if project_root is None:
+            project_root = os.getcwd()
+
+        # 查找resources目录
+        resources_dir = os.path.join(project_root, "resources")
+
+        if (not os.path.exists(resources_dir) or
+                not os.path.isdir(resources_dir)):
+            # 如果没有resources目录，静默返回
+            return
+
+        print(f"发现resources目录: {resources_dir}")
+
+        # 递归查找所有.resource文件
+        resource_files = []
+        for root, dirs, files in os.walk(resources_dir):
+            for file in files:
+                if file.endswith('.resource'):
+                    resource_files.append(os.path.join(root, file))
+
+        if not resource_files:
+            print("resources目录中没有找到.resource文件")
+            return
+
+        print(f"在resources目录中发现 {len(resource_files)} 个资源文件")
+
+        # 按照依赖关系排序并加载资源文件
+        sorted_files = self._sort_resources_by_dependencies(resource_files)
+
+        for resource_file in sorted_files:
+            try:
+                # 检查是否已经自动导入过
+                absolute_path = os.path.abspath(resource_file)
+                if absolute_path not in self.auto_imported_resources:
+                    self.load_resource_file(resource_file)
+                    self.auto_imported_resources.add(absolute_path)
+                    print(f"自动导入资源文件: {resource_file}")
+            except Exception as e:
+                print(f"自动导入资源文件失败 {resource_file}: {e}")
+
+    def _sort_resources_by_dependencies(self, resource_files):
+        """根据依赖关系对资源文件进行排序
+
+        Args:
+            resource_files: 资源文件列表
+
+        Returns:
+            list: 按依赖关系排序后的资源文件列表
+        """
+        # 简单的拓扑排序实现
+        dependencies = {}
+        all_files = set()
+
+        # 分析每个文件的依赖关系
+        for file_path in resource_files:
+            all_files.add(file_path)
+            dependencies[file_path] = self._extract_dependencies(file_path)
+
+        # 拓扑排序
+        sorted_files = []
+        visited = set()
+        temp_visited = set()
+
+        def visit(file_path):
+            if file_path in temp_visited:
+                # 检测到循环依赖，跳过
+                return
+            if file_path in visited:
+                return
+
+            temp_visited.add(file_path)
+
+            # 访问依赖的文件
+            for dep in dependencies.get(file_path, []):
+                if dep in all_files:  # 只处理在当前文件列表中的依赖
+                    visit(dep)
+
+            temp_visited.remove(file_path)
+            visited.add(file_path)
+            sorted_files.append(file_path)
+
+        # 访问所有文件
+        for file_path in resource_files:
+            if file_path not in visited:
+                visit(file_path)
+
+        return sorted_files
+
+    def _extract_dependencies(self, file_path):
+        """提取资源文件的依赖关系
+
+        Args:
+            file_path: 资源文件路径
+
+        Returns:
+            list: 依赖的文件路径列表
+        """
+        dependencies = []
+
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            # 解析文件获取导入信息
+            lexer = get_lexer()
+            parser = get_parser()
+            ast = parser.parse(content, lexer=lexer)
+
+            if ast.type == 'Start' and ast.children:
+                metadata_node = ast.children[0]
+                if metadata_node.type == 'Metadata':
+                    for item in metadata_node.children:
+                        if item.type == '@import':
+                            imported_file = item.value
+                            # 处理相对路径
+                            if not os.path.isabs(imported_file):
+                                imported_file = os.path.join(
+                                    os.path.dirname(file_path), imported_file)
+                            # 规范化路径
+                            imported_file = os.path.normpath(imported_file)
+                            dependencies.append(imported_file)
+
+        except Exception as e:
+            # 如果解析失败，返回空依赖列表
+            print(f"解析资源文件依赖失败 {file_path}: {e}")
+
+        return dependencies
+
     def load_resource_file(self, file_path: str) -> None:
         """加载资源文件
 
@@ -64,23 +200,37 @@ class CustomKeywordManager:
             with open(file_path, 'r', encoding='utf-8') as f:
                 content = f.read()
 
-            # 解析资源文件
-            lexer = get_lexer()
-            parser = get_parser()
-            ast = parser.parse(content, lexer=lexer)
-
-            # 标记为已加载
+            # 标记为已加载（在解析前标记，避免循环导入）
             self.resource_cache[absolute_path] = True
 
-            # 处理导入指令
-            self._process_imports(ast, os.path.dirname(file_path))
+            # 使用公共方法解析和处理资源文件内容
+            self._process_resource_file_content(content, file_path)
 
-            # 注册关键字
-            self._register_keywords(ast, file_path)
         except Exception as e:
+            # 如果处理失败，移除缓存标记
+            self.resource_cache.pop(absolute_path, None)
             print(f"资源文件 {file_path} 加载失败: {str(e)}")
             raise
 
+    def _process_resource_file_content(self, content: str, 
+                                       file_path: str) -> None:
+        """处理资源文件内容
+
+        Args:
+            content: 文件内容
+            file_path: 文件路径
+        """
+        # 解析资源文件
+        lexer = get_lexer()
+        parser = get_parser()
+        ast = parser.parse(content, lexer=lexer)
+
+        # 处理导入指令
+        self._process_imports(ast, os.path.dirname(file_path))
+
+        # 注册关键字
+        self._register_keywords_from_ast(ast, file_path)
+
     def _process_imports(self, ast: Node, base_dir: str) -> None:
         """处理资源文件中的导入指令
 
@@ -108,12 +258,13 @@ class CustomKeywordManager:
                 # 递归加载导入的资源文件
                 self.load_resource_file(imported_file)
 
-    def _register_keywords(self, ast: Node, file_path: str) -> None:
-        """从AST中注册关键字
+    def _register_keywords_from_ast(self, ast: Node, 
+                                    source_name: str) -> None:
+        """从AST中注册关键字（重构后的版本）
 
         Args:
             ast: 抽象语法树
-            file_path: 文件路径
+            source_name: 来源名称
         """
         if ast.type != 'Start' or len(ast.children) < 2:
             return
@@ -125,7 +276,7 @@ class CustomKeywordManager:
 
         for node in statements_node.children:
             if node.type in ['CustomKeyword', 'Function']:
-                self._register_custom_keyword(node, file_path)
+                self._register_custom_keyword(node, source_name)
 
     def _register_custom_keyword(self, node: Node, file_path: str) -> None:
         """注册自定义关键字
@@ -206,6 +357,91 @@ class CustomKeywordManager:
 
         print(f"已注册自定义关键字: {keyword_name} 来自文件: {file_path}")
 
+    def register_keyword_from_dsl_content(self, dsl_content: str, 
+                                          source_name: str = "DSL内容") -> list:
+        """从DSL内容注册关键字（公共方法）
+
+        Args:
+            dsl_content: DSL文本内容
+            source_name: 来源名称，用于日志显示
+
+        Returns:
+            list: 注册成功的关键字名称列表
+
+        Raises:
+            Exception: 解析或注册失败时抛出异常
+        """
+        try:
+            # 解析DSL内容
+            lexer = get_lexer()
+            parser = get_parser()
+            ast = parser.parse(dsl_content, lexer=lexer)
+
+            # 收集注册前的关键字列表
+            existing_keywords = (
+                set(keyword_manager._keywords.keys()) 
+                if hasattr(keyword_manager, '_keywords') 
+                else set()
+            )
+
+            # 使用统一的注册方法
+            self._register_keywords_from_ast(ast, source_name)
+
+            # 计算新注册的关键字
+            new_keywords = (
+                set(keyword_manager._keywords.keys()) 
+                if hasattr(keyword_manager, '_keywords') 
+                else set()
+            )
+            registered_keywords = list(new_keywords - existing_keywords)
+
+            if not registered_keywords:
+                raise ValueError("在DSL内容中未找到任何关键字定义")
+
+            return registered_keywords
+
+        except Exception as e:
+            print(f"从DSL内容注册关键字失败（来源：{source_name}）: {e}")
+            raise
+
+    def register_specific_keyword_from_dsl_content(
+            self, keyword_name: str, dsl_content: str, 
+            source_name: str = "DSL内容") -> bool:
+        """从DSL内容注册指定的关键字（公共方法）
+
+        Args:
+            keyword_name: 要注册的关键字名称
+            dsl_content: DSL文本内容
+            source_name: 来源名称，用于日志显示
+
+        Returns:
+            bool: 是否注册成功
+
+        Raises:
+            Exception: 解析失败或未找到指定关键字时抛出异常
+        """
+        try:
+            # 解析DSL内容
+            lexer = get_lexer()
+            parser = get_parser()
+            ast = parser.parse(dsl_content, lexer=lexer)
+
+            # 查找指定的关键字定义
+            if ast.type == 'Start' and len(ast.children) >= 2:
+                statements_node = ast.children[1]
+                if statements_node.type == 'Statements':
+                    for node in statements_node.children:
+                        if (node.type in ['CustomKeyword', 'Function'] and
+                                node.value == keyword_name):
+                            self._register_custom_keyword(node, source_name)
+                            return True
+
+            raise ValueError(f"在DSL内容中未找到关键字定义: {keyword_name}")
+
+        except Exception as e:
+            print(f"从DSL内容注册关键字失败 {keyword_name}（来源：{source_name}）: {e}")
+            raise
+
 
 # 创建全局自定义关键字管理器实例
 custom_keyword_manager = CustomKeywordManager()