teckel 0.4.0 → 0.8.0

data/spec/operation/config_spec.rb

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

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

data/spec/operation/default_settings_spec.rb

@@ -0,0 +1,120 @@
+# 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
+      )
+
+      it_behaves_like(
+        "operation with default settings",
+        Class.new(TeckelOperationDefaultSettings::BaseOperation) do
+          settings Struct.new(:injected)
+
+          default_settings!("default_value")
+
+          output_constructor ->(out) { out&.to_sym }
+        end
+      )
+    end
+
+    describe "with default constructor and simple Settings class responding to passed default setting" do
+      it_behaves_like(
+        "operation with default settings",
+        Class.new(TeckelOperationDefaultSettings::BaseOperation) do
+          settings(Struct.new(:injected) do
+            def self.default
+              new(:default_value)
+            end
+          end)
+
+          default_settings!(:default)
+        end
+      )
+    end
+  end
+end

data/spec/operation/fail_on_input_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "dry/validation"
+require 'support/dry_base'
+require 'support/fake_models'
+
+module TeckelOperationFailOnOInput
+  class NewUserContract < Dry::Validation::Contract
+    schema do
+      required(:name).filled(:string)
+      required(:age).value(:integer)
+    end
+  end
+
+  class CreateUser
+    include Teckel::Operation
+
+    result!
+
+    input(NewUserContract.new)
+    input_constructor(->(input){
+      result = self.class.input.call(input)
+      if result.success?
+        result.to_h
+      else
+        fail!(message: "Input data validation failed", errors: [result.errors.to_h])
+      end
+    })
+
+    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
+
+    finalize!
+  end
+
+  class CreateUserIncorrectFailure
+    include Teckel::Operation
+
+    result!
+
+    input(->(input) { input }) # NoOp
+    input_constructor(->(_input) {
+      fail!("Input data validation failed")
+    })
+
+    output none
+    error  Types::Hash.schema(message: Types::String, errors: Types::Array.of(Types::Hash))
+
+    def call(_); end
+    finalize!
+  end
+end
+
+RSpec.describe Teckel::Operation do
+  specify "successs" do
+    result = TeckelOperationFailOnOInput::CreateUser.call(name: "Bob", age: 23)
+    expect(result).to be_successful
+    expect(result.success).to be_a(User)
+  end
+
+  describe "failing in input_constructor" do
+    let(:failure_input) do
+      { name: "", age: "incorrect type" }
+    end
+
+    it "returns the failure thrown in input_constructor" do
+      result = TeckelOperationFailOnOInput::CreateUser.call(failure_input)
+      expect(result).to be_a(Teckel::Operation::Result)
+      expect(result).to be_failure
+      expect(result.failure).to eq(
+        message: "Input data validation failed",
+        errors: [
+          { name: ["must be filled"], age: ["must be an integer"] }
+        ]
+      )
+    end
+
+    it "does not run .call" do
+      expect(TeckelOperationFailOnOInput::CreateUser).to receive(:new).and_wrap_original do |m, *args|
+        op_instance = m.call(*args)
+        expect(op_instance).to_not receive(:call)
+        op_instance
+      end
+
+      TeckelOperationFailOnOInput::CreateUser.call(failure_input)
+    end
+  end
+
+  specify "thrown failure needs to conform to :error" do
+    expect {
+      TeckelOperationFailOnOInput::CreateUserIncorrectFailure.call(name: "Bob", age: 23)
+    }.to raise_error(Dry::Types::ConstraintError, /violates constraints/)
+  end
+end

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 }