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

pytest_dsl/core/hook_manager.py

@@ -0,0 +1,87 @@
+"""
+pytest-dsl hook管理器
+
+管理插件的注册、发现和调用
+"""
+import pluggy
+from typing import Optional, List, Any
+from .hookspecs import DSLHookSpecs
+
+
+class DSLHookManager:
+    """DSL Hook管理器"""
+    
+    _instance: Optional['DSLHookManager'] = None
+    
+    def __init__(self):
+        self.pm: pluggy.PluginManager = pluggy.PluginManager("pytest_dsl")
+        self.pm.add_hookspecs(DSLHookSpecs)
+        self._initialized = False
+    
+    @classmethod
+    def get_instance(cls) -> 'DSLHookManager':
+        """获取单例实例"""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+    
+    def register_plugin(self, plugin: Any, name: Optional[str] = None) -> None:
+        """注册插件
+        
+        Args:
+            plugin: 插件实例或模块
+            name: 插件名称（可选）
+        """
+        self.pm.register(plugin, name=name)
+    
+    def unregister_plugin(self, plugin: Any = None, 
+                          name: Optional[str] = None) -> None:
+        """注销插件
+        
+        Args:
+            plugin: 插件实例或模块
+            name: 插件名称
+        """
+        self.pm.unregister(plugin=plugin, name=name)
+    
+    def is_registered(self, plugin: Any) -> bool:
+        """检查插件是否已注册"""
+        return self.pm.is_registered(plugin)
+    
+    def load_setuptools_entrypoints(self, group: str = "pytest_dsl") -> int:
+        """加载setuptools入口点插件
+        
+        Args:
+            group: 入口点组名
+            
+        Returns:
+            加载的插件数量
+        """
+        return self.pm.load_setuptools_entrypoints(group)
+    
+    def get_plugins(self) -> List[Any]:
+        """获取所有已注册的插件"""
+        return self.pm.get_plugins()
+    
+    def hook(self) -> Any:
+        """获取hook调用器"""
+        return self.pm.hook
+    
+    def initialize(self) -> None:
+        """初始化hook管理器"""
+        if self._initialized:
+            return
+        
+        # 尝试加载setuptools入口点插件
+        try:
+            loaded = self.load_setuptools_entrypoints()
+            if loaded > 0:
+                print(f"加载了 {loaded} 个插件")
+        except Exception as e:
+            print(f"加载插件时出现错误: {e}")
+        
+        self._initialized = True
+
+
+# 全局hook管理器实例
+hook_manager = DSLHookManager.get_instance() 

pytest_dsl/core/hookable_executor.py

