ref: errors

Author: sshaplygin

errors.go

@@ -1,31 +1,26 @@
 package ru_doc_code
 
-import "errors"
-
-var (
-	// ErrInvalidINNLength
-	ErrInvalidINNLength = errors.New("invalid inn length")
-
-	// ErrInvalidBIKLength
-	ErrInvalidBIKLength = errors.New("invalid bik length")
-
-	// ErrInvalidKPPLength
-	ErrInvalidKPPLength = errors.New("invalid kpp length")
-
-	// ErrInvalidOGRNLength
-	ErrInvalidOGRNLength = errors.New("invalid ogrn length")
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+)
 
-	// ErrInvalidOGRNIPLength
-	ErrInvalidOGRNIPLength = errors.New("invalid ogrinp length")
+const (
+	unixLikePathSep = "/"
+	windowsPathSep  = "\\"
+)
 
-	// ErrInvalidSNILSLength
-	ErrInvalidSNILSLength = errors.New("invalid snils length")
+var (
+	// ErrInvalidLength invalid input document code length
+	ErrInvalidLength = errors.New("invalid length")
 
 	// ErrInvalidFormattedSNILSLength
 	ErrInvalidFormattedSNILSLength = errors.New("invalid formatted snils length")
 
-	// ErrInvalidRegistrationReasonCode
-	ErrInvalidRegistrationReasonCode = errors.New("invalid registration reason code")
+	// ErrRegistrationReasonCode
+	ErrRegistrationReasonCode = errors.New("invalid registration reason code")
 
 	// ErrInvalidValue
 	ErrInvalidValue = errors.New("invalid code value")
@@ -36,3 +31,34 @@ var (
 	// ErrNotImplemented
 	ErrNotImplemented = errors.New("method does not implemented")
 )
+
+type CommonError struct {
+	Method string
+	Err    error
+}
+
+func (c *CommonError) Error() string {
+	return fmt.Sprintf("%s: %s", c.Method, c.Err.Error())
+}
+
+func GetPackageName() (string, error) {
+	pc, _, _, ok := runtime.Caller(1)
+	if !ok {
+		return "", errors.New("invalid runtime caller")
+	}
+	parts := strings.Split(runtime.FuncForPC(pc).Name(), ".")
+	pl := len(parts)
+
+	sep := unixLikePathSep
+	if runtime.GOOS == "windows" {
+		sep = windowsPathSep
+	}
+
+	pathArr := strings.Split(parts[pl-2], sep)
+	if len(pathArr) == 0 {
+		return "", errors.New("invalid path length")
+	}
+	pkgName := pathArr[len(pathArr)-1]
+
+	return pkgName, nil
+}

kpp/kpp.go

@@ -14,7 +14,14 @@ type KPP struct {
 // example: input format is 773643301
 func Validate(kpp string) (bool, error) {
 	if len(kpp) != 9 {
-		return false, ru_doc_code.ErrInvalidKPPLength
+		pkg, err := ru_doc_code.GetPackageName()
+		if err != nil {
+			return false, err
+		}
+		return false, &ru_doc_code.CommonError{
+			Method: pkg,
+			Err:    ru_doc_code.ErrInvalidLength,
+		}
 	}
 
 	_, err := ru_doc_code.StrToArr(kpp)
@@ -26,7 +33,7 @@ func Validate(kpp string) (bool, error) {
 
 	_, ok := ru_doc_code.SupportedRegistrationReasonSet[ru_doc_code.RegistrationReasonCode(kpp[4:6])]
 	if !ok {
-		return false, ru_doc_code.ErrInvalidRegistrationReasonCode
+		return false, ru_doc_code.ErrRegistrationReasonCode
 	}
 
 	return true, nil

kpp/kpp_test.go

@@ -17,12 +17,12 @@ func TestValidate(t *testing.T) {
 		testCases := []ru_doc_code.TestCodeCase{
 			{
 				Code:    "1234567888776",
-				Error:   ru_doc_code.ErrInvalidKPPLength,
+				Error:   ru_doc_code.ErrInvalidLength,
 				IsValid: false,
 			},
 			{
 				Code:    "044525",
-				Error:   ru_doc_code.ErrInvalidKPPLength,
+				Error:   ru_doc_code.ErrInvalidLength,
 				IsValid: false,
 			},
 			{
@@ -39,7 +39,11 @@ func TestValidate(t *testing.T) {
 		for i, test := range testCases {
 			isValid, err := Validate(test.Code)
 			assert.Equal(t, isValid, test.IsValid, fmt.Sprintf("invalid test case %d: input: %s", i, test.Code))
-			assert.Equal(t, true, errors.Is(test.Error, err), fmt.Sprintf("invalid test case %d: input: %s", i, test.Code))
+			if err != nil {
+				assert.True(t, errors.As(err, &test.Error), fmt.Sprintf("invalid test case %d: input: %s", i, test.Code))
+			} else {
+				assert.Empty(t, err, fmt.Sprintf("invalid test case %d: input: %s", i, test.Code))
+			}
 		}
 	})
 
@@ -69,15 +73,19 @@ func TestValidate(t *testing.T) {
 		for i, test := range testCases {
 			isValid, err := Validate(test.Code)
 			assert.Equal(t, isValid, test.IsValid, fmt.Sprintf("invalid test case %d: input: %s", i, test.Code))
-			assert.Equal(t, true, errors.Is(test.Error, err), fmt.Sprintf("invalid test case %d: input: %s", i, test.Code))
+			if err != nil {
+				assert.True(t, errors.As(err, &test.Error), fmt.Sprintf("invalid test case %d: input: %s", i, test.Code))
+			} else {
+				assert.Empty(t, err, fmt.Sprintf("invalid test case %d: input: %s", i, test.Code))
+			}
 		}
 	})
 
 	t.Run("invalid registration reason code", func(t *testing.T) {
 		testCases := []ru_doc_code.TestCodeCase{
 			{
 				Code:    "773643301",
-				Error:   ru_doc_code.ErrInvalidRegistrationReasonCode,
+				Error:   ru_doc_code.ErrRegistrationReasonCode,
 				IsValid: false,
 			},
 			{
@@ -89,7 +97,11 @@ func TestValidate(t *testing.T) {
 		for i, test := range testCases {
 			isValid, err := Validate(test.Code)
 			assert.Equal(t, isValid, test.IsValid, fmt.Sprintf("invalid test case %d: input: %s", i, test.Code))
-			assert.Equal(t, true, errors.Is(test.Error, err), fmt.Sprintf("invalid test case %d: input: %s", i, test.Code))
+			if err != nil {
+				assert.True(t, errors.As(err, &test.Error), fmt.Sprintf("invalid test case %d: input: %s", i, test.Code))
+			} else {
+				assert.Empty(t, err, fmt.Sprintf("invalid test case %d: input: %s", i, test.Code))
+			}
 		}
 	})
 }