mutant 0.5.26 → 0.6.0

data/spec/unit/mutant/diff_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe Mutant::Diff do
+RSpec.describe Mutant::Diff do
   let(:object) { described_class }
 
   describe '.build' do
@@ -14,27 +12,27 @@ describe Mutant::Diff do
 
   end
 
-  describe '.colorize_line' do
-    let(:object) { described_class }
-
-    subject { object.colorize_line(line) }
-
-    context 'line beginning with "+"' do
-      let(:line) { '+line' }
+  describe '#colorized_diff' do
+    let(:object) { described_class.new(old, new) }
 
-      it { should eql(Mutant::Color::GREEN.format(line)) }
-    end
+    subject { object.colorized_diff }
 
-    context 'line beginning with "-"' do
-      let(:line) { '-line' }
+    context 'when there is a diff at begin of hunk' do
+      let(:old) { %w[foo bar] }
+      let(:new) { %w[baz bar] }
 
-      it { should eql(Mutant::Color::RED.format(line)) }
-    end
+      let(:expectation) do
+        [
+          "@@ -1,3 +1,3 @@\n",
+          Mutant::Color::RED.format("-foo\n"),
+          Mutant::Color::GREEN.format("+baz\n"),
+          " bar\n"
+        ].join
+      end
 
-    context 'line beginning in other char' do
-      let(:line) { ' line' }
+      it { should eql(expectation) }
 
-      it { should eql(line) }
+      it_should_behave_like 'an idempotent method'
     end
   end
 
@@ -43,6 +41,26 @@ describe Mutant::Diff do
 
     subject { object.diff }
 
+    context 'when there is a diff at begin and end' do
+      let(:old) { %w[foo bar foo] }
+      let(:new) { %w[baz bar baz] }
+
+      let(:expectation) do
+        strip_indent(<<-STR)
+          @@ -1,4 +1,4 @@
+          -foo
+          +baz
+           bar
+          -foo
+          +baz
+        STR
+      end
+
+      it { should eql(expectation) }
+
+      it_should_behave_like 'an idempotent method'
+    end
+
     context 'when there is a diff at begin of hunk' do
       let(:old) { %w[foo bar] }
       let(:new) { %w[baz bar] }

data/spec/unit/mutant/expression/method_spec.rb

@@ -1,9 +1,7 @@
-require 'spec_helper'
-
-describe Mutant::Expression::Method do
+RSpec.describe Mutant::Expression::Method do
 
   let(:object)           { described_class.parse(input) }
-  let(:cache)            { Mutant::Cache.new            }
+  let(:env)              { Fixtures::TEST_ENV           }
   let(:instance_method)  { 'TestApp::Literal#string'    }
   let(:singleton_method) { 'TestApp::Literal.string'    }
 
@@ -26,14 +24,14 @@ describe Mutant::Expression::Method do
   end
 
   describe '#matcher' do
-    subject { object.matcher(cache) }
+    subject { object.matcher(env) }
 
     context 'with an instance method' do
       let(:input) { instance_method }
 
       it 'returns correct matcher' do
         should eql(Mutant::Matcher::Method::Instance.new(
-          cache,
+          env,
           TestApp::Literal, TestApp::Literal.instance_method(:string)
         ))
       end
@@ -42,7 +40,7 @@ describe Mutant::Expression::Method do
     context 'with a singleton method' do
       let(:input) { singleton_method }
 
-      it { should eql(Mutant::Matcher::Method::Singleton.new(cache, TestApp::Literal, TestApp::Literal.method(:string))) }
+      it { should eql(Mutant::Matcher::Method::Singleton.new(env, TestApp::Literal, TestApp::Literal.method(:string))) }
     end
   end
 end

data/spec/unit/mutant/expression/methods_spec.rb

@@ -1,9 +1,7 @@
-require 'spec_helper'
-
-describe Mutant::Expression::Methods do
+RSpec.describe Mutant::Expression::Methods do
 
   let(:object)            { described_class.parse(input) }
