Add option to disable error wrapping

Sometimes implementations may want to transparently run code without wrapping errors from a library.

Author: ccremer

examples/options_test.go

@@ -0,0 +1,21 @@
+package examples
+
+import (
+	"errors"
+	"testing"
+
+	pipeline "github.com/ccremer/go-command-pipeline"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestExample_Options(t *testing.T) {
+	p := pipeline.NewPipeline()
+	p.WithOptions(pipeline.DisableErrorWrapping)
+	p.WithSteps(
+		pipeline.NewStepFromFunc("disabled error wrapping", func(_ pipeline.Context) error {
+			return errors.New("some error")
+		}),
+	)
+	result := p.Run()
+	assert.Equal(t, "some error", result.Err.Error())
+}

options.go

@@ -0,0 +1,21 @@
+package pipeline
+
+// Option configures the given Pipeline with a behaviour-altering setting.
+type Option func(pipeline *Pipeline)
+
+// WithOptions configures the Pipeline with settings.
+// The options are applied immediately.
+// Options are applied to nested pipelines provided they are set before building the nested pipeline.
+// Nested pipelines can be configured with their own options.
+func (p *Pipeline) WithOptions(options ...Option) *Pipeline {
+	for _, option := range options {
+		option(p)
+	}
+	return p
+}
+
+// DisableErrorWrapping disables the wrapping of errors that are emitted from pipeline steps.
+// This effectively causes Result.Err to be exactly the error as returned from a step.
+var DisableErrorWrapping Option = func(pipeline *Pipeline) {
+	pipeline.disableErrorWrapping = true
+}

options_test.go

@@ -0,0 +1,14 @@
+package pipeline
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPipeline_WithOptions(t *testing.T) {
+	t.Run("DisableErrorWrapping", func(t *testing.T) {
+		p := NewPipeline().WithOptions(DisableErrorWrapping)
+		assert.True(t, p.disableErrorWrapping)
+	})
+}

pipeline.go

@@ -8,10 +8,11 @@ import (
 type (
 	// Pipeline holds and runs intermediate actions, called "steps".
 	Pipeline struct {
-		steps       []Step
-		context     Context
-		beforeHooks []Listener
-		finalizer   ResultHandler
+		steps                []Step
+		context              Context
+		beforeHooks          []Listener
+		finalizer            ResultHandler
+		disableErrorWrapping bool
 	}
 	// Result is the object that is returned after each step and after running a pipeline.
 	Result struct {
@@ -87,7 +88,7 @@ func (p *Pipeline) WithSteps(steps ...Step) *Pipeline {
 // WithNestedSteps is similar to AsNestedStep, but it accepts the steps given directly as parameters.
 func (p *Pipeline) WithNestedSteps(name string, steps ...Step) Step {
 	return NewStep(name, func(_ Context) Result {
-		nested := &Pipeline{beforeHooks: p.beforeHooks, steps: steps, context: p.context}
+		nested := &Pipeline{beforeHooks: p.beforeHooks, steps: steps, context: p.context, disableErrorWrapping: p.disableErrorWrapping}
 		return nested.Run()
 	})
 }
@@ -145,6 +146,9 @@ func (p *Pipeline) doRun() Result {
 				// Abort pipeline without error
 				return Result{}
 			}
+			if p.disableErrorWrapping {
+				return Result{Err: err}
+			}
 			return Result{Err: fmt.Errorf("step '%s' failed: %w", step.Name, err)}
 		}
 	}