AzureCAF Terraform Provider

Tests are categorized by their purpose and the level of the stack they verify. Use the file naming patterns to identify the type of test you are looking at.

Test Categories

1. Provider Tests: Basic configuration and initialization (provider_test.go).
2. Resource Name Tests: String cleaning, concatenation, and slug retrieval (resource_name_test.go).
3. Naming Convention Tests: Tests for specific naming styles like cafclassic, cafrandom, random, and passthrough.
4. Data Source Tests: Validation of data source behavior vs resource behavior.
5. Model Tests: Regex, length, and string processing validations for generated models (models_generated_test.go).
6. Integration Tests: End-to-end Terraform lifecycle tests (prefixed with TestAcc).
7. Coverage/Edge Case Tests: Specialized tests to hit untested code paths or error handling logic.

File Naming Patterns

• *_test.go: Standard unit tests.
• integration_*_test.go: Integration tests with Terraform.
• *_coverage_test.go: Tests specifically for coverage improvement.
• enhanced_*_test.go: Comprehensive test suites.

The azurecaf_name resource performs several layers of validation to ensure generated names are valid for Azure:

1. Length Validation: Ensures names do not exceed maximum length after truncation and meet minimum requirements. Random length is validated against resource type constraints.
2. Pattern Validation: After composition and truncation, names must match the specific validation pattern for the chosen resource_type.

Warning on clean_input: If clean_input = false, the resource will not remove invalid characters from your input name. If the resulting composition contains characters disallowed by the resource_type pattern, validation will fail.

resource "azurecaf_name" "example" {
  name          = "my-app_name"
  resource_type = "azurerm_storage_account"  # Only allows alphanumeric
  clean_input   = false  # Won't clean invalid characters
}
# Error: Pattern validation failed

The provider offers two ways to generate names: a Data Source and a Resource. Choosing the right one depends on your lifecycle requirements.

Data Source (Recommended)

Use the data "azurecaf_name" block when you want names to be evaluated during the plan phase. This allows you to see the generated names in your Terraform plan before any resources are actually created.

data "azurecaf_name" "storage" {
  name          = "mydata"
  resource_type = "azurerm_storage_account"
  prefixes      = ["prod"]
  random_length = 3
}

resource "azurerm_storage_account" "example" {
  name = data.azurecaf_name.storage.result
}

Resource

Use the resource "azurecaf_name" block when you need to generate multiple related names for different resource types simultaneously. This ensures consistency across a group of resources.

resource "azurecaf_name" "multi_res" {
  name           = "myapp"
  resource_type  = "azurerm_app_service"
  resource_types = [
    "azurerm_app_service_plan",
    "azurerm_application_insights"
  ]
  prefixes      = ["prod"]
  random_length = 3
}

# Accessing the names:
# Primary name: azurecaf_name.multi_res.result
# All generated names: azurecaf_name.multi_res.results

# Data Source Example
data "azurecaf_name" "storage" {
  name          = "mydata"
  resource_type = "azurerm_storage_account"
  prefixes      = ["prod"]
  random_length = 3
}

# Resource Example
resource "azurecaf_name" "multi_res" {
  name           = "myapp"
  resource_type  = "azurerm_app_service"
  resource_types = [
    "azurerm_app_service_plan",
    "azurerm_application_insights"
  ]
  prefixes      = ["prod"]
  random_length = 3
}

The provider uses a name precedence algorithm to compose names. The order of components is:

1. name: The base name.
2. slug: The resource type abbreviation (if use_slug = true).
3. random: Random characters (if random_length > 0).
4. suffixes: Suffix strings (applied in order).
5. prefixes: Prefix strings (applied in reverse order).

Component Placement Order

• Prefixes: Added to the beginning (last prefix first).
• Slug: Added after prefixes.
• Name: The core component.
• Suffixes: Added to the end (first suffix first).
• Random: Added to the very end after suffixes.

Example Composition: For name="myapp", prefixes=["corp", "prod"], resource_type="azurerm_storage_account" (slug st), suffixes=["web", "001"], and random_length=3 with separator -:

1. Prefixes (reverse): prod-corp
2. Slug: st-prod-corp
3. Name: st-prod-corp-myapp
4. Suffixes (forward): st-prod-corp-myapp-web-001
5. Random: st-prod-corp-myapp-web-001-abc

Note: Final output is processed for lowercase and separator compliance (e.g., stprodcorpmyappweb001abc).

The legacy azurecaf_naming_convention resource follows a fixed composition order: [prefix, cafprefix, name, postfix] joined with -. The cafprefix is the resource-type slug (e.g., rg for Resource Group) defined by the provider.

Convention Behaviors

Validation and Constraints

• Character Filtering: The composed string is filtered through a resource-specific RegEx to remove invalid characters (e.g., dashes are stripped for Storage Accounts).
• Length: The name is bounded by max_length, which is capped by the Azure resource's actual maximum limit.
• Validation: The final output is checked against a ValidationRegExp. If it fails, the resource returns an error.

When a composed name exceeds the maximum length allowed by an Azure resource, the provider uses priority-based truncation. It attempts to fit as many components as possible based on their importance.

Truncation Priority

Components are added in this order. If a component cannot fit within the remaining character budget, it is skipped entirely:

1. name (Highest priority - always preserved if possible)
2. slug
3. random
4. suffixes
5. prefixes (Lowest priority - first to be dropped)

Examples

Prefix Truncation: If a storage account (max 24 chars) has a name "verylongapplicationname" (23 chars) and a prefix "corporate", the prefix and slug will be skipped to ensure the core name fits. Result: "verylongapplicationname"

Suffix Truncation: If a name is "myapp" (5 chars), slug is "st" (2 chars), and random is 8 chars, but a suffix "production" (10 chars) would push the total over the limit, the provider will skip "production" and move to the next suffix in the list (e.g., "web").