teckel 0.7.0 → 0.9.0

data/spec/chain/around_hook_spec.rb

@@ -1,100 +0,0 @@
-# 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/default_settings_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module TeckelChainDefaultSettingsTest
-  class MyOperation
-    include Teckel::Operation
-    result!
-
-    settings Struct.new(:say, :other)
-    settings_constructor ->(data) { settings.new(*data.values_at(*settings.members)) } # ruby 2.4 way for `keyword_init: true`
-
-    input none
-    output Hash
-    error none
-
-    def call(_)
-      success! settings.to_h
-    end
-  end
-
-  class Chain
-    include Teckel::Chain
-
-    default_settings!(a: { say: "Chain Default" })
-
-    step :a, MyOperation
-  end
-end
-
-RSpec.describe Teckel::Chain do
-  specify "call chain without settings, uses default settings" do
-    result = TeckelChainDefaultSettingsTest::Chain.call
-    expect(result.success).to eq(say: "Chain Default", other: nil)
-  end
-
-  specify "call chain with explicit settings, overwrites defaults" do
-    result = TeckelChainDefaultSettingsTest::Chain.with(a: { other: "What" }).call
-    expect(result.success).to eq(say: nil, other: "What")
-  end
-end

data/spec/chain/inheritance_spec.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require 'support/dry_base'
-require 'support/fake_models'
-
-module TeckelChainDefaultsViaBaseClass
-  LOG = [] # rubocop:disable Style/MutableConstant
-
-  class LoggingChain
-    include Teckel::Chain
-
-    around do |chain, input|
-      require 'benchmark'
-      result = nil
-      LOG << Benchmark.measure { result = chain.call(input) }
-      result
-    end
-
-    freeze
-  end
-
-  class OperationA
-    include Teckel::Operation
-
-    result!
-
-    input none
-    output Types::Integer
-    error none
-
-    def call(_)
-      success! rand(1000)
-    end
-
-    finalize!
-  end
-
-  class OperationB
-    include Teckel::Operation
-
-    result!
-
-    input none
-    output Types::String
-    error none
-
-    def call(_)
-      success! ("a".."z").to_a.sample
-    end
-
-    finalize!
-  end
-
-  class ChainA < LoggingChain
-    step :roll, OperationA
-
-    finalize!
-  end
-
-  class ChainB < LoggingChain
-    step :say, OperationB
-
-    finalize!
-  end
-
-  class ChainC < ChainB
-    finalize!
-  end
-end
-
-RSpec.describe Teckel::Chain do
-  before do
-    TeckelChainDefaultsViaBaseClass::LOG.clear
-  end
-
-  let(:base_chain) { TeckelChainDefaultsViaBaseClass::LoggingChain }
-  let(:chain_a) { TeckelChainDefaultsViaBaseClass::ChainA }
-  let(:chain_b) { TeckelChainDefaultsViaBaseClass::ChainB }
-  let(:chain_c) { TeckelChainDefaultsViaBaseClass::ChainC }
-
-  it "inherits config" do
-    expect(chain_a.around)
-    expect(chain_b.around)
-
-    expect(base_chain.steps).to eq([])
-    expect(chain_a.steps.size).to eq(1)
-    expect(chain_b.steps.size).to eq(1)
-  end
-
-  it "runs chain a" do
-    expect {
-      result = chain_a.call
-      expect(result.success).to be_a(Integer)
-    }.to change {
-      TeckelChainDefaultsViaBaseClass::LOG.size
-    }.from(0).to(1)
-  end
-
-  it "runs chain b" do
-    expect {
-      result = chain_b.call
-      expect(result.success).to be_a(String)
-    }.to change {
-      TeckelChainDefaultsViaBaseClass::LOG.size
-    }.from(0).to(1)
-  end
-
-  it "inherits steps" do
-    expect {
-      result = chain_c.call
-      expect(result.success).to be_a(String)
-    }.to change {
-      TeckelChainDefaultsViaBaseClass::LOG.size
-    }.from(0).to(1)
-  end
-end

data/spec/chain/none_input_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module TeckelChainNoneInputTest
-  class MyOperation
-    include Teckel::Operation
-    result!
-
-    settings Struct.new(:say)
-
-    input none
-    output String
-    error none
-
-    def call(_)
-      success!(settings&.say || "Called")
-    end
-  end
-
-  class Chain
-    include Teckel::Chain
-
-    step :a, MyOperation
-  end
-end
-
-RSpec.describe Teckel::Chain do
-  specify "call chain without input value" do
-    result = TeckelChainNoneInputTest::Chain.call
-    expect(result.success).to eq("Called")
-  end
-
-  specify "call chain runner without input value" do
-    result = TeckelChainNoneInputTest::Chain.with(a: "What").call
-    expect(result.success).to eq("What")
-  end
-end

data/spec/chain/results_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'support/dry_base'
-require 'support/fake_models'
-
-module TeckelChainResultTest
-  class Message
-    include ::Teckel::Operation
-
-    result!
-
-    input Types::Hash.schema(message: Types::String)
-    error none
-    output Types::String
-
-    def call(input)
-      success! input[:message].upcase
-    end
-  end
-
-  class Chain
-    include Teckel::Chain
-
-    step :message, Message
-
-    class Result < Teckel::Operation::Result
-      def initialize(value, success, step, opts = {})
-        super(value, success)
-        @step = step
-        @opts = opts
-      end
-
-      class << self
-        alias :[] :new # Alias the default constructor to :new
-      end
-
-      attr_reader :opts, :step
-    end
-
-    result_constructor ->(value, success, step) {
-      result.new(value, success, step, time: Time.now.to_i)
-    }
-  end
-end
-
-RSpec.describe Teckel::Chain do
-  specify do
-    result = TeckelChainResultTest::Chain.call(message: "Hello World!")
-    expect(result).to be_successful
-    expect(result.success).to eq("HELLO WORLD!")
-    expect(result.opts).to include(time: kind_of(Integer))
-  end
-end

data/spec/chain_spec.rb

@@ -1,180 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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

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

data/spec/operation/contract_trace_spec.rb

@@ -1,116 +0,0 @@
-# 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