mutant 0.8.0 → 0.8.1

data/spec/unit/mutant/integration/rspec_spec.rb

@@ -1,10 +1,10 @@
 require 'mutant/integration/rspec'
 
 RSpec.describe Mutant::Integration::Rspec do
-  let(:object) { described_class.new }
+  let(:object) { described_class.new(Mutant::Config::DEFAULT) }
 
-  let(:options)       { double('options')                           }
-  let(:runner)        { double('runner')                            }
+  let(:options) { double('options') }
+  let(:runner)  { double('runner')  }
 
   let(:example_a) do
     double(
@@ -97,19 +97,19 @@ RSpec.describe Mutant::Integration::Rspec do
     [
       Mutant::Test.new(
         id:         'rspec:0:example-a-location/example-a-full-description',
-        expression: Mutant::Expression.parse('*')
+        expression: parse_expression('*')
       ),
       Mutant::Test.new(
         id:         'rspec:1:example-c-location/Example::C blah',
-        expression: Mutant::Expression.parse('Example::C')
+        expression: parse_expression('Example::C')
       ),
       Mutant::Test.new(
         id:         "rspec:2:example-d-location/Example::D\nblah",
-        expression: Mutant::Expression.parse('*')
+        expression: parse_expression('*')
       ),
       Mutant::Test.new(
         id:         'rspec:3:example-e-location/Example::E',
-        expression: Mutant::Expression.parse('Foo')
+        expression: parse_expression('Foo')
       )
     ]
   end

data/spec/unit/mutant/integration_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe Mutant::Integration do
     Class.new(described_class)
   end
 
-  let(:object) { class_under_test.new }
+  let(:object) { class_under_test.new(Mutant::Config::DEFAULT) }
 
   describe '#setup' do
     subject { object.setup }
@@ -14,7 +14,7 @@ end
 
 RSpec.describe Mutant::Integration::Null do
 
-  let(:object) { described_class.new }
+  let(:object) { described_class.new(Mutant::Config::DEFAULT) }
 
   describe '#all_tests' do
     subject { object.all_tests }

data/spec/unit/mutant/isolation_spec.rb

@@ -64,37 +64,39 @@ RSpec.describe Mutant::Isolation::Fork do
       end
     end
 
-    it 'uses primitives in correct order when fork succeeds' do
-      reader, writer = double('reader'), double('writer')
-      expect(IO).to receive(:pipe).ordered.and_return([reader, writer])
-      expect(reader).to receive(:binmode).and_return(reader).ordered
-      expect(writer).to receive(:binmode).and_return(writer).ordered
-      pid = double('PID')
-      expect(Process).to receive(:fork).ordered.and_yield.and_return(pid)
-      file = double('file')
-      expect(File).to receive(:open).ordered.with('/dev/null', 'w').and_yield(file)
-      expect($stderr).to receive(:reopen).ordered.with(file)
-      expect(reader).to receive(:close).ordered
-      expect(writer).to receive(:write).ordered.with(Marshal.dump(:foo))
-      expect(writer).to receive(:close).ordered
-      expect(writer).to receive(:close).ordered
-      expect(reader).to receive(:read).ordered.and_return(Marshal.dump(:foo))
-      expect(Process).to receive(:waitpid).with(pid)
+    context 'uses primitives in correct order' do
+      let(:reader) { double('reader') }
+      let(:writer) { double('writer') }
 
-      expect(object.call { :foo }).to be(:foo)
-    end
+      before do
+        expect(IO).to receive(:pipe).with(binmode: true).ordered do |&block|
+          block.call([reader, writer])
+        end
+      end
 
-    it 'uses primitives in correct order when fork fails' do
-      reader, writer = double('reader'), double('writer')
-      expect(IO).to receive(:pipe).ordered.and_return([reader, writer])
-      expect(reader).to receive(:binmode).and_return(reader).ordered
-      expect(writer).to receive(:binmode).and_return(writer).ordered
-      expect(Process).to receive(:fork).ordered.and_return(nil)
-      expect(Process).to_not receive(:waitpid)
-
-      expect(writer).to receive(:close).ordered
-      expect(reader).to receive(:read).ordered.and_return(Marshal.dump(:foo))
-      expect(object.call).to be(:foo)
+      it 'when fork succeeds' do
+        pid = double('PID')
+        expect(Process).to receive(:fork).ordered.and_yield.and_return(pid)
+        file = double('file')
+        expect(File).to receive(:open).ordered.with('/dev/null', 'w').and_yield(file)
+        expect($stderr).to receive(:reopen).ordered.with(file)
+        expect(reader).to receive(:close).ordered
+        expect(writer).to receive(:write).ordered.with(Marshal.dump(:foo))
+        expect(writer).to receive(:close).ordered
+        expect(writer).to receive(:close).ordered
+        expect(reader).to receive(:read).ordered.and_return(Marshal.dump(:foo))
+        expect(Process).to receive(:waitpid).with(pid)
+
+        expect(object.call { :foo }).to be(:foo)
+      end
+
+      it 'when fork fails' do
+        expect(Process).to receive(:fork).ordered.and_return(nil)
+        expect(Process).to_not receive(:waitpid)
+        expect(writer).to receive(:close).ordered
+        expect(reader).to receive(:read).ordered.and_return(Marshal.dump(:foo))
+        expect(object.call).to be(:foo)
+      end
     end
   end
 end

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

@@ -1,7 +1,7 @@
 RSpec.describe Mutant::Matcher::Compiler::SubjectPrefix do
-  let(:object) { described_class.new(Mutant::Expression.parse('Foo*')) }
+  let(:object) { described_class.new(parse_expression('Foo*')) }
 
-  let(:_subject) { double('Subject', expression: Mutant::Expression.parse(subject_expression)) }
+  let(:_subject) { double('Subject', expression: parse_expression(subject_expression)) }
 
   describe '#call' do
     subject { object.call(_subject) }

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

@@ -3,8 +3,8 @@ RSpec.describe Mutant::Matcher::Compiler do
 
   let(:env) { Fixtures::TEST_ENV }
 
-  let(:expression_a) { Mutant::Expression.parse('Foo*') }
-  let(:expression_b) { Mutant::Expression.parse('Bar*') }
+  let(:expression_a) { parse_expression('Foo*') }
+  let(:expression_b) { parse_expression('Bar*') }
 
   let(:matcher_a) { expression_a.matcher(env) }
   let(:matcher_b) { expression_b.matcher(env) }
@@ -14,7 +14,7 @@ RSpec.describe Mutant::Matcher::Compiler do
   end
 
   let(:expected_predicate) do
-    Morpher.compile(s(:true))
+    Morpher.compile(s(:and, s(:negate, s(:or)), s(:and)))
   end
 
   describe '.call' do
@@ -31,78 +31,47 @@ RSpec.describe Mutant::Matcher::Compiler do
     end
 
     context 'on config with match expression' do
-      context 'and no filter' do
-        let(:attributes) do
-          { match_expressions: [expression_a] }
-        end
-
-        let(:expected_positive_matcher) { Mutant::Matcher::Chain.new([matcher_a]) }
-
-        it { should eql(expected_matcher) }
+      let(:expected_predicate) do
+        Morpher::Evaluator::Predicate::Boolean::And.new(
+          [
+            Morpher::Evaluator::Predicate::Negation.new(
+              Morpher::Evaluator::Predicate::Boolean::Or.new(ignore_expression_predicates)
+            ),
+            Morpher::Evaluator::Predicate::Boolean::And.new(subject_filter_predicates)
+          ]
+        )
       end
 
-      context 'and a subject filter' do
-        let(:attributes) do
-          {
-            match_expressions: [expression_a],
-            subject_ignores:   [expression_b]
-          }
-        end
-
-        let(:expected_positive_matcher) { Mutant::Matcher::Chain.new([matcher_a]) }
-
-        let(:expected_predicate) do
-          Morpher::Evaluator::Predicate::Negation.new(
-            Morpher::Evaluator::Predicate::Boolean::Or.new([
-              described_class::SubjectPrefix.new(expression_b)
-            ])
-          )
-        end
+      let(:expected_positive_matcher)    { Mutant::Matcher::Chain.new([matcher_a]) }
+      let(:attributes)                   { { match_expressions: [expression_a] }   }
+      let(:ignore_expression_predicates) { []                                      }
+      let(:subject_filter_predicates)    { []                                      }
 
+      context 'and no other constraints' do
         it { should eql(expected_matcher) }
       end
 
-      context 'and an attribute filter' do
+      context 'and ignore expressions' do
         let(:attributes) do
-          {
-            match_expressions: [expression_a],
-            subject_selects:   [[:code, 'foo']]
-          }
+          super().merge(ignore_expressions: [expression_b])
         end
 
-        let(:expected_positive_matcher) { Mutant::Matcher::Chain.new([matcher_a]) }
-
-        let(:expected_predicate) do
-          Morpher::Evaluator::Predicate::Boolean::Or.new([
-            Morpher.compile(s(:eql, s(:attribute, :code), s(:static, 'foo')))
-          ])
+        let(:ignore_expression_predicates) do
+          [Mutant::Matcher::Compiler::SubjectPrefix.new(expression_b)]
         end
 
         it { should eql(expected_matcher) }
       end
 
-      context 'and subject and attribute filter' do
+      context 'and subject filters' do
+        let(:filter) { double('filter') }
+
         let(:attributes) do
-          {
-            match_expressions: [expression_a],
-            subject_ignores:   [expression_b],
-            subject_selects:   [[:code, 'foo']]
-          }
+          super().merge(subject_filters: [filter])
         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)
