pulumi/sdk/go/common/util/result/result_test.go

// Copyright 2016-2023, Pulumi Corporation.
//
// 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 result

import (
	"bytes"
	"errors"
	"fmt"
	"testing"

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

func TestBail(t *testing.T) {
	t.Parallel()

	err := BailError(errors.New("big boom"))
	assert.EqualError(t, err, "BAIL: big boom")
}

func TestBailf(t *testing.T) {
	t.Parallel()

	err := BailErrorf("%d booms", 5)
	assert.EqualError(t, err, "BAIL: 5 booms")
}

func TestFprintBailf(t *testing.T) {
	t.Parallel()

	var buff bytes.Buffer
	err := FprintBailf(&buff, "%d booms", 5)
	assert.EqualError(t, err, "BAIL: 5 booms")
	assert.Equal(t, "5 booms\n", buff.String())
}

func TestIsBail(t *testing.T) {
	t.Parallel()

	inner := errors.New("big boom")
	bail := BailError(inner)
	wrapped := fmt.Errorf("wrapped: %w", bail)

	assert.False(t, IsBail(nil))
	assert.False(t, IsBail(inner))
	assert.True(t, IsBail(bail))
	assert.True(t, IsBail(wrapped))
}

func TestMergeBails(t *testing.T) {
	t.Parallel()

	// Arrange.
	cases := []struct {
		name     string
		errs     []error
		expected error
	}{
		{
			name:     "no errors",
			errs:     []error{},
			expected: nil,
		},
		{
			name:     "one nil",
			errs:     []error{nil},
			expected: nil,
		},
		{
			name:     "one error",
			errs:     []error{errors.New("boom")},
			expected: errors.New("boom"),
		},
		{
			name:     "one bail",
			errs:     []error{BailErrorf("boom")},
			expected: BailErrorf("BAIL: boom"),
		},
		{
			name:     "all nil",
			errs:     []error{nil, nil, nil},
			expected: nil,
		},
		{
			name: "all bails",
			errs: []error{
				BailError(errors.New("boom")),
				BailError(errors.New("bang")),
				BailErrorf("biff"),
			},
			expected: BailErrorf("BAIL: boom\nBAIL: bang\nBAIL: biff"),
		},
		{
			name: "all errors",
			errs: []error{
				errors.New("boom"),
				errors.New("bang"),
				errors.New("biff"),
			},
			expected: errors.New("boom\nbang\nbiff"),
		},
		{
			name: "nils and errors",
			errs: []error{
				nil,
				errors.New("boom"),
				nil,
				errors.New("bang"),
			},
			expected: errors.New("boom\nbang"),
		},
		{
			name: "nils and bails",
			errs: []error{
				nil,
				BailError(errors.New("boom")),
				nil,
				BailErrorf("bang"),
			},
			expected: BailErrorf("BAIL: boom\nBAIL: bang"),
		},
		{
			name: "errors and bails",
			errs: []error{
				errors.New("boom"),
				BailError(errors.New("bang")),
				errors.New("biff"),
			},
			expected: errors.New("boom\nbiff"),
		},
		{
			name: "errors, bails, and nils",
			errs: []error{
				errors.New("boom"),
				nil,
				BailErrorf("bang"),
				nil,
				nil,
				errors.New("biff"),
				nil,
			},
			expected: errors.New("boom\nbiff"),
		},
	}

	for _, c := range cases {
		c := c

		t.Run(c.name, func(t *testing.T) {
			t.Parallel()

			// Act.
			err := MergeBails(c.errs...)

			// Assert.
			if c.expected == nil {
				assert.Nil(t, err)
			} else {
				assert.Equalf(t, IsBail(c.expected), IsBail(err), "Expected IsBail to be %v", IsBail(c.expected))
				assert.EqualError(t, err, c.expected.Error())
			}
		})
	}
}