/\
                     /  \
                    /    \
                   / E2E  \          Minutos a horas
                  /  Tests \         Costo: Alto
                 /──────────\
                /Integration \       Minutos
               /    Tests    \       Costo: Medio-Alto
              /────────────────\
             /   Unit Tests     \    Segundos a minutos
            / (terraform test)  \    Costo: Bajo
           /────────────────────\
          /   Static Analysis    \   Milisegundos
         / (fmt, validate, lint) \   Costo: Muy bajo
        /──────────────────────────\

# Formatear todos los archivos .tf del directorio actual y subdirectorios
terraform fmt -recursive

# Solo verificar si hay archivos que necesitan formato (útil en CI/CD)
# Devuelve código de salida 0 si todo está formateado, 1 si hay cambios pendientes
terraform fmt -check -recursive

# Ver qué cambios haría sin aplicarlos (modo diff)
terraform fmt -diff -check

# Ejemplo de output cuando hay problemas de formato:
# variables.tf
# main.tf
# (devuelve código 1, lo que hace fallar el pipeline de CI)

# ANTES de terraform fmt (formato incorrecto):
resource "aws_instance" "web" {
ami="ami-0c55b159cbfafe1f0"
  instance_type    =   "t3.micro"
tags={Name="mi-instancia",Environment="dev"}
}

# DESPUÉS de terraform fmt (formato correcto):
resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t3.micro"
  tags = {
    Name        = "mi-instancia"
    Environment = "dev"
  }
}

# Ejecutar validación en el directorio actual
terraform validate

# Output exitoso:
# Success! The configuration is valid.

# Output con error:
# ╷
# │ Error: Reference to undeclared resource
# │
# │   on main.tf line 15, in resource "aws_instance" "web":
# │    15:   subnet_id = aws_subnet.public.id
# │
# │ A managed resource "aws_subnet" "public" has not been declared in the root module.
# ╵

# IMPORTANTE: terraform validate necesita que se haya ejecutado "terraform init" primero
terraform init -backend=false  # Inicializar sin configurar el backend (útil en CI)
terraform validate

# Instalación
brew install tflint  # macOS
# o usando el instalador oficial:
curl -s https://raw.githubusercontent.com/terraform-linters/tflint/master/install_linux.sh | bash

# Inicializar tflint con los plugins necesarios
tflint --init

# Ejecutar tflint
tflint

# Ejecutar de forma recursiva en subdirectorios
tflint --recursive

# .tflint.hcl - Archivo de configuración de tflint

config {
  # Habilitar el plugin de AWS para reglas específicas de ese proveedor
  plugin "aws" {
    enabled = true
    version = "0.27.0"
    source  = "github.com/terraform-linters/tflint-ruleset-aws"
  }
}

# Regla: tipos de instancia EC2 inválidos
rule "aws_instance_invalid_type" {
  enabled = true
}

# Regla: AMIs deprecadas o incorrectas
rule "aws_instance_invalid_ami" {
  enabled = true
}

# Regla: variables sin descripción
rule "terraform_documented_variables" {
  enabled = true
}

# Regla: outputs sin descripción
rule "terraform_documented_outputs" {
  enabled = true
}

# Regla: nombres de recursos que no siguen snake_case
rule "terraform_naming_convention" {
  enabled = true

  resource {
    format = "snake_case"
  }

  variable {
    format = "snake_case"
  }

  output {
    format = "snake_case"
  }
}

# Output de tflint cuando encuentra un problema:
# 2 issue(s) found:
#
# Warning: "t2.micro" is previous generation instance type. (aws_instance_invalid_type)
#
#   on main.tf line 5:
#    5:   instance_type = "t2.micro"
#
# Notice: `description` attribute is required (terraform_documented_variables)
#
#   on variables.tf line 1:
#    1: variable "region" {

# Instalación
pip install checkov

# Escanear el directorio actual
checkov -d .

# Escanear y generar reporte en formato JUnit (para CI/CD)
checkov -d . --output junitxml > checkov-report.xml

# Escanear y exportar en múltiples formatos
checkov -d . --output cli --output json --output-file-path .

# Omitir checks específicos (cuando hay falsos positivos o excepciones documentadas)
checkov -d . --skip-check CKV_AWS_79,CKV_AWS_8

# Ejemplo de output de checkov:
# Passed checks: 15, Failed checks: 3, Skipped checks: 0

