测试框架动态切换环境与用例

# configs/dev.yaml —— 开发环境配置
env: dev
base_url: http://localhost:8080
db:
  host: localhost
  port: 5432
  name: shop_dev
third_party:
  payment: mock         # DEV 走 mock，不发真实请求
  sms: mock
features:
  risk_control: false    # 关闭风控，便于调试

# configs/staging.yaml —— 预发环境配置
env: staging
base_url: https://api.stg.example.com
db:
  host: pg-stg.internal
  port: 5432
  name: shop_stg
third_party:
  payment: sandbox       # 沙箱网关
  sms: real
features:
  risk_control: true

# .env.staging —— 不进 Git，通过 Secret 注入
DB_PASSWORD=stg_s3cret
API_TOKEN=eyJhbGciOiJIUzI1NiJ9...

# 加载 .env 文件，按环境变量覆盖
from dotenv import load_dotenv
load_dotenv(".env.staging")  # 显式指定文件

# config.py —— 使用 pydantic-settings 加载多环境配置
from pydantic_settings import BaseSettings, SettingsConfigDict
from pydantic import Field, PostgresDsn
import yaml
 
class DBConfig(BaseSettings):
    host: str
    port: int = 5432
    name: str
    password: str = ""  # 从环境变量注入，不进 YAML
 
class AppConfig(BaseSettings):
    env: str = Field(default="dev", pattern="^(dev|staging|prod)$")
    base_url: str
    db: DBConfig
    payment_provider: str = "mock"
 
    model_config = SettingsConfigDict(
        env_file=".env",
        env_nested_delimiter="__",  # DB__HOST 形式支持嵌套
        extra="ignore",
    )
 
def load_config(env: str) -> AppConfig:
    """根据 env 名加载对应 YAML，再合并环境变量"""
    with open(f"configs/{env}.yaml", encoding="utf-8") as f:
        yaml_data = yaml.safe_load(f)
    # 环境变量优先级最高，会覆盖 YAML 中同名字段
    return AppConfig(**yaml_data)

# src/main/resources/application-staging.yml —— Spring Boot profile
spring:
  datasource:
    url: jdbc:postgresql://pg-stg.internal:5432/shop_stg
    username: stg_app
    password: ${DB_PASSWORD}   # 引用环境变量
  jpa:
    hibernate:
      ddl-auto: validate       # STG 不允许自动改表
payment:
  provider: sandbox
  api-key: ${PAYMENT_API_KEY}

// Spring Boot 测试中通过 @ActiveProfiles 激活 profile
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
 
@SpringBootTest
@ActiveProfiles("staging")  // 加载 application-staging.yml
class OrderServiceStagingIT {
    // 测试方法...
}

import org.springframework.test.context.DynamicPropertySource;
import org.springframework.test.context.DynamicPropertyRegistry;
 
@SpringBootTest
class OrderServiceDynamicIT {
 
    static PostgreSQLContainer<?> pg = new PostgreSQLContainer<>("postgres:16-alpine");
 
    static {
        pg.start();
    }
 
    // 运行时把容器随机端口注入到 Spring 配置
    @DynamicPropertySource
    static void props(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url",      pg::getJdbcUrl);
        registry.add("spring.datasource.username",  pg::getUsername);
        registry.add("spring.datasource.password",  pg::getPassword);
    }
}

# tests/conftest.py —— 注册 --env 参数并加载对应配置
import pytest
from config import load_config
 
def pytest_addoption(parser):
    """注册 --env 命令行参数，默认 dev"""
    parser.addoption(
        "--env", action="store", default="dev",
        choices=["dev", "staging", "prod"],
        help="目标测试环境：dev / staging / prod",
    )
 
@pytest.fixture(scope="session")
def app_config(request):
    """会话级配置 fixture，整个测试会话复用同一配置"""
    env = request.config.getoption("--env")
    return load_config(env)
 
@pytest.fixture(scope="session")
def base_url(app_config):
    return app_config.base_url

# 跑 DEV 环境用例
pytest --env=dev tests/
 
# 跑 STG 环境冒烟用例
pytest --env=staging -m smoke tests/

# tests/test_login.py —— 通过 fixture 注入环境配置
import pytest
 
@pytest.mark.smoke
def test_login_success(app_config, base_url):
    # app_config 是会话级 fixture，按 --env 自动路由
    user = app_config.test_users["default"]
    resp = requests.post(f"{base_url}/login", json=user)
    assert resp.status_code == 200

# tests/conftest.py —— 注册自定义 marker 并做环境一致性校验
import pytest
 
def pytest_configure(config):
    config.addinivalue_line("markers", "dev_only: 仅在 DEV 环境运行")
    config.addinivalue_line("markers", "staging_only: 仅在 STG 环境运行")
    config.addinivalue_line("markers", "prod_safe: 在 PROD 环境安全运行")
 
