Adapted to pytest framework

Author: Menglths

test/.gitignore

@@ -1,6 +1,10 @@
 reports/
 dataset/
 logs/
+result_outputs/
+results/
+.cache/
+backup/
 $null
 *__pycache__/
 .*

test/README.md

@@ -1,219 +1,179 @@
-# UCM Pytest Testing Framework
+# Pytest
+[简体中文](README_zh.md)
+A comprehensive Pytest testing framework featuring configuration management, database integration, performance testing, and HTML report generation.
 
-A unified cache management testing framework based on pytest, supporting multi-level testing, flexible marking, performance data collection, and beautiful Allure report generation.
+## 📋 Features
 
-## Framework Features
+- **Modern Testing Framework**: Complete test solution built on Pytest 7.0+
+- **Configuration Management**: YAML-based config with thread-safe singleton pattern
+- **Database Integration**: Built-in MySQL support with automatic result storage
+- **HTML Reports**: Auto-generated pytest HTML test reports
+- **Tagging System**: Multi-dimensional test tags (stage, feature, platform, etc.)
 
-- [x] 🏗️ **Multi-level Testing**: UnitTest(0) → Smoke(1) → Feature(2) → E2E(3)
-- [x] 🏷️ **Flexible Marking**: Support for feature tags, platform tags, and reliability tags
-- [x] 📊 **Data Collection**: Integrated InfluxDB performance data pushing
-- [x] 📋 **Beautiful Reports**: Allure test report integration, supporting both static HTML and dynamic server modes
-- [x] 🔧 **Configuration Management**: Flexible YAML-based configuration system
-- [x] 🚀 **Automation**: Support for parallel test execution and automatic cleanup
-
-## Test Level Definitions
-
-| Level | Name | Description | Execution Time |
-|-----|------|------|----------|
-| 0 | UnitTest | Unit Tests | Every code commit |
-| 1 | Smoke | Smoke Tests | Build verification |
-| 2 | Feature | Feature Tests | When features are completed |
-| 3 | E2E | End-to-End Tests | Before version release |
-
-## Directory Structure
+## 🗂️ Project Structure
 
 ```
-test/
-├── config.yaml              # Test framework configuration file
-├── conftest.py              # pytest configuration and fixtures, main program entry
-├── pytest.ini              # pytest markers and basic configuration
-├── requirements.txt         # Dependency package list
-├── common/                  # Common utility library
+pytest_demo/
+├── common/                          # Common modules
 │   ├── __init__.py
-│   ├── config_utils.py      # Configuration file reading tools
-│   ├── influxdb_utils.py    # InfluxDB writing tools
-│   └── allure_utils.py      # Allure reporting tools
-├── suites/                  # Test case directory
-│   ├── UnitTest/            # Unit tests (stage 0)
-│   ├── Smoke/               # Smoke tests (stage 1)
-│   ├── Feature/             # Feature tests (stage 2)
-│   ├── E2E/                 # End-to-end tests (stage 3)
-│   └── test_demo_function.py# Example test cases
-├── reports/                 # Test report directory
-└── logs/          # Test log directory
+│   ├── config_utils.py              # Configuration utilities
+│   ├── db_utils.py                  # Database utilities
+│   └── capture_utils                # Return-value capture utilities
+├── results/                         # Result storage folder
+├── suites/                          # Test suites
+│   ├── UnitTest                     # Unit tests
+│   ├── Feature                      # Feature tests
+│   └── E2E/                         # End-to-end tests
+│       └── test_demo_performance.py # Sample test file
+├── config.yaml                      # Main config file
+├── conftest.py                      # Pytest config
+├── pytest.ini                       # Pytest settings
+├── requirements.txt                 # Dependencies
+└── README.md                        # This doc (CN)
 ```
 
-## Quick Start
+## 🚀 Quick Start
 
-### 1. Environment Setup
-```bash
-# Install dependencies
-pip install -r requirements.txt
+### Prerequisites
 
-# Ensure Allure CLI is installed (for report generation)
-# Download from: https://github.com/allure-framework/allure2/releases
-```
+- Python 3.8+
+- MySQL 5.7+ (optional, for DB features)
+- Git
 