# Check: CKV_AWS_79: "Ensure Instance Metadata Service Version 1 is not enabled"
# FAILED for resource: aws_instance.web_server
# File: /main.tf:10-25

# Check: CKV_AWS_8: "Ensure all data stored in the Launch configuration or instance is securely encrypted"
# FAILED for resource: aws_instance.web_server
# File: /main.tf:10-25

# Check: CKV_AWS_20: "S3 Bucket has an ACL defined which allows public READ access"
# FAILED for resource: aws_s3_bucket.public_assets
# File: /storage.tf:5-15

# ANTES (inseguro - falla checkov):
resource "aws_instance" "web_server" {
  ami           = data.aws_ami.amazon_linux_2.id
  instance_type = "t3.micro"
  # Sin cifrado de volumen raíz
  # Sin deshabilitar IMDSv1
}

# DESPUÉS (seguro - pasa checkov):
resource "aws_instance" "web_server" {
  ami           = data.aws_ami.amazon_linux_2.id
  instance_type = "t3.micro"

  # Deshabilitar IMDSv1 (solo permitir IMDSv2)
  metadata_options {
    http_endpoint               = "enabled"
    http_tokens                 = "required"  # Requiere IMDSv2
    http_put_response_hop_limit = 1           # Limita el alcance del token
  }

  # Cifrar el volumen raíz
  root_block_device {
    encrypted   = true          # Cifrado con la clave por defecto de AWS KMS
    volume_type = "gp3"         # Tipo de volumen moderno y eficiente
    volume_size = 20            # Tamaño en GB
  }
}

# Instalación
brew install terrascan  # macOS
# o descarga desde: https://github.com/tenable/terrascan/releases

# Escanear el directorio actual con las reglas de AWS
terrascan scan -t aws

# Escanear con reglas de múltiples proveedores
terrascan scan -t aws -t k8s

# Escanear en formato JSON para integración con CI/CD
terrascan scan -t aws -o json

# Ver todas las políticas disponibles
terrascan list policies -t aws

mi-modulo/
├── main.tf
├── variables.tf
├── outputs.tf
└── tests/
    ├── unit_tests.tftest.hcl
    └── integration_tests.tftest.hcl

# Ejecutar todos los archivos .tftest.hcl en el directorio actual
terraform test

# Ejecutar solo un archivo de prueba específico
terraform test -filter=tests/unit_tests.tftest.hcl

# Ejecutar con output detallado
terraform test -verbose

# tests/unit_tests.tftest.hcl
# Pruebas unitarias para el módulo de networking

# ============================================================
# BLOQUE run: Define una prueba individual
# ============================================================

# PRUEBA 1: Verificar que el módulo aplica sin errores con valores por defecto
run "valid_configuration_with_defaults" {
  # command = plan  => Solo ejecuta "terraform plan" (sin crear recursos reales)
  # command = apply => Crea recursos reales (para pruebas de integración)
  command = plan

  # Valores de variables a usar en esta prueba
  variables {
    environment = "test"
    vpc_cidr    = "10.0.0.0/16"
    region      = "us-east-1"
  }

  # assert: Condiciones que deben ser verdaderas para que la prueba pase
  assert {
    # condition: La expresión que se evalúa (debe ser booleana)
    condition = output.vpc_cidr == "10.0.0.0/16"

    # error_message: Mensaje que se muestra si la condición es falsa
    error_message = "El CIDR de la VPC debe coincidir con el valor de entrada"
  }

  assert {
    # Verificar que el nombre del recurso sigue la convención esperada
    condition     = aws_vpc.main.tags["Environment"] == "test"
    error_message = "La etiqueta Environment debe ser 'test'"
  }
}

# PRUEBA 2: Verificar el comportamiento con diferentes entornos
run "production_environment_naming" {
  command = plan

  variables {
    environment = "prod"
    vpc_cidr    = "10.1.0.0/16"
    region      = "us-east-1"
  }

  assert {
    # Verificar que el nombre del recurso incluye el entorno
    condition     = can(regex("prod", aws_vpc.main.tags["Name"]))
    error_message = "El nombre de la VPC debe contener 'prod' en entorno de producción"
  }
}

