mutant 0.9.9 → 0.9.14

data/spec/unit/mutant/subject_spec.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Subject do
-  let(:class_under_test) do
-    Class.new(described_class) do
-      def expression
-        Mutant::Expression::Namespace::Exact.new(scope_name: 'SubjectA')
-      end
-
-      def match_expressions
-        [
-          expression,
-          Mutant::Expression::Namespace::Exact.new(scope_name: 'SubjectB')
-        ]
-      end
-    end
-  end
-
-  let(:object) do
-    class_under_test.new(
-      context:  context,
-      node:     node,
-      warnings: warnings
-    )
-  end
-
-  let(:node) do
-    Unparser.parse(<<-RUBY)
-      def foo
-      end
-    RUBY
-  end
-
-  let(:context) do
-    double(
-      'Context',
-      source_path: 'source_path'
-    )
-  end
-
-  let(:warnings) { instance_double(Mutant::Warnings) }
-
-  describe '#identification' do
-    subject { object.identification }
-
-    it { should eql('SubjectA:source_path:1') }
-  end
-
-  describe '#source_line' do
-    subject { object.source_line }
-
-    it { should be(1) }
-  end
-
-  describe '#source_lines' do
-    subject { object.source_lines }
-
-    it { should eql(1..2) }
-  end
-
-  describe '#prepare' do
-    subject { object.prepare }
-
-    it_should_behave_like 'a command method'
-  end
-
-  describe '#node' do
-    subject { object.node }
-
-    it { should be(node) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  describe '#mutations' do
-    subject { object.mutations }
-
-    before do
-      expect(Mutant::Mutator).to receive(:mutate).with(node).and_return([mutation_a, mutation_b])
-    end
-
-    let(:mutation_a) { instance_double(Parser::AST::Node, :mutation_a) }
-    let(:mutation_b) { instance_double(Parser::AST::Node, :mutation_b) }
-
-    it 'generates neutral and evil mutations' do
-      should eql([
-        Mutant::Mutation::Neutral.new(object, node),
-        Mutant::Mutation::Evil.new(object, mutation_a),
-        Mutant::Mutation::Evil.new(object, mutation_b)
-      ])
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Transform::Array do
-  subject { described_class.new(transform) }
-
-  let(:transform) { Mutant::Transform::Boolean.new }
-
-  describe '#apply' do
-    def apply
-      subject.apply(input)
-    end
-
-    context 'on array input' do
-      context 'empty' do
-        let(:input) { [] }
-
-        it 'returns sucess' do
-          expect(apply).to eql(Mutant::Either::Right.new(input))
-        end
-      end
-
-      context 'valid elements' do
-        let(:input) { [true, true] }
-
-        it 'returns sucess' do
-          expect(apply).to eql(Mutant::Either::Right.new(input))
-        end
-      end
-
-      context 'invalid elements' do
-        let(:input) { [true, 1] }
-
-        let(:boolean_error) do
-          Mutant::Transform::Error.new(
-            cause:     nil,
-            input:     1,
-            message:   'Expected: boolean but got: 1',
-            transform: transform
-          )
-        end
-
-        let(:index_error) do
-          Mutant::Transform::Error.new(
-            cause:     boolean_error,
-            input:     1,
-            message:   nil,
-            transform: Mutant::Transform::Index.new(index: 1, transform: transform)
-          )
-        end
-
-        let(:error) do
-          Mutant::Transform::Error.new(
-            cause:     index_error,
-            input:     input,
-            message:   'Failed to coerce array at index: 1',
-            transform: subject
-          )
-        end
-
-        it 'returns failure' do
-          expect(apply).to eql(Mutant::Either::Left.new(error))
-        end
-      end
-
-      context 'transformed elements' do
-        let(:input)     { [{ 'foo' => 'bar' }]                   }
-        let(:transform) { Mutant::Transform::Hash::Symbolize.new }
-
-        it 'returns transformed elements' do
-          expect(apply).to eql(Mutant::Either::Right.new([foo: 'bar']))
-        end
-      end
-    end
-
-    context 'on other input' do
-      let(:input) { false }
-
-      let(:error) do
-        Mutant::Transform::Error.new(
-          cause:     nil,
-          input:     input,
-          message:   'Expected: Array but got: FalseClass',
-          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/bool_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Transform::Boolean do
-  subject { described_class.new }
-
-  let(:primitive) { String }
-
-  describe '#apply' do
-    def apply
-      subject.apply(input)
-    end
-
-    context 'on true' do
-      let(:input) { true }
-
-      it 'returns sucess' do
-        expect(apply).to eql(Mutant::Either::Right.new(input))
-      end
-    end
-
-    context 'on false' do
-      let(:input) { false }
-
-      it 'returns sucess' do
-        expect(apply).to eql(Mutant::Either::Right.new(input))
-      end
-    end
-
-    context 'on nil input' do
-      let(:input) { nil }
-
-      let(:error) do
-        Mutant::Transform::Error.new(
-          cause:     nil,
-          input:     input,
-          message:   'Expected: boolean but got: nil',
-          transform: subject
-        )
-      end
-
-      it 'returns failure' do
-        expect(apply).to eql(Mutant::Either::Left.new(error))
-      end
-    end
-
-    context 'on truthy input' do
-      let(:input) { '' }
-
-      let(:error) do
-        Mutant::Transform::Error.new(
-          cause:     nil,
-          input:     input,
-          message:   'Expected: boolean but got: ""',
-          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/error_spec.rb

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

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

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