-              ])
-            )
-          ])
+        let(:subject_filter_predicates) do
+          [filter]
         end
 
         it { should eql(expected_matcher) }

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

@@ -0,0 +1,45 @@
+RSpec.describe Mutant::Matcher::Config do
+  describe '#inspect' do
+    subject { object.inspect }
+
+    context 'on default config' do
+      let(:object) { described_class::DEFAULT }
+
+      it { should eql('#<Mutant::Matcher::Config empty>') }
+    end
+
+    context 'with one expression' do
+      let(:object) { described_class::DEFAULT.add(:match_expressions, parse_expression('Foo')) }
+      it { should eql('#<Mutant::Matcher::Config match_expressions: [Foo]>') }
+    end
+
+    context 'with many expressions' do
+      let(:object) do
+        described_class::DEFAULT
+          .add(:match_expressions, parse_expression('Foo'))
+          .add(:match_expressions, parse_expression('Bar'))
+      end
+
+      it { should eql('#<Mutant::Matcher::Config match_expressions: [Foo,Bar]>') }
+    end
+
+    context 'with match and ignore expression' do
+      let(:object) do
+        described_class::DEFAULT
+          .add(:match_expressions,  parse_expression('Foo'))
+          .add(:ignore_expressions, parse_expression('Bar'))
+      end
+
+      it { should eql('#<Mutant::Matcher::Config match_expressions: [Foo] ignore_expressions: [Bar]>') }
+    end
+
+    context 'with subject filter' do
+      let(:object) do
+        described_class::DEFAULT
+          .add(:subject_filters, 'foo')
+      end
+
+      it { should eql('#<Mutant::Matcher::Config subject_filters: ["foo"]>') }
+    end
+  end
+end

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

