#3 Add error types

Author: safigo

errors.go

@@ -0,0 +1,34 @@
+package mimeheader
+
+type MimeParseErr struct {
+	Err error
+	Msg string
+}
+
+func (e MimeParseErr) Error() string {
+	if e.Err == nil {
+		return e.Msg
+	}
+
+	return e.Msg + ": " + e.Err.Error()
+}
+
+func (e MimeParseErr) Unwrap() error {
+	return e.Err
+}
+
+type MimeTypePartsErr struct {
+	Msg string
+}
+
+func (e MimeTypePartsErr) Error() string {
+	return e.Msg
+}
+
+type MimeTypeWildcardErr struct {
+	Msg string
+}
+
+func (e MimeTypeWildcardErr) Error() string {
+	return e.Msg
+}

parser.go

@@ -1,37 +1,32 @@
 package mimeheader
 
 import (
-	"errors"
-	"fmt"
 	"mime"
 	"strings"
 )
 
-const ParseMediaTypeErrMsg = "error in a parse media type"
-
-// Errors triggered by mime type parser.
-var (
-	// ErrMimeTypeParts is wrong number of mime type parts.
-	ErrMimeTypeParts = errors.New("wrong number of mime type parts")
-	// ErrMimeTypeWildcard is wrong mimetype format.
-	ErrMimeTypeWildcard = errors.New("mimetype cannot be as */plain")
+// Error messages.
+const (
+	MimeParseErrMsg        = "error in a parse media type"
+	MimeTypePartsErrMsg    = "wrong number of mime type parts"
+	MimeTypeWildcardErrMsg = "mimetype cannot be as */plain"
 )
 
 // ParseMediaType parses media type to MimeType structure.
 func ParseMediaType(mtype string) (MimeType, error) {
 	mtype, params, err := mime.ParseMediaType(mtype)
 	if err != nil {
-		return MimeType{}, fmt.Errorf("%s: %w", ParseMediaTypeErrMsg, err)
+		return MimeType{}, MimeParseErr{Err: err, Msg: MimeParseErrMsg}
 	}
 
 	mtypes := strings.SplitN(mtype, MimeSeparator, MimeParts)
 
 	if len(mtypes) != MimeParts {
-		return MimeType{}, ErrMimeTypeParts
+		return MimeType{}, MimeTypePartsErr{Msg: MimeTypePartsErrMsg}
 	}
 
 	if mtypes[0] == MimeAny && mtypes[1] != MimeAny {
-		return MimeType{}, ErrMimeTypeWildcard
+		return MimeType{}, MimeTypeWildcardErr{Msg: MimeTypeWildcardErrMsg}
 	}
 
 	mt := MimeType{

parser_test.go

@@ -2,8 +2,6 @@ package mimeheader_test
 
 import (
 	"errors"
-	"fmt"
-	"mime"
 	"reflect"
 	"testing"
 
@@ -19,12 +17,8 @@ func TestParseMediaType(t *testing.T) {
 			t.Parallel()
 
 			b, err := mimeheader.ParseMediaType(prov.mtype)
-			if (prov.expErr == nil) != (err == nil) {
-				t.Errorf("Unexpected error.\nExpected: %+v\nActual: %+v\n", prov.expErr, err)
-			}
-
-			if err != nil && prov.expErr != nil && prov.expErr.Error() != err.Error() {
-				t.Fatalf("Enuxpected error message.\nExpected: %s\nActual: %s\n", prov.expErr.Error(), err.Error())
+			if !errors.Is(err, prov.expErr) && !errors.As(err, &prov.expErr) {
+				t.Errorf("Unexpected error.\nExpected: %#v\nActual: %#v\n", prov.expErr, err)
 			}
 
 			if !reflect.DeepEqual(prov.exp, b) {
@@ -109,31 +103,31 @@ func providerParseMediaType() []parseMediaType {
 		{
 			name:   "Empty error",
 			mtype:  "",
-			expErr: fmt.Errorf("%s: %w", mimeheader.ParseMediaTypeErrMsg, errors.New("mime: no media type")),
+			expErr: mimeheader.MimeParseErr{},
 			exp:    mimeheader.MimeType{},
 		},
 		{
 			name:   "Wrong wildcard",
 			mtype:  "*/plain",
-			expErr: mimeheader.ErrMimeTypeWildcard,
+			expErr: mimeheader.MimeTypeWildcardErr{},
 			exp:    mimeheader.MimeType{},
 		},
 		{
 			name:   "Wrong delimiters",
 			mtype:  "text/plain;;",
-			expErr: fmt.Errorf("%s: %w", mimeheader.ParseMediaTypeErrMsg, errors.New("mime: invalid media parameter")),
+			expErr: mimeheader.MimeParseErr{},
 			exp:    mimeheader.MimeType{},
 		},
 		{
 			name:   "Invalid parts number",
 			mtype:  "*-plain",
-			expErr: mimeheader.ErrMimeTypeParts,
+			expErr: mimeheader.MimeTypePartsErr{},
 			exp:    mimeheader.MimeType{},
 		},
 		{
 			name:   "Wrong parameter",
 			mtype:  "text/plain; p=",
-			expErr: fmt.Errorf("%s: %w", mimeheader.ParseMediaTypeErrMsg, mime.ErrInvalidMediaParameter),
+			expErr: mimeheader.MimeTypeWildcardErr{},
 			exp:    mimeheader.MimeType{},
 		},
 	}