fix: correctly implement error interfaces on wrapped errors

There were two problems:

* `ExpectedError` and `UnexpectedError` should unwrap themselves
* `ErrorSet` should support equivalency check when there's a single
error inside.

This fixes the scenario of matching an error from a retry loop (in case if
just a single error was encountered).

Signed-off-by: Andrey Smirnov <[email protected]>

retry/retry.go

@@ -6,6 +6,7 @@
 package retry
 
 import (
+	"errors"
 	"fmt"
 	"log"
 	"math/rand"
@@ -74,6 +75,14 @@ func (e *ErrorSet) Append(err error) bool {
 	return ok
 }
 
+// Is implements errors.Is.
+func (e *ErrorSet) Is(err error) bool {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+
+	return len(e.errs) == 1 && errors.Is(e.errs[0], err)
+}
+
 // TimeoutError represents a timeout error.
 type TimeoutError struct{}
 
@@ -90,8 +99,16 @@ func IsTimeout(err error) bool {
 
 type expectedError struct{ error }
 
+func (e expectedError) Unwrap() error {
+	return e.error
+}
+
 type unexpectedError struct{ error }
 
+func (e unexpectedError) Unwrap() error {
+	return e.error
+}
+
 type retryer struct {
 	duration time.Duration
 	options  *Options

retry/retry_test.go

@@ -65,3 +65,29 @@ func Test_retry(t *testing.T) {
 		})
 	}
 }
+
+func Test_errors(t *testing.T) {
+	e := errors.New("xyz")
+
+	if !errors.Is(ExpectedError(e), e) {
+		t.Fatal("expected error should wrap errors")
+	}
+
+	if !errors.Is(UnexpectedError(e), e) {
+		t.Fatal("unexpected error should wrap errors")
+	}
+
+	errSet := ErrorSet{}
+	errSet.Append(e)
+
+	if !errors.Is(&errSet, e) {
+		t.Fatal("error set should wrap errors")
+	}
+
+	errSet = ErrorSet{}
+	errSet.Append(UnexpectedError(e))
+
+	if !errors.Is(&errSet, e) {
+		t.Fatal("error set should wrap errors")
+	}
+}