Configuración de Entorno de Pruebas: Guía Completa

# dev-environment.yml
environment: development

database:
  host: localhost
  port: 5432
  name: myapp_dev
  user: dev_user

cache:
  provider: redis
  host: localhost
  port: 6379

api:
  base_url: http://localhost:3000
  debug_mode: true
  log_level: DEBUG

features:
  email_service: mock  # No enviar emails reales
  payment_gateway: sandbox
  cdn: local_storage

monitoring:
  enabled: false  # Sin monitoreo en dev

# qa-environment.yml
environment: qa

database (como se discute en [Continuous Testing in DevOps: Quality Gates and CI/CD Integration](/es/blog/continuous-testing-devops)):
  host: qa-db.internal.company.com
  port: 5432
  name: myapp_qa
  user: qa_user
  pool_size: 10

cache:
  provider: redis
 (como se discute en [Grey Box Testing: Best of Both Worlds](/es/blog/grey-box-testing))  host: qa-redis.internal.company.com
  port: 6379
  cluster: true

api:
  base_url: https://qa.myapp.com
  debug_mode: false
  log_level: INFO

features:
  email_service: mailtrap  # Servicio de prueba de email
  payment_gateway: stripe_test
  cdn: qa_cdn

monitoring (como se discute en [Risk-Based Testing: Prioritizing Test Efforts for Maximum Impact](/es/blog/risk-based-testing)):
  enabled: true
  service: datadog
  alerts: qa-team@company.com

performance:
  rate_limit: 1000_per_minute
  max_connections: 100

test_data:
  auto_refresh: daily
  anonymized: true

# Infraestructura como Código (Terraform)
# terraform/qa-environment.tf

# Configuración VPC
resource "aws_vpc" "qa_vpc" {
  cidr_block = "10.0.0.0/16"

  tags = {
    Name = "qa-vpc"
    Environment = "qa"
  }
}

# Subnet
resource "aws_subnet" "qa_subnet" {
  vpc_id     = aws_vpc.qa_vpc.id
  cidr_block = "10.0.1.0/24"

  tags = {
    Name = "qa-subnet"
  }
}