# PRUEBA 3: Verificar que se rechaza un CIDR inválido
run "invalid_vpc_cidr_validation" {
  command = plan

  variables {
    environment = "dev"
    vpc_cidr    = "256.0.0.0/16"  # CIDR inválido
    region      = "us-east-1"
  }

  # expect_failures: Lista de recursos/variables que SE ESPERA que fallen
  # Útil para probar que las validaciones funcionan correctamente
  expect_failures = [
    var.vpc_cidr,  # Se espera que esta variable falle la validación
  ]
}

# tests/integration_tests.tftest.hcl
# Pruebas de integración: CREAN RECURSOS REALES en AWS
# ADVERTENCIA: Estas pruebas tienen costo en la nube y toman más tiempo

# Configuración del provider para las pruebas de integración
# Terraform test permite sobreescribir la configuración del provider
provider "aws" {
  region = "us-east-1"
  # Las credenciales se toman de las variables de entorno AWS_*
}

# PRUEBA DE INTEGRACIÓN 1: Verificar que la VPC se crea correctamente
run "vpc_is_created_with_correct_configuration" {
  command = apply  # Crea recursos reales

  variables {
    environment = "tftest"    # Prefijo específico para recursos de prueba
    vpc_cidr    = "10.99.0.0/16"  # CIDR reservado para pruebas
    region      = "us-east-1"
  }

  assert {
    # Verificar que el output contiene un ID de VPC válido
    condition     = can(regex("^vpc-", output.vpc_id))
    error_message = "El ID de la VPC debe comenzar con 'vpc-'"
  }

  assert {
    # Verificar que el estado de la VPC es 'available'
    condition     = aws_vpc.main.state == "available"
    error_message = "La VPC debe estar en estado 'available' después de crearse"
  }
}
# NOTA: terraform test destruye automáticamente los recursos creados con
# command = apply al finalizar cada bloque "run"

# PRUEBA DE INTEGRACIÓN 2: Verificar conectividad entre subnets
run "subnets_are_in_different_availability_zones" {
  command = apply

  variables {
    environment         = "tftest"
    vpc_cidr            = "10.99.0.0/16"
    region              = "us-east-1"
    availability_zones  = ["us-east-1a", "us-east-1b"]
  }

  assert {
    condition = (
      aws_subnet.public[0].availability_zone != aws_subnet.public[1].availability_zone
    )
    error_message = "Las subnets públicas deben estar en diferentes zonas de disponibilidad"
  }
}

# tests/networking_module_tests.tftest.hcl

# PATRONES COMUNES EN PRUEBAS DE TERRAFORM:

# Patrón 1: Verificar valores de outputs
run "outputs_have_correct_format" {
  command = plan
  variables {
    environment = "test"
    vpc_cidr    = "10.0.0.0/16"
  }

  # can() evalúa si una expresión se ejecuta sin error
  # regex() devuelve error si no hay coincidencia, lo que hace can() = false
  assert {
    condition     = can(regex("^10\\.", output.vpc_cidr))
    error_message = "El CIDR debe pertenecer al bloque 10.x.x.x"
  }
}

# Patrón 2: Verificar etiquetas de recursos
run "all_resources_have_required_tags" {
  command = plan
  variables {
    environment = "prod"
    vpc_cidr    = "10.0.0.0/16"
  }

  assert {
    # contains() verifica si un mapa tiene una clave específica
    condition     = contains(keys(aws_vpc.main.tags), "Environment")
    error_message = "Todos los recursos deben tener la etiqueta 'Environment'"
  }

  assert {
    condition     = contains(keys(aws_vpc.main.tags), "ManagedBy")
    error_message = "Todos los recursos deben tener la etiqueta 'ManagedBy'"
  }
}

# Patrón 3: Verificar que no hay recursos públicamente accesibles por defecto
run "no_public_access_by_default" {
  command = plan
  variables {
    environment        = "test"
    vpc_cidr           = "10.0.0.0/16"
    enable_nat_gateway = false
  }

  assert {
    condition     = aws_subnet.private.map_public_ip_on_launch == false
    error_message = "Las subnets privadas no deben asignar IPs públicas automáticamente"
  }
}

# Patrón 4: Verificar conteos de recursos
run "correct_number_of_subnets_created" {
  command = plan
  variables {
    environment        = "test"
    vpc_cidr           = "10.0.0.0/16"
    availability_zones = ["us-east-1a", "us-east-1b", "us-east-1c"]
  }

  assert {
    # length() cuenta el número de elementos en una lista o mapa
    condition     = length(aws_subnet.public) == 3
    error_message = "Deben crearse 3 subnets públicas, una por zona de disponibilidad"
  }
}

