chore: do not use sentinel errors when unneeded

- main reason being it's a burden to always define sentinel errors at global scope, wrap them with `%w` instead of using a string directly
- only use sentinel errors when it has to be checked using `errors.Is`
- replace all usage of these sentinel errors in `fmt.Errorf` with direct strings that were in the sentinel error
- exclude the sentinel error definition requirement from .golangci.yml
- update unit tests to use ContainersError instead of ErrorIs so it stays as a "not a change detector test" without requiring a sentinel error

internal/natpmp/checks.go

@@ -6,48 +6,40 @@ import (
 	"fmt"
 )
 
-var ErrRequestSizeTooSmall = errors.New("message size is too small")
-
 func checkRequest(request []byte) (err error) {
 	const minMessageSize = 2 // version number + operation code
 	if len(request) < minMessageSize {
-		return fmt.Errorf("%w: need at least %d bytes and got %d byte(s)",
-			ErrRequestSizeTooSmall, minMessageSize, len(request))
+		return fmt.Errorf("message size is too small: need at least %d bytes and got %d byte(s)",
+			minMessageSize, len(request))
 	}
 
 	return nil
 }
 
-var (
-	ErrResponseSizeTooSmall    = errors.New("response size is too small")
-	ErrResponseSizeUnexpected  = errors.New("response size is unexpected")
-	ErrProtocolVersionUnknown  = errors.New("protocol version is unknown")
-	ErrOperationCodeUnexpected = errors.New("operation code is unexpected")
-)
-
 func checkResponse(response []byte, expectedOperationCode byte,
 	expectedResponseSize uint,
 ) (err error) {
 	const minResponseSize = 4
 	if len(response) < minResponseSize {
-		return fmt.Errorf("%w: need at least %d bytes and got %d byte(s)",
-			ErrResponseSizeTooSmall, minResponseSize, len(response))
+		return fmt.Errorf("response size is too small: "+
+			"need at least %d bytes and got %d byte(s)",
+			minResponseSize, len(response))
 	}
 
 	if uint(len(response)) != expectedResponseSize {
-		return fmt.Errorf("%w: expected %d bytes and got %d byte(s)",
-			ErrResponseSizeUnexpected, expectedResponseSize, len(response))
+		return fmt.Errorf("response size is unexpected: "+
+			"expected %d bytes and got %d byte(s)",
+			expectedResponseSize, len(response))
 	}
 
 	protocolVersion := response[0]
 	if protocolVersion != 0 {
-		return fmt.Errorf("%w: %d", ErrProtocolVersionUnknown, protocolVersion)
+		return fmt.Errorf("protocol version is unknown: %d", protocolVersion)
 	}
 
 	operationCode := response[1]
 	if operationCode != expectedOperationCode {
-		return fmt.Errorf("%w: expected 0x%x and got 0x%x",
-			ErrOperationCodeUnexpected, expectedOperationCode, operationCode)
+		return fmt.Errorf("operation code is unexpected: expected 0x%x and got 0x%x", expectedOperationCode, operationCode)
 	}
 
 	resultCode := binary.BigEndian.Uint16(response[2:4])
@@ -59,15 +51,6 @@ func checkResponse(response []byte, expectedOperationCode byte,
 	return nil
 }
 
-var (
-	ErrVersionNotSupported       = errors.New("version is not supported")
-	ErrNotAuthorized             = errors.New("not authorized")
-	ErrNetworkFailure            = errors.New("network failure")
-	ErrOutOfResources            = errors.New("out of resources")
-	ErrOperationCodeNotSupported = errors.New("operation code is not supported")
-	ErrResultCodeUnknown         = errors.New("result code is unknown")
-)
-
 // checkResultCode checks the result code and returns an error
 // if the result code is not a success (0).
 // See https://www.ietf.org/rfc/rfc6886.html#section-3.5
@@ -78,16 +61,16 @@ func checkResultCode(resultCode uint16) (err error) {
 	case 0:
 		return nil
 	case 1:
-		return fmt.Errorf("%w", ErrVersionNotSupported)
+		return errors.New("version is not supported")
 	case 2:
-		return fmt.Errorf("%w", ErrNotAuthorized)
+		return errors.New("not authorized")
 	case 3:
-		return fmt.Errorf("%w", ErrNetworkFailure)
+		return errors.New("network failure")
 	case 4:
-		return fmt.Errorf("%w", ErrOutOfResources)
+		return errors.New("out of resources")
 	case 5:
-		return fmt.Errorf("%w", ErrOperationCodeNotSupported)
+		return errors.New("operation code is not supported")
 	default:
-		return fmt.Errorf("%w: %d", ErrResultCodeUnknown, resultCode)
+		return fmt.Errorf("result code is unknown: %d", resultCode)
 	}
 }

