From 99f69e19de8950698308c18f20cd88f09b3fe950 Mon Sep 17 00:00:00 2001 From: WestonPlatter Date: Thu, 3 Jul 2025 14:31:09 -0600 Subject: [PATCH 1/2] feat: add some basic tests for this repo --- .gitignore | 5 ++ tests/locals.tftest.hcl | 193 ++++++++++++++++++++++++++++++++++++++++ tests/main.tftest.hcl | 147 ++++++++++++++++++++++++++++++ 3 files changed, 345 insertions(+) create mode 100644 tests/locals.tftest.hcl create mode 100644 tests/main.tftest.hcl diff --git a/.gitignore b/.gitignore index 9636abe..5263ae8 100644 --- a/.gitignore +++ b/.gitignore @@ -44,3 +44,8 @@ backend.tf.json **/*.bak **/*.*swp **/.DS_Store + +CLAUDE.md +.claude/* +.cursor/* + diff --git a/tests/locals.tftest.hcl b/tests/locals.tftest.hcl new file mode 100644 index 0000000..6d2b2f7 --- /dev/null +++ b/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" + } +} diff --git a/tests/main.tftest.hcl b/tests/main.tftest.hcl new file mode 100644 index 0000000..ac4f97f --- /dev/null +++ b/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 = can(datadog_user.users["testuser"]) + 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" + } +} From a1f45aa2185131b5ff45bab8f942abf64b936503 Mon Sep 17 00:00:00 2001 From: WestonPlatter Date: Thu, 3 Jul 2025 14:34:30 -0600 Subject: [PATCH 2/2] fix: update testing syntax to be terraform applicable --- tests/main.tftest.hcl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/main.tftest.hcl b/tests/main.tftest.hcl index ac4f97f..5b8fbb3 100644 --- a/tests/main.tftest.hcl +++ b/tests/main.tftest.hcl @@ -34,7 +34,7 @@ run "test_datadog_user_basic_creation" { } assert { - condition = can(datadog_user.users["testuser"]) + condition = datadog_user.users["testuser"] != null error_message = "Should create datadog_user resource with key 'testuser'" }