RPA-Python与pytest-rancher集成：10步实现Rancher测试自动化完整指南

吴发崧

1103人浏览 · 2026-03-27 07:34:06

吴发崧 · 2026-03-27 07:34:06 发布

RPA-Python与pytest-rancher集成：10步实现Rancher测试自动化完整指南

【免费下载链接】RPA-Python Python package for doing RPA 项目地址: https://gitcode.com/gh_mirrors/rp/RPA-Python

想要彻底告别手动测试Rancher容器平台配置的繁琐工作吗？RPA-Python与pytest-rancher的完美结合，让容器平台测试自动化变得前所未有的简单！无论你是DevOps工程师、云原生开发者还是测试工程师，这个强大的自动化组合都能将你从重复性测试任务中解放出来，让你专注于真正重要的容器编排和微服务架构设计。

RPA-Python是一个功能强大的Python机器人流程自动化包，通过简单的pip install rpa即可安装使用。它提供了网页自动化、视觉识别、键盘鼠标控制等全方位自动化能力。当与pytest-rancher结合时，你可以创建智能的Rancher平台测试框架，实现集群配置验证、应用部署测试、监控告警检查等操作的完全自动化测试。

🚀 为什么需要RPA-Python与Rancher测试自动化？

在现代云原生开发中，Rancher作为领先的Kubernetes管理平台，被广泛应用于企业级容器编排。然而，测试Rancher配置通常需要：

集群配置验证：Kubernetes集群状态和配置检查
应用部署测试：容器化应用的部署和升级验证
监控告警检查：Prometheus和Grafana监控系统测试
安全策略测试：RBAC和网络策略验证
集成测试：与CI/CD流水线的端到端测试

RPA-Python通过其简洁的API，可以轻松实现这些测试任务的自动化，而pytest-rancher提供了专业的Rancher测试夹具，两者结合可以大幅提升测试效率和覆盖率。

🔧 快速开始：环境配置与安装

安装必要依赖

首先，确保你的Python环境已准备就绪，然后安装RPA-Python和pytest-rancher：

# 安装RPA-Python核心包
pip install rpa

# 安装pytest-rancher及相关测试工具
pip install pytest pytest-rancher kubernetes rancher-client

# 安装可选但推荐的测试增强工具
pip install pytest-html pytest-xdist pytest-cov pytest-docker

基础项目结构

创建以下项目结构来组织你的测试代码：

rancher_rpa_tests/
├── tests/
│   ├── __init__.py
│   ├── conftest.py
│   ├── test_rancher_basic.py
│   ├── test_rancher_cluster.py
│   └── test_rancher_apps.py
├── config/
│   └── rancher_config.yaml
├── requirements.txt
└── pytest.ini

📊 pytest-rancher基础配置

在conftest.py中配置pytest-rancher：

# tests/conftest.py
import pytest
import yaml
from rancher import Client
from kubernetes import client, config

@pytest.fixture(scope="session")
def rancher_client():
    """Rancher客户端会话级夹具"""
    # 从配置文件加载Rancher配置
    with open('config/rancher_config.yaml') as f:
        rancher_config = yaml.safe_load(f)
    
    # 创建Rancher客户端
    rancher = Client(
        url=rancher_config['url'],
        access_key=rancher_config['access_key'],
        secret_key=rancher_config['secret_key'],
        verify=rancher_config.get('verify_ssl', True)
    )
    yield rancher

@pytest.fixture(scope="session")
def kubernetes_client(rancher_client):
    """Kubernetes客户端夹具"""
    # 加载kubeconfig
    config.load_kube_config()
    
    # 创建Kubernetes客户端
    k8s_client = client.CoreV1Api()
    yield k8s_client

@pytest.fixture
def test_cluster(rancher_client):
    """测试集群夹具"""
    # 获取或创建测试集群
    cluster_name = "test-rpa-cluster"
    clusters = rancher_client.list_cluster(name=cluster_name)
    
    if clusters.data:
        cluster = clusters.data[0]
    else:
        # 创建测试集群（这里简化，实际需要完整配置）
        cluster = rancher_client.create_cluster(
            name=cluster_name,
            description="RPA-Python测试集群"
        )
    
    yield cluster
    
    # 测试后清理（可选）
    # rancher_client.delete(cluster)

🔧 RPA-Python与Rancher测试集成实战

场景1：自动化集群状态验证

# tests/test_rancher_basic.py
import pytest
import rpa as r
import time

