# Probar políticas de compilación


El comando [`docker buildx policy test`](/reference/cli/docker/buildx/policy/test/)
ejecuta pruebas unitarias para políticas de compilación utilizando el [marco de
pruebas estándar](https://www.openpolicyagent.org/docs/policy-testing) de OPA.

```console
$ docker buildx policy test <ruta>
```

Esto valida la lógica de la política con entradas simuladas (mocked).

Para realizar pruebas con fuentes reales (metadatos de imágenes reales, repositorios
de Git), utiliza
[`docker buildx policy eval`](/reference/cli/docker/buildx/policy/eval/) en su lugar.
Puedes usar la opción `eval --print` para resolver la entrada de una fuente específica
al escribir un caso de prueba.

## Ejemplo básico

Comienza con una política simple que solo permita imágenes de `alpine`:

```rego {title="Dockerfile.rego"}
package docker

default allow = false

allow if {
    input.image.repo == "alpine"
}

decision := {"allow": allow}
```

Crea un archivo de prueba con el sufijo `*_test.rego`. Las funciones de prueba deben
comenzar con `test_`:

```rego {title="Dockerfile_test.rego"}
package docker

test_alpine_allowed if {
    decision.allow with input as {"image": {"repo": "alpine"}}
}

test_ubuntu_denied if {
    not decision.allow with input as {"image": {"repo": "ubuntu"}}
}
```

Ejecuta las pruebas:

```console
$ docker buildx policy test .
test_alpine_allowed: PASS (allow=true)
test_ubuntu_denied: PASS (allow=false)
```

`PASS` indica que las pruebas definidas en `Dockerfile_test.rego` se ejecutaron con
éxito y se cumplieron todas las aserciones.

## Opciones del comando

Filtra las pruebas por nombre con `--run`:

```console
$ docker buildx policy test --run alpine .
test_alpine_allowed: PASS (allow=true)
```

Prueba políticas con nombres de archivo no predeterminados utilizando `--filename`:

```console
$ docker buildx policy test --filename app.Dockerfile .
```

Esto carga `app.Dockerfile.rego` y ejecuta los archivos `*_test.rego` con él.

## Salida de pruebas

Las pruebas aprobadas muestran el estado de permiso y cualquier mensaje de denegación:

```console
test_alpine_allowed: PASS (allow=true)
test_ubuntu_denied: PASS (allow=false, deny_msg=only alpine images are allowed)
```

Las pruebas fallidas muestran la entrada, la salida de la decisión y los campos
que faltan:

```console
test_invalid: FAIL (allow=false)
input:
  {
    "image": {}
  }
decision:
  {
    "allow": false,
    "deny_msg": [
      "only alpine images are allowed"
    ]
  }
missing_input: input.image.repo
```

## Probar mensajes de denegación

Para probar mensajes de error personalizados, captura el resultado completo de la
decisión y realiza la aserción sobre el campo `deny_msg`.

Para una política con mensajes de denegación:

```rego {title="Dockerfile.rego"}
package docker

default allow = false

allow if {
    input.image.repo == "alpine"
}

deny_msg contains msg if {
    not allow
    msg := "only alpine images are allowed"
}

decision := {"allow": allow, "deny_msg": deny_msg}
```

Prueba el mensaje de denegación:

```rego {title="Dockerfile_test.rego"}
test_deny_message if {
    result := decision with input as {"image": {"repo": "ubuntu"}}
    not result.allow
    "only alpine images are allowed" in result.deny_msg
}
```

## Patrones de prueba

**Probar reglas específicas de entorno:**

```rego
test_production_requires_digest if {
    decision.allow with input as {
        "env": {"target": "production"},
        "image": {"isCanonical": true}
    }
}

test_development_allows_tags if {
    decision.allow with input as {
        "env": {"target": "development"},
        "image": {"isCanonical": false}
    }
}
```

**Probar múltiples registros:**

```rego
test_dockerhub_allowed if {
    decision.allow with input as {
        "image": {
            "ref": "docker.io/library/alpine",
            "host": "docker.io",
            "repo": "alpine"
        }
    }
}

test_ghcr_allowed if {
    decision.allow with input as {
        "image": {
            "ref": "ghcr.io/myorg/myapp",
            "host": "ghcr.io",
            "repo": "myorg/myapp"
        }
    }
}
```

Para conocer los campos de entrada disponibles, consulta la
[Referencia de inputs](/build/policies/inputs/).

## Organizar archivos de prueba

El ejecutor de pruebas busca todos los archivos `*_test.rego` de forma recursiva:

```plaintext
build-policies/
├── Dockerfile.rego
├── Dockerfile_test.rego
└── tests/
    ├── registries_test.rego
    ├── signatures_test.rego
    └── environments_test.rego
```

Ejecuta todas las pruebas:

```console
$ docker buildx policy test .
```

O prueba archivos específicos:

```console
$ docker buildx policy test tests/registries_test.rego
```