teckel 0.1.0 → 0.6.0

data/spec/chain_around_hook_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'support/dry_base'
+require 'support/fake_db'
+require 'support/fake_models'
+
+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
+
+    result!
+
+    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)
+
+    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
+
+    around ->(chain, input) {
+      result = nil
+      begin
+        TeckelChainAroundHookTest.stack << :before
+
+        FakeDB.transaction do
+          result = chain.call(input)
+          raise FakeDB::Rollback if result.failure?
+        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
+    it "result matches" do
+      result = TeckelChainAroundHookTest::Chain.call(name: "Bob", age: 23)
+      expect(result.success).to include(user: kind_of(User), friend: kind_of(User))
+    end
+
+    it "runs around hook" do
+      TeckelChainAroundHookTest::Chain.call(name: "Bob", age: 23)
+      expect(TeckelChainAroundHookTest.stack).to eq([:before, :after])
+    end
+  end
+
+  context "failure" do
+    it "runs around hook" do
+      TeckelChainAroundHookTest::Chain.
+        with(befriend: :fail).
+        call(name: "Bob", age: 23)
+      expect(TeckelChainAroundHookTest.stack).to eq([:before])
+    end
+  end
+end

data/spec/chain_spec.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'support/dry_base'
+require 'support/fake_models'
+
+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
+
+    result!
+
+    input Types.Instance(User)
+    error none
+    output input
+
+    def call(usr)
+      Logger.new(File::NULL).info("User #{usr.name} created")
+      success! usr
+    end
+  end
+
+  class AddFriend
+    include ::Teckel::Operation
+
+    result!
+
+    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)
+
+    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
+
+    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
+
+  it 'Chain output points to last steps output' do
+    expect(TeckelChainTest::Chain.output).to eq(TeckelChainTest::AddFriend.output)
+  end
+
+  it 'Chain errors maps all step errors' do
+    expect(TeckelChainTest::Chain.errors).to eq([
+      TeckelChainTest::CreateUser.error,
+      Teckel::Contracts::None,
+      TeckelChainTest::AddFriend.error
+    ])
+  end
+
+  context "success" do
+    it "result matches" do
+      result =
+        TeckelChainTest::Chain.
+        with(befriend: nil).
+        call(name: "Bob", age: 23)
+
+      expect(result.success).to include(user: kind_of(User), friend: kind_of(User))
+    end
+  end
+
+  context "failure" do
+    it "returns a Result for invalid input" do
+      result =
+        TeckelChainTest::Chain.
+        with(befriend: :fail).
+        call(name: "Bob", age: 0)
+
+      expect(result).to be_a(Teckel::Chain::Result)
+      expect(result).to be_failure
+      expect(result.step).to eq(:create)
+      expect(result.value).to eq(errors: [{ age: "underage" }], message: "Could not save User")
+    end
+
+    it "returns a Result for failed step" do
+      result =
+        TeckelChainTest::Chain.
+        with(befriend: :fail).
+        call(name: "Bob", age: 23)
+
+      expect(result).to be_a(Teckel::Chain::Result)
+      expect(result).to be_failure
+      expect(result.step).to eq(:befriend)
+      expect(result.value).to eq(message: "Did not find a friend.")
+    end
+  end
+
+  describe "#finalize!" do
+    let(:frozen_error) do
+      # different ruby versions raise different errors
+      defined?(FrozenError) ? FrozenError : RuntimeError
+    end
+
+    subject { TeckelChainTest::Chain.dup }
+
+    it "freezes the Chain class and operation classes" do
+      subject.finalize!
+
+      steps = subject.steps
+      expect(steps).to be_frozen
+      expect(steps).to all be_frozen
+    end
+
+    it "disallows adding new steps" do
+      subject.class_eval do
+        step :other, TeckelChainTest::AddFriend
+      end
+
+      subject.finalize!
+
+      expect {
+        subject.class_eval do
+          step :yet_other, TeckelChainTest::AddFriend
+        end
+      }.to raise_error(frozen_error)
+    end
+
+    it "disallows changing around hook" do
+      subject.class_eval do
+        around ->{}
+      end
+
+      chain2 = TeckelChainTest::Chain.dup.finalize!
+      expect {
+        chain2.class_eval do
+          around ->{}
+        end
+      }.to raise_error(frozen_error)
+    end
+
+    it "runs" do
+      subject.finalize!
+
+      result = subject.call(name: "Bob", age: 23)
+      expect(result.success).to include(user: kind_of(User), friend: kind_of(User))
+    end
+
+    it "accepts mocks" do
+      subject.finalize!
+
+      allow(subject).to receive(:call) { :mocked }
+      expect(subject.call).to eq(:mocked)
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'support/dry_base'
+require 'support/fake_models'
+
+RSpec.describe Teckel::Config do
+  let(:sample_config) do
+    Teckel::Config.new
+  end
+
+  it "set and retrieve key" do
+    sample_config.for(:some_key, "some_value")
+    expect(sample_config.for(:some_key)).to eq("some_value")
+  end
+
+  it "allow default value via block" do
+    expect(sample_config.for(:some_key) { "default" }).to eq("default")
+    # and sets the block value
+    expect(sample_config.for(:some_key)).to eq("default")
+  end
+
+  it "raises FrozenConfigError when setting a key twice" do
+    sample_config.for(:some_key, "some_value")
+    expect { sample_config.for(:some_key, "other_value") }.to raise_error(Teckel::FrozenConfigError)
+  end
+end

data/spec/doctest_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'support/dry_base'
+require_relative 'support/fake_db'
+require_relative 'support/fake_models'
+
+require "teckel"

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module TeckelOperationDefaultSettings
+  class BaseOperation
+    include ::Teckel::Operation
+
+    input none
+    output Symbol
+    error none
+
+    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 }
+
+      it "with no settings" do
+        expect(subject.call).to eq(:default_value)
+      end
+
+      it "with settings" do
+        expect(subject.with(:injected_value).call).to eq(:injected_value)
+      end
+    end
+
+    describe "with default constructor and clever Settings class" do
+      it_behaves_like(
+        "operation with default settings",
+        Class.new(TeckelOperationDefaultSettings::BaseOperation) do
+          settings(Class.new do
+            def initialize(injected = nil)
+              @injected = injected
+            end
+
+            def injected
+              @injected || :default_value
+            end
+
+            class << self
+              alias :[] :new # make us respond to the default constructor
+            end
+          end)
+
+          default_settings!
+        end
+      )
+    end
+
+    describe "with custom constructor and clever Settings class" do
+      it_behaves_like(
+        "operation with default settings",
+        Class.new(TeckelOperationDefaultSettings::BaseOperation) do
+          settings(Class.new do
+            def initialize(injected = nil)
+              @injected = injected
+            end
+
+            def injected
+              @injected || :default_value
+            end
+          end)
+
+          settings_constructor :new
+          default_settings!
+        end
+      )
+    end
+
+    describe "with default constructor and simple Settings class" do
+      it_behaves_like(
+        "operation with default settings",
+        Class.new(TeckelOperationDefaultSettings::BaseOperation) do
+          settings Struct.new(:injected)
+
+          default_settings! -> { settings.new(:default_value) }
+        end
+      )
+
+      it_behaves_like(
+        "operation with default settings",
+        Class.new(TeckelOperationDefaultSettings::BaseOperation) do
+          settings Struct.new(:injected)
+
+          default_settings!(:default_value)
+        end
+      )
+    end
+  end
+end