mutest 0.0.1 → 0.0.2

data/spec/unit/mutest/parallel/source/array_spec.rb

@@ -0,0 +1,47 @@
+RSpec.describe Mutest::Parallel::Source::Array do
+  let(:object) { described_class.new(jobs) }
+
+  let(:job_a) { instance_double(Mutest::Parallel::Job) }
+  let(:job_b) { instance_double(Mutest::Parallel::Job) }
+  let(:job_c) { instance_double(Mutest::Parallel::Job) }
+
+  let(:jobs) { [job_a, job_b, job_c] }
+
+  describe '#next' do
+    subject { object.next }
+
+    context 'when there is a next job' do
+      it 'returns that job' do
+        is_expected.to be(job_a)
+      end
+
+      it 'does not return the same job twice' do
+        expect(object.next).to be(job_a)
+        expect(object.next).to be(job_b)
+        expect(object.next).to be(job_c)
+      end
+    end
+
+    context 'when there is no next job' do
+      let(:jobs) { [] }
+
+      it 'raises error' do
+        expect { subject }.to raise_error(Mutest::Parallel::Source::NoJobError)
+      end
+    end
+  end
+
+  describe '#next?' do
+    subject { object.next? }
+
+    context 'when there is a next job' do
+      it { is_expected.to be(true) }
+    end
+
+    context 'when there is no next job' do
+      let(:jobs) { [] }
+
+      it { is_expected.to be(false) }
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+RSpec.describe Mutest::Parallel::Worker do
+  let(:actor_env) do
+    FakeActor::Env.new(message_sequence, actor_names)
+  end
+
+  let(:message_sequence) { FakeActor::MessageSequence.new    }
+  let(:processor)        { instance_double(Proc)             }
+  let(:mailbox)          { actor_env.mailbox(:worker)        }
+  let(:parent)           { actor_env.mailbox(:parent).sender }
+  let(:payload)          { instance_double(Object)           }
+  let(:result_payload)   { instance_double(Object)           }
+
+  let(:attributes) do
+    {
+      processor: processor,
+      parent:    parent,
+      mailbox:   mailbox
+    }
+  end
+
+  before do
+    message_sequence.add(:parent, :ready, mailbox.sender)
+  end
+
+  describe '.run' do
+    subject { described_class.run(attributes) }
+
+    let(:actor_names) { [:worker] }
+
+    context 'when receiving :job command' do
+      before do
+        expect(processor).to receive(:call).with(payload).and_return(result_payload)
+
+        message_sequence.add(:worker, :job, job)
+        message_sequence.add(:parent, :result, job_result)
+        message_sequence.add(:parent, :ready, mailbox.sender)
+        message_sequence.add(:worker, :stop)
+      end
+
+      let(:index)           { instance_double(Fixnum)                                             }
+      let(:job_result)      { Mutest::Parallel::JobResult.new(job: job, payload: result_payload)  }
+      let(:job)             { Mutest::Parallel::Job.new(index: index, payload: payload)           }
+
+      it 'signals ready and status to parent' do
+        subject
+      end
+
+      it { is_expected.to be(described_class) }
+
+      it 'consumes all messages' do
+        expect { subject }.to change(&message_sequence.method(:consumed?)).from(false).to(true)
+      end
+    end
+
+    context 'when receiving unknown command' do
+      before do
+        message_sequence.add(:worker, :other)
+      end
+
+      it 'raises error' do
+        expect { subject }.to raise_error(Mutest::Actor::ProtocolError, 'Unknown command: :other')
+      end
+    end
+  end
+end

data/spec/unit/mutest/parallel_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe Mutest::Parallel do
+  describe '.async' do
+    subject { described_class.async(config) }
+
+    let(:config)  { instance_double(Mutest::Parallel::Config, env: env)       }
+    let(:env)     { instance_double(Mutest::Actor::Env, new_mailbox: mailbox) }
+    let(:mailbox) { Mutest::Actor::Mailbox.new                                }
+    let(:master)  { instance_double(Mutest::Parallel::Master)                 }
+
+    before do
+      expect(described_class::Master).to receive(:call).with(config).and_return(master)
+    end
+
+    it { is_expected.to eql(described_class::Driver.new(mailbox.bind(master))) }
+  end
+end

data/spec/unit/mutest/parser_spec.rb

@@ -0,0 +1,24 @@
+RSpec.describe Mutest::Parser do
+  let(:object) { described_class.new       }
+  let(:path)   { instance_double(Pathname) }
+  let(:source) { ':source'                 }
+
+  before do
+    expect(path).to receive(:read)
+      .with(no_args)
+      .and_return(source)
+  end
+
+  describe '#open' do
+    subject { object.open(path) }
+
+    it 'returns source file' do
+      expect(subject).to eql(Mutest::SourceFile.new(path, s(:sym, :source), nil))
+    end
+
+    it 'is idempotent' do
+      source = object.open(path)
+      expect(subject).to be(source)
+    end
+  end
+end

