errors_multi_test.go

package grip

import (
	"errors"
	"fmt"
	"strconv"
	"sync"
	"testing"

	"github.com/stretchr/testify/suite"
)

func TestDeprecatedLegacyCatcherSuite(t *testing.T) {
	s := new(CatcherSuite)
	s.reset = func() Catcher { return NewCatcher() }
	suite.Run(t, s)
}

func TestExtendedCatcherSuite(t *testing.T) {
	s := new(CatcherSuite)
	s.reset = func() Catcher { return NewExtendedCatcher() }
	suite.Run(t, s)
}

func TestBasicCatcherSuite(t *testing.T) {
	s := new(CatcherSuite)
	s.reset = func() Catcher { return NewBasicCatcher() }
	suite.Run(t, s)
}

func TestSimpleCatcherSuite(t *testing.T) {
	s := new(CatcherSuite)
	s.reset = func() Catcher { return NewSimpleCatcher() }
	suite.Run(t, s)
}

func TestTimestampCatcherSuite(t *testing.T) {
	s := new(CatcherSuite)
	s.reset = func() Catcher { return NewTimestampCatcher() }
	suite.Run(t, s)
}

func TestExtendedTimestampCatcherSuite(t *testing.T) {
	s := new(CatcherSuite)
	s.reset = func() Catcher { return NewExtendedTimestampCatcher() }
	suite.Run(t, s)
}

///////////////////////////////////
//
// Fixed Size Tests

func TestFixedSizeExtendedCatcherSuite(t *testing.T) {
	s := new(CatcherSuite)
	s.size = 100
	s.reset = func() Catcher { return MakeExtendedCatcher(s.size) }
	suite.Run(t, s)
}

func TestFixedSizeBasicCatcherSuite(t *testing.T) {
	s := new(CatcherSuite)
	s.size = 100
	s.reset = func() Catcher { return MakeBasicCatcher(s.size) }
	suite.Run(t, s)
}

func TestFixedSizeSimpleCatcherSuite(t *testing.T) {
	s := new(CatcherSuite)
	s.size = 100
	s.reset = func() Catcher { return MakeSimpleCatcher(s.size) }
	suite.Run(t, s)
}

func TestFixedSizeTimestampCatcherSuite(t *testing.T) {
	s := new(CatcherSuite)
	s.size = 100
	s.reset = func() Catcher { return MakeTimestampCatcher(s.size) }
	suite.Run(t, s)
}

func TestFixedSizeExtendedTimestampCatcherSuite(t *testing.T) {
	s := new(CatcherSuite)
	s.size = 100
	s.reset = func() Catcher { return MakeExtendedTimestampCatcher(s.size) }
	suite.Run(t, s)
}

////////////////////////////////////////////////////////////////////////

// CatcherSuite provides
type CatcherSuite struct {
	catcher Catcher
	reset   func() Catcher
	size    int
	suite.Suite
}

func (s *CatcherSuite) SetupTest() {
	s.catcher = s.reset()
}

func (s *CatcherSuite) TestInitialValuesOfCatcherInterface() {
	s.False(s.catcher.HasErrors())
	s.Equal(0, s.catcher.Len())
	s.Equal("", s.catcher.String())
}

func (s *CatcherSuite) TestAddMethodImpactsState() {
	s.requireBatchSize(1)

	err := errors.New("foo")

	s.False(s.catcher.HasErrors())
	s.Equal(0, s.catcher.Len())

	s.catcher.Add(err)

	s.True(s.catcher.HasErrors())
	s.Equal(1, s.catcher.Len())
}

func (s *CatcherSuite) TestAddingNilMethodDoesNotImpactCatcherState() {
	s.False(s.catcher.HasErrors())
	s.Equal(0, s.catcher.Len())

	for i := 0; i < 100; i++ {
		s.catcher.Add(nil)
	}

	s.False(s.catcher.HasErrors())
	s.Equal(0, s.catcher.Len())
}

func (s *CatcherSuite) TestAddingManyErrorsIsCaptured() {
	s.requireBatchSize(100)

	s.False(s.catcher.HasErrors())
	s.Equal(0, s.catcher.Len())

	for i := 1; i <= 100; i++ {
		s.catcher.Add(errors.New(strconv.Itoa(i)))
		s.True(s.catcher.HasErrors())
		s.Equal(i, s.catcher.Len())
	}

	s.True(s.catcher.HasErrors())
	s.Equal(100, s.catcher.Len())
}

