The azurecaf provider implements a set of methodologies for naming convention implementation, including the default Microsoft Cloud Adoption Framework for Azure recommendations as per the Azure naming and tagging best practices. Please note this project is not part of Azure Cloud Adoption Framework and is supported by the community, not by Microsoft Support.

The Azure CAF provider allows you to:

• 🏗️ Generate compliant Azure resource names following CAF guidelines and Azure naming restrictions
• 🧹 Clean and sanitize inputs to ensure compliance with allowed patterns for each Azure resource
• 🎲 Add random characters to resource names for uniqueness
• 🏷️ Handle prefixes and suffixes (either manual or as per Azure CAF resource conventions)
• ✅ Validate existing names using passthrough mode
• 🔄 Support multiple naming conventions (CAF classic, CAF random, passthrough, etc.)
• 📋 Generate names for 395 Azure resource types with accurate validation rules

Add the provider to your Terraform configuration:

terraform {
  required_providers {
    azurecaf = {
      source  = "aztfmod/azurecaf"
      version = "~> 1.2.28"  # Use the latest version
    }
  }
}

Generate an Azure-compliant resource group name:

# Using data source (recommended - evaluated at plan time)
data "azurecaf_name" "rg_example" {
  name          = "myproject"
  resource_type = "azurerm_resource_group"
  prefixes      = ["demo"]
  suffixes      = ["001"]
  random_length = 5
  clean_input   = true
}

resource "azurerm_resource_group" "example" {
  name     = data.azurecaf_name.rg_example.result
  location = "East US"
}

output "resource_group_name" {
  value = data.azurecaf_name.rg_example.result
  # Output: rg-demo-myproject-001-a1b2c
}

Generate names with automatic resource type prefixes:

data "azurecaf_name" "storage_account" {
  name          = "mydata"
  resource_type = "azurerm_storage_account"
  random_length = 3
}

resource "azurerm_storage_account" "example" {
  name                     = data.azurecaf_name.storage_account.result
  resource_group_name      = azurerm_resource_group.example.name
  location                 = azurerm_resource_group.example.location
  account_tier             = "Standard"
  account_replication_type = "LRS"
}
# Result: "stmydata123" (st = storage account slug, mydata = name, 123 = random)

Generate names for multiple related resources:

locals {
  project = "webapp"
  env     = "prod"
}

data "azurecaf_name" "app_service_plan" {
  name          = local.project
  resource_type = "azurerm_app_service_plan"
  prefixes      = [local.env]
  suffixes      = ["001"]
}

data "azurecaf_name" "app_service" {
  name          = local.project
  resource_type = "azurerm_app_service"
  prefixes      = [local.env]
  suffixes      = ["001"]
}

data "azurecaf_name" "key_vault" {
  name          = local.project
  resource_type = "azurerm_key_vault"
  prefixes      = [local.env]
  suffixes      = ["001"]
}

# Results:
# App Service Plan: "plan-prod-webapp-001"
# App Service: "app-prod-webapp-001"  
# Key Vault: "kv-prod-webapp-001"

For cases where you need to generate multiple resource names:

resource "azurecaf_name" "multiple_resources" {
  name           = "myapp"
  resource_type  = "azurerm_app_service"
  resource_types = [
    "azurerm_app_service_plan",
    "azurerm_application_insights"
  ]
  prefixes       = ["prod"]
  suffixes       = ["web"]
  random_length  = 3
  clean_input    = true
}

# Access individual names:
# Primary: azurecaf_name.multiple_resources.result
# All: azurecaf_name.multiple_resources.results

Validate existing resource names without modification:

data "azurecaf_name" "existing_storage" {
  name          = "mystorageaccount123"
  resource_type = "azurerm_storage_account"
  passthrough   = true
}

# Validates that "mystorageaccount123" is compliant with storage account naming rules

Complex naming with custom separators and no resource slugs:

data "azurecaf_name" "custom_vm" {
  name          = "database-server"
  resource_type = "azurerm_linux_virtual_machine"
  prefixes      = ["corp", "prod"]
  suffixes      = ["db", "001"]
  separator     = "_"
  use_slug      = false
  random_length = 4
  clean_input   = true
}

# Result: "corp_prod_database_server_db_001_a1b2"

This provider supports 395 Azure resource types with accurate naming validation rules. Each resource type has specific constraints for:

• Minimum and maximum length
• Allowed characters and patterns
• Case sensitivity requirements
• Uniqueness scope (global, resource group, or parent resource)

locals {
  environment_config = {
    dev = {
      prefix = "dev"
      random_length = 3
    }
    prod = {
      prefix = "prod" 
      random_length = 5
    }
  }
  
  current_env = local.environment_config[var.environment]
}

data "azurecaf_name" "app_service" {
  name          = var.application_name
  resource_type = "azurerm_app_service"
  prefixes      = [local.current_env.prefix]
  random_length = local.current_env.random_length
}

# In your module
variable "project_name" {
  description = "Name of the project"
  type        = string
}

variable "environment" {
  description = "Environment (dev, test, prod)"
  type        = string
}

data "azurecaf_name" "resources" {
  for_each = toset([
    "azurerm_resource_group",
    "azurerm_storage_account", 
    "azurerm_key_vault"
  ])
  
  name          = var.project_name
  resource_type = each.key
  prefixes      = [var.environment]
  random_length = 3
}

output "resource_names" {
  value = { for k, v in data.azurecaf_name.resources : k => v.result }
}

Issue: Names too long for resource type

# Problem: Generated name exceeds Azure limits
data "azurecaf_name" "long_name" {
  name          = "very-long-application-name-that-exceeds-limits"
  resource_type = "azurerm_storage_account"  # max 24 chars
}