data/spec/unit/mutest/registry_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe Mutest::Registry do
+  let(:lookup)  { object.lookup(type)           }
+  let(:object)  { described_class.new           }
+  let(:mutator) { class_double(Mutest::Mutator) }
+
+  def register_mutator
+    object.register(type, mutator)
+  end
+
+  context 'on registered type' do
+    subject { register_mutator }
+
+    let(:type) { :true }
+
+    before { subject }
+
+    it 'returns registered mutator' do
+      expect(lookup).to be(mutator)
+    end
+
+    it_behaves_like 'a command method'
+
+    context 'when registered twice' do
+      it 'fails upon registration' do
+        expect { register_mutator }.to raise_error(described_class::RegistryError, 'Duplicate type registration: :true')
+      end
+    end
+  end
+
+  context 'on unknown type' do
+    let(:type) { :unknown }
+
+    it 'raises error' do
+      expect { lookup }.to raise_error(described_class::RegistryError, 'No entry for: :unknown')
+    end
+  end
+
+  context 'when registering an invalid node type' do
+    let(:type) { :invalid }
+
+    it 'raises error' do
+      expect { register_mutator }.to raise_error(described_class::RegistryError, 'Invalid type registration: :invalid')
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+RSpec.describe Mutest::Reporter::CLI::Printer::Config do
+  setup_shared_context
+
+  let(:reportable) { config }
+
+  describe '.call' do
+    context 'on default config' do
+      it_reports(<<-REPORT)
+        Mutest configuration:
+        Matcher:         #<Mutest::Matcher::Config empty>
+        Integration:     Mutest::Integration::Null
+        Jobs:            1
+        Includes:        []
+        Requires:        []
+      REPORT
+    end
+
+    context 'with non default coverage expectation' do
+      it_reports(<<-REPORT)
+        Mutest configuration:
+        Matcher:         #<Mutest::Matcher::Config empty>
+        Integration:     Mutest::Integration::Null
+        Jobs:            1
+        Includes:        []
+        Requires:        []
+      REPORT
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+RSpec.describe Mutest::Reporter::CLI::Printer::EnvProgress do
+  setup_shared_context
+
+  let(:reportable) { env_result }
+
+  describe '.call' do
+    context 'without progress' do
+      with(:subject_a_result) { { mutation_results: [] } }
+
+      it_reports <<-'STR'
+        Mutest configuration:
+        Matcher:         #<Mutest::Matcher::Config empty>
+        Integration:     Mutest::Integration::Null
+        Jobs:            1
+        Includes:        []
+        Requires:        []
+        Subjects:        1
+        Mutations:       2
+        Results:         0
+        Kills:           0
+        Alive:           0
+        Runtime:         4.00s
+        Killtime:        0.00s
+        Overhead:        Inf%
+        Mutations/s:     0.00
+        Coverage:        100.00%
+      STR
+    end
+
+    context 'on full coverage' do
+      it_reports <<-'STR'
+        Mutest configuration:
+        Matcher:         #<Mutest::Matcher::Config empty>
+        Integration:     Mutest::Integration::Null
+        Jobs:            1
+        Includes:        []
+        Requires:        []
+        Subjects:        1
+        Mutations:       2
+        Results:         2
+        Kills:           2
+        Alive:           0
+        Runtime:         4.00s
+        Killtime:        2.00s
+        Overhead:        100.00%
+        Mutations/s:     0.50
+        Coverage:        100.00%
+      STR
+    end
+
+    context 'on partial coverage' do
+      with(:mutation_a_test_result) { { passed: true } }
+
+      it_reports <<-'STR'
+        Mutest configuration:
+        Matcher:         #<Mutest::Matcher::Config empty>
+        Integration:     Mutest::Integration::Null
+        Jobs:            1
+        Includes:        []
+        Requires:        []
+        Subjects:        1
+        Mutations:       2
+        Results:         2
+        Kills:           1
+        Alive:           1
+        Runtime:         4.00s
+        Killtime:        2.00s
+        Overhead:        100.00%
+        Mutations/s:     0.50
+        Coverage:        50.00%
+      STR
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+RSpec.describe Mutest::Reporter::CLI::Printer::EnvResult do
+  setup_shared_context
+
+  with(:mutation_a_test_result) { { passed: true } }
+
+  let(:reportable) { env_result }
+
+  describe '.call' do
+    it_reports <<-'STR'
+      subject-a
+      - test-a
+      evil:subject-a:d27d2
+      @@ -1,2 +1,2 @@
+      -true
+      +false
+      -----------------------
+      Mutest configuration:
+      Matcher:         #<Mutest::Matcher::Config empty>
+      Integration:     Mutest::Integration::Null
+      Jobs:            1
+      Includes:        []
+      Requires:        []
+      Subjects:        1
+      Mutations:       2
+      Results:         2
+      Kills:           1
+      Alive:           1
+      Runtime:         4.00s
+      Killtime:        2.00s
+      Overhead:        100.00%
+      Mutations/s:     0.50
+      Coverage:        50.00%
+    STR
+  end
+end

