You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@dubbo.apache.org by al...@apache.org on 2022/02/20 09:43:59 UTC
[dubbo-go] branch 3.0 updated: add config ut (#1757)
This is an automated email from the ASF dual-hosted git repository.
alexstocks pushed a commit to branch 3.0
in repository https://gitbox.apache.org/repos/asf/dubbo-go.git
The following commit(s) were added to refs/heads/3.0 by this push:
new 3c9fa51 add config ut (#1757)
3c9fa51 is described below
commit 3c9fa51c58dfa113beaa17ec269582f3e9eb259a
Author: zhaoyunxing <zh...@apache.org>
AuthorDate: Sun Feb 20 17:43:53 2022 +0800
add config ut (#1757)
* add application ut
* add config center config ut
* add tracing config ut
* add service discovery config ut
* add service config
* add service config ut
* add service ut
* add service ut
* add router config ut
* add root config ut
* add remote config ut
* fmt
* add registry config ut
* fmt
* add reference config ut
* add provider config ut
* add mock service ut
* add metric config ut
* add metadata report config ut
* add logger config ut
* add graceful shutdown config ut
* add config utils ut
---
config/application_config_test.go | 31 +++++
config/config_center_config_test.go | 51 +++++++++
config/custom_config_test.go | 52 ++++++---
config/graceful_shutdown_config.go | 2 -
config/graceful_shutdown_config_test.go | 28 +++++
config/logger_config.go | 4 -
config/logger_config_test.go | 13 +++
config/metadata_report_config.go | 9 --
...nfig_test.go => metadata_report_config_test.go} | 21 +++-
config/metric_config.go | 19 ++--
...cation_config_test.go => metric_config_test.go} | 13 +--
...tion_config_test.go => mock_rpcservice_test.go} | 14 ++-
config/provider_config.go | 10 --
config/provider_config_test.go | 24 ++++
config/reference_config_test.go | 43 +++++++
config/registry_config.go | 2 +-
config/registry_config_test.go | 57 ++++++++++
config/remote_config.go | 1 -
config/remote_config_test.go | 34 ++++++
config/root_config_test.go | 40 +++++++
config/router_config.go | 13 ---
config/router_config_test.go | 32 ++++++
config/service_config.go | 8 +-
config/service_config_test.go | 126 +++++++++++++++++++++
...ig_test.go => service_discovery_config_test.go} | 17 ++-
...ful_shutdown_config_test.go => service_test.go} | 29 +++--
...enter_config_test.go => tracing_config_test.go} | 13 ++-
27 files changed, 591 insertions(+), 115 deletions(-)
diff --git a/config/application_config_test.go b/config/application_config_test.go
index 398fa6e..86eea09 100644
--- a/config/application_config_test.go
+++ b/config/application_config_test.go
@@ -25,6 +25,10 @@ import (
"github.com/stretchr/testify/assert"
)
+import (
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
+)
+
func TestApplicationConfig(t *testing.T) {
err := Load(WithPath("./testdata/config/application/application.yaml"))
@@ -33,3 +37,30 @@ func TestApplicationConfig(t *testing.T) {
center := rootConfig.Registries
assert.NotNil(t, center)
}
+
+func TestApplicationConfigBuilder(t *testing.T) {
+
+ application := NewApplicationConfigBuilder().
+ SetOrganization("organization").
+ SetName("name").
+ SetModule("module").
+ SetVersion("version").
+ SetOwner("owner").
+ SetEnvironment("environment").
+ SetMetadataType("metadataType").
+ Build()
+
+ err := application.check()
+ assert.Nil(t, err)
+ err = application.Init()
+
+ assert.Nil(t, err)
+ assert.Equal(t, application.Name, "name")
+ assert.Equal(t, application.Organization, "organization")
+ assert.Equal(t, application.Module, "module")
+ assert.Equal(t, application.Version, "version")
+ assert.Equal(t, application.Owner, "owner")
+ assert.Equal(t, application.Environment, "environment")
+ assert.Equal(t, application.MetadataType, "metadataType")
+ assert.Equal(t, application.Prefix(), constant.ApplicationConfigPrefix)
+}
diff --git a/config/config_center_config_test.go b/config/config_center_config_test.go
index e77e593..b32c4c5 100644
--- a/config/config_center_config_test.go
+++ b/config/config_center_config_test.go
@@ -26,6 +26,7 @@ import (
)
import (
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
_ "dubbo.apache.org/dubbo-go/v3/config_center/apollo"
)
@@ -37,3 +38,53 @@ func TestApolloConfigCenterConfig(t *testing.T) {
registries := rootConfig.Registries
assert.NotNil(t, registries)
}
+func TestConfigCenterConfig(t *testing.T) {
+ var (
+ config *CenterConfig
+ err error
+ )
+
+ t.Run("ConfigCenterConfigBuilder", func(t *testing.T) {
+ config = NewConfigCenterConfigBuilder().
+ SetProtocol("protocol").
+ SetUserName("userName").
+ SetAddress("address").
+ SetPassword("password").
+ SetNamespace("namespace").
+ SetGroup("group").
+ SetDataID("dataId").
+ Build()
+
+ err = config.check()
+ assert.Nil(t, err)
+
+ assert.Equal(t, config.Protocol, "protocol")
+ assert.Equal(t, config.Username, "userName")
+ assert.Equal(t, config.Address, "address")
+ assert.Equal(t, config.Password, "password")
+ assert.Equal(t, config.Namespace, "namespace")
+ assert.Equal(t, config.Group, "group")
+ assert.Equal(t, config.DataId, "dataId")
+ assert.Equal(t, config.Prefix(), constant.ConfigCenterPrefix)
+ //assert.Equal(t, config.NameId(),
+ // strings.Join([]string{constant.ConfigCenterPrefix, "protocol", "address"}, "-"))
+ })
+
+ t.Run("GetUrlMap", func(t *testing.T) {
+ url := config.GetUrlMap()
+ assert.Equal(t, url.Get(constant.ConfigNamespaceKey), config.Namespace)
+ assert.Equal(t, url.Get(constant.ConfigClusterKey), config.Cluster)
+ })
+
+ t.Run("translateConfigAddress", func(t *testing.T) {
+ address := config.translateConfigAddress()
+ assert.Equal(t, address, "address")
+ })
+
+ t.Run("toUrl", func(t *testing.T) {
+ url, err := config.toURL()
+ assert.Nil(t, err)
+ namespace := url.GetParam(constant.ConfigNamespaceKey, "namespace")
+ assert.Equal(t, namespace, "namespace")
+ })
+}
diff --git a/config/custom_config_test.go b/config/custom_config_test.go
index 1289584..72193a2 100644
--- a/config/custom_config_test.go
+++ b/config/custom_config_test.go
@@ -18,6 +18,7 @@
package config
import (
+ "strings"
"testing"
)
@@ -25,15 +26,19 @@ import (
"github.com/stretchr/testify/assert"
)
+import (
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
+)
+
func TestCustomInit(t *testing.T) {
t.Run("empty use default", func(t *testing.T) {
err := Load(WithPath("./testdata/config/custom/empty.yaml"))
assert.Nil(t, err)
assert.NotNil(t, rootConfig)
- CustomConfig := rootConfig.Custom
- assert.NotNil(t, CustomConfig)
- assert.Equal(t, CustomConfig.ConfigMap, map[string]interface{}(nil))
- assert.Equal(t, CustomConfig.GetDefineValue("test", "test"), "test")
+ customConfig := rootConfig.Custom
+ assert.NotNil(t, customConfig)
+ assert.Equal(t, customConfig.ConfigMap, map[string]interface{}(nil))
+ assert.Equal(t, customConfig.GetDefineValue("test", "test"), "test")
assert.Equal(t, GetDefineValue("test", "test"), "test")
})
@@ -41,28 +46,43 @@ func TestCustomInit(t *testing.T) {
err := Load(WithPath("./testdata/config/custom/custom.yaml"))
assert.Nil(t, err)
assert.NotNil(t, rootConfig)
- CustomConfig := rootConfig.Custom
- assert.NotNil(t, CustomConfig)
- assert.Equal(t, CustomConfig.ConfigMap, map[string]interface{}{"test-config": true})
- assert.Equal(t, CustomConfig.GetDefineValue("test-config", false), true)
- assert.Equal(t, CustomConfig.GetDefineValue("test-no-config", false), false)
+ customConfig := rootConfig.Custom
+ assert.NotNil(t, customConfig)
+ assert.Equal(t, customConfig.ConfigMap, map[string]interface{}{"test-config": true})
+ assert.Equal(t, customConfig.GetDefineValue("test-config", false), true)
+ assert.Equal(t, customConfig.GetDefineValue("test-no-config", false), false)
assert.Equal(t, GetDefineValue("test-config", false), true)
assert.Equal(t, GetDefineValue("test-no-config", false), false)
})
t.Run("config builder", func(t *testing.T) {
- CustomConfigBuilder := NewCustomConfigBuilder()
- CustomConfigBuilder.SetDefineConfig("test-build", true)
- CustomConfig := CustomConfigBuilder.Build()
- assert.NotNil(t, CustomConfig)
- assert.Equal(t, CustomConfig.GetDefineValue("test-build", false), true)
- assert.Equal(t, CustomConfig.GetDefineValue("test-no-build", false), false)
+ customConfigBuilder := NewCustomConfigBuilder()
+ customConfigBuilder.SetDefineConfig("test-build", true)
+ customConfig := customConfigBuilder.Build()
+ assert.NotNil(t, customConfig)
+ assert.Equal(t, customConfig.GetDefineValue("test-build", false), true)
+ assert.Equal(t, customConfig.GetDefineValue("test-no-build", false), false)
// todo @(laurence) now we should guarantee rootConfig ptr can't be changed during test
tempRootConfig := rootConfig
- rt := NewRootConfigBuilder().SetCustom(CustomConfig).Build()
+ rt := NewRootConfigBuilder().SetCustom(customConfig).Build()
SetRootConfig(*rt)
assert.Equal(t, GetDefineValue("test-build", false), true)
assert.Equal(t, GetDefineValue("test-no-build", false), false)
SetRootConfig(*tempRootConfig)
})
}
+
+func TestConfigUtils(t *testing.T) {
+ config := NewRegistryConfigWithProtocolDefaultPort("nacos")
+
+ id := clientNameID(config, config.Protocol, config.Address)
+
+ assert.Equal(t, id, strings.Join([]string{constant.RegistryConfigPrefix, "nacos", "127.0.0.1:8848"}, "-"))
+
+ ids := translateRegistryIds([]string{"nacos,zk"})
+ assert.Equal(t, ids[0], "nacos")
+ assert.Equal(t, ids[1], "zk")
+
+ element := removeDuplicateElement([]string{"nacos", "nacos"})
+ assert.Equal(t, len(element), 1)
+}
diff --git a/config/graceful_shutdown_config.go b/config/graceful_shutdown_config.go
index 7b96927..445796e 100644
--- a/config/graceful_shutdown_config.go
+++ b/config/graceful_shutdown_config.go
@@ -78,7 +78,6 @@ func (config *ShutdownConfig) Prefix() string {
return constant.ShutdownConfigPrefix
}
-// nolint
func (config *ShutdownConfig) GetTimeout() time.Duration {
result, err := time.ParseDuration(config.Timeout)
if err != nil {
@@ -89,7 +88,6 @@ func (config *ShutdownConfig) GetTimeout() time.Duration {
return result
}
-// nolint
func (config *ShutdownConfig) GetStepTimeout() time.Duration {
result, err := time.ParseDuration(config.StepTimeout)
if err != nil {
diff --git a/config/graceful_shutdown_config_test.go b/config/graceful_shutdown_config_test.go
index a612200..3d4e8fa 100644
--- a/config/graceful_shutdown_config_test.go
+++ b/config/graceful_shutdown_config_test.go
@@ -26,6 +26,10 @@ import (
"github.com/stretchr/testify/assert"
)
+import (
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
+)
+
func TestShutdownConfigGetTimeout(t *testing.T) {
config := ShutdownConfig{}
assert.False(t, config.RejectRequest.Load())
@@ -46,3 +50,27 @@ func TestShutdownConfigGetTimeout(t *testing.T) {
assert.Equal(t, 34*time.Millisecond, config.GetTimeout())
assert.Equal(t, 79*time.Millisecond, config.GetStepTimeout())
}
+
+func TestNewShutDownConfigBuilder(t *testing.T) {
+ config := NewShutDownConfigBuilder().
+ SetTimeout("10s").
+ SetStepTimeout("15s").
+ SetRejectRequestHandler("handler").
+ SetRejectRequest(true).
+ SetInternalSignal(true).
+ Build()
+
+ assert.Equal(t, config.Prefix(), constant.ShutdownConfigPrefix)
+
+ timeout := config.GetTimeout()
+ assert.Equal(t, timeout, 10*time.Second)
+
+ stepTimeout := config.GetStepTimeout()
+ assert.Equal(t, stepTimeout, 15*time.Second)
+
+ err := config.Init()
+ assert.NoError(t, err)
+
+ waitTime := config.GetConsumerUpdateWaitTime()
+ assert.Equal(t, waitTime, 3*time.Second)
+}
diff --git a/config/logger_config.go b/config/logger_config.go
index d36b6d7..1050c0f 100644
--- a/config/logger_config.go
+++ b/config/logger_config.go
@@ -149,24 +149,20 @@ type LoggerConfigBuilder struct {
loggerConfig *LoggerConfig
}
-// nolint
func NewLoggerConfigBuilder() *LoggerConfigBuilder {
return &LoggerConfigBuilder{loggerConfig: &LoggerConfig{}}
}
-// nolint
func (lcb *LoggerConfigBuilder) SetLumberjackConfig(lumberjackConfig *lumberjack.Logger) *LoggerConfigBuilder {
lcb.loggerConfig.LumberjackConfig = lumberjackConfig
return lcb
}
-// nolint
func (lcb *LoggerConfigBuilder) SetZapConfig(zapConfig ZapConfig) *LoggerConfigBuilder {
lcb.loggerConfig.ZapConfig = zapConfig
return lcb
}
-// nolint
func (lcb *LoggerConfigBuilder) Build() *LoggerConfig {
return lcb.loggerConfig
}
diff --git a/config/logger_config_test.go b/config/logger_config_test.go
index 888d981..ed9ac24 100644
--- a/config/logger_config_test.go
+++ b/config/logger_config_test.go
@@ -70,3 +70,16 @@ func TestLoggerInit(t *testing.T) {
logger.Errorf("%s", "error")
})
}
+
+func TestNewLoggerConfigBuilder(t *testing.T) {
+ config := NewLoggerConfigBuilder().
+ SetLumberjackConfig(nil).
+ SetZapConfig(ZapConfig{}).
+ Build()
+
+ assert.NotNil(t, config)
+ values := config.getUrlMap()
+ assert.NotNil(t, values)
+ err := config.check()
+ assert.NoError(t, err)
+}
diff --git a/config/metadata_report_config.go b/config/metadata_report_config.go
index 9cc902d..99845ee 100644
--- a/config/metadata_report_config.go
+++ b/config/metadata_report_config.go
@@ -136,49 +136,40 @@ type MetadataReportConfigBuilder struct {
metadataReportConfig *MetadataReportConfig
}
-// nolint
func NewMetadataReportConfigBuilder() *MetadataReportConfigBuilder {
return &MetadataReportConfigBuilder{metadataReportConfig: &MetadataReportConfig{}}
}
-// nolint
func (mrcb *MetadataReportConfigBuilder) SetProtocol(protocol string) *MetadataReportConfigBuilder {
mrcb.metadataReportConfig.Protocol = protocol
return mrcb
}
-// nolint
func (mrcb *MetadataReportConfigBuilder) SetAddress(address string) *MetadataReportConfigBuilder {
mrcb.metadataReportConfig.Address = address
return mrcb
}
-// nolint
func (mrcb *MetadataReportConfigBuilder) SetUsername(username string) *MetadataReportConfigBuilder {
mrcb.metadataReportConfig.Username = username
return mrcb
}
-// nolint
func (mrcb *MetadataReportConfigBuilder) SetPassword(password string) *MetadataReportConfigBuilder {
mrcb.metadataReportConfig.Password = password
return mrcb
}
-// nolint
func (mrcb *MetadataReportConfigBuilder) SetTimeout(timeout string) *MetadataReportConfigBuilder {
mrcb.metadataReportConfig.Timeout = timeout
return mrcb
}
-// nolint
func (mrcb *MetadataReportConfigBuilder) SetGroup(group string) *MetadataReportConfigBuilder {
mrcb.metadataReportConfig.Group = group
return mrcb
}
-// nolint
func (mrcb *MetadataReportConfigBuilder) Build() *MetadataReportConfig {
- // TODO Init
return mrcb.metadataReportConfig
}
diff --git a/config/config_center_config_test.go b/config/metadata_report_config_test.go
similarity index 63%
copy from config/config_center_config_test.go
copy to config/metadata_report_config_test.go
index e77e593..1b1a9ac 100644
--- a/config/config_center_config_test.go
+++ b/config/metadata_report_config_test.go
@@ -26,14 +26,23 @@ import (
)
import (
- _ "dubbo.apache.org/dubbo-go/v3/config_center/apollo"
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
)
-func TestApolloConfigCenterConfig(t *testing.T) {
+func TestNewMetadataReportConfigBuilder(t *testing.T) {
+ config := NewMetadataReportConfigBuilder().
+ SetProtocol("nacos").
+ SetAddress("127.0.0.1:8848").
+ SetUsername("nacos").
+ SetPassword("123456").
+ SetTimeout("10s").
+ SetGroup("dubbo").
+ Build()
- err := Load(WithPath("./testdata/config/center/apollo.yaml"))
- assert.Nil(t, err)
+ assert.Equal(t, config.IsValid(), true)
+ assert.Equal(t, config.Prefix(), constant.MetadataReportPrefix)
- registries := rootConfig.Registries
- assert.NotNil(t, registries)
+ url, err := config.ToUrl()
+ assert.NoError(t, err)
+ assert.Equal(t, url.GetParam(constant.TimeoutKey, "3s"), "10s")
}
diff --git a/config/metric_config.go b/config/metric_config.go
index 458485c..13ecf2d 100644
--- a/config/metric_config.go
+++ b/config/metric_config.go
@@ -38,23 +38,22 @@ type MetricConfig struct {
PushGatewayAddress string `default:"" yaml:"push-gateway-address" json:"push-gateway-address,omitempty" property:"push-gateway-address"`
}
-func (m *MetricConfig) ToReporterConfig() *metrics.ReporterConfig {
+func (mc *MetricConfig) ToReporterConfig() *metrics.ReporterConfig {
defaultMetricsReportConfig := metrics.NewReporterConfig()
- if m.Mode == metrics.ReportModePush {
+ if mc.Mode == metrics.ReportModePush {
defaultMetricsReportConfig.Mode = metrics.ReportModePush
}
- if m.Namespace != "" {
- defaultMetricsReportConfig.Namespace = m.Namespace
+ if mc.Namespace != "" {
+ defaultMetricsReportConfig.Namespace = mc.Namespace
}
- defaultMetricsReportConfig.Enable = m.Enable == "1"
- defaultMetricsReportConfig.Port = m.Port
- defaultMetricsReportConfig.Path = m.Path
- defaultMetricsReportConfig.PushGatewayAddress = m.PushGatewayAddress
+ defaultMetricsReportConfig.Enable = mc.Enable == "1"
+ defaultMetricsReportConfig.Port = mc.Port
+ defaultMetricsReportConfig.Path = mc.Path
+ defaultMetricsReportConfig.PushGatewayAddress = mc.PushGatewayAddress
return defaultMetricsReportConfig
}
-// nolint
func (mc *MetricConfig) Init() error {
if mc == nil {
return errors.New("metrics config is null")
@@ -73,12 +72,10 @@ type MetricConfigBuilder struct {
metricConfig *MetricConfig
}
-// nolint
func NewMetricConfigBuilder() *MetricConfigBuilder {
return &MetricConfigBuilder{metricConfig: &MetricConfig{}}
}
-// nolint
func (mcb *MetricConfigBuilder) Build() *MetricConfig {
return mcb.metricConfig
}
diff --git a/config/application_config_test.go b/config/metric_config_test.go
similarity index 79%
copy from config/application_config_test.go
copy to config/metric_config_test.go
index 398fa6e..14804b3 100644
--- a/config/application_config_test.go
+++ b/config/metric_config_test.go
@@ -25,11 +25,10 @@ import (
"github.com/stretchr/testify/assert"
)
-func TestApplicationConfig(t *testing.T) {
-
- err := Load(WithPath("./testdata/config/application/application.yaml"))
- assert.Nil(t, err)
-
- center := rootConfig.Registries
- assert.NotNil(t, center)
+func TestMetricConfigBuilder(t *testing.T) {
+ config := NewMetricConfigBuilder().Build()
+ err := config.Init()
+ assert.NoError(t, err)
+ reporterConfig := config.ToReporterConfig()
+ assert.Equal(t, string(reporterConfig.Mode), "pull")
}
diff --git a/config/application_config_test.go b/config/mock_rpcservice_test.go
similarity index 73%
copy from config/application_config_test.go
copy to config/mock_rpcservice_test.go
index 398fa6e..3ee85c1 100644
--- a/config/application_config_test.go
+++ b/config/mock_rpcservice_test.go
@@ -18,6 +18,7 @@
package config
import (
+ "context"
"testing"
)
@@ -25,11 +26,14 @@ import (
"github.com/stretchr/testify/assert"
)
-func TestApplicationConfig(t *testing.T) {
+func TestMockService(t *testing.T) {
- err := Load(WithPath("./testdata/config/application/application.yaml"))
- assert.Nil(t, err)
+ mockService := &MockService{}
+ reference := mockService.Reference()
+ assert.Equal(t, reference, "MockService")
- center := rootConfig.Registries
- assert.NotNil(t, center)
+ err := mockService.GetUser1(context.TODO(), nil, nil)
+ assert.NoError(t, err)
+ err = mockService.GetUser(context.TODO(), nil, nil)
+ assert.NoError(t, err)
}
diff --git a/config/provider_config.go b/config/provider_config.go
index aaebc29..cc72120 100644
--- a/config/provider_config.go
+++ b/config/provider_config.go
@@ -174,25 +174,21 @@ func (pcb *ProviderConfigBuilder) SetFilter(filter string) *ProviderConfigBuilde
return pcb
}
-// nolint
func (pcb *ProviderConfigBuilder) SetRegister(register bool) *ProviderConfigBuilder {
pcb.providerConfig.Register = register
return pcb
}
-// nolint
func (pcb *ProviderConfigBuilder) SetRegistryIDs(RegistryIDs ...string) *ProviderConfigBuilder {
pcb.providerConfig.RegistryIDs = RegistryIDs
return pcb
}
-// nolint
func (pcb *ProviderConfigBuilder) SetServices(services map[string]*ServiceConfig) *ProviderConfigBuilder {
pcb.providerConfig.Services = services
return pcb
}
-// nolint
func (pcb *ProviderConfigBuilder) AddService(serviceID string, serviceConfig *ServiceConfig) *ProviderConfigBuilder {
if pcb.providerConfig.Services == nil {
pcb.providerConfig.Services = make(map[string]*ServiceConfig)
@@ -201,25 +197,21 @@ func (pcb *ProviderConfigBuilder) AddService(serviceID string, serviceConfig *Se
return pcb
}
-// nolint
func (pcb *ProviderConfigBuilder) SetProxyFactory(proxyFactory string) *ProviderConfigBuilder {
pcb.providerConfig.ProxyFactory = proxyFactory
return pcb
}
-// nolint
func (pcb *ProviderConfigBuilder) SetFilterConf(filterConf interface{}) *ProviderConfigBuilder {
pcb.providerConfig.FilterConf = filterConf
return pcb
}
-// nolint
func (pcb *ProviderConfigBuilder) SetConfigType(configType map[string]string) *ProviderConfigBuilder {
pcb.providerConfig.ConfigType = configType
return pcb
}
-// nolint
func (pcb *ProviderConfigBuilder) AddConfigType(key, value string) *ProviderConfigBuilder {
if pcb.providerConfig.ConfigType == nil {
pcb.providerConfig.ConfigType = make(map[string]string)
@@ -228,13 +220,11 @@ func (pcb *ProviderConfigBuilder) AddConfigType(key, value string) *ProviderConf
return pcb
}
-// nolint
func (pcb *ProviderConfigBuilder) SetRootConfig(rootConfig *RootConfig) *ProviderConfigBuilder {
pcb.providerConfig.rootConfig = rootConfig
return pcb
}
-// nolint
func (pcb *ProviderConfigBuilder) Build() *ProviderConfig {
return pcb.providerConfig
}
diff --git a/config/provider_config_test.go b/config/provider_config_test.go
index b418bff..1369b61 100644
--- a/config/provider_config_test.go
+++ b/config/provider_config_test.go
@@ -25,6 +25,10 @@ import (
"github.com/stretchr/testify/assert"
)
+import (
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
+)
+
func TestProviderConfigEmptyRegistry(t *testing.T) {
err := Load(WithPath("./testdata/config/provider/empty_registry_application.yaml"))
assert.Nil(t, err)
@@ -58,3 +62,23 @@ func TestProviderConfigRootRegistry(t *testing.T) {
// assert.NoError(t, ProviderInit(conPath))
// assert.Equal(t, "dubbo", config.referenceConfig.Services["UserProvider"].Protocol)
//}
+
+func TestNewProviderConfigBuilder(t *testing.T) {
+
+ config := NewProviderConfigBuilder().
+ SetFilter("echo").
+ SetRegister(true).
+ SetRegistryIDs("nacos").
+ SetServices(map[string]*ServiceConfig{}).
+ AddService("HelloService", &ServiceConfig{}).
+ SetProxyFactory("default").
+ SetFilterConf(nil).
+ SetConfigType(map[string]string{}).
+ AddConfigType("", "").
+ SetRootConfig(nil).
+ Build()
+
+ err := config.check()
+ assert.NoError(t, err)
+ assert.Equal(t, config.Prefix(), constant.ProviderConfigPrefix)
+}
diff --git a/config/reference_config_test.go b/config/reference_config_test.go
index 8458587..c8df59f 100644
--- a/config/reference_config_test.go
+++ b/config/reference_config_test.go
@@ -17,6 +17,19 @@
package config
+import (
+ "testing"
+)
+
+import (
+ "github.com/stretchr/testify/assert"
+)
+
+import (
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
+ _ "dubbo.apache.org/dubbo-go/v3/common/proxy/proxy_factory"
+)
+
//import (
// "context"
// "dubbo.apache.org/dubbo-go/v3/config"
@@ -409,3 +422,33 @@ package config
//func (gf *mockShutdownFilter) OnResponse(ctx context.Context, result protocol.Result, invoker protocol.Invoker, invocation protocol.Invocation) protocol.Result {
// return result
//}
+func TestNewReferenceConfigBuilder(t *testing.T) {
+ registryConfig := NewRegistryConfigWithProtocolDefaultPort("nacos")
+ protocolConfig := NewProtocolConfigBuilder().
+ SetName("dubbo").
+ SetPort("20000").
+ Build()
+ config := NewReferenceConfigBuilder().
+ SetInterface("org.apache.dubbo.HelloService").
+ SetRegistryIDs("nacos").
+ SetGeneric(false).
+ SetCluster("cluster").
+ SetSerialization("serialization").
+ SetProtocol("dubbo").
+ Build()
+
+ config.rootConfig = NewRootConfigBuilder().
+ SetProtocols(map[string]*ProtocolConfig{"dubbo": protocolConfig}).
+ SetRegistries(map[string]*RegistryConfig{"nacos": registryConfig}).
+ Build()
+
+ assert.Equal(t, config.Prefix(), constant.ReferenceConfigPrefix+config.InterfaceName+".")
+ proxy := config.GetProxy()
+ assert.Nil(t, proxy)
+
+ values := config.getURLMap()
+ assert.Equal(t, values.Get(constant.GroupKey), "")
+
+ invoker := config.GetInvoker()
+ assert.Nil(t, invoker)
+}
diff --git a/config/registry_config.go b/config/registry_config.go
index 2c113b2..a879718 100644
--- a/config/registry_config.go
+++ b/config/registry_config.go
@@ -381,7 +381,7 @@ func (rcb *RegistryConfigBuilder) SetParams(params map[string]string) *RegistryC
return rcb
}
-func (rcb *RegistryConfigBuilder) addParam(key, value string) *RegistryConfigBuilder {
+func (rcb *RegistryConfigBuilder) AddParam(key, value string) *RegistryConfigBuilder {
if rcb.registryConfig.Params == nil {
rcb.registryConfig.Params = make(map[string]string)
}
diff --git a/config/registry_config_test.go b/config/registry_config_test.go
index 6dbcad2..9c0be8c 100644
--- a/config/registry_config_test.go
+++ b/config/registry_config_test.go
@@ -27,6 +27,7 @@ import (
import (
"dubbo.apache.org/dubbo-go/v3/common"
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
)
func TestLoadRegistries(t *testing.T) {
@@ -74,3 +75,59 @@ func TestTranslateRegistryAddress(t *testing.T) {
assert.Equal(t, "nacos", reg.Protocol)
assert.Equal(t, "127.0.0.1:8848", reg.Address)
}
+
+func TestNewRegistryConfigBuilder(t *testing.T) {
+
+ config := NewRegistryConfigBuilder().
+ SetProtocol("nacos").
+ SetTimeout("10s").
+ SetGroup("group").
+ SetNamespace("public").
+ SetTTL("10s").
+ SetAddress("127.0.0.1:8848").
+ SetUsername("nacos").
+ SetPassword("123456").
+ SetSimplified(true).
+ SetPreferred(true).
+ SetZone("zone").
+ SetWeight(100).
+ SetParams(map[string]string{"timeout": "3s"}).
+ AddParam("timeout", "15s").
+ SetRegistryType("local").
+ Build()
+
+ config.DynamicUpdateProperties(config)
+
+ assert.Equal(t, config.Prefix(), constant.RegistryConfigPrefix)
+
+ values := config.getUrlMap(common.PROVIDER)
+ assert.Equal(t, values.Get("timeout"), "15s")
+
+ url, err := config.toMetadataReportUrl()
+ assert.NoError(t, err)
+ assert.Equal(t, url.GetParam("timeout", "3s"), "10s")
+
+ url, err = config.toURL(common.PROVIDER)
+ assert.NoError(t, err)
+ assert.Equal(t, url.GetParam("timeout", "3s"), "15s")
+
+ address := config.translateRegistryAddress()
+ assert.Equal(t, address, "127.0.0.1:8848")
+}
+
+func TestNewRegistryConfig(t *testing.T) {
+ config := NewRegistryConfig(
+ WithRegistryProtocol("nacos"),
+ WithRegistryAddress("127.0.0.1:8848"),
+ WithRegistryTimeOut("10s"),
+ WithRegistryGroup("group"),
+ WithRegistryTTL("10s"),
+ WithRegistryUserName("nacos"),
+ WithRegistryPassword("123456"),
+ WithRegistrySimplified(true),
+ WithRegistryPreferred(true),
+ WithRegistryWeight(100),
+ WithRegistryParams(map[string]string{"timeout": "3s"}))
+
+ assert.Equal(t, config.Timeout, "10s")
+}
diff --git a/config/remote_config.go b/config/remote_config.go
index feea7b8..7af5c10 100644
--- a/config/remote_config.go
+++ b/config/remote_config.go
@@ -49,7 +49,6 @@ func (rc *RemoteConfig) Prefix() string {
return constant.RemotePrefix
}
-// nolint
func (rc *RemoteConfig) Init() error {
return nil
}
diff --git a/config/remote_config_test.go b/config/remote_config_test.go
index cd21369..36cb5b3 100644
--- a/config/remote_config_test.go
+++ b/config/remote_config_test.go
@@ -19,12 +19,17 @@ package config
import (
"testing"
+ "time"
)
import (
"github.com/stretchr/testify/assert"
)
+import (
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
+)
+
func TestRemoteConfig_GetParam(t *testing.T) {
rc := &RemoteConfig{
Params: make(map[string]string, 1),
@@ -41,3 +46,32 @@ func TestRemoteConfig_GetParam(t *testing.T) {
value = rc.GetParam(key, def)
assert.Equal(t, actualVal, value)
}
+
+func TestNewRemoteConfigBuilder(t *testing.T) {
+ config := NewRemoteConfigBuilder().
+ SetProtocol("nacos").
+ SetAddress("127.0.0.1:8848").
+ SetTimeout("10s").
+ SetUsername("nacos").
+ SetPassword("nacos").
+ SetParams(map[string]string{"timeout": "3s"}).
+ AddParam("timeout", "15s").
+ Build()
+
+ values := config.getUrlMap()
+ assert.Equal(t, values.Get("timeout"), "15s")
+
+ url, err := config.ToURL()
+ assert.NoError(t, err)
+ assert.Equal(t, url.GetParam("timeout", "3s"), "15s")
+
+ err = config.Init()
+ assert.NoError(t, err)
+
+ timeout := config.GetTimeout()
+ assert.Equal(t, timeout, 10*time.Second)
+ assert.Equal(t, config.Prefix(), constant.RemotePrefix)
+
+ param := config.GetParam("timeout", "3s")
+ assert.Equal(t, param, "15s")
+}
diff --git a/config/root_config_test.go b/config/root_config_test.go
index 1b309d1..887991c 100644
--- a/config/root_config_test.go
+++ b/config/root_config_test.go
@@ -26,6 +26,7 @@ import (
)
import (
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
"dubbo.apache.org/dubbo-go/v3/common/yaml"
"dubbo.apache.org/dubbo-go/v3/config_center"
)
@@ -49,3 +50,42 @@ func TestGoConfigProcess(t *testing.T) {
assert.Equal(t, rc.rootConfig.Consumer.RequestTimeout, "6s")
}
+
+func TestNewRootConfigBuilder(t *testing.T) {
+ registryConfig := NewRegistryConfigWithProtocolDefaultPort("nacos")
+ protocolConfig := NewProtocolConfigBuilder().
+ SetName("dubbo").
+ SetPort("20000").
+ Build()
+ rootConfig = NewRootConfigBuilder().
+ SetConfigCenter(NewConfigCenterConfigBuilder().Build()).
+ SetMetadataReport(NewMetadataReportConfigBuilder().Build()).
+ AddProtocol("dubbo", protocolConfig).
+ AddRegistry("nacos", registryConfig).
+ SetProtocols(map[string]*ProtocolConfig{"dubbo": protocolConfig}).
+ SetRegistries(map[string]*RegistryConfig{"nacos": registryConfig}).
+ SetProvider(NewProviderConfigBuilder().Build()).
+ SetConsumer(NewConsumerConfigBuilder().Build()).
+ SetMetric(NewMetricConfigBuilder().Build()).
+ SetLogger(NewLoggerConfigBuilder().Build()).
+ SetShutdown(NewShutDownConfigBuilder().Build()).
+ SetShutDown(NewShutDownConfigBuilder().Build()).
+ SetRouter([]*RouterConfig{}).
+ SetEventDispatcherType("direct").
+ SetCacheFile("abc=123").
+ Build()
+
+ assert.Equal(t, rootConfig.Prefix(), constant.Dubbo)
+ ids := rootConfig.getRegistryIds()
+ assert.Equal(t, ids[0], "nacos")
+
+ down := GetShutDown()
+ assert.NotNil(t, down)
+
+ application := GetApplicationConfig()
+ assert.NotNil(t, application)
+
+ registerPOJO()
+ config := GetRootConfig()
+ assert.Equal(t, rootConfig, config)
+}
diff --git a/config/router_config.go b/config/router_config.go
index 0328e53..be7eaff 100644
--- a/config/router_config.go
+++ b/config/router_config.go
@@ -97,60 +97,50 @@ type RouterConfigBuilder struct {
routerConfig *RouterConfig
}
-// nolint
func NewRouterConfigBuilder() *RouterConfigBuilder {
return &RouterConfigBuilder{routerConfig: &RouterConfig{}}
}
-// nolint
func (rcb *RouterConfigBuilder) SetScope(scope string) *RouterConfigBuilder {
rcb.routerConfig.Scope = scope
return rcb
}
-// nolint
func (rcb *RouterConfigBuilder) SetKey(key string) *RouterConfigBuilder {
rcb.routerConfig.Key = key
return rcb
}
-// nolint
func (rcb *RouterConfigBuilder) SetForce(force bool) *RouterConfigBuilder {
rcb.routerConfig.Force = force
return rcb
}
-// nolint
func (rcb *RouterConfigBuilder) SetRuntime(runtime bool) *RouterConfigBuilder {
rcb.routerConfig.Runtime = runtime
return rcb
}
-// nolint
func (rcb *RouterConfigBuilder) SetEnable(enable bool) *RouterConfigBuilder {
rcb.routerConfig.Enable = enable
return rcb
}
-// nolint
func (rcb *RouterConfigBuilder) SetValid(valid bool) *RouterConfigBuilder {
rcb.routerConfig.Valid = valid
return rcb
}
-// nolint
func (rcb *RouterConfigBuilder) SetPriority(priority int) *RouterConfigBuilder {
rcb.routerConfig.Priority = priority
return rcb
}
-// nolint
func (rcb *RouterConfigBuilder) SetConditions(conditions []string) *RouterConfigBuilder {
rcb.routerConfig.Conditions = conditions
return rcb
}
-// nolint
func (rcb *RouterConfigBuilder) AddCondition(condition string) *RouterConfigBuilder {
if rcb.routerConfig.Conditions == nil {
rcb.routerConfig.Conditions = make([]string, 0)
@@ -159,13 +149,11 @@ func (rcb *RouterConfigBuilder) AddCondition(condition string) *RouterConfigBuil
return rcb
}
-// nolint
func (rcb *RouterConfigBuilder) SetTags(tags []Tag) *RouterConfigBuilder {
rcb.routerConfig.Tags = tags
return rcb
}
-// nolint
func (rcb *RouterConfigBuilder) AddTag(tag Tag) *RouterConfigBuilder {
if rcb.routerConfig.Tags == nil {
rcb.routerConfig.Tags = make([]Tag, 0)
@@ -174,7 +162,6 @@ func (rcb *RouterConfigBuilder) AddTag(tag Tag) *RouterConfigBuilder {
return rcb
}
-// nolint
func (rcb *RouterConfigBuilder) Build() *RouterConfig {
if err := rcb.routerConfig.Init(); err != nil {
panic(err)
diff --git a/config/router_config_test.go b/config/router_config_test.go
index bc43654..247749a 100644
--- a/config/router_config_test.go
+++ b/config/router_config_test.go
@@ -26,6 +26,10 @@ import (
"github.com/stretchr/testify/assert"
)
+import (
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
+)
+
const (
testDestinationRuleYML = "testdata/router_config_dest_rule.yml"
errorTestDestinationRuleYML = "testdata/router_config_destination_rule_error.yml"
@@ -58,3 +62,31 @@ func TestRouterInit(t *testing.T) {
//err = RouterInit(testVirtualServiceYML, errorTestDestinationRuleYML)
//assert.Error(t, err)
}
+
+func TestNewRouterConfigBuilder(t *testing.T) {
+ tag := Tag{
+ Name: "tag",
+ Addresses: []string{"127.0.0.1"},
+ }
+ rc := newEmptyRootConfig()
+ config := NewRouterConfigBuilder().
+ SetScope("scope").
+ SetKey("key").
+ SetForce(true).
+ SetRuntime(true).
+ SetEnable(true).
+ SetValid(true).
+ SetPriority(10).
+ SetConditions([]string{"condition"}).
+ AddCondition("condition").
+ SetTags([]Tag{tag}).
+ AddTag(tag).
+ Build()
+
+ err := initRouterConfig(rc)
+ assert.NoError(t, err)
+ err = config.Init()
+ assert.NoError(t, err)
+
+ assert.Equal(t, config.Prefix(), constant.RouterConfigPrefix)
+}
diff --git a/config/service_config.go b/config/service_config.go
index a550812..516736f 100644
--- a/config/service_config.go
+++ b/config/service_config.go
@@ -109,8 +109,12 @@ func (s *ServiceConfig) Init(rc *RootConfig) error {
s.exported = atomic.NewBool(false)
s.metadataType = rc.Application.MetadataType
s.unexported = atomic.NewBool(false)
- s.RCRegistriesMap = rc.Registries
- s.RCProtocolsMap = rc.Protocols
+ if len(s.RCRegistriesMap) == 0 {
+ s.RCRegistriesMap = rc.Registries
+ }
+ if len(s.RCProtocolsMap) == 0 {
+ s.RCProtocolsMap = rc.Protocols
+ }
if rc.Provider != nil {
s.ProxyFactoryKey = rc.Provider.ProxyFactory
}
diff --git a/config/service_config_test.go b/config/service_config_test.go
new file mode 100644
index 0000000..c3fa09d
--- /dev/null
+++ b/config/service_config_test.go
@@ -0,0 +1,126 @@
+/*
+ * 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 config
+
+import (
+ "context"
+ "strings"
+ "testing"
+)
+
+import (
+ "github.com/stretchr/testify/assert"
+)
+
+import (
+ "dubbo.apache.org/dubbo-go/v3/common"
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
+ _ "dubbo.apache.org/dubbo-go/v3/common/proxy/proxy_factory"
+)
+
+type HelloService struct {
+}
+
+func (hs *HelloService) Say(ctx context.Context, name string) (string, error) {
+ return name, nil
+}
+func (hs *HelloService) Reference() string {
+ return "HelloService"
+}
+
+func (hs *HelloService) JavaClassName() string {
+ return "org.apache.dubbo.HelloService"
+}
+
+func TestNewServiceConfigBuilder(t *testing.T) {
+ SetProviderService(&HelloService{})
+ var serviceConfig = newEmptyServiceConfig()
+ t.Run("NewServiceConfigBuilder", func(t *testing.T) {
+ registryConfig := NewRegistryConfigWithProtocolDefaultPort("nacos")
+ protocolConfig := NewProtocolConfigBuilder().
+ SetName("dubbo").
+ SetPort("20000").
+ Build()
+ rc := newEmptyRootConfig()
+
+ serviceConfig = NewServiceConfigBuilder().
+ SetRegistryIDs("nacos").
+ SetProtocolIDs("dubbo").
+ SetInterface("org.apache.dubbo.HelloService").
+ SetMetadataType("local").
+ SetLoadBalancce("random").
+ SetWarmUpTie("warmup").
+ SetCluster("cluster").
+ AddRCRegistry("nacos", registryConfig).
+ AddRCProtocol("dubbo", protocolConfig).
+ SetGroup("dubbo").
+ SetVersion("1.0.0").
+ SetProxyFactoryKey("default").
+ SetSerialization("serialization").
+ SetServiceID("HelloService").
+ Build()
+
+ serviceConfig.InitExported()
+
+ serviceConfig.Methods = []*MethodConfig{
+ {
+ Name: "Say",
+ Retries: "3",
+ },
+ }
+
+ err := serviceConfig.Init(rc)
+ assert.NoError(t, err)
+ err = serviceConfig.check()
+ assert.NoError(t, err)
+
+ assert.Equal(t, serviceConfig.Prefix(), strings.Join([]string{constant.ServiceConfigPrefix, serviceConfig.id}, "."))
+ assert.Equal(t, serviceConfig.IsExport(), false)
+ })
+
+ t.Run("loadRegistries&loadProtocol&getRandomPort", func(t *testing.T) {
+ registries := loadRegistries(serviceConfig.RegistryIDs, serviceConfig.RCRegistriesMap, common.PROVIDER)
+ assert.Equal(t, len(registries), 1)
+ assert.Equal(t, registries[0].Protocol, "registry")
+ assert.Equal(t, registries[0].Port, "8848")
+ assert.Equal(t, registries[0].GetParam("registry.role", "1"), "3")
+ assert.Equal(t, registries[0].GetParam("registry", "zk"), "nacos")
+
+ protocols := loadProtocol(serviceConfig.ProtocolIDs, serviceConfig.RCProtocolsMap)
+ assert.Equal(t, len(protocols), 1)
+ assert.Equal(t, protocols[0].Name, "dubbo")
+ assert.Equal(t, protocols[0].Port, "20000")
+
+ ports := getRandomPort(protocols)
+ nextPort := ports.Front()
+ assert.Nil(t, nextPort)
+ })
+ t.Run("getUrlMap", func(t *testing.T) {
+ values := serviceConfig.getUrlMap()
+ assert.Equal(t, values.Get("methods.Say.weight"), "0")
+ assert.Equal(t, values.Get("methods.Say.tps.limit.rate"), "")
+ assert.Equal(t, values.Get(constant.ServiceFilterKey), "echo,metrics,token,accesslog,tps,generic_service,execute,pshutdown")
+ })
+
+ t.Run("Implement", func(t *testing.T) {
+ serviceConfig.Implement(&HelloService{})
+ //urls := serviceConfig.GetExportedUrls()
+ //err := serviceConfig.Export()
+ assert.NotNil(t, serviceConfig.rpcService)
+ })
+}
diff --git a/config/config_center_config_test.go b/config/service_discovery_config_test.go
similarity index 71%
copy from config/config_center_config_test.go
copy to config/service_discovery_config_test.go
index e77e593..b26c538 100644
--- a/config/config_center_config_test.go
+++ b/config/service_discovery_config_test.go
@@ -26,14 +26,19 @@ import (
)
import (
- _ "dubbo.apache.org/dubbo-go/v3/config_center/apollo"
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
)
-func TestApolloConfigCenterConfig(t *testing.T) {
+func TestNewServiceDiscoveryConfigBuilder(t *testing.T) {
- err := Load(WithPath("./testdata/config/center/apollo.yaml"))
- assert.Nil(t, err)
+ config := NewServiceDiscoveryConfigBuilder().
+ SetProtocol("protocol").
+ SetGroup("group").
+ SetRemoteRef("remote").
+ Build()
- registries := rootConfig.Registries
- assert.NotNil(t, registries)
+ err := config.Init()
+ assert.Nil(t, err)
+ assert.Equal(t, config.Protocol, "protocol")
+ assert.Equal(t, config.Prefix(), constant.ServiceDiscPrefix)
}
diff --git a/config/graceful_shutdown_config_test.go b/config/service_test.go
similarity index 60%
copy from config/graceful_shutdown_config_test.go
copy to config/service_test.go
index a612200..e52ec04 100644
--- a/config/graceful_shutdown_config_test.go
+++ b/config/service_test.go
@@ -19,30 +19,27 @@ package config
import (
"testing"
- "time"
)
import (
"github.com/stretchr/testify/assert"
)
-func TestShutdownConfigGetTimeout(t *testing.T) {
- config := ShutdownConfig{}
- assert.False(t, config.RejectRequest.Load())
+func TestGetConsumerService(t *testing.T) {
- config = ShutdownConfig{
- Timeout: "60s",
- StepTimeout: "10s",
- }
+ SetConsumerService(&HelloService{})
+ SetProviderService(&HelloService{})
- assert.Equal(t, 60*time.Second, config.GetTimeout())
- assert.Equal(t, 10*time.Second, config.GetStepTimeout())
+ service := GetConsumerService("HelloService")
+ reference := service.(*HelloService).Reference()
- config = ShutdownConfig{
- Timeout: "34ms",
- StepTimeout: "79ms",
- }
+ assert.Equal(t, reference, "HelloService")
- assert.Equal(t, 34*time.Millisecond, config.GetTimeout())
- assert.Equal(t, 79*time.Millisecond, config.GetStepTimeout())
+ SetConsumerServiceByInterfaceName("org.apache.dubbo.HelloService", &HelloService{})
+ service = GetConsumerServiceByInterfaceName("org.apache.dubbo.HelloService")
+ reference = service.(*HelloService).Reference()
+ assert.Equal(t, reference, "HelloService")
+
+ callback := GetCallback(reference)
+ assert.Nil(t, callback)
}
diff --git a/config/config_center_config_test.go b/config/tracing_config_test.go
similarity index 76%
copy from config/config_center_config_test.go
copy to config/tracing_config_test.go
index e77e593..d21f3d1 100644
--- a/config/config_center_config_test.go
+++ b/config/tracing_config_test.go
@@ -26,14 +26,15 @@ import (
)
import (
- _ "dubbo.apache.org/dubbo-go/v3/config_center/apollo"
+ "dubbo.apache.org/dubbo-go/v3/common/constant"
)
-func TestApolloConfigCenterConfig(t *testing.T) {
+func TestTracingConfig(t *testing.T) {
- err := Load(WithPath("./testdata/config/center/apollo.yaml"))
+ tracing := &TracingConfig{}
+ err := tracing.Init()
assert.Nil(t, err)
-
- registries := rootConfig.Registries
- assert.NotNil(t, registries)
+ assert.Equal(t, tracing.Prefix(), constant.TracingConfigPrefix)
+ assert.Equal(t, tracing.Name, "jaeger")
+ assert.Equal(t, tracing.UseAgent, false)
}