teckel 0.2.0 → 0.7.0

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

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

@@ -0,0 +1,55 @@
+# 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(:failed_nil_result) { Teckel::Operation::Result.new(failure_value, nil) }
+
+  let(:success_value) { "some success" }
+  let(:successful_result) { Teckel::Operation::Result.new(success_value, true) }
+  let(:successful_1_result) { Teckel::Operation::Result.new(success_value, 1) }
+
+  it { expect(successful_result.successful?).to eq(true) }
+  it { expect(successful_1_result.successful?).to eq(true) }
+  it { expect(failed_result.successful?).to eq(false) }
+  it { expect(failed_nil_result.successful?).to eq(false) }
+
+  it { expect(successful_result.failure?).to eq(false) }
+  it { expect(successful_1_result.failure?).to eq(false) }
+  it { expect(failed_result.failure?).to eq(true) }
+  it { expect(failed_nil_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

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

data/spec/operation_spec.rb

@@ -0,0 +1,483 @@
+# frozen_string_literal: true
+
+require 'support/dry_base'
+require 'support/fake_models'
+
+module TeckelOperationPredefinedClassesTest
+  class CreateUserInput < Dry::Struct
+    attribute :name, Types::String
+    attribute :age, Types::Coercible::Integer
+  end
+
+  CreateUserOutput = Types.Instance(User)
+
+  class CreateUserError < Dry::Struct
+    attribute :message, Types::String
+    attribute :status_code, Types::Integer
+    attribute :meta, Types::Hash.optional
+  end
+
+  class CreateUser
+    include Teckel::Operation
+
+    input  CreateUserInput
+    output CreateUserOutput
+    error  CreateUserError
+
+    def call(input)
+      user = User.new(**input.attributes)
+      if user.save
+        success!(user)
+      else
+        fail!(
+          message: "Could not create User",
+          status_code: 400,
+          meta: { validation: user.errors }
+        )
+      end
+    end
+  end
+end
+
+module TeckelOperationInlineClassesTest
+  class CreateUser
+    include Teckel::Operation
+
+    class Input < Dry::Struct
+      attribute :name, Types::String
+      attribute :age, Types::Coercible::Integer
+    end
+
+    Output = Types.Instance(User)
+
+    class Error < Dry::Struct
+      attribute :message, Types::String
+      attribute :status_code, Types::Integer
+      attribute :meta, Types::Hash.optional
+    end
+
+    def call(input)
+      user = User.new(**input.attributes)
+      if user.save
+        success!(user)
+      else
+        fail!(
+          message: "Could not create User",
+          status_code: 400,
+          meta: { validation: user.errors }
+        )
+      end
+    end
+  end
+end
+
+module TeckelOperationAnnonClassesTest
+  class CreateUser
+    include ::Teckel::Operation
+
+    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
+end
+
+module TeckelOperationKeywordContracts
+  class MyOperation
+    include Teckel::Operation
+
+    class Input
+      def initialize(name:, age:)
+        @name, @age = name, age
+      end
+      attr_reader :name, :age
+    end
+
+    input_constructor ->(data) { Input.new(**data) }
+
+    Output = ::User
+
+    class Error
+      def initialize(message, errors)
+        @message, @errors = message, errors
+      end
+      attr_reader :message, :errors
+    end
+    error_constructor :new
+
+    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
+end
+
+module TeckelOperationCreateUserSplatInit
+  class MyOperation
+    include Teckel::Operation
+
+    input Struct.new(:name, :age)
+    input_constructor ->(data) { self.class.input.new(*data) }
+
+    Output = ::User
+
+    class Error
+      def initialize(message, errors)
+        @message, @errors = message, errors
+      end
+      attr_reader :message, :errors
+    end
+    error_constructor :new
+
+    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
+end
+
+module TeckelOperationGeneratedOutputTest
+  class MyOperation
+    include ::Teckel::Operation
+
+    input none
+    output Struct.new(:some_key)
+    output_constructor ->(data) { output.new(*data.values_at(*output.members)) } # ruby 2.4 way for `keyword_init: true`
+    error none
+
+    def call(_input)
+      success!(some_key: "some_value")
+    end
+  end
+end
+
+module TeckelOperationNoSettingsTest
+  class MyOperation
+    include ::Teckel::Operation
+
+    input none
+    output none
+    error none
+
+    def call(_input); end
+  end
+  MyOperation.finalize!
+end
+
+module TeckelOperationNoneDataTest
+  class MyOperation
+    include ::Teckel::Operation
+
+    settings Struct.new(:fail_it, :fail_data, :success_it, :success_data)
+    settings_constructor ->(data) { settings.new(*data.values_at(*settings.members)) }
+
+    input none
+    output none
+    error none
+
+    def call(_input)
+      if settings&.fail_it
+        if settings&.fail_data
+          fail!(settings.fail_data)
+        else
+          fail!
+        end
+      elsif settings&.success_it
+        if settings&.success_data
+          success!(settings.success_data)
+        else
+          success!
+        end
+      else
+        settings&.success_data
+      end
+    end
+  end
+end
+
+module TeckelOperationInjectSettingsTest
+  class MyOperation
+    include ::Teckel::Operation
+
+    settings Struct.new(:injected)
+    settings_constructor ->(data) { settings.new(*data.values_at(*settings.members)) }
+
+    input none
+    output Array
+    error none
+
+    def call(_input)
+      success!((settings&.injected || []) << :operation_data)
+    end
+  end
+end
+
+RSpec.describe Teckel::Operation do
+  context "predefined classes" do
+    specify "Input" do
+      expect(TeckelOperationPredefinedClassesTest::CreateUser.input).to eq(TeckelOperationPredefinedClassesTest::CreateUserInput)
+    end
+
+    specify "Output" do
+      expect(TeckelOperationPredefinedClassesTest::CreateUser.output).to eq(TeckelOperationPredefinedClassesTest::CreateUserOutput)
+    end
+
+    specify "Error" do
+      expect(TeckelOperationPredefinedClassesTest::CreateUser.error).to eq(TeckelOperationPredefinedClassesTest::CreateUserError)
+    end
+
+    context "success" do
+      specify do
+        result = TeckelOperationPredefinedClassesTest::CreateUser.call(name: "Bob", age: 23)
+        expect(result).to be_a(User)
+      end
+    end
+
+    context "error" do
+      specify do
+        result = TeckelOperationPredefinedClassesTest::CreateUser.call(name: "Bob", age: 7)
+        expect(result).to be_a(TeckelOperationPredefinedClassesTest::CreateUserError)
+        expect(result).to have_attributes(
+          message: "Could not create User",
+          status_code: 400,
+          meta: { validation: [{ age: "underage" }] }
+        )
+      end
+    end
+  end
+
+  context "inline classes" do
+    specify "Input" do
+      expect(TeckelOperationInlineClassesTest::CreateUser.input).to be <= Dry::Struct
+    end
+
+    specify "Output" do
+      expect(TeckelOperationInlineClassesTest::CreateUser.output).to be_a Dry::Types::Constrained
+    end
+
+    specify "Error" do
+      expect(TeckelOperationInlineClassesTest::CreateUser.error).to be <= Dry::Struct
+    end
+
+    context "success" do
+      specify do
+        result = TeckelOperationInlineClassesTest::CreateUser.call(name: "Bob", age: 23)
+        expect(result).to be_a(User)
+      end
+    end
+
+    context "error" do
+      specify do
+        result = TeckelOperationInlineClassesTest::CreateUser.call(name: "Bob", age: 7)
+        expect(result).to have_attributes(
+          message: "Could not create User",
+          status_code: 400,
+          meta: { validation: [{ age: "underage" }] }
+        )
+      end
+    end
+  end
+
+  context "annon classes" do
+    specify "output" do
+      expect(TeckelOperationAnnonClassesTest::CreateUser.call(name: "Bob", age: 23)).to be_a(User)
+    end
+
+    specify "errors" do
+      expect(TeckelOperationAnnonClassesTest::CreateUser.call(name: "Bob", age: 10)).to eq(message: "Could not save User", errors: [{ age: "underage" }])
+    end
+  end
+
+  context "keyword contracts" do
+    specify do
+      expect(TeckelOperationKeywordContracts::MyOperation.call(name: "Bob", age: 23)).to be_a(User)
+    end
+  end
+
+  context "splat contracts" do
+    specify do
+      expect(TeckelOperationCreateUserSplatInit::MyOperation.call(["Bob", 23])).to be_a(User)
+    end
+  end
+
+  context "generated output" do
+    specify "result" do
+      result = TeckelOperationGeneratedOutputTest::MyOperation.call
+      expect(result).to be_a(Struct)
+      expect(result.some_key).to eq("some_value")
+    end
+  end
+
+  context "inject settings" do
+    it "settings in operation instances are nil by default" do
+      op = TeckelOperationInjectSettingsTest::MyOperation.new
+      expect(op.settings).to be_nil
+    end
+
+    it "uses injected data" do
+      result =
+        TeckelOperationInjectSettingsTest::MyOperation.
+        with(injected: [:stuff]).
+        call
+
+      expect(result).to eq([:stuff, :operation_data])
+
+      expect(TeckelOperationInjectSettingsTest::MyOperation.call).to eq([:operation_data])
+    end
+
+    specify "calling `with` multiple times raises an error" do
+      op = TeckelOperationInjectSettingsTest::MyOperation.with(injected: :stuff_1)
+
+      expect {
+        op.with(more: :stuff_2)
+      }.to raise_error(Teckel::Error, "Operation already has settings assigned.")
+    end
+  end
+
+  context "operation with no settings" do
+    it "uses None as default settings class" do
+      expect(TeckelOperationNoSettingsTest::MyOperation.settings).to eq(Teckel::Contracts::None)
+      expect(TeckelOperationNoSettingsTest::MyOperation.new.settings).to be_nil
+    end
+
+    it "raises error when trying to set settings" do
+      expect {
+        TeckelOperationNoSettingsTest::MyOperation.with(any: :thing)
+      }.to raise_error(ArgumentError, "None called with arguments")
+    end
+  end
+
+  context "None in, out, err" do
+    let(:operation) { TeckelOperationNoneDataTest::MyOperation }
+
+    it "raises error when called with input data" do
+      expect { operation.call("stuff") }.to raise_error(ArgumentError)
+    end
+
+    it "raises error when fail! with data" do
+      expect {
+        operation.with(fail_it: true, fail_data: "stuff").call
+      }.to raise_error(ArgumentError)
+    end
+
+    it "returns nil as failure result when fail! without arguments" do
+      expect(operation.with(fail_it: true).call).to be_nil
+    end
+
+    it "raises error when success! with data" do
+      expect {
+        operation.with(success_it: true, success_data: "stuff").call
+      }.to raise_error(ArgumentError)
+    end
+
+    it "returns nil as success result when success! without arguments" do
+      expect(operation.with(success_it: true).call).to be_nil
+    end
+
+    it "returns nil as success result when returning nil" do
+      expect(operation.call).to be_nil
+    end
+  end
+
+  describe "#finalize!" do
+    let(:frozen_error) do
+      # different ruby versions raise different errors
+      defined?(FrozenError) ? FrozenError : RuntimeError
+    end
+
+    subject do
+      Class.new do
+        include ::Teckel::Operation
+
+        input Struct.new(:input_data)
+        output Struct.new(:output_data)
+
+        def call(input)
+          success!(input.input_data * 2)
+        end
+      end
+    end
+
+    it "fails b/c error config is missing" do
+      expect {
+        subject.finalize!
+      }.to raise_error(Teckel::MissingConfigError, "Missing error config for #{subject}")
+    end
+
+    specify "#dup" do
+      new_operation = subject.dup
+      new_operation.error Struct.new(:error)
+      expect { new_operation.finalize! }.to_not raise_error
+
+      expect {
+        subject.finalize!
+      }.to raise_error(Teckel::MissingConfigError, "Missing error config for #{subject}")
+    end
+
+    specify "#clone" do
+      new_operation = subject.clone
+      new_operation.error Struct.new(:error)
+      expect { new_operation.finalize! }.to_not raise_error
+
+      expect {
+        subject.finalize!
+      }.to raise_error(Teckel::MissingConfigError, "Missing error config for #{subject}")
+    end
+
+    it "rejects any config changes" do
+      subject.error Struct.new(:error)
+      expect { subject.finalize! }.to_not raise_error
+
+      # no more after finalize!
+      subject.finalize!
+
+      expect {
+        subject.error Struct.new(:other_error)
+      }.to raise_error(Teckel::FrozenConfigError, "Configuration error is already set")
+    end
+
+    it "runs" do
+      subject.error Struct.new(:error)
+      subject.finalize!
+
+      result = subject.call("test")
+      expect(result.output_data).to eq("testtest")
+    end
+
+    it "accepts mocks" do
+      subject.error Struct.new(:error)
+      subject.finalize!
+
+      allow(subject).to receive(:call) { :mocked }
+      expect(subject.call).to eq(:mocked)
+    end
+  end
+
+  describe "overwriting configs is not allowed" do
+    it "raises" do
+      expect {
+        Class.new do
+          include ::Teckel::Operation
+          input none
+          input Struct.new(:name)
+        end
+      }.to raise_error Teckel::FrozenConfigError, "Configuration input is already set"
+    end
+  end
+end