simplecov-patched 0.14.2

data/spec/fixtures/app/controllers/sample_controller.rb

@@ -0,0 +1,10 @@
+# Foo class
+class Foo
+  def initialize
+    @foo = "baz"
+  end
+
+  def bar
+    @foo
+  end
+end

data/spec/fixtures/app/models/user.rb

@@ -0,0 +1,10 @@
+# Foo class
+class Foo
+  def initialize
+    @foo = "baz"
+  end
+
+  def bar
+    @foo
+  end
+end

data/spec/fixtures/deleted_source_sample.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", ".."))
+require "lib/simplecov"
+SimpleCov.start { command_name "Test" }
+
+dir = File.expand_path(File.dirname(__FILE__))
+file = File.join(dir, "generated_buddha.rb")
+code = %{
+  def kill_the_buddha(z)
+    z**z
+  end
+}
+File.open(file, "w") { |f| f.print code }
+load file
+File.unlink file
+raise unless kill_the_buddha(3) == 27

data/spec/fixtures/frameworks/rspec_bad.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "..", ".."))
+require "lib/simplecov"
+require "rspec"
+SimpleCov.start
+describe "exit status" do
+  it "should exit with a non-zero exit status when assertion fails" do
+    expect(1).to eq(2)
+  end
+end

data/spec/fixtures/frameworks/rspec_good.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "..", ".."))
+require "lib/simplecov"
+require "rspec"
+SimpleCov.start
+describe "exit status" do
+  it "should exit with a zero exit status when assertion fails" do
+    expect(1).to eq(1)
+  end
+end

data/spec/fixtures/frameworks/testunit_bad.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "..", ".."))
+require "lib/simplecov"
+SimpleCov.start
+require "test/unit"
+class FooTest < Test::Unit::TestCase
+  def test_foo
+    assert false
+  end
+end

data/spec/fixtures/frameworks/testunit_good.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "..", ".."))
+require "lib/simplecov"
+SimpleCov.start
+require "test/unit"
+class FooTest < Test::Unit::TestCase
+  def test_foo
+    assert true
+  end
+end

data/spec/fixtures/iso-8859.rb

@@ -0,0 +1,3 @@
+
+# localized to Espa�ol thus:
+

data/spec/fixtures/never.rb

@@ -0,0 +1,2 @@
+# This class is purely some
+# comments

data/spec/fixtures/resultset1.rb

@@ -0,0 +1,4 @@
+puts "foo"
+puts "foo"
+puts "foo"
+puts "foo"

data/spec/fixtures/resultset2.rb

@@ -0,0 +1,4 @@
+
+class Resultset
+  VERSION = 2
+end

data/spec/fixtures/sample.rb

@@ -0,0 +1,16 @@
+# Foo class
+class Foo
+  def initialize
+    @foo = "baz"
+  end
+
+  def bar
+    @foo
+  end
+
+  #:nocov:
+  def skipped
+    @foo * 2
+  end
+  #:nocov:
+end

data/spec/fixtures/skipped.rb

@@ -0,0 +1,4 @@
+# Not relevant
+# :nocov:
+# Hash.new
+# :nocov:

data/spec/fixtures/skipped_and_executed.rb

@@ -0,0 +1,8 @@
+# So much skippping
+# :nocov:
+class Foo
+  def bar
+    0
+  end
+end
+#:nocov:

data/spec/fixtures/utf-8.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+puts "135°C"

data/spec/helper.rb

@@ -0,0 +1,26 @@
+require "rspec"
+# loaded before simplecov to also capture parse time warnings
+require "support/fail_rspec_on_ruby_warning"
+require "simplecov"
+
+SimpleCov.coverage_dir("tmp/coverage")
+
+def source_fixture(filename)
+  File.expand_path(File.join(File.dirname(__FILE__), "fixtures", filename))
+end
+
+# Taken from http://stackoverflow.com/questions/4459330/how-do-i-temporarily-redirect-stderr-in-ruby
+require "stringio"
+
+def capture_stderr
+  # The output stream must be an IO-like object. In this case we capture it in
+  # an in-memory IO object so we can return the string value. You can assign any
+  # IO object here.
+  previous_stderr = $stderr
+  $stderr = StringIO.new
+  yield
+  $stderr.string
+ensure
+  # Restore the previous value of stderr (typically equal to STDERR).
+  $stderr = previous_stderr
+end

