mutant 0.7.9 → 0.8.0

data/spec/support/file_system.rb

@@ -0,0 +1,60 @@
+module MutantSpec
+  class FileState
+    DEFAULTS = IceNine.deep_freeze(
+      file:     false,
+      contents: nil,
+      requires: []
+    )
+
+    include Adamantium, Anima.new(*DEFAULTS.keys)
+
+    def self.new(attributes = DEFAULTS)
+      super(DEFAULTS.merge(attributes))
+    end
+
+    DOES_NOT_EXIST = new
+
+    alias_method :file?, :file
+  end # FileState
+
+  class FakePathname
+    include Adamantium, Concord.new(:file_system, :pathname)
+
+    def join(*arguments)
+      self.class.new(
+        file_system,
+        pathname.join(*arguments)
+      )
+    end
+
+    def read
+      state.contents
+    end
+
+    def to_s
+      pathname.to_s
+    end
+
+    def file?
+      state.file?
+    end
+
+  private
+
+    def state
+      file_system.state(pathname.to_s)
+    end
+  end # Pathname
+
+  class FileSystem
+    include Adamantium, Concord.new(:file_states)
+
+    def state(filename)
+      file_states.fetch(filename, FileState::DOES_NOT_EXIST)
+    end
+
+    def path(filename)
+      FakePathname.new(self, Pathname.new(filename))
+    end
+  end # FileSystem
+end # MutantSpec

data/spec/support/rb_bug.rb

@@ -3,7 +3,7 @@ require 'ffi'
 module RbBug
   extend FFI::Library
   ffi_lib 'ruby'
-  attach_function :rb_bug, [:string, :varargs], :void
+  attach_function :rb_bug, %i[string varargs], :void
 
   # Call the test bug
   #

data/spec/support/ruby_vm.rb

@@ -0,0 +1,82 @@
+module MutantSpec
+  # Not a real VM, just kidding. It connects the require / eval triggers
+  # require semantics Zombifier relies on in a way we can avoid having to
+  # mock around everywhere to test every detail.
+  #
+  # rubocop:disable LineLength
+  class RubyVM
+    include Concord.new(:expected_events)
+
+    # An event being observed by the VM handlers
+    class EventObservation
+      include Concord::Public.new(:type, :payload)
+    end
+
+    # An event being expected, can advance the VM
+    class EventExpectation
+      include AbstractType, Anima.new(:expected_payload, :trigger_requires)
+
+      DEFAULTS = IceNine.deep_freeze(trigger_requires: [])
+
+      def initialize(attributes)
+        super(DEFAULTS.merge(attributes))
+      end
+
+      def handle(vm, observation)
+        unless match?(observation)
+          fail "Unexpected event observation: #{observation.inspect}, expected #{inspect}"
+        end
+
+        trigger_requires.each(&vm.method(:require))
+      end
+
+    private
+
+      abstract_method :advance_vm
+
+      def match?(observation)
+        observation.type.eql?(self.class) && observation.payload.eql?(expected_payload)
+      end
+
+      # Expectation and advance on require calls
+      class Require < self
+      end
+
+      # Expectation and advance on eval calls
+      class Eval < self
+      end
+    end
+
+    # A fake implementation of Kernel#require
+    def require(logical_name)
+      handle_event(EventObservation.new(EventExpectation::Require, logical_name: logical_name))
+      self
+    end
+
+    # A fake implementation of Kernel#eval
+    def eval(source, binding, location)
+      handle_event(
+        EventObservation.new(
+          EventExpectation::Eval,
+          binding:  binding,
+          source:   source,
+          source_location: location
+        )
+      )
+      self
+    end
+
+    # Test if VM events where fully processed
+    def done?
+      expected_events.empty?
+    end
+
+  private
+
+    def handle_event(observation)
+      fail "Unexpected event: #{observation.type} / #{observation.payload}" if expected_events.empty?
+
+      expected_events.slice!(0).handle(self, observation)
+    end
+  end
+end # MutantSpec

data/spec/support/shared_context.rb

@@ -1,3 +1,4 @@
+# rubocop:disable ModuleLength
 module SharedContext
   def update(name, &block)
     define_method(name) do
@@ -13,6 +14,14 @@ module SharedContext
     end
   end
 
+  def it_reports(expected_content)
+    it 'writes expected report to output' do
+      described_class.call(output, reportable)
+      output.rewind
+      expect(output.read).to eql(strip_indent(expected_content))
+    end
+  end
+
   # rubocop:disable MethodLength
   # rubocop:disable AbcSize
   def setup_shared_context
@@ -21,11 +30,17 @@ module SharedContext
     let(:job_b)            { Mutant::Parallel::Job.new(index: 1, payload: mutation_b)                   }
     let(:job_a_result)     { Mutant::Runner::JobResult.new(job: job_a, result: mutation_a_result)       }
     let(:job_b_result)     { Mutant::Runner::JobResult.new(job: job_b, result: mutation_b_result)       }
