mutest 0.0.1 → 0.0.2

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

@@ -0,0 +1,212 @@
+RSpec.describe Mutest::Reporter::CLI do
+  setup_shared_context
+
+  let(:object) { described_class.new(output, format) }
+
+  let(:tput) do
+    instance_double(
+      Mutest::Reporter::CLI::Tput,
+      restore: '[tput-restore]',
+      prepare: '[tput-prepare]'
+    )
+  end
+
+  let(:framed_format) do
+    described_class::Format::Framed.new(
+      tty:  false,
+      tput: tput
+    )
+  end
+
+  let(:tty?) { false }
+
+  let(:progressive_format) do
+    described_class::Format::Progressive.new(tty: tty?)
+  end
+
+  let(:format) { framed_format }
+
+  def contents
+    output.rewind
+    output.read
+  end
+
+  def self.it_reports(expected_content)
+    it 'writes expected report to output' do
+      expect(subject).to be(object)
+      expect(contents).to eql(strip_indent(expected_content))
+    end
+  end
+
+  before do
+    allow(Time).to receive(:now).and_return(Time.now)
+  end
+
+  describe '.build' do
+    subject { described_class.build(output) }
+
+    let(:progressive_format) do
+      described_class::Format::Progressive.new(tty: tty?)
+    end
+
+    let(:framed_format) do
+      described_class::Format::Framed.new(
+        tty:  true,
+        tput: tput
+      )
+    end
+
+    before do
+      expect(ENV).to receive(:key?).with('CI').and_return(ci?)
+    end
+
+    let(:output) { instance_double(IO, tty?: tty?) }
+    let(:tty?)   { true                            }
+    let(:ci?)    { false                           }
+
+    context 'when not on CI and on a tty' do
+      before do
+        expect(described_class::Tput).to receive(:detect).and_return(tput)
+      end
+
+      context 'and tput is available' do
+        it { is_expected.to eql(described_class.new(output, framed_format)) }
+      end
+
+      context 'and tput is not available' do
+        let(:tput) { nil }
+
+        it { is_expected.to eql(described_class.new(output, progressive_format)) }
+      end
+    end
+
+    context 'when on CI' do
+      let(:ci?) { true }
+      it { is_expected.to eql(described_class.new(output, progressive_format)) }
+    end
+
+    context 'when output is not a tty?' do
+      let(:tty?) { false }
+      it { is_expected.to eql(described_class.new(output, progressive_format)) }
+    end
+
+    context 'when output does not respond to #tty?' do
+      let(:output) { instance_double(IO) }
+      let(:tty?)   { false               }
+
+      it { is_expected.to eql(described_class.new(output, progressive_format)) }
+    end
+  end
+
+  describe '#warn' do
+    subject { object.warn(message) }
+
+    let(:message) { 'message' }
+
+    it_reports("message\n")
+  end
+
+  describe '#delay' do
+    subject { object.delay }
+
+    it { is_expected.to be(0.05) }
+  end
+
+  describe '#start' do
+    subject { object.start(env) }
+
+    context 'on progressive format' do
+      let(:format) { progressive_format }
+
+      it_reports(<<-REPORT)
+        Mutest configuration:
+        Matcher:         #<Mutest::Matcher::Config empty>
+        Integration:     Mutest::Integration::Null
+        Jobs:            1
+        Includes:        []
+        Requires:        []
+      REPORT
+    end
+
+    context 'on framed format' do
+      it_reports '[tput-prepare]'
+    end
+  end
+
+  describe '#report' do
+    subject { object.report(env_result) }
+
+    it_reports(<<-REPORT)
+      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%
+    REPORT
+  end
+
+  describe '#progress' do
+    subject { object.progress(status) }
+
+    context 'on framed format' do
+      let(:format) { framed_format }
+
+      it_reports(<<-REPORT)
+        [tput-restore]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%
+        Active subjects: 0
+      REPORT
+    end
+
+    context 'on progressive format' do
+      let(:format) { progressive_format }
+
+      context 'with empty scheduler' do
+        with(:env_result) { { subject_results: [] } }
+
+        let(:tty?) { true }
+
+        it_reports Mutest::Color::GREEN.format('(00/02) 100% - killtime: 0.00s runtime: 4.00s overhead: 4.00s') << "\n"
+      end
+
+      context 'with last mutation present' do
+        with(:env_result) { { subject_results: [subject_a_result] } }
+
+        context 'when mutation is successful' do
+          it_reports "(02/02) 100% - killtime: 2.00s runtime: 4.00s overhead: 2.00s\n"
+        end
+
+        context 'when mutation is NOT successful' do
+          with(:mutation_a_test_result) { { passed: true } }
+
+          it_reports "(01/02)  50% - killtime: 2.00s runtime: 4.00s overhead: 2.00s\n"
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutest/reporter/null_spec.rb

