simplecov-patched 0.14.2

data/spec/return_codes_spec.rb

@@ -0,0 +1,34 @@
+require "helper"
+
+# Make sure that exit codes of tests are propagated properly
+# See https://github.com/colszowka/simplecov/issues/5
+describe "return codes" do
+  context "inside fixtures/frameworks" do
+    around do |test|
+      Dir.chdir(File.join(File.dirname(__FILE__), "fixtures", "frameworks")) do
+        FileUtils.rm_rf("./coverage")
+        test.call
+      end
+    end
+
+    it "has return code 0 when running testunit_good.rb" do
+      `ruby testunit_good.rb`
+      expect($?.exitstatus).to be_zero
+    end
+
+    it "has return code 0 when running rspec_good.rb" do
+      `rspec rspec_good.rb`
+      expect($?.exitstatus).to be_zero
+    end
+
+    it "has non-0 return code when running testunit_bad.rb" do
+      `ruby testunit_bad.rb`
+      expect($?.exitstatus).not_to be_zero
+    end
+
+    it "has return code 1 when running rspec_bad.rb" do
+      `rspec rspec_bad.rb`
+      expect($?.exitstatus).not_to be_zero
+    end
+  end
+end

data/spec/simplecov_spec.rb

@@ -0,0 +1,110 @@
+require "helper"
+
+if SimpleCov.usable?
+  describe SimpleCov do
+    describe ".result" do
+      before do
+        SimpleCov.clear_result!
+        allow(Coverage).to receive(:result).once.and_return({})
+        allow(SimpleCov).to receive(:add_not_loaded_files).once.and_return({})
+      end
+
+      context "with merging disabled" do
+        before do
+          allow(SimpleCov).to receive(:use_merging).once.and_return(false)
+        end
+
+        context "when not running" do
+          before do
+            allow(SimpleCov).to receive(:running).and_return(false)
+          end
+
+          it "returns nil" do
+            expect(SimpleCov.result).to be_nil
+          end
+        end
+
+        context "when running" do
+          before do
+            allow(SimpleCov).to receive(:running).and_return(true, false)
+          end
+
+          it "uses the result from Coverage" do
+            expect(Coverage).to receive(:result).once.and_return({})
+            SimpleCov.result
+          end
+
+          it "adds not-loaded-files" do
+            expect(SimpleCov).to receive(:add_not_loaded_files).once.and_return({})
+            SimpleCov.result
+          end
+
+          it "doesn't store the current coverage" do
+            expect(SimpleCov::ResultMerger).to receive(:store_result).never
+            SimpleCov.result
+          end
+
+          it "doesn't merge the result" do
+            expect(SimpleCov::ResultMerger).to receive(:merged_result).never
+            SimpleCov.result
+          end
+
+          it "caches its result" do
+            result = SimpleCov.result
+            expect(SimpleCov.result).to equal(result)
+          end
+        end
+      end
+
+      context "with merging enabled" do
+        let(:the_merged_result) { double }
+
+        before do
+          allow(SimpleCov).to receive(:use_merging).once.and_return(true)
+          allow(SimpleCov::ResultMerger).to receive(:store_result).once
+          allow(SimpleCov::ResultMerger).to receive(:merged_result).once.and_return(the_merged_result)
+        end
+
+        context "when not running" do
+          before do
+            allow(SimpleCov).to receive(:running).and_return(false)
+          end
+
+          it "merges the result" do
+            expect(SimpleCov.result).to equal(the_merged_result)
+          end
+        end
+
+        context "when running" do
+          before do
+            allow(SimpleCov).to receive(:running).and_return(true, false)
+          end
+
+          it "uses the result from Coverage" do
+            expect(Coverage).to receive(:result).once.and_return({})
+            SimpleCov.result
+          end
+
+          it "adds not-loaded-files" do
+            expect(SimpleCov).to receive(:add_not_loaded_files).once.and_return({})
+            SimpleCov.result
+          end
+
+          it "stores the current coverage" do
+            expect(SimpleCov::ResultMerger).to receive(:store_result).once
+            SimpleCov.result
+          end
+
+          it "merges the result" do
+            expect(SimpleCov.result).to equal(the_merged_result)
+          end
+
+          it "caches its result" do
+            result = SimpleCov.result
+            expect(SimpleCov.result).to equal(result)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/source_file_line_spec.rb