def test_rancher_cluster_health(rancher_client):
    """测试Rancher集群健康状态"""
    
    # 初始化RPA-Python
    r.init()
    
    try:
        # 1. 登录Rancher Web界面
        r.url(rancher_client._base_url)
        r.wait(5)
        
        # 2. 输入凭据（实际使用中应该使用环境变量或安全存储）
        r.type('//input[@placeholder="用户名或邮箱"]', 'admin')
        r.type('//input[@type="password"]', 'password[enter]')
        r.wait(3)
        
        # 3. 导航到集群管理页面
        r.click('//span[contains(text(), "集群管理")]')
        r.wait(2)
        
        # 4. 验证集群状态
        cluster_status = r.read('//div[contains(@class, "cluster-state")]')
        assert "Active" in cluster_status or "运行中" in cluster_status
        
        # 5. 检查节点状态
        r.click('//a[contains(text(), "节点")]')
        r.wait(2)
        
        node_count_text = r.read('//div[contains(@class, "node-count")]')
        print(f"📊 集群节点状态: {node_count_text}")
        
        # 6. 使用API验证集群健康
        clusters = rancher_client.list_cluster()
        assert len(clusters.data) > 0
        
        for cluster in clusters.data:
            print(f"✅ 集群 '{cluster.name}' 状态: {cluster.state}")
            assert cluster.state == "active"
        
        print("✅ 所有集群健康检查通过")
        
    finally:
        # 清理RPA会话
        r.close()

场景2：应用部署端到端测试

# tests/test_rancher_apps.py
import pytest
import rpa as r
import yaml
from kubernetes import client, utils

class TestRancherAppDeployment:
    """Rancher应用部署测试场景"""
    
    @pytest.fixture(autouse=True)
    def setup_teardown(self, kubernetes_client):
        """每个测试前后的设置和清理"""
        self.k8s_client = kubernetes_client
        self.namespace = "rpa-test-namespace"
        
        # 创建测试命名空间
        namespace_manifest = {
            "apiVersion": "v1",
            "kind": "Namespace",
            "metadata": {
                "name": self.namespace
            }
        }
        
        self.k8s_client.create_namespace(
            client.V1Namespace(**namespace_manifest)
        )
        
        yield
        
        # 测试后清理命名空间
        try:
            self.k8s_client.delete_namespace(self.namespace)
        except:
            pass
    
    def test_nginx_deployment_workflow(self, rancher_client):
        """Nginx部署端到端工作流测试"""
        r.init()
        
        try:
            # 步骤1: 通过Rancher UI部署应用
            r.url(f"{rancher_client._base_url}/apps")
            r.wait(3)
            
            # 点击部署应用按钮
            r.click('//button[contains(text(), "部署")]')
            r.wait(2)
            
            # 输入应用名称
            r.type('//input[@placeholder="应用名称"]', 'rpa-nginx-test')
            
            # 选择命名空间
            r.click('//select[@name="namespace"]')
            r.type('//select[@name="namespace"]', self.namespace + '[enter]')
            
            # 输入Docker镜像
            r.type('//input[@placeholder="Docker镜像"]', 'nginx:latest')
            
            # 设置端口
            r.type('//input[@placeholder="容器端口"]', '80')
            r.type('//input[@placeholder="服务端口"]', '8080')
            
            # 点击部署
            r.click('//button[contains(text(), "创建")]')
            r.wait(10)  # 等待部署完成
            
            # 步骤2: 验证部署状态
            deployments = self.k8s_client.list_namespaced_deployment(
                namespace=self.namespace
            )
            
            nginx_deployment = None
            for deploy in deployments.items:
                if deploy.metadata.name == 'rpa-nginx-test':
                    nginx_deployment = deploy
                    break
            
            assert nginx_deployment is not None
            assert nginx_deployment.status.ready_replicas == 1
            
            # 步骤3: 通过RPA验证Web界面
            r.url(f"{rancher_client._base_url}/k8s/clusters/local/api/v1/namespaces/{self.namespace}/services")
            r.wait(3)
            
            # 查找nginx服务
            service_info = r.read('//table[@class="service-table"]')
            assert "rpa-nginx-test" in service_info
            
            print("✅ Nginx应用部署测试通过")
            
        finally:
            r.close()

🎯 高级测试模式与最佳实践

1. 多集群测试模式

import pytest
import rpa as r

@pytest.mark.parametrize("cluster_config", [
    {"name": "dev-cluster", "node_count": 3, "k8s_version": "v1.24"},
    {"name": "staging-cluster", "node_count": 5, "k8s_version": "v1.25"},
    {"name": "prod-cluster", "node_count": 10, "k8s_version": "v1.26"},
])
def test_multi_cluster_validation(rancher_client, cluster_config):
    """多集群配置验证测试"""
    r.init()
    
    try:
        # 导航到集群列表
        r.url(f"{rancher_client._base_url}/clusters")
        r.wait(3)
        
        # 搜索特定集群
        r.type('//input[@placeholder="搜索集群"]', cluster_config['name'] + '[enter]')
        r.wait(2)
        
        # 验证集群信息
        cluster_row = r.read(f'//tr[contains(., "{cluster_config["name"]}")]')
        
        assert cluster_config['name'] in cluster_row
        
        # 点击查看详情
        r.click(f'//tr[contains(., "{cluster_config["name"]}")]//button[contains(text(), "查看")]')
        r.wait(2)
        
        # 验证Kubernetes版本
        k8s_version = r.read('//div[contains(@class, "k8s-version")]')
        assert cluster_config['k8s_version'] in k8s_version
        
        # 验证节点数量
        node_info = r.read('//div[contains(@class, "node-info")]')
        assert str(cluster_config['node_count']) in node_info
        
    finally:
        r.close()