internal/natpmp/checks_test.go

@@ -1,6 +1,7 @@
 package natpmp
 
 import (
+	"errors"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -11,12 +12,10 @@ func Test_checkRequest(t *testing.T) {
 
 	testCases := map[string]struct {
 		request    []byte
-		err        error
 		errMessage string
 	}{
 		"too_short": {
 			request:    []byte{1},
-			err:        ErrRequestSizeTooSmall,
 			errMessage: "message size is too small: need at least 2 bytes and got 1 byte(s)",
 		},
 		"success": {
@@ -30,9 +29,10 @@ func Test_checkRequest(t *testing.T) {
 
 			err := checkRequest(testCase.request)
 
-			assert.ErrorIs(t, err, testCase.err)
-			if testCase.err != nil {
+			if testCase.errMessage != "" {
 				assert.EqualError(t, err, testCase.errMessage)
+			} else {
+				assert.NoError(t, err)
 			}
 		})
 	}
@@ -50,33 +50,33 @@ func Test_checkResponse(t *testing.T) {
 	}{
 		"too_short": {
 			response:   []byte{1},
-			err:        ErrResponseSizeTooSmall,
+			err:        errors.New("response size is too small"),
 			errMessage: "response size is too small: need at least 4 bytes and got 1 byte(s)",
 		},
 		"size_mismatch": {
 			response:             []byte{0, 0, 0, 0},
 			expectedResponseSize: 5,
-			err:                  ErrResponseSizeUnexpected,
+			err:                  errors.New("response size is unexpected"),
 			errMessage:           "response size is unexpected: expected 5 bytes and got 4 byte(s)",
 		},
 		"protocol_unknown": {
 			response:             []byte{1, 0, 0, 0},
 			expectedResponseSize: 4,
-			err:                  ErrProtocolVersionUnknown,
+			err:                  errors.New("protocol version is unknown"),
 			errMessage:           "protocol version is unknown: 1",
 		},
 		"operation_code_unexpected": {
 			response:              []byte{0, 2, 0, 0},
 			expectedOperationCode: 1,
 			expectedResponseSize:  4,
-			err:                   ErrOperationCodeUnexpected,
+			err:                   errors.New("operation code is unexpected"),
 			errMessage:            "operation code is unexpected: expected 0x1 and got 0x2",
 		},
 		"result_code_failure": {
 			response:              []byte{0, 1, 0, 1},
 			expectedOperationCode: 1,
 			expectedResponseSize:  4,
-			err:                   ErrVersionNotSupported,
+			err:                   errors.New("version is not supported"),
 			errMessage:            "result code: version is not supported",
 		},
 		"success": {
@@ -94,9 +94,11 @@ func Test_checkResponse(t *testing.T) {
 				testCase.expectedOperationCode,
 				testCase.expectedResponseSize)
 
-			assert.ErrorIs(t, err, testCase.err)
 			if testCase.err != nil {
+				assert.ErrorContains(t, err, testCase.err.Error())
 				assert.EqualError(t, err, testCase.errMessage)
+			} else {
+				assert.NoError(t, err)
 			}
 		})
 	}
@@ -113,32 +115,32 @@ func Test_checkResultCode(t *testing.T) {
 		"success": {},
 		"version_unsupported": {
 			resultCode: 1,
-			err:        ErrVersionNotSupported,
+			err:        errors.New("version is not supported"),
 			errMessage: "version is not supported",
 		},
 		"not_authorized": {
 			resultCode: 2,
-			err:        ErrNotAuthorized,
+			err:        errors.New("not authorized"),
 			errMessage: "not authorized",
 		},
 		"network_failure": {
 			resultCode: 3,
-			err:        ErrNetworkFailure,
+			err:        errors.New("network failure"),
 			errMessage: "network failure",
 		},
 		"out_of_resources": {
 			resultCode: 4,
-			err:        ErrOutOfResources,
+			err:        errors.New("out of resources"),
 			errMessage: "out of resources",
 		},
 		"unsupported_operation_code": {
 			resultCode: 5,
-			err:        ErrOperationCodeNotSupported,
+			err:        errors.New("operation code is not supported"),
 			errMessage: "operation code is not supported",
 		},
 		"unknown": {
 			resultCode: 6,
-			err:        ErrResultCodeUnknown,
+			err:        errors.New("result code is unknown"),
 			errMessage: "result code is unknown: 6",
 		},
 	}
@@ -149,9 +151,11 @@ func Test_checkResultCode(t *testing.T) {
 
 			err := checkResultCode(testCase.resultCode)
 
-			assert.ErrorIs(t, err, testCase.err)
 			if testCase.err != nil {
+				assert.ErrorContains(t, err, testCase.err.Error())
 				assert.EqualError(t, err, testCase.errMessage)
+			} else {
+				assert.NoError(t, err)
 			}
 		})
 	}

