simplecov 0.15.0 → 0.17.1

data/spec/fixtures/resultset1.rb

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

data/spec/fixtures/resultset2.rb

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

data/spec/fixtures/sample.rb

@@ -1,16 +0,0 @@
-# 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

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

data/spec/fixtures/skipped_and_executed.rb

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

data/spec/fixtures/utf-8.rb

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

data/spec/helper.rb

@@ -1,26 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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/lines_classifier_spec.rb

@@ -1,103 +0,0 @@
-require "helper"
-require "simplecov/lines_classifier"
-
-describe SimpleCov::LinesClassifier do
-  describe "#classify" do
-    describe "relevant lines" do
-      it "determines code as relevant" do
-        classified_lines = subject.classify [
-          "module Foo",
-          "  class Baz",
-          "    def Bar",
-          "      puts 'hi'",
-          "    end",
-          "  end",
-          "end",
-        ]
-
-        expect(classified_lines.length).to eq 7
-        expect(classified_lines).to all be_relevant
-      end
-    end
-
-    describe "not-relevant lines" do
-      it "determines whitespace is not-relevant" do
-        classified_lines = subject.classify [
-          "",
-          "  ",
-          "\t\t",
-        ]
-
-        expect(classified_lines.length).to eq 3
-        expect(classified_lines).to all be_irrelevant
-      end
-
-      describe "comments" do
-        it "determines comments are not-relevant" do
-          classified_lines = subject.classify [
-            "#Comment",
-            " # Leading space comment",
-            "\t# Leading tab comment",
-          ]
-
-          expect(classified_lines.length).to eq 3
-          expect(classified_lines).to all be_irrelevant
-        end
-
-        it "doesn't mistake interpolation as a comment" do
-          classified_lines = subject.classify [
-            'puts "#{var}"',
-          ]
-
-          expect(classified_lines.length).to eq 1
-          expect(classified_lines).to all be_relevant
-        end
-      end
-
-      describe ":nocov: blocks" do
-        it "determines :nocov: blocks are not-relevant" do
-          classified_lines = subject.classify [
-            "# :nocov:",
-            "def hi",
-            "end",
-            "# :nocov:",
-          ]
-
-          expect(classified_lines.length).to eq 4
-          expect(classified_lines).to all be_irrelevant
-        end
-
-        it "determines all lines after a non-closing :nocov: as not-relevant" do
-          classified_lines = subject.classify [
-            "# :nocov:",
-            "puts 'Not relevant'",
-            "# :nocov:",
-            "puts 'Relevant again'",
-            "puts 'Still relevant'",
-            "# :nocov:",
-            "puts 'Not relevant till the end'",
-            "puts 'Ditto'",
-          ]
-
-          expect(classified_lines.length).to eq 8
-
-          expect(classified_lines[0..2]).to all be_irrelevant
-          expect(classified_lines[3..4]).to all be_relevant
-          expect(classified_lines[5..7]).to all be_irrelevant
-        end
-      end
-    end
-  end
-
-  RSpec::Matchers.define :be_relevant do
-    match do |actual|
-      actual == SimpleCov::LinesClassifier::RELEVANT
-    end
-  end
-
-  RSpec::Matchers.define :be_irrelevant do
-    match do |actual|
-      actual == SimpleCov::LinesClassifier::NOT_RELEVANT
-    end
-  end
-end

data/spec/multi_formatter_spec.rb

@@ -1,20 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,171 +0,0 @@
-require "helper"
-require "tempfile"
-require "timeout"
-
-if SimpleCov.usable?
-  describe SimpleCov::ResultMerger do
-    before do
-      SimpleCov::ResultMerger.clear_resultset
-      File.delete(SimpleCov::ResultMerger.resultset_path) if File.exist?(SimpleCov::ResultMerger.resultset_path)
-    end
-
-    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
-    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 be(set)
-      end
-
-      it "persists to disk" do
-        SimpleCov::ResultMerger.store_result("a" => [1])
-        SimpleCov::ResultMerger.clear_resultset
-        new_set = SimpleCov::ResultMerger.resultset
-        expect(new_set).to eq("a" => [1])
-      end
-
-      it "synchronizes writes" do
-        expect(SimpleCov::ResultMerger).to receive(:synchronize_resultset)
-        SimpleCov::ResultMerger.store_result({})
-      end
-    end
-
-    describe ".resultset" do
-      it "caches" do
-        set = SimpleCov::ResultMerger.resultset
-        new_set = SimpleCov::ResultMerger.resultset
-        expect(new_set).to be(set)
-      end
-
-      it "synchronizes reads" do
-        expect(SimpleCov::ResultMerger).to receive(:synchronize_resultset)
-        SimpleCov::ResultMerger.resultset
-      end
-    end
-
-    describe ".synchronize_resultset" do
-      it "is reentrant (i.e. doesn't block its own process)" do
-        # without @resultset_locked, this spec would fail and
-        # `.store_result` wouldn't work
-        expect do
-          Timeout.timeout(1) do
-            SimpleCov::ResultMerger.synchronize_resultset do
-              SimpleCov::ResultMerger.synchronize_resultset do
-              end
-            end
-          end
-        end.not_to raise_error
-      end
-
-      it "blocks other processes" do
-        file = Tempfile.new("foo")
-
-        other_process = open("|ruby -e " + Shellwords.escape(<<-CODE) + " 2>/dev/null")
-          require "simplecov"
-          SimpleCov.coverage_dir(#{SimpleCov.coverage_dir.inspect})
-
-          # ensure the parent process has enough time to get a
-          # lock before we do
-          sleep 0.5
-
-          $stdout.sync = true
-          puts "running" # see `sleep`s in parent process
-
-          SimpleCov::ResultMerger.synchronize_resultset do
-            File.open(#{file.path.inspect}, "a") { |f| f.write("process 2\n") }
-          end
-        CODE
-
-        SimpleCov::ResultMerger.synchronize_resultset do
-          # wait until the child process is going, and then wait some more
-          # so we can be sure it blocks on the lock we already have.
-          sleep 0.1 until other_process.gets == "running\n"
-          sleep 1
-
-          # despite the sleeps, this will be written first since we got
-          # the first lock
-          File.open(file.path, "a") { |f| f.write("process 1\n") }
-        end
-
-        # wait for it to finish
-        other_process.gets
-
-        expect(file.read).to eq("process 1\nprocess 2\n")
-      end
-    end
-  end
-end