This is an automated email from the ASF dual-hosted git repository.
alexstocks pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/dubbo-go.git
The following commit(s) were added to refs/heads/develop by this push:
new 78ad16a22 test: add unit test for server/options.go (#3131)
78ad16a22 is described below
commit 78ad16a2225f226cab4809f425365929d784be78
Author: Akashisang <[email protected]>
AuthorDate: Mon Dec 22 07:38:06 2025 +0800
test: add unit test for server/options.go (#3131)
* test: add unit test for server/options.go
---
server/options_test.go | 960 +++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 960 insertions(+)
diff --git a/server/options_test.go b/server/options_test.go
new file mode 100644
index 000000000..ae148017d
--- /dev/null
+++ b/server/options_test.go
@@ -0,0 +1,960 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package server
+
+import (
+ "testing"
+ "time"
+)
+
+import (
+ "github.com/stretchr/testify/assert"
+)
+
+import (
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
+ "dubbo.apache.org/dubbo-go/v3/global"
+ "dubbo.apache.org/dubbo-go/v3/protocol"
+ "dubbo.apache.org/dubbo-go/v3/registry"
+)
+
+// Test defaultServerOptions
+func TestDefaultServerOptions(t *testing.T) {
+ opts := defaultServerOptions()
+ assert.NotNil(t, opts)
+ assert.NotNil(t, opts.Application)
+ assert.NotNil(t, opts.Provider)
+ assert.NotNil(t, opts.Shutdown)
+ assert.NotNil(t, opts.Metrics)
+ assert.NotNil(t, opts.Otel)
+ assert.NotNil(t, opts.TLS)
+}
+
+// Test ServerOptions.init with no options
+func TestServerOptionsInit(t *testing.T) {
+ opts := defaultServerOptions()
+ err := opts.init()
+ assert.NoError(t, err)
+ assert.NotNil(t, opts.Provider)
+}
+
+// Test ServerOptions.init with options
+func TestServerOptionsInitWithOptions(t *testing.T) {
+ opts := defaultServerOptions()
+ testOpt := WithServerGroup("test-group")
+ err := opts.init(testOpt)
+ assert.NoError(t, err)
+ assert.Equal(t, "test-group", opts.Provider.Group)
+}
+
+// Test WithServerLoadBalanceConsistentHashing
+func TestWithServerLoadBalanceConsistentHashing(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerLoadBalanceConsistentHashing()
+ opt(opts)
+ assert.Equal(t, constant.LoadBalanceKeyConsistentHashing,
opts.Provider.Loadbalance)
+}
+
+// Test WithServerLoadBalanceLeastActive
+func TestWithServerLoadBalanceLeastActive(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerLoadBalanceLeastActive()
+ opt(opts)
+ assert.Equal(t, constant.LoadBalanceKeyLeastActive,
opts.Provider.Loadbalance)
+}
+
+// Test WithServerLoadBalanceRandom
+func TestWithServerLoadBalanceRandom(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerLoadBalanceRandom()
+ opt(opts)
+ assert.Equal(t, constant.LoadBalanceKeyRandom,
opts.Provider.Loadbalance)
+}
+
+// Test WithServerLoadBalanceRoundRobin
+func TestWithServerLoadBalanceRoundRobin(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerLoadBalanceRoundRobin()
+ opt(opts)
+ assert.Equal(t, constant.LoadBalanceKeyRoundRobin,
opts.Provider.Loadbalance)
+}
+
+// Test WithServerLoadBalanceP2C
+func TestWithServerLoadBalanceP2C(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerLoadBalanceP2C()
+ opt(opts)
+ assert.Equal(t, constant.LoadBalanceKeyP2C, opts.Provider.Loadbalance)
+}
+
+// Test WithServerLoadBalance
+func TestWithServerLoadBalance(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerLoadBalance("custom-lb")
+ opt(opts)
+ assert.Equal(t, "custom-lb", opts.Provider.Loadbalance)
+}
+
+// Test WithServerWarmUp
+func TestWithServerWarmUp(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerWarmUp(60 * time.Second)
+ opt(opts)
+ assert.Equal(t, "60", opts.Provider.Warmup)
+}
+
+// Test WithServerClusterAvailable
+func TestWithServerClusterAvailable(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerClusterAvailable()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyAvailable, opts.Provider.Cluster)
+}
+
+// Test WithServerClusterBroadcast
+func TestWithServerClusterBroadcast(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerClusterBroadcast()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyBroadcast, opts.Provider.Cluster)
+}
+
+// Test WithServerClusterFailBack
+func TestWithServerClusterFailBack(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerClusterFailBack()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyFailback, opts.Provider.Cluster)
+}
+
+// Test WithServerClusterFailFast
+func TestWithServerClusterFailFast(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerClusterFailFast()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyFailfast, opts.Provider.Cluster)
+}
+
+// Test WithServerClusterFailOver
+func TestWithServerClusterFailOver(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerClusterFailOver()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyFailover, opts.Provider.Cluster)
+}
+
+// Test WithServerClusterFailSafe
+func TestWithServerClusterFailSafe(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerClusterFailSafe()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyFailsafe, opts.Provider.Cluster)
+}
+
+// Test WithServerClusterForking
+func TestWithServerClusterForking(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerClusterForking()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyForking, opts.Provider.Cluster)
+}
+
+// Test WithServerClusterZoneAware
+func TestWithServerClusterZoneAware(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerClusterZoneAware()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyZoneAware, opts.Provider.Cluster)
+}
+
+// Test WithServerClusterAdaptiveService
+func TestWithServerClusterAdaptiveService(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerClusterAdaptiveService()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyAdaptiveService,
opts.Provider.Cluster)
+}
+
+// Test WithServerCluster
+func TestWithServerCluster(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerCluster("custom-cluster")
+ opt(opts)
+ assert.Equal(t, "custom-cluster", opts.Provider.Cluster)
+}
+
+// Test WithServerGroup
+func TestWithServerGroup(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerGroup("test-group")
+ opt(opts)
+ assert.Equal(t, "test-group", opts.Provider.Group)
+}
+
+// Test WithServerVersion
+func TestWithServerVersion(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerVersion("1.0.0")
+ opt(opts)
+ assert.Equal(t, "1.0.0", opts.Provider.Version)
+}
+
+// Test WithServerJSON
+func TestWithServerJSON(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerJSON()
+ opt(opts)
+ assert.Equal(t, constant.JSONSerialization, opts.Provider.Serialization)
+}
+
+// Test WithServerToken
+func TestWithServerToken(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerToken("test-token")
+ opt(opts)
+ assert.Equal(t, "test-token", opts.Provider.Token)
+}
+
+// Test WithServerNotRegister
+func TestWithServerNotRegister(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerNotRegister()
+ opt(opts)
+ assert.True(t, opts.Provider.NotRegister)
+}
+
+// Test WithServerWarmup
+func TestWithServerWarmup(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerWarmup(30 * time.Second)
+ opt(opts)
+ assert.Equal(t, "30s", opts.Provider.Warmup)
+}
+
+// Test WithServerRetries
+func TestWithServerRetries(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerRetries(3)
+ opt(opts)
+ assert.Equal(t, "3", opts.Provider.Retries)
+}
+
+// Test WithServerSerialization
+func TestWithServerSerialization(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerSerialization("protobuf")
+ opt(opts)
+ assert.Equal(t, "protobuf", opts.Provider.Serialization)
+}
+
+// Test WithServerAccesslog
+func TestWithServerAccesslog(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerAccesslog("/var/log/access.log")
+ opt(opts)
+ assert.Equal(t, "/var/log/access.log", opts.Provider.AccessLog)
+}
+
+// Test WithServerTpsLimiter
+func TestWithServerTpsLimiter(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerTpsLimiter("default")
+ opt(opts)
+ assert.Equal(t, "default", opts.Provider.TpsLimiter)
+}
+
+// Test WithServerTpsLimitRate
+func TestWithServerTpsLimitRate(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerTpsLimitRate(1000)
+ opt(opts)
+ assert.Equal(t, "1000", opts.Provider.TpsLimitRate)
+}
+
+// Test WithServerTpsLimitStrategy
+func TestWithServerTpsLimitStrategy(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerTpsLimitStrategy("adaptive")
+ opt(opts)
+ assert.Equal(t, "adaptive", opts.Provider.TpsLimitStrategy)
+}
+
+// Test WithServerTpsLimitRejectedHandler
+func TestWithServerTpsLimitRejectedHandler(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerTpsLimitRejectedHandler("abort")
+ opt(opts)
+ assert.Equal(t, "abort", opts.Provider.TpsLimitRejectedHandler)
+}
+
+// Test WithServerExecuteLimit
+func TestWithServerExecuteLimit(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerExecuteLimit("100")
+ opt(opts)
+ assert.Equal(t, "100", opts.Provider.ExecuteLimit)
+}
+
+// Test WithServerExecuteLimitRejectedHandler
+func TestWithServerExecuteLimitRejectedHandler(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerExecuteLimitRejectedHandler("abort")
+ opt(opts)
+ assert.Equal(t, "abort", opts.Provider.ExecuteLimitRejectedHandler)
+}
+
+// Test WithServerAuth
+func TestWithServerAuth(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerAuth("default")
+ opt(opts)
+ assert.Equal(t, "default", opts.Provider.Auth)
+}
+
+// Test WithServerParamSign
+func TestWithServerParamSign(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerParamSign("md5")
+ opt(opts)
+ assert.Equal(t, "md5", opts.Provider.ParamSign)
+}
+
+// Test WithServerTag
+func TestWithServerTag(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerTag("v1")
+ opt(opts)
+ assert.Equal(t, "v1", opts.Provider.Tag)
+}
+
+// Test WithServerParam
+func TestWithServerParam(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerParam("key1", "value1")
+ opt(opts)
+ assert.Equal(t, "value1", opts.Provider.Params["key1"])
+}
+
+// Test WithServerParam creates params map if nil
+func TestWithServerParamCreateMap(t *testing.T) {
+ opts := defaultServerOptions()
+ opts.Provider.Params = nil
+ opt := WithServerParam("key1", "value1")
+ opt(opts)
+ assert.NotNil(t, opts.Provider.Params)
+ assert.Equal(t, "value1", opts.Provider.Params["key1"])
+}
+
+// Test WithServerFilter
+func TestWithServerFilter(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerFilter("echo")
+ opt(opts)
+ assert.Equal(t, "echo", opts.Provider.Filter)
+}
+
+// Test WithServerRegistryIDs
+func TestWithServerRegistryIDs(t *testing.T) {
+ opts := defaultServerOptions()
+ registryIDs := []string{"registry1", "registry2"}
+ opt := WithServerRegistryIDs(registryIDs)
+ opt(opts)
+ assert.Equal(t, registryIDs, opts.Provider.RegistryIDs)
+}
+
+// Test WithServerProtocolIDs
+func TestWithServerProtocolIDs(t *testing.T) {
+ opts := defaultServerOptions()
+ protocolIDs := []string{"dubbo", "triple"}
+ opt := WithServerProtocolIDs(protocolIDs)
+ opt(opts)
+ assert.Equal(t, protocolIDs, opts.Provider.ProtocolIDs)
+}
+
+// Test WithServerAdaptiveService
+func TestWithServerAdaptiveService(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerAdaptiveService()
+ opt(opts)
+ assert.True(t, opts.Provider.AdaptiveService)
+}
+
+// Test WithServerAdaptiveServiceVerbose
+func TestWithServerAdaptiveServiceVerbose(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerAdaptiveServiceVerbose()
+ opt(opts)
+ assert.True(t, opts.Provider.AdaptiveServiceVerbose)
+}
+
+// Test SetServerApplication
+func TestSetServerApplication(t *testing.T) {
+ opts := defaultServerOptions()
+ appCfg := &global.ApplicationConfig{Name: "test-app"}
+ opt := SetServerApplication(appCfg)
+ opt(opts)
+ assert.Equal(t, appCfg, opts.Application)
+}
+
+// Test SetServerRegistries
+func TestSetServerRegistries(t *testing.T) {
+ opts := defaultServerOptions()
+ regs := map[string]*global.RegistryConfig{
+ "reg1": {Protocol: "zookeeper"},
+ }
+ opt := SetServerRegistries(regs)
+ opt(opts)
+ assert.Equal(t, regs, opts.Registries)
+}
+
+// Test SetServerProtocols
+func TestSetServerProtocols(t *testing.T) {
+ opts := defaultServerOptions()
+ pros := map[string]*global.ProtocolConfig{
+ "dubbo": {Name: "dubbo"},
+ }
+ opt := SetServerProtocols(pros)
+ opt(opts)
+ assert.Equal(t, pros, opts.Protocols)
+}
+
+// Test SetServerShutdown
+func TestSetServerShutdown(t *testing.T) {
+ opts := defaultServerOptions()
+ shutdown := &global.ShutdownConfig{Timeout: "10s"}
+ opt := SetServerShutdown(shutdown)
+ opt(opts)
+ assert.Equal(t, shutdown, opts.Shutdown)
+}
+
+// Test SetServerMetrics
+func TestSetServerMetrics(t *testing.T) {
+ opts := defaultServerOptions()
+ metrics := &global.MetricsConfig{}
+ opt := SetServerMetrics(metrics)
+ opt(opts)
+ assert.Equal(t, metrics, opts.Metrics)
+}
+
+// Test SetServerOtel
+func TestSetServerOtel(t *testing.T) {
+ opts := defaultServerOptions()
+ otel := &global.OtelConfig{}
+ opt := SetServerOtel(otel)
+ opt(opts)
+ assert.Equal(t, otel, opts.Otel)
+}
+
+// Test SetServerTLS
+func TestSetServerTLS(t *testing.T) {
+ opts := defaultServerOptions()
+ tlsCfg := &global.TLSConfig{}
+ opt := SetServerTLS(tlsCfg)
+ opt(opts)
+ assert.Equal(t, tlsCfg, opts.TLS)
+}
+
+// Test SetServerProvider
+func TestSetServerProvider(t *testing.T) {
+ opts := defaultServerOptions()
+ provider := &global.ProviderConfig{}
+ opt := SetServerProvider(provider)
+ opt(opts)
+ assert.Equal(t, provider, opts.Provider)
+}
+
+// ==================== ServiceOptions Tests ====================
+
+// Test defaultServiceOptions
+func TestDefaultServiceOptions(t *testing.T) {
+ opts := defaultServiceOptions()
+ assert.NotNil(t, opts)
+ assert.NotNil(t, opts.Service)
+ assert.NotNil(t, opts.Application)
+ assert.False(t, opts.unexported.Load())
+ assert.False(t, opts.exported.Load())
+ assert.True(t, opts.needExport)
+}
+
+// Test WithInterface
+func TestWithInterface(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithInterface("com.example.Service")
+ opt(opts)
+ assert.Equal(t, "com.example.Service", opts.Service.Interface)
+}
+
+// Test WithRegistryIDs
+func TestWithRegistryIDs(t *testing.T) {
+ opts := defaultServiceOptions()
+ registryIDs := []string{"registry1"}
+ opt := WithRegistryIDs(registryIDs)
+ opt(opts)
+ assert.NotEqual(t, registryIDs, opts.Service.RegistryIDs)
+}
+
+// Test WithFilter
+func TestWithFilter(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithFilter("echo,access_log")
+ opt(opts)
+ assert.Equal(t, "echo,access_log", opts.Service.Filter)
+}
+
+// Test WithLoadBalanceConsistentHashing
+func TestWithLoadBalanceConsistentHashing(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithLoadBalanceConsistentHashing()
+ opt(opts)
+ assert.Equal(t, constant.LoadBalanceKeyConsistentHashing,
opts.Service.Loadbalance)
+}
+
+// Test WithLoadBalanceLeastActive
+func TestWithLoadBalanceLeastActive(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithLoadBalanceLeastActive()
+ opt(opts)
+ assert.Equal(t, constant.LoadBalanceKeyLeastActive,
opts.Service.Loadbalance)
+}
+
+// Test WithLoadBalanceRandom
+func TestWithLoadBalanceRandom(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithLoadBalanceRandom()
+ opt(opts)
+ assert.Equal(t, constant.LoadBalanceKeyRandom, opts.Service.Loadbalance)
+}
+
+// Test WithLoadBalanceRoundRobin
+func TestWithLoadBalanceRoundRobin(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithLoadBalanceRoundRobin()
+ opt(opts)
+ assert.Equal(t, constant.LoadBalanceKeyRoundRobin,
opts.Service.Loadbalance)
+}
+
+// Test WithLoadBalanceP2C
+func TestWithLoadBalanceP2C(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithLoadBalanceP2C()
+ opt(opts)
+ assert.Equal(t, constant.LoadBalanceKeyP2C, opts.Service.Loadbalance)
+}
+
+// Test WithLoadBalance
+func TestWithLoadBalance(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithLoadBalance("custom-lb")
+ opt(opts)
+ assert.Equal(t, "custom-lb", opts.Service.Loadbalance)
+}
+
+// Test WithWarmUp
+func TestWithWarmUp(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithWarmUp(60 * time.Second)
+ opt(opts)
+ assert.Equal(t, "60", opts.Service.Warmup)
+}
+
+// Test WithClusterAvailable
+func TestWithClusterAvailable(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithClusterAvailable()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyAvailable, opts.Service.Cluster)
+}
+
+// Test WithClusterBroadcast
+func TestWithClusterBroadcast(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithClusterBroadcast()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyBroadcast, opts.Service.Cluster)
+}
+
+// Test WithClusterFailBack
+func TestWithClusterFailBack(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithClusterFailBack()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyFailback, opts.Service.Cluster)
+}
+
+// Test WithClusterFailFast
+func TestWithClusterFailFast(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithClusterFailFast()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyFailfast, opts.Service.Cluster)
+}
+
+// Test WithClusterFailOver
+func TestWithClusterFailOver(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithClusterFailOver()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyFailover, opts.Service.Cluster)
+}
+
+// Test WithClusterFailSafe
+func TestWithClusterFailSafe(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithClusterFailSafe()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyFailsafe, opts.Service.Cluster)
+}
+
+// Test WithClusterForking
+func TestWithClusterForking(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithClusterForking()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyForking, opts.Service.Cluster)
+}
+
+// Test WithClusterZoneAware
+func TestWithClusterZoneAware(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithClusterZoneAware()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyZoneAware, opts.Service.Cluster)
+}
+
+// Test WithClusterAdaptiveService
+func TestWithClusterAdaptiveService(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithClusterAdaptiveService()
+ opt(opts)
+ assert.Equal(t, constant.ClusterKeyAdaptiveService,
opts.Service.Cluster)
+}
+
+// Test WithCluster
+func TestWithCluster(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithCluster("custom-cluster")
+ opt(opts)
+ assert.Equal(t, "custom-cluster", opts.Service.Cluster)
+}
+
+// Test WithGroup
+func TestWithGroup(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithGroup("test-group")
+ opt(opts)
+ assert.Equal(t, "test-group", opts.Service.Group)
+}
+
+// Test WithVersion
+func TestWithVersion(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithVersion("1.0.0")
+ opt(opts)
+ assert.Equal(t, "1.0.0", opts.Service.Version)
+}
+
+// Test WithJSON
+func TestWithJSON(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithJSON()
+ opt(opts)
+ assert.Equal(t, constant.JSONSerialization, opts.Service.Serialization)
+}
+
+// Test WithToken
+func TestWithToken(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithToken("test-token")
+ opt(opts)
+ assert.Equal(t, "test-token", opts.Service.Token)
+}
+
+// Test WithNotRegister
+func TestWithNotRegister(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithNotRegister()
+ opt(opts)
+ assert.True(t, opts.Service.NotRegister)
+}
+
+// Test WithWarmup
+func TestWithWarmup(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithWarmup(30 * time.Second)
+ opt(opts)
+ assert.Equal(t, "30s", opts.Service.Warmup)
+}
+
+// Test WithRetries
+func TestWithRetries(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithRetries(3)
+ opt(opts)
+ assert.Equal(t, "3", opts.Service.Retries)
+}
+
+// Test WithSerialization
+func TestWithSerialization(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithSerialization("protobuf")
+ opt(opts)
+ assert.Equal(t, "protobuf", opts.Service.Serialization)
+}
+
+// Test WithAccesslog
+func TestWithAccesslog(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithAccesslog("/var/log/access.log")
+ opt(opts)
+ assert.Equal(t, "/var/log/access.log", opts.Service.AccessLog)
+}
+
+// Test WithTpsLimiter
+func TestWithTpsLimiter(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithTpsLimiter("default")
+ opt(opts)
+ assert.Equal(t, "default", opts.Service.TpsLimiter)
+}
+
+// Test WithTpsLimitRate
+func TestWithTpsLimitRate(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithTpsLimitRate(1000)
+ opt(opts)
+ assert.Equal(t, "1000", opts.Service.TpsLimitRate)
+}
+
+// Test WithTpsLimitStrategy
+func TestWithTpsLimitStrategy(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithTpsLimitStrategy("adaptive")
+ opt(opts)
+ assert.Equal(t, "adaptive", opts.Service.TpsLimitStrategy)
+}
+
+// Test WithTpsLimitRejectedHandler
+func TestWithTpsLimitRejectedHandler(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithTpsLimitRejectedHandler("abort")
+ opt(opts)
+ assert.Equal(t, "abort", opts.Service.TpsLimitRejectedHandler)
+}
+
+// Test WithExecuteLimit
+func TestWithExecuteLimit(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithExecuteLimit("100")
+ opt(opts)
+ assert.Equal(t, "100", opts.Service.ExecuteLimit)
+}
+
+// Test WithExecuteLimitRejectedHandler
+func TestWithExecuteLimitRejectedHandler(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithExecuteLimitRejectedHandler("abort")
+ opt(opts)
+ assert.Equal(t, "abort", opts.Service.ExecuteLimitRejectedHandler)
+}
+
+// Test WithAuth
+func TestWithAuth(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithAuth("default")
+ opt(opts)
+ assert.Equal(t, "default", opts.Service.Auth)
+}
+
+// Test WithParamSign
+func TestWithParamSign(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithParamSign("md5")
+ opt(opts)
+ assert.Equal(t, "md5", opts.Service.ParamSign)
+}
+
+// Test WithTag
+func TestWithTag(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithTag("v1")
+ opt(opts)
+ assert.Equal(t, "v1", opts.Service.Tag)
+}
+
+// Test WithParam
+func TestWithParam(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithParam("key1", "value1")
+ opt(opts)
+ assert.Equal(t, "value1", opts.Service.Params["key1"])
+}
+
+// Test WithParam creates params map if nil
+func TestWithParamCreateMap(t *testing.T) {
+ opts := defaultServiceOptions()
+ opts.Service.Params = nil
+ opt := WithParam("key1", "value1")
+ opt(opts)
+ assert.NotNil(t, opts.Service.Params)
+ assert.Equal(t, "value1", opts.Service.Params["key1"])
+}
+
+// Test WithIDLMode
+func TestWithIDLMode(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithIDLMode(constant.IDL)
+ opt(opts)
+ assert.Equal(t, constant.IDL, opts.IDLMode)
+}
+
+// Test SetApplication
+func TestSetApplication(t *testing.T) {
+ opts := defaultServiceOptions()
+ appCfg := &global.ApplicationConfig{Name: "test-app"}
+ opt := SetApplication(appCfg)
+ opt(opts)
+ assert.Equal(t, appCfg, opts.Application)
+}
+
+// Test SetProvider
+func TestSetProvider(t *testing.T) {
+ opts := defaultServiceOptions()
+ provider := &global.ProviderConfig{}
+ opt := SetProvider(provider)
+ opt(opts)
+ assert.Equal(t, provider, opts.Provider)
+}
+
+// Test SetService
+func TestSetService(t *testing.T) {
+ opts := defaultServiceOptions()
+ service := &global.ServiceConfig{Interface: "com.example.Service"}
+ opt := SetService(service)
+ opt(opts)
+ assert.Equal(t, service, opts.Service)
+}
+
+// Test SetRegistries
+func TestSetRegistries(t *testing.T) {
+ opts := defaultServiceOptions()
+ regs := map[string]*global.RegistryConfig{
+ "reg1": {Protocol: "zookeeper"},
+ }
+ opt := SetRegistries(regs)
+ opt(opts)
+ assert.Equal(t, regs, opts.Registries)
+}
+
+// Test SetProtocols
+func TestSetProtocols(t *testing.T) {
+ opts := defaultServiceOptions()
+ pros := map[string]*global.ProtocolConfig{
+ "dubbo": {Name: "dubbo"},
+ }
+ opt := SetProtocols(pros)
+ opt(opts)
+ assert.Equal(t, pros, opts.Protocols)
+}
+
+// Test WithServerRegistry
+func TestWithServerRegistry(t *testing.T) {
+ opts := defaultServerOptions()
+
+ // Use registry.WithZookeeper() to create a proper registry option
+ opt := WithServerRegistry(registry.WithZookeeper(),
registry.WithID("test-registry"))
+ opt(opts)
+
+ assert.NotNil(t, opts.Registries)
+ assert.Contains(t, opts.Registries, "test-registry")
+ assert.Equal(t, "zookeeper", opts.Registries["test-registry"].Protocol)
+}
+
+// Test WithServerProtocol
+func TestWithServerProtocol(t *testing.T) {
+ opts := defaultServerOptions()
+
+ // Use protocol options to create a proper protocol configuration
+ opt := WithServerProtocol(protocol.WithDubbo(),
protocol.WithID("test-protocol"))
+ opt(opts)
+
+ assert.NotNil(t, opts.Protocols)
+ assert.Contains(t, opts.Protocols, "test-protocol")
+ assert.Equal(t, "dubbo", opts.Protocols["test-protocol"].Name)
+}
+
+// Test WithServerFilterConf
+func TestWithServerFilterConf(t *testing.T) {
+ opts := defaultServerOptions()
+ conf := map[string]any{"key": "value"}
+ opt := WithServerFilterConf(conf)
+ opt(opts)
+ assert.Equal(t, conf, opts.Provider.FilterConf)
+}
+
+// Test WithServerTLSOption
+func TestWithServerTLSOption(t *testing.T) {
+ opts := defaultServerOptions()
+ opt := WithServerTLSOption()
+ opt(opts)
+ assert.NotNil(t, opts.TLS)
+}
+
+// Test WithProtocol for ServiceOptions
+func TestWithProtocol(t *testing.T) {
+ opts := defaultServiceOptions()
+
+ // Use protocol options to create a proper protocol configuration
+ opt := WithProtocol(protocol.WithTriple(),
protocol.WithID("test-protocol"))
+ opt(opts)
+
+ assert.NotNil(t, opts.Protocols)
+ assert.Contains(t, opts.Protocols, "test-protocol")
+ assert.Equal(t, "tri", opts.Protocols["test-protocol"].Name)
+}
+
+// Test WithRegistry for ServiceOptions
+func TestWithRegistry(t *testing.T) {
+ opts := defaultServiceOptions()
+
+ // Use registry.WithNacos() to create a proper registry option
+ opt := WithRegistry(registry.WithNacos(),
registry.WithID("test-registry"))
+ opt(opts)
+
+ assert.NotNil(t, opts.Registries)
+ assert.Contains(t, opts.Registries, "test-registry")
+ assert.Equal(t, "nacos", opts.Registries["test-registry"].Protocol)
+}
+
+// Test WithMethod
+func TestWithMethod(t *testing.T) {
+ opts := defaultServiceOptions()
+ opt := WithMethod()
+ opt(opts)
+ assert.NotNil(t, opts.Service.Methods)
+ // Verify that a method was actually added
+ assert.Equal(t, 1, len(opts.Service.Methods))
+}
+
+// Test WithProtocolIDs for ServiceOptions
+func TestWithProtocolIDs(t *testing.T) {
+ opts := defaultServiceOptions()
+ protocolIDs := []string{"dubbo"}
+ opt := WithProtocolIDs(protocolIDs)
+ opt(opts)
+ assert.NotEqual(t, protocolIDs, opts.Service.ProtocolIDs)
+}
