Merge pull request #13 from golage/feature/casting-errors

feat: implements error casting

Author: mohsensamiei

errors.go

@@ -37,6 +37,26 @@ func Wrap(cause error, code Code, message string, args ...interface{}) Fundament
 	return fnd
 }
 
+// Cast returns new instance fundamental error with error cause and code
+func Cast(err error, code Code) Fundamental {
+	parsed, _ := Parse(err)
+	if parsed == nil {
+		return nil
+	}
+	if code == CodeNil {
+		return nil
+	}
+	fnd := &fundamental{
+		code:       code,
+		message:    parsed.Message(),
+		stackTrace: parsed.StackTrace(),
+	}
+	if fnd.stackTrace == nil {
+		fnd.stackTrace = stacktrace.Capture(1)
+	}
+	return fnd
+}
+
 // Parse returns fundamental error and code from all of error types
 func Parse(err error) (Fundamental, Code) {
 	switch err := err.(type) {

errors_test.go

@@ -267,3 +267,71 @@ func TestWrap(t *testing.T) {
 		})
 	}
 }
+
+func TestCast(t *testing.T) {
+	type args struct {
+		err  error
+		code Code
+	}
+	tests := []struct {
+		name string
+		args args
+		want Fundamental
+	}{
+		{
+			name: "must returns nil with nil err",
+			args: args{
+				err:  nil,
+				code: CodePermissionDenied,
+			},
+			want: nil,
+		},
+		{
+			name: "must returns nil with nil code",
+			args: args{
+				err:  fmt.Errorf("error"),
+				code: CodeNil,
+			},
+			want: nil,
+		},
+		{
+			name: "must returns fundamental from built-in error",
+			args: args{
+				err:  fmt.Errorf("error"),
+				code: CodeUnimplemented,
+			},
+			want: &fundamental{
+				code:       CodeUnimplemented,
+				message:    "error",
+				stackTrace: stacktrace.Capture(0),
+			},
+		},
+		{
+			name: "must returns fundamental from fundamental error with new code",
+			args: args{
+				err:  New(CodeAlreadyExists, "error"),
+				code: CodeUnimplemented,
+			},
+			want: &fundamental{
+				code:       CodeUnimplemented,
+				message:    "error",
+				stackTrace: stacktrace.Capture(0),
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := Cast(tt.args.err, tt.args.code)
+			if tt.want == nil {
+				assert.Equal(t, err, nil)
+			} else {
+				assert.Equal(t, err.Error(), tt.want.Error())
+				assert.Equal(t, err.Message(), tt.want.Message())
+				assert.Equal(t, int(err.Code()), int(tt.want.Code()))
+				if tt.want.StackTrace() != nil {
+					assert.Equal(t, err.StackTrace()[1:], tt.want.StackTrace()[1:])
+				}
+			}
+		})
+	}
+}