-  let(:cache)             { Mutant::Cache.new            }
+  let(:env)               { Fixtures::TEST_ENV           }
   let(:instance_methods)  { 'TestApp::Literal#'          }
   let(:singleton_methods) { 'TestApp::Literal.'          }
 
@@ -26,18 +24,18 @@ describe Mutant::Expression::Methods do
   end
 
   describe '#matcher' do
-    subject { object.matcher(cache) }
+    subject { object.matcher(env) }
 
     context 'with an instance method' do
       let(:input) { instance_methods }
 
-      it { should eql(Mutant::Matcher::Methods::Instance.new(cache, TestApp::Literal)) }
+      it { should eql(Mutant::Matcher::Methods::Instance.new(env, TestApp::Literal)) }
     end
 
     context 'with a singleton method' do
       let(:input) { singleton_methods }
 
-      it { should eql(Mutant::Matcher::Methods::Singleton.new(cache, TestApp::Literal)) }
+      it { should eql(Mutant::Matcher::Methods::Singleton.new(env, TestApp::Literal)) }
     end
   end
 end

data/spec/unit/mutant/expression/namespace/flat_spec.rb

@@ -1,15 +1,13 @@
-require 'spec_helper'
+RSpec.describe Mutant::Expression::Namespace::Exact do
 
-describe Mutant::Expression::Namespace::Exact do
-
-  let(:object)            { described_class.parse(input) }
-  let(:cache)             { Mutant::Cache.new            }
-  let(:input)             { 'TestApp::Literal'           }
+  let(:object) { described_class.parse(input) }
+  let(:env)    { Fixtures::TEST_ENV           }
+  let(:input)  { 'TestApp::Literal'           }
 
   describe '#matcher' do
-    subject { object.matcher(cache) }
+    subject { object.matcher(env) }
 
-    it { should eql(Mutant::Matcher::Scope.new(cache, TestApp::Literal, object)) }
+    it { should eql(Mutant::Matcher::Scope.new(env, TestApp::Literal, object)) }
   end
 
   describe '#match_length' do

data/spec/unit/mutant/expression/namespace/recursive_spec.rb

@@ -1,14 +1,13 @@
-require 'spec_helper'
-
-describe Mutant::Expression::Namespace::Recursive do
+RSpec.describe Mutant::Expression::Namespace::Recursive do
 
   let(:object) { described_class.parse(input) }
-  let(:cache)  { Mutant::Cache.new                   }
-  let(:input)  { 'TestApp::Literal*'                 }
+  let(:input)  { 'TestApp::Literal*'          }
+  let(:env)    { Fixtures::TEST_ENV           }
 
   describe '#matcher' do
-    subject { object.matcher(cache) }
-    it { should eql(Mutant::Matcher::Namespace.new(cache, object)) }
+    subject { object.matcher(env) }
+
+    it { should eql(Mutant::Matcher::Namespace.new(env, object)) }
   end
 
   describe '#match_length' do

data/spec/unit/mutant/expression_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe Mutant::Expression do
+RSpec.describe Mutant::Expression do
   let(:object) { described_class }
 
   describe '.try_parse' do
@@ -18,7 +16,7 @@ describe Mutant::Expression do
       it { should eql(Mutant::Expression::Namespace::Exact.new('Foo')) }
     end
 
-    context 'on ambigious expression' do
+    context 'on ambiguous expression' do
       class ExpressionA < Mutant::Expression
         register(/\Atest-syntax\z/)
       end
@@ -30,11 +28,22 @@ describe Mutant::Expression do
       let(:input) { 'test-syntax' }
 
       it 'raises an exception' do
-        expect { subject }.to raise_error(Mutant::Expression::AmbigousExpressionError, 'Ambigous expression: "test-syntax"')
+        expect { subject }.to raise_error(
+          Mutant::Expression::AmbiguousExpressionError,
+          'Ambiguous expression: "test-syntax"'
+        )
       end
     end
   end
 
