mutant 0.7.8 → 0.7.9

data/spec/unit/mutant/env_spec.rb

@@ -19,7 +19,6 @@ RSpec.describe Mutant::Env do
       )
     end
 
-    let(:isolation)    { Mutant::Isolation::None                                                 }
     let(:integration)  { double('Integration')                                                   }
     let(:isolation)    { double('Isolation')                                                     }
     let(:mutation)     { Mutant::Mutation::Evil.new(mutation_subject, Mutant::AST::Nodes::N_NIL) }

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

@@ -0,0 +1,193 @@
+require 'mutant/integration/rspec'
+
+RSpec.describe Mutant::Integration::Rspec do
+  let(:object) { described_class.new }
+
+  let(:options)       { double('options')                           }
+  let(:runner)        { double('runner')                            }
+
+  let(:example_a) do
+    double(
+      'Example A',
+      metadata: {
+        location:         'example-a-location',
+        full_description: 'example-a-full-description'
+      }
+    )
+  end
+
+  let(:example_b) do
+    double(
+      'Example B',
+      metadata: {
+        location:         'example-b-location',
+        full_description: 'example-b-full-description',
+        mutant:           false
+      }
+    )
+  end
+
+  let(:example_c) do
+    double(
+      'Example C',
+      metadata: {
+        location:         'example-c-location',
+        full_description: 'Example::C blah'
+      }
+    )
+  end
+
+  let(:example_d) do
+    double(
+      'Example D',
+      metadata: {
+        location:         'example-d-location',
+        full_description: "Example::D\nblah"
+      }
+    )
+  end
+
+  let(:example_e) do
+    double(
+      'Example E',
+      metadata: {
+        location:          'example-e-location',
+        full_description:  'Example::E',
+        mutant_expression: 'Foo'
+      }
+    )
+  end
+
+  let(:examples) do
+    [
+      example_a,
+      example_b,
+      example_c,
+      example_d,
+      example_e
+    ]
+  end
+
+  let(:example_groups) do
+    [
+      double(
+        'root example group',
+        descendants: [
+          double('example group', examples: examples)
+        ]
+      )
+    ]
+  end
+
+  let(:filtered_examples) do
+    {
+      double('Key') => examples.dup
+    }
+  end
+
+  let(:world) do
+    double(
+      'world',
+      example_groups:         example_groups,
+      filtered_examples:      filtered_examples
+    )
+  end
+
+  let(:all_tests) do
+    [
+      Mutant::Test.new(
+        id:         'rspec:0:example-a-location/example-a-full-description',
+        expression: Mutant::Expression.parse('*')
+      ),
+      Mutant::Test.new(
+        id:         'rspec:1:example-c-location/Example::C blah',
+        expression: Mutant::Expression.parse('Example::C')
+      ),
+      Mutant::Test.new(
+        id:         "rspec:2:example-d-location/Example::D\nblah",
+        expression: Mutant::Expression.parse('*')
+      ),
+      Mutant::Test.new(
+        id:         'rspec:3:example-e-location/Example::E',
+        expression: Mutant::Expression.parse('Foo')
+      )
+    ]
+  end
+
+  before do
+    expect(RSpec::Core::ConfigurationOptions).to receive(:new).with(%w[spec --fail-fast]).and_return(options)
+    expect(RSpec::Core::Runner).to receive(:new).with(options).and_return(runner)
+    expect(RSpec).to receive(:world).with(no_args).and_return(world)
+    allow(Time).to receive(:now).and_return(Time.now)
+  end
+
+  describe '#all_tests' do
+    subject { object.all_tests }
+
+    it { should eql(all_tests) }
+  end
+
+  describe '#setup' do
+    subject { object.setup }
+
+    before do
+      expect(runner).to receive(:setup) do |error, output|
+        expect(error).to be($stderr)
+        output.write('foo')
+      end
+    end
+
+    it { should be(object) }
+  end
+
+  describe '#call' do
+    subject { object.call(tests) }
+
+    before do
+      expect(runner).to receive(:setup) do |_errors, output|
+        output.write('the-test-output')
+      end
+
+      object.setup
+    end
+
+    let(:tests) { [all_tests.fetch(0)] }
+
+    before do
+      expect(world).to receive(:ordered_example_groups) do
+        filtered_examples.values.flatten
+      end
+      expect(runner).to receive(:run_specs).with([example_a]).and_return(exit_status)
+    end
+
+    context 'on unsuccessful exit' do
+      let(:exit_status) { 1 }
+
+      it 'should return failed result' do
+        expect(subject).to eql(
+          Mutant::Result::Test.new(
+            tests: tests,
+            output: 'the-test-output',
+            passed: false,
+            runtime: 0.0
+          )
+        )
+      end
+    end
+
+    context 'on successful exit' do
+      let(:exit_status) { 0 }
+
+      it 'should return passed result' do
+        expect(subject).to eql(
+          Mutant::Result::Test.new(
+            tests: tests,
+            output: 'the-test-output',
+            passed: true,
+            runtime: 0.0
+          )
+        )
+      end
+    end
+  end
+end

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