@@ -0,0 +1,134 @@
+"""
+可扩展的DSL执行器
+
+支持hook机制的DSL执行器，提供统一的执行接口
+"""
+from typing import Dict, List, Optional, Any
+from .dsl_executor import DSLExecutor
+from .hook_manager import hook_manager
+
+
+class HookableExecutor:
+    """支持Hook机制的DSL执行器"""
+    
+    def __init__(self):
+        self.executor = None
+        self._ensure_initialized()
+    
+    def _ensure_initialized(self):
+        """确保执行器已初始化"""
+        if self.executor is None:
+            self.executor = DSLExecutor(enable_hooks=True)
+    
+    def execute_dsl(self, dsl_id: str, context: Optional[Dict[str, Any]] = None) -> Any:
+        """执行DSL用例
+        
+        Args:
+            dsl_id: DSL标识符
+            context: 执行上下文（可选）
+            
+        Returns:
+            执行结果
+        """
+        self._ensure_initialized()
+        
+        # 通过hook获取执行上下文扩展
+        if self.executor.enable_hooks and self.executor.hook_manager:
+            context_results = self.executor.hook_manager.pm.hook.dsl_get_execution_context(
+                dsl_id=dsl_id, base_context=context or {}
+            )
+            for extended_context in context_results:
+                if extended_context:
+                    context = extended_context
+                    break
+        
+        # 执行DSL（内容为空，通过hook加载）
+        return self.executor.execute_from_content(
+            content="",
+            dsl_id=dsl_id,
+            context=context
+        )
+    
+    def list_dsl_cases(self, project_id: Optional[int] = None, 
+                       filters: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
+        """列出DSL用例
+        
+        Args:
+            project_id: 项目ID（可选）
+            filters: 过滤条件（可选）
+            
+        Returns:
+            用例列表
+        """
+        self._ensure_initialized()
+        
+        if not (self.executor.enable_hooks and self.executor.hook_manager):
+            return []
+        
+        all_cases = []
+        case_results = self.executor.hook_manager.pm.hook.dsl_list_cases(
+            project_id=project_id, filters=filters
+        )
+        
+        for result in case_results:
+            if result:
+                all_cases.extend(result)
+        
+        return all_cases
+    
+    def validate_dsl_content(self, dsl_id: str, content: str) -> List[str]:
+        """验证DSL内容
+        
+        Args:
+            dsl_id: DSL标识符
+            content: DSL内容
+            
+        Returns:
+            验证错误列表，空列表表示验证通过
+        """
+        self._ensure_initialized()
+        
+        if not (self.executor.enable_hooks and self.executor.hook_manager):
+            return []
+        
+        all_errors = []
+        validation_results = self.executor.hook_manager.pm.hook.dsl_validate_content(
+            dsl_id=dsl_id, content=content
+        )
+        
+        for errors in validation_results:
+            if errors:
+                all_errors.extend(errors)
+        
+        return all_errors
+    
+    def transform_dsl_content(self, dsl_id: str, content: str) -> str:
+        """转换DSL内容
+        
+        Args:
+            dsl_id: DSL标识符
+            content: 原始DSL内容
+            
+        Returns:
+            转换后的DSL内容
+        """
+        self._ensure_initialized()
+        
+        if not (self.executor.enable_hooks and self.executor.hook_manager):
+            return content
+        
+        transformed_content = content
+        transform_results = self.executor.hook_manager.pm.hook.dsl_transform_content(
+            dsl_id=dsl_id, content=content
+        )
+        
+        for result in transform_results:
+            if result:
+                transformed_content = result
+                break
+        
+        return transformed_content
+
+
+# 全局实例
+hookable_executor = HookableExecutor() 

pytest_dsl/core/hookable_keyword_manager.py

@@ -0,0 +1,106 @@
+"""
+可扩展的关键字管理器
+
+支持通过hook机制注册自定义关键字
+"""
+from typing import Dict, List, Optional, Any
+from .keyword_manager import keyword_manager
+from .hook_manager import hook_manager
+
+
+class HookableKeywordManager:
+    """支持Hook机制的关键字管理器"""
+
+    def __init__(self):
+        self.hook_keywords = {}  # 存储通过hook注册的关键字
+        self._initialized = False
+
+    def initialize(self):
+        """初始化，调用hook注册关键字"""
+        if self._initialized:
+            return
+
+        if hook_manager and hook_manager._initialized:
+            try:
+                # 调用hook注册自定义关键字
+                hook_manager.pm.hook.dsl_register_custom_keywords()
+                print(f"通过Hook注册了 {len(self.hook_keywords)} 个自定义关键字")
+            except Exception as e:
+                print(f"Hook关键字注册失败: {e}")
+
+        self._initialized = True
+
+    def register_hook_keyword(self, keyword_name: str, dsl_content: str,
+                              source_info: Optional[Dict[str, Any]] = None):
+        """通过Hook注册自定义关键字
+
+        Args:
+            keyword_name: 关键字名称
+            dsl_content: DSL内容定义
+            source_info: 来源信息
+        """
+        # 检查是否已经注册过
+        if keyword_name in self.hook_keywords:
+            print(f"Hook关键字 {keyword_name} 已存在，跳过重复注册")
+            return
+
+        # 使用custom_keyword_manager的公共方法注册关键字
+        try:
+            from .custom_keyword_manager import custom_keyword_manager
+
+            # 准备来源名称
+            source_name = (source_info.get('source_name', 'Hook插件') 
+                          if source_info else 'Hook插件')
+
+            # 使用公共方法注册指定关键字
+            success = custom_keyword_manager.register_specific_keyword_from_dsl_content(
+                keyword_name, dsl_content, source_name
+            )
+
+            if success:
+                # 更新来源信息
+                if keyword_name in keyword_manager._keywords:
+                    keyword_info = keyword_manager._keywords[keyword_name]
+                    if source_info:
+                        keyword_info.update(source_info)
+                    else:
+                        keyword_info.update({
+                            'source_type': 'hook',
+                            'source_name': 'Hook插件'
+                        })
+
+                # 记录到hook关键字列表
+                self.hook_keywords[keyword_name] = {
+                    'dsl_content': dsl_content,
+                    'source_info': source_info or {
+                        'source_type': 'hook',
+                        'source_name': 'Hook插件'
+                    }
+                }
+
+                print(f"注册Hook关键字: {keyword_name}")
+
+        except Exception as e:
+            print(f"注册Hook关键字失败 {keyword_name}: {e}")
+            raise
+
+    def get_hook_keywords(self) -> Dict[str, Dict]:
+        """获取所有通过Hook注册的关键字"""
+        return self.hook_keywords.copy()
+
+    def is_hook_keyword(self, keyword_name: str) -> bool:
+        """检查是否为Hook关键字"""
+        return keyword_name in self.hook_keywords
+
+    def unregister_hook_keyword(self, keyword_name: str):
+        """注销Hook关键字"""
+        if keyword_name in self.hook_keywords:
+            del self.hook_keywords[keyword_name]
+            # 从关键字管理器中移除
+            if hasattr(keyword_manager, '_keywords'):
+                keyword_manager._keywords.pop(keyword_name, None)
+            print(f"注销Hook关键字: {keyword_name}")
+
+
+# 全局实例
+hookable_keyword_manager = HookableKeywordManager()

pytest_dsl/core/hookspecs.py

@@ -0,0 +1,175 @@
+"""
+pytest-dsl hook规范定义
+
+使用pluggy定义hook接口，允许外部框架扩展DSL功能
+"""
+import pluggy
+from typing import Dict, List, Optional, Any
+
+# 创建pytest-dsl的hook标记器
+hookspec = pluggy.HookspecMarker("pytest_dsl")
+hookimpl = pluggy.HookimplMarker("pytest_dsl")
+
+
+class DSLHookSpecs:
+    """DSL Hook规范"""
+
+    @hookspec
+    def dsl_load_content(self, dsl_id: str) -> Optional[str]:
+        """加载DSL内容
+
+        Args:
+            dsl_id: DSL标识符（可以是文件路径、数据库ID等）
+
+        Returns:
+            DSL内容字符串，如果无法加载返回None
+        """
+
+    @hookspec
+    def dsl_list_cases(self, project_id: Optional[int] = None,
+                       filters: Optional[Dict[str, Any]] = None
+                       ) -> List[Dict[str, Any]]:
+        """列出DSL用例
+
+        Args:
+            project_id: 项目ID，用于过滤（可选）
+            filters: 其他过滤条件（可选）
+
+        Returns:
+            用例列表，每个用例包含id、name、description等字段
+        """
+
+    @hookspec
+    def dsl_register_custom_keywords(self,
+                                     project_id: Optional[int] = None) -> None:
+        """注册自定义关键字
+
+        Args:
+            project_id: 项目ID，用于过滤（可选）
+        """
+
+    @hookspec
+    def dsl_get_execution_context(self, dsl_id: str,
+                                  base_context: Dict[str, Any]
+                                  ) -> Dict[str, Any]:
+        """获取执行上下文
+
+        Args:
+            dsl_id: DSL标识符
+            base_context: 基础上下文
+
+        Returns:
+            扩展后的执行上下文
+        """
+
+    @hookspec(firstresult=True)  # 只使用第一个返回结果
+    def dsl_create_executor(self) -> Optional[Any]:
+        """创建自定义DSL执行器
+
+        Returns:
+            自定义执行器实例，如果返回None则使用默认执行器
+        """
+
+    @hookspec
+    def dsl_before_execution(self, dsl_id: str,
+                             context: Dict[str, Any]) -> None:
+        """DSL执行前的hook
+
+        Args:
+            dsl_id: DSL标识符
+            context: 执行上下文
+        """
+
+    @hookspec
+    def dsl_after_execution(self, dsl_id: str, context: Dict[str, Any],
+                            result: Any,
+                            exception: Optional[Exception] = None) -> None:
+        """DSL执行后的hook
+
+        Args:
+            dsl_id: DSL标识符
+            context: 执行上下文
+            result: 执行结果
+            exception: 如果执行失败，包含异常信息
+        """
+
+    @hookspec
+    def dsl_transform_content(self, dsl_id: str, content: str) -> str:
+        """转换DSL内容
+
+        Args:
+            dsl_id: DSL标识符
+            content: 原始DSL内容
+
+        Returns:
+            转换后的DSL内容
+        """
+
+    @hookspec
+    def dsl_validate_content(self, dsl_id: str, content: str) -> List[str]:
+        """验证DSL内容
+
+        Args:
+            dsl_id: DSL标识符
+            content: DSL内容
+
+        Returns:
+            验证错误列表，空列表表示验证通过
+        """
+
+    @hookspec
+    def dsl_load_variables(self, project_id: Optional[int] = None,
+                           environment: Optional[str] = None,
+                           filters: Optional[Dict[str, Any]] = None
+                           ) -> Dict[str, Any]:
+        """加载变量配置
+
+        Args:
+            project_id: 项目ID，用于过滤（可选）
+            environment: 环境名称，如dev、test、prod等（可选）
+            filters: 其他过滤条件（可选）
+
+        Returns:
+            变量字典，键为变量名，值为变量值
+        """
+
+    @hookspec
+    def dsl_get_variable(self, var_name: str, project_id: Optional[int] = None,
+                         environment: Optional[str] = None
+                         ) -> Optional[Any]:
+        """获取单个变量值
+
+        Args:
+            var_name: 变量名
+            project_id: 项目ID，用于过滤（可选）
+            environment: 环境名称（可选）
+
+        Returns:
+            变量值，如果变量不存在返回None
+        """
+
+    @hookspec
+    def dsl_list_variable_sources(self, project_id: Optional[int] = None
+                                  ) -> List[Dict[str, Any]]:
+        """列出可用的变量源
+
+        Args:
+            project_id: 项目ID，用于过滤（可选）
+
+        Returns:
+            变量源列表，每个源包含name、type、description等字段
+        """
+
+    @hookspec
+    def dsl_validate_variables(self, variables: Dict[str, Any],
+                               project_id: Optional[int] = None
+                               ) -> List[str]:
+        """验证变量配置
+
+        Args:
+            variables: 变量字典
+            project_id: 项目ID，用于过滤（可选）
+
+        Returns:
+            验证错误列表，空列表表示验证通过
+        """