rung 0.0.1.pre.alpha → 0.1

data/features/040_failure_step.feature

@@ -0,0 +1,118 @@
+# order: 40
+Feature: Failure Step
+:!hardbreaks:
+When operations fails next normal steps are no ignored and not executed.
+
+There's a way to react to a failure with special failure steps.
+
+Failure steps can be defined similarly to normal steps (as a block, method, or a callable object).
+They are *only* executed when operation has failed.
+
+  Scenario: Failure step is executed when operation fails
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      step do
+        print_to_output "Working..."
+        # something went wrong...
+        false
+      end
+
+      failure do
+        print_to_output " Oops!"
+      end
+
+      step do
+        print_to_output "This won't be executed"
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call
+    """
+    Then I see output
+    """
+    Working... Oops!
+    """
+
+  Scenario: Failure step is not executed when operation doesn't fail
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      step do
+        print_to_output "Working..."
+        # everything's fine
+        true
+      end
+
+      failure do
+        print_to_output " Oops!"
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call
+    """
+    Then I see output
+    """
+    Working...
+    """
+
+  Scenario: It's possible to define multiple failure steps
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      step do |state|
+        print_to_output "Working..."
+        # something went wrong...
+        state[:error] = "404"
+        false
+      end
+
+      failure do
+        print_to_output " Error: "
+      end
+
+      failure do |state|
+        print_to_output state[:error]
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call
+    """
+    Then I see output
+    """
+    Working... Error: 404
+    """
+
+  Scenario: Failure step is executed only when it's defined after failed step
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      failure do
+        print_to_output "Something's wrong"
+      end
+
+      step do
+        print_to_output "Working..."
+        # something went wrong...
+        false
+      end
+
+      failure do
+        print_to_output " Oops!"
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call
+    """
+    Then I see output
+    """
+    Working... Oops!
+    """

data/features/050_other_steps.feature

