mutant 0.8.24 → 0.9.0

data/spec/unit/mutant/transform/error_spec.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Transform::Error do
+  subject { described_class.new(attributes) }
+
+  let(:message)        { 'root-message' }
+  let(:direct_cause)   { nil            }
+  let(:indirect_cause) { nil            }
+
+  let(:attributes) do
+    transform =
+      if direct_cause
+        Mutant::Transform::Named.new('root', direct_cause.transform)
+      else
+        Mutant::Transform::Boolean.new
+      end
+
+    {
+      cause:     direct_cause,
+      input:     nil,
+      message:   message,
+      transform: transform
+    }
+  end
+
+  shared_context 'direct cause' do
+    let(:direct_cause) do
+      transform =
+        if indirect_cause
+          Mutant::Transform::Named.new('direct-cause', indirect_cause.transform)
+        else
+          Mutant::Transform::Boolean.new
+        end
+
+      described_class.new(
+        cause:     indirect_cause,
+        input:     nil,
+        message:   'direct-cause-message',
+        transform: transform
+      )
+    end
+  end
+
+  shared_examples 'indirect cause' do
+    let(:indirect_cause) do
+      described_class.new(
+        cause:     nil,
+        input:     nil,
+        message:   'indirect-cause-message',
+        transform: Mutant::Transform::Boolean.new
+      )
+    end
+  end
+
+  describe '#trace' do
+    def apply
+      subject.trace
+    end
+
+    context 'without cause' do
+      it 'returns path to self' do
+        expect(apply).to eql([subject])
+      end
+    end
+
+    context 'with direct cause' do
+      include_context 'direct cause'
+
+      it 'returns path to direct cause' do
+        expect(apply).to eql([subject, direct_cause])
+      end
+    end
+
+    context 'with indirect cause' do
+      include_context 'direct cause'
+      include_context 'indirect cause'
+
+      it 'returns path to direct cause' do
+        expect(apply).to eql([subject, direct_cause, indirect_cause])
+      end
+    end
+  end
+
+  describe '#compact_message' do
+    def apply
+      subject.compact_message
+    end
+
+    context 'root cause' do
+      it 'returns expected message' do
+        expect(apply).to eql('Mutant::Transform::Boolean: root-message')
+      end
+    end
+
+    context 'with direct cause' do
+      include_context 'direct cause'
+
+      it 'returns expected message' do
+        expect(apply).to eql(<<~'MESSAGE'.chomp)
+          root/Mutant::Transform::Boolean: direct-cause-message
+        MESSAGE
+      end
+    end
+
+    context 'with indirect cause' do
+      include_context 'direct cause'
+      include_context 'indirect cause'
+
+      context 'with present slugs' do
+        it 'returns expected message' do
+          expect(apply).to eql(<<~'MESSAGE'.chomp)
+            root/direct-cause/Mutant::Transform::Boolean: indirect-cause-message
+          MESSAGE
+        end
+      end
+
+      context 'with empty slug' do
+        let(:direct_cause) do
+          super().with(
+            transform: Mutant::Transform::Named.new('', indirect_cause.transform)
+          )
+        end
+
+        it 'returns expected message' do
+          expect(apply).to eql(<<~'MESSAGE'.chomp)
+            root/Mutant::Transform::Boolean: indirect-cause-message
+          MESSAGE
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutant/transform/exception_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Transform::Exception do
+  subject { described_class.new(error_class, block) }
+
+  let(:error_class) do
+    Class.new(RuntimeError)
+  end
+
+  describe '#apply' do
+    def apply
+      subject.apply(input)
+    end
+
+    let(:input) { 2 }
+
+    context 'block that does not raise' do
+      let(:block) { ->(input) { input*input } }
+
+      it 'returns expected success value' do
+        expect(apply).to eql(Mutant::Either::Right.new(4))
+      end
+    end
+
+    context 'on block that raises' do
+      context 'a covered exception' do
+        let(:block) { ->(_input) { fail(error_class, 'some message') } }
+
+        let(:error) do
+          Mutant::Transform::Error.new(
+            cause:     nil,
+            input:     input,
+            message:   'some message',
+            transform: subject
+          )
+        end
+
+        it 'returns expected error' do
+          expect(apply).to eql(Mutant::Either::Left.new(error))
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutant/transform/hash_spec.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Transform::Hash do
+  subject { described_class.new(attributes) }
+
+  let(:required) { []                                       }
+  let(:optional) { []                                       }
+  let(:symbol)   { Mutant::Transform::Primitive.new(Symbol) }
+
+  let(:attributes) do
+    {
+      required: required,
+      optional: optional
+    }
+  end
+
+  describe '#apply' do
+    def apply
+      subject.apply(input)
+    end
+
+    context 'on Hash input' do
+      context 'empty' do
+        let(:input) { {} }
+
+        it 'returns sucess' do
+          expect(apply).to eql(Mutant::Either::Right.new(input))
+        end
+      end
+
+      context 'missing key' do
+        let(:input)    { {}                                       }
+        let(:required) { [described_class::Key.new(:foo, symbol)] }
+
+        let(:error) do
+          Mutant::Transform::Error.new(
+            cause:     nil,
+            input:     input,
+            message:   'Missing keys: [:foo], Unexpected keys: []',
+            transform: subject
+          )
+        end
+
+        it 'returns error' do
+          expect(apply).to eql(Mutant::Either::Left.new(error))
+        end
+      end
+
+      context 'extra key' do
+        let(:input) { { foo: :bar } }
+
+        let(:error) do
+          Mutant::Transform::Error.new(
+            cause:     nil,
+            input:     input,
+            message:   'Missing keys: [], Unexpected keys: [:foo]',
+            transform: subject
+          )
+        end
+
+        it 'returns error' do
+          expect(apply).to eql(Mutant::Either::Left.new(error))
+        end
+      end
+
+      context 'using required' do
+        let(:input)    { { foo: :bar }                            }
+        let(:required) { [described_class::Key.new(:foo, symbol)] }
+
+        it 'returns success' do
+          expect(apply).to eql(Mutant::Either::Right.new(input))
+        end
+      end
+
+      context 'using optional' do
+        let(:optional) { [described_class::Key.new(:foo, symbol)] }
+
+        context 'not providing the optional key' do
+          let(:input) { {} }
+
+          it 'returns success' do
+            expect(apply).to eql(Mutant::Either::Right.new(input))
+          end
+        end
+
+        context 'providing the optional key' do
+          let(:input) { { foo: :bar } }
+
+          it 'returns success' do
+            expect(apply).to eql(Mutant::Either::Right.new(input))
+          end
+        end
+      end
+
+      shared_examples 'key transform error' do
+        let(:innermost_error) do
+          Mutant::Transform::Error.new(
+            cause:     nil,
+            input:     'bar',
+            message:   'Expected: Symbol but got: String',
+            transform: symbol
+          )
+        end
+
+        let(:inner_error) do
+          Mutant::Transform::Error.new(
+            cause:     innermost_error,
+            input:     'bar',
+            message:   nil,
+            transform: key_transform
+          )
+        end
+
+        let(:error) do
+          Mutant::Transform::Error.new(
+            cause:     inner_error,
+            input:     input,
+            message:   nil,
+            transform: subject
+          )
+        end
+
+        it 'returns failure' do
+          expect(apply).to eql(Mutant::Either::Left.new(error))
+        end
+      end
+
+      context 'key transform error' do
+        let(:input) { { foo: 'bar' } }
+
+        let(:key_transform) { described_class::Key.new(:foo, symbol) }
+
+        context 'on optional key' do
+          let(:optional) { [key_transform] }
+
+          include_examples 'key transform error'
+        end
+
+        context 'on required key' do
+          let(:required) { [key_transform] }
+
+          include_examples 'key transform error'
+        end
+      end
+    end
+
+    context 'on other input' do
+      let(:input) { [] }
+
+      let(:error) do
+        Mutant::Transform::Error.new(
+          cause:     nil,
+          input:     input,
+          message:   'Expected: Hash but got: Array',
+          transform: subject
+        )
+      end
+
+      it 'returns failure' do
+        expect(apply).to eql(Mutant::Either::Left.new(error))
+      end
+    end
+  end
+end
+
+RSpec.describe Mutant::Transform::Hash::Symbolize do
+  subject { described_class.new }
+
+  describe '#apply' do
+    def apply
+      subject.apply(input)
+    end
+
+    let(:input) { { 'foo' => 'bar' } }
+
+    it 'returns success' do
+      expect(apply).to eql(Mutant::Either::Right.new(foo: 'bar'))
+    end
+  end
+end
+
+RSpec.describe Mutant::Transform::Hash::Key do
+  subject { described_class.new(:foo, boolean) }
+
+  let(:boolean) { Mutant::Transform::Boolean.new }
+
+  describe '#slug' do
+    def apply
+      subject.slug
+    end
+
+    it 'returns expected slug' do
+      expect(apply).to eql('[:foo]')
+    end
+  end
+
+  describe '#apply' do
+    def apply
+      subject.apply(input)
+    end
+
+    context 'on valid input' do
+      let(:input) { true }
+
+      it 'returns success' do
+        expect(apply).to eql(Mutant::Either::Right.new(true))
+      end
+    end
+
+    context 'on invalid input' do
+      let(:input) { 1 }
+
+      let(:inner_error) do
+        Mutant::Transform::Error.new(
+          cause:     nil,
+          input:     1,
+          message:   'Expected: boolean but got: 1',
+          transform: boolean
+        )
+      end
+
+      let(:error) do
+        Mutant::Transform::Error.new(
+          cause:     inner_error,
+          input:     1,
+          message:   nil,
+          transform: subject
+        )
+      end
+
+      it 'returns failure' do
+        expect(apply).to eql(Mutant::Either::Left.new(error))
+      end
+    end
+  end
+end

