feat: using the MP tf test prompt, add some basic tests

.gitignore

@@ -44,3 +44,8 @@ backend.tf.json
 **/*.bak
 **/*.*swp
 **/.DS_Store
+
+CLAUDE.md
+.claude/*
+.cursor/*
+

tests/locals.tftest.hcl

@@ -0,0 +1,193 @@
+# Test file for locals block logic validation in main.tf
+# Focus: Testing user list-to-map transformation and role mapping
+
+# Mock provider for Datadog data sources
+mock_provider "datadog" {
+  mock_data "datadog_role" {
+    defaults = {
+      id = "mock-role-id"
+    }
+  }
+}
+
+# Test 1: Basic users list-to-map transformation
+run "test_users_list_to_map_transformation" {
+  command = plan
+
+  variables {
+    users = [
+      {
+        username             = "johndoe"
+        email               = "john.doe@example.com"
+        name                = "John Doe"
+        roles               = ["standard"]
+        disabled            = false
+        send_user_invitation = true
+      },
+      {
+        username             = "janesmith"
+        email               = "jane.smith@example.com"
+        name                = "Jane Smith"
+        roles               = ["admin", "read_only"]
+        disabled            = false
+        send_user_invitation = true
+      }
+    ]
+  }
+
+  assert {
+    condition = length(local.users) == 2
+    error_message = "Users map should contain exactly 2 users"
+  }
+
+  assert {
+    condition = contains(keys(local.users), "johndoe")
+    error_message = "Users map should contain key 'johndoe'"
+  }
+
+  assert {
+    condition = contains(keys(local.users), "janesmith")
+    error_message = "Users map should contain key 'janesmith'"
+  }
+
+  assert {
+    condition = local.users["johndoe"].email == "john.doe@example.com"
+    error_message = "User johndoe should have correct email address"
+  }
+
+  assert {
+    condition = local.users["janesmith"].name == "Jane Smith"
+    error_message = "User janesmith should have correct name"
+  }
+}
+
+# Test 2: Roles mapping and data source integration
+run "test_roles_mapping_logic" {
+  command = plan
+
+  variables {
+    users = [
+      {
+        username             = "testuser"
+        email               = "test@example.com"
+        name                = "Test User"
+        roles               = ["standard"]
+        disabled            = false
+        send_user_invitation = true
+      }
+    ]
+  }
+
+  assert {
+    condition = length(local.roles) == 3
+    error_message = "Roles map should contain exactly 3 role mappings"
+  }
+
+  assert {
+    condition = contains(keys(local.roles), "standard")
+    error_message = "Roles map should contain 'standard' key"
+  }
+
+  assert {
+    condition = contains(keys(local.roles), "admin")
+    error_message = "Roles map should contain 'admin' key"
+  }
+
+  assert {
+    condition = contains(keys(local.roles), "read_only")
+    error_message = "Roles map should contain 'read_only' key"
+  }
+
+  assert {
+    condition = local.roles["standard"] == data.datadog_role.standard.id
+    error_message = "Standard role should map to correct data source ID"
+  }
+
+  assert {
+    condition = local.roles["admin"] == data.datadog_role.admin.id
+    error_message = "Admin role should map to correct data source ID"
+  }
+
+  assert {
+    condition = local.roles["read_only"] == data.datadog_role.read_only.id
+    error_message = "Read-only role should map to correct data source ID"
+  }
+}
+
+# Test 3: Edge cases - empty users list and unique usernames
+run "test_edge_cases_empty_users_and_uniqueness" {
+  command = plan
+
+  variables {
+    users = []
+  }
+
+  assert {
+    condition = length(local.users) == 0
+    error_message = "Empty users list should result in empty users map"
+  }
+
+  assert {
+    condition = length(local.roles) == 3
+    error_message = "Roles map should still contain 3 mappings even with empty users"
+  }
+}
+
+# Test 4: Multiple users with different role combinations
+run "test_multiple_users_different_roles" {
+  command = plan
+
+  variables {
+    users = [
+      {
+        username             = "admin_user"
+        email               = "admin@example.com"
+        name                = "Admin User"
+        roles               = ["admin"]
+        disabled            = false
+        send_user_invitation = true
+      },
+      {
+        username             = "readonly_user"
+        email               = "readonly@example.com"
+        name                = "Read Only User"
+        roles               = ["read_only"]
+        disabled            = true
+        send_user_invitation = false
+      },
+      {
+        username             = "multi_role_user"
+        email               = "multi@example.com"
+        name                = "Multi Role User"
+        roles               = ["standard", "admin"]
+        disabled            = false
+        send_user_invitation = true
+      }
+    ]
+  }
+
+  assert {
+    condition = length(local.users) == 3
+    error_message = "Users map should contain exactly 3 users"
+  }
+
+  assert {
+    condition = length(distinct(keys(local.users))) == length(keys(local.users))
+    error_message = "All user keys should be unique (no duplicate usernames)"
+  }
+
+  assert {
+    condition = local.users["admin_user"].roles == toset(["admin"])
+    error_message = "Admin user should have correct roles"
+  }
+
+  assert {
+    condition = local.users["readonly_user"].disabled == true
+    error_message = "Read-only user should be disabled"
+  }
+
+  assert {
+    condition = local.users["multi_role_user"].roles == toset(["standard", "admin"])
+    error_message = "Multi-role user should have correct roles set"
+  }
+}

tests/main.tftest.hcl

@@ -0,0 +1,147 @@
+# Test file for main.tf resource logic validation
+# Focus: Testing datadog_user resource creation and basic attribute mapping
+
+# Mock provider for Datadog resources and data sources
+mock_provider "datadog" {
+  mock_data "datadog_role" {
+    defaults = {
+      id = "mock-role-id"
+    }
+  }
+
+  mock_resource "datadog_user" {
+    defaults = {
+      id = "mock-user-id"
+    }
+  }
+}
+
+# Test 1: Basic datadog_user resource creation
+run "test_datadog_user_basic_creation" {
+  command = plan
+
+  variables {
+    users = [
+      {
+        username             = "testuser"
+        email               = "test@example.com"
+        name                = "Test User"
+        roles               = ["standard"]
+        disabled            = false
+        send_user_invitation = true
+      }
+    ]
+  }
+
+  assert {
+    condition = datadog_user.users["testuser"] != null
+    error_message = "Should create datadog_user resource with key 'testuser'"
+  }
+
+  assert {
+    condition = datadog_user.users["testuser"].email == "test@example.com"
+    error_message = "User email should be correctly mapped to resource attribute"
+  }
+}
+
+# Test 2: Complex multiple users and role mapping logic
+run "test_multiple_users_and_role_mapping" {
+  command = plan
+
+  variables {
+    users = [
+      {
+        username             = "admin_user"
+        email               = "admin@example.com"
+        name                = "Admin User"
+        roles               = ["admin"]
+        disabled            = false
+        send_user_invitation = true
+      },
+      {
+        username             = "readonly_user"
+        email               = "readonly@example.com"
+        name                = "Read Only User"
+        roles               = ["read_only"]
+        disabled            = true
+        send_user_invitation = false
+      },
+      {
+        username             = "standard_user"
+        email               = "standard@example.com"
+        name                = "Standard User"
+        roles               = ["standard"]
+        disabled            = false
+        send_user_invitation = true
+      }
+    ]
+  }
+
+  # Test that all three users are created
+  assert {
+    condition = length(keys(datadog_user.users)) == 3
+    error_message = "Should create exactly 3 datadog_user resources"
+  }
+
+  # Test role mapping logic works (each user has roles populated)
+  assert {
+    condition = length(datadog_user.users["admin_user"].roles) == 1
+    error_message = "Admin user should have 1 role mapped"
+  }
+
+  assert {
+    condition = length(datadog_user.users["readonly_user"].roles) == 1
+    error_message = "Read-only user should have 1 role mapped"
+  }
+
+  assert {
+    condition = length(datadog_user.users["standard_user"].roles) == 1
+    error_message = "Standard user should have 1 role mapped"
+  }
+
+  # Test that role mapping transformation works (roles are populated with mock IDs)
+  assert {
+    condition = alltrue([
+      for role in datadog_user.users["admin_user"].roles :
+      role == "mock-role-id"
+    ])
+    error_message = "Admin user roles should be mapped to mock data source ID"
+  }
+
+  # Test different attribute combinations
+  assert {
+    condition = datadog_user.users["readonly_user"].disabled == true
+    error_message = "Read-only user should be disabled"
+  }
+
+  assert {
+    condition = datadog_user.users["readonly_user"].send_user_invitation == false
+    error_message = "Read-only user should not send invitation"
+  }
+
+  assert {
+    condition = datadog_user.users["admin_user"].disabled == false
+    error_message = "Admin user should be enabled"
+  }
+
+  # Test that resource keys match usernames (critical for for_each)
+  assert {
+    condition = alltrue([
+      contains(keys(datadog_user.users), "admin_user"),
+      contains(keys(datadog_user.users), "readonly_user"),
+      contains(keys(datadog_user.users), "standard_user")
+    ])
+    error_message = "All expected user keys should be present in datadog_user resources"
+  }
+
+  # Test that names and emails are correctly mapped
+  assert {
+    condition = datadog_user.users["readonly_user"].name == "Read Only User"
+    error_message = "Read-only user should have correct name"
+  }
+
+  assert {
+    condition = datadog_user.users["standard_user"].email == "standard@example.com"
+    error_message = "Standard user should have correct email"
+  }
+}