add introspection interfaces for some fsm errors

errors.go

@@ -16,6 +16,7 @@ package fsm
 
 import (
 	"context"
+	"errors"
 )
 
 // InvalidEventError is returned by FSM.Event() when the event cannot be called
@@ -69,6 +70,15 @@ func (e NoTransitionError) Error() string {
 	return "no transition"
 }
 
+func (e NoTransitionError) Is(target error) bool {
+	_, ok := target.(NoTransitionError)
+	return ok || errors.Is(e.Err, target)
+}
+
+func (e NoTransitionError) Unwrap() error {
+	return e.Err
+}
+
 // CanceledError is returned by FSM.Event() when a callback have canceled a
 // transition.
 type CanceledError struct {
@@ -82,6 +92,15 @@ func (e CanceledError) Error() string {
 	return "transition canceled"
 }
 
+func (e CanceledError) Is(target error) bool {
+	_, ok := target.(CanceledError)
+	return ok || errors.Is(e.Err, target)
+}
+
+func (e CanceledError) Unwrap() error {
+	return e.Err
+}
+
 // AsyncError is returned by FSM.Event() when a callback have initiated an
 // asynchronous state transition.
 type AsyncError struct {
@@ -98,6 +117,15 @@ func (e AsyncError) Error() string {
 	return "async started"
 }
 
+func (e AsyncError) Is(target error) bool {
+	_, ok := target.(AsyncError)
+	return ok || errors.Is(e.Err, target)
+}
+
+func (e AsyncError) Unwrap() error {
+	return e.Err
+}
+
 // InternalError is returned by FSM.Event() and should never occur. It is a
 // probably because of a bug.
 type InternalError struct{}

errors_test.go

@@ -53,35 +53,71 @@ func TestNotInTransitionError(t *testing.T) {
 
 func TestNoTransitionError(t *testing.T) {
 	e := NoTransitionError{}
+	innerErr := errors.New("no transition")
 	if e.Error() != "no transition" {
 		t.Error("NoTransitionError string mismatch")
 	}
-	e.Err = errors.New("no transition")
+	e.Err = innerErr
 	if e.Error() != "no transition with error: "+e.Err.Error() {
 		t.Error("NoTransitionError string mismatch")
 	}
+
+	realErr := hideErrInterfaceType(e)
+	if !errors.Is(realErr, NoTransitionError{}) {
+		t.Error("NoTransitionError 'Is' broken")
+	}
+	if !errors.Is(realErr, innerErr) {
+		t.Error("NoTransitionError 'Is' broken")
+	}
+	if errors.Unwrap(e) != innerErr {
+		t.Error("NoTransitionError 'Unwrap' broken")
+	}
 }
 
 func TestCanceledError(t *testing.T) {
 	e := CanceledError{}
+	innerErr := errors.New("canceled")
 	if e.Error() != "transition canceled" {
 		t.Error("CanceledError string mismatch")
 	}
-	e.Err = errors.New("canceled")
+	e.Err = innerErr
 	if e.Error() != "transition canceled with error: "+e.Err.Error() {
 		t.Error("CanceledError string mismatch")
 	}
+
+	realErr := hideErrInterfaceType(e)
+	if !errors.Is(realErr, CanceledError{}) {
+		t.Error("CanceledError 'Is' broken")
+	}
+	if !errors.Is(realErr, innerErr) {
+		t.Error("CanceledError 'Is' broken")
+	}
+	if errors.Unwrap(e) != innerErr {
+		t.Error("CanceledError 'Unwrap' broken")
+	}
 }
 
 func TestAsyncError(t *testing.T) {
 	e := AsyncError{}
+	innerErr := errors.New("async")
 	if e.Error() != "async started" {
 		t.Error("AsyncError string mismatch")
 	}
-	e.Err = errors.New("async")
+	e.Err = innerErr
 	if e.Error() != "async started with error: "+e.Err.Error() {
 		t.Error("AsyncError string mismatch")
 	}
+
+	realErr := hideErrInterfaceType(e)
+	if !errors.Is(realErr, AsyncError{}) {
+		t.Error("AsyncError 'Is' broken")
+	}
+	if !errors.Is(realErr, innerErr) {
+		t.Error("AsyncError 'Is' broken")
+	}
+	if errors.Unwrap(e) != innerErr {
+		t.Error("AsyncError 'Unwrap' broken")
+	}
 }
 
 func TestInternalError(t *testing.T) {
@@ -90,3 +126,7 @@ func TestInternalError(t *testing.T) {
 		t.Error("InternalError string mismatch")
 	}
 }
+
+func hideErrInterfaceType(err error) error {
+	return err
+}