data/spec/unit/mutant/transform/index_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Transform::Index do
+  subject { described_class.new(index: index, transform: transform) }
+
+  let(:index)     { 1                              }
+  let(:transform) { Mutant::Transform::Boolean.new }
+
+  describe '#slug' do
+    def apply
+      subject.slug
+    end
+
+    it 'retursn expected value' do
+      expect(apply).to eql('1')
+    end
+
+    it 'returns frozen value' do
+      expect(apply.frozen?).to be(true)
+    end
+
+    it 'returns idempotent value' do
+      expect(apply).to be(apply)
+    end
+  end
+
+  describe '#apply' do
+    def apply
+      subject.apply(input)
+    end
+
+    context 'on valid input' do
+      let(:input) { true }
+
+      it 'returns sucess' do
+        expect(apply).to eql(Mutant::Either::Right.new(input))
+      end
+    end
+
+    context 'on nvalid input' do
+      let(:input) { 1 }
+
+      let(:boolean_error) do
+        Mutant::Transform::Error.new(
+          cause:     nil,
+          input:     input,
+          message:   'Expected: boolean but got: 1',
+          transform: transform
+        )
+      end
+
+      let(:error) do
+        Mutant::Transform::Error.new(
+          cause:     boolean_error,
+          input:     input,
+          message:   nil,
+          transform: subject
+        )
+      end
+
+      it 'returns failure' do
+        expect(apply).to eql(Mutant::Either::Left.new(error))
+      end
+    end
+  end
+
+  describe '.wrap' do
+    def apply
+      described_class.wrap(error, index)
+    end
+
+    let(:error) do
+      Mutant::Transform::Error.new(
+        cause:     :nil,
+        input:     1,
+        message:   nil,
+        transform: transform
+      )
+    end
+
+    it 'returns wrapped error' do
+      expect(apply).to eql(
+        Mutant::Transform::Error.new(
+          cause:     error,
+          input:     1,
+          message:   nil,
+          transform: described_class.new(index: index, transform: transform)
+        )
+      )
+    end
+  end
+end