mutant 0.9.9 → 0.9.14

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,4 +0,0 @@
-source 'https://rubygems.org'
-
-gem 'mutant',          path: '../'
-gem 'mutant-minitest', path: '../'

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,110 +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
-end
-
-require 'test_app/metaclasses'
-require 'test_app/literal'
-$VERBOSE = original

data/test_app/lib/test_app/literal.rb

@@ -1,35 +0,0 @@
-module TestApp
-  # Class for integration testing literal mutations
-  class Literal
-    def boolean
-      true
-    end
-
-    def command(_foo)
-      self
-    end
-
-    def string
-      'string'
-    end
-
-    def uncovered_string
-      'string'
-    end
-
-    def self.string
-      'string'
-    end
-
-    def symbol
-      :symbol
-    end
-
-    def float
-      2.4
-    end
-  end
-
-  class Empty
-  end
-end

data/test_app/lib/test_app/metaclasses.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module TestApp
-  module MetaclassMethodTests
-    module DefinedOnSelf
-      class << self
-        def foo; end
-      end
-
-      # again this is a weird edge-case that's being checked for consistent
-      # behaviour, not something that people ought to be doing.
-      module InsideMetaclass
-        class << self
-          # some older versions of ruby don't have Object#singleton_class,
-          # this is just an implementation of that so we can grab
-          # InsideMetaclass.metaclass for use as the scope object
-          def metaclass
-            class << self
-              self
-            end
-          end
-
-          # InsideMetaclass.foo
-          def foo; end
-
-          class << self
-            # #<Class:InsideMetaclass>.foo
-            def foo; end
-          end
-        end
-      end
-    end
-
-    module DefinedOnLvar
-      a = self
-      class << a
-        def foo; end
-      end
-    end
-
-    module DefinedOnConstant
-      module InsideNamespace
-        class << InsideNamespace
-          def foo; end
-        end
-      end
-
-      module OutsideNamespace
-      end
-
-      class << OutsideNamespace
-        def foo
-        end
-      end
-    end
-
-    module DefinedMultipleTimes
-      module DifferentLines
-        class << self
-          def foo
-          end
-
-          def foo(_arg)
-          end
-        end
-      end
-
-      module SameLine
-        module SameScope
-          class << self
-            def foo; end; def foo(_arg); end
-          end
-        end
-
-        module DifferentScope
-          class << self; def foo; end; end; class << DifferentScope; def foo(_arg); end; end; class << MetaclassMethodTests; def foo; end; end
-        end
-
-        module DifferentName
-          class << self; def foo; end; def bar(_arg); end; end
-        end
-      end
-    end
-
-    module NotActuallyInAMetaclass
-      class << self
-        # some older versions of ruby don't have Object#singleton_class,
-        # this is just an implementation of that so we can grab
-        # InsideMetaclass.metaclass for use as the scope object
-        def metaclass
-          class << self
-            self
-          end
-        end
-
-        # this is a very weird construction that I do not recommend.
-        # to access SomeClass you have to do
-        # NotActuallyInAMetaclass.singleton_class::SomeClass. Very weird
-        # This is only here so we can test that metaclass_receiver? correctly
-        # returns false
-        class SomeClass
-          def foo
-          end
-        end
-      end
-    end
-  end
-end

data/test_app/spec/spec_helper.rb

@@ -1,9 +0,0 @@
-$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib')
-
-require 'test_app'
-require 'rspec'
-
-# require spec support files and shared behavior
-Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each do |file|
-  require file
-end

data/test_app/spec/unit/test_app/literal_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe TestApp::Literal do
-
-  describe '#command' do
-    subject { object.command(double) }
-
-    let(:object) { described_class.new }
-
-    it { should be(object) }
-  end
-
-  describe '#string' do
-    subject { object.string }
-
-    let(:object) { described_class.new }
-
-    it { should eql('string') }
-  end
-end

data/test_app/test/unit/test_app/literal_test.rb

@@ -1,16 +0,0 @@
-require 'minitest/autorun'
-require 'mutant/minitest/coverage'
-
-class LiteralTest < Minitest::Test
-  cover 'TestApp::Literal*'
-
-  def test_command
-    object = ::TestApp::Literal.new
-
-    assert_equal(object, object.command('x'))
-  end
-
-  def test_string
-    assert_equal('string', ::TestApp::Literal.new.string)
-  end
-end