func (s *CatcherSuite) TestResolveMethodIsNilIfNotHasErrors() {
	s.False(s.catcher.HasErrors())
	s.Equal(0, s.catcher.Len())

	s.NoError(s.catcher.Resolve())

	for i := 0; i < 100; i++ {
		s.catcher.Add(nil)
		s.NoError(s.catcher.Resolve())
	}

	s.False(s.catcher.HasErrors())
	s.Equal(0, s.catcher.Len())
}

func (s *CatcherSuite) TestResolveMethodDoesNotClearStateOfCatcher() {
	s.requireBatchSize(10)

	s.False(s.catcher.HasErrors())
	s.Equal(0, s.catcher.Len())

	for i := 1; i <= 10; i++ {
		s.catcher.Add(errors.New(strconv.Itoa(i)))
		s.True(s.catcher.HasErrors())
	}
	s.Equal(10, s.catcher.Len())

	s.Error(s.catcher.Resolve())

	s.True(s.catcher.HasErrors())
	s.Equal(10, s.catcher.Len())
}

func (s *CatcherSuite) TestConcurrentAddingOfErrors() {
	batchSize := 256
	if s.size <= batchSize {
		batchSize = s.size

	}
	wg := &sync.WaitGroup{}
	s.Equal(s.catcher.Len(), 0)
	for i := 0; i < batchSize; i++ {
		wg.Add(1)
		go func(num int) {
			s.catcher.Add(fmt.Errorf("adding err #%d", num))
			wg.Done()
		}(i)
	}
	wg.Wait()
	s.Equal(s.catcher.Len(), batchSize)
}

func (s *CatcherSuite) requireBatchSize(size int) {
	if s.size <= 0 {
		return
	}

	s.Require().True(s.size >= size, "batch size must be larger than the size of the collector")
}

func (s *CatcherSuite) TestErrorsAndExtendMethods() {
	s.requireBatchSize(20)

	for i := 1; i <= 10; i++ {
		s.catcher.Add(errors.New(strconv.Itoa(i)))
		s.True(s.catcher.HasErrors())
	}

	errs := s.catcher.Errors()

	s.Equal(s.catcher.Len(), 10)
	s.Equal(s.catcher.Len(), len(errs))

	s.catcher.Extend(errs)
	s.Equal(s.catcher.Len(), 20)
}

func (s *CatcherSuite) TestExtendWithEmptySet() {
	s.Equal(s.catcher.Len(), 0)
	s.catcher.Extend(s.catcher.Errors())
	s.Equal(s.catcher.Len(), 0)
}

func (s *CatcherSuite) TestExtendWithNilErrors() {
	s.requireBatchSize(1)
	errs := []error{nil, errors.New("what"), nil}
	s.Len(errs, 3)
	s.catcher.Extend(errs)
	s.Equal(s.catcher.Len(), 1)
}

func (s *CatcherSuite) TestAddWhenNilError() {
	s.catcher.AddWhen(true, nil)
	s.Equal(s.catcher.Len(), 0)
	s.catcher.AddWhen(false, nil)
	s.Equal(s.catcher.Len(), 0)
}

func (s *CatcherSuite) TestAddWithErrorAndFalse() {
	s.requireBatchSize(1)

	s.catcher.AddWhen(false, errors.New("f"))
	s.Equal(s.catcher.Len(), 0)
	s.catcher.AddWhen(true, errors.New("f"))
	s.Equal(s.catcher.Len(), 1)
	s.catcher.AddWhen(false, errors.New("f"))
	s.Equal(s.catcher.Len(), 1)
}

func (s *CatcherSuite) TestExtendWhenNilError() {
	s.catcher.ExtendWhen(true, []error{})
	s.Equal(s.catcher.Len(), 0)
	s.catcher.ExtendWhen(false, []error{})
	s.Equal(s.catcher.Len(), 0)
	s.catcher.ExtendWhen(true, nil)
	s.Equal(s.catcher.Len(), 0)
	s.catcher.ExtendWhen(false, nil)
	s.Equal(s.catcher.Len(), 0)
}

