teckel 0.5.0 → 0.6.0

data/spec/chain_around_hook_spec.rb

@@ -4,77 +4,77 @@ require 'support/dry_base'
 require 'support/fake_db'
 require 'support/fake_models'
 
-RSpec.describe Teckel::Chain do
-  module TeckelChainAroundHookTest
-    class CreateUser
-      include ::Teckel::Operation
-
-      result!
-
-      input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer.optional)
-      output Types.Instance(User)
-      error  Types::Hash.schema(message: Types::String, errors: Types::Array.of(Types::Hash))
-
-      def call(input)
-        user = User.new(name: input[:name], age: input[:age])
-        if user.save
-          success!(user)
-        else
-          fail!(message: "Could not safe User", errors: user.errors)
-        end
+module TeckelChainAroundHookTest
+  class CreateUser
+    include ::Teckel::Operation
+
+    result!
+
+    input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer.optional)
+    output Types.Instance(User)
+    error  Types::Hash.schema(message: Types::String, errors: Types::Array.of(Types::Hash))
+
+    def call(input)
+      user = User.new(name: input[:name], age: input[:age])
+      if user.save
+        success!(user)
+      else
+        fail!(message: "Could not safe User", errors: user.errors)
       end
     end
+  end
 
-    class AddFriend
-      include ::Teckel::Operation
+  class AddFriend
+    include ::Teckel::Operation
 
-      result!
+    result!
 
-      settings Struct.new(:fail_befriend)
+    settings Struct.new(:fail_befriend)
 
-      input Types.Instance(User)
-      output Types::Hash.schema(user: Types.Instance(User), friend: Types.Instance(User))
-      error  Types::Hash.schema(message: Types::String)
+    input Types.Instance(User)
+    output Types::Hash.schema(user: Types.Instance(User), friend: Types.Instance(User))
+    error  Types::Hash.schema(message: Types::String)
 
-      def call(user)
-        if settings&.fail_befriend
-          fail!(message: "Did not find a friend.")
-        else
-          { user: user, friend: User.new(name: "A friend", age: 42) }
-        end
+    def call(user)
+      if settings&.fail_befriend
+        fail!(message: "Did not find a friend.")
+      else
+        success! user: user, friend: User.new(name: "A friend", age: 42)
       end
     end
+  end
 
-    @stack = []
-    def self.stack
-      @stack
-    end
-
-    class Chain
-      include Teckel::Chain
+  @stack = []
+  def self.stack
+    @stack
+  end
 
-      around ->(chain, input) {
-        result = nil
-        begin
-          TeckelChainAroundHookTest.stack << :before
+  class Chain
+    include Teckel::Chain
 
-          FakeDB.transaction do
-            result = chain.call(input)
-            raise FakeDB::Rollback if result.failure?
-          end
+    around ->(chain, input) {
+      result = nil
+      begin
+        TeckelChainAroundHookTest.stack << :before
 
-          TeckelChainAroundHookTest.stack << :after
-          result
-        rescue FakeDB::Rollback
-          result
+        FakeDB.transaction do
+          result = chain.call(input)
+          raise FakeDB::Rollback if result.failure?
         end
-      }
 
-      step :create, CreateUser
-      step :befriend, AddFriend
-    end
+        TeckelChainAroundHookTest.stack << :after
+        result
+      rescue FakeDB::Rollback
+        result
+      end
+    }
+
+    step :create, CreateUser
+    step :befriend, AddFriend
   end
+end
 
+RSpec.describe Teckel::Chain do
   before { TeckelChainAroundHookTest.stack.clear }
 
   context "success" do

data/spec/chain_spec.rb

@@ -3,70 +3,70 @@
 require 'support/dry_base'
 require 'support/fake_models'
 
-RSpec.describe Teckel::Chain do
-  module TeckelChainTest
-    class CreateUser
-      include ::Teckel::Operation
-      result!
-
-      input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer.optional)
-      output Types.Instance(User)
-      error  Types::Hash.schema(message: Types::String, errors: Types::Array.of(Types::Hash))
-
-      def call(input)
-        user = User.new(name: input[:name], age: input[:age])
-        if user.save
-          success!(user)
-        else
-          fail!(message: "Could not save User", errors: user.errors)
-        end
+module TeckelChainTest
+  class CreateUser
+    include ::Teckel::Operation
+    result!
+
+    input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer.optional)
+    output Types.Instance(User)
+    error  Types::Hash.schema(message: Types::String, errors: Types::Array.of(Types::Hash))
+
+    def call(input)
+      user = User.new(name: input[:name], age: input[:age])
+      if user.save
+        success!(user)
+      else
+        fail!(message: "Could not save User", errors: user.errors)
       end
     end
