teckel 0.8.0 → 0.9.0

data/spec/operation/default_settings_spec.rb

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

@@ -1,103 +0,0 @@
-# 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,94 +0,0 @@
-# frozen_string_literal: true
-
-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
-        success!(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
-        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 }
-
-    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

@@ -1,49 +0,0 @@
-# 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 success" }
-  let(:successful_result) { Teckel::Operation::Result.new(success_value, true) }
-
-  it { expect(successful_result.successful?).to eq(true) }
-  it { expect(failed_result.successful?).to eq(false) }
-
-  it { expect(successful_result.failure?).to eq(false) }
-  it { expect(failed_result.failure?).to eq(true) }
-
-  it { expect(successful_result.value).to eq(success_value) }
-  it { expect(failed_result.value).to eq(failure_value) }
-
-  describe "#success" do
-    it("on successful result, returns value") {
-      expect(successful_result.success).to eq(success_value)
-    }
-
-    describe "on failed result" do
-      it("with no fallbacks, returns nil") {
-        expect(failed_result.success).to eq(nil)
-      }
-      it("with default-argument, returns default-argument") {
-        expect(failed_result.success("other")).to eq("other")
-      }
-      it("with block, returns block return value") {
-        expect(failed_result.success { |value| "Failed: #{value}" } ).to eq("Failed: some error")
-      }
-      it("with default-argument and block given, returns default-argument, skips block") {
-        expect { |blk|
-          expect(failed_result.success("default", &blk)).to_not eq("default")
-        }.to(yield_control)
-      }
-    end
-  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 success") }
-  end
-end

data/spec/operation/results_spec.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require 'support/dry_base'
-require 'support/fake_models'
-
-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
-      success! user
-    else
-      fail!(message: "Could not save User", errors: user.errors)
-    end
-  end
-end
-
-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) { MyResult.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
-      success! user
-    else
-      fail!(message: "Could not save User", errors: user.errors)
-    end
-  end
-end
-
-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
-
-RSpec.describe Teckel::Operation do
-  context "with build in result object" do
-    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
-    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
-    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