-    let(:mutations)        { [mutation_a, mutation_b]                                                   }
-    let(:matchable_scopes) { double('matchable scopes', length: 10)                                     }
     let(:test_a)           { double('test a', identification: 'test-a')                                 }
     let(:test_b)           { double('test b', identification: 'test-b')                                 }
+    let(:output)           { StringIO.new                                                               }
+    let(:matchable_scopes) { double('matchable scopes', length: 10)                                     }
     let(:message_sequence) { FakeActor::MessageSequence.new                                             }
+    let(:mutations)        { [mutation_a, mutation_b]                                                   }
+    let(:mutation_a_node)  { s(:false)                                                                  }
+    let(:mutation_b_node)  { s(:nil)                                                                    }
+    let(:mutation_b)       { Mutant::Mutation::Evil.new(subject_a, mutation_b_node)                     }
+    let(:mutation_a)       { Mutant::Mutation::Evil.new(subject_a, mutation_a_node)                     }
+    let(:subject_a_node)   { s(:true)                                                                   }
 
     let(:status) do
       Mutant::Parallel::Status.new(
@@ -45,8 +60,8 @@ module SharedContext
     let(:subject_a) do
       double(
         'subject a',
-        node:           s(:true),
-        source:         'true',
+        node:           subject_a_node,
+        source:         Unparser.unparse(subject_a_node),
         tests:          [test_a],
         identification: 'subject-a'
       )
@@ -64,12 +79,6 @@ module SharedContext
       )
     end
 