+  end
 
-    class LogUser
-      include ::Teckel::Operation
+  class LogUser
+    include ::Teckel::Operation
 
-      result!
+    result!
 
-      input Types.Instance(User)
-      error none
-      output input
+    input Types.Instance(User)
+    error none
+    output input
 
-      def call(usr)
-        Logger.new(File::NULL).info("User #{usr.name} created")
-        usr
-      end
+    def call(usr)
+      Logger.new(File::NULL).info("User #{usr.name} created")
+      success! usr
     end
+  end
 
-    class AddFriend
-      include ::Teckel::Operation
+  class AddFriend
+    include ::Teckel::Operation
 
-      result!
+    result!
 
-      settings Struct.new(:fail_befriend)
+    settings Struct.new(:fail_befriend)
 
-      input Types.Instance(User)
-      output Types::Hash.schema(user: Types.Instance(User), friend: Types.Instance(User))
-      error  Types::Hash.schema(message: Types::String)
+    input Types.Instance(User)
+    output Types::Hash.schema(user: Types.Instance(User), friend: Types.Instance(User))
+    error  Types::Hash.schema(message: Types::String)
 
-      def call(user)
-        if settings&.fail_befriend
-          fail!(message: "Did not find a friend.")
-        else
-          { user: user, friend: User.new(name: "A friend", age: 42) }
-        end
+    def call(user)
+      if settings&.fail_befriend
+        fail!(message: "Did not find a friend.")
+      else
+        success! user: user, friend: User.new(name: "A friend", age: 42)
       end
     end
+  end
 
-    class Chain
-      include Teckel::Chain
+  class Chain
+    include Teckel::Chain
 
-      step :create, CreateUser
-      step :log, LogUser
-      step :befriend, AddFriend
-    end
+    step :create, CreateUser
+    step :log, LogUser
+    step :befriend, AddFriend
   end
+end
 
+RSpec.describe Teckel::Chain do
   it 'Chain input points to first step input' do
     expect(TeckelChainTest::Chain.input).to eq(TeckelChainTest::CreateUser.input)
   end

data/spec/operation/contract_trace_spec.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'support/dry_base'
+
+module TeckelOperationContractTrace
+  DefaultError = Struct.new(:message, :status_code)
+  Settings = Struct.new(:fail_it)
+
+  class ApplicationOperation
+    include Teckel::Operation
+
+    class Input < Dry::Struct
+      attribute :input_data, Types::String
+    end
+
+    class Output < Dry::Struct
+      attribute :output_data, Types::String
+    end
+
+    class Error < Dry::Struct
+      attribute :error_data, Types::String
+    end
+
+    # Freeze the base class to make sure it's inheritable configuration is not altered
+    freeze
+  end
+end
+
+# Hack to get reliable stack traces
+eval <<~RUBY, binding, "operation_success_error.rb"
+  module TeckelOperationContractTrace
+    class OperationSuccessError < ApplicationOperation
+      # Includes a deliberate bug while crating a success output
+      def call(input)
+        success!(incorrect_key: 1)
+      end
+    end
+  end
+RUBY
+
+eval <<~RUBY, binding, "operation_simple_success_error.rb"
+  module TeckelOperationContractTrace
+    class OperationSimpleSuccessNil < ApplicationOperation
+      # Includes a deliberate bug while crating a success output
+      def call(input)
+        return { incorrect_key: 1 }
+      end
+    end
+  end
+RUBY
+
+eval <<~RUBY, binding, "operation_failure_error.rb"
+  module TeckelOperationContractTrace
+    class OperationFailureError < ApplicationOperation
+      # Includes a deliberate bug while crating an error output
+      def call(input)
+        fail!(incorrect_key: 1)
+      end
+    end
+  end
+RUBY
+
+eval <<~RUBY, binding, "operation_ok.rb"
+  module TeckelOperationContractTrace
+    class OperationOk < ApplicationOperation
+      def call(input)
+        success!(output_data: "all fine")
+      end
+    end
+  end
+RUBY
+
+eval <<~RUBY, binding, "operation_input_error.rb"
+  module TeckelOperationContractTrace
+    def self.run_operation(operation)
+      operation.call(error_input_data: "failure")
+    end
+  end
+RUBY
+
+RSpec.describe Teckel::Operation do
+  context "contract errors include meaningful trace" do
+    specify "incorrect success" do
+      expect {
+        TeckelOperationContractTrace::OperationSuccessError.call(input_data: "ok")
+      }.to raise_error(Dry::Struct::Error) { |error|
+        expect(error.backtrace).to include /^#{Regexp.escape("operation_success_error.rb:5:in `call'")}$/
+      }
+    end
+
+    specify "incorrect success via simple return results in +nil+, but no meaningful trace" do
+      expect(
+        TeckelOperationContractTrace::OperationSimpleSuccessNil.call(input_data: "ok")
+      ).to be_nil
+    end
+
+    specify "incorrect fail" do
+      expect {
+        TeckelOperationContractTrace::OperationFailureError.call(input_data: "ok")
+      }.to raise_error(Dry::Struct::Error) { |error|
+        expect(error.backtrace).to include /^#{Regexp.escape("operation_failure_error.rb:5:in `call'")}$/
+      }
+    end
+
+    specify "incorrect input" do
+      operation = TeckelOperationContractTrace::OperationOk
+
+      expect(operation.call(input_data: "ok")).to eq(operation.output[output_data: "all fine"])
+      expect {
+        TeckelOperationContractTrace.run_operation(operation)
+      }.to raise_error(Dry::Struct::Error) { |error|
+        expect(error.backtrace).to include /^#{Regexp.escape("operation_input_error.rb:3:in `run_operation'")}$/
+      }
+    end
+  end
+end