# .github/workflows/terraform-tests.yml
# Pipeline de GitHub Actions para ejecutar pruebas de Terraform

name: Terraform Tests

on:
  pull_request:
    branches: [main, develop]
  push:
    branches: [main]

jobs:
  # ============================================================
  # JOB 1: Análisis estático (rápido, sin credenciales de nube)
  # ============================================================
  static-analysis:
    name: Static Analysis
    runs-on: ubuntu-latest

    steps:
      - name: Checkout código
        uses: actions/checkout@v4

      - name: Configurar Terraform
        uses: hashicorp/setup-terraform@v3
        with:
          terraform_version: "1.7.0"

      - name: Inicializar Terraform (sin backend)
        run: terraform init -backend=false

      - name: Verificar formato (terraform fmt)
        run: terraform fmt -check -recursive
        # Falla si algún archivo no está formateado correctamente

      - name: Validar sintaxis (terraform validate)
        run: terraform validate

      - name: Instalar tflint
        uses: terraform-linters/setup-tflint@v4
        with:
          tflint_version: v0.50.0

      - name: Inicializar tflint
        run: tflint --init

      - name: Ejecutar tflint
        run: tflint --recursive

      - name: Instalar checkov
        run: pip install checkov

      - name: Ejecutar checkov
        run: |
          checkov -d . \
            --output cli \
            --output junitxml \
            --output-file-path . \
            --skip-check CKV_AWS_79  # Excluir si hay razón documentada
        # El resultado XML se puede publicar como reporte en GitHub

  # ============================================================
  # JOB 2: Pruebas unitarias con terraform test
  # ============================================================
  unit-tests:
    name: Unit Tests
    runs-on: ubuntu-latest
    needs: static-analysis  # Solo ejecutar si el análisis estático pasa

    steps:
      - name: Checkout código
        uses: actions/checkout@v4

      - name: Configurar Terraform
        uses: hashicorp/setup-terraform@v3
        with:
          terraform_version: "1.7.0"

      - name: Inicializar Terraform
        run: terraform init -backend=false

      - name: Ejecutar pruebas unitarias
        run: terraform test -filter=tests/unit_tests.tftest.hcl
        # Las pruebas unitarias usan command=plan, no necesitan credenciales de nube

  # ============================================================
  # JOB 3: Pruebas de integración (solo en merge a main)
  # ============================================================
  integration-tests:
    name: Integration Tests
    runs-on: ubuntu-latest
    needs: unit-tests
    # Solo ejecutar en merge a main, no en cada PR (costo en la nube)
    if: github.ref == 'refs/heads/main'

    env:
      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID_TEST }}
      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY_TEST }}
      AWS_DEFAULT_REGION: us-east-1

    steps:
      - name: Checkout código
        uses: actions/checkout@v4

      - name: Configurar Terraform
        uses: hashicorp/setup-terraform@v3
        with:
          terraform_version: "1.7.0"

      - name: Inicializar Terraform
        run: terraform init

      - name: Ejecutar pruebas de integración
        run: terraform test -filter=tests/integration_tests.tftest.hcl
        # terraform test destruye los recursos automáticamente al finalizar

# modules/s3-secure-bucket/main.tf

variable "bucket_name" {
  description = "Nombre del bucket S3"
  type        = string
}

variable "environment" {
  description = "Entorno de despliegue"
  type        = string
}

variable "enable_versioning" {
  description = "Habilitar versionado del bucket"
  type        = bool
  default     = true

  validation {
    condition     = var.enable_versioning == true || var.environment == "dev"
    error_message = "El versionado solo puede deshabilitarse en entorno dev."
  }
}

resource "aws_s3_bucket" "main" {
  bucket = "${var.bucket_name}-${var.environment}"

  tags = {
    Name        = "${var.bucket_name}-${var.environment}"
    Environment = var.environment
    ManagedBy   = "terraform"
  }
}

resource "aws_s3_bucket_versioning" "main" {
  bucket = aws_s3_bucket.main.id

  versioning_configuration {
    status = var.enable_versioning ? "Enabled" : "Suspended"
  }
}

resource "aws_s3_bucket_server_side_encryption_configuration" "main" {
  bucket = aws_s3_bucket.main.id

  rule {
    apply_server_side_encryption_by_default {
      sse_algorithm = "AES256"
    }
  }
}

