mutest 0.0.1 → 0.0.2

data/spec/unit/mutest/util/one_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe Mutest::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/mutest/warning_filter_spec.rb

@@ -0,0 +1,99 @@
+RSpec.describe Mutest::WarningFilter do
+  let(:object) { described_class.new(target) }
+
+  let(:target) do
+    acc = writes
+    Module.new do
+      define_singleton_method(:write, &acc.method(:<<))
+    end
+  end
+
+  let(:writes) { [] }
+
+  describe '#write' do
+    subject { object.write(message) }
+
+    context 'when writing a non warning message' do
+      let(:message) { 'foo' }
+
+      it 'writes message' do
+        expect { subject }.to change { writes }.from([]).to([message])
+      end
+
+      it 'does not capture warning' do
+        subject
+        expect(subject.warnings).to eql([])
+      end
+    end
+
+    context 'when writing a warning message' do
+      let(:message) { "test.rb:1: warning: some warning\n" }
+
+      it 'captures warning' do
+        expect { subject }.to change { object.warnings }.from([]).to([message])
+      end
+
+      it 'does not write message' do
+        subject
+        expect(writes).to eql([])
+      end
+    end
+  end
+
+  describe '.use' do
+    let(:object) { described_class }
+
+    it 'executes block with warning filter enabled' do
+      found = false
+      object.use do
+        found = $stderr.instance_of?(described_class)
+      end
+      expect(found).to be(true)
+    end
+
+    it 'resets to original stderr after execution with exception ' do
+      original = $stderr
+      begin
+        object.use { fail }
+      rescue
+        :make_rubo_cop_happy
+      end
+      expect($stderr).to be(original)
+    end
+
+    it 'returns warnings generated within block' do
+      warnings =
+        object.use do
+          # rubocop:disable Security/Eval
+          eval(<<-RUBY)
+            Class.new do
+              def foo
+              end
+
+              def foo
+              end
+            end
+          RUBY
+        end
+      expect(warnings).to eql(
+        [
+          "(eval):5: warning: method redefined; discarding old foo\n",
+          "(eval):2: warning: previous definition of foo was here\n"
+        ]
+      )
+    end
+
+    it 'passes through non warning writes' do
+      expect($stderr).to receive(:write).with('foo')
+      object.use do
+        $stderr.write('foo')
+      end
+    end
+
+    it 'resets to original stderr after execution' do
+      original = $stderr
+      object.use {}
+      expect($stderr).to be(original)
+    end
+  end
+end

data/spec/unit/mutest/zombifier_spec.rb

@@ -0,0 +1,120 @@
+RSpec.describe Mutest::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
+    MutestSpec::RubyVM.new(
+      [
+        MutestSpec::RubyVM::EventExpectation::Require.new(
+          expected_payload: {
+            logical_name: 'project'
+          },
+          return_value:     true
+        ),
+        MutestSpec::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
+        ),
+        MutestSpec::RubyVM::EventExpectation::Require.new(
+          expected_payload: {
+            logical_name: 'foo'
+          },
+          trigger_requires: %w[bar],
+          return_value:     true
+        ),
+        MutestSpec::RubyVM::EventExpectation::Require.new(
+          expected_payload: {
+            logical_name: 'bar'
+          },
+          return_value:     true
+        ),
+        MutestSpec::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
+        ),
+        MutestSpec::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
+    MutestSpec::FileSystem.new(
+      Hash[
+        file_entries.map { |key, attributes| [key, MutestSpec::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/spec/unit/mutest_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe Mutest do
+  let(:object) { described_class }
+
+  describe '.ci?' do
+    subject { object.ci? }
+
+    let(:value) { instance_double(Object, 'value') }
+
+    before do
+      expect(ENV).to receive(:key?).with('CI').and_return(value)
+    end
+
+    it { is_expected.to be(value) }
+  end
+end

data/test_app/.rspec

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

data/test_app/Gemfile.rspec3.4

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

data/test_app/Gemfile.rspec3.5

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

data/test_app/lib/test_app.rb

@@ -0,0 +1,109 @@
+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
+    class 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/literal'
+$VERBOSE = original

data/test_app/lib/test_app/literal.rb

@@ -0,0 +1,40 @@
+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
+
+    # mutest:disable
+    def disabled_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/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$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

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