@@ -0,0 +1,135 @@
+# order: 50
+Feature: Other steps
+:!hardbreaks:
+
+`step` and `failure` are the basic step types.
+For the convenience there are also two additional step
+types defined:
+
+* `tee` - works the same way as `step` but ignores the return value
+* `always` - executes on both success and failure. Return value is not checked
+
+.Table Step behaviours
+|===
+|Step name|Execute on success|Execute on failure|Ignore return value
+
+|step|✓|✗|✗
+|failure|✗|✓|✓
+|tee|✓|✗|✓
+|always|✓|✓|✓
+
+  Scenario: `tee` step result is not checked
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      tee do
+        print_to_output "Hello "
+        false
+      end
+
+      step do
+        print_to_output "World!"
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call
+    """
+    Then I see output
+    """
+    Hello World!
+    """
+
+  Scenario: `tee` is not executed when operation is failed
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      step do
+        print_to_output "Hello"
+        false # fail
+      end
+
+      tee do
+        print_to_output "World!"
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call
+    """
+    Then I see output
+    """
+    Hello
+    """
+
+
+  Scenario: `always` is called when operation is successful
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      step do
+        print_to_output "Hello "
+      end
+
+      always do
+        print_to_output "World!"
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call
+    """
+    Then I see output
+    """
+    Hello World!
+    """
+
+  Scenario: `always` is called when operation is failed
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      step do
+        print_to_output "Hello "
+        false # fail
+      end
+
+      always do
+        print_to_output "World!"
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call
+    """
+    Then I see output
+    """
+    Hello World!
+    """
+
+  Scenario: state object provides information about operation success with `success?` and `fail?`
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      step do
+        print_to_output "Hello"
+        false # fail
+      end
+
+      always do |state|
+        print_to_output " World!" if state.success?
+        print_to_output " There!" if state.fail?
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call
+    """
+    Then I see output
+    """
+    Hello There!
+    """

data/features/051_fail_fast.feature

@@ -0,0 +1,66 @@
+# order: 51
+Feature: Fail fast
+:!hardbreaks:
+When a fail-fast step is executed and the operation is a failure then
+no next step is executed, including `always` and `failure` steps.
+
+It doesn't matter if a failure is caused by the fail-fast step itself or if it
+was caused by any previous step, it behaves the same way.
+
+  Scenario: When step with `fail_fast` fails the execution is immediately stopped
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      step(fail_fast: true) do
+        print_to_output "Hello"
+        false
+      end
+
+      step do
+        print_to_output " World!"
+      end
+    end
+    """
+    When I run
+    """
+    @result = Operation.new.call
+    """
+    Then I see output
+    """
+    Hello
+    """
+    And I can assure that
+    """
+    @result.failure?
+    """
+
+  Scenario: Any kind of step can use `fail_fast`
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      step do
+        print_to_output "Hello"
+        false
+      end
+
+      failure fail_fast: true do
+        print_to_output "...Goodbye!"
+      end
+
+      step do
+        print_to_output " World!"
+      end
+    end
+    """
+    When I run
+    """
+    @result = Operation.new.call
+    """
+    Then I see output
+    """
+    Hello...Goodbye!
+    """
+    And I can assure that
+    """
+    @result.failure?
+    """

data/features/060_step_wrappers.feature

@@ -0,0 +1,170 @@
+# order: 60
+Feature: Step wrappers
+:!hardbreaks:
+It's possible to step around a group of successive steps.
+This is a common use case for surrounding multiple steps in
+a database transaction and rolling back when steps inside fail.
+
+Steps wrapper is defined as a step (of any type, e.g. `step` or `tee`)
+with callable wrapper-action and additional
+block defining nested steps.
+
+Wrapper-action is a Callable or method name.
+
+Yielding the block calls inner steps. Yield returns `false` if
+any of the inner steps failed or `true` otherwise.
+
+Example usage:
+```ruby
+class Operation < Rung::Operation
+  class TransactionWrapper
+    def self.call(state)
+      return if state.fail?
+      ActiveRecord::Base.transaction do
+        success = yield
+        raise ActiveRecord::Rollback unless success
+        true
+      end
+    end
+  end
+
+  step TransactionWrapper do
+    step :create_new_entity
+    step :update_counter
+  end
+end
+```
+
+  Scenario: Wrapper can yield to execute inner steps
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      class Wrapper
+        def self.call
+          print_to_output "Starting\n"
+          success = yield
+          if success
+            print_to_output "\nSuccess!"
+          else
+            print_to_output "\nFailure!"
+          end
+        end
+      end
+
+      step Wrapper do
+        step { print_to_output "Hello " }
+        step do |state|
+          print_to_output "World!"
+          state[:variable] # return variable passed by the user
+        end
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call(variable: true)
+    """
+    Then I see output
+    """
+    Starting
+    Hello World!
+    Success!
+    """
+    Then I clear output
+    When I run
+    """
+    Operation.new.call(variable: false)
+    """
+    Then I see output
+    """
+    Starting
+    Hello World!
+    Failure!
+    """
+
+  Scenario: Wrappers can be nested
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      class Wrapper
+        def initialize(name)
+          @name = name
+        end
+
+        def call
+          print_to_output "Starting #{@name}\n"
+          yield
+          print_to_output "Finishing #{@name}\n"
+        end
+      end
+
+      step Wrapper.new("first") do
+        step { print_to_output "Hello\n" }
+        step Wrapper.new("second") do
+          step { print_to_output "Hi\n" }
+        end
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call
+    """
+    Then I see output
+    """
+    Starting first
+    Hello
+    Starting second
+    Hi
+    Finishing second
+    Finishing first
+
+    """
+
+  Scenario: step type is important when calling a wrapper
+    Given definition
+    """ruby
+    class Operation < Rung::Operation
+      class Wrapper
+        def initialize(name)
+          @name = name
+        end
+
+        def call
+          print_to_output "from: #{@name}\n"
+          yield
+        end
+      end
+
+      step do
+        print_to_output "RED ALERT\n"
+        false
+      end
+
+      step Wrapper.new("OK") do
+        step { print_to_output "Hurray!\n" }
+      end
+
+      failure Wrapper.new("FAIL") do
+        failure { print_to_output "Oops!\n" }
+      end
+
+      always Wrapper.new("ALWAYS") do
+        step { print_to_output "We're done!\n" }
+        failure { print_to_output "We're done, but something went wrong!\n" }
+      end
+    end
+    """
+    When I run
+    """
+    Operation.new.call(variable: true)
+    """
+    Then I see output
+    """
+    RED ALERT
+    from: FAIL
+    Oops!
+    from: ALWAYS
+    We're done, but something went wrong!
+
+    """