data/spec/unit/mutest/reporter/cli/printer/mutation_progress_result_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe Mutest::Reporter::CLI::Printer::MutationProgressResult do
+  setup_shared_context
+
+  let(:reportable) { mutation_a_result }
+
+  before do
+    allow(output).to receive(:tty?).and_return(true)
+  end
+
+  describe '.run' do
+    context 'on killed mutest' do
+      with(:mutation_a_test_result) { { passed: true } }
+
+      it_reports Mutest::Color::RED.format('F')
+    end
+
+    context 'on alive mutest' do
+      with(:mutation_a_test_result) { { passed: false } }
+
+      it_reports Mutest::Color::GREEN.format('.')
+    end
+  end
+end

data/spec/unit/mutest/reporter/cli/printer/mutation_result_spec.rb

@@ -0,0 +1,110 @@
+RSpec.describe Mutest::Reporter::CLI::Printer::MutationResult do
+  setup_shared_context
+
+  let(:reportable) { mutation_a_result }
+
+  describe '.call' do
+    context 'failed kill' do
+      with(:mutation_a_test_result) { { passed: true } }
+
+      context 'on evil mutation' do
+        context 'with a diff' do
+          context 'on a tty' do
+            before do
+              allow(output).to receive(:tty?).and_return(true)
+            end
+
+            it_reports(
+              [
+                [Mutest::Color::NONE,  "evil:subject-a:d27d2\n"],
+                [Mutest::Color::NONE,  "@@ -1,2 +1,2 @@\n"],
+                [Mutest::Color::RED,   "-true\n"],
+                [Mutest::Color::GREEN, "+false\n"],
+                [Mutest::Color::NONE,  "-----------------------\n"]
+              ].map { |color, text| color.format(text) }.join
+            )
+          end
+
+          context 'on non tty' do
+            it_reports(<<-'STR')
+              evil:subject-a:d27d2
+              @@ -1,2 +1,2 @@
+              -true
+              +false
+              -----------------------
+            STR
+          end
+        end
+
+        context 'without a diff' do
+          # This is intentionally invalid AST mutest might produce
+          let(:subject_a_node) { s(:lvar, :super) }
+
+          # Unparses exactly the same way as above node
+          let(:mutation_a_node) { s(:zsuper) }
+
+          it_reports(<<-REPORT)
+            evil:subject-a:a5bc7
+            --- Internal failure ---
+            BUG: Mutation NOT resulted in exactly one diff hunk. Please report a reproduction!
+            Original unparsed source:
+            super
+            Original AST:
+            s(:lvar, :super)
+            Mutated unparsed source:
+            super
+            Mutated AST:
+            s(:zsuper)
+            -----------------------
+          REPORT
+        end
+      end
+
+      context 'on neutral mutation' do
+        with(:mutation_a_test_result) { { passed: false } }
+
+        let(:mutation_a) do
+          Mutest::Mutation::Neutral.new(subject_a, s(:true))
+        end
+
+        it_reports(<<-REPORT)
+          neutral:subject-a:d5318
+          --- Neutral failure ---
+          Original code was inserted unmutated. And the test did NOT PASS.
+          Your tests do not pass initially or you found a bug in mutest / unparser.
+          Subject AST:
+          s(:true)
+          Unparsed Source:
+          true
+          Test Result:
+          - 1 @ runtime: 1.0
+            - test-a
+          Test Output:
+          mutation a test result output
+          -----------------------
+        REPORT
+      end
+
+      context 'on noop mutation' do
+        with(:mutation_a_test_result) { { passed: false } }
+
+        let(:mutation_a) do
+          Mutest::Mutation::Noop.new(subject_a, s(:true))
+        end
+
+        it_reports(<<-REPORT)
+          noop:subject-a:d5318
+          ---- Noop failure -----
+          No code was inserted. And the test did NOT PASS.
+          This is typically a problem of your specs not passing unmutated.
+          Test Result:
+          - 1 @ runtime: 1.0
+            - test-a
+          Test Output:
+          mutation a test result output
+          -----------------------
+        REPORT
+      end
+    end
+  end
+end