Merge 5df3e6f into 30d5319

jsm.go

@@ -161,6 +161,65 @@ type APIError struct {
 	Description string `json:"description,omitempty"`
 }
 
+// Error prints the JetStream API error code and description
+func (e *APIError) Error() string {
+	return fmt.Sprintf("nats: API error %d: %s", e.ErrorCode, e.Description)
+}
+
+// Is matches against an APIError.
+func (e *APIError) Is(err error) bool {
+	// Extract internal APIError to match against.
+	var aerr *APIError
+	ok := errors.As(err, &aerr)
+	if !ok {
+		return ok
+	}
+	return e.ErrorCode == aerr.ErrorCode
+}
+
+// JetStreamAPIError is an error result from making a request to the
+// JetStream API.
+type JetStreamAPIError interface {
+	Code() int
+	ErrorCode() int
+	Description() string
+	error
+}
+
+type jsAPIError struct {
+	code        int
+	errorCode   int
+	description string
+	message     string
+}
+
+func (err *jsAPIError) Code() int {
+	return err.code
+}
+
+func (err *jsAPIError) ErrorCode() int {
+	return err.errorCode
+}
+
+func (err *jsAPIError) Description() string {
+	if err.description == "" {
+		return err.message
+	}
+	return err.description
+}
+
+func (err *jsAPIError) Error() string {
+	return fmt.Sprintf("nats: %v", err.message)
+}
+
+func (err *jsAPIError) Unwrap() error {
+	return &APIError{
+		Code:        err.Code(),
+		ErrorCode:   err.ErrorCode(),
+		Description: err.Description(),
+	}
+}
+
 // apiResponse is a standard response from the JetStream JSON API
 type apiResponse struct {
 	Type  string    `json:"type"`
@@ -245,10 +304,15 @@ func (js *js) AccountInfo(opts ...JSOpt) (*AccountInfo, error) {
 	}
 	if info.Error != nil {
 		var err error
-		if strings.Contains(info.Error.Description, "not enabled for") {
+		// Internally checks based on error code instead of description match.
+		if errors.Is(info.Error, ErrJetStreamNotEnabled) {
 			err = ErrJetStreamNotEnabled
 		} else {
-			err = errors.New(info.Error.Description)
+			err = &jsAPIError{
+				code:        info.Error.Code,
+				errorCode:   info.Error.ErrorCode,
+				description: info.Error.Description,
+			}
 		}
 		return nil, err
 	}

nats.go

@@ -139,7 +139,6 @@ var (
 	ErrNoResponders                 = errors.New("nats: no responders available for request")
 	ErrNoContextOrTimeout           = errors.New("nats: no context or timeout given")
 	ErrPullModeNotAllowed           = errors.New("nats: pull based not supported")
-	ErrJetStreamNotEnabled          = errors.New("nats: jetstream not enabled")
 	ErrJetStreamBadPre              = errors.New("nats: jetstream api prefix not valid")
 	ErrNoStreamResponse             = errors.New("nats: no response from stream")
 	ErrNotJSMessage                 = errors.New("nats: not a jetstream message")
@@ -172,6 +171,11 @@ var (
 	ErrConnectionNotTLS             = errors.New("nats: connection is not tls")
 )
 
+var (
+	// ErrJetStreamNotEnabled is an error returned when JetStream is not enabled for an account.
+	ErrJetStreamNotEnabled JetStreamAPIError = &jsAPIError{errorCode: 10039, message: "jetstream not enabled"}
+)
+
 func init() {
 	rand.Seed(time.Now().UnixNano())
 }

test/js_test.go

@@ -87,9 +87,71 @@ func TestJetStreamNotAccountEnabled(t *testing.T) {
 	nc, js := jsClient(t, s)
 	defer nc.Close()
 
-	if _, err := js.AccountInfo(); err != nats.ErrJetStreamNotEnabled {
+	_, err := js.AccountInfo()
+
+	// check directly to var (backwards compatible)
+	if err != nats.ErrJetStreamNotEnabled {
 		t.Fatalf("Did not get the proper error, got %v", err)
 	}
+
+	// matching via errors.Is
+	if ok := errors.Is(err, nats.ErrJetStreamNotEnabled); !ok {
+		t.Fatal("Expected ErrJetStreamNotEnabled")
+	}
+
+	// matching wrapped via error.Is
+	err2 := fmt.Errorf("custom error: %w", nats.ErrJetStreamNotEnabled)
+	if ok := errors.Is(err2, nats.ErrJetStreamNotEnabled); !ok {
+		t.Fatal("Expected wrapped ErrJetStreamNotEnabled")
+	}
+
+	// via classic type assertion.
+	jserr, ok := err.(nats.JetStreamAPIError)
+	if !ok {
+		t.Fatal("Expected a JetStreamAPIError")
+	}
+	expected := 10039
+	if jserr.ErrorCode() != expected {
+		t.Fatalf("Expected: %v, got: %v", expected, jserr.ErrorCode())
+	}
+
+	// matching to interface via errors.As(...)
+	var apierr nats.JetStreamAPIError
+	ok = errors.As(err, &apierr)
+	if !ok {
+		t.Fatal("Expected a JetStreamAPIError")
+	}
+	if apierr.ErrorCode() != expected {
+		t.Fatalf("Expected: %v, got: %v", expected, apierr.ErrorCode())
+	}
+	expectedMessage := "nats: jetstream not enabled"
+	if apierr.Error() != expectedMessage {
+		t.Fatalf("Expected: %v, got: %v", expectedMessage, apierr.Error())
+	}
+
+	// matching arbitrary custom error via errors.Is(...)
+	customErr := &nats.APIError{ErrorCode: expected}
+	if ok := errors.Is(customErr, nats.ErrJetStreamNotEnabled); !ok {
+		t.Fatal("Expected wrapped ErrJetStreamNotEnabled")
+	}
+	customErr = &nats.APIError{ErrorCode: 1}
+	if ok := errors.Is(customErr, nats.ErrJetStreamNotEnabled); ok {
+		t.Fatal("Expected to not match ErrJetStreamNotEnabled")
+	}
+
+	// matching to concrete type via errors.As(...)
+	var aerr *nats.APIError
+	ok = errors.As(err, &aerr)
+	if !ok {
+		t.Fatal("Expected an APIError")
+	}
+	if aerr.ErrorCode != expected {
+		t.Fatalf("Expected: %v, got: %v", expected, aerr.ErrorCode)
+	}
+	expectedMessage = "nats: API error 10039: jetstream not enabled"
+	if aerr.Error() != expectedMessage {
+		t.Fatalf("Expected: %v, got: %v", expectedMessage, apierr.Error())
+	}
 }
 
 func TestJetStreamPublish(t *testing.T) {