-### 2. Configuration File
-The main configuration file is `config.yaml`, containing the following configuration items:
-- **reports**: Report generation configuration (HTML/Allure)
-- **log**: Logging configuration
-- **influxdb**: Performance data push configuration
-- **llm_connection**: LLM connection configuration
+### Installation
 
-### 3. Running Tests
-```bash
-# Run all tests
-pytest
+1. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
 
-# Run specific level tests
-pytest --stage=1                    # Run smoke tests
-pytest --stage=2+                   # Run feature and end-to-end tests
+2. **Configure database** (optional)
 
-# Run specific tag tests
-pytest --feature=performance        # Run performance-related tests
-pytest --platform=gpu               # Run GPU platform tests
-pytest --reliability=high           # Run high reliability tests
+   Edit `config.yaml`:
+   ```yaml
+    database:
+      backup: "results/"
+      host: "127.0.0.1"
+      port: 3306
+      name: "ucm_pytest"
+      user: "root"
+      password: "123456"
+      charset: "utf8mb4"
+   ```
 
-# Combined filtering
-pytest --stage=1 --feature=performance,accuracy  # Performance and accuracy tests in smoke tests
-```
+3. **Run tests**
+   ```bash
+   # Run all tests
+   pytest
+
+   # Run tests by tag
+   pytest --stage=1
+   pytest --feature=performance
+   ```
+
+## ⚙️ Configuration
 
-## Test Case Standards
+### config.yaml
+
+Full YAML-based config. Key sections:
+
+- **reports**: Report settings (HTML, timestamp, etc.)
+- **database**: MySQL connection details
+
+## 🧪 Test Examples
+
+### Basic functional test
 
-### Basic Structure
 ```python
+# suites/E2E/test_demo_performance.py
 import pytest
-import allure
-from common.config_utils import config_utils as config_instance
-
-class TestExample:
-    """Test example class"""
-
-    @pytest.mark.stage(2)
-    @pytest.mark.feature("performance")
-    @pytest.mark.platform("gpu")
-    def test_gpu_performance(self):
-        """Test GPU performance"""
-        # Arrange
-        test_data = config_instance.get_config("test_data")
-        
-        # Act & Assert
-        with allure.step("Execute GPU computation"):
-            result = perform_gpu_calculation(test_data)
-            assert result.is_valid
-            
-        # Collect performance data
-        from common.influxdb_utils import push_to_influx
-        push_to_influx("gpu_compute_time", result.duration, {
-            "test_name": "test_gpu_performance",
-            "platform": "gpu"
-        })
-```
 
-### Marking Usage Guidelines
+@pytest.fixture(scope="module", name="calc")
+def calculator():
+    return Calculator()
 
-#### 1. Level Markers (Required)
-```python
-@pytest.mark.stage(0)    # Unit tests
-@pytest.mark.stage(1)    # Smoke tests
-@pytest.mark.stage(2)    # Feature tests
-@pytest.mark.stage(3)    # End-to-end tests
-```
+@pytest.mark.feature("mark")
+class TestCalculator:
+    def test_add(self, calc):
+        assert calc.add(1, 2) == 3
 
-#### 2. Feature Markers (Recommended)
-```python
-@pytest.mark.feature("performance")     # Performance tests
-@pytest.mark.feature("accuracy")        # Accuracy tests
-@pytest.mark.feature("memory")          # Memory tests
+    def test_divide_by_zero(self, calc):
+        with pytest.raises(ZeroDivisionError):
+            calc.divide(6, 0)
 ```
 
-#### 3. Platform Markers (Optional)
-```python
-@pytest.mark.platform("gpu")            # GPU platform tests
-@pytest.mark.platform("npu")            # NPU platform tests
-@pytest.mark.platform("cpu")            # CPU platform tests
-```
+## 🏷️ Tagging System
 