@@ -0,0 +1,155 @@
+require "helper"
+
+if SimpleCov.usable?
+  describe SimpleCov::SourceFile::Line do
+    context "a source line" do
+      subject do
+        SimpleCov::SourceFile::Line.new("# the ruby source", 5, 3)
+      end
+
+      it 'returns "# the ruby source" as src' do
+        expect(subject.src).to eq("# the ruby source")
+      end
+
+      it "returns the same for source as for src" do
+        expect(subject.src).to eq(subject.source)
+      end
+
+      it "has line number 5" do
+        expect(subject.line_number).to eq(5)
+      end
+
+      it "has equal line_number, line and number" do
+        expect(subject.line).to eq(subject.line_number)
+        expect(subject.number).to eq(subject.line_number)
+      end
+
+      context "flagged as skipped!" do
+        before do
+          subject.skipped!
+        end
+        it "is not covered" do
+          expect(subject).not_to be_covered
+        end
+
+        it "is skipped" do
+          expect(subject).to be_skipped
+        end
+
+        it "is not missed" do
+          expect(subject).not_to be_missed
+        end
+
+        it "is not never" do
+          expect(subject).not_to be_never
+        end
+
+        it "status is skipped" do
+          expect(subject.status).to eq("skipped")
+        end
+      end
+    end
+
+    context "A source line with coverage" do
+      subject do
+        SimpleCov::SourceFile::Line.new("# the ruby source", 5, 3)
+      end
+
+      it "has coverage of 3" do
+        expect(subject.coverage).to eq(3)
+      end
+
+      it "is covered" do
+        expect(subject).to be_covered
+      end
+
+      it "is not skipped" do
+        expect(subject).not_to be_skipped
+      end
+
+      it "is not missed" do
+        expect(subject).not_to be_missed
+      end
+
+      it "is not never" do
+        expect(subject).not_to be_never
+      end
+
+      it "status is covered" do
+        expect(subject.status).to eq("covered")
+      end
+    end
+
+    context "A source line without coverage" do
+      subject do
+        SimpleCov::SourceFile::Line.new("# the ruby source", 5, 0)
+      end
+
+      it "has coverage of 0" do
+        expect(subject.coverage).to be_zero
+      end
+
+      it "is not covered" do
+        expect(subject).not_to be_covered
+      end
+
+      it "is not skipped" do
+        expect(subject).not_to be_skipped
+      end
+
+      it "is missed" do
+        expect(subject).to be_missed
+      end
+
+      it "is not never" do
+        expect(subject).not_to be_never
+      end
+
+      it "status is missed" do
+        expect(subject.status).to eq("missed")
+      end
+    end
+
+    context "A source line with no code" do
+      subject do
+        SimpleCov::SourceFile::Line.new("# the ruby source", 5, nil)
+      end
+
+      it "has nil coverage" do
+        expect(subject.coverage).to be_nil
+      end
+
+      it "is not covered" do
+        expect(subject).not_to be_covered
+      end
+
+      it "is not skipped" do
+        expect(subject).not_to be_skipped
+      end
+
+      it "is not missed" do
+        expect(subject).not_to be_missed
+      end
+
+      it "is never" do
+        expect(subject).to be_never
+      end
+
+      it "status is never" do
+        expect(subject.status).to eq("never")
+      end
+    end
+
+    it "raises ArgumentError when initialized with invalid src" do
+      expect { SimpleCov::SourceFile::Line.new(:symbol, 5, 3) }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError when initialized with invalid line_number" do
+      expect { SimpleCov::SourceFile::Line.new("some source", "five", 3) }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError when initialized with invalid coverage" do
+      expect { SimpleCov::SourceFile::Line.new("some source", 5, "three") }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/source_file_spec.rb

