teckel 0.4.0 → 0.8.0

data/spec/operation_spec.rb

@@ -3,44 +3,238 @@
 require 'support/dry_base'
 require 'support/fake_models'
 
-RSpec.describe Teckel::Operation do
-  context "predefined classes" do
-    module TeckelOperationPredefinedClassesTest
-      class CreateUserInput < Dry::Struct
-        attribute :name, Types::String
-        attribute :age, Types::Coercible::Integer
+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
 
-      CreateUserOutput = Types.Instance(User)
+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
 
-      class CreateUserError < Dry::Struct
-        attribute :message, Types::String
-        attribute :status_code, Types::Integer
-        attribute :meta, Types::Hash.optional
+    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
 
-      class CreateUser
-        include Teckel::Operation
+module TeckelOperationAnnonClassesTest
+  class CreateUser
+    include ::Teckel::Operation
 
-        input  CreateUserInput
-        output CreateUserOutput
-        error  CreateUserError
+    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(**input.attributes)
-          if user.save
-            success!(user)
-          else
-            fail!(
-              message: "Could not create User",
-              status_code: 400,
-              meta: { validation: user.errors }
-            )
-          end
+    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
+  let(:frozen_error) do
+    # different ruby versions raise different errors
+    defined?(FrozenError) ? FrozenError : RuntimeError
+  end
+
+  context "predefined classes" do
     specify "Input" do
       expect(TeckelOperationPredefinedClassesTest::CreateUser.input).to eq(TeckelOperationPredefinedClassesTest::CreateUserInput)
     end
@@ -74,38 +268,6 @@ RSpec.describe Teckel::Operation do
   end
 
   context "inline classes" do
-    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
-            user
-          else
-            fail!(
-              message: "Could not create User",
-              status_code: 400,
-              meta: { validation: user.errors }
-            )
-          end
-        end
-      end
-    end
-
     specify "Input" do
       expect(TeckelOperationInlineClassesTest::CreateUser.input).to be <= Dry::Struct
     end
@@ -138,25 +300,6 @@ RSpec.describe Teckel::Operation do
   end
 
   context "annon classes" do
-    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
-            user
-          else
-            fail!(message: "Could not save User", errors: user.errors)
-          end
-        end
-      end
-    end
-
     specify "output" do
       expect(TeckelOperationAnnonClassesTest::CreateUser.call(name: "Bob", age: 23)).to be_a(User)
     end
@@ -167,91 +310,18 @@ RSpec.describe Teckel::Operation do
   end
 
   context "keyword contracts" do
-    class CreateUserKeywordInit
-      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
-          user
-        else
-          fail!(message: "Could not save User", errors: user.errors)
-        end
-      end
-    end
-
     specify do
-      expect(CreateUserKeywordInit.call(name: "Bob", age: 23)).to be_a(User)
+      expect(TeckelOperationKeywordContracts::MyOperation.call(name: "Bob", age: 23)).to be_a(User)
     end
   end
 
   context "splat contracts" do
-    class CreateUserSplatInit
-      include Teckel::Operation
-
-      input Struct.new(:name, :age)
-      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
-          user
-        else
-          fail!(message: "Could not save User", errors: user.errors)
-        end
-      end
-    end
-
     specify do
-      expect(CreateUserSplatInit.call(["Bob", 23])).to be_a(User)
+      expect(TeckelOperationCreateUserSplatInit::MyOperation.call(["Bob", 23])).to be_a(User)
     end
   end
 
   context "generated output" do
-    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)
-          { some_key: "some_value" }
-        end
-      end
-    end
-
     specify "result" do
       result = TeckelOperationGeneratedOutputTest::MyOperation.call
       expect(result).to be_a(Struct)
@@ -260,31 +330,13 @@ RSpec.describe Teckel::Operation do
   end
 
   context "inject settings" do
-    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)
-          (settings&.injected || []) << :operation_data
-        end
-      end
-    end
-
     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.
+      result = TeckelOperationInjectSettingsTest::MyOperation.
         with(injected: [:stuff]).
         call
 
@@ -294,28 +346,15 @@ RSpec.describe Teckel::Operation do
     end
 
     specify "calling `with` multiple times raises an error" do