func (s *CatcherSuite) TestExtendWithErrorAndFalse() {
	s.requireBatchSize(3)

	s.catcher.ExtendWhen(false, []error{errors.New("f")})
	s.Equal(s.catcher.Len(), 0)
	s.catcher.ExtendWhen(true, []error{errors.New("f")})
	s.Equal(s.catcher.Len(), 1)
	s.catcher.ExtendWhen(false, []error{errors.New("f")})
	s.Equal(s.catcher.Len(), 1)

	s.catcher.ExtendWhen(false, []error{errors.New("f"), errors.New("f")})
	s.Equal(s.catcher.Len(), 1)
	s.catcher.ExtendWhen(true, []error{errors.New("f"), errors.New("f")})
	s.Equal(s.catcher.Len(), 3)
}

func (s *CatcherSuite) TestNewEmpty() {
	s.catcher.New("")
	s.Equal(s.catcher.Len(), 0)
}

func (s *CatcherSuite) TestNewAdd() {
	s.requireBatchSize(1)
	s.catcher.New("one")
	s.Equal(s.catcher.Len(), 1)
	s.Contains(s.catcher.Errors()[0].Error(), "one")
}

func (s *CatcherSuite) TestWrapEmpty() {
	s.catcher.Wrap(nil, "foo")
	s.Equal(s.catcher.Len(), 0)
}

func (s *CatcherSuite) TestWrapFEmpty() {
	s.catcher.Wrapf(nil, "foo:%t", true)
	s.Equal(s.catcher.Len(), 0)
}

func (s *CatcherSuite) TestWrapPopulated() {
	s.requireBatchSize(1)

	s.catcher.Wrap(errors.New("foo"), "bar")
	s.Equal(s.catcher.Len(), 1)
	s.Contains(s.catcher.Errors()[0].Error(), "foo")
	s.Contains(s.catcher.Errors()[0].Error(), "bar")
}

func (s *CatcherSuite) TestWrapfPopulated() {
	s.requireBatchSize(1)

	s.catcher.Wrapf(errors.New("foo"), "bar: %s", "this")
	s.Equal(s.catcher.Len(), 1)
	s.Contains(s.catcher.Errors()[0].Error(), "foo")
	s.Contains(s.catcher.Errors()[0].Error(), "bar: this")
}

func (s *CatcherSuite) TestWrapPopulatedNillAnnotation() {
	s.requireBatchSize(1)

	s.catcher.Wrap(errors.New("foo"), "")
	s.Equal(s.catcher.Len(), 1)
	s.Contains(s.catcher.Errors()[0].Error(), "foo")
}

func (s *CatcherSuite) TestWrapfPopulatedNillAnnotation() {
	s.requireBatchSize(1)
	s.catcher.Wrapf(errors.New("foo"), "")
	s.Equal(s.catcher.Len(), 1)
	s.Contains(s.catcher.Errors()[0].Error(), "foo")
}

func (s *CatcherSuite) TestNewWhen() {
	s.requireBatchSize(1)
	s.catcher.NewWhen(false, "")
	s.Equal(s.catcher.Len(), 0)
	s.catcher.NewWhen(false, "one")
	s.Equal(s.catcher.Len(), 0)
	s.catcher.NewWhen(true, "one")
	s.Equal(s.catcher.Len(), 1)
	s.catcher.NewWhen(true, "")
	s.Equal(s.catcher.Len(), 1)
	s.catcher.NewWhen(false, "one")
	s.Equal(s.catcher.Len(), 1)
}

func (s *CatcherSuite) TestErrorfNilCases() {
	s.catcher.Errorf("")
	s.Equal(s.catcher.Len(), 0)
	s.catcher.Errorf("", true, false)
	s.Equal(s.catcher.Len(), 0)
}

func (s *CatcherSuite) TestErrorfWhenNilCases() {
	s.catcher.ErrorfWhen(true, "")
	s.Equal(s.catcher.Len(), 0)
	s.catcher.ErrorfWhen(true, "", true, false)
	s.Equal(s.catcher.Len(), 0)

	s.catcher.ErrorfWhen(false, "")
	s.Equal(s.catcher.Len(), 0)
	s.catcher.ErrorfWhen(false, "", true, false)
	s.Equal(s.catcher.Len(), 0)
}

