This is an automated email from the ASF dual-hosted git repository. alexstocks pushed a commit to branch main in repository https://gitbox.apache.org/repos/asf/dubbo-go.git
commit 9438a1bb21fc1acd9011625b756a45aff0495cd5 Author: Akashisang <[email protected]> AuthorDate: Mon Dec 22 07:34:28 2025 +0800 test: add unit test for global (#3124) * test: add unit test for global --- global/config_test.go | 1729 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1729 insertions(+) diff --git a/global/config_test.go b/global/config_test.go index c436a7d75..7a7ea21e9 100644 --- a/global/config_test.go +++ b/global/config_test.go @@ -319,3 +319,1732 @@ func CheckCompleteInequality(t *testing.T, origin any, clone any) { } } } +func TestReferenceConfigGetOptions(t *testing.T) { + t.Run("full_reference_config", func(t *testing.T) { + ref := &ReferenceConfig{ + InterfaceName: "com.test.Service", + URL: "localhost:20880", + Filter: "echo", + Protocol: "dubbo", + Cluster: "failover", + Loadbalance: "random", + Retries: "3", + Group: "test", + Version: "1.0.0", + Serialization: "hessian2", + ProvidedBy: "provider", + Async: true, + Generic: "true", + Sticky: true, + RequestTimeout: "5s", + TracingKey: "jaeger", + MeshProviderPort: 8080, + KeepAliveInterval: "1m", + KeepAliveTimeout: "30s", + Params: map[string]string{ + "key": "value", + }, + Check: func() *bool { b := true; return &b }(), + RegistryIDs: []string{"reg1", "reg2"}, + MethodsConfig: []*MethodConfig{ + {Name: "method1"}, + }, + ProtocolClientConfig: DefaultClientProtocolConfig(), + } + + opts := ref.GetOptions() + assert.NotNil(t, opts, "opts should not be nil") + assert.True(t, len(opts) > 0, "opts should have items") + }) + + t.Run("empty_reference_config", func(t *testing.T) { + emptyRef := &ReferenceConfig{} + emptyOpts := emptyRef.GetOptions() + // An empty config will return nil from GetOptions since all fields are empty + if emptyOpts != nil { + assert.Equal(t, 0, len(emptyOpts), "empty ref config should have no options") + } + }) + + t.Run("reference_config_with_retries_parsing", func(t *testing.T) { + ref := &ReferenceConfig{ + Retries: "5", + } + opts := ref.GetOptions() + assert.NotNil(t, opts) + // Verify that a valid retries value produces at least one option + assert.Greater(t, len(opts), 0, "should have at least one option from Retries") + }) + + t.Run("reference_config_with_invalid_retries", func(t *testing.T) { + ref := &ReferenceConfig{ + Retries: "invalid", + } + opts := ref.GetOptions() + // Invalid retries should not be added to options + // This is expected behavior - invalid values are silently skipped + // Verify the returned options do not contain a retries option + // by confirming the invalid string is not converted + + // GetOptions returns nil (or empty slice) when no options are present + // Since Retries is the only field and it's invalid, no options should be produced + if opts != nil { + // If opts is returned as a slice, it should be empty since Retries is invalid + assert.Equal(t, 0, len(opts), "invalid retries value should not produce any options") + } + // The fact that invalid retries is not in opts confirms it was rejected + }) +} + +// TestReferenceConfigClone tests the Clone method of ReferenceConfig +func TestReferenceConfigClone(t *testing.T) { + t.Run("nil_reference_config_clone", func(t *testing.T) { + var nilRef *ReferenceConfig + cloned := nilRef.Clone() + assert.Nil(t, cloned) + }) +} + +// TestReferenceConfigOptions tests the option functions +func TestReferenceConfigOptions(t *testing.T) { + t.Run("WithReference_InterfaceName", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_InterfaceName("com.test.Service") + opt(ref) + assert.Equal(t, "com.test.Service", ref.InterfaceName) + }) + + t.Run("WithReference_Check_true", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Check(true) + opt(ref) + assert.NotNil(t, ref.Check) + assert.True(t, *ref.Check) + }) + + t.Run("WithReference_Check_false", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Check(false) + opt(ref) + assert.NotNil(t, ref.Check) + assert.False(t, *ref.Check) + }) + + t.Run("WithReference_URL", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_URL("localhost:20880") + opt(ref) + assert.Equal(t, "localhost:20880", ref.URL) + }) + + t.Run("WithReference_Filter", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Filter("echo") + opt(ref) + assert.Equal(t, "echo", ref.Filter) + }) + + t.Run("WithReference_Protocol", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Protocol("tri") + opt(ref) + assert.Equal(t, "tri", ref.Protocol) + }) + + t.Run("WithReference_RegistryIDs", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_RegistryIDs([]string{"reg1", "reg2"}) + opt(ref) + assert.Equal(t, 2, len(ref.RegistryIDs)) + assert.Equal(t, "reg1", ref.RegistryIDs[0]) + assert.Equal(t, "reg2", ref.RegistryIDs[1]) + }) + + t.Run("WithReference_RegistryIDs_empty", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_RegistryIDs([]string{}) + opt(ref) + assert.Equal(t, 0, len(ref.RegistryIDs)) + }) + + t.Run("WithReference_Cluster", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Cluster("failover") + opt(ref) + assert.Equal(t, "failover", ref.Cluster) + }) + + t.Run("WithReference_LoadBalance", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_LoadBalance("random") + opt(ref) + assert.Equal(t, "random", ref.Loadbalance) + }) + + t.Run("WithReference_Retries", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Retries(3) + opt(ref) + assert.Equal(t, "3", ref.Retries) + }) + + t.Run("WithReference_Group", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Group("test") + opt(ref) + assert.Equal(t, "test", ref.Group) + }) + + t.Run("WithReference_Version", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Version("1.0.0") + opt(ref) + assert.Equal(t, "1.0.0", ref.Version) + }) + + t.Run("WithReference_Serialization", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Serialization("hessian2") + opt(ref) + assert.Equal(t, "hessian2", ref.Serialization) + }) + + t.Run("WithReference_ProviderBy", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_ProviderBy("provider") + opt(ref) + assert.Equal(t, "provider", ref.ProvidedBy) + }) + + t.Run("WithReference_Async_true", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Async(true) + opt(ref) + assert.True(t, ref.Async) + }) + + t.Run("WithReference_Async_false", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Async(false) + opt(ref) + assert.False(t, ref.Async) + }) + + t.Run("WithReference_Params", func(t *testing.T) { + ref := &ReferenceConfig{} + params := map[string]string{"key": "value", "key2": "value2"} + opt := WithReference_Params(params) + opt(ref) + assert.Equal(t, "value", ref.Params["key"]) + assert.Equal(t, "value2", ref.Params["key2"]) + }) + + t.Run("WithReference_Generic", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Generic("true") + opt(ref) + assert.Equal(t, "true", ref.Generic) + }) + + t.Run("WithReference_Sticky", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Sticky(true) + opt(ref) + assert.True(t, ref.Sticky) + }) + + t.Run("WithReference_RequestTimeout", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_RequestTimeout("5s") + opt(ref) + assert.Equal(t, "5s", ref.RequestTimeout) + }) + + t.Run("WithReference_Force", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_Force(true) + opt(ref) + assert.True(t, ref.ForceTag) + }) + + t.Run("WithReference_TracingKey", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_TracingKey("jaeger") + opt(ref) + assert.Equal(t, "jaeger", ref.TracingKey) + }) + + t.Run("WithReference_MeshProviderPort", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_MeshProviderPort(8080) + opt(ref) + assert.Equal(t, 8080, ref.MeshProviderPort) + }) + + t.Run("WithReference_KeepAliveInterval", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_KeepAliveInterval("1m") + opt(ref) + assert.Equal(t, "1m", ref.KeepAliveInterval) + }) + + t.Run("WithReference_KeepAliveTimeout", func(t *testing.T) { + ref := &ReferenceConfig{} + opt := WithReference_KeepAliveTimeout("30s") + opt(ref) + assert.Equal(t, "30s", ref.KeepAliveTimeout) + }) + + t.Run("WithReference_ProtocolClientConfig", func(t *testing.T) { + ref := &ReferenceConfig{} + pcc := DefaultClientProtocolConfig() + opt := WithReference_ProtocolClientConfig(pcc) + opt(ref) + assert.NotNil(t, ref.ProtocolClientConfig) + }) +} +func TestRegistryConfigUseAsMetadataReport(t *testing.T) { + t.Run("empty_use_as_meta_report_defaults_to_true", func(t *testing.T) { + reg := &RegistryConfig{UseAsMetaReport: ""} + result, err := reg.UseAsMetadataReport() + assert.Nil(t, err) + assert.True(t, result) + }) + + t.Run("true_string", func(t *testing.T) { + reg := &RegistryConfig{UseAsMetaReport: "true"} + result, err := reg.UseAsMetadataReport() + assert.Nil(t, err) + assert.True(t, result) + }) + + t.Run("false_string", func(t *testing.T) { + reg := &RegistryConfig{UseAsMetaReport: "false"} + result, err := reg.UseAsMetadataReport() + assert.Nil(t, err) + assert.False(t, result) + }) + + t.Run("TRUE_uppercase", func(t *testing.T) { + reg := &RegistryConfig{UseAsMetaReport: "TRUE"} + result, err := reg.UseAsMetadataReport() + assert.Nil(t, err) + assert.True(t, result) + }) + + t.Run("FALSE_uppercase", func(t *testing.T) { + reg := &RegistryConfig{UseAsMetaReport: "FALSE"} + result, err := reg.UseAsMetadataReport() + assert.Nil(t, err) + assert.False(t, result) + }) + + t.Run("invalid_use_as_meta_report", func(t *testing.T) { + reg := &RegistryConfig{UseAsMetaReport: "invalid"} + result, err := reg.UseAsMetadataReport() + assert.NotNil(t, err) + assert.False(t, result) + }) + + t.Run("1_as_true", func(t *testing.T) { + reg := &RegistryConfig{UseAsMetaReport: "1"} + result, err := reg.UseAsMetadataReport() + assert.Nil(t, err) + assert.True(t, result) + }) + + t.Run("0_as_false", func(t *testing.T) { + reg := &RegistryConfig{UseAsMetaReport: "0"} + result, err := reg.UseAsMetadataReport() + assert.Nil(t, err) + assert.False(t, result) + }) +} + +// TestRegistryConfigClone tests the Clone method of RegistryConfig +func TestRegistryConfigClone(t *testing.T) { + t.Run("clone_full_registry_config", func(t *testing.T) { + reg := &RegistryConfig{ + Protocol: "zookeeper", + Timeout: "5s", + Group: "test", + Namespace: "ns", + TTL: "15m", + Address: "localhost:2181", + Username: "user", + Password: "pass", + Simplified: true, + Preferred: true, + Zone: "zone1", + Weight: 100, + UseAsMetaReport: "true", + UseAsConfigCenter: "true", + RegistryType: "nacos", + Params: map[string]string{ + "key1": "value1", + "key2": "value2", + }, + } + cloned := reg.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, reg.Protocol, cloned.Protocol) + assert.Equal(t, reg.Timeout, cloned.Timeout) + assert.Equal(t, reg.Group, cloned.Group) + assert.Equal(t, reg.Namespace, cloned.Namespace) + assert.Equal(t, reg.TTL, cloned.TTL) + assert.Equal(t, reg.Address, cloned.Address) + assert.Equal(t, reg.Username, cloned.Username) + assert.Equal(t, reg.Password, cloned.Password) + assert.Equal(t, reg.Simplified, cloned.Simplified) + assert.Equal(t, reg.Preferred, cloned.Preferred) + assert.Equal(t, reg.Zone, cloned.Zone) + assert.Equal(t, reg.Weight, cloned.Weight) + assert.Equal(t, reg.UseAsMetaReport, cloned.UseAsMetaReport) + assert.Equal(t, reg.UseAsConfigCenter, cloned.UseAsConfigCenter) + assert.NotSame(t, reg, cloned) + assert.NotSame(t, reg.Params, cloned.Params) + assert.Equal(t, "value1", cloned.Params["key1"]) + assert.Equal(t, "value2", cloned.Params["key2"]) + }) + + t.Run("clone_nil_registry_config", func(t *testing.T) { + var reg *RegistryConfig + cloned := reg.Clone() + assert.Nil(t, cloned) + }) + + t.Run("clone_empty_registry_config", func(t *testing.T) { + reg := &RegistryConfig{} + cloned := reg.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, reg, cloned) + }) + + t.Run("clone_with_empty_params", func(t *testing.T) { + reg := &RegistryConfig{ + Protocol: "nacos", + Params: make(map[string]string), + } + cloned := reg.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, 0, len(cloned.Params)) + assert.NotSame(t, reg.Params, cloned.Params) + }) +} + +// TestDefaultRegistryConfig tests DefaultRegistryConfig function +func TestDefaultRegistryConfig(t *testing.T) { + t.Run("default_registry_config", func(t *testing.T) { + reg := DefaultRegistryConfig() + assert.NotNil(t, reg) + assert.Equal(t, "true", reg.UseAsMetaReport) + assert.Equal(t, "true", reg.UseAsConfigCenter) + assert.Equal(t, "5s", reg.Timeout) + assert.Equal(t, "15m", reg.TTL) + }) +} + +// TestDefaultRegistriesConfig tests DefaultRegistriesConfig function +func TestDefaultRegistriesConfig(t *testing.T) { + t.Run("default_registries_config", func(t *testing.T) { + regs := DefaultRegistriesConfig() + assert.NotNil(t, regs) + assert.Equal(t, 0, len(regs)) + }) +} + +// TestCloneRegistriesConfig tests CloneRegistriesConfig function +func TestCloneRegistriesConfig(t *testing.T) { + t.Run("clone_multiple_registries", func(t *testing.T) { + regs := map[string]*RegistryConfig{ + "reg1": { + Protocol: "zookeeper", + Address: "localhost:2181", + Params: map[string]string{ + "key": "value", + }, + }, + "reg2": { + Protocol: "nacos", + Address: "localhost:8848", + Params: map[string]string{ + "key2": "value2", + }, + }, + } + cloned := CloneRegistriesConfig(regs) + assert.Equal(t, 2, len(cloned)) + assert.Equal(t, "zookeeper", cloned["reg1"].Protocol) + assert.Equal(t, "nacos", cloned["reg2"].Protocol) + assert.NotSame(t, regs["reg1"], cloned["reg1"]) + assert.NotSame(t, regs["reg2"], cloned["reg2"]) + assert.Equal(t, "value", cloned["reg1"].Params["key"]) + assert.Equal(t, "value2", cloned["reg2"].Params["key2"]) + }) + + t.Run("clone_nil_registries_config", func(t *testing.T) { + var regs map[string]*RegistryConfig + cloned := CloneRegistriesConfig(regs) + assert.Nil(t, cloned) + }) + + t.Run("clone_empty_registries_config", func(t *testing.T) { + regs := make(map[string]*RegistryConfig) + cloned := CloneRegistriesConfig(regs) + assert.NotNil(t, cloned) + assert.Equal(t, 0, len(cloned)) + assert.NotSame(t, regs, cloned) + }) + + t.Run("clone_single_registry", func(t *testing.T) { + regs := map[string]*RegistryConfig{ + "reg1": { + Protocol: "etcdv3", + Timeout: "10s", + Weight: 50, + Preferred: true, + }, + } + cloned := CloneRegistriesConfig(regs) + assert.Equal(t, 1, len(cloned)) + assert.Equal(t, "etcdv3", cloned["reg1"].Protocol) + assert.Equal(t, "10s", cloned["reg1"].Timeout) + assert.Equal(t, int64(50), cloned["reg1"].Weight) + assert.True(t, cloned["reg1"].Preferred) + }) +} +func TestRouterConfigClone(t *testing.T) { + t.Run("clone_full_router_config", func(t *testing.T) { + router := &RouterConfig{ + Scope: "service", + Key: "com.test.Service", + Priority: 10, + ScriptType: "javascript", + Script: "1==1", + Force: func() *bool { + b := true + return &b + }(), + Runtime: func() *bool { + b := false + return &b + }(), + Enabled: func() *bool { + b := true + return &b + }(), + Valid: func() *bool { + b := true + return &b + }(), + Conditions: []string{"condition1", "condition2"}, + Tags: []Tag{ + { + Name: "tag1", + Addresses: []string{"addr1", "addr2"}, + }, + { + Name: "tag2", + Addresses: []string{"addr3"}, + }, + }, + } + + cloned := router.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, router.Scope, cloned.Scope) + assert.Equal(t, router.Key, cloned.Key) + assert.Equal(t, router.Priority, cloned.Priority) + assert.Equal(t, router.ScriptType, cloned.ScriptType) + assert.Equal(t, router.Script, cloned.Script) + assert.NotSame(t, router, cloned) + assert.NotSame(t, router.Conditions, cloned.Conditions) + assert.NotSame(t, router.Tags, cloned.Tags) + assert.Equal(t, 2, len(cloned.Conditions)) + assert.Equal(t, 2, len(cloned.Tags)) + assert.Equal(t, "tag1", cloned.Tags[0].Name) + assert.Equal(t, "tag2", cloned.Tags[1].Name) + assert.Equal(t, 2, len(cloned.Tags[0].Addresses)) + assert.Equal(t, 1, len(cloned.Tags[1].Addresses)) + }) + + t.Run("clone_nil_router_config", func(t *testing.T) { + var router *RouterConfig + cloned := router.Clone() + assert.Nil(t, cloned) + }) + + t.Run("clone_empty_router_config", func(t *testing.T) { + router := &RouterConfig{} + cloned := router.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, router, cloned) + }) + + t.Run("clone_router_config_with_nil_pointers", func(t *testing.T) { + router := &RouterConfig{ + Scope: "service", + Key: "com.test.Service", + Force: nil, + Runtime: nil, + } + cloned := router.Clone() + assert.NotNil(t, cloned) + assert.Nil(t, cloned.Force) + assert.Nil(t, cloned.Runtime) + }) + + t.Run("clone_router_config_preserves_pointer_values", func(t *testing.T) { + forceTrue := true + runtimeFalse := false + router := &RouterConfig{ + Scope: "service", + Key: "test", + Force: &forceTrue, + Runtime: &runtimeFalse, + } + cloned := router.Clone() + assert.NotNil(t, cloned.Force) + assert.NotNil(t, cloned.Runtime) + assert.True(t, *cloned.Force) + assert.False(t, *cloned.Runtime) + assert.NotSame(t, router.Force, cloned.Force) + assert.NotSame(t, router.Runtime, cloned.Runtime) + }) +} + +// TestDefaultRouterConfig tests DefaultRouterConfig function +func TestDefaultRouterConfig(t *testing.T) { + t.Run("default_router_config", func(t *testing.T) { + router := DefaultRouterConfig() + assert.NotNil(t, router) + assert.Equal(t, 0, len(router.Conditions)) + assert.Equal(t, 0, len(router.Tags)) + }) +} + +// TestTagStructure tests Tag structure and cloning +func TestTagStructure(t *testing.T) { + t.Run("tag_with_addresses", func(t *testing.T) { + tag := Tag{ + Name: "test", + Addresses: []string{"addr1", "addr2"}, + } + assert.Equal(t, "test", tag.Name) + assert.Equal(t, 2, len(tag.Addresses)) + }) + + t.Run("tag_with_empty_addresses", func(t *testing.T) { + tag := Tag{ + Name: "test", + Addresses: []string{}, + } + assert.Equal(t, 0, len(tag.Addresses)) + }) +} + +// TestRouterConfigFields tests individual fields of RouterConfig +func TestRouterConfigFields(t *testing.T) { + t.Run("router_config_scope", func(t *testing.T) { + router := &RouterConfig{ + Scope: "application", + } + assert.Equal(t, "application", router.Scope) + }) + + t.Run("router_config_priority", func(t *testing.T) { + router := &RouterConfig{ + Priority: 100, + } + assert.Equal(t, 100, router.Priority) + }) + + t.Run("router_config_script_type", func(t *testing.T) { + router := &RouterConfig{ + ScriptType: "groovy", + Script: "1 == 1", + } + assert.Equal(t, "groovy", router.ScriptType) + assert.Equal(t, "1 == 1", router.Script) + }) + + t.Run("router_config_conditions_multiple", func(t *testing.T) { + router := &RouterConfig{ + Conditions: []string{"cond1", "cond2", "cond3"}, + } + assert.Equal(t, 3, len(router.Conditions)) + assert.Equal(t, "cond1", router.Conditions[0]) + assert.Equal(t, "cond3", router.Conditions[2]) + }) +} +func TestProtocolConfigClone(t *testing.T) { + t.Run("clone_full_protocol_config", func(t *testing.T) { + proto := &ProtocolConfig{ + Name: "tri", + Ip: "localhost", + Port: "20880", + MaxServerSendMsgSize: "1mb", + MaxServerRecvMsgSize: "4mb", + TripleConfig: &TripleConfig{ + MaxServerSendMsgSize: "2mb", + MaxServerRecvMsgSize: "4mb", + KeepAliveInterval: "1m", + KeepAliveTimeout: "30s", + Http3: DefaultHttp3Config(), + }, + Params: map[string]string{ + "key1": "value1", + "key2": "value2", + }, + } + + cloned := proto.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, proto.Name, cloned.Name) + assert.Equal(t, proto.Ip, cloned.Ip) + assert.Equal(t, proto.Port, cloned.Port) + assert.Equal(t, proto.MaxServerSendMsgSize, cloned.MaxServerSendMsgSize) + assert.Equal(t, proto.MaxServerRecvMsgSize, cloned.MaxServerRecvMsgSize) + assert.NotSame(t, proto, cloned) + assert.NotSame(t, proto.TripleConfig, cloned.TripleConfig) + assert.NotNil(t, cloned.TripleConfig) + }) + + t.Run("clone_nil_protocol_config", func(t *testing.T) { + var proto *ProtocolConfig + cloned := proto.Clone() + assert.Nil(t, cloned) + }) + + t.Run("clone_protocol_config_with_nil_triple_config", func(t *testing.T) { + proto := &ProtocolConfig{ + Name: "dubbo", + Port: "20880", + } + cloned := proto.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, "dubbo", cloned.Name) + }) + + t.Run("clone_protocol_config_preserves_all_fields", func(t *testing.T) { + proto := &ProtocolConfig{ + Name: "http", + Ip: "localhost", + Port: "8080", + MaxServerSendMsgSize: "10mb", + MaxServerRecvMsgSize: "10mb", + } + cloned := proto.Clone() + assert.Equal(t, "http", cloned.Name) + assert.Equal(t, "localhost", cloned.Ip) + assert.Equal(t, "8080", cloned.Port) + assert.Equal(t, "10mb", cloned.MaxServerSendMsgSize) + assert.Equal(t, "10mb", cloned.MaxServerRecvMsgSize) + }) +} + +// TestDefaultProtocolConfig tests DefaultProtocolConfig function +func TestDefaultProtocolConfig(t *testing.T) { + t.Run("default_protocol_config", func(t *testing.T) { + proto := DefaultProtocolConfig() + assert.NotNil(t, proto) + assert.NotEmpty(t, proto.Name) + assert.NotEmpty(t, proto.Port) + assert.NotNil(t, proto.TripleConfig) + }) +} + +// TestProtocolConfigFields tests individual fields of ProtocolConfig +func TestProtocolConfigFields(t *testing.T) { + t.Run("protocol_config_name", func(t *testing.T) { + proto := &ProtocolConfig{Name: "dubbo"} + assert.Equal(t, "dubbo", proto.Name) + }) + + t.Run("protocol_config_ip", func(t *testing.T) { + proto := &ProtocolConfig{Ip: "localhost"} + assert.Equal(t, "localhost", proto.Ip) + }) + + t.Run("protocol_config_port", func(t *testing.T) { + proto := &ProtocolConfig{Port: "9090"} + assert.Equal(t, "9090", proto.Port) + }) + + t.Run("protocol_config_with_params", func(t *testing.T) { + params := map[string]string{ + "param1": "value1", + "param2": "value2", + } + proto := &ProtocolConfig{ + Name: "tri", + Params: params, + } + assert.NotNil(t, proto.Params) + }) + + t.Run("protocol_config_with_triple_config", func(t *testing.T) { + tripleConfig := &TripleConfig{ + KeepAliveInterval: "2m", + KeepAliveTimeout: "60s", + } + proto := &ProtocolConfig{ + Name: "tri", + TripleConfig: tripleConfig, + } + assert.NotNil(t, proto.TripleConfig) + assert.Equal(t, "2m", proto.TripleConfig.KeepAliveInterval) + assert.Equal(t, "60s", proto.TripleConfig.KeepAliveTimeout) + }) +} + +// TestTripleConfigClone tests the Clone method of TripleConfig +func TestTripleConfigClone(t *testing.T) { + t.Run("clone_full_triple_config", func(t *testing.T) { + triple := &TripleConfig{ + MaxServerSendMsgSize: "5mb", + MaxServerRecvMsgSize: "5mb", + KeepAliveInterval: "3m", + KeepAliveTimeout: "45s", + Http3: DefaultHttp3Config(), + } + cloned := triple.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, triple.MaxServerSendMsgSize, cloned.MaxServerSendMsgSize) + assert.Equal(t, triple.MaxServerRecvMsgSize, cloned.MaxServerRecvMsgSize) + assert.Equal(t, triple.KeepAliveInterval, cloned.KeepAliveInterval) + assert.Equal(t, triple.KeepAliveTimeout, cloned.KeepAliveTimeout) + assert.NotSame(t, triple, cloned) + assert.NotSame(t, triple.Http3, cloned.Http3) + }) + + t.Run("clone_nil_triple_config", func(t *testing.T) { + var triple *TripleConfig + cloned := triple.Clone() + assert.Nil(t, cloned) + }) + + t.Run("clone_triple_config_with_nil_http3", func(t *testing.T) { + triple := &TripleConfig{ + MaxServerSendMsgSize: "1mb", + } + cloned := triple.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, "1mb", cloned.MaxServerSendMsgSize) + }) +} + +// TestDefaultTripleConfig tests DefaultTripleConfig function +func TestDefaultTripleConfig(t *testing.T) { + t.Run("default_triple_config", func(t *testing.T) { + triple := DefaultTripleConfig() + assert.NotNil(t, triple) + assert.NotNil(t, triple.Http3) + }) +} + +// TestHttp3ConfigClone tests the Clone method of Http3Config +func TestHttp3ConfigClone(t *testing.T) { + t.Run("clone_http3_config", func(t *testing.T) { + http3 := &Http3Config{ + Enable: true, + Negotiation: false, + } + cloned := http3.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, http3.Enable, cloned.Enable) + assert.Equal(t, http3.Negotiation, cloned.Negotiation) + }) + + t.Run("clone_nil_http3_config", func(t *testing.T) { + var http3 *Http3Config + cloned := http3.Clone() + assert.Nil(t, cloned) + }) + + t.Run("clone_http3_config_with_defaults", func(t *testing.T) { + http3 := DefaultHttp3Config() + cloned := http3.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, http3.Enable, cloned.Enable) + assert.Equal(t, http3.Negotiation, cloned.Negotiation) + }) +} + +// TestDefaultHttp3Config tests DefaultHttp3Config function +func TestDefaultHttp3Config(t *testing.T) { + t.Run("default_http3_config", func(t *testing.T) { + http3 := DefaultHttp3Config() + assert.NotNil(t, http3) + }) +} +func TestConsumerConfigClone(t *testing.T) { + t.Run("clone_full_consumer_config", func(t *testing.T) { + consumer := &ConsumerConfig{ + Filter: "echo", + Protocol: "dubbo", + RequestTimeout: "5s", + ProxyFactory: "default", + Check: true, + AdaptiveService: true, + TracingKey: "jaeger", + MeshEnabled: true, + MaxWaitTimeForServiceDiscovery: "5s", + RegistryIDs: []string{"reg1", "reg2"}, + References: map[string]*ReferenceConfig{ + "ref1": { + InterfaceName: "com.test.Service1", + }, + "ref2": { + InterfaceName: "com.test.Service2", + }, + }, + } + + cloned := consumer.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, consumer.Filter, cloned.Filter) + assert.Equal(t, consumer.Protocol, cloned.Protocol) + assert.Equal(t, consumer.RequestTimeout, cloned.RequestTimeout) + assert.Equal(t, consumer.Check, cloned.Check) + assert.Equal(t, consumer.AdaptiveService, cloned.AdaptiveService) + assert.NotSame(t, consumer, cloned) + assert.NotSame(t, consumer.References, cloned.References) + assert.Equal(t, 2, len(cloned.References)) + assert.Equal(t, "com.test.Service1", cloned.References["ref1"].InterfaceName) + }) + + t.Run("clone_nil_consumer_config", func(t *testing.T) { + var consumer *ConsumerConfig + cloned := consumer.Clone() + assert.Nil(t, cloned) + }) + + t.Run("clone_consumer_config_with_empty_references", func(t *testing.T) { + consumer := &ConsumerConfig{ + Filter: "echo", + } + cloned := consumer.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, "echo", cloned.Filter) + assert.NotSame(t, consumer, cloned) + }) +} + +// TestDefaultConsumerConfig tests DefaultConsumerConfig function +func TestDefaultConsumerConfig(t *testing.T) { + t.Run("default_consumer_config", func(t *testing.T) { + consumer := DefaultConsumerConfig() + assert.NotNil(t, consumer) + assert.True(t, consumer.Check) + assert.NotNil(t, consumer.References) + assert.Equal(t, 0, len(consumer.References)) + }) +} + +// TestConsumerConfigFields tests individual fields of ConsumerConfig +func TestConsumerConfigFields(t *testing.T) { + t.Run("consumer_config_filter", func(t *testing.T) { + consumer := &ConsumerConfig{ + Filter: "echo", + } + assert.Equal(t, "echo", consumer.Filter) + }) + + t.Run("consumer_config_protocol", func(t *testing.T) { + consumer := &ConsumerConfig{ + Protocol: "tri", + } + assert.Equal(t, "tri", consumer.Protocol) + }) + + t.Run("consumer_config_timeout", func(t *testing.T) { + consumer := &ConsumerConfig{ + RequestTimeout: "10s", + } + assert.Equal(t, "10s", consumer.RequestTimeout) + }) + + t.Run("consumer_config_check", func(t *testing.T) { + consumer := &ConsumerConfig{ + Check: false, + } + assert.False(t, consumer.Check) + }) + + t.Run("consumer_config_adaptive_service", func(t *testing.T) { + consumer := &ConsumerConfig{ + AdaptiveService: true, + } + assert.True(t, consumer.AdaptiveService) + }) + + t.Run("consumer_config_registry_ids", func(t *testing.T) { + consumer := &ConsumerConfig{ + RegistryIDs: []string{"reg1", "reg2", "reg3"}, + } + assert.Equal(t, 3, len(consumer.RegistryIDs)) + }) + + t.Run("consumer_config_mesh_enabled", func(t *testing.T) { + consumer := &ConsumerConfig{ + MeshEnabled: true, + } + assert.True(t, consumer.MeshEnabled) + }) +} +func TestServiceConfigClone(t *testing.T) { + t.Run("clone_full_service_config", func(t *testing.T) { + service := &ServiceConfig{ + Filter: "echo", + Interface: "com.test.Service", + Group: "test", + Version: "1.0.0", + Cluster: "failover", + Loadbalance: "random", + NotRegister: true, + Weight: 100, + TracingKey: "jaeger", + Auth: "token", + Token: "abc123", + AccessLog: "true", + TpsLimiter: "default", + TpsLimitInterval: "1000", + TpsLimitRate: "100", + TpsLimitStrategy: "default", + ExecuteLimit: "10", + ExecuteLimitRejectedHandler: "default", + ParamSign: "true", + Tag: "prod", + Warmup: "60", + Retries: "3", + Serialization: "hessian2", + ProtocolIDs: []string{"proto1"}, + RegistryIDs: []string{"reg1"}, + Methods: []*MethodConfig{ + {Name: "method1"}, + }, + Params: map[string]string{ + "key": "value", + }, + RCProtocolsMap: map[string]*ProtocolConfig{ + "proto1": {Name: "tri"}, + }, + RCRegistriesMap: map[string]*RegistryConfig{ + "reg1": {Protocol: "zookeeper"}, + }, + } + + cloned := service.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, service.Filter, cloned.Filter) + assert.Equal(t, service.Interface, cloned.Interface) + assert.Equal(t, service.Group, cloned.Group) + assert.Equal(t, service.Version, cloned.Version) + assert.NotSame(t, service, cloned) + assert.NotSame(t, service.Params, cloned.Params) + assert.Equal(t, "value", cloned.Params["key"]) + assert.Equal(t, 1, len(cloned.ProtocolIDs)) + assert.Equal(t, 1, len(cloned.RegistryIDs)) + }) + + t.Run("clone_nil_service_config", func(t *testing.T) { + var service *ServiceConfig + cloned := service.Clone() + assert.Nil(t, cloned) + }) + + t.Run("clone_empty_service_config", func(t *testing.T) { + service := &ServiceConfig{} + cloned := service.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, service, cloned) + }) + + t.Run("clone_service_config_with_maps", func(t *testing.T) { + service := &ServiceConfig{ + Interface: "com.test.Service", + RCProtocolsMap: map[string]*ProtocolConfig{ + "proto1": {Name: "tri", Port: "20880"}, + "proto2": {Name: "dubbo", Port: "20881"}, + }, + RCRegistriesMap: map[string]*RegistryConfig{ + "reg1": {Protocol: "zookeeper", Address: "localhost:2181"}, + "reg2": {Protocol: "nacos", Address: "localhost:8848"}, + }, + } + cloned := service.Clone() + assert.Equal(t, 2, len(cloned.RCProtocolsMap)) + assert.Equal(t, 2, len(cloned.RCRegistriesMap)) + assert.NotSame(t, service.RCProtocolsMap, cloned.RCProtocolsMap) + assert.NotSame(t, service.RCRegistriesMap, cloned.RCRegistriesMap) + }) +} + +// TestDefaultServiceConfig tests DefaultServiceConfig function +func TestDefaultServiceConfig(t *testing.T) { + t.Run("default_service_config", func(t *testing.T) { + service := DefaultServiceConfig() + assert.NotNil(t, service) + assert.NotNil(t, service.Methods) + assert.NotNil(t, service.Params) + assert.NotNil(t, service.RCProtocolsMap) + assert.NotNil(t, service.RCRegistriesMap) + assert.Equal(t, 0, len(service.Methods)) + assert.Equal(t, 0, len(service.Params)) + }) +} + +// TestServiceConfigFields tests individual fields of ServiceConfig +func TestServiceConfigFields(t *testing.T) { + t.Run("service_config_interface", func(t *testing.T) { + service := &ServiceConfig{ + Interface: "com.test.Service", + } + assert.Equal(t, "com.test.Service", service.Interface) + }) + + t.Run("service_config_version", func(t *testing.T) { + service := &ServiceConfig{ + Version: "2.0.0", + } + assert.Equal(t, "2.0.0", service.Version) + }) + + t.Run("service_config_group", func(t *testing.T) { + service := &ServiceConfig{ + Group: "production", + } + assert.Equal(t, "production", service.Group) + }) + + t.Run("service_config_cluster", func(t *testing.T) { + service := &ServiceConfig{ + Cluster: "forking", + } + assert.Equal(t, "forking", service.Cluster) + }) + + t.Run("service_config_loadbalance", func(t *testing.T) { + service := &ServiceConfig{ + Loadbalance: "leastactive", + } + assert.Equal(t, "leastactive", service.Loadbalance) + }) + + t.Run("service_config_weight", func(t *testing.T) { + service := &ServiceConfig{ + Weight: 200, + } + assert.Equal(t, int64(200), service.Weight) + }) + + t.Run("service_config_not_register", func(t *testing.T) { + service := &ServiceConfig{ + NotRegister: true, + } + assert.True(t, service.NotRegister) + }) + + t.Run("service_config_protocol_ids", func(t *testing.T) { + service := &ServiceConfig{ + ProtocolIDs: []string{"proto1", "proto2"}, + } + assert.Equal(t, 2, len(service.ProtocolIDs)) + }) + + t.Run("service_config_registry_ids", func(t *testing.T) { + service := &ServiceConfig{ + RegistryIDs: []string{"reg1"}, + } + assert.Equal(t, 1, len(service.RegistryIDs)) + }) +} + +// TestServiceOptionFunc tests the ServiceOption function type +func TestServiceOptionFunc(t *testing.T) { + t.Run("apply_service_option", func(t *testing.T) { + service := &ServiceConfig{} + opt := func(cfg *ServiceConfig) { + cfg.Interface = "com.test.Service" + cfg.Version = "1.0.0" + } + opt(service) + assert.Equal(t, "com.test.Service", service.Interface) + assert.Equal(t, "1.0.0", service.Version) + }) +} +func TestProviderConfigClone(t *testing.T) { + t.Run("clone_full_provider_config", func(t *testing.T) { + provider := &ProviderConfig{ + Filter: "echo", + Register: true, + RegistryIDs: []string{"reg1", "reg2"}, + ProtocolIDs: []string{"proto1"}, + TracingKey: "jaeger", + ProxyFactory: "default", + AdaptiveService: true, + AdaptiveServiceVerbose: true, + ConfigType: map[string]string{"key": "value"}, + Services: map[string]*ServiceConfig{ + "service1": {Interface: "com.test.Service1"}, + }, + ServiceConfig: ServiceConfig{ + Interface: "com.test.BaseService", + Group: "test", + Version: "1.0.0", + }, + } + + cloned := provider.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, provider.Filter, cloned.Filter) + assert.Equal(t, provider.Register, cloned.Register) + assert.NotSame(t, provider, cloned) + assert.NotSame(t, provider.Services, cloned.Services) + + // Verify RegistryIDs is a true deep copy by mutating the clone + assert.Equal(t, len(provider.RegistryIDs), len(cloned.RegistryIDs)) + assert.Equal(t, provider.RegistryIDs, cloned.RegistryIDs) + if len(cloned.RegistryIDs) > 0 { + cloned.RegistryIDs[0] = "modified" + assert.NotEqual(t, cloned.RegistryIDs[0], provider.RegistryIDs[0], "Modifying clone should not affect original") + } + cloned.RegistryIDs = append(cloned.RegistryIDs, "new_registry") + assert.NotEqual(t, len(provider.RegistryIDs), len(cloned.RegistryIDs)) + + // Verify ProtocolIDs is a true deep copy by mutating the clone + assert.Equal(t, len(provider.ProtocolIDs), len(cloned.ProtocolIDs)) + assert.Equal(t, provider.ProtocolIDs, cloned.ProtocolIDs) + if len(cloned.ProtocolIDs) > 0 { + cloned.ProtocolIDs[0] = "modified" + assert.NotEqual(t, cloned.ProtocolIDs[0], provider.ProtocolIDs[0], "Modifying clone should not affect original") + } + cloned.ProtocolIDs = append(cloned.ProtocolIDs, "new_protocol") + assert.NotEqual(t, len(provider.ProtocolIDs), len(cloned.ProtocolIDs)) + + // Verify Services is a true deep copy by mutating the clone + assert.Equal(t, len(provider.Services), len(cloned.Services)) + cloned.Services["service2"] = &ServiceConfig{Interface: "com.test.Service2"} + assert.NotEqual(t, len(provider.Services), len(cloned.Services)) + assert.NotContains(t, provider.Services, "service2") + assert.Contains(t, cloned.Services, "service2") + }) + + t.Run("clone_nil_provider_config", func(t *testing.T) { + var provider *ProviderConfig + cloned := provider.Clone() + assert.Nil(t, cloned) + }) + + t.Run("clone_default_provider_config", func(t *testing.T) { + provider := DefaultProviderConfig() + cloned := provider.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, provider, cloned) + + // Verify RegistryIDs is a true deep copy + if len(provider.RegistryIDs) > 0 { + assert.Equal(t, provider.RegistryIDs, cloned.RegistryIDs) + cloned.RegistryIDs[0] = "modified" + assert.NotEqual(t, provider.RegistryIDs[0], cloned.RegistryIDs[0], "Modifying clone should not affect original") + } + + // Verify ProtocolIDs is a true deep copy + if len(provider.ProtocolIDs) > 0 { + assert.Equal(t, provider.ProtocolIDs, cloned.ProtocolIDs) + cloned.ProtocolIDs[0] = "modified" + assert.NotEqual(t, provider.ProtocolIDs[0], cloned.ProtocolIDs[0], "Modifying clone should not affect original") + } + + // Verify Services is a true deep copy + originalServicesLen := len(provider.Services) + cloned.Services["new_service"] = &ServiceConfig{Interface: "com.test.NewService"} + assert.Equal(t, originalServicesLen, len(provider.Services)) + assert.Greater(t, len(cloned.Services), len(provider.Services)) + }) +} + +// TestDefaultProviderConfig tests DefaultProviderConfig function +func TestDefaultProviderConfig(t *testing.T) { + t.Run("default_provider_config", func(t *testing.T) { + provider := DefaultProviderConfig() + assert.NotNil(t, provider) + assert.NotNil(t, provider.RegistryIDs) + assert.NotNil(t, provider.ProtocolIDs) + assert.NotNil(t, provider.Services) + }) +} + +// TestProviderConfigFields tests individual fields of ProviderConfig +func TestProviderConfigFields(t *testing.T) { + t.Run("provider_config_filter", func(t *testing.T) { + provider := &ProviderConfig{} + provider.Filter = "echo" + assert.Equal(t, "echo", provider.Filter) + }) + + t.Run("provider_config_register", func(t *testing.T) { + provider := &ProviderConfig{ + Register: false, + } + assert.False(t, provider.Register) + }) + + t.Run("provider_config_registry_ids", func(t *testing.T) { + provider := &ProviderConfig{ + RegistryIDs: []string{"reg1", "reg2"}, + } + assert.Equal(t, 2, len(provider.RegistryIDs)) + }) + + t.Run("provider_config_protocol_ids", func(t *testing.T) { + provider := &ProviderConfig{ + ProtocolIDs: []string{"proto1"}, + } + assert.Equal(t, 1, len(provider.ProtocolIDs)) + }) + + t.Run("provider_config_tracing_key", func(t *testing.T) { + provider := &ProviderConfig{ + TracingKey: "zipkin", + } + assert.Equal(t, "zipkin", provider.TracingKey) + }) + + t.Run("provider_config_adaptive_service", func(t *testing.T) { + provider := &ProviderConfig{ + AdaptiveService: true, + AdaptiveServiceVerbose: true, + } + assert.True(t, provider.AdaptiveService) + assert.True(t, provider.AdaptiveServiceVerbose) + }) + + t.Run("provider_config_services_map", func(t *testing.T) { + provider := &ProviderConfig{ + Services: map[string]*ServiceConfig{ + "service1": {Interface: "com.test.Service1"}, + "service2": {Interface: "com.test.Service2"}, + }, + } + assert.Equal(t, 2, len(provider.Services)) + assert.Equal(t, "com.test.Service1", provider.Services["service1"].Interface) + }) + + t.Run("provider_config_proxy_factory", func(t *testing.T) { + provider := &ProviderConfig{ + ProxyFactory: "javassist", + } + assert.Equal(t, "javassist", provider.ProxyFactory) + }) +} +func TestApplicationConfigClone(t *testing.T) { + t.Run("clone_full_application_config", func(t *testing.T) { + app := &ApplicationConfig{ + Organization: "apache", + Name: "dubbo-app", + Module: "sample", + Group: "test", + Version: "1.0.0", + Owner: "team", + Environment: "production", + MetadataType: "local", + Tag: "v1", + MetadataServicePort: "20881", + MetadataServiceProtocol: "dubbo", + } + cloned := app.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, app.Organization, cloned.Organization) + assert.Equal(t, app.Name, cloned.Name) + assert.NotSame(t, app, cloned) + }) + + t.Run("clone_nil_application_config", func(t *testing.T) { + var app *ApplicationConfig + cloned := app.Clone() + assert.Nil(t, cloned) + }) +} + +// TestDefaultApplicationConfig tests DefaultApplicationConfig function +func TestDefaultApplicationConfig(t *testing.T) { + t.Run("default_application_config", func(t *testing.T) { + app := DefaultApplicationConfig() + assert.NotNil(t, app) + }) +} + +// TestApplicationConfigFields tests individual fields +func TestApplicationConfigFields(t *testing.T) { + t.Run("application_config_organization", func(t *testing.T) { + app := &ApplicationConfig{ + Organization: "company", + } + assert.Equal(t, "company", app.Organization) + }) + + t.Run("application_config_name", func(t *testing.T) { + app := &ApplicationConfig{ + Name: "my-app", + } + assert.Equal(t, "my-app", app.Name) + }) + + t.Run("application_config_metadata_type", func(t *testing.T) { + app := &ApplicationConfig{ + MetadataType: "remote", + } + assert.Equal(t, "remote", app.MetadataType) + }) +} +func TestCustomConfigClone(t *testing.T) { + t.Run("clone_full_custom_config", func(t *testing.T) { + custom := &CustomConfig{ + ConfigMap: map[string]any{ + "key1": "value1", + "key2": 123, + }, + } + cloned := custom.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, custom, cloned) + if custom.ConfigMap != nil { + assert.NotSame(t, custom.ConfigMap, cloned.ConfigMap) + } + }) + + t.Run("clone_nil_custom_config", func(t *testing.T) { + var custom *CustomConfig + cloned := custom.Clone() + assert.Nil(t, cloned) + }) +} + +// TestDefaultCustomConfig tests DefaultCustomConfig function +func TestDefaultCustomConfig(t *testing.T) { + t.Run("default_custom_config", func(t *testing.T) { + custom := DefaultCustomConfig() + assert.NotNil(t, custom) + }) +} +func TestMethodConfigClone(t *testing.T) { + t.Run("clone_full_method_config", func(t *testing.T) { + method := &MethodConfig{ + Name: "testMethod", + Retries: "3", + RequestTimeout: "5s", + } + cloned := method.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, method.Name, cloned.Name) + assert.NotSame(t, method, cloned) + }) + + t.Run("clone_nil_method_config", func(t *testing.T) { + var method *MethodConfig + cloned := method.Clone() + assert.Nil(t, cloned) + }) + + t.Run("clone_empty_method_config", func(t *testing.T) { + method := &MethodConfig{} + cloned := method.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, method, cloned) + }) +} + +// TestMethodConfigFields tests individual fields +func TestMethodConfigFields(t *testing.T) { + t.Run("method_config_name", func(t *testing.T) { + method := &MethodConfig{ + Name: "method1", + } + assert.Equal(t, "method1", method.Name) + }) + + t.Run("method_config_retries", func(t *testing.T) { + method := &MethodConfig{ + Retries: "5", + } + assert.Equal(t, "5", method.Retries) + }) + + t.Run("method_config_request_timeout", func(t *testing.T) { + method := &MethodConfig{ + RequestTimeout: "10s", + } + assert.Equal(t, "10s", method.RequestTimeout) + }) +} +func TestMetricConfigClone(t *testing.T) { + t.Run("clone_metrics_config", func(t *testing.T) { + metrics := DefaultMetricsConfig() + if metrics != nil { + cloned := metrics.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, metrics, cloned) + } + }) + + t.Run("clone_nil_metrics_config", func(t *testing.T) { + var metrics *MetricsConfig + cloned := metrics.Clone() + assert.Nil(t, cloned) + }) + + t.Run("clone_aggregate_config", func(t *testing.T) { + agg := &AggregateConfig{} + cloned := agg.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, agg, cloned) + }) + + t.Run("clone_prometheus_config", func(t *testing.T) { + prom := &PrometheusConfig{} + cloned := prom.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, prom, cloned) + }) + + t.Run("clone_exporter", func(t *testing.T) { + exp := &Exporter{} + cloned := exp.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, exp, cloned) + }) + + t.Run("clone_pushgateway_config", func(t *testing.T) { + push := &PushgatewayConfig{} + cloned := push.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, push, cloned) + }) +} + +// TestDefaultMetricsConfig tests DefaultMetricsConfig function +func TestDefaultMetricsConfig(t *testing.T) { + t.Run("default_metrics_config", func(t *testing.T) { + metrics := DefaultMetricsConfig() + assert.NotNil(t, metrics) + }) +} +func TestOtelConfigClone(t *testing.T) { + t.Run("clone_otel_config", func(t *testing.T) { + otel := DefaultOtelConfig() + if otel != nil { + cloned := otel.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, otel, cloned) + } + }) + + t.Run("clone_nil_otel_config", func(t *testing.T) { + var otel *OtelConfig + cloned := otel.Clone() + assert.Nil(t, cloned) + }) + + t.Run("clone_otel_trace_config", func(t *testing.T) { + trace := &OtelTraceConfig{} + cloned := trace.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, trace, cloned) + }) +} + +// TestDefaultOtelConfig tests DefaultOtelConfig function +func TestDefaultOtelConfig(t *testing.T) { + t.Run("default_otel_config", func(t *testing.T) { + otel := DefaultOtelConfig() + assert.NotNil(t, otel) + }) +} + +// TestProfilesConfigClone tests Clone method +func TestProfilesConfigClone(t *testing.T) { + t.Run("clone_profiles_config", func(t *testing.T) { + profiles := DefaultProfilesConfig() + if profiles != nil { + cloned := profiles.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, profiles, cloned) + } + }) + + t.Run("clone_nil_profiles_config", func(t *testing.T) { + var profiles *ProfilesConfig + cloned := profiles.Clone() + assert.Nil(t, cloned) + }) +} + +// TestDefaultProfilesConfig tests DefaultProfilesConfig function +func TestDefaultProfilesConfig(t *testing.T) { + t.Run("default_profiles_config", func(t *testing.T) { + profiles := DefaultProfilesConfig() + assert.NotNil(t, profiles) + }) +} + +// TestConfigCenterConfigClone tests Clone method +func TestConfigCenterConfigClone(t *testing.T) { + t.Run("clone_center_config", func(t *testing.T) { + center := DefaultCenterConfig() + if center != nil { + cloned := center.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, center, cloned) + } + }) + + t.Run("clone_nil_center_config", func(t *testing.T) { + var center *CenterConfig + cloned := center.Clone() + assert.Nil(t, cloned) + }) +} + +// TestDefaultCenterConfig tests DefaultCenterConfig function +func TestDefaultCenterConfig(t *testing.T) { + t.Run("default_center_config", func(t *testing.T) { + center := DefaultCenterConfig() + assert.NotNil(t, center) + }) +} + +// TestMetadataReportConfigClone tests Clone method +func TestMetadataReportConfigClone(t *testing.T) { + t.Run("clone_metadata_report_config", func(t *testing.T) { + metadata := DefaultMetadataReportConfig() + if metadata != nil { + cloned := metadata.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, metadata, cloned) + } + }) + + t.Run("clone_nil_metadata_report_config", func(t *testing.T) { + var metadata *MetadataReportConfig + cloned := metadata.Clone() + assert.Nil(t, cloned) + }) +} + +// TestDefaultMetadataReportConfig tests DefaultMetadataReportConfig function +func TestDefaultMetadataReportConfig(t *testing.T) { + t.Run("default_metadata_report_config", func(t *testing.T) { + metadata := DefaultMetadataReportConfig() + assert.NotNil(t, metadata) + }) +} +func TestShutdownConfigClone(t *testing.T) { + t.Run("clone_shutdown_config", func(t *testing.T) { + shutdown := DefaultShutdownConfig() + if shutdown != nil { + cloned := shutdown.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, shutdown, cloned) + } + }) + + t.Run("clone_nil_shutdown_config", func(t *testing.T) { + var shutdown *ShutdownConfig + cloned := shutdown.Clone() + assert.Nil(t, cloned) + }) +} + +// TestDefaultShutdownConfig tests DefaultShutdownConfig function +func TestDefaultShutdownConfig(t *testing.T) { + t.Run("default_shutdown_config", func(t *testing.T) { + shutdown := DefaultShutdownConfig() + assert.NotNil(t, shutdown) + }) +} + +// TestTLSConfigClone tests Clone method +func TestTLSConfigClone(t *testing.T) { + t.Run("clone_tls_config", func(t *testing.T) { + tls := &TLSConfig{ + CACertFile: "/path/to/ca", + TLSCertFile: "/path/to/cert", + TLSKeyFile: "/path/to/key", + TLSServerName: "localhost", + } + cloned := tls.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, tls.CACertFile, cloned.CACertFile) + assert.Equal(t, tls.TLSCertFile, cloned.TLSCertFile) + assert.NotSame(t, tls, cloned) + }) + + t.Run("clone_nil_tls_config", func(t *testing.T) { + var tls *TLSConfig + cloned := tls.Clone() + assert.Nil(t, cloned) + }) +} + +// TestClientProtocolConfigClone tests Clone method +func TestClientProtocolConfigClone(t *testing.T) { + t.Run("clone_client_protocol_config", func(t *testing.T) { + client := DefaultClientProtocolConfig() + if client != nil { + cloned := client.Clone() + assert.NotNil(t, cloned) + assert.NotSame(t, client, cloned) + } + }) + + t.Run("clone_nil_client_protocol_config", func(t *testing.T) { + var client *ClientProtocolConfig + cloned := client.Clone() + assert.Nil(t, cloned) + }) +} + +// TestDefaultClientProtocolConfig tests DefaultClientProtocolConfig function +func TestDefaultClientProtocolConfig(t *testing.T) { + t.Run("default_client_protocol_config", func(t *testing.T) { + client := DefaultClientProtocolConfig() + assert.NotNil(t, client) + }) +} +func TestLoggerConfigClone(t *testing.T) { + t.Run("clone_full_logger_config", func(t *testing.T) { + logger := &LoggerConfig{ + Level: "info", + } + cloned := logger.Clone() + assert.NotNil(t, cloned) + assert.Equal(t, logger.Level, cloned.Level) + assert.NotSame(t, logger, cloned) + }) + + t.Run("clone_nil_logger_config", func(t *testing.T) { + var logger *LoggerConfig + cloned := logger.Clone() + assert.Nil(t, cloned) + }) +} + +// TestDefaultLoggerConfig tests DefaultLoggerConfig function +func TestDefaultLoggerConfig(t *testing.T) { + t.Run("default_logger_config", func(t *testing.T) { + logger := DefaultLoggerConfig() + assert.NotNil(t, logger) + }) +} + +// TestLoggerConfigFields tests individual fields +func TestLoggerConfigFields(t *testing.T) { + t.Run("logger_config_level", func(t *testing.T) { + logger := &LoggerConfig{ + Level: "debug", + } + assert.Equal(t, "debug", logger.Level) + }) +}