def pytest_collection_modifyitems(config, items):
    """收集阶段过滤：根据 --env 剔除不匹配的用例"""
    env = config.getoption("--env")
    skip = pytest.mark.skip(reason=f"当前环境 {env} 不匹配 marker 要求")
    for item in items:
        if "dev_only" in item.keywords and env != "dev":
            item.add_marker(skip)
        if "staging_only" in item.keywords and env != "staging":
            item.add_marker(skip)
        if "prod_safe" not in item.keywords and env == "prod":
            item.add_marker(skip)  # PROD 默认只跑 prod_safe 用例

# tests/test_user.py —— 用例侧显式声明环境绑定
import pytest
 
@pytest.mark.dev_only
def test_delete_user_cascade(app_config):
    """破坏性用例：仅 DEV 跑"""
    delete_user(app_config.test_users["temp"])
    assert get_user(...) is None
 
@pytest.mark.prod_safe
def test_search_product_returns_200(base_url):
    """只读用例：所有环境均可"""
    resp = requests.get(f"{base_url}/products?q=iphone")
    assert resp.status_code == 200

# tests/test_checkout.py —— mark 多重标记
import pytest
 
@pytest.mark.smoke
@pytest.mark.regression
def test_checkout_happy_path():
    ...
 
@pytest.mark.regression
@pytest.mark.slow
def test_checkout_full_refund_flow():
    ...

# 只跑冒烟用例
pytest -m smoke
 
# 跑除 slow 外的所有回归用例
pytest -m "regression and not slow"

# 跑所有名字含 login 的用例
pytest -k "login"
 
# 跑 login 或 register，但排除 failure 用例
pytest -k "(login or register) and not failure"

import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;
 
@Tag("smoke")
class LoginTest {
 
    @Test
    @Tag("regression")
    void testLoginSuccess() { ... }
 
    @Test
    @Tag("slow")
    void testLoginWithRetries() { ... }
}

<!-- pom.xml —— JUnit 5 按 tag 筛选 -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <groups>smoke | regression</groups>          <!-- 包含的 tag -->
        <excludedGroups>slow</excludedGroups>         <!-- 排除的 tag -->
    </configuration>
</plugin>

# docker-compose.staging.yml —— STG 环境编排
services:
  app:
    image: registry.example.com/shop:${TAG:-latest}
    environment:
      - SPRING_PROFILES_ACTIVE=staging
      - DB_PASSWORD=${DB_PASSWORD}
    depends_on:
      - postgres
  postgres:
    image: postgres:16-alpine
    environment:
      - POSTGRES_DB=shop_stg
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    volumes:
      - pg-stg-data:/var/lib/postgresql/data
volumes:
  pg-stg-data:

# 启动 STG 编排
docker compose -f docker-compose.staging.yml up -d

# tests/conftest.py —— Testcontainers 提供测试级 DB 隔离
import pytest
from testcontainers.postgres import PostgresContainer
 
@pytest.fixture(scope="session")
def pg_container(app_config):
    """会话级启动 PostgreSQL 容器，会话结束自动销毁"""
    if app_config.env == "dev":
        # DEV 环境用一次性容器，避免污染本地 DB
        with PostgresContainer("postgres:16-alpine") as pg:
            yield pg
    else:
        # STG / PROD 环境使用已有 DB，不启动容器
        yield app_config.db

# 创建测试专用 Namespace
kubectl create ns test-staging
kubectl apply -f deploy/ -n test-staging
 
# 跑完销毁，资源级联回收
kubectl delete ns test-staging

# gitops/environments/staging/values.yaml —— GitOps 中的环境声明
env: staging
replicas: 2
image:
  tag: v1.4.2
config:
  db_host: pg-stg.internal
  features:
    risk_control: true
secrets:
  ref: staging-secrets   # 引用 K8s Secret，不直接存储

# k8s/configmap-staging.yaml —— ConfigMap 示例
apiVersion: v1
kind: ConfigMap
metadata:
  name: test-config
  namespace: test-staging
data:
  ENV: staging
  BASE_URL: https://api.stg.example.com
  DB_HOST: pg-stg.internal
---
# k8s/secret-staging.yaml —— Secret 示例
apiVersion: v1
kind: Secret
metadata:
  name: test-secrets
  namespace: test-staging
type: Opaque
stringData:
  DB_PASSWORD: stg_s3cret
  API_TOKEN: eyJhbGciOiJIUzI1NiJ9...

# tests/test_checkout.py —— Feature Flag 驱动用例行为
import pytest
from flag_client import is_enabled  # 封装 LaunchDarkly / Unleash
 
@pytest.mark.regression
def test_checkout(app_config):
    if is_enabled("new_payment_flow", default=False):
        # flag 启用时走新支付链路
        resp = checkout_v2(app_config.test_order)
    else:
        resp = checkout_v1(app_config.test_order)
    assert resp.status_code == 200