Testing

It is highly recommended to write tests for your custom policies.

Rego testing

To help you verify the correctness of your custom policies, OPA gives you a framework that you can use to write tests for your policies. By writing tests for your custom policies you can speed up the development process of new rules and reduce the amount of time it takes to modify rules as requirements evolve.

For more details, see Policy Testing.

Example

  1. package user.dockerfile.ID002
  3. test_add_denied {
  4.     r := deny with input as {"stages": {"alpine:3.13": [
  5.         {"Cmd": "add", "Value": ["/target/resources.tar.gz", "resources.jar"]},
  6.         {"Cmd": "add", "Value": ["/target/app.jar", "app.jar"]},
  7.     ]}}
  9.     count(r) == 1
  10.     r[_] == "Consider using 'COPY /target/app.jar app.jar' command instead of 'ADD /target/app.jar app.jar'"
  11. }

To write tests for custom policies, you can refer to existing tests under AppShield.

Go testing

Fanal which is a core library of Trivy can be imported as a Go library. You can scan config files in Go and test your custom policies using Go’s testing methods, such as table-driven tests. This allows you to use the actual configuration file as input, making it easy to prepare test data and ensure that your custom policies work in practice.

In particular, Dockerfile and HCL need to be converted to structural data as input, which may be different from the expected input format.

Tip

We recommend writing OPA and Go tests both since they have different roles, like unit tests and integration tests.

The following example stores allowed and denied configuration files in a directory. Successes contains the result of successes, and Failures contains the result of failures.

  1. {
  2.     name:  "disallowed ports",
  3.     input: "configs/",
  4.     fields: fields{
  5.         policyPaths: []string{"policy"},
  6.         dataPaths:   []string{"data"},
  7.         namespaces:  []string{"user"},
  8.     },
  9.     want: []types.Misconfiguration{
  10.         {
  11.             FileType: types.Dockerfile,
  12.             FilePath: "Dockerfile.allowed",
  13.             Successes: types.MisconfResults{
  14.                 {
  15.                     Namespace: "user.dockerfile.ID002",
  16.                     PolicyMetadata: types.PolicyMetadata{
  17.                         ID:          "ID002",
  18.                         Type:        "Docker Custom Check",
  19.                         Title:       "Disallowed ports exposed",
  20.                         Severity:    "HIGH",
  21.                     },
  22.                 },
  23.             },
  24.         },
  25.         {
  26.             FileType: types.Dockerfile,
  27.             FilePath: "Dockerfile.denied",
  28.             Failures: types.MisconfResults{
  29.                 {
  30.                     Namespace: "user.dockerfile.ID002",
  31.                     Message:   "Port 23 should not be exposed",
  32.                     PolicyMetadata: types.PolicyMetadata{
  33.                         ID:          "ID002",
  34.                         Type:        "Docker Custom Check",
  35.                         Title:       "Disallowed ports exposed",
  36.                         Severity:    "HIGH",
  37.                     },
  38.                 },
  39.             },
  40.         },
  41.     },
  42. },

Dockerfile.allowed has one successful result in Successes, while Dockerfile.denied has one failure result in Failures.