multierr_test.go

package multierr_test

import (
	"errors"
	"testing"

	"github.com/jordanhasgul/multierr"
	"github.com/stretchr/testify/require"
)

func TestNew(t *testing.T) {
	t.Run("zero errors", func(t *testing.T) {
		e := multierr.New()
		require.Equal(t, e.Len(), 0)
	})

	t.Run("one nil error", func(t *testing.T) {
		e := multierr.New(nil)
		require.Equal(t, e.Len(), 0)
	})

	t.Run("one non-nil error", func(t *testing.T) {
		e := multierr.New(errors.New("1"))
		require.Equal(t, e.Len(), 1)
	})

	t.Run("some nil errors", func(t *testing.T) {
		e := multierr.New(
			errors.New("1"),
			errors.New("2"),
			nil,
		)
		require.Equal(t, e.Len(), 2)
	})

	t.Run("some non-nil errors", func(t *testing.T) {
		e := multierr.New(
			errors.New("1"),
			errors.New("2"),
			errors.New("3"),
		)
		require.Equal(t, e.Len(), 3)
	})

}

func TestAppend(t *testing.T) {
	t.Run("nil error", func(t *testing.T) {
		t.Run("zero errors", func(t *testing.T) {
			var (
				err error
				e   = multierr.Append(err)
			)
			require.Equal(t, e.Len(), 0)
		})

		t.Run("one nil error", func(t *testing.T) {
			var (
				err error
				e   = multierr.Append(err, nil)
			)
			require.Equal(t, e.Len(), 0)
		})

		t.Run("one non-nil error", func(t *testing.T) {
			var (
				err error
				e   = multierr.Append(err, errors.New("1"))
			)
			require.Equal(t, e.Len(), 1)
		})

		t.Run("some nil errors", func(t *testing.T) {
			var (
				err error
				e   = multierr.Append(
					err,
					errors.New("1"),
					errors.New("2"),
					nil,
				)
			)
			require.Equal(t, e.Len(), 2)
		})

		t.Run("some non-nil errors", func(t *testing.T) {
			var (
				err error
				e   = multierr.Append(
					err,
					errors.New("1"),
					errors.New("2"),
					errors.New("3"),
				)
			)
			require.Equal(t, e.Len(), 3)
		})
	})

	t.Run("non-nil error", func(t *testing.T) {
		t.Run("zero errors", func(t *testing.T) {
			var (
				err = errors.New("1")
				e   = multierr.Append(err)
			)
			require.Equal(t, e.Len(), 1)
		})

		t.Run("one nil error", func(t *testing.T) {
			var (
				err = errors.New("1")
				e   = multierr.Append(err, nil)
			)
			require.Equal(t, e.Len(), 1)
		})

		t.Run("one non-nil error", func(t *testing.T) {
			var (
				err = errors.New("1")
				e   = multierr.Append(err, errors.New("2"))
			)
			require.Equal(t, e.Len(), 2)
		})

		t.Run("some nil errors", func(t *testing.T) {
			var (
				err = errors.New("1")
				e   = multierr.Append(
					err,
					errors.New("2"),
					errors.New("3"),
					nil,
				)
			)
			require.Equal(t, e.Len(), 3)
		})

		t.Run("some non-nil errors", func(t *testing.T) {
			var (
				err = errors.New("1")
				e   = multierr.Append(
					err,
					errors.New("2"),
					errors.New("3"),
					errors.New("4"),
				)
			)
			require.Equal(t, e.Len(), 4)
		})
	})

	t.Run("nil multierr.Error", func(t *testing.T) {
		t.Run("zero errors", func(t *testing.T) {
			var e *multierr.Error
			e = multierr.Append(e)
			require.Equal(t, e.Len(), 0)
		})

		t.Run("one non-nil error", func(t *testing.T) {
			var e *multierr.Error
			e = multierr.Append(e, errors.New("1"))
			require.Equal(t, e.Len(), 1)
		})

		t.Run("one nil error", func(t *testing.T) {
			var e *multierr.Error
			e = multierr.Append(e, nil)
			require.Equal(t, e.Len(), 0)
		})

		t.Run("some non-nil errors", func(t *testing.T) {
			var e *multierr.Error
			e = multierr.Append(
				e,
				errors.New("1"),
				errors.New("2"),
				errors.New("3"),
			)
			require.Equal(t, e.Len(), 3)
		})

		t.Run("some nil errors", func(t *testing.T) {
			var e *multierr.Error
			e = multierr.Append(
				e,
				errors.New("1"),
				errors.New("2"),
				nil,
			)
			require.Equal(t, e.Len(), 2)
		})
	})

	t.Run("non-nil multierr.Error", func(t *testing.T) {
		t.Run("zero errors", func(t *testing.T) {
			e := multierr.New(errors.New("1"))
			e = multierr.Append(e)
			require.Equal(t, e.Len(), 1)
		})

		t.Run("one nil error", func(t *testing.T) {
			e := multierr.New(errors.New("1"))
			e = multierr.Append(e, nil)
			require.Equal(t, e.Len(), 1)
		})

		t.Run("one non-nil error", func(t *testing.T) {
			e := multierr.New(errors.New("1"))
			e = multierr.Append(e, errors.New("2"))
			require.Equal(t, e.Len(), 2)
		})

		t.Run("some nil errors", func(t *testing.T) {
			e := multierr.New(errors.New("1"))
			e = multierr.Append(
				e,
				errors.New("2"),
				errors.New("3"),
				nil,
			)
			require.Equal(t, e.Len(), 3)
		})

		t.Run("some non-nil errors", func(t *testing.T) {
			e := multierr.New(errors.New("1"))
			e = multierr.Append(
				e,
				errors.New("2"),
				errors.New("3"),
				errors.New("4"),
			)
			require.Equal(t, e.Len(), 4)
		})
	})
}

func TestError_Error(t *testing.T) {
	t.Run("nil multierr.Error", func(t *testing.T) {
		var (
			e      *multierr.Error
			errStr = ""
		)
		require.Equal(t, errStr, e.Error())
	})

	t.Run("non-nil multierr.Error", func(t *testing.T) {
		t.Run("zero errors", func(t *testing.T) {
			var (
				e      = multierr.New()
				errStr = ""
			)
			require.Equal(t, errStr, e.Error())
		})

		t.Run("one error", func(t *testing.T) {
			var (
				e      = multierr.New(errors.New("1"))
				errStr = "1 error(s) occurred:\n└── 1\n"
			)
			require.Equal(t, errStr, e.Error())
		})

		t.Run("some errors", func(t *testing.T) {
			var (
				e = multierr.New(
					errors.New("1"),
					multierr.New(
						errors.New("2"),
						errors.New("3"),
					),
					multierr.New(errors.New("4")),
				)
				errStr = "" +
					"3 error(s) occurred:\n" +
					"├── 1\n" +
					"├── 2 error(s) occurred:\n" +
					"│   ├── 2\n" +
					"│   └── 3\n" +
					"└── 1 error(s) occurred:\n" +
					"    └── 4\n"
			)
			require.Equal(t, errStr, e.Error())
		})
	})
}