+  describe '#inspect' do
+    let(:object) { described_class.parse('Foo') }
+    subject { object.inspect }
+
+    it { should eql('<Mutant::Expression: Foo>') }
+    it_should_behave_like 'an idempotent method'
+  end
+
   describe '.parse' do
     subject { object.parse(input) }
 

data/spec/unit/mutant/integration_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe Mutant::Integration do
+RSpec.describe Mutant::Integration do
 
   let(:class_under_test) do
     Class.new(described_class)
@@ -13,3 +11,16 @@ describe Mutant::Integration do
     it_should_behave_like 'a command method'
   end
 end
+
+RSpec.describe Mutant::Integration::Null do
+
+  let(:object) { described_class.new }
+
+  describe '#setup' do
+    subject { object.all_tests }
+
+    it { should eql([]) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

data/spec/unit/mutant/isolation_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe Mutant::Isolation::None do
+RSpec.describe Mutant::Isolation::None do
   before do
     @initial = 1
   end
@@ -24,7 +22,7 @@ describe Mutant::Isolation::None do
   end
 end
 
-describe Mutant::Isolation::Fork do
+RSpec.describe Mutant::Isolation::Fork do
   before do
     @initial = 1
   end

data/spec/unit/mutant/loader/eval_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe Mutant::Loader::Eval, '.call' do
+RSpec.describe Mutant::Loader::Eval, '.call' do
 
   subject { object.call(node, mutation_subject) }
 

data/spec/unit/mutant/matcher/chain_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe Mutant::Matcher::Chain do
+RSpec.describe Mutant::Matcher::Chain do
 
   let(:object) { described_class.new(matchers) }
 

data/spec/unit/mutant/matcher/compiler/subject_prefix_spec.rb

@@ -0,0 +1,21 @@
+RSpec.describe Mutant::Matcher::Compiler::SubjectPrefix do
+  let(:object) { described_class.new(Mutant::Expression.parse('Foo*')) }
+
+  let(:_subject) { double('Subject', expression: Mutant::Expression.parse(subject_expression)) }
+
+  describe '#call' do
+    subject { object.call(_subject) }
+
+    context 'when subject expression is prefixed by expression' do
+      let(:subject_expression) { 'Foo::Bar' }
+
+      it { should be(true) }
+    end
+
+    context 'when subject expression is NOT prefixed by expression' do
+      let(:subject_expression) { 'Bar' }
+
+      it { should be(false) }
+    end
+  end
+end

data/spec/unit/mutant/matcher/compiler_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe Mutant::Matcher::Compiler do
+RSpec.describe Mutant::Matcher::Compiler do
   let(:object) { described_class }
 
   let(:env) { Fixtures::TEST_ENV }
@@ -82,6 +80,33 @@ describe Mutant::Matcher::Compiler do
 
         it { should eql(expected_matcher) }
       end
+
+      context 'and subject and attribute filter' do
+        let(:attributes) do
+          {
+            match_expressions: [expression_a],
+            subject_ignores:   [expression_b],
+            subject_selects:   [[:code, 'foo']]
+          }
+        end
+
+        let(:expected_positive_matcher) { Mutant::Matcher::Chain.new([matcher_a]) }
+
+        let(:expected_predicate) do
+          Morpher::Evaluator::Predicate::Boolean::And.new([
+            Morpher::Evaluator::Predicate::Boolean::Or.new([
+              Morpher.compile(s(:eql, s(:attribute, :code), s(:static, 'foo')))
+            ]),
+            Morpher::Evaluator::Predicate::Negation.new(
+              Morpher::Evaluator::Predicate::Boolean::Or.new([
+                described_class::SubjectPrefix.new(expression_b)
+              ])
+            )
+          ])
+        end
+
+        it { should eql(expected_matcher) }
+      end
     end
 
     context 'on config with multiple match expressions' do

data/spec/unit/mutant/matcher/filter_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe Mutant::Matcher::Filter do
+RSpec.describe Mutant::Matcher::Filter do
   let(:object) { described_class.new(matcher, predicate) }
 
   describe '#each' do

data/spec/unit/mutant/matcher/method/instance_spec.rb

@@ -1,7 +1,5 @@
-require 'spec_helper'
-
 # rubocop:disable ClassAndModuleChildren
-describe Mutant::Matcher::Method::Instance do
+RSpec.describe Mutant::Matcher::Method::Instance do
 
   let(:env)      { Fixtures::TEST_ENV             }
   let(:reporter) { Fixtures::TEST_CONFIG.reporter }
@@ -68,7 +66,7 @@ describe Mutant::Matcher::Method::Instance do
     end
 
     context 'when method is defined multiple times' do
-      context 'on differend lines' do
+      context 'on different lines' do
         let(:base) { __LINE__ }
         class self::Foo
           def bar
@@ -96,7 +94,7 @@ describe Mutant::Matcher::Method::Instance do
         it_should_behave_like 'a method matcher'
       end
 
-      context 'on the same line with differend scope' do
+      context 'on the same line with different scope' do
         let(:base) { __LINE__ }
         class self::Foo
           def self.bar; end; def bar(_arg); end

data/spec/unit/mutant/matcher/method/singleton_spec.rb

@@ -1,7 +1,5 @@
-require 'spec_helper'
-
 # rubocop:disable ClassAndModuleChildren
-describe Mutant::Matcher::Method::Singleton, '#each' do
+RSpec.describe Mutant::Matcher::Method::Singleton, '#each' do
   subject { object.each { |subject| yields << subject } }
 
   let(:object)       { described_class.new(env, scope, method) }
@@ -23,6 +21,26 @@ describe Mutant::Matcher::Method::Singleton, '#each' do
 
   context 'on singleton methods' do
 
+    context 'when also defined on lvar' do
+      let(:base) { __LINE__ }
+      class self::Foo
+        a = Object.new
+        def a.bar; end; def self.bar; end
+      end
+
+      let(:method_name) { :bar }
+      let(:method_line) { 3    }
+
+      it_should_behave_like 'a method matcher'
+
+      it 'warns about definition on non const/self' do
+        subject
+        expect(env.config.reporter.warn_calls).to(
+          include('Can only match :defs on :self or :const got :lvar unable to match')
+        )
+      end
+    end
+
     context 'when defined on self' do
       let(:base) { __LINE__ }
       class self::Foo
@@ -72,7 +90,7 @@ describe Mutant::Matcher::Method::Singleton, '#each' do
     end
 
     context 'when defined multiple times in the same line' do
-      context 'with method on differend scope' do
+      context 'with method on different scope' do
         let(:base) { __LINE__ }
         module self::Namespace
           module Foo; end

data/spec/unit/mutant/matcher/methods/instance_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe Mutant::Matcher::Methods::Instance, '#each' do
+RSpec.describe Mutant::Matcher::Methods::Instance, '#each' do
   let(:object) { described_class.new(env, Foo) }
   let(:env)    { Fixtures::TEST_ENV            }
 
@@ -46,9 +44,12 @@ describe Mutant::Matcher::Methods::Instance, '#each' do
 
   before do
     matcher = Mutant::Matcher::Method::Instance
-    allow(matcher).to receive(:new).with(env, Foo, Foo.instance_method(:method_a)).and_return([subject_a])
-    allow(matcher).to receive(:new).with(env, Foo, Foo.instance_method(:method_b)).and_return([subject_b])
-    allow(matcher).to receive(:new).with(env, Foo, Foo.instance_method(:method_c)).and_return([subject_c])
+    allow(matcher).to receive(:new)
+      .with(env, Foo, Foo.instance_method(:method_a)).and_return([subject_a])
+    allow(matcher).to receive(:new)
+      .with(env, Foo, Foo.instance_method(:method_b)).and_return([subject_b])
+    allow(matcher).to receive(:new)
+      .with(env, Foo, Foo.instance_method(:method_c)).and_return([subject_c])
   end
 
   it 'should yield expected subjects' do