data/spec/last_run_spec.rb

@@ -0,0 +1,48 @@
+require "helper"
+
+if SimpleCov.usable?
+  describe SimpleCov::LastRun do
+    subject { SimpleCov::LastRun }
+
+    it "defines a last_run_path" do
+      expect(subject.last_run_path).to include "tmp/coverage/.last_run.json"
+    end
+
+    it "writes json to its last_run_path that can be parsed again" do
+      structure = [{"key" => "value"}]
+      subject.write(structure)
+      file_contents = File.read(subject.last_run_path)
+      expect(JSON.parse(file_contents)).to eq structure
+    end
+
+    context "reading" do
+      context "but the last_run file does not exist" do
+        before { File.delete(subject.last_run_path) if File.exist?(subject.last_run_path) }
+
+        it "returns nil" do
+          expect(subject.read).to be_nil
+        end
+      end
+
+      context "a non empty result" do
+        before { subject.write([]) }
+
+        it "reads json from its last_run_path" do
+          expect(subject.read).to eq([])
+        end
+      end
+
+      context "an empty result" do
+        before do
+          File.open(subject.last_run_path, "w+") do |f|
+            f.puts ""
+          end
+        end
+
+        it "returns nil" do
+          expect(subject.read).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/multi_formatter_spec.rb

@@ -0,0 +1,20 @@
+require "helper"
+
+require "simplecov/formatter/multi_formatter"
+
+describe SimpleCov::Formatter::MultiFormatter do
+  describe ".[]" do
+    # Regression test for https://github.com/colszowka/simplecov/issues/428
+    it "constructs a formatter with multiple children" do
+      # Silence deprecation warnings.
+      allow(described_class).to receive(:warn)
+
+      children = [
+        SimpleCov::Formatter::SimpleFormatter,
+        SimpleCov::Formatter::SimpleFormatter,
+      ]
+
+      expect(described_class[*children].new.formatters).to eq(children)
+    end
+  end
+end

data/spec/raw_coverage_spec.rb

@@ -0,0 +1,92 @@
+require "helper"
+
+if SimpleCov.usable?
+  describe SimpleCov::RawCoverage do
+    describe "with two faked coverage resultsets" do
+      before do
+        @resultset1 = {
+          source_fixture("sample.rb") => [nil, 1, 1, 1, nil, nil, 1, 1, nil, nil],
+          source_fixture("app/models/user.rb") => [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil],
+          source_fixture("app/controllers/sample_controller.rb") => [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil],
+          source_fixture("resultset1.rb") => [1, 1, 1, 1],
+          source_fixture("parallel_tests.rb") => [nil, 0, nil, 0],
+          source_fixture("conditionally_loaded_1.rb") => [nil, 0, 1],  # loaded only in the first resultset
+          source_fixture("three.rb") => [nil, 1, 1],
+        }
+
+        @resultset2 = {
+          source_fixture("sample.rb") => [1, nil, 1, 1, nil, nil, 1, 1, nil, nil],
+          source_fixture("app/models/user.rb") => [nil, 1, 5, 1, nil, nil, 1, 0, nil, nil],
+          source_fixture("app/controllers/sample_controller.rb") => [nil, 3, 1, nil, nil, nil, 1, 0, nil, nil],
+          source_fixture("resultset2.rb") => [nil, 1, 1, nil],
+          source_fixture("parallel_tests.rb") => [nil, nil, 0, 0],
+          source_fixture("conditionally_loaded_2.rb") => [nil, 0, 1],  # loaded only in the second resultset
+          source_fixture("three.rb") => [nil, 1, 4],
+        }
+
+        @resultset3 = {
+          source_fixture("three.rb") => [nil, 1, 2],
+        }
+      end
+
+      context "a merge" do
+        subject do
+          SimpleCov::RawCoverage.merge_results(@resultset1, @resultset2, @resultset3)
+        end
+
+        it "has proper results for sample.rb" do
+          expect(subject[source_fixture("sample.rb")]).to eq([1, 1, 2, 2, nil, nil, 2, 2, nil, nil])
+        end
+
+        it "has proper results for user.rb" do
+          expect(subject[source_fixture("app/models/user.rb")]).to eq([nil, 2, 6, 2, nil, nil, 2, 0, nil, nil])
+        end
+
+        it "has proper results for sample_controller.rb" do
+          expect(subject[source_fixture("app/controllers/sample_controller.rb")]).to eq([nil, 4, 2, 1, nil, nil, 2, 0, nil, nil])
+        end
+
+        it "has proper results for resultset1.rb" do
+          expect(subject[source_fixture("resultset1.rb")]).to eq([1, 1, 1, 1])
+        end
+
+        it "has proper results for resultset2.rb" do
+          expect(subject[source_fixture("resultset2.rb")]).to eq([nil, 1, 1, nil])
+        end
+
+        it "has proper results for parallel_tests.rb" do
+          expect(subject[source_fixture("parallel_tests.rb")]).to eq([nil, nil, nil, 0])
+        end
+
+        it "has proper results for conditionally_loaded_1.rb" do
+          expect(subject[source_fixture("conditionally_loaded_1.rb")]).to eq([nil, 0, 1])
+        end
+
+        it "has proper results for conditionally_loaded_2.rb" do
+          expect(subject[source_fixture("conditionally_loaded_2.rb")]).to eq([nil, 0, 1])
+        end
+
+        it "has proper results for three.rb" do
+          expect(subject[source_fixture("three.rb")]).to eq([nil, 3, 7])
+        end
+      end
+    end
+
+    it "merges frozen resultsets" do
+      resultset1 = {
+        source_fixture("sample.rb").freeze => [nil, 1, 1, 1, nil, nil, 1, 1, nil, nil].freeze,
+        source_fixture("app/models/user.rb").freeze => [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil].freeze,
+      }.freeze
+
+      resultset2 = {
+        source_fixture("sample.rb").freeze => [1, nil, 1, 1, nil, nil, 1, 1, nil, nil].freeze,
+      }.freeze
+
+      merged_result = SimpleCov::RawCoverage.merge_results(resultset1, resultset2)
+      expect(merged_result.keys).to eq(resultset1.keys)
+      expect(merged_result.values.map(&:frozen?)).to eq([false, false])
+      expect(merged_result[source_fixture("sample.rb")]).to eq([1, 1, 2, 2, nil, nil, 2, 2, nil, nil])
+      expect(merged_result[source_fixture("app/models/user.rb")]).to eq([nil, 1, 1, 1, nil, nil, 1, 0, nil, nil])
+    end
+  end
+end