-      op = TeckelOperationInjectSettingsTest::MyOperation.with(injected: :stuff_1)
+      op = TeckelOperationInjectSettingsTest::MyOperation.with(injected: :stuff1)
 
       expect {
-        op.with(more: :stuff_2)
-      }.to raise_error(Teckel::Error)
+        op.with(more: :stuff2)
+      }.to raise_error(Teckel::Error, "Operation already has settings assigned.")
     end
   end
 
   context "operation with no settings" do
-    module TeckelOperationNoSettingsTest
-      class MyOperation
-        include ::Teckel::Operation
-
-        input none
-        output none
-        error none
-
-        def call(_input); end
-      end
-      MyOperation.finalize!
-    end
-
     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
@@ -329,37 +368,6 @@ RSpec.describe Teckel::Operation do
   end
 
   context "None in, out, err" do
-    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
-
     let(:operation) { TeckelOperationNoneDataTest::MyOperation }
 
     it "raises error when called with input data" do
@@ -386,23 +394,12 @@ RSpec.describe Teckel::Operation do
       expect(operation.with(success_it: true).call).to be_nil
     end
 
-    it "raises error when returning data" do
-      expect {
-        operation.with(success_it: false, success_data: "stuff").call
-      }.to raise_error(ArgumentError)
-    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
@@ -482,4 +479,53 @@ RSpec.describe Teckel::Operation do
       }.to raise_error Teckel::FrozenConfigError, "Configuration input is already set"
     end
   end
+
+  describe "frozen" do
+    subject do
+      Class.new do
+        include ::Teckel::Operation
+
+        input none
+        output none
+        error none
+
+        def call(_input); end
+      end
+    end
+
+    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 config" do
+      subject.freeze
+      expect { subject.settings Struct.new(:test) }.to raise_error(frozen_error)
+    end
+
+    describe '#clone' do
+      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/rb27/pattern_matching_spec.rb

@@ -37,7 +37,7 @@ RSpec.describe "Ruby 2.7 pattern matches for Result and Chain" do
 
       def call(usr)
         Logger.new(File::NULL).info("User #{usr.name} created")
-        usr
+        success! usr
       end
     end
 
@@ -56,7 +56,7 @@ RSpec.describe "Ruby 2.7 pattern matches for Result and Chain" do
         if settings&.fail_befriend
           fail!(message: "Did not find a friend.")
         else
-          { user: user, friend: User.new(name: "A friend", age: 42) }
+          success!(user: user, friend: User.new(name: "A friend", age: 42))
         end
       end
     end

data/spec/result_spec.rb

@@ -3,18 +3,20 @@
 require 'support/dry_base'
 require 'support/fake_models'
 
+module TeckelResultTest
+  class MissingResultImplementation
+    include Teckel::Result
+    def initialize(value, success); end
+  end
+end
+
 RSpec.describe Teckel::Result do
   describe "missing initialize" do
-    class MissingResultImplementation
-      include Teckel::Result
-      def initialize(value, success); end
-    end
-
-    specify do
-      result = MissingResultImplementation["value", true]
-      expect { result.successful? }.to raise_error(NotImplementedError)
-      expect { result.failure? }.to raise_error(NotImplementedError)
-      expect { result.value }.to raise_error(NotImplementedError)
+    specify "raises NotImplementedError" do
+      result = TeckelResultTest::MissingResultImplementation["value", true]
+      expect { result.successful? }.to raise_error(NotImplementedError, "Result object does not implement `successful?`")
+      expect { result.failure? }.to raise_error(NotImplementedError, "Result object does not implement `successful?`")
+      expect { result.value }.to raise_error(NotImplementedError, "Result object does not implement `value`")
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,12 +3,22 @@
 require "bundler/setup"
 if ENV['COVERAGE'] == 'true'
   require 'simplecov'
+
+  SimpleCov.formatter = case ENV['SIMPLECOV']&.downcase
+  when 'html'
+    SimpleCov::Formatter::HTMLFormatter
+  else
+    require 'simplecov_json_formatter'
+    SimpleCov::Formatter::JSONFormatter
+  end
+
   SimpleCov.start do
     add_filter %r{^/spec/}
   end
 end
 
 require "teckel"
+require "teckel/chain"
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure