simplecov 0.10.0 → 0.11.0

data/spec/merge_helpers_spec.rb

@@ -0,0 +1,108 @@
+require "helper"
+
+describe "merge helpers" do
+  describe "with two faked coverage resultsets" do
+    before do
+      SimpleCov.use_merging true
+      @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],
+      }
+
+      @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],
+      }
+    end
+
+    context "a merge" do
+      subject do
+        @resultset1.merge_resultset(@resultset2)
+      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
+    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
+
+        context "with merging disabled" do
+          before { SimpleCov.use_merging false }
+
+          it "returns nil for SimpleCov.result" do
+            expect(SimpleCov.result).to be_nil
+          end
+        end
+      end
+    end
+  end
+end if SimpleCov.usable?

data/spec/result_spec.rb

@@ -0,0 +1,207 @@
+require "helper"
+
+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 if SimpleCov.usable?

data/spec/return_codes_spec.rb

@@ -0,0 +1,37 @@
+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
+    before do
+      @current_dir = Dir.getwd
+      Dir.chdir(File.join(File.dirname(__FILE__), "fixtures", "frameworks"))
+      FileUtils.rm_rf("./coverage")
+    end
+
+    after do
+      Dir.chdir(@current_dir)
+    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/source_file_line_spec.rb

@@ -0,0 +1,153 @@
+require "helper"
+
+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 if SimpleCov.usable?