Merge pull request #937 from mbj/improve/reporting

Add env details to start report

Author: mbj

docs/mutant-minitest.md

@@ -63,7 +63,7 @@ bundle exec mutant --include lib --require auom --use minitest -- 'AUOM*'
 This prints a report like:
 
 ```sh
-Mutant configuration:
+Mutant environment:
 Matcher:         #<Mutant::Matcher::Config match_expressions: [AUOM*]>
 Integration:     Mutant::Integration::Minitest
 Jobs:            8

docs/mutant-rspec.md

@@ -37,7 +37,7 @@ bundle exec mutant --include lib --require auom --use rspec -- 'AUOM*'
 This prints a report like:
 
 ```sh
-Mutant configuration:
+Mutant environment:
 Matcher:         #<Mutant::Matcher::Config match_expressions: [AUOM*]>
 Integration:     Mutant::Integration::Rspec
 Jobs:            8

lib/mutant.rb

@@ -169,6 +169,7 @@ module Mutant
 require 'mutant/reporter/cli'
 require 'mutant/reporter/cli/printer'
 require 'mutant/reporter/cli/printer/config'
+require 'mutant/reporter/cli/printer/env'
 require 'mutant/reporter/cli/printer/env_progress'
 require 'mutant/reporter/cli/printer/env_result'
 require 'mutant/reporter/cli/printer/isolation_result'

lib/mutant/env.rb

@@ -74,6 +74,54 @@ def warn(message)
       self
     end
 
+    # Selected tests
+    #
+    # @return [Set<Test>]
+    def selected_tests
+      selections.values.flatten.to_set
+    end
+    memoize :selected_tests
+
+    # Amount of mutations
+    #
+    # @return [Integer]
+    def amount_mutations
+      mutations.length
+    end
+    memoize :amount_mutations
+
+    # Amount of tests reachable by integration
+    #
+    # @return [Integer]
+    def amount_total_tests
+      integration.all_tests.length
+    end
+    memoize :amount_total_tests
+
+    # Amount of selected subjects
+    #
+    # @return [Integer]
+    def amount_subjects
+      subjects.length
+    end
+    memoize :amount_subjects
+
+    # Amount of selected tests
+    #
+    # @return [Integer]
+    def amount_selected_tests
+      selected_tests.length
+    end
+    memoize :amount_selected_tests
+
+    # Ratio between selected tests and subjects
+    #
+    # @return [Rational]
+    def test_subject_ratio
+      Rational(amount_selected_tests, amount_subjects)
+    end
+    memoize :test_subject_ratio
+
   private
 
     # Kill mutation under isolation with integration

lib/mutant/reporter/cli/format.rb

@@ -72,7 +72,7 @@ class Progressive < self
           #
           # @return [String]
           def start(env)
-            format(Printer::Config, env.config)
+            format(Printer::Env, env)
           end
 
           # Progress representation

lib/mutant/reporter/cli/printer/config.rb

@@ -13,7 +13,6 @@ class Config < self
           #
           # @return [undefined]
           def run
-            info 'Mutant configuration:'
             info 'Matcher:         %s', object.matcher.inspect
             info 'Integration:     %s', object.integration
             info 'Jobs:            %d', object.jobs

lib/mutant/reporter/cli/printer/env.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Reporter
+    class CLI
+      class Printer
+        # Env printer
+        class Env < self
+          delegate(
+            :amount_mutations,
+            :amount_selected_tests,
+            :amount_subjects,
+            :amount_total_tests,
+            :config,
+            :test_subject_ratio
+          )
+
+          FORMATS = IceNine.deep_freeze([
+            [:info,   'Subjects:        %s',        :amount_subjects      ],
+            [:info,   'Total-Tests:     %s',        :amount_total_tests   ],
+            [:info,   'Selected-Tests:  %s',        :amount_selected_tests],
+            [:info,   'Tests/Subject:   %0.2f avg', :test_subject_ratio   ],
+            [:info,   'Mutations:       %s',        :amount_mutations     ]
+          ])
+
+          # Run printer
+          #
+          # @return [undefined]
+          def run
+            info('Mutant environment:')
+            visit(Config, config)
+            FORMATS.each do |report, format, value|
+              __send__(report, format, __send__(value))
+            end
+          end
+        end # EnvProgress
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutant

