Vihren Atlas

Atlas › Test

TestFailureConverter_OperationError

go.temporal.io/server/common/nexus/nexusrpc/TestFailureConverter_OperationError

Package
go.temporal.io/server/common/nexus/nexusrpc
Suite / test hierarchy
TestFailureConverter_OperationError
Test
TestFailureConverter_OperationError
Introduced at
failure_converter.go ×1 Joint frontier
Covered ranges
19
Covered lines
53
Covered files
1

Covered source

Expand a file to inspect source; the > gutter marks covered lines.

go.temporal.io/server/common/nexus/nexusrpc/failure_converter.go 53 covered LOC · 19 ranges

Open complete file

46 // ErrorToFailure implements FailureConverter.
47 // nolint:revive // Keeping all of the logic together for readability, even if it means the function is long.
48 > func (e knownErrorFailureConverter) ErrorToFailure(err error) (nexus.Failure, error) { failure_converter.go
49 > if err == nil {
50 return nexus.Failure{}, nil
51 }
52 // NOTE: not using errors.Unwrap here we are intentionally only supporting unwrapping known errors.
53 > switch typedErr := err.(type) { failure_converter.go
54 > case *nexus.FailureError: failure_converter.go
55 > f := typedErr.Failure
56 > // FailureError is has both a Cause error and an underlying Failure Cause.
57 > // When instantiated directly, there are cases where only the Go error cause is set.
58 > // Preserve the embedded failure's cause, as the embedded failure is treated similarly to the OriginalFailure field for well-known other error types.
59 > if typedErr.Cause != nil && f.Cause == nil {
60 c, err := e.ErrorToFailure(typedErr.Cause)
61 if err != nil {
64 f.Cause = &c
65 }
66 > return f, nil failure_converter.go
67 case *nexus.HandlerError:
68 if typedErr.OriginalFailure != nil {
95 }
96 return f, nil
97 > case *nexus.OperationError: failure_converter.go
98 > if typedErr.OriginalFailure != nil {
99 > return *typedErr.OriginalFailure, nil failure_converter.go
100 > }
101 > data := serializedOperationError{ failure_converter.go
102 > State: string(typedErr.State),
103 > }
104 > details, err := json.Marshal(data)
105 > if err != nil {
106 return nexus.Failure{}, err
107 }
108 > f := nexus.Failure{ failure_converter.go
109 > Message: typedErr.Message,
110 > StackTrace: typedErr.StackTrace,
111 > Metadata: map[string]string{
112 > "type": "nexus.OperationError",
113 > },
114 > Details: details,
115 > }
116 >
117 > if typedErr.Cause != nil {
118 > c, err := e.ErrorToFailure(typedErr.Cause) failure_converter.go
119 > if err != nil {
120 return nexus.Failure{}, err
121 }
122 > f.Cause = &c failure_converter.go
123 }
124 > return f, nil failure_converter.go
125 default:
126 return nexus.Failure{
132 // FailureToError implements FailureConverter.
133 // nolint:revive // Keeping all of the logic together for readability, even if it means the function is long.
134 > func (e knownErrorFailureConverter) FailureToError(f nexus.Failure) (error, error) { failure_converter.go
135 > if f.Metadata != nil {
136 > switch f.Metadata["type"] { failure_converter.go
137 case "nexus.HandlerError":
138 var se serializedHandlerError
155 }
156 return he, nil
157 > case "nexus.OperationError": failure_converter.go
158 > var se serializedOperationError
159 > err := json.Unmarshal(f.Details, &se)
160 > if err != nil {
161 return nil, fmt.Errorf("failed to deserialize OperationError: %w", err)
162 }
163 > oe := &nexus.OperationError{ failure_converter.go
164 > Message: f.Message,
165 > StackTrace: f.StackTrace,
166 > State: nexus.OperationState(se.State),
167 > OriginalFailure: &f,
168 > }
169 > if f.Cause != nil {
170 > oe.Cause, err = e.FailureToError(*f.Cause) failure_converter.go
171 > if err != nil {
172 return nil, err
173 }
174 }
175 > return oe, nil failure_converter.go
176 }
177 }
178 // Note that the original failure cause is retained on the FailureError's failure object.
179 > fe := &nexus.FailureError{Failure: f} failure_converter.go
180 > if f.Cause != nil {
181 c, err := e.FailureToError(*f.Cause)
182 if err != nil {