@@ -1,16 +1,15 @@
 RSpec.describe Mutant::Matcher::Filter do
-  let(:object) { described_class.new(matcher, predicate) }
+  let(:object)    { described_class.new(matcher, predicate) }
+  let(:matcher)   { [subject_a, subject_b]                  }
+  let(:subject_a) { double('Subject A')                     }
+  let(:subject_b) { double('Subject B')                     }
 
   describe '#each' do
     let(:yields) { [] }
     subject { object.each { |entry| yields << entry } }
 
-    let(:matcher)   { [subject_a, subject_b] }
     let(:predicate) { ->(node) { node.eql?(subject_a) } }
 
-    let(:subject_a) { double('Subject A') }
-    let(:subject_b) { double('Subject B') }
-
     # it_should_behave_like 'an #each method'
     context 'with no block' do
       subject { object.each }
@@ -26,4 +25,12 @@ RSpec.describe Mutant::Matcher::Filter do
       expect { subject }.to change { yields }.from([]).to([subject_a])
     end
   end
+
+  describe '.build' do
+    subject { described_class.build(matcher, &predicate) }
+
+    let(:predicate) { ->(_subject) { false } }
+
+    its(:to_a) { should eql([]) }
+  end
 end

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

@@ -1,4 +1,3 @@
-# rubocop:disable ClassAndModuleChildren
 RSpec.describe Mutant::Matcher::Method::Instance do
 
   let(:env)      { Fixtures::TEST_ENV             }

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

@@ -1,4 +1,3 @@
-# rubocop:disable ClassAndModuleChildren
 RSpec.describe Mutant::Matcher::Method::Singleton, '#each' do
   subject { object.each(&yields.method(:<<)) }
 

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

