Add global handler test

api/global/handler.go

@@ -22,10 +22,12 @@ import (
 	"go.opentelemetry.io/otel/api/oterror"
 )
 
-var (
+var defaultHandler = &handler{
-	defaultLogger  = log.New(os.Stderr, "", log.LstdFlags)
+	l: log.New(os.Stderr, "", log.LstdFlags),
-	defaultHandler = handler{l: defaultLogger}
+}
-)
+
+// Global Handler (used for testing).
+var globalHandler oterror.Handler = defaultHandler
 
 // handler logs all errors to STDERR.
 type handler struct {
@@ -46,12 +48,12 @@ func (h *handler) setDelegate(d oterror.Handler) {
 	h.delegate = d
 }
 
-// Error implements oterror.Handler.
+// Handle implements oterror.Handler.
-func (h *handler) Error(err error) {
+func (h *handler) Handle(err error) {
 	h.Lock()
 	defer h.Unlock()
 	if h.delegate != nil {
-		h.delegate.Error(err)
+		h.delegate.Handle(err)
 		return
 	}
 	h.l.Print(err)
@@ -62,10 +64,15 @@ func (h *handler) Error(err error) {
 // until an Handler is set (all functionality is delegated to the set
 // Handler once it is set).
 func Handler() oterror.Handler {
-	return defaultHandler
+	return globalHandler
 }
 
 // SetHandler sets the global Handler to be h.
 func SetHandler(h oterror.Handler) {
 	defaultHandler.setDelegate(h)
 }
+
+// Handle is a convience function for Handler().Handle(err)
+func Handle(err error) {
+	globalHandler.Handle(err)
+}

api/global/handler_test.go

@@ -0,0 +1,125 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed 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 global
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/suite"
+	"go.opentelemetry.io/otel/api/oterror"
+)
+
+type mock []error
+
+func (m *mock) Handle(err error) {
+	(*m) = append(*m, err)
+}
+
+type HandlerTestSuite struct {
+	suite.Suite
+
+	origHandler oterror.Handler
+
+	errs []error
+}
+
+func (s *HandlerTestSuite) Handle(err error) {
+	s.errs = append(s.errs, err)
+}
+
+func (s *HandlerTestSuite) SetupSuite() {
+	s.origHandler = globalHandler
+	globalHandler = s
+}
+
+func (s *HandlerTestSuite) TearDownSuite() {
+	globalHandler = s.origHandler
+}
+
+func (s *HandlerTestSuite) SetupTest() {
+	s.errs = []error{}
+}
+
+func (s *HandlerTestSuite) TestGlocalHandler() {
+	err1 := errors.New("one")
+	err2 := errors.New("two")
+	Handler().Handle(err1)
+	Handle(err2)
+	s.Assert().Equal([]error{err1, err2}, s.errs)
+}
+
+func (s *HandlerTestSuite) TestNoDropsOnDelegate() {
+	var sent int
+	err := errors.New("")
+	stop := make(chan struct{})
+	beat := make(chan struct{})
+	done := make(chan struct{})
+
+	go func() {
+		for {
+			select {
+			case <-stop:
+				done <- struct{}{}
+				return
+			default:
+				sent++
+				Handle(err)
+			}
+
+			select {
+			case beat <- struct{}{}:
+			default:
+			}
+		}
+	}()
+
+	// Wait for the spice to flow
+	select {
+	case <-time.Tick(2 * time.Millisecond):
+		s.T().Fatal("no errors were sent in 2ms")
+	case <-beat:
+	}
+
+	// Change to another Handler. We are testing this is loss-less.
+	secondary := new(mock)
+	SetHandler(secondary)
+
+	select {
+	case <-time.Tick(2 * time.Millisecond):
+		s.T().Fatal("no errors were sent within 2ms after SetHandler")
+	case <-beat:
+	}
+
+	// Now beat is clear, wait for a fresh send.
+	select {
+	case <-time.Tick(2 * time.Millisecond):
+		s.T().Fatal("no fresh errors were sent within 2ms after SetHandler")
+	case <-beat:
+	}
+
+	// Stop sending errors.
+	stop <- struct{}{}
+	// Ensure we do not lose any straglers.
+	<-done
+
+	s.Assert().Greater(len(s.errs), 1, "at least 2 errors should have been sent")
+	s.Assert().Len(s.errs, sent)
+}
+
+func TestHandlerTestSuite(t *testing.T) {
+	suite.Run(t, new(HandlerTestSuite))
+}

api/oterror/handler.go

@@ -17,7 +17,7 @@ package oterror
 // Handler performs a required function when an irremediable event is
 // encountered.
 type Handler interface {
-	// Error handles any error that irremediable by an OpenTelemetry
+	// Handle handles any error that irremediable by an OpenTelemetry
 	// component.
-	Error(error)
+	Handle(error)
 }