@@ -0,0 +1,141 @@
+require "helper"
+
+if SimpleCov.usable?
+  describe SimpleCov::SourceFile do
+    COVERAGE_FOR_SAMPLE_RB = [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil, nil, nil, nil, nil, nil, nil].freeze
+    context "a source file initialized with some coverage data" do
+      subject do
+        SimpleCov::SourceFile.new(source_fixture("sample.rb"), COVERAGE_FOR_SAMPLE_RB)
+      end
+
+      it "has a filename" do
+        expect(subject.filename).not_to be_nil
+      end
+
+      it "has source equal to src" do
+        expect(subject.src).to eq(subject.source)
+      end
+
+      it "has source_lines equal to lines" do
+        expect(subject.lines).to eq(subject.source_lines)
+      end
+
+      it "has 16 source lines" do
+        expect(subject.lines.count).to eq(16)
+      end
+
+      it "has all source lines of type SimpleCov::SourceFile::Line" do
+        subject.lines.each do |line|
+          expect(line).to be_a SimpleCov::SourceFile::Line
+        end
+      end
+
+      it "has 'class Foo' as line(2).source" do
+        expect(subject.line(2).source).to eq("class Foo\n")
+      end
+
+      it "returns lines number 2, 3, 4, 7 for covered_lines" do
+        expect(subject.covered_lines.map(&:line)).to eq([2, 3, 4, 7])
+      end
+
+      it "returns lines number 8 for missed_lines" do
+        expect(subject.missed_lines.map(&:line)).to eq([8])
+      end
+
+      it "returns lines number 1, 5, 6, 9, 10, 16 for never_lines" do
+        expect(subject.never_lines.map(&:line)).to eq([1, 5, 6, 9, 10, 16])
+      end
+
+      it "returns line numbers 11, 12, 13, 14, 15 for skipped_lines" do
+        expect(subject.skipped_lines.map(&:line)).to eq([11, 12, 13, 14, 15])
+      end
+
+      it "has 80% covered_percent" do
+        expect(subject.covered_percent).to eq(80.0)
+      end
+    end
+
+    context "simulating potential Ruby 1.9 defect -- see Issue #56" do
+      subject do
+        SimpleCov::SourceFile.new(source_fixture("sample.rb"), COVERAGE_FOR_SAMPLE_RB + [nil])
+      end
+
+      it "has 16 source lines regardless of extra data in coverage array" do
+        # Do not litter test output with known warning
+        capture_stderr { expect(subject.lines.count).to eq(16) }
+      end
+
+      it "prints a warning to stderr if coverage array contains more data than lines in the file" do
+        captured_output = capture_stderr do
+          subject.lines
+        end
+
+        expect(captured_output).to match(/^Warning: coverage data provided/)
+      end
+    end
+
+    context "a file that is never relevant" do
+      COVERAGE_FOR_NEVER_RB = [nil, nil].freeze
+
+      subject do
+        SimpleCov::SourceFile.new(source_fixture("never.rb"), COVERAGE_FOR_NEVER_RB)
+      end
+
+      it "has 0.0 covered_strength" do
+        expect(subject.covered_strength).to eq 0.0
+      end
+
+      it "has 0.0 covered_percent" do
+        expect(subject.covered_percent).to eq 100.0
+      end
+    end
+
+    context "a file where nothing is ever executed mixed with skipping #563" do
+      COVERAGE_FOR_SKIPPED_RB = [nil, nil, nil, nil].freeze
+
+      subject do
+        SimpleCov::SourceFile.new(source_fixture("skipped.rb"), COVERAGE_FOR_SKIPPED_RB)
+      end
+
+      it "has 0.0 covered_strength" do
+        expect(subject.covered_strength).to eq 0.0
+      end
+
+      it "has 0.0 covered_percent" do
+        expect(subject.covered_percent).to eq 0.0
+      end
+    end
+
+    context "a file where everything is skipped and missed #563" do
+      COVERAGE_FOR_SKIPPED_RB_2 = [nil, nil, 0, nil].freeze
+
+      subject do
+        SimpleCov::SourceFile.new(source_fixture("skipped.rb"), COVERAGE_FOR_SKIPPED_RB_2)
+      end
+
+      it "has 0.0 covered_strength" do
+        expect(subject.covered_strength).to eq 0.0
+      end
+
+      it "has 0.0 covered_percent" do
+        expect(subject.covered_percent).to eq 0.0
+      end
+    end
+
+    context "a file where everything is skipped/irrelevamt but executed #563" do
+      COVERAGE_FOR_SKIPPED_AND_EXECUTED_RB = [nil, nil, 1, 1, 0, nil, nil, nil].freeze
+
+      subject do
+        SimpleCov::SourceFile.new(source_fixture("skipped_and_executed.rb"), COVERAGE_FOR_SKIPPED_AND_EXECUTED_RB)
+      end
+
+      it "has 0.0 covered_strength" do
+        expect(subject.covered_strength).to eq 0.0
+      end
+
+      it "has 0.0 covered_percent" do
+        expect(subject.covered_percent).to eq 0.0
+      end
+    end
+  end
+end

data/spec/support/fail_rspec_on_ruby_warning.rb

@@ -0,0 +1,75 @@
+# Borrowed and heavily adjusted from:
+# https://github.com/metricfu/metric_fu/blob/master/spec/capture_warnings.rb
+require "fileutils"
+
+class FailOnWarnings
+  def initialize
+    @stderr_stream = StringIO.new
+    @app_root = Dir.pwd
+  end
+
+  def collect_warnings
+    $stderr = @stderr_stream
+    $VERBOSE = true
+  end
+
+  def process_warnings
+    lines = close_stream
+    app_warnings, other_warnings = split_lines(lines)
+
+    print_own_warnings(app_warnings) if app_warnings.any?
+    write_other_warnings_to_tmp(other_warnings) if other_warnings.any?
+    fail_script(app_warnings) if app_warnings.any?
+  end
+
+private
+
+  def close_stream
+    $stderr = STDERR
+
+    @stderr_stream.rewind
+    lines = @stderr_stream.read.split("\n")
+    lines.uniq!
+    @stderr_stream.close
+    lines
+  end
+
+  def split_lines(lines)
+    lines.partition { |line| line.include?(@app_root) }
+  end
+
+  def print_own_warnings(app_warnings)
+    puts ""
+    puts ""
+    puts <<-WARNINGS
+#{'-' * 30} app warnings: #{'-' * 30}
+    #{app_warnings.join("\n")}
+    #{'-' * 75}
+    WARNINGS
+  end
+
+  def write_other_warnings_to_tmp(other_warnings)
+    output_dir = File.join(@app_root, "tmp")
+    FileUtils.mkdir_p(output_dir)
+    output_file = File.join(output_dir, "warnings.txt")
+    File.open(output_file, "w") do |file|
+      file.write(other_warnings.join("\n") << "\n")
+    end
+    puts
+    puts "Non-app warnings written to tmp/warnings.txt"
+    puts
+  end
+
+  def fail_script(app_warnings)
+    abort "Failing build due to app warnings: #{app_warnings.inspect}"
+  end
+end
+
+warning_collector = FailOnWarnings.new
+warning_collector.collect_warnings
+
+RSpec.configure do |config|
+  config.after(:suite) do
+    warning_collector.process_warnings
+  end
+end