@@ -2,7 +2,7 @@ RSpec.describe Mutant::Loader::Eval, '.call' do
 
   subject { object.call(node, mutation_subject) }
 
-  let(:object) { described_class }
+  let(:object) { Class.new(described_class) }
   let(:path)   { __FILE__        }
   let(:line)   { 1               }
 

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

@@ -1,39 +1,40 @@
 RSpec.describe Mutant::Matcher::Methods::Instance, '#each' do
-  let(:object) { described_class.new(env, Foo) }
+  let(:object) { described_class.new(env, class_under_test) }
   let(:env)    { Fixtures::TEST_ENV            }
 
   subject { object.each { |matcher| yields << matcher } }
 
   let(:yields) { [] }
 
-  module Bar
-    def method_d
-    end
+  let(:class_under_test) do
+    parent = Module.new do
+      def method_d
+      end
 
-    def method_e
+      def method_e
+      end
     end
-  end
 
-  class Foo
-    include Bar
+    Class.new do
+      include parent
 
-    private :method_d
+      private :method_d
 
-  public
+      public
 
-    def method_a
-    end
+      def method_a
+      end
 
-  protected
+      protected
 
-    def method_b
-    end
+      def method_b
+      end
 
-  private
+      private
 
-    def method_c
+      def method_c
+      end
     end
-
   end
 
   let(:subject_a) { double('Subject A') }
@@ -45,11 +46,11 @@ RSpec.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])
+      .with(env, class_under_test, class_under_test.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])
+      .with(env, class_under_test, class_under_test.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])
+      .with(env, class_under_test, class_under_test.instance_method(:method_c)).and_return([subject_c])
   end
 
   it 'should yield expected subjects' do

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

@@ -1,33 +1,35 @@
 RSpec.describe Mutant::Matcher::Methods::Singleton, '#each' do
-  let(:object) { described_class.new(env, Foo) }
+  let(:object) { described_class.new(env, class_under_test) }
   let(:env)    { Fixtures::TEST_ENV            }
 
   subject { object.each { |matcher| yields << matcher } }
 
   let(:yields) { [] }
 
-  module Bar
-    def method_d
-    end
+  let(:class_under_test) do
+    parent = Module.new do
+      def method_d
+      end
 
-    def method_e
+      def method_e
+      end
     end
-  end
 
-  class Foo
-    extend Bar
+    Class.new do
+      extend parent
 
-    def self.method_a
-    end
+      def self.method_a
+      end
 
-    def self.method_b
-    end
-    class << self; protected :method_b; end
+      def self.method_b
+      end
+      class << self; protected :method_b; end
 
-    def self.method_c
-    end
-    private_class_method :method_c
+      def self.method_c
+      end
+      private_class_method :method_c
 
+    end
   end
 
   let(:subject_a) { double('Subject A') }
@@ -39,11 +41,11 @@ RSpec.describe Mutant::Matcher::Methods::Singleton, '#each' do
   before do
     matcher = Mutant::Matcher::Method::Singleton
     allow(matcher).to receive(:new)
-      .with(env, Foo, Foo.method(:method_a)).and_return([subject_a])
+      .with(env, class_under_test, class_under_test.method(:method_a)).and_return([subject_a])
     allow(matcher).to receive(:new)
-      .with(env, Foo, Foo.method(:method_b)).and_return([subject_b])
+      .with(env, class_under_test, class_under_test.method(:method_b)).and_return([subject_b])
     allow(matcher).to receive(:new)
-      .with(env, Foo, Foo.method(:method_c)).and_return([subject_c])
+      .with(env, class_under_test, class_under_test.method(:method_c)).and_return([subject_c])
   end
 
   it 'should yield expected subjects' do

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

@@ -29,8 +29,6 @@ RSpec.describe Mutant::Parallel::Worker do
 
     context 'when receving :job command' do
 
-      let(:test_result) { double('Test Result') }
-
       before do
         expect(processor).to receive(:call).with(payload).and_return(result_payload)
 

data/spec/unit/mutant/reporter/cli/tput_spec.rb