-#### 4. Reliability Markers (Optional)
-```python
-@pytest.mark.reliability("high")        # High reliability tests
-@pytest.mark.reliability("medium")      # Medium reliability tests
-@pytest.mark.reliability("low")         # Low reliability tests
-```
+Multi-dimensional tags supported:
 
-## Allure Report Integration
+### Stage tags
+- `stage(0)`: Unit tests
+- `stage(1)`: Smoke tests
+- `stage(2)`: Regression tests
+- `stage(3)`: Release tests
 
-### 1. Basic Usage
-```python
-import allure
-
-@allure.feature('User Authentication')
-@allure.story('Login Function')
-def test_user_login():
-    """Test user login functionality"""
-    with allure.step("Enter username and password"):
-        login_page.enter_credentials("user", "pass")
-    
-    with allure.step("Click login button"):
-        login_page.click_login()
-    
-    with allure.step("Verify successful login"):
-        assert dashboard_page.is_displayed()
-        
-    # Add attachment
-    allure.attach("Screenshot data", name="Login Screenshot", 
-                  attachment_type=allure.attachment_type.PNG)
-```
+### Functional tags
+- `feature`: Module tag
+- `platform`: Platform tag (GPU/NPU)
+
+### Usage
+
+```bash
+# Run smoke tests and above
+pytest --stage=1+
+
+# Run by feature
+pytest --feature=performance
+pytest --feature=performance,reliability
 
-### 2. Report Configuration
-Configure Allure reports in `config.yaml`:
-```yaml
-reports:
-  allure:
-    enabled: true
-    html_enable: true
-    serve_mode: true          # Use dynamic server mode
-    serve_host: "localhost"
-    serve_port: 8081
-    directory: "allure-results"
+# Run by platform
+pytest --platform=gpu
 ```
 
-### 3. Report Viewing
-- **Static HTML Mode**: Automatically generates static HTML reports after test completion
-- **Dynamic Server Mode**: Starts Allure server, providing interactive report interface
+### HTML Reports
+
+Auto-generated timestamped HTML reports:
+- Location: `reports/pytest_YYYYMMDD_HHMMSS/report.html`
+- Detailed results, errors, timing
+- Customizable title & style
+
+### Database Storage
+
+If enabled, results are auto-saved to MySQL.  
+To add new record types, ask DB admin to create tables; otherwise only local files are used.
+
+Example:
+```python
+@pytest.mark.feature("capture")  # Must be top decorator
+@export_vars
+def test_capture_mix():
+    assert 1 == 1
+    return {
+        '_name': 'demo',
+        '_data': {
+            'length': 10086,            # single value
+            'accuracy': [0.1, 0.2, 0.3], # list
+            'loss': [0.1, 0.2, 0.3],     # list
+        }
+    }
+```
 
-## Performance Data Collection
+### Config Access
 
-### InfluxDB Integration
+Read settings easily:
 ```python
-from common.influxdb_utils import push_to_influx
-
-# Collect performance data in tests
-def test_performance_metrics():
-    start_time = time.time()
-    
-    # Execute test logic
-    result = perform_operation()
-    
-    # Push performance data to InfluxDB
-    push_to_influx("operation_duration", time.time() - start_time, {
-        "test_name": "test_performance_metrics",
-        "operation_type": "calculation",
-        "success": str(result.success)
-    })
+from common.config_utils import config_utils
+# Get config
+db_config = config_utils.get_config("database")
+api_config = config_utils.get_nested_config("easyPerf.api")
 ```
 
-## Extensions and Customization
+## 🛠️ Development Guide
 
-### Adding New Markers
-1. Add new marker definitions in the `markers` section of `pytest.ini`
-2. Keep the `markers =` and `# end of markers` lines unchanged
-3. Re-run tests to use new markers
+### Adding New Tests
 
-### Custom Configuration
-Customize through `config.yaml`:
-- Report format and storage location
-- Log level and output format
-- InfluxDB connection parameters
-- LLM service configuration
+1. Create test files under `suites/` categories
+2. Apply appropriate tags
+3. Naming: `test_*.py`
+4. Use fixtures & marks for data management
+5. Keep custom marks concise and aligned with overall goals