output "bucket_id" {
  description = "ID del bucket S3"
  value       = aws_s3_bucket.main.id
}

output "bucket_arn" {
  description = "ARN del bucket S3"
  value       = aws_s3_bucket.main.arn
}

# modules/s3-secure-bucket/tests/bucket_tests.tftest.hcl

# PRUEBA 1: El nombre del bucket incluye el entorno
run "bucket_name_includes_environment" {
  command = plan

  variables {
    bucket_name       = "mi-app-datos"
    environment       = "prod"
    enable_versioning = true
  }

  assert {
    # El ID del bucket debe contener el nombre y el entorno concatenados
    condition     = aws_s3_bucket.main.bucket == "mi-app-datos-prod"
    error_message = "El nombre del bucket debe ser '{bucket_name}-{environment}'"
  }

  assert {
    # La etiqueta Name debe coincidir con el nombre del bucket
    condition     = aws_s3_bucket.main.tags["Name"] == "mi-app-datos-prod"
    error_message = "La etiqueta Name debe coincidir con el nombre del bucket"
  }
}

# PRUEBA 2: El versionado está habilitado por defecto
run "versioning_enabled_by_default" {
  command = plan

  variables {
    bucket_name = "mi-bucket"
    environment = "staging"
    # No especificamos enable_versioning, debe usar el valor por defecto (true)
  }

  assert {
    condition = (
      aws_s3_bucket_versioning.main.versioning_configuration[0].status == "Enabled"
    )
    error_message = "El versionado debe estar habilitado por defecto"
  }
}

# PRUEBA 3: Se rechaza deshabilitar el versionado en producción
run "cannot_disable_versioning_in_production" {
  command = plan

  variables {
    bucket_name       = "mi-bucket"
    environment       = "prod"
    enable_versioning = false  # Debe fallar la validación
  }

  # Esperamos que la variable falle su validación
  expect_failures = [
    var.enable_versioning,
  ]
}

# PRUEBA 4: Se permite deshabilitar el versionado en dev
run "can_disable_versioning_in_dev" {
  command = plan

  variables {
    bucket_name       = "mi-bucket"
    environment       = "dev"
    enable_versioning = false  # Permitido en dev
  }

  assert {
    condition = (
      aws_s3_bucket_versioning.main.versioning_configuration[0].status == "Suspended"
    )
    error_message = "El versionado debe estar suspendido cuando enable_versioning=false"
  }
}

# PRUEBA 5: La encriptación está siempre configurada
run "encryption_is_always_configured" {
  command = plan

  variables {
    bucket_name = "mi-bucket"
    environment = "prod"
  }

  assert {
    condition = (
      aws_s3_bucket_server_side_encryption_configuration.main
        .rule[0]
        .apply_server_side_encryption_by_default[0]
        .sse_algorithm == "AES256"
    )
    error_message = "La encriptación AES256 debe estar siempre configurada"
  }
}

# PRUEBA 6: Las etiquetas requeridas están presentes
run "required_tags_are_present" {
  command = plan

  variables {
    bucket_name = "mi-bucket"
    environment = "prod"
  }

  assert {
    condition     = contains(keys(aws_s3_bucket.main.tags), "Environment")
    error_message = "La etiqueta 'Environment' es requerida en todos los buckets"
  }

  assert {
    condition     = contains(keys(aws_s3_bucket.main.tags), "ManagedBy")
    error_message = "La etiqueta 'ManagedBy' es requerida en todos los buckets"
  }

  assert {
    condition     = aws_s3_bucket.main.tags["ManagedBy"] == "terraform"
    error_message = "El valor de 'ManagedBy' debe ser 'terraform'"
  }
}

# Navegar al módulo
cd modules/s3-secure-bucket

# Inicializar (necesario aunque no haya backend)
terraform init -backend=false

# Ejecutar todas las pruebas
terraform test

# Output esperado:
# tests/bucket_tests.tftest.hcl... in progress
#   run "bucket_name_includes_environment"... pass
#   run "versioning_enabled_by_default"... pass
#   run "cannot_disable_versioning_in_production"... pass
#   run "can_disable_versioning_in_dev"... pass
#   run "encryption_is_always_configured"... pass
#   run "required_tags_are_present"... pass
# tests/bucket_tests.tftest.hcl... tearing down
# tests/bucket_tests.tftest.hcl... pass
#
# Success! 6 passed, 0 failed.