mutant 0.9.8 → 0.9.13

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Reporter::CLI::Printer::TestResult do
-  setup_shared_context
-
-  let(:reportable) { mutation_a_test_result }
-
-  describe '.call' do
-    it_reports <<~'STR'
-      - 1 @ runtime: 1.0
-        - test-a
-      Test Output:
-      mutation a test result output
-    STR
-  end
-end

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

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Reporter::CLI::Printer do
-  let(:output) { StringIO.new }
-
-  subject { class_under_test.call(output, reportable) }
-
-  def self.it_reports(expectation)
-    it 'writes expected report' do
-      allow(output).to receive(:tty?).and_return(tty?)
-      subject
-      output.rewind
-      expect(output.read).to eql(expectation)
-    end
-  end
-
-  let(:reportable) { instance_double(Mutant::Result::Env, success?: success?) }
-  let(:tty?)       { true                                                     }
-  let(:success?)   { true                                                     }
-
-  describe '.call' do
-    let(:class_under_test) do
-      Class.new(described_class) do
-        def run
-          puts object
-        end
-      end
-    end
-
-    let(:reportable) { 'foo' }
-
-    it_reports "foo\n"
-  end
-
-  describe '.delegate' do
-    let(:reportable) { double(foo: :bar, baz: :boz) }
-
-    let(:class_under_test) do
-      Class.new(described_class) do
-        delegate :foo, :baz
-
-        def run
-          puts(foo)
-          puts(baz)
-        end
-      end
-    end
-
-    it_reports "bar\nboz\n"
-
-    it 'sets delegation methods to private visibility' do
-      expect(class_under_test.private_instance_methods).to include(:foo, :baz)
-    end
-  end
-
-  describe '#status' do
-    let(:class_under_test) do
-      Class.new(described_class) do
-        def run
-          status('foo %s', 'bar')
-        end
-      end
-    end
-
-    context 'on tty' do
-      context 'on success' do
-        it_reports Mutant::Color::GREEN.format('foo bar') + "\n"
-      end
-
-      context 'on failure' do
-        let(:success?) { false }
-        it_reports Mutant::Color::RED.format('foo bar') + "\n"
-      end
-    end
-
-    context 'on no tty' do
-      let(:tty?) { false }
-
-      context 'on success' do
-        it_reports "foo bar\n"
-      end
-
-      context 'on failure' do
-        let(:success?) { false }
-
-        it_reports "foo bar\n"
-      end
-    end
-  end
-
-  describe '#visit_collection' do
-    let(:class_under_test) do
-      reporter = nested_reporter
-      Class.new(described_class) do
-        define_method(:run) do
-          visit_collection(reporter, %w[foo bar])
-        end
-      end
-    end
-
-    let(:nested_reporter) do
-      Class.new(described_class) do
-        def run
-          puts object
-        end
-      end
-    end
-
-    it_reports "foo\nbar\n"
-  end
-
-  describe '#visit' do
-    let(:class_under_test) do
-      reporter = nested_reporter
-      Class.new(described_class) do
-        define_method(:run) do
-          visit(reporter, 'foo')
-        end
-      end
-    end
-
-    let(:nested_reporter) do
-      Class.new(described_class) do
-        def run
-          puts object
-        end
-      end
-    end
-
-    it_reports "foo\n"
-  end
-
-  describe '#info' do
-    let(:class_under_test) do
-      Class.new(described_class) do
-        def run
-          info('%s - %s', 'foo', 'bar')
-        end
-      end
-    end
-
-    it_reports "foo - bar\n"
-  end
-
-  describe '#colorize' do
-    let(:class_under_test) do
-      Class.new(described_class) do
-        def run
-          puts(colorize(Mutant::Color::RED, 'foo'))
-        end
-      end
-    end
-
-    context 'when output is a tty?' do
-      it_reports Mutant::Color::RED.format('foo') + "\n"
-    end
-
-    context 'when output is NOT a tty?' do
-      let(:tty?) { false }
-      it_reports "foo\n"
-    end
-  end
-end

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

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Reporter::CLI do
-  setup_shared_context
-
-  let(:object) { described_class.new(output, format) }
-  let(:tty?)   { false                               }
-
-  let(:format) do
-    described_class::Format::Progressive.new(tty?)
-  end
-
-  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(expected_content)
-    end
-  end
-
-  before do
-    allow(Mutant::Timer).to receive_messages(now: Mutant::Timer.now)
-  end
-
-  describe '.build' do
-    subject { described_class.build(output) }
-
-    context 'when output is a tty' do
-      let(:tty?)   { true                            }
-      let(:output) { instance_double(IO, tty?: true) }
-
-      it { should eql(described_class.new(output, format)) }
-    end
-
-    context 'when output is not a tty' do
-      context 'and does not respond to #tty?' do
-        let(:output) { nil }
-
-        it { should eql(described_class.new(output, format)) }
-      end
-
-      context 'and does respond to #tty?' do
-        it { should eql(described_class.new(output, format)) }
-      end
-    end
-  end
-
-  describe '#warn' do
-    subject { object.warn(message) }
-
-    let(:message) { 'message' }
-
-    it_reports("message\n")
-  end
-
-  describe '#delay' do
-    subject { object.delay }
-
-    it { should eql(1.0) }
-  end
-
-  describe '#start' do
-    subject { object.start(env) }
-
-    it_reports(<<~REPORT)
-      Mutant environment:
-      Matcher:         #<Mutant::Matcher::Config empty>
-      Integration:     null
-      Jobs:            1
-      Includes:        []
-      Requires:        []
-      Subjects:        1
-      Total-Tests:     1
-      Selected-Tests:  1
-      Tests/Subject:   1.00 avg
-      Mutations:       2
-    REPORT
-  end
-
-  describe '#report' do
-    subject { object.report(env_result) }
-
-    it_reports(<<~REPORT)
-      Mutant environment:
-      Matcher:         #<Mutant::Matcher::Config empty>
-      Integration:     null
-      Jobs:            1
-      Includes:        []
-      Requires:        []
-      Subjects:        1
-      Total-Tests:     1
-      Selected-Tests:  1
-      Tests/Subject:   1.00 avg
-      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 'with empty scheduler' do
-      with(:env_result) { { subject_results: [] } }
-
-      let(:tty?) { true }
-
-      # rubocop:disable Metrics/LineLength
-      it_reports Mutant::Color::GREEN.format('progress: 00/02 alive: 0 runtime: 4.00s killtime: 0.00s mutations/s: 0.00') + "\n"
-      # rubocop:enable Metrics/LineLength
-    end
-
-    context 'with last mutation present' do
-      with(:env_result) { { subject_results: [subject_a_result] } }
-
-      context 'when mutation is successful' do
-        it_reports "progress: 02/02 alive: 0 runtime: 4.00s killtime: 2.00s mutations/s: 0.50\n"
-      end
-
-      context 'when mutation is NOT successful' do
-        with(:mutation_a_test_result) { { passed: true } }
-
-        it_reports "progress: 02/02 alive: 1 runtime: 4.00s killtime: 2.00s mutations/s: 0.50\n"
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::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/mutant/reporter/sequence_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Mutant::Reporter::Sequence do
-  let(:object)     { described_class.new([reporter_a, reporter_b]) }
-  let(:value)      { instance_double(Object)                       }
-  let(:reporter_a) { instance_double(Mutant::Reporter, delay: 1.0) }
-  let(:reporter_b) { instance_double(Mutant::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 eql(1.0)
-    end
-  end
-end

data/spec/unit/mutant/repository/diff/ranges_spec.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-describe Mutant::Repository::Diff::Ranges do
-  describe '.parse' do
-    def apply
-      described_class.parse(diff)
-    end
-
-    let(:diff) do
-      Tempfile.open('old') do |old_file|
-        old_file.write(old)
-        old_file.flush
-        Tempfile.open('new') do |new_file|
-          new_file.write(new)
-          new_file.flush
-          # rubocop:disable Lint/RedundantSplatExpansion
-          stdout, status = Open3.capture2(
-            *%W[
-              git
-              diff
-              --no-index
-              --unified=0
-              --
-              #{old_file.path}
-              #{new_file.path}
-            ]
-          )
-          # rubocop:enable Lint/RedundantSplatExpansion
-
-          fail unless [0, 256].include?(status.to_i)
-
-          stdout
-        end
-      end
-    end
-
-    context 'on empty diff' do
-      let(:old) { '' }
-      let(:new) { '' }
-
-      it 'returns emtpy set' do
-        expect(apply).to eql(Set.new)
-      end
-    end
-
-    context 'on empty old' do
-      let(:old) { '' }
-
-      context 'adding a single line' do
-        let(:new) do
-          <<~'STR'
-            a
-          STR
-        end
-
-        it 'returns expected set' do
-          expect(apply).to eql([1..1].to_set)
-        end
-      end
-
-      context 'adding a multiple lines' do
-        let(:old) { '' }
-
-        let(:new) do
-          <<~'STR'
-            a
-            b
-          STR
-        end
-
-        it 'returns expected set' do
-          expect(apply).to eql([1..2].to_set)
-        end
-      end
-    end
-
-    context 'on empty new' do
-      let(:new) { '' }
-
-      context 'removing a single line' do
-        let(:old) do
-          <<~'STR'
-            a
-          STR
-        end
-
-        it 'returns expected set' do
-          expect(apply).to eql([1..1].to_set)
-        end
-      end
-
-      context 'removing a multiple lines' do
-        let(:old) do
-          <<~'STR'
-            a
-            b
-          STR
-        end
-
-        it 'returns expected set' do
-          expect(apply).to eql([1..2].to_set)
-        end
-      end
-    end
-
-    context 'single line modification' do
-      let(:old) do
-        <<~'STR'
-          a
-          b
-          c
-          a
-        STR
-      end
-
-      let(:new) do
-        <<~'STR'
-          a
-          b
-          b
-          a
-        STR
-      end
-
-      it 'returns expected set' do
-        expect(apply).to eql([3..3].to_set)
-      end
-    end
-
-    context 'nonempty old and new' do
-      context 'single line addition' do
-        let(:old) do
-          <<~'STR'
-            a
-            b
-            a
-          STR
-        end
-
-        let(:new) do
-          <<~'STR'
-            a
-            b
-            b
-            a
-          STR
-        end
-
-        it 'returns expected set' do
-          expect(apply).to eql([3..3].to_set)
-        end
-      end
-      context 'multi line modification' do
-        let(:old) do
-          <<~'STR'
-            a
-            b
-            c
-            d
-            a
-          STR
-        end
-
-        let(:new) do
-          <<~'STR'
-            a
-            b
-            b
-            b
-            a
-          STR
-        end
-
-        it 'returns expected set' do
-          expect(apply).to eql([3..4].to_set)
-        end
-      end
-    end
-  end
-end