lib/mutant/reporter/cli/printer/env_progress.rb

@@ -8,41 +8,31 @@ class Printer
         class EnvProgress < self
           delegate(
             :amount_mutation_results,
-            :amount_mutations,
             :amount_mutations_alive,
             :amount_mutations_killed,
-            :amount_selected_tests,
-            :amount_subjects,
-            :amount_total_tests,
             :coverage,
             :env,
             :killtime,
             :overhead,
-            :runtime,
-            :test_subject_ratio
+            :runtime
           )
 
           FORMATS = IceNine.deep_freeze([
-            [:info,   'Subjects:        %s',        :amount_subjects         ],
-            [:info,   'Total-Tests:     %s',        :amount_total_tests      ],
-            [:info,   'Selected-Tests:  %s',        :amount_selected_tests   ],
-            [:info,   'Tests/Subject:   %0.2f avg', :test_subject_ratio      ],
-            [:info,   'Mutations:       %s',        :amount_mutations        ],
-            [:info,   'Results:         %s',        :amount_mutation_results ],
-            [:info,   'Kills:           %s',        :amount_mutations_killed ],
-            [:info,   'Alive:           %s',        :amount_mutations_alive  ],
-            [:info,   'Runtime:         %0.2fs',    :runtime                 ],
-            [:info,   'Killtime:        %0.2fs',    :killtime                ],
-            [:info,   'Overhead:        %0.2f%%',   :overhead_percent        ],
-            [:info,   'Mutations/s:     %0.2f',     :mutations_per_second    ],
-            [:status, 'Coverage:        %0.2f%%',   :coverage_percent        ]
+            [:info,   'Results:         %s',      :amount_mutation_results],
+            [:info,   'Kills:           %s',      :amount_mutations_killed],
+            [:info,   'Alive:           %s',      :amount_mutations_alive ],
+            [:info,   'Runtime:         %0.2fs',  :runtime                ],
+            [:info,   'Killtime:        %0.2fs',  :killtime               ],
+            [:info,   'Overhead:        %0.2f%%', :overhead_percent       ],
+            [:info,   'Mutations/s:     %0.2f',   :mutations_per_second   ],
+            [:status, 'Coverage:        %0.2f%%', :coverage_percent       ]
           ])
 
           # Run printer
           #
           # @return [undefined]
           def run
-            visit(Config, env.config)
+            visit(Env, env)
             FORMATS.each do |report, format, value|
               __send__(report, format, __send__(value))
             end

lib/mutant/result.rb

@@ -101,35 +101,6 @@ def amount_mutations
         env.mutations.length
       end
 
-      # Amount of subjects
-      #
-      # @return [Integer]
-      def amount_subjects
-        env.subjects.length
-      end
-
-      # Amount of tests reachable by integration
-      #
-      # @return [Integer]
-      def amount_total_tests
-        env.integration.all_tests.length
-      end
-
-      # Amount of selected tests
-      #
-      # @return [Integer]
-      def amount_selected_tests
-        env.selections.values.flatten.to_set.length
-      end
-      memoize :amount_selected_tests
-
-      # Ratio between selected tests and subjects
-      #
-      # @return [Rational]
-      def test_subject_ratio
-        Rational(amount_selected_tests, amount_subjects)
-      end
-
       # Test if processing needs to stop
       #
       # @return [Boolean]

spec/support/shared_context.rb

@@ -36,6 +36,7 @@ def setup_shared_context
     let(:output)          { StringIO.new                                             }
     let(:subject_a_node)  { s(:true)                                                 }
     let(:test_a)          { instance_double(Mutant::Test, identification: 'test-a')  }
