mutant 0.9.10 → 0.10.0

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

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Transform::Sequence do
-  subject { described_class.new(steps) }
-
-  let(:steps) do
-    [
-      hash_transform,
-      hash_symbolize
-    ]
-  end
-
-  let(:hash_transform) do
-    Mutant::Transform::Hash.new(optional: [], required: [key_transform])
-  end
-
-  let(:key_transform) do
-    Mutant::Transform::Hash::Key.new('foo', Mutant::Transform::Boolean.new)
-  end
-
-  let(:boolean_transform) do
-    Mutant::Transform::Boolean.new
-  end
-
-  let(:hash_symbolize) do
-    Mutant::Transform::Hash::Symbolize.new
-  end
-
-  describe '#apply' do
-    def apply
-      subject.apply(input)
-    end
-
-    context 'on valid input' do
-      let(:input) { { 'foo' => true } }
-
-      it 'returns success' do
-        expect(apply).to eql(Mutant::Either::Right.new(foo: true))
-      end
-    end
-
-    context 'on invalid input' do
-      let(:input) { { 'foo' => 1 } }
-
-      let(:boolean_error) do
-        Mutant::Transform::Error.new(
-          cause:     nil,
-          input:     1,
-          message:   'Expected: boolean but got: 1',
-          transform: boolean_transform
-        )
-      end
-
-      let(:key_error) do
-        Mutant::Transform::Error.new(
-          cause:     boolean_error,
-          input:     1,
-          message:   nil,
-          transform: key_transform
-        )
-      end
-
-      let(:hash_error) do
-        Mutant::Transform::Error.new(
-          cause:     key_error,
-          input:     input,
-          message:   nil,
-          transform: hash_transform
-        )
-      end
-
-      let(:index_error) do
-        Mutant::Transform::Error.new(
-          cause:     hash_error,
-          input:     input,
-          message:   nil,
-          transform: Mutant::Transform::Index.new(
-            index:     0,
-            transform: hash_transform
-          )
-        )
-      end
-
-      let(:error) do
-        Mutant::Transform::Error.new(
-          cause:     index_error,
-          input:     input,
-          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/util/one_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Util, '.one' do
-  let(:first) { instance_double(Object)                          }
-  let(:array) { instance_double(Array, one?: true, first: first) }
-
-  it 'returns first element' do
-    expect(described_class.one(array)).to be(first)
-  end
-
-  it 'fails if the list is empty' do
-    expect { described_class.one([]) }
-      .to raise_error(described_class::SizeError)
-      .with_message('expected size to be exactly 1 but size was 0')
-  end
-
-  it 'fails if the list has more than one element' do
-    expect { described_class.one([1, 2]) }
-      .to raise_error(described_class::SizeError)
-      .with_message('expected size to be exactly 1 but size was 2')
-  end
-end

data/spec/unit/mutant/warnings_spec.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Warnings do
-  subject { described_class.new(warning_module) }
-
-  before do
-    subject # make sure we infect the module in any case
-  end
-
-  let(:original_messages) do
-    []
-  end
-
-  let(:warning_module) do
-    original_messages = original_messages()
-
-    # Simulation of corelib `Warning` module
-    Module.new do
-      module_function def warn(*arguments)
-        messages << arguments
-      end
-
-      module_function define_method(:messages) { original_messages }
-    end
-  end
-
-  def cause_warnings
-    original_messages.clear
-
-    warning_module = warning_module()
-
-    warning_module.warn('warning-a')
-
-    Class
-      .new { include warning_module }
-      .new
-      .instance_eval { warn('warning-b') }
-  end
-
-  describe '#call' do
-    def apply
-      subject.call { cause_warnings }
-    end
-
-    def expect_captured_messages(captured_messages)
-      expect(captured_messages).to eql([%w[warning-a], %w[warning-b]])
-      expect(captured_messages.frozen?).to eql(true)
-      expect(captured_messages.map(&:frozen?)).to eql([true, true])
-      expect(captured_messages.flat_map(&:frozen?)).to eql([true, true])
-      expect(original_messages).to eql([])
-    end
-
-    def expect_original_messages
-      expect(original_messages).to eql([%w[warning-a], %w[warning-b]])
-    end
-
-    it 'captures expected warnings during block execution' do
-      expect_captured_messages(apply)
-      expect(original_messages).to eql([])
-    end
-
-    it 'captures expected warnings during repeated block execution' do
-      expect_captured_messages(apply)
-      expect_captured_messages(apply)
-    end
-
-    it 'does use original implementation without block execution' do
-      cause_warnings
-      expect_original_messages
-    end
-
-    it 'does use original implementation before block execution' do
-      cause_warnings
-      expect_original_messages
-      expect_captured_messages(apply)
-    end
-
-    it 'does use original implementation after block execution' do
-      expect_captured_messages(apply)
-      cause_warnings
-      expect_original_messages
-    end
-
-    it 'rejects re-entrant use' do
-      expect { subject.call { subject.call } }
-        .to raise_error(described_class::RecursiveUseError)
-    end
-  end
-end

data/spec/unit/mutant/world_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::World do
-  subject do
-    Mutant::WORLD
-  end
-
-  describe '#inspect' do
-    def apply
-      subject.inspect
-    end
-
-    it 'returns expected value' do
-      expect(apply).to eql('#<Mutant::World>')
-    end
-
-    it 'is frozen' do
-      expect(apply.frozen?).to be(true)
-    end
-
-    it 'is idempotent' do
-      expect(apply).to be(apply)
-    end
-  end
-
-  describe '#capture_stdout' do
-    def apply
-      subject.capture_stdout(command)
-    end
-
-    let(:open3)          { class_double(Open3)              }
-    let(:stdout)         { instance_double(String, :stdout) }
-    let(:subject)        { super().with(open3: open3)       }
-    let(:command)        { %w[foo bar baz]                  }
-
-    let(:process_status) do
-      instance_double(
-        Process::Status,
-        success?: success?
-      )
-    end
-
-    before do
-      allow(open3).to receive_messages(capture2: [stdout, process_status])
-    end
-
-    context 'when process exists successful' do
-      let(:success?) { true }
-
-      it 'returns stdout' do
-        expect(apply).to eql(Mutant::Either::Right.new(stdout))
-      end
-    end
-
-    context 'when process exists unsuccessful' do
-      let(:success?) { false }
-
-      it 'returns stdout' do
-        expect(apply).to eql(Mutant::Either::Left.new("Command #{command.inspect} failed!"))
-      end
-    end
-  end
-end

data/spec/unit/mutant/zombifier_spec.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Zombifier do
-  let(:root_require) { Pathname.new('project') }
-  let(:pathname)     { class_double(Pathname)  }
-
-  let(:require_highjack) do
-    lambda do |block|
-      original = ruby_vm.method(:require)
-      allow(ruby_vm).to receive(:require) do |argument|
-        return_value = ruby_vm.expected_events.first.return_value
-        expect(block.call(argument)).to be(return_value)
-      end
-      original
-    end
-  end
-
-  let(:options) do
-    {
-      load_path:        %w[a b],
-      includes:         %w[project bar],
-      namespace:        :Zombie,
-      require_highjack: require_highjack,
-      root_require:     root_require,
-      pathname:         pathname,
-      kernel:           ruby_vm
-    }
-  end
-
-  let(:ruby_vm) do
-    MutantSpec::RubyVM.new(
-      [
-        MutantSpec::RubyVM::EventExpectation::Require.new(
-          expected_payload: {
-            logical_name: 'project'
-          },
-          return_value:     true
-        ),
-        MutantSpec::RubyVM::EventExpectation::Eval.new(
-          expected_payload: {
-            binding:         TOPLEVEL_BINDING,
-            source:          "module Zombie\n  module Project\n  end\nend",
-            source_location: 'a/project.rb'
-          },
-          trigger_requires: %w[foo bar],
-          return_value:     nil
-        ),
-        MutantSpec::RubyVM::EventExpectation::Require.new(
-          expected_payload: {
-            logical_name: 'foo'
-          },
-          trigger_requires: %w[bar],
-          return_value:     true
-        ),
-        MutantSpec::RubyVM::EventExpectation::Require.new(
-          expected_payload: {
-            logical_name: 'bar'
-          },
-          return_value:     true
-        ),
-        MutantSpec::RubyVM::EventExpectation::Eval.new(
-          expected_payload: {
-            binding:         TOPLEVEL_BINDING,
-            source:          "module Zombie\n  module Bar\n  end\nend",
-            source_location: 'b/bar.rb'
-          },
-          trigger_requires: %w[],
-          return_value:     nil
-        ),
-        MutantSpec::RubyVM::EventExpectation::Require.new(
-          expected_payload: {
-            logical_name: 'bar'
-          },
-          return_value:     false
-        )
-      ]
-    )
-  end
-
-  let(:file_entries) do
-    {
-      'a/project.rb' => { file: true, contents: 'module Project; end' },
-      'b/bar.rb'     => { file: true, contents: 'module Bar; end'     }
-    }
-  end
-
-  let(:file_system) do
-    MutantSpec::FileSystem.new(
-      Hash[
-        file_entries.map { |key, attributes| [key, MutantSpec::FileState.new(attributes)] }
-      ]
-    )
-  end
-
-  describe '.call' do
-    def apply
-      described_class.call(options)
-    end
-
-    before do
-      allow(pathname).to receive(:new, &file_system.method(:path))
-    end
-
-    it 'returns self' do
-      expect(apply).to be(described_class)
-    end
-
-    it 'walks the VM through expected steps' do
-      expect { apply }.to change(ruby_vm, :done?).from(false).to(true)
-    end
-
-    context 'when zombifier require fails' do
-      let(:file_entries) do
-        {}
-      end
-
-      it 'raises zombifier specific load error' do
-        expect { apply }.to raise_error(described_class::LoadError, 'Cannot find file "project.rb" in load path')
-      end
-    end
-  end
-end

data/test_app/.rspec

@@ -1 +0,0 @@
---color

data/test_app/Gemfile.minitest

@@ -1,6 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'mutant',          path: '../'
-gem 'mutant-minitest', path: '../'
-
-eval_gemfile File.expand_path('../../Gemfile.shared', __FILE__)

data/test_app/Gemfile.rspec3.8

@@ -1,7 +0,0 @@
-source 'https://rubygems.org'
-gem 'rspec',      '~> 3.8.0'
-gem 'rspec-core', '~> 3.8.0'
-gem 'mutant',       path: '../'
-gem 'mutant-rspec', path: '../'
-gem 'adamantium'
-eval_gemfile File.expand_path('../../Gemfile.shared', __FILE__)

data/test_app/lib/test_app.rb

@@ -1,114 +0,0 @@
-require 'adamantium'
-
-original = $VERBOSE
-# Silence intentional violations made to exercise the method matcher edge cases.
-# This is NOT representative for could you should write!
-$VERBOSE = false
-# Namespace for test application
-module TestApp
-  module InstanceMethodTests
-    module WithMemoizer
-      include Adamantium
-
-      def bar; end; def baz; end
-      eval('def boz; end')
-      def foo; end;
-      memoize :foo
-    end
-
-    module DefinedMultipleTimes
-      class DifferentLines
-        def foo
-        end
-
-        def foo(_arg)
-        end
-      end
-
-      class SameLineSameScope
-        def foo; end; def foo(_arg); end
-      end
-
-      class SameLineDifferentScope
-        def self.foo; end; def foo(_arg); end
-      end
-    end
-
-    class InClassEval
-      class_eval do
-        def foo
-        end
-      end
-    end
-
-    class InModuleEval
-      module_eval do
-        def foo
-        end
-      end
-    end
-
-    class InInstanceEval
-      module_eval do
-        def foo
-        end
-      end
-    end
-  end
-
-  module SingletonMethodTests
-    module DefinedOnSelf
-      def self.foo; end
-    end
-
-    module DefinedOnLvar
-      a = self
-      def a.foo; end
-    end
-
-    module DefinedOnConstant
-      module InsideNamespace
-        def InsideNamespace.foo
-        end
-      end
-
-      module OutsideNamespace
-      end
-
-      def OutsideNamespace.foo
-      end
-    end
-
-    module DefinedMultipleTimes
-      module DifferentLines
-        def self.foo
-        end
-
-        def self.foo(_arg)
-        end
-      end
-
-      module SameLine
-        module SameScope
-          def self.foo; end; def self.foo(_arg); end
-        end
-
-        module DifferentScope
-          def self.foo; end; def DifferentScope.foo(_arg); end; def SingletonMethodTests.foo; end
-        end
-
-        module DifferentName
-          def self.foo; end; def self.bar(_arg); end
-        end
-      end
-    end
-  end
-
-  def self.root
-    File.expand_path('..', __dir__)
-  end
-end
-
-require 'test_app/metaclasses'
-require 'test_app/literal'
-$VERBOSE = original