Terraform Test

by hashicorpf706481af9b8No license890 starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 3 days ago

Comprehensive guide for writing and running Terraform tests. Use when creating test files (.tftest.hcl), writing test scenarios with run blocks, validating infrastructure behavior with assertions, mocking providers and data sources, testing module outputs and resource configurations, or troubleshooting Terraform test syntax and execution.

Instructions onlySoftware DevelopmentDevOps & Cloud
AI-generated overview

Guides writing and running Terraform tests with .tftest.hcl files, run blocks, assertions, mocks and CI integration.

What it does
This skill provides instructions for authoring and executing Terraform's built-in test framework. It covers test file structure, run and assert blocks, plan versus apply modes, provider and data source mocking, module outputs, state keys, parallel runs and cleanup behavior. It also includes reference material on mock providers, CI/CD pipelines and a full example test suite.
When to use it
Use it when creating or troubleshooting Terraform test files, validating infrastructure configuration behavior, or setting up unit and integration tests for Terraform modules. It is also relevant when mocking providers to avoid real credentials or wiring tests into CI pipelines.
Requirements
Requires Terraform with its built-in test command; mock providers need Terraform 1.7.0 or later. Apply-mode tests need provider credentials and network access to create real resources. No scripts are shipped; the skill is instructions plus three reference documents.

Terraform Test

Terraform's built-in testing framework validates that configuration updates don't introduce breaking changes. Tests run against temporary resources, protecting existing infrastructure and state files.

Reference Files

  • references/MOCK_PROVIDERS.md — Mock provider syntax, common defaults, when to use mocks (Terraform 1.7.0+ only — skip if the user's version is below 1.7)
  • references/CI_CD.md — GitHub Actions and GitLab CI pipeline examples
  • references/EXAMPLES.md — Complete example test suite (unit, integration, and mock tests for a VPC module)

Read the relevant reference file when the user asks about mocking, CI/CD integration, or wants a full example.

Core Concepts

  • Test file (.tftest.hcl / .tftest.json): Contains run blocks that validate your configuration
  • Run block: A single test scenario with optional variables, providers, and assertions
  • Assert block: Conditions that must be true for the test to pass
  • Mock provider: Simulates provider behavior without real infrastructure (Terraform 1.7.0+)
  • Test modes: apply (default, creates real resources) or plan (validates logic only)

File Structure

my-module/├── main.tf├── variables.tf├── outputs.tf└── tests/    ├── defaults_unit_test.tftest.hcl         # plan mode — fast, no resources    ├── validation_unit_test.tftest.hcl        # plan mode    └── full_stack_integration_test.tftest.hcl # apply mode — creates real resources

Use *_unit_test.tftest.hcl for plan-mode tests and *_integration_test.tftest.hcl for apply-mode tests so they can be filtered separately in CI.

Test File Structure

hcl
# Optional: test-wide settingstest {  parallel = true  # Enable parallel execution for all run blocks (default: false)}
# Optional: file-level variables (highest precedence, override all other sources)variables {  aws_region    = "us-west-2"  instance_type = "t2.micro"}
# Optional: provider configurationprovider "aws" {  region = var.aws_region}
# Required: at least one run blockrun "test_default_configuration" {  command = plan
  assert {    condition     = aws_instance.example.instance_type == "t2.micro"    error_message = "Instance type should be t2.micro by default"  }}

Run Block

