teckel 0.3.0 → 0.4.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'
+
+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
+      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
+          { 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
+
+  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'
+
+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
+      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")
+        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
+          { 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
+
+  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/inheritance_spec.rb

@@ -0,0 +1,94 @@
+# 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
+
+        settings Settings
+        settings_constructor ->(data) { settings.new(*data.values_at(*settings.members)) }
+
+        error DefaultError
+        error_constructor ->(data) { error.new(*data.values_at(*error.members)) }
+
+        result!
+
+        # Freeze the base class to make sure it's inheritable configuration is not altered
+        freeze
+      end
+
+      class OperationA < ApplicationOperation
+        input Struct.new(:input_data_a)
+        output Struct.new(:output_data_a)
+
+        def call(input)
+          if settings&.fail_it
+            fail!(message: settings.fail_it, status_code: 400)
+          else
+            input.input_data_a * 2
+          end
+        end
+
+        finalize!
+      end
+
+      class OperationB < ApplicationOperation
+        input Struct.new(:input_data_b)
+        output Struct.new(:output_data_b)
+
+        def call(input)
+          if settings&.fail_it
+            fail!(message: settings.fail_it, status_code: 500)
+          else
+            input.input_data_b * 4
+          end
+        end
+
+        finalize!
+      end
+    end
+
+    let(:operation_a) { TeckelOperationDefaultsViaBaseClass::OperationA }
+    let(:operation_b) { TeckelOperationDefaultsViaBaseClass::OperationB }
+
+    it "inherits config" do
+      expect(operation_a.result).to eq(Teckel::Operation::Result)
+      expect(operation_a.settings).to eq(TeckelOperationDefaultsViaBaseClass::Settings)
+
+      expect(operation_b.result).to eq(Teckel::Operation::Result)
+      expect(operation_b.settings).to eq(TeckelOperationDefaultsViaBaseClass::Settings)
+    end
+
+    context "operation_a" do
+      it "can run" do
+        result = operation_a.call(10)
+        expect(result.success.to_h).to eq(output_data_a: 20)
+      end
+
+      it "can fail" do
+        result = operation_a.with(fail_it: "D'oh!").call(10)
+        expect(result.failure.to_h).to eq(
+          message: "D'oh!", status_code: 400
+        )
+      end
+    end
+
+    context "operation_b" do
+      it "can run" do
+        result = operation_b.call(10)
+        expect(result.success.to_h).to eq(output_data_b: 40)
+      end
+
+      it "can fail" do
+        result = operation_b.with(fail_it: "D'oh!").call(10)
+        expect(result.failure.to_h).to eq(
+          message: "D'oh!", status_code: 500
+        )
+      end
+    end
+  end
+end

data/spec/operation/result_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+RSpec.describe Teckel::Operation::Result do
+  let(:failure_value) { "some error" }
+  let(:failed_result) { Teckel::Operation::Result.new(failure_value, false) }
+
+  let(:success_value) { "some error" }
+  let(:successful_result) { Teckel::Operation::Result.new(failure_value, true) }
+
+  it { expect(successful_result.successful?).to be(true) }
+  it { expect(failed_result.successful?).to be(false) }
+
+  it { expect(successful_result.failure?).to be(false) }
+  it { expect(failed_result.failure?).to be(true) }
+
+  it { expect(successful_result.value).to eq(success_value) }
+  it { expect(failed_result.value).to eq(failure_value) }
+
+  describe "#success" do
+    it { expect(successful_result.success).to eq(success_value) }
+
+    it { expect(failed_result.success).to eq(nil) }
+    it { expect(failed_result.success("other")).to eq("other") }
+    it { expect(failed_result.success { |value| "Failed: #{value}" } ).to eq("Failed: some error") }
+  end
+
+  describe "#failure" do
+    it { expect(failed_result.failure).to eq(failure_value) }
+
+    it { expect(successful_result.failure).to eq(nil) }
+    it { expect(successful_result.failure("other")).to eq("other") }
+    it { expect(successful_result.failure { |value| "Failed: #{value}" } ).to eq("Failed: some error") }
+  end
+end

data/spec/operation/results_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'support/dry_base'
+require 'support/fake_models'
+
+RSpec.describe Teckel::Operation do
+  context "with build in result object" do
+    class CreateUserWithResult
+      include Teckel::Operation
+
+      result!
+
+      input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer)
+      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
+          user
+        else
+          fail!(message: "Could not save User", errors: user.errors)
+        end
+      end
+    end
+
+    specify "output" do
+      result = CreateUserWithResult.call(name: "Bob", age: 23)
+      expect(result).to be_a(Teckel::Result)
+      expect(result).to be_successful
+      expect(result.success).to be_a(User)
+    end
+
+    specify "errors" do
+      result = CreateUserWithResult.call(name: "Bob", age: 10)
+      expect(result).to be_a(Teckel::Result)
+      expect(result).to be_failure
+      expect(result.failure).to eq(message: "Could not save User", errors: [{ age: "underage" }])
+    end
+  end
+
+  context "using custom result" do
+    class CreateUserCustomResult
+      include Teckel::Operation
+
+      class MyResult
+        include Teckel::Result # makes sure this can be used in a Chain
+
+        def initialize(value, success, opts = {})
+          @value, @success, @opts = value, success, opts
+        end
+
+        # implementing Teckel::Result
+        def successful?
+          @success
+        end
+
+        # implementing Teckel::Result
+        attr_reader :value
+
+        attr_reader :opts
+      end
+
+      result MyResult
+      result_constructor ->(value, success) { result.new(value, success, time: Time.now.to_i) }
+
+      input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer)
+      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
+          user
+        else
+          fail!(message: "Could not save User", errors: user.errors)
+        end
+      end
+    end
+
+    specify "output" do
+      result = CreateUserCustomResult.call(name: "Bob", age: 23)
+      expect(result).to be_a(CreateUserCustomResult::MyResult)
+      expect(result).to be_successful
+      expect(result.value).to be_a(User)
+
+      expect(result.opts).to include(time: kind_of(Integer))
+    end
+
+    specify "errors" do
+      result = CreateUserCustomResult.call(name: "Bob", age: 10)
+      expect(result).to be_a(CreateUserCustomResult::MyResult)
+      expect(result).to be_failure
+      expect(result.value).to eq(message: "Could not save User", errors: [{ age: "underage" }])
+
+      expect(result.opts).to include(time: kind_of(Integer))
+    end
+  end
+
+  context "overwriting Result" do
+    class CreateUserOverwritingResult
+      include Teckel::Operation
+
+      class Result
+        include Teckel::Result # makes sure this can be used in a Chain
+
+        def initialize(value, success); end
+      end
+    end
+
+    it "uses the class definition" do
+      expect(CreateUserOverwritingResult.result).to_not eq(Teckel::Operation::Result)
+      expect(CreateUserOverwritingResult.result).to eq(CreateUserOverwritingResult::Result)
+      expect(CreateUserOverwritingResult.result_constructor).to eq(CreateUserOverwritingResult::Result.method(:[]))
+    end
+  end
+end