@@ -1,7 +1,7 @@
 RSpec.describe Mutant::Matcher::Namespace do
-  let(:object) { described_class.new(env, Mutant::Expression.parse('TestApp*')) }
-  let(:yields) { []                                                             }
-  let(:env)    { double('Env')                                                  }
+  let(:object) { described_class.new(env, parse_expression('TestApp*')) }
+  let(:yields) { []                                                     }
+  let(:env)    { double('Env')                                          }
 
   subject { object.each { |item| yields << item } }
 
@@ -22,7 +22,7 @@ RSpec.describe Mutant::Matcher::Namespace do
 
       allow(env).to receive(:matchable_scopes).and_return(
         [singleton_a, singleton_b, singleton_c].map do |scope|
-          Mutant::Matcher::Scope.new(env, scope, Mutant::Expression.parse(scope.name))
+          Mutant::Matcher::Scope.new(env, scope, parse_expression(scope.name))
         end
       )
     end

data/spec/unit/mutant/parallel/worker_spec.rb

@@ -27,7 +27,7 @@ RSpec.describe Mutant::Parallel::Worker do
 
     let(:actor_names) { [:worker] }
 
-    context 'when receving :job command' do
+    context 'when receiving :job command' do
 
       before do
         expect(processor).to receive(:call).with(payload).and_return(result_payload)

data/spec/unit/mutant/reporter/cli/printer/config_spec.rb

@@ -7,8 +7,8 @@ RSpec.describe Mutant::Reporter::CLI::Printer::Config do
     context 'on default config' do
       it_reports(<<-REPORT)
         Mutant configuration:
-        Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
-        Integration:     null
+        Matcher:         #<Mutant::Matcher::Config empty>
+        Integration:     Mutant::Integration::Null
         Expect Coverage: 100.00%
         Jobs:            1
         Includes:        []
@@ -21,8 +21,8 @@ RSpec.describe Mutant::Reporter::CLI::Printer::Config do
 
       it_reports(<<-REPORT)
         Mutant configuration:
-        Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
-        Integration:     null
+        Matcher:         #<Mutant::Matcher::Config empty>
+        Integration:     Mutant::Integration::Null
         Expect Coverage: 10.00%
         Jobs:            1
         Includes:        []

data/spec/unit/mutant/reporter/cli/printer/env_progress_spec.rb

@@ -11,8 +11,8 @@ RSpec.describe Mutant::Reporter::CLI::Printer::EnvProgress do
 
       it_reports <<-'STR'
         Mutant configuration:
-        Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
-        Integration:     null
+        Matcher:         #<Mutant::Matcher::Config empty>
+        Integration:     Mutant::Integration::Null
         Expect Coverage: 10.00%
         Jobs:            1
         Includes:        []
@@ -24,7 +24,7 @@ RSpec.describe Mutant::Reporter::CLI::Printer::EnvProgress do
         Runtime:         4.00s
         Killtime:        0.00s
         Overhead:        Inf%
-        Coverage:        0.00%
+        Coverage:        100.00%
         Expected:        10.00%
       STR
     end
@@ -32,8 +32,8 @@ RSpec.describe Mutant::Reporter::CLI::Printer::EnvProgress do
     context 'on full coverage' do
       it_reports <<-'STR'
         Mutant configuration:
-        Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
-        Integration:     null
+        Matcher:         #<Mutant::Matcher::Config empty>
+        Integration:     Mutant::Integration::Null
         Expect Coverage: 10.00%
         Jobs:            1
         Includes:        []
@@ -55,8 +55,8 @@ RSpec.describe Mutant::Reporter::CLI::Printer::EnvProgress do
 
       it_reports <<-'STR'
         Mutant configuration:
-        Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
-        Integration:     null
+        Matcher:         #<Mutant::Matcher::Config empty>
+        Integration:     Mutant::Integration::Null
         Expect Coverage: 10.00%
         Jobs:            1
         Includes:        []

data/spec/unit/mutant/reporter/cli/printer/env_result_spec.rb

@@ -15,8 +15,8 @@ RSpec.describe Mutant::Reporter::CLI::Printer::EnvResult do
       +false
       -----------------------
       Mutant configuration:
-      Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
-      Integration:     null
+      Matcher:         #<Mutant::Matcher::Config empty>
+      Integration:     Mutant::Integration::Null
       Expect Coverage: 100.00%
       Jobs:            1
       Includes:        []