Add immutable stateless default impl of step

- CreateSimpleStep function to create an immutable stateless step

pipeline.go

@@ -45,6 +45,12 @@ A step is a single unit of work. It's an alias for Runnable
 		}
 	}
 
+If your step is completely stateless, you can create an immutable instance through CreateSimpleStep
+
+    step := pipeline.CreateSimpleStep("step_name", func(ctx pipeline.Context) error {
+        // Do stuff.
+    })
+
 Stage
 
 A stage contains a collection of steps. The collection will be executed according to the stage implementation (eg. concurrently, sequentially, condition-based, etc).
@@ -56,7 +62,7 @@ To create one of the already defined stages, we can simply invoke its constructo
 		user.CreateUserStep(userService),
 	)
 
-Since a stage is nothing more than an interface, you can create your own implementations abiding that contract.
+Since a stage is nothing more than an interface, you can create your own custom implementations abiding that contract.
 
 Stage group
 

simple_step.go

@@ -0,0 +1,25 @@
+package pipeline
+
+// Simple step structure. A simple step is a stateless unit of work (just a function to run).
+type simpleStep struct {
+	name string
+	run  func(ctx Context) error
+}
+
+func (s *simpleStep) Name() string {
+	return s.name
+}
+
+func (s *simpleStep) Run(ctx Context) error {
+	return s.run(ctx)
+}
+
+// CreateSimpleStep creates an immutable stateless unit of work based on a function that matches the Runnable contract.
+// You can use this implementation when your use-cases will be completely stateless (they don't rely on a service
+// or anything that can be injected at the start and stay immutable for the lifetime of the process)
+func CreateSimpleStep(name string, run func(ctx Context) error) Step {
+	return &simpleStep{
+		name: name,
+		run:  run,
+	}
+}

simple_step_test.go

@@ -0,0 +1,43 @@
+package pipeline_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/saantiaguilera/go-pipeline"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSimpleStep_GivenAName_WhenGettingItsName_ThenItsTheExpected(t *testing.T) {
+	expectedName := "test_name"
+	step := pipeline.CreateSimpleStep(expectedName, nil)
+
+	name := step.Name()
+
+	assert.Equal(t, expectedName, name)
+}
+
+func TestSimpleStep_GivenARunFunc_WhenRunning_ThenItsCalled(t *testing.T) {
+	called := false
+	run := func(ctx pipeline.Context) error {
+		called = true
+		return nil
+	}
+	step := pipeline.CreateSimpleStep("", run)
+
+	_ = step.Run(nil)
+
+	assert.True(t, called)
+}
+
+func TestSimpleStep_GivenARunFuncThatErrors_WhenRunning_ThenErrorIsReturned(t *testing.T) {
+	expectedErr := errors.New("some error")
+	run := func(ctx pipeline.Context) error {
+		return expectedErr
+	}
+	step := pipeline.CreateSimpleStep("", run)
+
+	err := step.Run(nil)
+
+	assert.Equal(t, expectedErr, err)
+}