teckel 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df9c73577c9c93fbaaf2e7661a07bdc3b1b0397832a62a8edbe4eea846c4c029
-  data.tar.gz: 037041bf0eb6ae8bc41e354772d3ce1d04002a35ecccc0b1ecefa33a85845c3b
+  metadata.gz: 213ed6f9b3d25db8b7fc284ced55aa1a3a71b4ec54f10fd3ed3bf4e0a315dbd3
+  data.tar.gz: d013f110763117b066987bfb6c085e8682db372856ea7ab27f4803858be96e3c
 SHA512:
-  metadata.gz: 2f6f601e816c972aed8e511b05fdbc418a48aab10c2ca246d108661cc25a8d514a41944b2e01b9294757a2a717696491f20f601f5f60e53faa45651aec48bc7f
-  data.tar.gz: 68bc46e5ed21cf5e639ee1fc00265b278f9062f42de9d179a07559862990a078df9dcb2ef26956eb629cf08e71409b9b05bd363a11930cb64ecdee533d63d2ea
+  metadata.gz: 82db9106f0da688411be738866692455653eb59298afa01ba24500975b0498bf9a164f9f59e2741a4ed9c0c252174bd86fa71dd4204338fe04424d961c21621b
+  data.tar.gz: 6c693373c212e3b127dde042fdaba1ab7865d813cba17d0624a73a62e62589fc68bfe86ed93b9e7c32295deb6053411e4ea0cf57f0897b6f8e7e339ce60dd7be

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changes
 
+## 0.8.0
+
+- Add mutation testing (currently about 80% covered)
+- Breaking: `Teckel::Operation::Result` no longer converts the `successful` value to a boolean.
+  When using the default result implementation, nothing changes for you.
+  When you manually pass anything else into it, `succesful?` will return this value. The `failure` and `success` methods
+  work on the "Truthy" value of `successful`
+  ```ruby
+  result = Result.new(some_value, 42)
+  result.successful?
+  # => 42
+  ```
+- Change: `freeze`ing an `Operation` or `Chain` will also freeze their internal config (input, output, steps, etc.)
+
+Internal:
+
+- Some refactoring to cover mutations
+- Extracted creating the runable `Operation` instance into a new, public `runable(settings = UNDEFINED)` method.
+  Mainly to reduce code duplication but this also makes testing, stubbing and mocking easier.
+
 ## 0.7.0
 
 - Breaking: `Teckel::Chain` will not be required by default. require manually if needed `require "teckel/chain"` [GH-24]

data/README.md