# Solution: Use shorter base name or disable slug
data "azurecaf_name" "fixed_name" {
  name          = "shortname"
  resource_type = "azurerm_storage_account"
  use_slug      = false  # Removes 'st' prefix
}

Issue: Invalid characters in resource names

# Problem: Special characters not allowed
data "azurecaf_name" "invalid_chars" {
  name          = "[email protected]"
  resource_type = "azurerm_app_service"
  clean_input   = false  # Keeps invalid chars
}

# Solution: Enable input cleaning (default)
data "azurecaf_name" "clean_name" {
  name          = "[email protected]"
  resource_type = "azurerm_app_service"
  clean_input   = true   # Removes invalid chars
}

The provider validates names against Azure requirements and will show specific error messages:

Error: Invalid resource name "my--invalid--name"
│ The generated name contains consecutive separators, which is not allowed for azurerm_storage_account

The Azure CAF terraform provider includes comprehensive testing to ensure reliability and correctness.

To run the standard unit tests:

go test ./azurecaf/...

To run tests with coverage information:

go test -cover ./azurecaf/...

For a detailed coverage report:

go test -coverprofile=coverage.out ./azurecaf/...
go tool cover -html=coverage.out -o coverage.html

Integration tests verify the provider works correctly with Terraform itself. These tests require setting the TF_ACC environment variable:

# Run all integration tests
TF_ACC=1 go test -v ./azurecaf/... -run="TestAcc"

# Run specific integration tests
TF_ACC=1 go test -v ./azurecaf/... -run="TestAccDataSourcesIntegration"
TF_ACC=1 go test -v ./azurecaf/... -run="TestAccErrorHandling"

Note: Integration tests take longer to run than unit tests.

The project maintains high test coverage (99.0% of statements) to ensure code quality and reliability. Tests are designed to cover:

• Basic functionality for all resources and data sources
• Edge cases and error handling
• Various resource types and naming conventions
• Different configuration combinations
• Environment variable interactions
• Validation and constraints

The test files are organized as follows:

• Unit Tests: Basic test files like resource_name_test.go
• Enhanced Tests: More comprehensive tests in files like enhanced_tests_test.go
• Integration Tests: Tests with the prefix TestAcc that interact with Terraform directly
• Error Handling Tests: Tests that verify proper error reporting in edge cases
• Complete Coverage Tests: Tests designed specifically to achieve maximum code coverage
• Resource Matrix Tests: Comprehensive validation of all 395 resource types
• Constraint Tests: Validation of resource naming constraints and limitations

The provider includes a comprehensive testing framework that validates all 395 Azure resource types:

# Run comprehensive tests for all resource types
make test_all_resources

# Run resource matrix validation (category-based testing)
make test_resource_matrix

# Run resource constraint validation
make test_resource_constraints

# Test resource definition completeness
make test_resource_definitions

This framework ensures:

• 100% Resource Coverage: All 395 resource types are tested
• Naming Validation: Each resource type's naming constraints are verified
• Category Organization: Resources are tested by logical categories (Compute, Networking, etc.)
• Edge Case Testing: Complex naming scenarios and error conditions are validated

When writing new tests, consider the following guidelines:

1. Unit Tests: Test individual functions and components in isolation
2. Integration Tests: Test full resources with actual Terraform configurations
3. Error Cases: Include tests for edge cases and error conditions
4. Resource Types: Test with various Azure resource types to ensure naming compatibility
5. Validation: Test validation rules for different resource constraints

The project includes Makefile targets for common testing operations:

# Run unit tests without coverage
make unittest

# Run tests with coverage reporting
make test_coverage

# Generate HTML coverage report
make test_coverage_html

# Run integration tests
make test_integration

# Run data source integration tests
make test_data_sources

# Run error handling integration tests
make test_error_handling

# Run resource naming convention tests
make test_resource_naming

# Run all tests (unit and integration)
make test_all

# Run CI tests (unit tests with coverage, no integration tests)
make test_ci

# Comprehensive testing framework
make test_all_resources          # Test all 395 resource types
make test_resource_matrix        # Category-based resource testing
make test_resource_constraints   # Validation constraint testing
make test_resource_definitions   # Resource definition completeness

# Build the project and run unit tests
make build

# Clean up build artifacts
make clean

1. Clone the repository:

   git clone https://github.com/aztfmod/terraform-provider-azurecaf.git
   cd terraform-provider-azurecaf

2. Build the provider:

   make build

3. Run tests:

   # Unit tests only
   make unittest
   
   # All tests (unit + integration)  
   make test_all

For detailed testing information, see TESTING.md.

We welcome contributions to the Azure CAF Terraform Provider! Here's how you can help:

• 🐛 Bug Reports: Open an issue with detailed reproduction steps
• 💡 Feature Requests: Discuss new features in issues before implementing
• 📝 Documentation: Help improve documentation and examples
• 🔧 Code: Submit pull requests for bug fixes and new features

For detailed contribution guidelines, see CONTRIBUTING.md.

1. Check the resource status table to see if it's already implemented
2. Create an issue requesting the new resource type
3. Add the resource definition to resourceDefinition.json
4. Run make build to generate the updated code
5. Add tests and submit a pull request

• 💬 Questions: Reach out to tf-landingzones at microsoft dot com
• 💭 Discussions: Join us on Gitter
• 🐛 Issues: Report bugs and request features on GitHub Issues

This provider supports 395 Azure resource types. Here's the implementation status compared to the azurerm provider:

This project is licensed under the MIT License - see the LICENSE file for details.

• Microsoft Azure team for the Cloud Adoption Framework guidelines
• Terraform community for the excellent provider SDK
• All contributors who have helped improve this provider

Made with ❤️ by the Azure CAF community

❌ = Not yet implemented ✔ = Already implemented ⚠ = Will not be implemented