@@ -0,0 +1,12 @@
+RSpec.describe Mutest::Reporter::Null do
+  let(:object) { described_class.new     }
+  let(:value)  { instance_double(Object) }
+
+  %i[progress report start warn].each do |name|
+    describe "##{name}" do
+      subject { object.public_send(name, value) }
+
+      it_should_behave_like 'a command method'
+    end
+  end
+end

data/spec/unit/mutest/reporter/sequence_spec.rb

@@ -0,0 +1,29 @@
+RSpec.describe Mutest::Reporter::Sequence do
+  let(:object)     { described_class.new([reporter_a, reporter_b]) }
+  let(:value)      { instance_double(Object)                       }
+  let(:reporter_a) { instance_double(Mutest::Reporter, delay: 1.0) }
+  let(:reporter_b) { instance_double(Mutest::Reporter, delay: 2.0) }
+
+  %i[report progress warn start].each do |name|
+    describe "##{name}" do
+      subject { object.public_send(name, value) }
+
+      before do
+        [reporter_a, reporter_b].each do |receiver|
+          expect(receiver).to receive(name)
+            .ordered
+            .with(value)
+            .and_return(receiver)
+        end
+      end
+
+      it_should_behave_like 'a command method'
+    end
+  end
+
+  describe '#delay' do
+    it 'returns the lowest value' do
+      expect(object.delay).to be(1.0)
+    end
+  end
+end

data/spec/unit/mutest/repository/diff_spec.rb