# Grupo de Seguridad
resource "aws_security_group" "qa_sg" {
  name        = "qa-security-group"
  description = "Grupo de seguridad de entorno QA"
  vpc_id      = aws_vpc.qa_vpc.id

  # Permitir HTTP desde cualquier lugar
  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  # Permitir HTTPS desde cualquier lugar
  ingress {
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  # Permitir SSH solo desde red de empresa
  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["203.0.113.0/24"]  # Rango IP de empresa
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

# Docker Compose para Entorno QA
# docker-compose.qa.yml

version: '3.8'

services:
  # Servidor de Aplicación
  app:
    image: myapp:qa-latest
    container_name: qa-app
    ports:

      - "3000:3000"
    environment:

      - NODE_ENV=qa
      - DATABASE_URL=postgresql://qa_user:${DB_PASSWORD}@qa-db:5432/myapp_qa
      - REDIS_URL=redis://qa-redis:6379
      - API_KEY=${API_KEY}
      - SECRET_KEY=${SECRET_KEY}
    depends_on:

      - db
      - redis
    networks:

      - qa-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Base de Datos
  db:
    image: postgres:13
    container_name: qa-db
    environment:

      - POSTGRES_DB=myapp_qa
      - POSTGRES_USER=qa_user
      - POSTGRES_PASSWORD=${DB_PASSWORD}
    volumes:

      - qa-db-data:/var/lib/postgresql/data
      - ./init-scripts:/docker-entrypoint-initdb.d
    ports:

      - "5432:5432"
    networks:

      - qa-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U qa_user"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Redis Cache
  redis:
    image: redis:6-alpine
    container_name: qa-redis
    ports:

      - "6379:6379"
    networks:

      - qa-network
    volumes:

      - qa-redis-data:/data
    command: redis-server --appendonly yes

volumes:
  qa-db-data:
  qa-redis-data:

networks:
  qa-network:
    driver: bridge

# test_data_manager.py
import psycopg2
from faker import Faker
import random

class TestDataManager:
    """Gestionar datos de prueba para entorno QA"""

    def __init__(self, db_connection_string):
        self.conn = psycopg2.connect(db_connection_string)
        self.fake = Faker('es_ES')  # Español

    def reset_database(self):
        """Restablecer base de datos a estado limpio"""
        with self.conn.cursor() as cursor:
            # Limpiar todas las tablas (respetando claves foráneas)
            cursor.execute("""
                TRUNCATE TABLE
                    orders,
                    order_items,
                    products,
                    users,
                    addresses
                CASCADE
            """)
            self.conn.commit()
            print("Restablecimiento de base de datos completo")

    def seed_users(self, count=100):
        """Crear usuarios de prueba"""
        with self.conn.cursor() as cursor:
            users = []
            for _ in range(count):
                user = {
                    'email': self.fake.email(),
                    'first_name': self.fake.first_name(),
                    'last_name': self.fake.last_name(),
                    'password_hash': '$2b$10$EIXexample',  # Contraseña pre-hasheada
                    'created_at': self.fake.date_time_between(start_date='-1y')
                }
                users.append(user)

                cursor.execute("""
                    INSERT INTO users (email, first_name, last_name, password_hash, created_at)
                    VALUES (%(email)s, %(first_name)s, %(last_name)s, %(password_hash)s, %(created_at)s)
                """, user)

            self.conn.commit()
            print(f"Creados {count} usuarios de prueba")

    def create_known_test_accounts(self):
        """Crear cuentas de prueba conocidas para pruebas manuales"""
        test_accounts = [
            {
                'email': 'usuario.prueba@example.com',
                'password': 'Prueba123!',
                'first_name': 'Usuario',
                'last_name': 'Prueba',
                'role': 'user'
            },
            {
                'email': 'admin@example.com',
                'password': 'Admin123!',
                'first_name': 'Admin',
                'last_name': 'Usuario',
                'role': 'admin'
            }
        ]

        with self.conn.cursor() as cursor:
            for account in test_accounts:
                cursor.execute("""
                    INSERT INTO users (email, password_hash, first_name, last_name, role)
                    VALUES (%s, %s, %s, %s, %s)
                    ON CONFLICT (email) DO UPDATE
                    SET password_hash = EXCLUDED.password_hash
                """, (
                    account['email'],
                    '$2b$10$EIXexample',  # Contraseña pre-hasheada
                    account['first_name'],
                    account['last_name'],
                    account['role']
                ))

            self.conn.commit()
            print("Creadas cuentas de prueba conocidas")

    def refresh_test_data(self):
        """Actualización completa de datos de prueba"""
        print("Iniciando actualización de datos de prueba...")
        self.reset_database()
        self.create_known_test_accounts()
        self.seed_users(100)
        print("¡Actualización de datos de prueba completa!")

# config.py - Configuración específica de entorno

import os
from enum import Enum

class Environment(Enum):
    DEVELOPMENT = "development"
    QA = "qa"
    STAGING = "staging"
    PRODUCTION = "production"

class Config:
    """Configuración base"""
    SECRET_KEY = os.getenv('SECRET_KEY')
    DATABASE_URL = os.getenv('DATABASE_URL')
    REDIS_URL = os.getenv('REDIS_URL')

class QAConfig(Config):
    """Configuración de entorno QA"""
    DEBUG = False
    LOG_LEVEL = "INFO"

    # Usar servicios de prueba
    EMAIL_BACKEND = "mailtrap"
    PAYMENT_GATEWAY = "stripe_test"

    # Configuraciones específicas de QA
    ALLOWED_HOSTS = ["qa.myapp.com"]
    CORS_ORIGINS = ["https://qa.myapp.com"]

    # Actualización de datos de prueba
    AUTO_REFRESH_TEST_DATA = True
    TEST_DATA_REFRESH_TIME = "03:00"  # 3 AM diario

# Dockerfile para entorno de pruebas

FROM python:3.9-slim

WORKDIR /app

# Instalar dependencias del sistema
RUN apt-get update && apt-get install -y \
    postgresql-client \
    redis-tools \
    curl \
    && rm -rf /var/lib/apt/lists/*

# Instalar dependencias de Python
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copiar código de aplicación
COPY . .

# Crear usuario sin privilegios
RUN useradd -m -u 1000 appuser && \
    chown -R appuser:appuser /app

USER appuser

# Health check
HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
    CMD curl -f http://localhost:3000/health || exit 1

EXPOSE 3000

CMD ["python", "app.py"]

# Lista de Verificación de Aislamiento de Entorno

✓ Infraestructura separada (VPCs, redes)
✓ Bases de datos separadas (sin instancias DB compartidas)
✓ Credenciales separadas (contraseñas únicas, claves API)
✓ Monitoreo separado (alertas específicas de entorno)
✓ Segmentación de red (firewalls, grupos de seguridad)
✓ Control de acceso (permisos basados en roles)

# Usar variables de entorno para configuración
# .env.qa

# Base de Datos
DATABASE_HOST=qa-db.internal.company.com
DATABASE_PORT=5432
DATABASE_NAME=myapp_qa
DATABASE_USER=qa_user
DATABASE_PASSWORD=${SECRET_DB_PASSWORD}

# Redis
REDIS_HOST=qa-redis.internal.company.com
REDIS_PORT=6379

# Claves API (modo prueba)
STRIPE_API_KEY=sk_test_xxxxx
SENDGRID_API_KEY=SG.test.xxxxx

# Feature Flags
FEATURE_NEW_CHECKOUT=true
FEATURE_AI_RECOMMENDATIONS=false

#!/bin/bash
# setup-qa-environment.sh

set -e

echo "Configurando entorno QA..."

# 1. Aprovisionar infraestructura
echo "Aprovisionando infraestructura..."
cd terraform
terraform init
terraform apply -auto-approve

# 2. Desplegar aplicación
echo "Desplegando aplicación..."
cd ../
docker-compose -f docker-compose.qa.yml up -d

# 3. Esperar a que los servicios estén saludables
echo "Esperando servicios..."
./wait-for-services.sh

# 4. Ejecutar migraciones de base de datos
echo "Ejecutando migraciones..."
docker-compose -f docker-compose.qa.yml exec app python manage.py migrate

# 5. Cargar datos de prueba
echo "Cargando datos de prueba..."
docker-compose -f docker-compose.qa.yml exec app python seed_data.py

echo "¡Configuración de entorno QA completa!"
echo "Acceso en: https://qa.myapp.com"

# environment_health_check.py

import requests
import psycopg2
import redis

class EnvironmentHealthCheck:
    """Monitorear salud del entorno de pruebas"""

    def __init__(self, config):
        self.config = config
        self.results = []

    def check_application(self):
        """Verificar si la aplicación está respondiendo"""
        try:
            response = requests.get(f"{self.config['app_url']}/health", timeout=5)
            if response.status_code == 200:
                self.results.append(("Aplicación", "✓ Saludable"))
            else:
                self.results.append(("Aplicación", f"✗ No saludable (Estado: {response.status_code})"))
        except Exception as e:
            self.results.append(("Aplicación", f"✗ Caída ({str(e)})"))

    def check_database(self):
        """Verificar conectividad de base de datos"""
        try:
            conn = psycopg2.connect(self.config['database_url'])
            with conn.cursor() as cursor:
                cursor.execute("SELECT 1")
                result = cursor.fetchone()
                if result:
                    self.results.append(("Base de Datos", "✓ Saludable"))
            conn.close()
        except Exception as e:
            self.results.append(("Base de Datos", f"✗ Caída ({str(e)})"))

    def run_all_checks(self):
        """Ejecutar todas las verificaciones de salud"""
        print("Verificación de Salud del Entorno")
        print("=" * 50)

        self.check_application()
        self.check_database()

        for service, status in self.results:
            print(f"{service:.<30} {status}")

        print("=" * 50)

        return all("✓" in status for _, status in self.results)