2. 性能与压力测试

import pytest
import rpa as r
import time
import concurrent.futures

def test_rancher_api_performance(rancher_client):
    """Rancher API性能测试"""
    
    r.init()
    
    try:
        # 测试API响应时间
        start_time = time.time()
        
        # 同时执行多个API操作
        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
            futures = []
            
            # 并行获取不同类型资源
            futures.append(executor.submit(
                lambda: rancher_client.list_cluster()
            ))
            futures.append(executor.submit(
                lambda: rancher_client.list_project()
            ))
            futures.append(executor.submit(
                lambda: rancher_client.list_user()
            ))
            
            # 等待所有任务完成
            results = []
            for future in concurrent.futures.as_completed(futures):
                results.append(future.result())
        
        end_time = time.time()
        total_time = end_time - start_time
        
        print(f"⏱️  API并发测试完成时间: {total_time:.2f}秒")
        
        # 通过RPA验证Web界面响应
        r.url(f"{rancher_client._base_url}/dashboard")
        r.wait(2)
        
        page_load_start = time.time()
        page_content = r.read('page')
        page_load_end = time.time()
        
        page_load_time = page_load_end - page_load_start
        print(f"🌐 页面加载时间: {page_load_time:.2f}秒")
        
        # 性能断言
        assert total_time < 10.0, f"API响应时间过长: {total_time:.2f}秒"
        assert page_load_time < 5.0, f"页面加载时间过长: {page_load_time:.2f}秒"
        
    finally:
        r.close()

🔧 配置文件与测试优化

pytest.ini配置

[pytest]
testpaths = tests
python_files = test_*.py
python_classes = Test*
python_functions = test_*
addopts =
    --tb=short
    --strict-markers
    --html=rancher_test_report.html
    --self-contained-html
    -v
    -n auto
markers =
    slow: marks tests as slow (deselect with '-m "not slow"')
    rancher: marks tests that require Rancher
    rpa: marks tests that use RPA-Python
    cluster: marks tests that create/destroy clusters

rancher_config.yaml配置

# Rancher测试配置
rancher:
  url: "https://rancher.example.com"
  access_key: "${RANCHER_ACCESS_KEY}"
  secret_key: "${RANCHER_SECRET_KEY}"
  verify_ssl: true

clusters:
  test_cluster:
    name: "rpa-test-cluster"
    provider: "custom"
    kubernetes_version: "v1.25.0"
    nodes:
      - address: "192.168.1.100"
        user: "root"
        role: ["controlplane", "etcd", "worker"]

test_settings:
  timeout: 300
  retry_attempts: 3
  cleanup_after_test: true

📈 测试报告与监控

生成HTML测试报告

# 运行测试并生成报告
pytest tests/ --html=rancher_test_report.html --self-contained-html

# 生成覆盖率报告
pytest tests/ --cov=. --cov-report=html --cov-report=xml

# 运行特定标记的测试
pytest tests/ -m "rancher and not slow" --html=fast_tests.html

集成CI/CD流程

# .github/workflows/rancher-tests.yml
name: Rancher RPA Tests

on: [push, pull_request]

jobs:
  rancher-tests:
    runs-on: ubuntu-latest
    
    services:
      rancher:
        image: rancher/rancher:latest
        ports:
          - 8080:80
          - 8443:443
        env:
          CATTLE_BOOTSTRAP_PASSWORD: admin
    
    steps:
    - uses: actions/checkout@v2
    
    - name: Set up Python
      uses: actions/setup-python@v2
      with:
        python-version: '3.9'
    
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    
    - name: Wait for Rancher
      run: |
        echo "等待Rancher启动..."
        sleep 60
    
    - name: Run Rancher RPA tests
      run: |
        pytest tests/ \
          --html=rancher_test_report.html \
          --self-contained-html \
          --cov=. \
          --cov-report=xml
    
    - name: Upload test report
      uses: actions/upload-artifact@v2
      with:
        name: rancher-test-report
        path: |
          rancher_test_report.html
          coverage.xml

🚨 常见问题与解决方案

问题1: Rancher API连接失败

解决方案: 检查网络连接和认证信息

# 增加连接超时和重试机制
import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

session = requests.Session()
retry_strategy = Retry(
    total=3,
    backoff_factor=1,
    status_forcelist=[429, 500, 502, 503, 504]
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)
session.mount("http://", adapter)

问题2: RPA-Python视觉自动化问题

解决方案: 确保正确配置视觉自动化模式

# 使用视觉自动化模式
r.init(visual_automation=True)

# 或者使用headless模式避免UI问题
r.init(chrome_browser=False)

问题3: 测试数据清理不彻底

解决方案: 实现可靠的清理机制

@pytest.fixture
def clean_test_environment(rancher_client):
    """确保测试环境清理"""
    test_resources = []
    
    yield test_resources
    
    # 测试后清理所有资源
    for resource in test_resources:
        try:
            rancher_client.delete(resource)
        except:
            pass