@@ -3,10 +3,10 @@
 Ruby service classes with enforced<sup name="footnote-1-source">[1](#footnote-1)</sup> input, output and error data structure definition.
 
 [![Gem Version](https://img.shields.io/gem/v/teckel.svg)][gem]
-[![Build Status](https://github.com/dry-rb/dry-configurable/workflows/ci/badge.svg)][ci]
+[![Build Status](https://github.com/fnordfish/teckel/actions/workflows/specs.yml/badge.svg)][ci]
 [![Maintainability](https://api.codeclimate.com/v1/badges/b3939aaec6271a567a57/maintainability)](https://codeclimate.com/github/fnordfish/teckel/maintainability)
 [![Test Coverage](https://api.codeclimate.com/v1/badges/b3939aaec6271a567a57/test_coverage)](https://codeclimate.com/github/fnordfish/teckel/test_coverage)
-[![API Documentation Coverage](https://inch-ci.org/github/fnordfish/teckel.svg?branch=master)][inch]
+[![API Documentation Coverage](https://inch-ci.org/github/fnordfish/teckel.svg?branch=main)][inch]
 
 ## Installation
 
@@ -95,5 +95,5 @@ Please also see [DEVELOPMENT.md](DEVELOPMENT.md) for planned features and genera
 - <a name="footnote-1">1</a>: Obviously, it's still Ruby and you can cheat. Don’t! [↩](#footnote-1-source)
 
 [gem]: https://rubygems.org/gems/teckel
-[ci]: https://github.com/fnordfish/teckel/actions?query=workflow%3ACI
+[ci]: https://github.com/fnordfish/teckel/actions/workflows/specs.yml
 [inch]: http://inch-ci.org/github/fnordfish/teckel

data/lib/teckel/chain/config.rb

@@ -148,7 +148,7 @@ module Teckel
         } || raise(MissingConfigError, "Missing result_constructor config for #{self}")
       end
 
-      # Declare default settings operation iin this chain should use when called without
+      # Declare default settings operation in this chain should use when called without
       # {Teckel::Chain::ClassMethods#with #with}.
       #
       # Explicit call-time settings will *not* get merged with declared default setting.
@@ -227,7 +227,7 @@ module Teckel
       # @return [self]
       # @!visibility public
       def dup
-        dup_config(super)
+        dup_config(super())
       end
 
       # Produces a clone of this chain.
@@ -237,15 +237,25 @@ module Teckel
       # @!visibility public
       def clone
         if frozen?
-          super
+          super()
         else
-          dup_config(super)
+          dup_config(super())
         end
       end
 
+      # Prevents further modifications to this chain and its config
+      #
+      # @return [self]
+      # @!visibility public
+      def freeze
+        steps.freeze
+        @config.freeze
+        super()
+      end
+
       # @!visibility private
       def inherited(subclass)
-        super dup_config(subclass)
+        super(dup_config(subclass))
       end
 
       # @!visibility private
@@ -264,10 +274,11 @@ module Teckel
       end
 
       def build_constructor(on, sym_or_proc)
-        if sym_or_proc.is_a?(Symbol) && on.respond_to?(sym_or_proc)
-          on.public_method(sym_or_proc)
-        elsif sym_or_proc.respond_to?(:call)
+        case sym_or_proc
+        when Proc
           sym_or_proc
+        when Symbol
+          on.public_method(sym_or_proc) if on.respond_to?(sym_or_proc)
         end
       end
     end

data/lib/teckel/chain/runner.rb

@@ -29,7 +29,7 @@ module Teckel
       end
 
       def steps
-        settings == UNDEFINED ? chain.steps : steps_with_settings
+        settings.eql?(UNDEFINED) ? chain.steps : steps_with_settings
       end
 
       private

data/lib/teckel/chain.rb

@@ -74,8 +74,10 @@ module Teckel
     end
 
     def self.included(receiver)
-      receiver.extend Config
-      receiver.extend ClassMethods
+      receiver.class_eval do
+        extend Config
+        extend ClassMethods
+      end
     end
   end
 end

data/lib/teckel/config.rb

@@ -35,12 +35,12 @@ module Teckel
     # @!visibility private
     def freeze
       @config.freeze
-      super
+      super()
     end
 
     # @!visibility private
     def dup
-      super.tap do |copy|
+      super().tap do |copy|
         copy.instance_variable_set(:@config, @config.dup)
       end
     end

data/lib/teckel/operation/config.rb

@@ -12,7 +12,7 @@ module Teckel
       #   @return [Class] The +input+ class
       def input(klass = nil)
         @config.for(:input, klass) { self::Input if const_defined?(:Input) } ||
-          raise(Teckel::MissingConfigError, "Missing input config for #{self}")
+          raise(MissingConfigError, "Missing input config for #{self}")
       end
 
       # @overload input_constructor()
@@ -57,8 +57,7 @@ module Teckel
       #
       #     MyOperation.input_constructor.is_a?(Proc) #=> true
       def input_constructor(sym_or_proc = nil)
-        get_set_constructor(:input_constructor, input, sym_or_proc) ||
-          raise(MissingConfigError, "Missing input_constructor config for #{self}")
+        get_set_constructor(:input_constructor, input, sym_or_proc)
       end
 
       # @overload output()
@@ -72,7 +71,7 @@ module Teckel
       #   @return [Class] The +output+ class
       def output(klass = nil)
         @config.for(:output, klass) { self::Output if const_defined?(:Output) } ||
-          raise(Teckel::MissingConfigError, "Missing output config for #{self}")
+          raise(MissingConfigError, "Missing output config for #{self}")
       end
 
       # @overload output_constructor()
@@ -103,8 +102,7 @@ module Teckel
       #       output_constructor ->(name, options) { Output.new(name: name, **options) }
       #     end
       def output_constructor(sym_or_proc = nil)
-        get_set_constructor(:output_constructor, output, sym_or_proc) ||
-          raise(MissingConfigError, "Missing output_constructor config for #{self}")
+        get_set_constructor(:output_constructor, output, sym_or_proc)
       end
 
       # @overload error()
@@ -117,7 +115,7 @@ module Teckel
       #   @return [Class,nil] The +error+ class or +nil+ if it does not error
       def error(klass = nil)
         @config.for(:error, klass) { self::Error if const_defined?(:Error) } ||
-          raise(Teckel::MissingConfigError, "Missing error config for #{self}")
+          raise(MissingConfigError, "Missing error config for #{self}")
       end
 
       # @overload error_constructor()
@@ -148,8 +146,7 @@ module Teckel
       #       error_constructor ->(name, options) { Error.new(name: name, **options) }
       #     end
       def error_constructor(sym_or_proc = nil)
-        get_set_constructor(:error_constructor, error, sym_or_proc) ||
-          raise(MissingConfigError, "Missing error_constructor config for #{self}")
+        get_set_constructor(:error_constructor, error, sym_or_proc)
       end
 
       # @!endgroup
@@ -219,12 +216,9 @@ module Teckel
       #
       #   (Like calling +MyOperation.with(arg1, arg2, ...)+)
       def default_settings!(*args)
-        callable =
-          if args.empty?
-            -> { settings_constructor.call }
-          elsif args.length == 1
-            build_constructor(settings, args.first)
-          end
+        callable = if args.size.equal?(1)
+          build_constructor(settings, args.first)
+        end
 
         callable ||= -> { settings_constructor.call(*args) }
 
@@ -246,7 +240,7 @@ module Teckel
       #   @param klass [Class] A class like the {Runner}
       #   @!visibility protected
       def runner(klass = nil)
-        @config.for(:runner, klass) { Teckel::Operation::Runner }
+        @config.for(:runner, klass) { Runner }
       end
 
       # @overload result()
@@ -301,8 +295,8 @@ module Teckel
       # @note Don't use in conjunction with {result} or {result_constructor}
       # @return [nil]
       def result!
-        @config.for(:result, Teckel::Operation::Result)
-        @config.for(:result_constructor, Teckel::Operation::Result.method(:new))
+        @config.for(:result, Result)
+        @config.for(:result_constructor, Result.method(:new))
         nil
       end
 
@@ -340,9 +334,7 @@ module Teckel
       # @return [self]
       # @!visibility public
       def dup
-        super.tap do |copy|
-          copy.instance_variable_set(:@config, @config.dup)
-        end
+        dup_config(super())
       end
 
       # Produces a clone of this operation and all it's configuration
@@ -351,18 +343,24 @@ module Teckel
       # @!visibility public
       def clone
         if frozen?
-          super
+          super()
         else
-          super.tap do |copy|
-            copy.instance_variable_set(:@config, @config.dup)
-          end
+          dup_config(super())
         end
       end
 
+      # Prevents further modifications to this operation and its config
+      #
+      # @return [self]
+      # @!visibility public
+      def freeze
+        @config.freeze
+        super()
+      end
+
       # @!visibility private
       def inherited(subclass)
-        subclass.instance_variable_set(:@config, @config.dup)
-        super subclass
+        super(dup_config(subclass))
       end
 
       # @!visibility private
@@ -376,19 +374,25 @@ module Teckel
 
       private
 
+      def dup_config(other_class)
+        other_class.instance_variable_set(:@config, @config.dup)
+        other_class
+      end
+
       def get_set_constructor(name, on, sym_or_proc)
-        constructor = build_constructor(on, sym_or_proc) unless sym_or_proc.nil?
+        constructor = build_constructor(on, sym_or_proc)
 
         @config.for(name, constructor) {
-          build_constructor(on, Teckel::DEFAULT_CONSTRUCTOR)
+          build_constructor(on, DEFAULT_CONSTRUCTOR)
         }
       end
 
       def build_constructor(on, sym_or_proc)
-        if sym_or_proc.is_a?(Symbol) && on.respond_to?(sym_or_proc)
-          on.public_method(sym_or_proc)
-        elsif sym_or_proc.respond_to?(:call)
+        case sym_or_proc
+        when Proc
           sym_or_proc
+        when Symbol
+          on.public_method(sym_or_proc) if on.respond_to?(sym_or_proc)
         end
       end
     end

data/lib/teckel/operation/result.rb

@@ -38,16 +38,16 @@ module Teckel
       include Teckel::Result
 
       # @param value [Object] The result value
-      # @param success [Boolean] whether this is a successful result
-      def initialize(value, success)
+      # @param successful [Boolean] whether this is a successful result
+      def initialize(value, successful)
         @value = value
-        @success = (!!success).freeze
+        @successful = successful
       end
 
       # Whether this is a success result
       # @return [Boolean]
       def successful?
-        @success
+        @successful
       end
 
       # @!attribute [r] value
@@ -59,8 +59,8 @@ module Teckel
       # @param  default [Mixed] return this default value if it's not a failure result
       # @return [Mixed] the value/payload
       def failure(default = nil, &block)
-        return @value unless @success
-        return yield(@value) if block
+        return value unless @successful
+        return yield(value) if block
 
         default
       end
@@ -70,8 +70,8 @@ module Teckel
       # @param  default [Mixed] return this default value if it's not a success result
       # @return [Mixed] the value/payload
       def success(default = nil, &block)
-        return @value if @success
-        return yield(@value) if block
+        return value if @successful
+        return yield(value) if block
 
         default
       end

data/lib/teckel/operation/runner.rb

@@ -29,7 +29,7 @@ module Teckel
 
         op = operation.new
         op.runner = self
-        op.settings = settings if settings != UNDEFINED
+        op.settings = settings unless settings.eql?(UNDEFINED)
 
         @instance = op
       end
@@ -37,7 +37,7 @@ module Teckel
       # This is just here to raise a meaningful error.
       # @!visibility private
       def with(*)
-        raise Teckel::Error, "Operation already has settings assigned."
+        raise Error, "Operation already has settings assigned."
       end
 
       # Halt any further execution with a output value
@@ -46,7 +46,7 @@ module Teckel
       # @!visibility protected
       def success!(*args)
         value =
-          if args.size == 1 && operation.output === args.first # rubocop:disable Style/CaseEquality
+          if args.size.equal?(1) && operation.output === args.first # rubocop:disable Style/CaseEquality
             args.first
           else
             operation.output_constructor.call(*args)
@@ -61,7 +61,7 @@ module Teckel
       # @!visibility protected
       def fail!(*args)
         value =
-          if args.size == 1 && operation.error === args.first # rubocop:disable Style/CaseEquality
+          if args.size.equal?(1) && operation.error === args.first # rubocop:disable Style/CaseEquality
             args.first
           else
             operation.error_constructor.call(*args)

data/lib/teckel/operation.rb

@@ -58,6 +58,9 @@ module Teckel
   # @!visibility public
   module Operation
     module ClassMethods
+      # @!visibility private
+      UNDEFINED = Object.new
+
       # Invoke the Operation
       #
       # @param input Any form of input your {Teckel::Operation::Config#input input} class can handle via the given
@@ -66,21 +69,15 @@ module Teckel
       #   {Teckel::Operation::Config#output output} class
       # @!visibility public
       def call(input = nil)
-        default_settings = self.default_settings
-
-        if default_settings
-          runner.new(self, default_settings.call)
-        else
-          runner.new(self)
-        end.call(input)
+        runable.call(input)
       end
 
-      # Provide {InstanceMethods#settings() settings} to the running operation.
+      # Provide {InstanceMethods#settings() settings} to the operation.
       #
       # This method is intended to be called on the operation class outside of
-      # it's definition, prior to running {#call}.
+      # it's definition, prior to invoking {#call}.
       #
-      # @param input Any form of input your {Teckel::Operation::Config#settings settings} class can handle via the given
+      # @param settings Any form of settings your {Teckel::Operation::Config#settings settings} class can handle via the given
       #   {Teckel::Operation::Config#settings_constructor settings_constructor}
       # @return [Class] The configured {Teckel::Operation::Config#runner runner}
       # @!visibility public
@@ -111,11 +108,31 @@ module Teckel
       #   MyOperation.with(false).call
       #   MyOperation.call
       #   LOG #=> []
-      def with(input)
-        runner.new(self, settings_constructor.call(input))
+      def with(settings)
+        runable(settings_constructor.call(settings))
       end
       alias :set :with
 
+      # Constructs a Runner instance for {call} and {with}.
+      #
+      # @note This method is public to make testing, stubbing and mocking easier.
+      #   Your normal application code should use {with} and/or {call}
+      #
+      # @param settings Optional. Any form of settings your
+      #   {Teckel::Operation::Config#settings settings} class can handle via the
+      #   given {Teckel::Operation::Config#settings_constructor settings_constructor}
+      # @return [Class] The configured {Teckel::Operation::Config#runner runner}
+      # @!visibility public
+      def runable(settings = UNDEFINED)
+        if settings != UNDEFINED
+          runner.new(self, settings)
+        elsif default_settings
+          runner.new(self, default_settings.call)
+        else
+          runner.new(self)
+        end
+      end
+
       # Convenience method for setting {Teckel::Operation::Config#input input},
       # {Teckel::Operation::Config#output output} or
       # {Teckel::Operation::Config#error error} to the
@@ -145,7 +162,7 @@ module Teckel
       #
       #   MyOperation.call #=> nil
       def none
-        Teckel::Contracts::None
+        Contracts::None
       end
     end
 
@@ -187,9 +204,11 @@ module Teckel
     end
 
     def self.included(receiver)
-      receiver.extend         Config
-      receiver.extend         ClassMethods
-      receiver.send :include, InstanceMethods
+      receiver.class_eval do
+        extend  Config
+        extend  ClassMethods
+        include InstanceMethods
+      end
     end
   end
 end

data/lib/teckel/result.rb

@@ -55,8 +55,10 @@ module Teckel
     end
 
     def self.included(receiver)
-      receiver.extend         ClassMethods
-      receiver.send :include, InstanceMethods
+      receiver.class_eval do
+        extend  ClassMethods
+        include InstanceMethods
+      end
     end
   end
 end

data/lib/teckel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Teckel
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/spec/chain_spec.rb

@@ -67,6 +67,11 @@ module TeckelChainTest
 end
 
 RSpec.describe Teckel::Chain do
+  let(:frozen_error) do
+    # different ruby versions raise different errors
+    defined?(FrozenError) ? FrozenError : RuntimeError
+  end
+
   it 'Chain input points to first step input' do
     expect(TeckelChainTest::Chain.input).to eq(TeckelChainTest::CreateUser.input)
   end
@@ -85,8 +90,7 @@ RSpec.describe Teckel::Chain do
 
   context "success" do
     it "result matches" do
-      result =
-        TeckelChainTest::Chain.
+      result = TeckelChainTest::Chain.
         with(befriend: nil).
         call(name: "Bob", age: 23)
 
@@ -96,8 +100,7 @@ RSpec.describe Teckel::Chain do
 
   context "failure" do
     it "returns a Result for invalid input" do
-      result =
-        TeckelChainTest::Chain.
+      result = TeckelChainTest::Chain.
         with(befriend: :fail).
         call(name: "Bob", age: 0)
 
@@ -108,8 +111,7 @@ RSpec.describe Teckel::Chain do
     end
 
     it "returns a Result for failed step" do
-      result =
-        TeckelChainTest::Chain.
+      result = TeckelChainTest::Chain.
         with(befriend: :fail).
         call(name: "Bob", age: 23)
 
@@ -121,11 +123,6 @@ RSpec.describe Teckel::Chain do
   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
@@ -177,4 +174,82 @@ RSpec.describe Teckel::Chain do
       expect(subject.call).to eq(:mocked)
     end
   end
+
+  describe "#clone" do
+    subject { TeckelChainTest::Chain.dup }
+    let(:klone) { subject.clone }
+
+    it 'clones' do
+      expect(klone.object_id).not_to be_eql(subject.object_id)
+    end
+
+    it 'clones config' do
+      orig_config = subject.instance_variable_get(:@config)
+      klone_config = klone.instance_variable_get(:@config)
+      expect(klone_config.object_id).not_to be_eql(orig_config.object_id)
+    end
+
+    it 'clones steps' do
+      orig_settings = subject.instance_variable_get(:@config).instance_variable_get(:@config)[:steps]
+      klone_settings = klone.instance_variable_get(:@config).instance_variable_get(:@config)[:steps]
+
+      expect(orig_settings).to be_a(Array)
+      expect(klone_settings).to be_a(Array)
+      expect(klone_settings.object_id).not_to be_eql(orig_settings.object_id)
+    end
+  end
+
+  describe "frozen" do
+    subject { TeckelChainTest::Chain.dup }
+
+    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 steps" do
+      subject.freeze
+      expect {
+        subject.class_eval do
+          step :yet_other, TeckelChainTest::AddFriend
+        end
+      }.to raise_error(frozen_error)
+    end
+
+    it "prevents changes to config" do
+      subject.freeze
+      expect {
+        subject.class_eval do
+          default_settings!(a: { say: "Chain Default" })
+        end
+      }.to raise_error(frozen_error)
+    end
+
+    describe '#clone' do
+      subject { TeckelChainTest::Chain.dup }
+
+      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/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

@@ -26,6 +26,7 @@ module TeckelOperationContractTrace
   end
 end
 
+# rubocop:disable Style/EvalWithLocation
 # Hack to get reliable stack traces
 eval <<~RUBY, binding, "operation_success_error.rb"
   module TeckelOperationContractTrace
@@ -77,6 +78,7 @@ eval <<~RUBY, binding, "operation_input_error.rb"
     end
   end
 RUBY
+# rubocop:enable Style/EvalWithLocation
 
 RSpec.describe Teckel::Operation do
   context "contract errors include meaningful trace" do

data/spec/operation/default_settings_spec.rb

@@ -89,6 +89,32 @@ RSpec.describe Teckel::Operation do
           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/result_spec.rb

@@ -3,21 +3,15 @@
 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) }

data/spec/operation_spec.rb

@@ -229,6 +229,11 @@ module TeckelOperationInjectSettingsTest
 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)
@@ -331,8 +336,7 @@ RSpec.describe Teckel::Operation do
     end
 
     it "uses injected data" do
-      result =
-        TeckelOperationInjectSettingsTest::MyOperation.
+      result = TeckelOperationInjectSettingsTest::MyOperation.
         with(injected: [:stuff]).
         call
 
@@ -342,10 +346,10 @@ 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)
+        op.with(more: :stuff2)
       }.to raise_error(Teckel::Error, "Operation already has settings assigned.")
     end
   end
@@ -396,11 +400,6 @@ RSpec.describe Teckel::Operation do
   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
@@ -480,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/spec_helper.rb

@@ -3,8 +3,15 @@
 require "bundler/setup"
 if ENV['COVERAGE'] == 'true'
   require 'simplecov'
-  require 'simplecov_json_formatter'
-  SimpleCov.formatter = SimpleCov::Formatter::JSONFormatter
+
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: teckel
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Robert Schulze
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-03 00:00:00.000000000 Z
+date: 2021-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: mutant-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -115,6 +129,7 @@ files:
 - spec/chain_spec.rb
 - spec/config_spec.rb
 - spec/doctest_helper.rb
+- spec/operation/config_spec.rb
 - spec/operation/contract_trace_spec.rb
 - spec/operation/default_settings_spec.rb
 - spec/operation/fail_on_input_spec.rb
@@ -133,10 +148,10 @@ homepage: https://github.com/fnordfish/teckel
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://github.com/fnordfish/teckel/blob/master/CHANGELOG.md
+  changelog_uri: https://github.com/fnordfish/teckel/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/fnordfish/teckel
   bug_tracker_uri: https://github.com/fnordfish/teckel/issues
-  documentation_uri: https://www.rubydoc.info/gems/teckel/0.7.0
+  documentation_uri: https://www.rubydoc.info/gems/teckel/0.8.0
   user_docs_uri: https://fnordfish.github.io/teckel/
 post_install_message:
 rdoc_options: []
@@ -153,7 +168,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
 summary: Operations with enforced in/out/err data structures
@@ -166,6 +181,7 @@ test_files:
 - spec/chain_spec.rb
 - spec/config_spec.rb
 - spec/doctest_helper.rb
+- spec/operation/config_spec.rb
 - spec/operation/contract_trace_spec.rb
 - spec/operation/default_settings_spec.rb
 - spec/operation/fail_on_input_spec.rb