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

pytest_dsl/core/dsl_executor_utils.py

@@ -15,10 +15,10 @@ parser = get_parser()
 
 def read_file(filename):
     """读取DSL文件内容
-    
+
     Args:
         filename: 文件路径
-        
+
     Returns:
         str: 文件内容
     """
@@ -26,28 +26,27 @@ def read_file(filename):
         return f.read()
 
 
-def execute_dsl_file(filename: str) -> None:
+def execute_dsl_file(filename: str, executor: DSLExecutor = None) -> None:
     """执行DSL文件
-    
+
     Args:
         filename: DSL文件路径
+        executor: 可选的DSL执行器实例，如果不提供则创建新的
     """
     try:
         # 读取文件内容
         with open(filename, 'r', encoding='utf-8') as f:
             content = f.read()
-            
-        # 创建词法分析器和语法分析器
-        lexer = get_lexer()
-        parser = get_parser()
-        
-        # 解析DSL文件
-        ast = parser.parse(content, lexer=lexer)
-        
-        # 创建执行器并执行
-        executor = DSLExecutor()
-        executor.execute(ast)
-        
+
+        # 创建或使用提供的执行器
+        if executor is None:
+            executor = DSLExecutor(enable_tracking=True)
+
+        # 使用带跟踪功能的execute_from_content方法
+        # 使用文件路径作为dsl_id以便于跟踪
+        dsl_id = str(Path(filename).resolve())
+        executor.execute_from_content(content, dsl_id=dsl_id)
+
     except Exception as e:
         # 如果是语法错误，记录并抛出
         if "语法错误" in str(e):
@@ -59,18 +58,18 @@ def execute_dsl_file(filename: str) -> None:
 
 def extract_metadata_from_ast(ast):
     """从AST中提取元数据
-    
+
     提取DSL文件中的元数据信息，如@data和@name标记。
-    
+
     Args:
         ast: 解析后的抽象语法树
-        
+
     Returns:
         tuple: (data_source, test_title) 元组，如果不存在则为None
     """
     data_source = None
     test_title = None
-    
+
     for child in ast.children:
         if child.type == 'Metadata':
             for item in child.children:
@@ -80,5 +79,5 @@ def extract_metadata_from_ast(ast):
                     test_title = item.value
             if data_source and test_title:
                 break
-                
-    return data_source, test_title
+
+    return data_source, test_title

pytest_dsl/core/execution_tracker.py