@@ -0,0 +1,106 @@
+describe Mutest::Repository::Diff do
+  describe '#touches?' do
+    subject { object.touches?(path, line_range) }
+
+    let(:object) do
+      described_class.new(
+        config: config,
+        from:   'from_rev',
+        to:     'to_rev'
+      )
+    end
+
+    let(:config) do
+      instance_double(
+        Mutest::Config,
+        kernel:   kernel,
+        open3:    open3,
+        pathname: pathname
+      )
+    end
+
+    let(:pathname)   { class_double(Pathname, pwd: pwd) }
+    let(:open3)      { class_double(Open3)              }
+    let(:kernel)     { class_double(Kernel)             }
+    let(:pwd)        { Pathname.new('/foo')             }
+    let(:path)       { Pathname.new('/foo/bar.rb')      }
+    let(:line_range) { 1..2                             }
+
+    shared_context 'test if git tracks the file' do
+      before do
+        expect(config.kernel).to receive(:system)
+          .ordered
+          .with(
+            *%W[git ls-files --error-unmatch -- #{path}],
+            out: File::NULL,
+            err: File::NULL
+          ).and_return(git_ls_success?)
+      end
+    end
+
+    context 'when file is in a different subdirectory' do
+      let(:path) { Pathname.new('/baz/bar.rb') }
+
+      before do
+        expect(config.kernel).not_to receive(:system)
+      end
+
+      it { is_expected.to be(false) }
+    end
+
+    context 'when file is NOT tracked in repository' do
+      let(:git_ls_success?) { false }
+
+      include_context 'test if git tracks the file'
+
+      it { is_expected.to be(false) }
+    end
+
+    context 'when file is tracked in repository' do
+      let(:git_ls_success?) { true                                                 }
+      let(:status)          { instance_double(Process::Status, success?: success?) }
+      let(:stdout)          { instance_double(String, empty?: stdout_empty?)       }
+      let(:stdout_empty?)   { false                                                }
+
+      include_context 'test if git tracks the file'
+
+      before do
+        expect(config.open3).to receive(:capture2)
+          .ordered
+          .with(*expected_git_log_command, binmode: true)
+          .and_return([stdout, status])
+      end
+
+      let(:expected_git_log_command) do
+        %W[git log from_rev...to_rev -L 1,2:#{path}]
+      end
+
+      context 'on failure of git log command' do
+        let(:success?) { false }
+
+        it 'raises error' do
+          expect { subject }.to raise_error(
+            Mutest::Repository::RepositoryError,
+            "Command #{expected_git_log_command} failed!"
+          )
+        end
+      end
+
+      context 'on suuccess of git command' do
+        let(:success?) { true }
+
+        context 'on empty stdout' do
+          let(:stdout_empty?) { true }
+
+          it { is_expected.to be(false) }
+        end
+
+        context 'on non empty stdout' do
+          let(:stdout_empty?) { false }
+
+          it { is_expected.to be(true) }
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutest/repository/subject_filter_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Mutest::Repository::SubjectFilter do
+  context '#call' do
+    subject { object.call(mutest_subject) }
+
+    let(:object) { described_class.new(diff)                 }
+    let(:diff)   { instance_double(Mutest::Repository::Diff) }
+    let(:value)  { instance_double(Object, 'value')          }
+
+    let(:mutest_subject) do
+      double(
+        'Subject',
+        source_path:  double('source path'),
+        source_lines: double('source lines')
+      )
+    end
+
+    before do
+      expect(diff).to receive(:touches?).with(
+        mutest_subject.source_path,
+        mutest_subject.source_lines
+      ).and_return(value)
+    end
+
+    it 'connects return value to repository diff API' do
+      expect(subject).to be(value)
+    end
+  end
+end

data/spec/unit/mutest/require_highjack_spec.rb

@@ -0,0 +1,71 @@
+RSpec.describe Mutest::RequireHighjack do
+  let(:highjacked_calls) { [] }
+  let(:require_calls)    { [] }
+
+  let(:target_module) do
+    acc = require_calls
+    Module.new do
+      define_method(:require, &acc.method(:<<))
+      define_singleton_method(:require, &acc.method(:<<))
+    end
+  end
+
+  def singleton_require(logical_name)
+    target_module.require(logical_name)
+  end
+
+  def instance_require(logical_name)
+    Object.new.extend(target_module).require(logical_name)
+  end
+
+  describe '.call' do
+    let(:logical_name) { instance_double(String) }
+
+    def apply
+      described_class.call(target_module, highjacked_calls.method(:<<))
+    end
+
+    it 'prevents warnings' do
+      expect(Mutest::WarningFilter.use(&method(:apply))).to eql([])
+    end
+
+    it 'returns the original implementation from singleton' do
+      expect { apply.call(logical_name) }
+        .to change { require_calls }
+        .from([])
+        .to([logical_name])
+    end
+
+    context '#require' do
+      it 'does highjack calls' do
+        apply
+        expect { instance_require(logical_name) }
+          .to change { highjacked_calls }
+          .from([])
+          .to([logical_name])
+      end
+
+      it 'does not call original require' do
+        apply
+        expect { instance_require(logical_name) }
+          .not_to change { require_calls }.from([])
+      end
+    end
+
+    context '.require' do
+      it 'does highjack calls' do
+        apply
+        expect { singleton_require(logical_name) }
+          .to change { highjacked_calls }
+          .from([])
+          .to([logical_name])
+      end
+
+      it 'does not call original require' do
+        apply
+        expect { singleton_require(logical_name) }
+          .not_to change { require_calls }.from([])
+      end
+    end
+  end
+end