error_test.go

// Copyright 2016 Qiang Xue. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.

package validation

import (
	"errors"
	"fmt"
	"testing"

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

func TestNewInternalError(t *testing.T) {
	err := NewInternalError(errors.New("abc"))
	if assert.NotNil(t, err.InternalError()) {
		assert.Equal(t, "abc", err.InternalError().Error())
	}
}

func TestErrors_Error(t *testing.T) {
	errs := Errors{
		"B": errors.New("B1"),
		"C": errors.New("C1"),
		"A": errors.New("A1"),
	}
	assert.Equal(t, "A: A1; B: B1; C: C1.", errs.Error())

	errs = Errors{
		"B": errors.New("B1"),
	}
	assert.Equal(t, "B: B1.", errs.Error())

	errs = Errors{}
	assert.Equal(t, "", errs.Error())

	// issue #147: nil value should not cause panic
	errs = Errors{
		"A": errors.New("A1"),
		"B": nil,
		"C": errors.New("C1"),
	}
	assert.NotPanics(t, func() {
		_ = errs.Error()
	})
}

func TestErrors_Is(t *testing.T) {
	sentinel := errors.New("sentinel")

	assert.True(t, errors.Is(Errors{"A": errors.New("a"), "B": sentinel}, sentinel))
	assert.False(t, errors.Is(Errors{"A": errors.New("a"), "B": errors.New("b")}, sentinel))

	// wrapped field errors are matched through the errors chain
	assert.True(t, errors.Is(Errors{"A": fmt.Errorf("wrapped: %w", sentinel)}, sentinel))

	// errors nested in Errors (maps, slices, nested structs) are matched too
	assert.True(t, errors.Is(Errors{"A": Errors{"0": sentinel}}, sentinel))

	// nil field errors and empty Errors do not match, and no target never matches
	assert.False(t, errors.Is(Errors{"A": nil}, sentinel))
	assert.False(t, errors.Is(Errors{}, sentinel))
	assert.False(t, errors.Is(Errors{"A": errors.New("a")}, nil))
}

type customError struct {
	code int
}

func (e customError) Error() string { return fmt.Sprintf("custom %d", e.code) }

func TestErrors_As(t *testing.T) {
	var target customError

	assert.True(t, errors.As(Errors{"A": errors.New("a"), "B": customError{code: 7}}, &target))
	assert.Equal(t, 7, target.code)

	// errors nested in Errors are found too
	target = customError{}
	assert.True(t, errors.As(Errors{"A": Errors{"0": customError{code: 9}}}, &target))
	assert.Equal(t, 9, target.code)

	// wrapped field errors are unwrapped
	target = customError{}
	assert.True(t, errors.As(Errors{"A": fmt.Errorf("wrapped: %w", customError{code: 3})}, &target))
	assert.Equal(t, 3, target.code)

	// fields are scanned in sorted key order, so the "A" match wins over "B"
	target = customError{}
	assert.True(t, errors.As(Errors{"B": customError{code: 2}, "A": customError{code: 1}}, &target))
	assert.Equal(t, 1, target.code)

	// no matching field, nil field errors and empty Errors report false
	target = customError{}
	assert.False(t, errors.As(Errors{"A": errors.New("a"), "B": nil}, &target))
	assert.False(t, errors.As(Errors{}, &target))
}

func TestErrors_MarshalMessage(t *testing.T) {
	errs := Errors{
		"A": errors.New("A1"),
		"B": Errors{
			"2": errors.New("B1"),
		},
	}
	errsJSON, err := errs.MarshalJSON()
	assert.Nil(t, err)
	assert.Equal(t, "{\"A\":\"A1\",\"B\":{\"2\":\"B1\"}}", string(errsJSON))
}

func TestErrors_Filter(t *testing.T) {
	errs := Errors{
		"B": errors.New("B1"),
		"C": nil,
		"A": errors.New("A1"),
	}
	err := errs.Filter()
	assert.Equal(t, 2, len(errs))
	if assert.NotNil(t, err) {
		assert.Equal(t, "A: A1; B: B1.", err.Error())
	}

	errs = Errors{}
	assert.Nil(t, errs.Filter())

	errs = Errors{
		"B": nil,
		"C": nil,
	}

	assert.Nil(t, errs.Filter())
}

func TestErrorObject_SetCode(t *testing.T) {
	err := NewError("A", "msg").(ErrorObject)

	assert.Equal(t, err.code, "A")
	assert.Equal(t, err.Code(), "A")

	err = err.SetCode("B").(ErrorObject)
	assert.Equal(t, "B", err.code)
}

func TestErrorObject_Code(t *testing.T) {
	err := NewError("A", "msg").(ErrorObject)

	assert.Equal(t, err.Code(), "A")
}

func TestErrorObject_SetMessage(t *testing.T) {
	err := NewError("code", "A").(ErrorObject)

	assert.Equal(t, err.message, "A")
	assert.Equal(t, err.Message(), "A")

	err = err.SetMessage("abc").(ErrorObject)
	assert.Equal(t, err.message, "abc")
	assert.Equal(t, err.Message(), "abc")
}

func TestErrorObject_Message(t *testing.T) {
	err := NewError("code", "A").(ErrorObject)

	assert.Equal(t, err.message, "A")
	assert.Equal(t, err.Message(), "A")
}

func TestErrorObject_Params(t *testing.T) {
	p := map[string]interface{}{"A": "val1", "AA": "val2"}

	err := NewError("code", "A").(ErrorObject)
	err = err.SetParams(p).(ErrorObject)
	err = err.SetMessage("B").(ErrorObject)

	assert.Equal(t, err.params, p)
	assert.Equal(t, err.Params(), p)
}

func TestErrorObject_AddParam2(t *testing.T) {
	p := map[string]interface{}{"key": "val"}
	err := NewError("code", "A").(ErrorObject)
	err = err.AddParam("key", "val").(ErrorObject)

	assert.Equal(t, err.params, p)
	assert.Equal(t, err.Params(), p)
}

func TestErrorObject_AddParam(t *testing.T) {
	p := map[string]interface{}{"A": "val1", "B": "val2"}

	err := NewError("code", "A").(ErrorObject)
	err = err.SetParams(p).(ErrorObject)
	err = err.AddParam("C", "val3").(ErrorObject)

	p["C"] = "val3"

	assert.Equal(t, err.params, p)
	assert.Equal(t, err.Params(), p)
}

func TestError_Code(t *testing.T) {
	err := NewError("A", "msg")

	assert.Equal(t, err.Code(), "A")
}

func TestError_SetMessage(t *testing.T) {
	err := NewError("code", "A")

	assert.Equal(t, err.Message(), "A")

	err = err.SetMessage("abc")
	assert.Equal(t, err.Message(), "abc")
}

func TestError_Message(t *testing.T) {
	err := NewError("code", "A")

	assert.Equal(t, err.Message(), "A")
}

func TestError_Params(t *testing.T) {
	p := map[string]interface{}{"A": "val1", "AA": "val2"}

	err := NewError("code", "A")
	err = err.SetParams(p)
	err = err.SetMessage("B")

	assert.Equal(t, err.Params(), p)
}

func TestValidationError(t *testing.T) {
	params := map[string]interface{}{
		"A": "B",
	}

	err := NewError("code", "msg")
	err = err.SetParams(params)

	assert.Equal(t, err.Code(), "code")
	assert.Equal(t, err.Message(), "msg")
	assert.Equal(t, err.Params(), params)

	params = map[string]interface{}{"min": 1}
	err = err.SetParams(params)

	assert.Equal(t, err.Params(), params)
}