Function TestNetErrors

pkg/errors/errors_test.go:112–233

(t *testing.T)

}

func TestNetErrors(t *testing.T) {
	t.Parallel()
	a := assertions.New(t)

	errDummy := fmt.Errorf("dummy")

	for _, tc := range []struct {
		Name     string
		Error    error
		Validate func(err error, e *errors.Error, a *assertions.Assertion)
	}{
		{
			Name: "DNSError",
			Error: &net.DNSError{
				Err:         "SERVFAIL",
				Name:        "invalid-name",
				IsNotFound:  true,
				IsTemporary: false,
				IsTimeout:   false,
				Server:      "dns-server",
			},
			Validate: func(err error, e *errors.Error, a *assertions.Assertion) {
				a.So(e.FullName(), should.Equal, "pkg/errors:net_dns")
				a.So(errors.IsUnavailable(e), should.BeTrue)
				a.So(e.PublicAttributes(), should.Resemble, map[string]any{
					"message":   err.Error(),
					"timeout":   false,
					"not_found": true,
				})
			},
		},
		{
			Name:  "UnknownNetworkError",
			Error: net.UnknownNetworkError("1.1.1.1"),
			Validate: func(err error, e *errors.Error, a *assertions.Assertion) {
				a.So(e.FullName(), should.Equal, "pkg/errors:net_unknown_network")
				a.So(errors.IsNotFound(e), should.BeTrue)
				a.So(e.PublicAttributes(), should.Resemble, map[string]any{
					"message": err.Error(),
					"timeout": false,
				})
			},
		},
		{
			Name:  "InvalidAddrError",
			Error: net.InvalidAddrError("1.1.1.1"),
			Validate: func(err error, e *errors.Error, a *assertions.Assertion) {
				a.So(e.FullName(), should.Equal, "pkg/errors:net_invalid_addr")
				a.So(errors.IsInvalidArgument(e), should.BeTrue)
				a.So(e.PublicAttributes(), should.Resemble, map[string]any{
					"message": err.Error(),
					"timeout": false,
				})
			},
		},
		{
			Name: "AddrError",
			Error: &net.AddrError{