+    let(:subjects)        { [subject_a]                                              }
 
     let(:job_a) do
       Mutant::Parallel::Source::Job.new(
@@ -54,14 +55,24 @@ def setup_shared_context
     let(:env) do
       instance_double(
         Mutant::Env,
-        config:      config,
-        integration: integration,
-        mutations:   mutations,
-        selections:  { subject_a => [test_a] },
-        subjects:    [subject_a]
+        amount_mutations:      mutations.length,
+        amount_selected_tests: selections.values.flatten.to_set.length,
+        amount_subjects:       subjects.length,
+        amount_total_tests:    integration.all_tests.length,
+        config:                config,
+        integration:           integration,
+        mutations:             mutations,
+        selected_tests:        [test_a].to_set,
+        selections:            selections,
+        subjects:              subjects,
+        test_subject_ratio:    Rational(1)
       )
     end
 
+    let(:selections) do
+      { subject_a => [test_a] }
+    end
+
     let(:integration) do
       instance_double(
         Mutant::Integration,

spec/unit/mutant/env_spec.rb

@@ -8,27 +8,31 @@
       matchable_scopes: [],
       mutations:        [],
       selector:         selector,
-      subjects:         [mutation_subject],
+      subjects:         [subject_a, subject_b],
       parser:           Mutant::Parser.new,
       world:            world
     )
   end
 
-  let(:integration)       { instance_double(Mutant::Integration) }
   let(:integration_class) { Mutant::Integration::Null            }
   let(:isolation)         { Mutant::Isolation::None.new          }
   let(:kernel)            { instance_double(Object, 'kernel')    }
-  let(:mutation_subject)  { instance_double(Mutant::Subject)     }
+  let(:subject_a)         { instance_double(Mutant::Subject, :a) }
+  let(:subject_b)         { instance_double(Mutant::Subject, :b) }
   let(:reporter)          { instance_double(Mutant::Reporter)    }
   let(:selector)          { instance_double(Mutant::Selector)    }
-  let(:test_a)            { instance_double(Mutant::Test)        }
-  let(:test_b)            { instance_double(Mutant::Test)        }
-  let(:tests)             { [test_a, test_b]                     }
+  let(:test_a)            { instance_double(Mutant::Test, :a)    }
+  let(:test_b)            { instance_double(Mutant::Test, :b)    }
+  let(:test_c)            { instance_double(Mutant::Test, :c)    }
+
+  let(:integration) do
+    instance_double(Mutant::Integration, all_tests: [test_a, test_b, test_c])
+  end
 
   let(:mutation) do
     instance_double(
       Mutant::Mutation,
-      subject: mutation_subject
+      subject: subject_a
     )
   end
 
@@ -50,8 +54,12 @@
 
   before do
     allow(selector).to receive(:call)
-      .with(mutation_subject)
-      .and_return(tests)
+      .with(subject_a)
+      .and_return([test_a, test_b])
+
+    allow(selector).to receive(:call)
+      .with(subject_b)
+      .and_return([test_b, test_c])
 
     allow(Mutant::Timer).to receive(:now).and_return(2.0, 3.0)
   end
@@ -98,7 +106,7 @@ def apply
 
         expect(isolation).to have_received(:call).ordered
         expect(mutation).to have_received(:insert).ordered.with(kernel)
-        expect(integration).to have_received(:call).ordered.with(tests)
+        expect(integration).to have_received(:call).ordered.with([test_a, test_b])
       end
 
       include_examples 'mutation kill'
@@ -128,7 +136,10 @@ def apply
     end
 
     it 'returns expected selections' do
-      expect(apply).to eql(mutation_subject => tests)
+      expect(apply).to eql(
+        subject_a => [test_a, test_b],
+        subject_b => [test_b, test_c]
+      )
     end
   end
 
@@ -154,6 +165,38 @@ def apply
     end
   end
 
+  describe '#amount_mutations' do
+    def apply
+      subject.amount_mutations
+    end
+
+    it 'returns expected value' do
+      expect(apply).to be(0)
+    end
+  end
+
+  describe '#amount_total_tests' do
+    def apply
+      subject.amount_total_tests
+    end
+
+    it 'returns expected value' do
+      expect(apply).to be(3)
+    end
+  end
+
+  describe '#test_subject_ratio' do
+    def apply
+      subject.test_subject_ratio
+    end
+
+    let(:subjects) { [subject_a, instance_double(Mutant::Subject)] }
+
+    it 'returns expected value' do
+      expect(apply).to eql(Rational(3, 2))
+    end
+  end
+
   describe '.empty' do
     def apply
       described_class.empty(world, config)