hcl
run "test_name" {  command  = plan  # or apply (default)  parallel = true  # optional, since v1.9.0
  # Override file-level variables  variables {    instance_type = "t3.large"  }
  # Reference a specific module  module {    source  = "./modules/vpc"  # local or registry only (not git/http)    version = "5.0.0"          # registry modules only  }
  # Control state isolation  state_key = "shared_state"  # since v1.9.0
  # Plan behavior  plan_options {    mode    = refresh-only  # or normal (default)    refresh = true    replace = [aws_instance.example]    target  = [aws_instance.example]  }
  # Assertions  assert {    condition     = aws_instance.example.id != ""    error_message = "Instance should have a valid ID"  }
  # Expected failures (test passes if these fail)  expect_failures = [    var.instance_count  ]}

Common Test Patterns

Validate outputs

hcl
run "test_outputs" {  command = plan
  assert {    condition     = output.vpc_id != null    error_message = "VPC ID output must be defined"  }
  assert {    condition     = can(regex("^vpc-", output.vpc_id))    error_message = "VPC ID should start with 'vpc-'"  }}

Conditional resources

hcl
run "test_nat_gateway_disabled" {  command = plan
  variables {    create_nat_gateway = false  }
  assert {    condition     = length(aws_nat_gateway.main) == 0    error_message = "NAT gateway should not be created when disabled"  }}

Resource counts

hcl
run "test_resource_count" {  command = plan
  variables {    instance_count = 3  }
  assert {    condition     = length(aws_instance.workers) == 3    error_message = "Should create exactly 3 worker instances"  }}

Tags

hcl
run "test_resource_tags" {  command = plan
  variables {    common_tags = {      Environment = "production"      ManagedBy   = "Terraform"    }  }
  assert {    condition     = aws_instance.example.tags["Environment"] == "production"    error_message = "Environment tag should be set correctly"  }
  assert {    condition     = aws_instance.example.tags["ManagedBy"] == "Terraform"    error_message = "ManagedBy tag should be set correctly"  }}

Data sources

hcl
run "test_data_source_lookup" {  command = plan
  assert {    condition     = data.aws_ami.ubuntu.id != ""    error_message = "Should find a valid Ubuntu AMI"  }
  assert {    condition     = can(regex("^ami-", data.aws_ami.ubuntu.id))    error_message = "AMI ID should be in correct format"  }}

Validation rules

hcl
run "test_invalid_environment" {  command = plan
  variables {    environment = "invalid"  }
  expect_failures = [    var.environment  ]}

Sequential tests with dependencies

hcl
run "setup_vpc" {  command = apply
  assert {    condition     = output.vpc_id != ""    error_message = "VPC should be created"  }}
run "test_subnet_in_vpc" {  command = plan
  variables {    vpc_id = run.setup_vpc.vpc_id  }
  assert {    condition     = aws_subnet.example.vpc_id == run.setup_vpc.vpc_id    error_message = "Subnet should be in the VPC from setup_vpc"  }}

Plan options (refresh-only, targeted)

hcl
run "test_refresh_only" {  command = plan
  plan_options {    mode = refresh-only  }
  assert {    condition     = aws_instance.example.tags["Environment"] == "production"    error_message = "Tags should be refreshed correctly"  }}
run "test_specific_resource" {  command = plan
  plan_options {    target = [aws_instance.example]  }
  assert {    condition     = aws_instance.example.instance_type == "t2.micro"    error_message = "Targeted resource should be planned"  }}

Parallel modules

hcl
run "test_networking_module" {  command  = plan  parallel = true
  module {    source = "./modules/networking"  }
  assert {    condition     = output.vpc_id != ""    error_message = "VPC should be created"  }}
run "test_compute_module" {  command  = plan  parallel = true
  module {    source = "./modules/compute"  }
  assert {    condition     = output.instance_id != ""    error_message = "Instance should be created"  }}

State key sharing

hcl
run "create_foundation" {  command   = apply  state_key = "foundation"
  assert {    condition     = aws_vpc.main.id != ""    error_message = "Foundation VPC should be created"  }}
run "create_application" {  command   = apply  state_key = "foundation"
  variables {    vpc_id = run.create_foundation.vpc_id  }
  assert {    condition     = aws_instance.app.vpc_id == run.create_foundation.vpc_id    error_message = "Application should use foundation VPC"  }}

Cleanup ordering (S3 objects before bucket)

hcl
run "create_bucket" {  command = apply
  assert {    condition     = aws_s3_bucket.example.id != ""    error_message = "Bucket should be created"  }}
run "add_objects" {  command = apply
  assert {    condition     = length(aws_s3_object.files) > 0    error_message = "Objects should be added"  }}
# Cleanup destroys in reverse: objects first, then bucket

Multiple aliased providers

hcl
provider "aws" {  alias  = "primary"  region = "us-west-2"}
provider "aws" {  alias  = "secondary"  region = "us-east-1"}
run "test_with_specific_provider" {  command = plan
  providers = {    aws = provider.aws.secondary  }
  assert {    condition     = aws_instance.example.availability_zone == "us-east-1a"    error_message = "Instance should be in us-east-1 region"  }}

Complex conditions

hcl
assert {  condition = alltrue([    for subnet in aws_subnet.private :    can(regex("^10\\.0\\.", subnet.cidr_block))  ])  error_message = "All private subnets should use 10.0.0.0/8 CIDR range"}

Cleanup

Resources are destroyed in reverse run block order after test completion. This matters for dependencies (e.g., S3 objects before bucket). Use terraform test -no-cleanup to skip cleanup for debugging.

Running Tests

bash
terraform test                                        # all teststerraform test tests/defaults.tftest.hcl             # specific fileterraform test -filter=test_vpc_configuration        # by run block nameterraform test -test-directory=integration-tests     # custom directoryterraform test -verbose                              # detailed outputterraform test -no-cleanup                           # skip resource cleanup

Best Practices

  1. Naming: *_unit_test.tftest.hcl for plan mode, *_integration_test.tftest.hcl for apply mode
  2. Test naming: Use descriptive run block names that explain the scenario being tested
  3. Default to plan: Use command = plan unless you need to test real resource behavior
  4. Use mocks for external dependencies — faster and no credentials needed (see references/MOCK_PROVIDERS.md)
  5. Error messages: Make them specific enough to diagnose failures without running the test again
  6. Negative tests: Use expect_failures to verify validation rules reject bad inputs
  7. Variable coverage: Test different variable combinations to validate all code paths — test variables have the highest precedence and override all other sources
  8. Module sources: Test files only support local paths and registry modules — not git or HTTP URLs
  9. Parallel execution: Use parallel = true for independent tests with different state files
  10. Cleanup: Integration tests destroy resources in reverse run block order automatically; use -no-cleanup for debugging
  11. CI/CD: Run unit tests on every PR, integration tests on merge (see references/CI_CD.md)

Troubleshooting

IssueSolution
Assertion failuresUse -verbose to see actual vs expected values
Missing credentialsUse mock providers for unit tests
Unsupported module sourceConvert git/HTTP sources to local modules
Tests interferingUse state_key or separate modules for isolation
Slow testsUse command = plan and mocks; run integration tests separately

References

Source and attribution

Source:hashicorp/agent-skillsinplugins/terraform/skills/terraform-testat commitf706481

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

More from hashicorp/agent-skills

Terraform Style Guide

hashicorp

Generates and reviews Terraform HCL code following HashiCorp's official style conventions and best practices.

DevOps & Cloud890updated 3 days ago

Terraform Stacks

hashicorp

Guides writing and validating HashiCorp Terraform Stacks configuration files for multi-environment infrastructure.

DevOps & Cloud890updated 3 days ago

Terraform Policy

hashicorp

Writes, tests and converts Terraform Policy files (.policy.hcl, .policytest.hcl) and Sentinel policies.

Software Development890updated 3 days ago

Refactor Module

hashicorp

Guides refactoring monolithic Terraform configurations into reusable, maintainable modules with migration and tests.

Software Development890updated 3 days ago

Provider Resources

hashicorp

Implement Terraform Provider resources and data sources using the Plugin Framework: CRUD operations, schema design, plan modifiers and validators, not-found handling, waiters for eventually consistent APIs, import support, resource design principles, and required acceptance test coverage. Use when adding or changing a resource or data source, deciding whether an API concept should be a resource, wiring a resource to the provider's configured client, handling drift or resource-not-found, or reviewing a resource implementation before submission.

Awaiting classification890updated 3 days ago

Provider Framework Migration

hashicorp

Guides migrating Terraform provider resources from Plugin SDKv2 to the Plugin Framework using a muxed provider.

Software Development890updated 3 days ago

More in Software Development

Playground

anthropics

Featured

Builds self-contained interactive HTML playgrounds with controls, live preview, and copyable prompt output.

Software Development37Kupdated today

M5 Onboard

anthropics

Featured

Provisions M5Stack ESP32 boards by detecting them on USB, flashing UIFlow 2.0 firmware, and installing a MicroPython app bundle.

Software Development37Kupdated today

Cardputer Buddy

anthropics

Featured

Guides iterating on a Cardputer-Adv MicroPython app bundle: adding apps, pushing files over USB-serial, tailing logs, and running REPL commands.

Software Development37Kupdated today

Web Design Guidelines

vercel-labs

Featured

Reviews UI code against Web Interface Guidelines fetched from a remote source and reports findings as file:line entries.

Software Development32Kupdated 5 weeks ago

Vercel React Native Skills

vercel-labs

Featured

React Native and Expo best-practice rules covering list performance, animation, navigation, UI patterns, state, and monorepo setup.

Software Development32Kupdated 5 weeks ago

Vercel React Best Practices

vercel-labs

Featured

Vercel's React and Next.js performance guidelines, organized as 70 rules for writing, reviewing, and refactoring code.

Software Development32Kupdated 5 weeks ago