mutest 0.0.1 → 0.0.2

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

@@ -0,0 +1,43 @@
+RSpec.describe Mutest::Reporter::CLI::Printer::StatusProgressive do
+  setup_shared_context
+
+  let(:reportable) { status }
+
+  describe '.call' do
+    context 'with empty scheduler' do
+      with(:env_result) { { subject_results: [] } }
+
+      it_reports <<-REPORT
+        (00/02) 100% - killtime: 0.00s runtime: 4.00s overhead: 4.00s
+      REPORT
+    end
+
+    context 'with scheduler active on one subject' do
+      context 'without progress' do
+        with(:status) { { active_jobs: [].to_set } }
+
+        it_reports(<<-REPORT)
+          (02/02) 100% - killtime: 2.00s runtime: 4.00s overhead: 2.00s
+        REPORT
+      end
+
+      context 'with progress' do
+        with(:status) { { active_jobs: [job_b, job_a].to_set } }
+
+        context 'on failure' do
+          with(:mutation_a_test_result) { { passed: true } }
+
+          it_reports(<<-REPORT)
+            (01/02)  50% - killtime: 2.00s runtime: 4.00s overhead: 2.00s
+          REPORT
+        end
+
+        context 'on success' do
+          it_reports(<<-REPORT)
+            (02/02) 100% - killtime: 2.00s runtime: 4.00s overhead: 2.00s
+          REPORT
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+RSpec.describe Mutest::Reporter::CLI::Printer::Status do
+  setup_shared_context
+
+  let(:reportable) { status }
+
+  describe '.call' do
+    context 'with empty scheduler' do
+      with(:env_result) { { subject_results: [] } }
+
+      it_reports <<-REPORT
+        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%
+        Active subjects: 0
+      REPORT
+    end
+
+    context 'with scheduler active on one subject' do
+      context 'without progress' do
+        with(:status) { { active_jobs: [].to_set } }
+
+        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%
+          Active subjects: 0
+        REPORT
+      end
+
+      context 'with progress' do
+        with(:status) { { active_jobs: [job_b, job_a].to_set } }
+
+        context 'on failure' do
+          with(:mutation_a_test_result) { { passed: true } }
+
+          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:           1
+            Alive:           1
+            Runtime:         4.00s
+            Killtime:        2.00s
+            Overhead:        100.00%
+            Mutations/s:     0.50
+            Coverage:        50.00%
+            Active Jobs:
+            0: evil:subject-a:d27d2
+            1: evil:subject-a:d5a9d
+            Active subjects: 1
+            subject-a mutations: 2
+            F.
+            (01/02)  50% - killtime: 2.00s runtime: 2.00s overhead: 0.00s
+          REPORT
+        end
+
+        context 'on success' do
+          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%
+            Active Jobs:
+            0: evil:subject-a:d27d2
+            1: evil:subject-a:d5a9d
+            Active subjects: 1
+            subject-a mutations: 2
+            ..
+            (02/02) 100% - killtime: 2.00s runtime: 2.00s overhead: 0.00s
+          REPORT
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+RSpec.describe Mutest::Reporter::CLI::Printer::SubjectProgress do
+  setup_shared_context
+
+  let(:reportable) { subject_a_result }
+
+  describe '.call' do
+    context 'on full coverage' do
+      it_reports <<-'STR'
+        subject-a mutations: 2
+        ..
+        (02/02) 100% - killtime: 2.00s runtime: 2.00s overhead: 0.00s
+      STR
+    end
+
+    context 'on partial coverage' do
+      with(:mutation_a_test_result) { { passed: true } }
+
+      it_reports <<-'STR'
+        subject-a mutations: 2
+        F.
+        (01/02)  50% - killtime: 2.00s runtime: 2.00s overhead: 0.00s
+      STR
+    end
+
+    context 'without results' do
+      with(:subject_a_result) { { mutation_results: [] } }
+
+      it_reports <<-'STR'
+        subject-a mutations: 2
+        (00/02) 100% - killtime: 0.00s runtime: 0.00s overhead: 0.00s
+      STR
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+RSpec.describe Mutest::Reporter::CLI::Printer::SubjectResult do
+  setup_shared_context
+
+  let(:reportable) { subject_a_result }
+
+  describe '.call' do
+    context 'on full coverage' do
+      it_reports <<-'STR'
+        subject-a
+        - test-a
+      STR
+    end
+
+    context 'on partial coverage' do
+      with(:mutation_a_test_result) { { passed: true } }
+
+      it_reports <<-'STR'
+        subject-a
+        - test-a
+        evil:subject-a:d27d2
+        @@ -1,2 +1,2 @@
+        -true
+        +false
+        -----------------------
+      STR
+    end
+
+    context 'without results' do
+      with(:subject_a_result) { { mutation_results: [] } }
+
+      it_reports <<-'STR'
+        subject-a
+        - test-a
+      STR
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+RSpec.describe Mutest::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/mutest/reporter/cli/printer_spec.rb

@@ -0,0 +1,161 @@
+RSpec.describe Mutest::Reporter::CLI::Printer do
+  subject { class_under_test.call(output, reportable) }
+
+  let(:output) { StringIO.new }
+
+  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(strip_indent(expectation))
+    end
+  end
+
+  let(:reportable) { instance_double(Mutest::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 Mutest::Color::GREEN.format('foo bar') << "\n"
+      end
+
+      context 'on failure' do
+        let(:success?) { false }
+        it_reports Mutest::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(Mutest::Color::RED, 'foo'))
+        end
+      end
+    end
+
+    context 'when output is a tty?' do
+      it_reports Mutest::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/mutest/reporter/cli/tput_spec.rb

@@ -0,0 +1,48 @@
+RSpec.describe Mutest::Reporter::CLI::Tput do
+  describe '.detect' do
+    subject { described_class.detect }
+
+    def expect_command(command, stdout, success)
+      allow(Open3).to receive(:capture3).with(command).and_return(
+        [
+          stdout,
+          instance_double(IO),
+          instance_double(Process::Status, 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) { is_expected.to eql('[reset][sc]') }
+      its(:restore) { is_expected.to eql('[rc][ed]')    }
+    end
+
+    context 'when tput reset fails' do
+      let(:tput_reset?) { false }
+
+      it { is_expected.to 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) { is_expected.to eql('[reset][sc]') }
+      its(:restore) { is_expected.to eql('[rc][cd]')    }
+    end
+  end
+end