@@ -0,0 +1,291 @@
+"""
+DSL执行跟踪器
+负责跟踪DSL执行过程中的行号、状态等信息，并提供回调接口
+"""
+
+import time
+import threading
+from typing import Dict, Any, List, Optional, Callable
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class ExecutionStatus(Enum):
+    """执行状态枚举"""
+    PENDING = "pending"      # 等待执行
+    RUNNING = "running"      # 正在执行
+    SUCCESS = "success"      # 执行成功
+    FAILED = "failed"        # 执行失败
+    SKIPPED = "skipped"      # 跳过执行
+
+
+@dataclass
+class ExecutionStep:
+    """执行步骤信息"""
+    line_number: int
+    node_type: str
+    description: str
+    status: ExecutionStatus = ExecutionStatus.PENDING
+    start_time: Optional[float] = None
+    end_time: Optional[float] = None
+    error: Optional[str] = None
+    result: Optional[Any] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def duration(self) -> Optional[float]:
+        """计算执行耗时"""
+        if self.start_time and self.end_time:
+            return self.end_time - self.start_time
+        return None
+
+    def start(self):
+        """开始执行"""
+        self.status = ExecutionStatus.RUNNING
+        self.start_time = time.time()
+
+    def finish(self, result: Any = None, error: str = None):
+        """完成执行"""
+        self.end_time = time.time()
+        if error:
+            self.status = ExecutionStatus.FAILED
+            self.error = error
+        else:
+            self.status = ExecutionStatus.SUCCESS
+            self.result = result
+
+    def skip(self, reason: str = None):
+        """跳过执行"""
+        self.status = ExecutionStatus.SKIPPED
+        if reason:
+            self.metadata['skip_reason'] = reason
+
+
+class ExecutionTracker:
+    """DSL执行跟踪器"""
+
+    def __init__(self, dsl_id: str = None):
+        self.dsl_id = dsl_id
+        self.steps: List[ExecutionStep] = []
+        self.current_step: Optional[ExecutionStep] = None
+        self.execution_start_time: Optional[float] = None
+        self.execution_end_time: Optional[float] = None
+        self.callbacks: Dict[str, List[Callable]] = {
+            'step_start': [],
+            'step_finish': [],
+            'execution_start': [],
+            'execution_finish': [],
+            'line_change': []
+        }
+        self._lock = threading.Lock()
+
+        # 执行统计
+        self.total_steps = 0
+        self.completed_steps = 0
+        self.failed_steps = 0
+
+    def register_callback(self, event: str, callback: Callable):
+        """注册回调函数
+
+        Args:
+            event: 事件类型 (step_start, step_finish, execution_start, 
+                   execution_finish, line_change)
+            callback: 回调函数
+        """
+        if event in self.callbacks:
+            self.callbacks[event].append(callback)
+
+    def _trigger_callbacks(self, event: str, **kwargs):
+        """触发回调函数"""
+        for callback in self.callbacks.get(event, []):
+            try:
+                callback(tracker=self, **kwargs)
+            except Exception as e:
+                # 回调异常不应影响主执行流程
+                print(f"回调函数执行异常: {e}")
+
+    def start_execution(self):
+        """开始执行"""
+        with self._lock:
+            self.execution_start_time = time.time()
+            self._trigger_callbacks('execution_start')
+
+    def finish_execution(self):
+        """完成执行"""
+        with self._lock:
+            self.execution_end_time = time.time()
+            self._trigger_callbacks('execution_finish')
+
+    def start_step(self, line_number: int, node_type: str,
+                   description: str, **metadata) -> ExecutionStep:
+        """开始执行步骤"""
+        with self._lock:
+            step = ExecutionStep(
+                line_number=line_number,
+                node_type=node_type,
+                description=description,
+                metadata=metadata
+            )
+            step.start()
+
+            self.steps.append(step)
+            self.current_step = step
+            self.total_steps += 1
+
+            # 触发回调
+            self._trigger_callbacks('step_start', step=step)
+            self._trigger_callbacks('line_change',
+                                    line_number=line_number, step=step)
+
+            return step
+
+    def finish_current_step(self, result: Any = None, error: str = None):
+        """完成当前步骤"""
+        with self._lock:
+            if self.current_step:
+                self.current_step.finish(result, error)
+
+                if error:
+                    self.failed_steps += 1
+                else:
+                    self.completed_steps += 1
+
+                # 触发回调
+                self._trigger_callbacks('step_finish', step=self.current_step)
+
+                # 记录到Allure
+                self._log_step_to_allure(self.current_step)
+
+                self.current_step = None
+
+    def skip_current_step(self, reason: str = None):
+        """跳过当前步骤"""
+        with self._lock:
+            if self.current_step:
+                self.current_step.skip(reason)
+                self.completed_steps += 1
+
+                # 触发回调
+                self._trigger_callbacks('step_finish', step=self.current_step)
+
+                # 记录到Allure
+                self._log_step_to_allure(self.current_step)
+
+                self.current_step = None
+
+    def get_current_line(self) -> Optional[int]:
+        """获取当前执行行号"""
+        return self.current_step.line_number if self.current_step else None
+
+    def get_execution_progress(self) -> Dict[str, Any]:
+        """获取执行进度信息"""
+        return {
+            'dsl_id': self.dsl_id,
+            'total_steps': self.total_steps,
+            'completed_steps': self.completed_steps,
+            'failed_steps': self.failed_steps,
+            'current_line': self.get_current_line(),
+            'progress_percentage': (
+                (self.completed_steps / self.total_steps * 100)
+                if self.total_steps > 0 else 0),
+            'execution_time': self.get_execution_time()
+        }
+
+    def get_execution_time(self) -> Optional[float]:
+        """获取执行时间"""
+        if self.execution_start_time:
+            end_time = self.execution_end_time or time.time()
+            return end_time - self.execution_start_time
+        return None
+
+    def get_steps_summary(self) -> Dict[str, Any]:
+        """获取步骤执行摘要"""
+        status_counts = {}
+        line_ranges = []
+
+        for step in self.steps:
+            # 统计状态
+            status = step.status.value
+            status_counts[status] = status_counts.get(status, 0) + 1
+
+            # 收集行号范围
+            line_ranges.append(step.line_number)
+
+        return {
+            'total_steps': len(self.steps),
+            'status_counts': status_counts,
+            'line_range': {
+                'start': min(line_ranges) if line_ranges else None,
+                'end': max(line_ranges) if line_ranges else None
+            },
+            'execution_time': self.get_execution_time(),
+            'steps': [
+                {
+                    'line': step.line_number,
+                    'type': step.node_type,
+                    'status': step.status.value,
+                    'duration': step.duration,
+                    'description': step.description
+                } for step in self.steps
+            ]
+        }
+
+    def _log_step_to_allure(self, step: ExecutionStep):
+        """将步骤信息记录到Allure报告"""
+        # 不再创建额外的allure attachment，避免重复记录
+        # DSL执行器中已经有专门的attachment记录行号信息
+        pass
+
+    def export_execution_report(self) -> Dict[str, Any]:
+        """导出执行报告"""
+        return {
+            'dsl_id': self.dsl_id,
+            'execution_summary': self.get_execution_progress(),
+            'steps_summary': self.get_steps_summary(),
+            'execution_timeline': [
+                {
+                    'line_number': step.line_number,
+                    'node_type': step.node_type,
+                    'description': step.description,
+                    'status': step.status.value,
+                    'start_time': step.start_time,
+                    'end_time': step.end_time,
+                    'duration': step.duration,
+                    'error': step.error,
+                    'metadata': step.metadata
+                } for step in self.steps
+            ]
+        }
+
+
+# 全局跟踪器注册表
+_global_trackers: Dict[str, ExecutionTracker] = {}
+_tracker_lock = threading.Lock()
+
+
+def get_or_create_tracker(dsl_id: str = None) -> ExecutionTracker:
+    """获取或创建执行跟踪器"""
+    with _tracker_lock:
+        if dsl_id is None:
+            dsl_id = f"tracker_{int(time.time() * 1000)}"
+
+        if dsl_id not in _global_trackers:
+            _global_trackers[dsl_id] = ExecutionTracker(dsl_id)
+
+        return _global_trackers[dsl_id]
+
+
+def get_tracker(dsl_id: str) -> Optional[ExecutionTracker]:
+    """获取指定的执行跟踪器"""
+    return _global_trackers.get(dsl_id)
+
+
+def remove_tracker(dsl_id: str):
+    """移除执行跟踪器"""
+    with _tracker_lock:
+        _global_trackers.pop(dsl_id, None)
+
+
+def list_active_trackers() -> List[str]:
+    """列出所有活跃的跟踪器"""
+    return list(_global_trackers.keys())

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()