-    let(:mutation_a_node) { s(:false) }
-    let(:mutation_b_node) { s(:nil)   }
-
-    let(:mutation_b) { Mutant::Mutation::Evil.new(subject_a, mutation_b_node) }
-    let(:mutation_a) { Mutant::Mutation::Evil.new(subject_a, mutation_a_node) }
-
     let(:mutation_a_result) do
       Mutant::Result::Mutation.new(
         mutation:    mutation_a,

data/spec/unit/mutant/ast_spec.rb

@@ -23,7 +23,7 @@ RSpec.describe Mutant::AST do
       let(:block) { ->(node) { node.equal?(child_a) } }
 
       it 'returns the full path' do
-        expect(path).to eql([:root, :parent, :child_a])
+        expect(path).to eql(%i[root parent child_a])
       end
     end
 
@@ -31,7 +31,7 @@ RSpec.describe Mutant::AST do
       let(:block) { ->(node) { node.equal?(child_a) || node.equal?(child_b) } }
 
       it 'returns the last full path' do
-        expect(path).to eql([:root, :parent, :child_b])
+        expect(path).to eql(%i[root parent child_b])
       end
     end
   end

data/spec/unit/mutant/cache_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Mutant::Cache do
+  let(:object) { described_class.new }
+
+  describe '#parse' do
+    let(:path) { double('Path') }
+
+    subject { object.parse(path) }
+
+    before do
+      allow(File).to receive(:read).with(path).and_return(':source')
+    end
+
+    it 'returns parsed source' do
+      expect(subject).to eql(s(:sym, :source))
+    end
+
+    it 'returns cached parsed source' do
+      source = object.parse(path)
+      expect(subject).to be(source)
+    end
+  end
+end

data/spec/unit/mutant/cli_spec.rb

@@ -105,13 +105,6 @@ RSpec.describe Mutant::CLI do
       it_should_behave_like 'an invalid cli run'
     end
 
-    context 'with code filter and missing argument' do
-      let(:arguments)        { %w[--code]                 }
-      let(:expected_message) { 'missing argument: --code' }
-
-      it_should_behave_like 'an invalid cli run'
-    end
-
     context 'with include help flag' do
       let(:flags) { %w[--help] }
 
@@ -133,10 +126,8 @@ Environment:
 
 Options:
         --expected-coverage COVERAGE Fail unless COVERAGE is not reached exactly, parsed via Rational()
-        --score COVERAGE             Fail unless COVERAGE is not reached exactly [deprecated]
-        --use STRATEGY               Use STRATEGY for killing mutations
+        --use INTEGRATION            Use INTEGRATION to kill mutations
         --ignore-subject PATTERN     Ignore subjects that match PATTERN
-        --code CODE                  Scope execution to subjects with CODE
         --fail-fast                  Fail fast
         --version                    Print mutants version
     -d, --debug                      Enable debugging output
@@ -229,16 +220,6 @@ Options:
       end
     end
 
-    context 'with score flag' do
-      let(:flags) { %w[--score 50.0] }
-
-      it_should_behave_like 'a cli parser'
-
-      it 'configures expected coverage' do
-        expect(subject.config.expected_coverage).to eql(Rational(1, 2))
-      end
-    end
-
     context 'with require flag' do
       let(:flags) { %w[--require foo] }
 
@@ -288,15 +269,5 @@ Options:
         expect(subject.config.zombie).to be(true)
       end
     end
-
-    context 'with subject code filter' do
-      let(:flags) { %w[--code faa --code bbb] }
-
-      let(:expected_matcher_config) do
-        default_matcher_config.update(subject_selects: [[:code, 'faa'], [:code, 'bbb']])
-      end
-
-      it_should_behave_like 'a cli parser'
-    end
   end
 end

data/spec/unit/mutant/context_spec.rb

@@ -1,3 +1,4 @@
+# rubocop:disable ClosingParenthesisIndentation
 RSpec.describe Mutant::Context::Scope do
   describe '.wrap' do
     subject { described_class.wrap(scope, node) }

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

@@ -30,10 +30,12 @@ RSpec.describe Mutant::Expression::Method do
       let(:input) { instance_method }
 
       it 'returns correct matcher' do
-        should eql(Mutant::Matcher::Method::Instance.new(
-          env,
-          TestApp::Literal, TestApp::Literal.instance_method(:string)
-        ))
+        should eql(
+          Mutant::Matcher::Method::Instance.new(
+            env,
+            TestApp::Literal, TestApp::Literal.instance_method(:string)
+          )
+        )
       end
     end
 

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

@@ -1,6 +1,6 @@
 RSpec.describe Mutant::Parallel::Master do
   let(:message_sequence)     { FakeActor::MessageSequence.new                                             }
-  let(:actor_names)          { [:master, :worker_a, :worker_b]                                            }
+  let(:actor_names)          { %i[master worker_a worker_b]                                               }
   let(:status)               { double('Status')                                                           }
   let(:sink)                 { FakeSink.new                                                               }
   let(:processor)            { double('Processor')                                                        }

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

@@ -0,0 +1,33 @@
+RSpec.describe Mutant::Reporter::CLI::Printer::Config do
+  setup_shared_context
+
+  let(:reportable) { config }
+
+  describe '.call' do
+    context 'on default config' do
+      it_reports(<<-REPORT)
+        Mutant configuration:
+        Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
+        Integration:     null
+        Expect Coverage: 100.00%
+        Jobs:            1
+        Includes:        []
+        Requires:        []
+      REPORT
+    end
+
+    context 'with non default coverage expectation' do
+      update(:config) { { expected_coverage: 0.1r } }
+
+      it_reports(<<-REPORT)
+        Mutant configuration:
+        Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
+        Integration:     null
+        Expect Coverage: 10.00%
+        Jobs:            1
+        Includes:        []
+        Requires:        []
+      REPORT
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+RSpec.describe Mutant::Reporter::CLI::Printer::EnvProgress do
+  setup_shared_context
+
+  update(:config) { { expected_coverage: 0.1r } }
+
+  let(:reportable) { env_result }
+
+  describe '.call' do
+    context 'without progress' do
+      update(:subject_a_result) { { mutation_results: [] } }
+
+      it_reports <<-'STR'
+        Mutant configuration:
+        Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
+        Integration:     null
+        Expect Coverage: 10.00%
+        Jobs:            1
+        Includes:        []
+        Requires:        []
+        Subjects:        1
+        Mutations:       2
+        Kills:           0
+        Alive:           0
+        Runtime:         4.00s
+        Killtime:        0.00s
+        Overhead:        Inf%
+        Coverage:        0.00%
+        Expected:        10.00%
+      STR
+    end
+
+    context 'on full coverage' do
+      it_reports <<-'STR'
+        Mutant configuration:
+        Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
+        Integration:     null
+        Expect Coverage: 10.00%
+        Jobs:            1
+        Includes:        []
+        Requires:        []
+        Subjects:        1
+        Mutations:       2
+        Kills:           2
+        Alive:           0
+        Runtime:         4.00s
+        Killtime:        2.00s
+        Overhead:        100.00%
+        Coverage:        100.00%
+        Expected:        10.00%
+      STR
+    end
+
+    context 'on partial coverage' do
+      update(:mutation_a_test_result) { { passed: true } }
+
+      it_reports <<-'STR'
+        Mutant configuration:
+        Matcher:         #<Mutant::Matcher::Config match_expressions=[] subject_ignores=[] subject_selects=[]>
+        Integration:     null
+        Expect Coverage: 10.00%
+        Jobs:            1
+        Includes:        []
+        Requires:        []
+        Subjects:        1
+        Mutations:       2
+        Kills:           1
+        Alive:           1
+        Runtime:         4.00s
+        Killtime:        2.00s
+        Overhead:        100.00%
+        Coverage:        50.00%
+        Expected:        10.00%
+      STR
+    end
+  end
+end