internal/natpmp/portmapping.go

@@ -3,17 +3,11 @@ package natpmp
 import (
 	"context"
 	"encoding/binary"
-	"errors"
 	"fmt"
 	"net/netip"
 	"time"
 )
 
-var (
-	ErrNetworkProtocolUnknown = errors.New("network protocol is unknown")
-	ErrLifetimeTooLong        = errors.New("lifetime is too long")
-)
-
 // Add or delete a port mapping. To delete a mapping, set both the
 // requestedExternalPort and lifetime to 0.
 // See https://www.ietf.org/rfc/rfc6886.html#section-3.3
@@ -26,8 +20,9 @@ func (c *Client) AddPortMapping(ctx context.Context, gateway netip.Addr,
 	lifetimeSecondsFloat := lifetime.Seconds()
 	const maxLifetimeSeconds = uint64(^uint32(0))
 	if uint64(lifetimeSecondsFloat) > maxLifetimeSeconds {
-		return 0, 0, 0, 0, fmt.Errorf("%w: %d seconds must at most %d seconds",
-			ErrLifetimeTooLong, uint64(lifetimeSecondsFloat), maxLifetimeSeconds)
+		return 0, 0, 0, 0, fmt.Errorf("lifetime is too long: "+
+			"%d seconds must at most %d seconds",
+			uint64(lifetimeSecondsFloat), maxLifetimeSeconds)
 	}
 	const messageSize = 12
 	message := make([]byte, messageSize)
@@ -38,7 +33,7 @@ func (c *Client) AddPortMapping(ctx context.Context, gateway netip.Addr,
 	case "tcp":
 		message[1] = 2 // operationCode 2
 	default:
-		return 0, 0, 0, 0, fmt.Errorf("%w: %s", ErrNetworkProtocolUnknown, protocol)
+		return 0, 0, 0, 0, fmt.Errorf("network protocol is unknown: %s", protocol)
 	}
 	// [2:3] are reserved.
 	binary.BigEndian.PutUint16(message[4:6], internalPort)

internal/natpmp/portmapping_test.go

@@ -25,18 +25,15 @@ func Test_Client_AddPortMapping(t *testing.T) {
 		assignedInternalPort      uint16
 		assignedExternalPort      uint16
 		assignedLifetime          time.Duration
-		err                       error
 		errMessage                string
 	}{
 		"lifetime_too_long": {
 			lifetime:   time.Duration(uint64(^uint32(0))+1) * time.Second,
-			err:        ErrLifetimeTooLong,
 			errMessage: "lifetime is too long: 4294967296 seconds must at most 4294967295 seconds",
 		},
 		"protocol_unknown": {
 			lifetime:   time.Second,
 			protocol:   "xyz",
-			err:        ErrNetworkProtocolUnknown,
 			errMessage: "network protocol is unknown: xyz",
 		},
 		"rpc_error": {
@@ -48,7 +45,6 @@ func Test_Client_AddPortMapping(t *testing.T) {
 			lifetime:                  1200 * time.Second,
 			initialConnectionDuration: time.Millisecond,
 			exchanges:                 []udpExchange{{close: true}},
-			err:                       ErrConnectionTimeout,
 			errMessage: "executing remote procedure call: connection timeout: failed attempts: " +
 				"read udp 127.0.0.1:[1-9][0-9]{0,4}->127.0.0.1:[1-9][0-9]{0,4}: i/o timeout \\(try 1\\)",
 		},
@@ -136,9 +132,6 @@ func Test_Client_AddPortMapping(t *testing.T) {
 			assert.Equal(t, testCase.assignedExternalPort, assignedExternalPort)
 			assert.Equal(t, testCase.assignedLifetime, assignedLifetime)
 			if testCase.errMessage != "" {
-				if testCase.err != nil {
-					assert.ErrorIs(t, err, testCase.err)
-				}
 				assert.Regexp(t, "^"+testCase.errMessage+"$", err.Error())
 			} else {
 				assert.NoError(t, err)

internal/natpmp/rpc.go

@@ -11,17 +11,12 @@ import (
 	"time"
 )
 
-var (
-	ErrGatewayIPUnspecified = errors.New("gateway IP is unspecified")
-	ErrConnectionTimeout    = errors.New("connection timeout")
-)
-
 func (c *Client) rpc(ctx context.Context, gateway netip.Addr,
 	request []byte, responseSize uint) (
 	response []byte, err error,
 ) {
 	if gateway.IsUnspecified() || !gateway.IsValid() {
-		return nil, fmt.Errorf("%w", ErrGatewayIPUnspecified)
+		return nil, errors.New("gateway IP is unspecified")
 	}
 
 	err = checkRequest(request)
@@ -114,8 +109,7 @@ func (c *Client) rpc(ctx context.Context, gateway netip.Addr,
 	}
 
 	if retryCount == c.maxRetries {
-		return nil, fmt.Errorf("%w: failed attempts: %s",
-			ErrConnectionTimeout, dedupFailedAttempts(failedAttempts))
+		return nil, fmt.Errorf("connection timeout: failed attempts: %s", dedupFailedAttempts(failedAttempts))
 	}
 
 	// Opcodes between 0 and 127 are client requests.  Opcodes from 128 to

internal/natpmp/rpc_test.go

@@ -20,20 +20,17 @@ func Test_Client_rpc(t *testing.T) {
 		initialConnectionDuration time.Duration
 		exchanges                 []udpExchange
 		expectedResponse          []byte
-		err                       error
 		errMessage                string
 	}{
 		"gateway_ip_unspecified": {
 			gateway:    netip.IPv6Unspecified(),
 			request:    []byte{0, 0},
-			err:        ErrGatewayIPUnspecified,
 			errMessage: "gateway IP is unspecified",
 		},
 		"request_too_small": {
 			gateway:                   netip.AddrFrom4([4]byte{127, 0, 0, 1}),
 			request:                   []byte{0},
 			initialConnectionDuration: time.Nanosecond, // doesn't matter
-			err:                       ErrRequestSizeTooSmall,
 			errMessage: `checking request: message size is too small: ` +
 				`need at least 2 bytes and got 1 byte\(s\)`,
 		},
@@ -53,7 +50,6 @@ func Test_Client_rpc(t *testing.T) {
 			exchanges: []udpExchange{
 				{request: []byte{0, 1}, close: true},
 			},
-			err: ErrConnectionTimeout,
 			errMessage: "connection timeout: failed attempts: " +
 				"read udp 127.0.0.1:[1-9][0-9]{0,4}->127.0.0.1:[1-9][0-9]{0,4}: i/o timeout \\(try 1\\)",
 		},
@@ -66,7 +62,6 @@ func Test_Client_rpc(t *testing.T) {
 				request:  []byte{0, 0},
 				response: []byte{1},
 			}},
-			err: ErrResponseSizeTooSmall,
 			errMessage: `checking response: response size is too small: ` +
 				`need at least 4 bytes and got 1 byte\(s\)`,
 		},
@@ -80,7 +75,6 @@ func Test_Client_rpc(t *testing.T) {
 				request:  []byte{0x0, 0x2, 0x0, 0x0, 0x0, 0x7b, 0x1, 0xc8, 0x0, 0x0, 0x4, 0xb0},
 				response: []byte{0, 1, 2, 3}, // size 4
 			}},
-			err: ErrResponseSizeUnexpected,
 			errMessage: `checking response: response size is unexpected: ` +
 				`expected 5 bytes and got 4 byte\(s\)`,
 		},
@@ -94,7 +88,6 @@ func Test_Client_rpc(t *testing.T) {
 				request:  []byte{0x0, 0x2, 0x0, 0x0, 0x0, 0x7b, 0x1, 0xc8, 0x0, 0x0, 0x4, 0xb0},
 				response: []byte{0x1, 0x82, 0x0, 0x0, 0x0, 0x14, 0x4, 0x96, 0x0, 0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
 			}},
-			err:        ErrProtocolVersionUnknown,
 			errMessage: "checking response: protocol version is unknown: 1",
 		},
 		"unexpected_operation_code": {
@@ -107,7 +100,6 @@ func Test_Client_rpc(t *testing.T) {
 				request:  []byte{0x0, 0x2, 0x0, 0x0, 0x0, 0x7b, 0x1, 0xc8, 0x0, 0x0, 0x4, 0xb0},
 				response: []byte{0x0, 0x88, 0x0, 0x0, 0x0, 0x14, 0x4, 0x96, 0x0, 0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
 			}},
-			err:        ErrOperationCodeUnexpected,
 			errMessage: "checking response: operation code is unexpected: expected 0x82 and got 0x88",
 		},
 		"failure_result_code": {
@@ -120,7 +112,6 @@ func Test_Client_rpc(t *testing.T) {
 				request:  []byte{0x0, 0x2, 0x0, 0x0, 0x0, 0x7b, 0x1, 0xc8, 0x0, 0x0, 0x4, 0xb0},
 				response: []byte{0x0, 0x82, 0x0, 0x11, 0x0, 0x14, 0x4, 0x96, 0x0, 0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
 			}},
-			err:        ErrResultCodeUnknown,
 			errMessage: "checking response: result code: result code is unknown: 17",
 		},
 		"success": {
@@ -153,9 +144,6 @@ func Test_Client_rpc(t *testing.T) {
 				testCase.request, testCase.responseSize)
 
 			if testCase.errMessage != "" {
-				if testCase.err != nil {
-					assert.ErrorIs(t, err, testCase.err)
-				}
 				assert.Regexp(t, "^"+testCase.errMessage+"$", err.Error())
 			} else {
 				assert.NoError(t, err)