feat: add test cases and make corrections

client/model_interation.go → client/model_integration.go

@@ -41,8 +41,8 @@ type IntegrationUpdateParam struct {
 
 // ConfigItemParam struct for ConfigItemParam
 type ConfigItemParam struct {
-	Key   string `json:"key,omitempty"`
-	Value string `json:"value,omitempty"`
+	Key   string `json:"key"`
+	Value string `json:"value"`
 }
 
 // PageNumResultIntegrationVO struct for PageNumResultIntegrationVO

examples/resources/quick-start/resource.tf

@@ -10,8 +10,8 @@ locals {
   env_id = "example"
 
   automq_byoc_host          = "http://localhost:8081"
-  automq_byoc_access_key_id = "goiNxB8DfbbXJ85B"
-  automq_byoc_secret_key    = "QPyEIcBXHKOBzEeeCZcpNSMRjXtj4XiS"
+  automq_byoc_access_key_id = "RSaIMzrFC0kAmS1x"
+  automq_byoc_secret_key    = "msnGqOuaV5gblXPvkWfxg7Ao7Nq2iyMo"
 
   instance_deploy_region = "cn-hangzhou"
   instance_deploy_zone   = "cn-hangzhou-b"
@@ -48,11 +48,15 @@ resource "automq_kafka_instance" "example" {
     }
   ]
   compute_specs = {
-    aku     = "12"
+    aku     = "18"
     version = "1.1.0"
   }
   acl          = true
   integrations = [automq_integration.example.id]
+  configs = {
+    "auto.create.topics.enable" = "false"
+    "log.retention.ms"          = "3600000"
+  }
 }
 
 resource "automq_kafka_topic" "example" {
@@ -72,7 +76,7 @@ resource "automq_kafka_user" "example" {
   environment_id = local.env_id
 
   kafka_instance_id = automq_kafka_instance.example.id
-  username          = "automq_kafka_user"
+  username          = "automq_kafka_user-1"
   password          = "automq_kafka_user"
 }
 

go.mod

@@ -10,11 +10,16 @@ require (
 	github.com/hashicorp/terraform-plugin-log v0.9.0
 	github.com/hashicorp/terraform-plugin-sdk/v2 v2.34.0
 	github.com/hashicorp/terraform-plugin-testing v1.10.0
+	github.com/stretchr/testify v1.9.0
 	github.com/testcontainers/testcontainers-go v0.32.0
 	github.com/wiremock/go-wiremock v1.9.0
 )
 
-require github.com/hashicorp/go-retryablehttp v0.7.7 // indirect
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/hashicorp/go-retryablehttp v0.7.7 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+)
 
 require (
 	dario.cat/mergo v1.0.0 // indirect

internal/models/acl.go

@@ -1,8 +1,10 @@
 package models
 
 import (
+	"fmt"
 	"terraform-provider-automq/client"
 
+	"github.com/hashicorp/terraform-plugin-framework/diag"
 	"github.com/hashicorp/terraform-plugin-framework/types"
 )
 
@@ -19,30 +21,42 @@ type KafkaAclResourceModel struct {
 	Permission     types.String `tfsdk:"permission"`
 }
 
-func ExpandKafkaACLResource(acl KafkaAclResourceModel, request *client.KafkaAclBindingParam) {
+func ExpandKafkaACLResource(acl KafkaAclResourceModel, request *client.KafkaAclBindingParam) diag.Diagnostics {
 	request.AccessControlParam = client.KafkaControlParam{}
 	request.ResourcePatternParam = client.KafkaResourcePatternParam{}
 	request.AccessControlParam.OperationGroup = acl.OperationGroup.ValueString()
 	request.AccessControlParam.PermissionType = acl.Permission.ValueString()
 
-	request.AccessControlParam.User = ParsePrincipalUser(acl.Principal.ValueString())
+	user, err := ParsePrincipalUser(acl.Principal.ValueString())
+	if err != nil {
+		return diag.Diagnostics{diag.NewErrorDiagnostic("Failed to parse principal", err.Error())}
+	}
 
+	request.AccessControlParam.User = user
 	request.ResourcePatternParam.Name = acl.ResourceName.ValueString()
 	request.ResourcePatternParam.PatternType = acl.PatternType.ValueString()
 	request.ResourcePatternParam.ResourceType = acl.ResourceType.ValueString()
+	return nil
 }
 
-func ParsePrincipalUser(principal string) string {
-	if condition := principal[:5]; condition == "User:" {
-		return principal[5:]
+func ParsePrincipalUser(principal string) (string, error) {
+	if len(principal) < 5 {
+		return "", fmt.Errorf("invalid principal format: %s", principal)
+	}
+	if condition := principal[:5]; condition != "User:" {
+		return "", fmt.Errorf("invalid principal format: %s", principal)
+	}
+	user := principal[5:]
+	if user == "" {
+		return "", fmt.Errorf("invalid principal format: %s", principal)
 	}
-	return principal
+	return user, nil
 }
 
-func FlattenKafkaACLResource(acl *client.KafkaAclBindingVO, resource *KafkaAclResourceModel) {
+func FlattenKafkaACLResource(acl *client.KafkaAclBindingVO, resource *KafkaAclResourceModel) diag.Diagnostics {
 	aclId, err := client.GenerateAclID(*acl)
 	if err != nil {
-		return
+		return diag.Diagnostics{diag.NewErrorDiagnostic("Failed to generate ACL ID", err.Error())}
 	}
 	resource.ID = types.StringValue(aclId)
 
@@ -52,4 +66,5 @@ func FlattenKafkaACLResource(acl *client.KafkaAclBindingVO, resource *KafkaAclRe
 	resource.Principal = types.StringValue("User:" + acl.AccessControl.User)
 	resource.OperationGroup = types.StringValue(acl.AccessControl.OperationGroup.Name)
 	resource.Permission = types.StringValue(acl.AccessControl.PermissionType)
+	return nil
 }

internal/models/acl_test.go

@@ -0,0 +1,152 @@
+package models
+
+import (
+	"terraform-provider-automq/client"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestExpandKafkaACLResource(t *testing.T) {
+	tests := []struct {
+		acl      KafkaAclResourceModel
+		expected client.KafkaAclBindingParam
+	}{
+		{
+			acl: KafkaAclResourceModel{
+				EnvironmentID:  types.StringValue("env-123"),
+				KafkaInstance:  types.StringValue("kafka-123"),
+				ID:             types.StringValue("acl-123"),
+				ResourceType:   types.StringValue("topic"),
+				ResourceName:   types.StringValue("test-topic"),
+				PatternType:    types.StringValue("literal"),
+				Principal:      types.StringValue("User:test-user"),
+				OperationGroup: types.StringValue("read"),
+				Permission:     types.StringValue("allow"),
+			},
+			expected: client.KafkaAclBindingParam{
+				AccessControlParam: client.KafkaControlParam{
+					OperationGroup: "read",
+					PermissionType: "allow",
+					User:           "test-user",
+				},
+				ResourcePatternParam: client.KafkaResourcePatternParam{
+					Name:         "test-topic",
+					PatternType:  "literal",
+					ResourceType: "topic",
+				},
+			},
+		},
+		{
+			acl: KafkaAclResourceModel{
+				Principal: types.StringValue("admin"),
+			},
+			expected: client.KafkaAclBindingParam{
+				AccessControlParam: client.KafkaControlParam{
+					User: "admin",
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		request := &client.KafkaAclBindingParam{}
+		ExpandKafkaACLResource(test.acl, request)
+
+		assert.Equal(t, test.expected.AccessControlParam.OperationGroup, request.AccessControlParam.OperationGroup)
+		assert.Equal(t, test.expected.AccessControlParam.PermissionType, request.AccessControlParam.PermissionType)
+		assert.Equal(t, test.expected.AccessControlParam.User, request.AccessControlParam.User)
+		assert.Equal(t, test.expected.ResourcePatternParam.Name, request.ResourcePatternParam.Name)
+		assert.Equal(t, test.expected.ResourcePatternParam.PatternType, request.ResourcePatternParam.PatternType)
+		assert.Equal(t, test.expected.ResourcePatternParam.ResourceType, request.ResourcePatternParam.ResourceType)
+	}
+}
+
+func TestParsePrincipalUser(t *testing.T) {
+	tests := []struct {
+		principal string
+		hasDiag   bool
+		expected  string
+	}{
+		{
+			principal: "User:test-user",
+			expected:  "test-user",
+			hasDiag:   false,
+		},
+		{
+			principal: "User:admin",
+			expected:  "admin",
+			hasDiag:   false,
+		},
+		{
+			principal: "User:admin:admin",
+			expected:  "admin:admin",
+			hasDiag:   false,
+		},
+		{
+			principal: "User:",
+			expected:  "",
+			hasDiag:   true,
+		},
+		{
+			principal: "User",
+			expected:  "",
+			hasDiag:   true,
+		},
+	}
+	for _, test := range tests {
+		user, err := ParsePrincipalUser(test.principal)
+
+		if test.hasDiag {
+			assert.NotNil(t, err)
+		} else {
+			assert.Nil(t, err)
+			assert.Equal(t, test.expected, user)
+		}
+	}
+}
+
+func TestFlattenKafkaACLResource(t *testing.T) {
+	tests := []struct {
+		acl      *client.KafkaAclBindingVO
+		expected KafkaAclResourceModel
+	}{
+		{
+			acl: &client.KafkaAclBindingVO{
+				ResourcePattern: &client.KafkaResourcePatternVO{
+					ResourceType: "topic",
+					Name:         "test-topic",
+					PatternType:  "literal",
+				},
+				AccessControl: &client.KafkaAccessControlVO{
+					User:           "test-user",
+					OperationGroup: client.OperationGroup{Name: "read"},
+					PermissionType: "allow",
+				},
+			},
+			expected: KafkaAclResourceModel{
+				ResourceType:   types.StringValue("topic"),
+				ResourceName:   types.StringValue("test-topic"),
+				PatternType:    types.StringValue("literal"),
+				Principal:      types.StringValue("User:test-user"),
+				OperationGroup: types.StringValue("read"),
+				Permission:     types.StringValue("allow"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		resource := &KafkaAclResourceModel{}
+		diag := FlattenKafkaACLResource(test.acl, resource)
+
+		assert.Nil(t, diag)
+
+		assert.Equal(t, test.expected.ResourceType.ValueString(), resource.ResourceType.ValueString())
+		assert.Equal(t, test.expected.ResourceName.ValueString(), resource.ResourceName.ValueString())
+		assert.Equal(t, test.expected.PatternType.ValueString(), resource.PatternType.ValueString())
+		assert.Equal(t, test.expected.Principal.ValueString(), resource.Principal.ValueString())
+		assert.Equal(t, test.expected.OperationGroup.ValueString(), resource.OperationGroup.ValueString())
+		assert.Equal(t, test.expected.Permission.ValueString(), resource.Permission.ValueString())
+	}
+}

internal/models/intergation.go

@@ -8,6 +8,15 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/types"
 )
 
+const (
+	IntegrationTypeCloudWatch = "cloudWatch"
+	IntegrationTypeKafka      = "kafka"
+	IntegrationTypePrometheus = "prometheus"
+
+	SecurityProtocolSASLPlain = "SASL_PLAINTEXT"
+	SecurityProtocolPlainText = "PLAINTEXT"
+)
+
 // IntegrationResourceModel describes the resource data model.
 type IntegrationResourceModel struct {
 	EnvironmentID    types.String                 `tfsdk:"environment_id"`
@@ -43,7 +52,7 @@ func ExpandIntergationResource(in *client.IntegrationParam, integration Integrat
 	integrationType := integration.Type.ValueString()
 	in.Name = integration.Name.ValueString()
 	in.Type = &integrationType
-	if integrationType == "cloudWatch" {
+	if integrationType == IntegrationTypeCloudWatch {
 		in.Name = integration.Name.ValueString()
 		if integration.CloudWatchConfig == nil {
 			return diag.NewErrorDiagnostic("Missing required field", "cloud_watch_config is required for CloudWatch integration")
@@ -57,7 +66,7 @@ func ExpandIntergationResource(in *client.IntegrationParam, integration Integrat
 				Value: integration.CloudWatchConfig.NameSpace.ValueString(),
 			},
 		}
-	} else if integrationType == "kafka" {
+	} else if integrationType == IntegrationTypeKafka {
 		in.Name = integration.Name.ValueString()
 		if integration.EndPoint.IsNull() || integration.EndPoint.IsUnknown() {
 			return diag.NewErrorDiagnostic("Missing required field", "endpoint is required for Kafka integration")
@@ -69,7 +78,7 @@ func ExpandIntergationResource(in *client.IntegrationParam, integration Integrat
 		if integration.KafkaConfig.SecurityProtocol.ValueString() == "" {
 			return diag.NewErrorDiagnostic("Missing required field", "security_protocol is required for Kafka integration")
 		}
-		if integration.KafkaConfig.SecurityProtocol.ValueString() == "SASL_PLAINTEXT" {
+		if integration.KafkaConfig.SecurityProtocol.ValueString() == SecurityProtocolSASLPlain {
 			if integration.KafkaConfig.SaslMechanism.ValueString() == "" {
 				return diag.NewErrorDiagnostic("Missing required field", "sasl_mechanism is required for Kafka integration")
 			}
@@ -97,15 +106,15 @@ func ExpandIntergationResource(in *client.IntegrationParam, integration Integrat
 					Value: integration.KafkaConfig.SaslPassword.ValueString(),
 				},
 			}
-		} else if integration.KafkaConfig.SecurityProtocol.ValueString() == "PLAINTEXT" {
+		} else if integration.KafkaConfig.SecurityProtocol.ValueString() == SecurityProtocolPlainText {
 			in.Config = []client.ConfigItemParam{
 				{
 					Key:   "security_protocol",
 					Value: integration.KafkaConfig.SecurityProtocol.ValueString(),
 				},
 			}
 		}
-	} else if integrationType == "prometheus" {
+	} else if integrationType == IntegrationTypePrometheus {
 		in.Name = integration.Name.ValueString()
 		if integration.EndPoint.IsNull() || integration.EndPoint.IsUnknown() {
 			return diag.NewErrorDiagnostic("Missing required field", "endpoint is required for Prometheus integration")
@@ -125,21 +134,21 @@ func FlattenIntergrationResource(integration *client.IntegrationVO, resource *In
 }
 
 func flattenIntergrationTypeConfig(iType string, config map[string]interface{}, resource *IntegrationResourceModel) {
-	if iType == "Kafka" {
+	if iType == IntegrationTypeKafka {
 		flattenKafkaConfig(config, resource)
 		return
-	} else if iType == "CloudWatch" {
+	} else if iType == IntegrationTypeCloudWatch {
 		flattenCloudWatchConfig(config, resource)
 		return
-	} else if iType == "Prometheus" {
+	} else if iType == IntegrationTypePrometheus {
 		return
 	}
 }
 
 func flattenKafkaConfig(config map[string]interface{}, resource *IntegrationResourceModel) {
 	resource.KafkaConfig = &KafkaIntegrationConfig{}
 	if v, ok := config["securityProtocol"]; ok {
-		resource.KafkaConfig.SaslMechanism = types.StringValue(v.(string))
+		resource.KafkaConfig.SecurityProtocol = types.StringValue(v.(string))
 	}
 	if v, ok := config["saslMechanism"]; ok {
 		resource.KafkaConfig.SaslMechanism = types.StringValue(v.(string))
@@ -154,7 +163,7 @@ func flattenKafkaConfig(config map[string]interface{}, resource *IntegrationReso
 
 func flattenCloudWatchConfig(config map[string]interface{}, resource *IntegrationResourceModel) {
 	resource.CloudWatchConfig = &CloudWatchIntegrationConfig{}
-	if v, ok := config["namespece"]; ok {
+	if v, ok := config["namespace"]; ok {
 		resource.CloudWatchConfig.NameSpace = types.StringValue(v.(string))
 	}
 }