add unit tests and modify event struct

registry/common/event_publishing_service_deiscovery_test.go

+/*
+ * 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 common
+
+import (
+	"reflect"
+	"testing"
+)
+
+import (
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/suite"
+)
+
+import (
+	"github.com/apache/dubbo-go/common/extension"
+	"github.com/apache/dubbo-go/common/observer"
+	dispatcher2 "github.com/apache/dubbo-go/common/observer/dispatcher"
+	"github.com/apache/dubbo-go/registry"
+	gxset "github.com/dubbogo/gost/container/set"
+	gxpage "github.com/dubbogo/gost/page"
+)
+
+func TestEventPublishingServiceDiscovery_DispatchEvent(t *testing.T) {
+	dc := NewEventPublishingServiceDiscovery(&ServiceDiscoveryA{})
+	tsd := &TestServiceDiscoveryDestroyingEventListener{}
+	tsd.SetT(t)
+	tsi := &TestServiceInstancePreRegisteredEventListener{}
+	tsi.SetT(t)
+	extension.AddEventListener(tsd)
+	extension.AddEventListener(tsi)
+	extension.SetEventDispatcher("direct", dispatcher2.NewDirectEventDispatcher)
+	extension.SetAndInitGlobalDispatcher("direct")
+	err := dc.Destroy()
+	assert.Nil(t, err)
+	si := &registry.DefaultServiceInstance{Id: "testServiceInstance"}
+	err = dc.Register(si)
+	assert.Nil(t, err)
+
+}
+
+type TestServiceDiscoveryDestroyingEventListener struct {
+	suite.Suite
+	observer.BaseListenable
+}
+
+func (tel *TestServiceDiscoveryDestroyingEventListener) OnEvent(e observer.Event) error {
+	e1, ok := e.(*ServiceDiscoveryDestroyingEvent)
+	assert.Equal(tel.T(), ok, true)
+	assert.Equal(tel.T(), "testServiceDiscovery", e1.GetOriginal().String())
+	assert.Equal(tel.T(), "testServiceDiscovery", e1.GetServiceDiscovery().String())
+	return nil
+}
+
+func (tel *TestServiceDiscoveryDestroyingEventListener) GetPriority() int {
+	return -1
+}
+
+func (tel *TestServiceDiscoveryDestroyingEventListener) GetEventType() reflect.Type {
+	return reflect.TypeOf(ServiceDiscoveryDestroyingEvent{})
+}
+
+type TestServiceInstancePreRegisteredEventListener struct {
+	suite.Suite
+	observer.BaseListenable
+}
+
+func (tel *TestServiceInstancePreRegisteredEventListener) OnEvent(e observer.Event) error {
+	e1, ok := e.(*ServiceInstancePreRegisteredEvent)
+	assert.Equal(tel.T(), ok, true)
+	assert.Equal(tel.T(), "testServiceInstance", e1.getServiceInstance().GetId())
+	return nil
+}
+
+func (tel *TestServiceInstancePreRegisteredEventListener) GetPriority() int {
+	return -1
+}
+
+func (tel *TestServiceInstancePreRegisteredEventListener) GetEventType() reflect.Type {
+	return reflect.TypeOf(ServiceInstancePreRegisteredEvent{})
+}
+
+type ServiceDiscoveryA struct {
+}
+
+// String return mockServiceDiscovery
+func (msd *ServiceDiscoveryA) String() string {
+	return "testServiceDiscovery"
+}
+
+// Destroy do nothing
+func (msd *ServiceDiscoveryA) Destroy() error {
+	return nil
+}
+
+func (msd *ServiceDiscoveryA) Register(instance registry.ServiceInstance) error {
+	return nil
+}
+
+func (msd *ServiceDiscoveryA) Update(instance registry.ServiceInstance) error {
+	return nil
+}
+
+func (msd *ServiceDiscoveryA) Unregister(instance registry.ServiceInstance) error {
+	return nil
+}
+
+func (msd *ServiceDiscoveryA) GetDefaultPageSize() int {
+	return 1
+}
+
+func (msd *ServiceDiscoveryA) GetServices() *gxset.HashSet {
+	return nil
+}
+
+func (msd *ServiceDiscoveryA) GetInstances(serviceName string) []registry.ServiceInstance {
+	return nil
+}
+
+func (msd *ServiceDiscoveryA) GetInstancesByPage(serviceName string, offset int, pageSize int) gxpage.Pager {
+	return nil
+}
+
+func (msd *ServiceDiscoveryA) GetHealthyInstancesByPage(serviceName string, offset int, pageSize int, healthy bool) gxpage.Pager {
+	return nil
+}
+
+func (msd *ServiceDiscoveryA) GetRequestInstances(serviceNames []string, offset int, requestedSize int) map[string]gxpage.Pager {
+	return nil
+}
+
+func (msd *ServiceDiscoveryA) AddListener(listener *registry.ServiceInstancesChangedListener) error {
+	return nil
+}
+
+func (msd *ServiceDiscoveryA) DispatchEventByServiceName(serviceName string) error {
+	return nil
+}
+
+func (msd *ServiceDiscoveryA) DispatchEventForInstances(serviceName string, instances []registry.ServiceInstance) error {
+	return nil
+}
+
+func (msd *ServiceDiscoveryA) DispatchEvent(event *registry.ServiceInstancesChangedEvent) error {
+	return nil
+}

registry/common/event_publishing_service_discovery.go

@@ -17,6 +17,10 @@
 
 package common
 
+import (
+	"github.com/apache/dubbo-go/registry"
+)
+
 import (
 	"github.com/apache/dubbo-go/common/extension"
 	"github.com/apache/dubbo-go/common/observer"
@@ -24,12 +28,6 @@ import (
 	gxpage "github.com/dubbogo/gost/page"
 )
 
-import (
-	"github.com/apache/dubbo-go/registry"
-)
-
-var dispatcher = extension.GetGlobalDispatcher()
-
 // EventPublishingServiceDiscovery will enhance Service Discovery
 // Publish some event about service discovery
 type EventPublishingServiceDiscovery struct {
@@ -43,10 +41,12 @@ func NewEventPublishingServiceDiscovery(serviceDiscovery registry.ServiceDiscove
 	}
 }
 
+// String
 func (epsd *EventPublishingServiceDiscovery) String() string {
 	return epsd.serviceDiscovery.String()
 }
 
+// Destroy delegate function
 func (epsd *EventPublishingServiceDiscovery) Destroy() error {
 	f := func() error {
 		return epsd.serviceDiscovery.Destroy()
@@ -55,6 +55,7 @@ func (epsd *EventPublishingServiceDiscovery) Destroy() error {
 		f, NewServiceDiscoveryDestroyedEvent(epsd, epsd.serviceDiscovery))
 }
 
+// Register delegate function
 func (epsd *EventPublishingServiceDiscovery) Register(instance registry.ServiceInstance) error {
 	f := func() error {
 		return epsd.serviceDiscovery.Register(instance)
@@ -64,6 +65,7 @@ func (epsd *EventPublishingServiceDiscovery) Register(instance registry.ServiceI
 
 }
 
+// Update delegate function
 func (epsd *EventPublishingServiceDiscovery) Update(instance registry.ServiceInstance) error {
 	f := func() error {
 		return epsd.serviceDiscovery.Update(instance)
@@ -71,9 +73,10 @@ func (epsd *EventPublishingServiceDiscovery) Update(instance registry.ServiceIns
 	return epsd.executeWithEvents(nil, f, nil)
 }
 
+// Unregister delegate function
 func (epsd *EventPublishingServiceDiscovery) Unregister(instance registry.ServiceInstance) error {
 	f := func() error {
-		return epsd.serviceDiscovery.Register(instance)
+		return epsd.serviceDiscovery.Unregister(instance)
 	}
 	return epsd.executeWithEvents(NewServiceInstancePreUnregisteredEvent(epsd.serviceDiscovery, instance),
 		f, NewServiceInstanceUnregisteredEvent(epsd.serviceDiscovery, instance))
@@ -103,8 +106,9 @@ func (epsd *EventPublishingServiceDiscovery) GetRequestInstances(serviceNames []
 	return epsd.serviceDiscovery.GetRequestInstances(serviceNames, offset, requestedSize)
 }
 
+// AddListener add event listener
 func (epsd *EventPublishingServiceDiscovery) AddListener(listener *registry.ServiceInstancesChangedListener) error {
-	dispatcher.AddEventListener(listener)
+	extension.GetGlobalDispatcher().AddEventListener(listener)
 	return epsd.serviceDiscovery.AddListener(listener)
 }
 
@@ -120,16 +124,18 @@ func (epsd *EventPublishingServiceDiscovery) DispatchEvent(event *registry.Servi
 	return epsd.serviceDiscovery.DispatchEvent(event)
 }
 
+// executeWithEvents dispatch before event and after event if return error will dispatch exception event
 func (epsd *EventPublishingServiceDiscovery) executeWithEvents(beforeEvent observer.Event, f func() error, afterEvent observer.Event) error {
+	globalDispatcher := extension.GetGlobalDispatcher()
 	if beforeEvent != nil {
-		dispatcher.Dispatch(beforeEvent)
+		globalDispatcher.Dispatch(beforeEvent)
 	}
 	if err := f(); err != nil {
-		dispatcher.Dispatch(NewServiceDiscoveryExceptionEvent(epsd, epsd.serviceDiscovery, err))
+		globalDispatcher.Dispatch(NewServiceDiscoveryExceptionEvent(epsd, epsd.serviceDiscovery, err))
 		return err
 	}
 	if afterEvent != nil {
-		dispatcher.Dispatch(afterEvent)
+		globalDispatcher.Dispatch(afterEvent)
 	}
 	return nil
 }

registry/common/service_discovery_event.go

@@ -25,24 +25,15 @@ import (
 type ServiceDiscoveryEvent struct {
 	observer.BaseEvent
 	original registry.ServiceDiscovery
-	err      error
 }
 
-func NewServiceDiscoveryEventWithoutError(discovery registry.ServiceDiscovery, original registry.ServiceDiscovery) *ServiceDiscoveryEvent {
+func NewServiceDiscoveryEvent(discovery registry.ServiceDiscovery, original registry.ServiceDiscovery) *ServiceDiscoveryEvent {
 	return &ServiceDiscoveryEvent{
 		BaseEvent: *observer.NewBaseEvent(discovery),
 		original:  original,
 	}
 }
 
-func NewServiceDiscoveryEvent(discovery registry.ServiceDiscovery, original registry.ServiceDiscovery, err error) *ServiceDiscoveryEvent {
-	return &ServiceDiscoveryEvent{
-		BaseEvent: *observer.NewBaseEvent(discovery),
-		original:  original,
-		err:       err,
-	}
-}
-
 func (sde *ServiceDiscoveryEvent) GetServiceDiscovery() registry.ServiceDiscovery {
 	return sde.GetSource().(registry.ServiceDiscovery)
 }
@@ -51,37 +42,58 @@ func (sde *ServiceDiscoveryEvent) GetOriginal() registry.ServiceDiscovery {
 	return sde.original
 }
 
-type ServiceDiscoveryDestroyingEvent ServiceDiscoveryEvent
+// ServiceDiscoveryDestroyingEvent
+// this event will be dispatched before service discovery be destroyed
+type ServiceDiscoveryDestroyingEvent struct {
+	ServiceDiscoveryEvent
+}
 
-type ServiceDiscoveryExceptionEvent ServiceDiscoveryEvent
+// ServiceDiscoveryExceptionEvent
+// this event will be dispatched when the error occur in service discovery
+type ServiceDiscoveryExceptionEvent struct {
+	ServiceDiscoveryEvent
+	err error
+}
 
-type ServiceDiscoveryInitializedEvent ServiceDiscoveryEvent
+// ServiceDiscoveryInitializedEvent
+// this event will be dispatched after service discovery initialize
+type ServiceDiscoveryInitializedEvent struct {
+	ServiceDiscoveryEvent
+}
 
-type ServiceDiscoveryInitializingEvent ServiceDiscoveryEvent
+// ServiceDiscoveryInitializingEvent
+// this event will be dispatched before service discovery initialize
+type ServiceDiscoveryInitializingEvent struct {
+	ServiceDiscoveryEvent
+}
 
-type ServiceDiscoveryDestroyedEvent ServiceDiscoveryEvent
+// ServiceDiscoveryDestroyedEvent
+// this event will be dispatched after service discovery be destroyed
+type ServiceDiscoveryDestroyedEvent struct {
+	ServiceDiscoveryEvent
+}
 
 // NewServiceDiscoveryDestroyingEvent create a ServiceDiscoveryDestroyingEvent
 func NewServiceDiscoveryDestroyingEvent(discovery registry.ServiceDiscovery, original registry.ServiceDiscovery) *ServiceDiscoveryDestroyingEvent {
-	return (*ServiceDiscoveryDestroyingEvent)(NewServiceDiscoveryEventWithoutError(discovery, original))
+	return &ServiceDiscoveryDestroyingEvent{*NewServiceDiscoveryEvent(discovery, original)}
 }
 
 // NewServiceDiscoveryExceptionEvent create a ServiceDiscoveryExceptionEvent
 func NewServiceDiscoveryExceptionEvent(discovery registry.ServiceDiscovery, original registry.ServiceDiscovery, err error) *ServiceDiscoveryExceptionEvent {
-	return (*ServiceDiscoveryExceptionEvent)(NewServiceDiscoveryEvent(discovery, original, err))
+	return &ServiceDiscoveryExceptionEvent{*NewServiceDiscoveryEvent(discovery, original), err}
 }
 
 // NewServiceDiscoveryInitializedEvent create a ServiceDiscoveryInitializedEvent
 func NewServiceDiscoveryInitializedEvent(discovery registry.ServiceDiscovery, original registry.ServiceDiscovery) *ServiceDiscoveryInitializedEvent {
-	return (*ServiceDiscoveryInitializedEvent)(NewServiceDiscoveryEventWithoutError(discovery, original))
+	return &ServiceDiscoveryInitializedEvent{*NewServiceDiscoveryEvent(discovery, original)}
 }
 
 // NewServiceDiscoveryInitializingEvent create a ServiceDiscoveryInitializingEvent
 func NewServiceDiscoveryInitializingEvent(discovery registry.ServiceDiscovery, original registry.ServiceDiscovery) *ServiceDiscoveryInitializingEvent {
-	return (*ServiceDiscoveryInitializingEvent)(NewServiceDiscoveryEventWithoutError(discovery, original))
+	return &ServiceDiscoveryInitializingEvent{*NewServiceDiscoveryEvent(discovery, original)}
 }
 
 // NewServiceDiscoveryDestroyedEvent create a ServiceDiscoveryDestroyedEvent
 func NewServiceDiscoveryDestroyedEvent(discovery registry.ServiceDiscovery, original registry.ServiceDiscovery) *ServiceDiscoveryDestroyedEvent {
-	return (*ServiceDiscoveryDestroyedEvent)(NewServiceDiscoveryEventWithoutError(discovery, original))
+	return &ServiceDiscoveryDestroyedEvent{*NewServiceDiscoveryEvent(discovery, original)}
 }

registry/common/service_instance_event.go

@@ -39,30 +39,46 @@ func (sie *ServiceInstanceEvent) getServiceInstance() registry.ServiceInstance {
 	return sie.serviceInstance
 }
 
-type ServiceInstancePreRegisteredEvent ServiceInstanceEvent
+// ServiceInstancePreRegisteredEvent
+// this event will be dispatched before service instance be registered
+type ServiceInstancePreRegisteredEvent struct {
+	ServiceInstanceEvent
+}
 
-type ServiceInstancePreUnregisteredEvent ServiceInstanceEvent
+// ServiceInstancePreUnregisteredEvent
+// this event will be dispatched before service instance be unregistered
+type ServiceInstancePreUnregisteredEvent struct {
+	ServiceInstanceEvent
+}
 
-type ServiceInstanceRegisteredEvent ServiceInstanceEvent
+// ServiceInstanceRegisteredEvent
+// this event will be dispatched after service instance be registered
+type ServiceInstanceRegisteredEvent struct {
+	ServiceInstanceEvent
+}
 
-type ServiceInstanceUnregisteredEvent ServiceInstanceEvent
+// ServiceInstanceRegisteredEvent
+// this event will be dispatched after service instance be unregistered
+type ServiceInstanceUnregisteredEvent struct {
+	ServiceInstanceEvent
+}
 
 // NewServiceInstancePreRegisteredEvent create a ServiceInstancePreRegisteredEvent
 func NewServiceInstancePreRegisteredEvent(source interface{}, instance registry.ServiceInstance) *ServiceInstancePreRegisteredEvent {
-	return (*ServiceInstancePreRegisteredEvent)(NewServiceInstanceEvent(source, instance))
+	return &ServiceInstancePreRegisteredEvent{*NewServiceInstanceEvent(source, instance)}
 }
 
 // NewServiceInstancePreUnregisteredEvent create a ServiceInstancePreUnregisteredEvent
 func NewServiceInstancePreUnregisteredEvent(source interface{}, instance registry.ServiceInstance) *ServiceInstancePreUnregisteredEvent {
-	return (*ServiceInstancePreUnregisteredEvent)(NewServiceInstanceEvent(source, instance))
+	return &ServiceInstancePreUnregisteredEvent{*NewServiceInstanceEvent(source, instance)}
 }
 
 // NewServiceInstanceRegisteredEvent create a ServiceInstanceRegisteredEvent
 func NewServiceInstanceRegisteredEvent(source interface{}, instance registry.ServiceInstance) *ServiceInstanceRegisteredEvent {
-	return (*ServiceInstanceRegisteredEvent)(NewServiceInstanceEvent(source, instance))
+	return &ServiceInstanceRegisteredEvent{*NewServiceInstanceEvent(source, instance)}
 }
 
 // NewServiceInstanceUnregisteredEvent create a ServiceInstanceUnregisteredEvent
 func NewServiceInstanceUnregisteredEvent(source interface{}, instance registry.ServiceInstance) *ServiceInstanceUnregisteredEvent {
-	return (*ServiceInstanceUnregisteredEvent)(NewServiceInstanceEvent(source, instance))
+	return &ServiceInstanceUnregisteredEvent{*NewServiceInstanceEvent(source, instance)}
 }