func (s *CatcherSuite) TestErrorfNoArgs() {
	s.requireBatchSize(1)
	s.catcher.Errorf("%s what")
	s.Equal(s.catcher.Len(), 1)
	s.Contains(s.catcher.Errors()[0].Error(), "%s what")
}

func (s *CatcherSuite) TestErrorfWhenNoArgs() {
	s.catcher.ErrorfWhen(false, "%s what")
	s.Equal(s.catcher.Len(), 0)

	s.catcher.ErrorfWhen(true, "%s what")
	s.Equal(s.catcher.Len(), 1)
	s.Contains(s.catcher.Errors()[0].Error(), "%s what")
}

func (s *CatcherSuite) TestErrorfFull() {
	s.requireBatchSize(1)
	s.catcher.Errorf("%s what", "this")
	s.Equal(s.catcher.Len(), 1)
	s.Contains(s.catcher.Errors()[0].Error(), "this what")
}

func (s *CatcherSuite) TestWhenErrorfFull() {
	s.requireBatchSize(1)
	s.catcher.ErrorfWhen(false, "%s what", "this")
	s.Equal(s.catcher.Len(), 0)

	s.catcher.ErrorfWhen(true, "%s what", "this")
	s.Equal(s.catcher.Len(), 1)
	s.Contains(s.catcher.Errors()[0].Error(), "this what")
}

func (s *CatcherSuite) TestCheckWhenError() {
	s.requireBatchSize(1)
	fn := func() error { return errors.New("hi") }
	s.Error(fn())
	s.catcher.CheckWhen(false, fn)
	s.Equal(s.catcher.Len(), 0)
	s.catcher.CheckWhen(true, fn)
	s.Equal(s.catcher.Len(), 1)
	s.catcher.Check(fn)
	s.Equal(s.catcher.Len(), 2)
}

func (s *CatcherSuite) TestCheckWhenNoError() {
	fn := func() error { return nil }
	s.NoError(fn())
	s.catcher.CheckWhen(false, fn)
	s.Equal(s.catcher.Len(), 0)
	s.catcher.CheckWhen(true, fn)
	s.Equal(s.catcher.Len(), 0)
	s.catcher.Check(fn)
	s.Equal(s.catcher.Len(), 0)
}

func (s *CatcherSuite) TestCheckExtendNoError() {
	fn := func() error { return nil }
	s.catcher.CheckExtend([]CheckFunction{fn, fn, fn})
	s.Equal(s.catcher.Len(), 0)
}

func (s *CatcherSuite) TestCheckExtendError() {
	s.requireBatchSize(3)
	fn := func() error { return errors.New("hi") }
	s.catcher.CheckExtend([]CheckFunction{fn, fn, fn})
	s.Equal(s.catcher.Len(), 3)
}

func (s *CatcherSuite) TestCheckExtendMixed() {
	s.requireBatchSize(2)
	s.catcher.CheckExtend([]CheckFunction{
		func() error { return errors.New("hi") },
		func() error { return errors.New("hi") },
		func() error { return nil },
	})
	s.Equal(s.catcher.Len(), 2)
}

func (s *CatcherSuite) TestCapsRespectedForAdd() {
	iters := 0
	for i := 0; i < 2*s.size; i++ {
		iters++
		s.catcher.Add(errors.New("abc"))
	}
	s.Equal(2*s.size, iters) // sanity check

	if s.size == 0 {
		s.Equal(s.catcher.Len(), 2*s.size)
	} else {
		s.Equal(s.catcher.Len(), s.size)
	}

}

func (s *CatcherSuite) TestCapsRespectedForExtend() {
	if s.size <= 0 {
	}

	errs := make([]error, s.size*2)

	for idx := range errs {
		errs[idx] = errors.New("abc")
	}

	s.catcher.Extend(errs)
	if s.size <= 0 {
		s.Equal(s.catcher.Len(), 2*s.size)
	} else {
		s.Equal(s.catcher.Len(), s.size)
	}

	s.catcher.Extend(errs)

	if s.size <= 0 {
		s.Equal(s.catcher.Len(), 4*s.size)
	} else {
		s.Equal(s.catcher.Len(), s.size)
	}
}