data/spec/result_merger_spec.rb

@@ -0,0 +1,96 @@
+require "helper"
+
+if SimpleCov.usable?
+  describe SimpleCov::ResultMerger do
+    describe "with two faked coverage resultsets" do
+      before do
+        @resultset1 = {
+          source_fixture("sample.rb") => [nil, 1, 1, 1, nil, nil, 1, 1, nil, nil],
+          source_fixture("app/models/user.rb") => [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil],
+          source_fixture("app/controllers/sample_controller.rb") => [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil],
+          source_fixture("resultset1.rb") => [1, 1, 1, 1],
+          source_fixture("parallel_tests.rb") => [nil, 0, nil, 0],
+          source_fixture("conditionally_loaded_1.rb") => [nil, 0, 1],  # loaded only in the first resultset
+        }
+
+        @resultset2 = {
+          source_fixture("sample.rb") => [1, nil, 1, 1, nil, nil, 1, 1, nil, nil],
+          source_fixture("app/models/user.rb") => [nil, 1, 5, 1, nil, nil, 1, 0, nil, nil],
+          source_fixture("app/controllers/sample_controller.rb") => [nil, 3, 1, nil, nil, nil, 1, 0, nil, nil],
+          source_fixture("resultset2.rb") => [nil, 1, 1, nil],
+          source_fixture("parallel_tests.rb") => [nil, nil, 0, 0],
+          source_fixture("conditionally_loaded_2.rb") => [nil, 0, 1],  # loaded only in the second resultset
+        }
+      end
+
+      # See Github issue #6
+      it "returns an empty hash when the resultset cache file is empty" do
+        File.open(SimpleCov::ResultMerger.resultset_path, "w+") { |f| f.puts "" }
+        expect(SimpleCov::ResultMerger.resultset).to be_empty
+      end
+
+      # See Github issue #6
+      it "returns an empty hash when the resultset cache file is not present" do
+        system "rm #{SimpleCov::ResultMerger.resultset_path}" if File.exist?(SimpleCov::ResultMerger.resultset_path)
+        expect(SimpleCov::ResultMerger.resultset).to be_empty
+      end
+
+      context "and results generated from those" do
+        before do
+          system "rm #{SimpleCov::ResultMerger.resultset_path}" if File.exist?(SimpleCov::ResultMerger.resultset_path)
+          @result1 = SimpleCov::Result.new(@resultset1)
+          @result1.command_name = "result1"
+          @result2 = SimpleCov::Result.new(@resultset2)
+          @result2.command_name = "result2"
+        end
+
+        context "with stored results" do
+          before do
+            SimpleCov::ResultMerger.store_result(@result1)
+            SimpleCov::ResultMerger.store_result(@result2)
+          end
+
+          it "has stored data in resultset_path JSON file" do
+            expect(File.readlines(SimpleCov::ResultMerger.resultset_path).length).to be > 50
+          end
+
+          it "returns a hash containing keys ['result1' and 'result2'] for resultset" do
+            expect(SimpleCov::ResultMerger.resultset.keys.sort).to eq %w[result1 result2]
+          end
+
+          it "returns proper values for merged_result" do
+            expect(SimpleCov::ResultMerger.merged_result.source_files.find { |s| s.filename =~ /user/ }.lines.map(&:coverage)).to eq([nil, 2, 6, 2, nil, nil, 2, 0, nil, nil])
+          end
+
+          context "with second result way above the merge_timeout" do
+            before do
+              @result2.created_at = Time.now - 172_800 # two days ago
+              SimpleCov::ResultMerger.store_result(@result2)
+            end
+
+            it "has only one result in SimpleCov::ResultMerger.results" do
+              expect(SimpleCov::ResultMerger.results.length).to eq(1)
+            end
+          end
+        end
+      end
+
+      describe ".store_result" do
+        it "refreshes the resultset" do
+          set = SimpleCov::ResultMerger.resultset
+          SimpleCov::ResultMerger.store_result({})
+          new_set = SimpleCov::ResultMerger.resultset
+          expect(new_set).not_to equal(set)
+        end
+      end
+
+      describe ".resultset" do
+        it "caches by default" do
+          set = SimpleCov::ResultMerger.resultset
+          new_set = SimpleCov::ResultMerger.resultset
+          expect(new_set).to equal(set)
+        end
+      end
+    end
+  end
+end

