Merge pull request #9 from joomcode/feature/immutability

Feature/immutability

Author: PeterIvanov

error.go

@@ -26,27 +26,40 @@ var _ fmt.Formatter = (*Error)(nil)
 // It is a caller's responsibility to accumulate and update a property, if needed.
 // Dynamic properties is a brittle mechanism and should therefore be used with care and in a simple and robust manner.
 func (e *Error) WithProperty(key Property, value interface{}) *Error {
-	if e.properties == nil {
-		e.properties = make(map[Property]interface{}, 1)
+	errorCopy := *e
+
+	if errorCopy.properties == nil {
+		errorCopy.properties = make(map[Property]interface{}, 1)
+	} else {
+		errorCopy.properties = make(map[Property]interface{}, len(e.properties) + 1)
+		for k, v := range e.properties {
+			errorCopy.properties[k] = v
+		}
 	}
 
-	e.properties[key] = value
-	return e
+	errorCopy.properties[key] = value
+	return &errorCopy
 }
 
 // WithUnderlyingErrors adds multiple additional related (hidden, suppressed) errors to be used exclusively in error output.
 // Note that these errors make no other effect whatsoever: their traits, types, properties etc. are lost on the observer.
 // Consider using errorx.DecorateMany instead.
 func (e *Error) WithUnderlyingErrors(errs ...error) *Error {
+	errorCopy := *e
+
+	newUnderying := make([]error, 0, len(e.underlying) + len(errs))
+	newUnderying = append(newUnderying, e.underlying...)
+
 	for _, err := range errs {
 		if err == nil {
 			continue
 		}
 
-		e.underlying = append(e.underlying, err)
+		newUnderying = append(newUnderying, err)
 	}
 
-	return e
+	errorCopy.underlying = newUnderying
+	return &errorCopy
 }
 
 // Property extracts a dynamic property value from an error.

error_test.go

@@ -72,6 +72,41 @@ func TestErrorMessages(t *testing.T) {
 	})
 }
 
+func TestImmutableError(t *testing.T) {
+	t.Run("Property", func(t *testing.T) {
+		err := testType.NewWithNoMessage()
+		err1 := err.WithProperty(PropertyPayload(), 1)
+		err2 := err1.WithProperty(PropertyPayload(), 2)
+
+		require.True(t, err.errorType.IsOfType(err2.errorType))
+		require.Equal(t, err.message, err2.message)
+
+		payload, ok := ExtractPayload(err)
+		require.False(t, ok)
+
+		payload, ok = ExtractPayload(err1)
+		require.True(t, ok)
+		require.EqualValues(t, 1, payload)
+
+		payload, ok = ExtractPayload(err2)
+		require.True(t, ok)
+		require.EqualValues(t, 2, payload)
+	})
+
+	t.Run("Underlying", func(t *testing.T) {
+		err := testType.NewWithNoMessage()
+		err1 := err.WithUnderlyingErrors(testSubtype0.NewWithNoMessage())
+		err2 := err1.WithUnderlyingErrors(testSubtype1.NewWithNoMessage())
+
+		require.True(t, err.errorType.IsOfType(err2.errorType))
+		require.Equal(t, err.message, err2.message)
+
+		require.Len(t, err.underlying, 0)
+		require.Len(t, err1.underlying, 1)
+		require.Len(t, err2.underlying, 2)
+	})
+}
+
 func TestErrorStackTrace(t *testing.T) {
 	err := createErrorFuncInStackTrace(testType)
 	output := fmt.Sprintf("%+v", err)