@@ -0,0 +1,48 @@
+RSpec.describe Mutant::Reporter::CLI::Tput do
+  describe '.detect' do
+    subject { described_class.detect }
+
+    def expect_command(command, stdout, success)
+      allow(Open3).to receive(:capture3).with(command).ordered.and_return(
+        [
+          stdout,
+          double('Stderr'),
+          double('Exitstatus', success?: success)
+        ]
+      )
+    end
+
+    let(:tput_reset?) { true }
+    let(:tput_sc?)    { true }
+    let(:tput_rc?)    { true }
+    let(:tput_ed?)    { true }
+
+    before do
+      expect_command('tput reset', '[reset]', tput_reset?)
+      expect_command('tput sc', '[sc]', tput_sc?)
+      expect_command('tput rc', '[rc]', tput_rc?)
+      expect_command('tput ed', '[ed]', tput_ed?)
+    end
+
+    context 'when all tput commands are supported' do
+      its(:prepare) { should eql('[reset][sc]') }
+      its(:restore) { should eql('[rc][ed]')    }
+    end
+
+    context 'when tput reset fails' do
+      let(:tput_reset?) { false }
+
+      it { should be(nil) }
+    end
+
+    context 'when ed fails' do
+      let(:tput_ed?) { false }
+      let(:tput_cd?) { true }
+      before do
+        expect_command('tput cd', '[cd]', tput_cd?)
+      end
+      its(:prepare) { should eql('[reset][sc]') }
+      its(:restore) { should eql('[rc][cd]')    }
+    end
+  end
+end

data/spec/unit/mutant/reporter/cli_spec.rb

@@ -2,12 +2,20 @@ RSpec.describe Mutant::Reporter::CLI do
   setup_shared_context
 
   let(:object) { described_class.new(output, format) }
-  let(:output) { StringIO.new }
+  let(:output) { StringIO.new                        }
+
+  let(:tput) do
+    double(
+      'tput',
+      restore: '[tput-restore]',
+      prepare: '[tput-prepare]'
+    )
+  end
 
   let(:framed_format) do
     described_class::Format::Framed.new(
       tty:  false,
-      tput: described_class::Tput::UNAVAILABLE
+      tput: tput
     )
   end
 
@@ -43,7 +51,7 @@ RSpec.describe Mutant::Reporter::CLI do
     let(:framed_format) do
       described_class::Format::Framed.new(
         tty:  true,
-        tput: described_class::Tput::INSTANCE
+        tput: tput
       )
     end
 
@@ -56,7 +64,19 @@ RSpec.describe Mutant::Reporter::CLI do
     let(:ci?)    { false                        }
 
     context 'when not on CI and on a tty' do
-      it { should eql(described_class.new(output, framed_format)) }
+      before do
+        expect(described_class::Tput).to receive(:detect).and_return(tput)
+      end
+
+      context 'and tput is available' do
+        it { should eql(described_class.new(output, framed_format)) }
+      end
+
+      context 'and tput is not available' do
+        let(:tput) { nil }
+
+        it { should eql(described_class.new(output, progressive_format)) }
+      end
     end
 
     context 'when on CI' do
@@ -109,7 +129,7 @@ RSpec.describe Mutant::Reporter::CLI do
     end
 
     context 'on framed format' do
-      it_reports ''
+      it_reports '[tput-prepare]'
     end
   end
 
@@ -144,7 +164,7 @@ RSpec.describe Mutant::Reporter::CLI do
         update(:env_result) { { subject_results: [] } }
 
         it_reports <<-REPORT
-          Mutant configuration:
+          [tput-restore]Mutant configuration:
           Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
           Integration:     null
           Expect Coverage: 100.00%
@@ -169,7 +189,7 @@ RSpec.describe Mutant::Reporter::CLI do
           update(:status) { { active_jobs: [].to_set } }
 
           it_reports(<<-REPORT)
-            Mutant configuration:
+            [tput-restore]Mutant configuration:
             Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
             Integration:     null
             Expect Coverage: 100.00%
@@ -196,7 +216,7 @@ RSpec.describe Mutant::Reporter::CLI do
             update(:mutation_a_test_result) { { passed: true } }
 
             it_reports(<<-REPORT)
-              Mutant configuration:
+              [tput-restore]Mutant configuration:
               Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
               Integration:     null
               Expect Coverage: 100.00%
@@ -224,7 +244,7 @@ RSpec.describe Mutant::Reporter::CLI do
 
           context 'on success' do
             it_reports(<<-REPORT)
-              Mutant configuration:
+              [tput-restore]Mutant configuration:
               Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
               Integration:     null
               Expect Coverage: 100.00%