test(core): add coverage for lock and map-copy race fixes

Fixes: #3247

Author: xxs588

cluster/router/chain/chain_test.go

@@ -0,0 +1,93 @@
+/*
+ * 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 chain
+
+import (
+	"sync"
+	"testing"
+)
+
+import (
+	"github.com/stretchr/testify/assert"
+)
+
+import (
+	clusterpkg "dubbo.apache.org/dubbo-go/v3/cluster/cluster"
+	"dubbo.apache.org/dubbo-go/v3/common"
+	"dubbo.apache.org/dubbo-go/v3/protocol/base"
+)
+
+func TestRouteFiltersByServiceKey(t *testing.T) {
+	chain := &RouterChain{}
+
+	invokerA := newMockInvoker("com.test.ServiceA")
+	invokerB := newMockInvoker("com.test.ServiceB")
+	chain.SetInvokers([]base.Invoker{invokerA, invokerB})
+
+	urlA := common.NewURLWithOptions(common.WithInterface("com.test.ServiceA"))
+	result := chain.Route(urlA, nil)
+
+	assert.Len(t, result, 1)
+	assert.Equal(t, invokerA.GetURL().ServiceKey(), result[0].GetURL().ServiceKey())
+}
+
+func TestRouteFallsBackToAllInvokersWhenNoMatch(t *testing.T) {
+	chain := &RouterChain{}
+
+	invokerA := newMockInvoker("com.test.ServiceA")
+	invokerB := newMockInvoker("com.test.ServiceB")
+	chain.SetInvokers([]base.Invoker{invokerA, invokerB})
+
+	urlC := common.NewURLWithOptions(common.WithInterface("com.test.ServiceC"))
+	result := chain.Route(urlC, nil)
+
+	assert.Len(t, result, 2)
+}
+
+func TestRouteConcurrentReadWrite(t *testing.T) {
+	chain := &RouterChain{}
+	chain.SetInvokers([]base.Invoker{newMockInvoker("com.test.ServiceA")})
+
+	urlA := common.NewURLWithOptions(common.WithInterface("com.test.ServiceA"))
+
+	var wg sync.WaitGroup
+	for i := 0; i < 20; i++ {
+		wg.Add(1)
+		go func(idx int) {
+			defer wg.Done()
+			for j := 0; j < 100; j++ {
+				if j%2 == 0 {
+					chain.SetInvokers([]base.Invoker{newMockInvoker("com.test.ServiceA"), newMockInvoker("com.test.ServiceB")})
+				} else {
+					_ = chain.Route(urlA, nil)
+				}
+			}
+		}(i)
+	}
+	wg.Wait()
+}
+
+func newMockInvoker(interfaceName string) base.Invoker {
+	url := common.NewURLWithOptions(
+		common.WithProtocol("tri"),
+		common.WithIp("127.0.0.1"),
+		common.WithPort("20000"),
+		common.WithInterface(interfaceName),
+	)
+	return clusterpkg.NewMockInvoker(url, 1)
+}

config/service_map_copy_test.go

@@ -0,0 +1,64 @@
+/*
+ * 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 (
+	"testing"
+)
+
+import (
+	"github.com/stretchr/testify/assert"
+)
+
+type providerServiceForMapCopy struct{}
+
+func (p *providerServiceForMapCopy) Reference() string {
+	return "providerServiceForMapCopy"
+}
+
+type consumerServiceForMapCopy struct{}
+
+func (c *consumerServiceForMapCopy) Reference() string {
+	return "consumerServiceForMapCopy"
+}
+
+func TestGetProviderServiceMapReturnsCopy(t *testing.T) {
+	service := &providerServiceForMapCopy{}
+	SetProviderService(service)
+
+	original := GetProviderServiceMap()
+	assert.Contains(t, original, service.Reference())
+
+	delete(original, service.Reference())
+
+	again := GetProviderServiceMap()
+	assert.Contains(t, again, service.Reference())
+}
+
+func TestGetConsumerServiceMapReturnsCopy(t *testing.T) {
+	service := &consumerServiceForMapCopy{}
+	SetConsumerService(service)
+
+	original := GetConsumerServiceMap()
+	assert.Contains(t, original, service.Reference())
+
+	delete(original, service.Reference())
+
+	again := GetConsumerServiceMap()
+	assert.Contains(t, again, service.Reference())
+}

dubbo_test.go

@@ -27,11 +27,24 @@ import (
 
 import (
 	"dubbo.apache.org/dubbo-go/v3/client"
+	"dubbo.apache.org/dubbo-go/v3/common"
 	"dubbo.apache.org/dubbo-go/v3/common/constant"
 	"dubbo.apache.org/dubbo-go/v3/registry"
 	"dubbo.apache.org/dubbo-go/v3/server"
 )
 
+type providerServiceForLockTest struct{}
+
+func (p *providerServiceForLockTest) Reference() string {
+	return "providerServiceForLockTest"
+}
+
+type consumerServiceForLockTest struct{}
+
+func (c *consumerServiceForLockTest) Reference() string {
+	return "consumerServiceForLockTest"
+}
+
 // TestIndependentConfig tests the configurations of the `instance`, `client`, and `server` are independent.
 func TestIndependentConfig(t *testing.T) {
 	// instance configuration
@@ -96,3 +109,52 @@ func TestIndependentConfig(t *testing.T) {
 		panic(err)
 	}
 }
+
+func TestSetProviderServiceStoresDefinition(t *testing.T) {
+	proLock.Lock()
+	original := providerServices
+	providerServices = make(map[string]*server.ServiceDefinition, len(original))
+	for k, v := range original {
+		providerServices[k] = v
+	}
+	proLock.Unlock()
+
+	t.Cleanup(func() {
+		proLock.Lock()
+		providerServices = original
+		proLock.Unlock()
+	})
+
+	svc := &providerServiceForLockTest{}
+	SetProviderService(svc)
+
+	proLock.RLock()
+	defer proLock.RUnlock()
+	def, ok := providerServices[common.GetReference(svc)]
+	assert.True(t, ok)
+	assert.Same(t, svc, def.Handler)
+}
+
+func TestGetConsumerConnectionUnderReadLock(t *testing.T) {
+	conLock.Lock()
+	original := consumerServices
+	consumerServices = make(map[string]*client.ClientDefinition, len(original))
+	for k, v := range original {
+		consumerServices[k] = v
+	}
+	conLock.Unlock()
+
+	t.Cleanup(func() {
+		conLock.Lock()
+		consumerServices = original
+		conLock.Unlock()
+	})
+
+	svc := &consumerServiceForLockTest{}
+	key := common.GetReference(svc)
+	consumerServices[key] = &client.ClientDefinition{Svc: svc}
+
+	conn, err := GetConsumerConnection(key)
+	assert.Nil(t, conn)
+	assert.Error(t, err)
+}