data/spec/operation/default_settings_spec.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-RSpec.describe Teckel::Operation do
-  context "default settings" do
-    module TeckelOperationDefaultSettings
-      class BaseOperation
-        include ::Teckel::Operation
+module TeckelOperationDefaultSettings
+  class BaseOperation
+    include ::Teckel::Operation
 
-        input none
-        output Symbol
-        error none
+    input none
+    output Symbol
+    error none
 
-        def call(_input)
-          success! settings.injected
-        end
-      end
+    def call(_input)
+      success! settings.injected
     end
+  end
+end
 
+RSpec.describe Teckel::Operation do
+  context "default settings" do
     shared_examples "operation with default settings" do |operation|
       subject { operation }
 

data/spec/operation/inheritance_spec.rb

@@ -1,57 +1,57 @@
 # frozen_string_literal: true
 
-RSpec.describe Teckel::Operation do
-  context "default settings via base class" do
-    module TeckelOperationDefaultsViaBaseClass
-      DefaultError = Struct.new(:message, :status_code)
-      Settings = Struct.new(:fail_it)
-
-      class ApplicationOperation
-        include Teckel::Operation
+module TeckelOperationDefaultsViaBaseClass
+  DefaultError = Struct.new(:message, :status_code)
+  Settings = Struct.new(:fail_it)
 
-        settings Settings
-        settings_constructor ->(data) { settings.new(*data.values_at(*settings.members)) }
+  class ApplicationOperation
+    include Teckel::Operation
 
-        error DefaultError
-        error_constructor ->(data) { error.new(*data.values_at(*error.members)) }
+    settings Settings
+    settings_constructor ->(data) { settings.new(*data.values_at(*settings.members)) }
 
-        result!
+    error DefaultError
+    error_constructor ->(data) { error.new(*data.values_at(*error.members)) }
 
-        # Freeze the base class to make sure it's inheritable configuration is not altered
-        freeze
-      end
+    result!
 
-      class OperationA < ApplicationOperation
-        input Struct.new(:input_data_a)
-        output Struct.new(:output_data_a)
+    # Freeze the base class to make sure it's inheritable configuration is not altered
+    freeze
+  end
 
-        def call(input)
-          if settings&.fail_it
-            fail!(message: settings.fail_it, status_code: 400)
-          else
-            input.input_data_a * 2
-          end
-        end
+  class OperationA < ApplicationOperation
+    input Struct.new(:input_data_a)
+    output Struct.new(:output_data_a)
 
-        finalize!
+    def call(input)
+      if settings&.fail_it
+        fail!(message: settings.fail_it, status_code: 400)
+      else
+        success!(input.input_data_a * 2)
       end
+    end
 
-      class OperationB < ApplicationOperation
-        input Struct.new(:input_data_b)
-        output Struct.new(:output_data_b)
+    finalize!
+  end
 
-        def call(input)
-          if settings&.fail_it
-            fail!(message: settings.fail_it, status_code: 500)
-          else
-            input.input_data_b * 4
-          end
-        end
+  class OperationB < ApplicationOperation
+    input Struct.new(:input_data_b)
+    output Struct.new(:output_data_b)
 
-        finalize!
+    def call(input)
+      if settings&.fail_it
+        fail!(message: settings.fail_it, status_code: 500)
+      else
+        success!(input.input_data_b * 4)
       end
     end
 
+    finalize!
+  end
+end
+
+RSpec.describe Teckel::Operation do
+  context "default settings via base class" do
     let(:operation_a) { TeckelOperationDefaultsViaBaseClass::OperationA }
     let(:operation_b) { TeckelOperationDefaultsViaBaseClass::OperationB }