data/spec/result_spec.rb

@@ -0,0 +1,209 @@
+require "helper"
+
+if SimpleCov.usable?
+  describe "result" do
+    context "with a (mocked) Coverage.result" do
+      before do
+        @prev_filters = SimpleCov.filters
+        SimpleCov.filters = []
+        @prev_groups = SimpleCov.groups
+        SimpleCov.groups = {}
+        @prev_formatter = SimpleCov.formatter
+        SimpleCov.formatter = nil
+      end
+
+      after do
+        SimpleCov.filters   = @prev_filters
+        SimpleCov.groups    = @prev_groups
+        SimpleCov.formatter = @prev_formatter
+      end
+
+      let(:original_result) do
+        {
+          source_fixture("sample.rb") => [nil, 1, 1, 1, nil, nil, 1, 1, nil, nil],
+          source_fixture("app/models/user.rb") => [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil],
+          source_fixture("app/controllers/sample_controller.rb") => [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil],
+        }
+      end
+
+      context "a simple cov result initialized from that" do
+        subject { SimpleCov::Result.new(original_result) }
+
+        it "has 3 filenames" do
+          expect(subject.filenames.count).to eq(3)
+        end
+
+        it "has 3 source files" do
+          expect(subject.source_files.count).to eq(3)
+          subject.source_files.each do |source_file|
+            expect(source_file).to be_a SimpleCov::SourceFile
+          end
+        end
+
+        it "returns an instance of SimpleCov::FileList for source_files and files" do
+          expect(subject.files).to be_a SimpleCov::FileList
+          expect(subject.source_files).to be_a SimpleCov::FileList
+        end
+
+        it "has files equal to source_files" do
+          expect(subject.files).to eq(subject.source_files)
+        end
+
+        it "has accurate covered percent" do
+          # in our fixture, there are 13 covered line (result in 1) in all 15 relevant line (result in non-nil)
+          expect(subject.covered_percent).to eq(86.66666666666667)
+        end
+
+        it "has accurate covered percentages" do
+          expect(subject.covered_percentages).to eq([80.0, 80.0, 100.0])
+        end
+
+        it "has accurate least covered file" do
+          expect(subject.least_covered_file).to match(/sample_controller.rb/)
+        end
+
+        [:covered_percent, :covered_percentages, :least_covered_file, :covered_strength, :covered_lines, :missed_lines, :total_lines].each do |msg|
+          it "responds to #{msg}" do
+            expect(subject).to respond_to(msg)
+          end
+        end
+
+        context "dumped with to_hash" do
+          it "is a hash" do
+            expect(subject.to_hash).to be_a Hash
+          end
+
+          context "loaded back with from_hash" do
+            let(:dumped_result) do
+              SimpleCov::Result.from_hash(subject.to_hash)
+            end
+
+            it "has 3 source files" do
+              expect(dumped_result.source_files.count).to eq(subject.source_files.count)
+            end
+
+            it "has the same covered_percent" do
+              expect(dumped_result.covered_percent).to eq(subject.covered_percent)
+            end
+
+            it "has the same covered_percentages" do
+              expect(dumped_result.covered_percentages).to eq(subject.covered_percentages)
+            end
+
+            it "has the same timestamp" do
+              expect(dumped_result.created_at.to_i).to eq(subject.created_at.to_i)
+            end
+
+            it "has the same command_name" do
+              expect(dumped_result.command_name).to eq(subject.command_name)
+            end
+
+            it "has the same original_result" do
+              expect(dumped_result.original_result).to eq(subject.original_result)
+            end
+          end
+        end
+      end
+
+      context "with some filters set up" do
+        before do
+          SimpleCov.add_filter "sample.rb"
+        end
+
+        it "has 2 files in a new simple cov result" do
+          expect(SimpleCov::Result.new(original_result).source_files.length).to eq(2)
+        end
+
+        it "has 80 covered percent" do
+          expect(SimpleCov::Result.new(original_result).covered_percent).to eq(80)
+        end
+
+        it "has [80.0, 80.0] covered percentages" do
+          expect(SimpleCov::Result.new(original_result).covered_percentages).to eq([80.0, 80.0])
+        end
+      end
+
+      context "with groups set up for all files" do
+        before do
+          SimpleCov.add_group "Models", "app/models"
+          SimpleCov.add_group "Controllers", ["app/controllers"]
+          SimpleCov.add_group "Other" do |src_file|
+            File.basename(src_file.filename) == "sample.rb"
+          end
+        end
+
+        subject do
+          SimpleCov::Result.new(original_result)
+        end
+
+        it "has 3 groups" do
+          expect(subject.groups.length).to eq(3)
+        end
+
+        it "has user.rb in 'Models' group" do
+          expect(File.basename(subject.groups["Models"].first.filename)).to eq("user.rb")
+        end
+
+        it "has sample_controller.rb in 'Controllers' group" do
+          expect(File.basename(subject.groups["Controllers"].first.filename)).to eq("sample_controller.rb")
+        end
+
+        context "and simple formatter being used" do
+          before do
+            SimpleCov.formatter = SimpleCov::Formatter::SimpleFormatter
+          end
+
+          it "returns a formatted string with result.format!" do
+            expect(subject.format!).to be_a String
+          end
+        end
+
+        context "and multi formatter being used" do
+          before do
+            SimpleCov.formatters = [
+              SimpleCov::Formatter::SimpleFormatter,
+              SimpleCov::Formatter::SimpleFormatter,
+            ]
+          end
+
+          it "returns an array containing formatted string with result.format!" do
+            formatted = subject.format!
+            expect(formatted.count).to eq(2)
+            expect(formatted.first).to be_a String
+          end
+        end
+      end
+
+      context "with groups set up that do not match all files" do
+        before do
+          SimpleCov.configure do
+            add_group "Models", "app/models"
+            add_group "Controllers", "app/controllers"
+          end
+        end
+
+        subject { SimpleCov::Result.new(original_result) }
+
+        it "has 3 groups" do
+          expect(subject.groups.length).to eq(3)
+        end
+
+        it "has 1 item per group" do
+          subject.groups.each_value do |files|
+            expect(files.length).to eq(1)
+          end
+        end
+
+        it 'has sample.rb in "Ungrouped" group' do
+          expect(File.basename(subject.groups["Ungrouped"].first.filename)).to eq("sample.rb")
+        end
+
+        it "returns all groups as instances of SimpleCov::FileList" do
+          subject.groups.each_value do |files|
+            expect(files).to be_a SimpleCov::FileList
+          end
+        end
+      end
+    end
+  end
+end