teckel 0.8.0 → 0.9.0

data/spec/chain_spec.rb

@@ -1,255 +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
-  let(:frozen_error) do
-    # different ruby versions raise different errors
-    defined?(FrozenError) ? FrozenError : RuntimeError
-  end
-
-  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
-    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
-
-  describe "#clone" do
-    subject { TeckelChainTest::Chain.dup }
-    let(:klone) { subject.clone }
-
-    it 'clones' do
-      expect(klone.object_id).not_to be_eql(subject.object_id)
-    end
-
-    it 'clones config' do
-      orig_config = subject.instance_variable_get(:@config)
-      klone_config = klone.instance_variable_get(:@config)
-      expect(klone_config.object_id).not_to be_eql(orig_config.object_id)
-    end
-
-    it 'clones steps' do
-      orig_settings = subject.instance_variable_get(:@config).instance_variable_get(:@config)[:steps]
-      klone_settings = klone.instance_variable_get(:@config).instance_variable_get(:@config)[:steps]
-
-      expect(orig_settings).to be_a(Array)
-      expect(klone_settings).to be_a(Array)
-      expect(klone_settings.object_id).not_to be_eql(orig_settings.object_id)
-    end
-  end
-
-  describe "frozen" do
-    subject { TeckelChainTest::Chain.dup }
-
-    it "also freezes the config" do
-      expect { subject.freeze }.to change {
-        [
-          subject.frozen?,
-          subject.instance_variable_get(:@config).frozen?
-        ]
-      }.from([false, false]).to([true, true])
-    end
-
-    it "prevents changes to steps" do
-      subject.freeze
-      expect {
-        subject.class_eval do
-          step :yet_other, TeckelChainTest::AddFriend
-        end
-      }.to raise_error(frozen_error)
-    end
-
-    it "prevents changes to config" do
-      subject.freeze
-      expect {
-        subject.class_eval do
-          default_settings!(a: { say: "Chain Default" })
-        end
-      }.to raise_error(frozen_error)
-    end
-
-    describe '#clone' do
-      subject { TeckelChainTest::Chain.dup }
-
-      it 'clones the class' do
-        subject.freeze
-        klone = subject.clone
-
-        expect(klone).to be_frozen
-        expect(klone.object_id).not_to be_eql(subject.object_id)
-      end
-
-      it 'cloned class uses the same, frozen config' do
-        subject.freeze
-        klone = subject.clone
-
-        orig_config = subject.instance_variable_get(:@config)
-        klone_config = klone.instance_variable_get(:@config)
-
-        expect(klone_config).to be_frozen
-        expect(klone_config.object_id).to be_eql(orig_config.object_id)
-      end
-    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/config_spec.rb

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-
-require "ostruct"
-
-RSpec.describe Teckel::Operation do
-  let(:operation) do
-    Class.new do
-      include Teckel::Operation
-      input none
-      output ->(o) { o }
-      error none
-
-      def call(_)
-        success! settings
-      end
-    end
-  end
-
-  let(:blank_operation) do
-    Class.new do
-      include Teckel::Operation
-    end
-  end
-
-  describe ".settings" do
-    specify "no settings" do
-      expect(operation.settings).to eq(Teckel::Contracts::None)
-      expect(operation.settings_constructor).to eq(Teckel::Contracts::None.method(:new))
-    end
-
-    specify "with settings klass" do
-      settings_klass = Struct.new(:name)
-      operation.settings(settings_klass)
-      expect(operation.settings).to eq(settings_klass)
-    end
-
-    specify "without settings class, with settings constructor as proc" do
-      settings_const = if RUBY_VERSION < '2.6.0'
-        ->(sets) { sets.map { |k, v| [k.to_s, v.to_i] }.to_h }
-      else
-        ->(sets) { sets.to_h { |k, v| [k.to_s, v.to_i] } }
-      end
-
-      operation.settings_constructor(settings_const)
-
-      expect(operation.settings).to eq(Teckel::Contracts::None)
-      expect(operation.settings_constructor).to eq(settings_const)
-
-      runner = operation.with(key: "1")
-      expect(runner).to be_a(Teckel::Operation::Runner)
-      expect(runner.settings).to eq({ "key" => 1 })
-    end
-
-    specify "with settings class, with settings constructor as symbol" do
-      settings_klass = Struct.new(:name) do
-        def self.make_one(opts)
-          new(opts[:name])
-        end
-      end
-
-      operation.settings(settings_klass)
-      operation.settings_constructor(:make_one)
-
-      expect(operation.settings).to eq(settings_klass)
-      expect(operation.settings_constructor).to eq(settings_klass.method(:make_one))
-
-      runner = operation.with(name: "value")
-      expect(runner).to be_a(Teckel::Operation::Runner)
-      expect(runner.settings).to be_a(settings_klass)
-      expect(runner.settings.name).to eq("value")
-    end
-
-    specify "with settings class as constant" do
-      settings_klass = Struct.new(:name)
-      operation.const_set(:Settings, settings_klass)
-
-      expect(operation.settings).to eq(settings_klass)
-      expect(operation.settings_constructor).to eq(settings_klass.method(:[]))
-    end
-  end
-
-  describe ".default_settings" do
-    specify "no default_settings" do
-      expect(operation.default_settings).to be_nil
-      expect(operation.runner).to receive(:new).with(operation).and_call_original
-
-      operation.call
-    end
-
-    specify "default_settings!() with no default_settings" do
-      operation.default_settings!
-      expect(operation.default_settings).to be_a(Proc)
-
-      expect(operation.default_settings).to receive(:call).with(no_args).and_wrap_original do |original_method, *args, &block|
-        settings = original_method.call(*args, &block)
-        expect(settings).to be_nil
-        expect(operation.runner).to receive(:new).with(operation, settings).and_call_original
-        settings
-      end
-
-      operation.call
-    end
-
-    specify "default_settings!() with default_settings" do
-      settings_klass = Struct.new(:name)
-
-      operation.settings(settings_klass)
-      operation.default_settings!
-
-      expect(operation.default_settings).to be_a(Proc)
-
-      expect(operation.default_settings).to receive(:call).with(no_args).and_wrap_original do |original_method, *args, &block|
-        settings = original_method.call(*args, &block)
-        expect(settings).to be_a(settings_klass).and have_attributes(name: nil)
-        expect(operation.runner).to receive(:new).with(operation, settings).and_call_original
-        settings
-      end
-
-      operation.call
-    end
-
-    specify "default_settings!(arg) with default_settings" do
-      settings_klass = Struct.new(:name)
-
-      operation.settings(settings_klass)
-      operation.default_settings!("Bob")
-
-      expect(operation.default_settings).to be_a(Proc)
-
-      expect(operation.default_settings).to receive(:call).with(no_args).and_wrap_original do |original_method, *args, &block|
-        settings = original_method.call(*args, &block)
-        expect(settings).to be_a(settings_klass).and have_attributes(name: "Bob")
-        expect(operation.runner).to receive(:new).with(operation, settings).and_call_original
-        settings
-      end
-
-      expect(operation.call).to be_a(Struct).and have_attributes(name: "Bob")
-    end
-  end
-
-  %i[input output error].each do |meth|
-    describe ".#{meth}" do
-      specify "missing .#{meth} config raises MissingConfigError" do
-        expect {
-          blank_operation.public_send(meth)
-        }.to raise_error(Teckel::MissingConfigError, "Missing #{meth} config for #{blank_operation}")
-      end
-    end
-
-    describe ".#{meth}_constructor" do
-      specify "missing .#{meth}_constructor config raises MissingConfigError for missing #{meth}" do
-        expect {
-          blank_operation.public_send(:"#{meth}_constructor")
-        }.to raise_error(Teckel::MissingConfigError, "Missing #{meth} config for #{blank_operation}")
-      end
-    end
-  end
-
-  specify "default settings config" do
-    expect(blank_operation.settings).to eq(Teckel::Contracts::None)
-  end
-
-  specify "default settings_constructor" do
-    expect(blank_operation.settings_constructor).to eq(Teckel::Contracts::None.method(:[]))
-  end
-
-  specify "default settings_constructor with settings config set" do
-    settings_klass = Struct.new(:name)
-    blank_operation.settings(settings_klass)
-
-    expect(blank_operation.settings_constructor).to eq(settings_klass.method(:[]))
-  end
-
-  specify "unsupported constructor method" do
-    blank_operation.settings(Class.new)
-    expect {
-      blank_operation.settings_constructor(:nope)
-    }.to raise_error(Teckel::MissingConfigError, "Missing settings_constructor config for #{blank_operation}")
-
-    expect {
-      blank_operation.settings_constructor
-    }.to raise_error(Teckel::MissingConfigError, "Missing settings_constructor config for #{blank_operation}")
-  end
-
-  describe "result" do
-    specify "default result config" do
-      expect(blank_operation.result).to eq(Teckel::Operation::ValueResult)
-    end
-
-    specify "default result_constructor" do
-      expect(blank_operation.result_constructor).to eq(Teckel::Operation::ValueResult.method(:[]))
-    end
-
-    specify "default result_constructor with settings config set" do
-      result_klass = OpenStruct.new
-      blank_operation.result(result_klass)
-
-      expect(blank_operation.result_constructor).to eq(result_klass.method(:[]))
-    end
-
-    specify "unsupported constructor method" do
-      blank_operation.result(Class.new)
-      expect {
-        blank_operation.result_constructor(:nope)
-      }.to raise_error(Teckel::MissingConfigError, "Missing result_constructor config for #{blank_operation}")
-
-      expect {
-        blank_operation.result_constructor
-      }.to raise_error(Teckel::MissingConfigError, "Missing result_constructor config for #{blank_operation}")
-    end
-
-    specify "with result class as constant" do
-      result_klass = OpenStruct.new
-      blank_operation.const_set(:Result, result_klass)
-
-      expect(blank_operation.result).to eq(result_klass)
-      expect(blank_operation.result_constructor).to eq(result_klass.method(:[]))
-    end
-  end
-
-  describe "result!" do
-    specify "default result config" do
-      blank_operation.result!
-      expect(blank_operation.result).to eq(Teckel::Operation::Result)
-    end
-  end
-end

data/spec/operation/contract_trace_spec.rb

@@ -1,118 +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
-
-# rubocop:disable Style/EvalWithLocation
-# 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
-# rubocop:enable Style/EvalWithLocation
-
-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