simplecov 0.11.2 → 0.13.0

data/spec/file_list_spec.rb

@@ -1,48 +1,50 @@
 require "helper"
 
-describe SimpleCov::Result do
-  subject do
-    original_result = {
-      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, 2, 2, 0, nil, nil, 0, nil, nil, nil],
-    }
-    SimpleCov::Result.new(original_result).files
-  end
-
-  it "has 11 covered lines" do
-    expect(subject.covered_lines).to eq(11)
-  end
-
-  it "has 3 missed lines" do
-    expect(subject.missed_lines).to eq(3)
-  end
-
-  it "has 19 never lines" do
-    expect(subject.never_lines).to eq(19)
-  end
-
-  it "has 14 lines of code" do
-    expect(subject.lines_of_code).to eq(14)
-  end
-
-  it "has 3 skipped lines" do
-    expect(subject.skipped_lines).to eq(3)
-  end
-
-  it "has the correct covered percent" do
-    expect(subject.covered_percent).to eq(78.57142857142857)
-  end
-
-  it "has the correct covered percentages" do
-    expect(subject.covered_percentages).to eq([50.0, 80.0, 100.0])
-  end
-
-  it "has the correct least covered file" do
-    expect(subject.least_covered_file).to match(/sample_controller.rb/)
-  end
-
-  it "has the correct covered strength" do
-    expect(subject.covered_strength).to eq(0.9285714285714286)
-  end
-end if SimpleCov.usable?
+if SimpleCov.usable?
+  describe SimpleCov::Result do
+    subject do
+      original_result = {
+        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, 2, 2, 0, nil, nil, 0, nil, nil, nil],
+      }
+      SimpleCov::Result.new(original_result).files
+    end
+
+    it "has 11 covered lines" do
+      expect(subject.covered_lines).to eq(11)
+    end
+
+    it "has 3 missed lines" do
+      expect(subject.missed_lines).to eq(3)
+    end
+
+    it "has 19 never lines" do
+      expect(subject.never_lines).to eq(19)
+    end
+
+    it "has 14 lines of code" do
+      expect(subject.lines_of_code).to eq(14)
+    end
+
+    it "has 3 skipped lines" do
+      expect(subject.skipped_lines).to eq(3)
+    end
+
+    it "has the correct covered percent" do
+      expect(subject.covered_percent).to eq(78.57142857142857)
+    end
+
+    it "has the correct covered percentages" do
+      expect(subject.covered_percentages).to eq([50.0, 80.0, 100.0])
+    end
+
+    it "has the correct least covered file" do
+      expect(subject.least_covered_file).to match(/sample_controller.rb/)
+    end
+
+    it "has the correct covered strength" do
+      expect(subject.covered_strength).to eq(0.9285714285714286)
+    end
+  end
+end

data/spec/filters_spec.rb

@@ -1,96 +1,98 @@
 require "helper"
 
-describe SimpleCov::SourceFile do
-  subject do
-    SimpleCov::SourceFile.new(source_fixture("sample.rb"), [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil])
-  end
-
-  it "doesn't match a new SimpleCov::StringFilter 'foobar'" do
-    expect(SimpleCov::StringFilter.new("foobar")).not_to be_matches subject
-  end
-
-  it "doesn't match a new SimpleCov::StringFilter 'some/path'" do
-    expect(SimpleCov::StringFilter.new("some/path")).not_to be_matches subject
-  end
-
-  it "matches a new SimpleCov::StringFilter 'spec/fixtures'" do
-    expect(SimpleCov::StringFilter.new("spec/fixtures")).to be_matches subject
-  end
-
-  it "matches a new SimpleCov::StringFilter 'spec/fixtures/sample.rb'" do
-    expect(SimpleCov::StringFilter.new("spec/fixtures/sample.rb")).to be_matches subject
-  end
-
-  it "matches a new SimpleCov::StringFilter 'sample.rb'" do
-    expect(SimpleCov::StringFilter.new("sample.rb")).to be_matches subject
-  end
-
-  it "doesn't match a new SimpleCov::BlockFilter that is not applicable" do
-    expect(SimpleCov::BlockFilter.new(proc { |s| File.basename(s.filename) == "foo.rb" })).not_to be_matches subject
-  end
+if SimpleCov.usable?
+  describe SimpleCov::SourceFile do
+    subject do
+      SimpleCov::SourceFile.new(source_fixture("sample.rb"), [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil])
+    end
 
-  it "matches a new SimpleCov::BlockFilter that is applicable" do
-    expect(SimpleCov::BlockFilter.new(proc { |s| File.basename(s.filename) == "sample.rb" })).to be_matches subject
-  end
+    it "doesn't match a new SimpleCov::StringFilter 'foobar'" do
+      expect(SimpleCov::StringFilter.new("foobar")).not_to be_matches subject
+    end
 
-  it "matches a new SimpleCov::ArrayFilter when 'sample.rb' is passed as array" do
-    expect(SimpleCov::ArrayFilter.new(["sample.rb"])).to be_matches subject
-  end
+    it "doesn't match a new SimpleCov::StringFilter 'some/path'" do
+      expect(SimpleCov::StringFilter.new("some/path")).not_to be_matches subject
+    end
 
-  it "doesn't match a new SimpleCov::ArrayFilter when a file path different than 'sample.rb' is passed as array" do
-    expect(SimpleCov::ArrayFilter.new(["other_file.rb"])).not_to be_matches subject
-  end
+    it "matches a new SimpleCov::StringFilter 'spec/fixtures'" do
+      expect(SimpleCov::StringFilter.new("spec/fixtures")).to be_matches subject
+    end
 
-  it "matches a new SimpleCov::ArrayFilter when two file paths including 'sample.rb' are passed as array" do
-    expect(SimpleCov::ArrayFilter.new(["sample.rb", "other_file.rb"])).to be_matches subject
-  end
+    it "matches a new SimpleCov::StringFilter 'spec/fixtures/sample.rb'" do
+      expect(SimpleCov::StringFilter.new("spec/fixtures/sample.rb")).to be_matches subject
+    end
 
-  context "with no filters set up and a basic source file in an array" do
-    before do
-      @prev_filters = SimpleCov.filters
-      SimpleCov.filters = []
+    it "matches a new SimpleCov::StringFilter 'sample.rb'" do
+      expect(SimpleCov::StringFilter.new("sample.rb")).to be_matches subject
     end
 
-    subject do
-      [SimpleCov::SourceFile.new(source_fixture("sample.rb"), [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil])]
+    it "doesn't match a new SimpleCov::BlockFilter that is not applicable" do
+      expect(SimpleCov::BlockFilter.new(proc { |s| File.basename(s.filename) == "foo.rb" })).not_to be_matches subject
     end
 
-    after do
-      SimpleCov.filters = @prev_filters
+    it "matches a new SimpleCov::BlockFilter that is applicable" do
+      expect(SimpleCov::BlockFilter.new(proc { |s| File.basename(s.filename) == "sample.rb" })).to be_matches subject
     end
 
-    it 'returns 0 items after executing SimpleCov.filtered on files when using a "sample" string filter' do
-      SimpleCov.add_filter "sample"
-      expect(SimpleCov.filtered(subject).count).to be_zero
+    it "matches a new SimpleCov::ArrayFilter when 'sample.rb' is passed as array" do
+      expect(SimpleCov::ArrayFilter.new(["sample.rb"])).to be_matches subject
     end
 
-    it 'returns 0 items after executing SimpleCov.filtered on files when using a "spec/fixtures" string filter' do
-      SimpleCov.add_filter "spec/fixtures"
-      expect(SimpleCov.filtered(subject).count).to be_zero
+    it "doesn't match a new SimpleCov::ArrayFilter when a file path different than 'sample.rb' is passed as array" do
+      expect(SimpleCov::ArrayFilter.new(["other_file.rb"])).not_to be_matches subject
     end
 
-    it 'returns 1 item after executing SimpleCov.filtered on files when using a "fooo" string filter' do
-      SimpleCov.add_filter "fooo"
-      expect(SimpleCov.filtered(subject).count).to eq(1)
+    it "matches a new SimpleCov::ArrayFilter when two file paths including 'sample.rb' are passed as array" do
+      expect(SimpleCov::ArrayFilter.new(["sample.rb", "other_file.rb"])).to be_matches subject
     end
 
-    it "returns 0 items after executing SimpleCov.filtered on files when using a block filter that returns true" do
-      SimpleCov.add_filter do
-        true
+    context "with no filters set up and a basic source file in an array" do
+      before do
+        @prev_filters = SimpleCov.filters
+        SimpleCov.filters = []
       end
-      expect(SimpleCov.filtered(subject).count).to be_zero
-    end
 
-    it "returns 1 item after executing SimpleCov.filtered on files when using an always-false block filter" do
-      SimpleCov.add_filter do
-        false
+      subject do
+        [SimpleCov::SourceFile.new(source_fixture("sample.rb"), [nil, 1, 1, 1, nil, nil, 1, 0, nil, nil])]
+      end
+
+      after do
+        SimpleCov.filters = @prev_filters
+      end
+
+      it 'returns 0 items after executing SimpleCov.filtered on files when using a "sample" string filter' do
+        SimpleCov.add_filter "sample"
+        expect(SimpleCov.filtered(subject).count).to be_zero
       end
-      expect(SimpleCov.filtered(subject).count).to eq(1)
-    end
 
-    it "returns a FileList after filtering" do
-      SimpleCov.add_filter "fooo"
-      expect(SimpleCov.filtered(subject)).to be_a SimpleCov::FileList
+      it 'returns 0 items after executing SimpleCov.filtered on files when using a "spec/fixtures" string filter' do
+        SimpleCov.add_filter "spec/fixtures"
+        expect(SimpleCov.filtered(subject).count).to be_zero
+      end
+
+      it 'returns 1 item after executing SimpleCov.filtered on files when using a "fooo" string filter' do
+        SimpleCov.add_filter "fooo"
+        expect(SimpleCov.filtered(subject).count).to eq(1)
+      end
+
+      it "returns 0 items after executing SimpleCov.filtered on files when using a block filter that returns true" do
+        SimpleCov.add_filter do
+          true
+        end
+        expect(SimpleCov.filtered(subject).count).to be_zero
+      end
+
+      it "returns 1 item after executing SimpleCov.filtered on files when using an always-false block filter" do
+        SimpleCov.add_filter do
+          false
+        end
+        expect(SimpleCov.filtered(subject).count).to eq(1)
+      end
+
+      it "returns a FileList after filtering" do
+        SimpleCov.add_filter "fooo"
+        expect(SimpleCov.filtered(subject)).to be_a SimpleCov::FileList
+      end
     end
   end
-end if SimpleCov.usable?
+end

data/spec/fixtures/deleted_source_sample.rb

@@ -12,4 +12,4 @@ code = %{
 File.open(file, "w") { |f| f.print code }
 load file
 File.unlink file
-fail unless kill_the_buddha(3) == 27
+raise unless kill_the_buddha(3) == 27

data/spec/merge_helpers_spec.rb

@@ -1,108 +1,126 @@
 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],
-      }.extend(SimpleCov::HashMergeHelper)
-
-      @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])
+if SimpleCov.usable?
+  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],
+          source_fixture("parallel_tests.rb") => [nil, 0, nil, 0],
+          source_fixture("conditionally_loaded_1.rb") => [nil, 0, 1],  # loaded only in the first resultset
+        }.extend(SimpleCov::HashMergeHelper)
+
+        @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
 
-      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
+      context "a merge" do
+        subject do
+          @resultset1.merge_resultset(@resultset2)
+        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 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 resultset2.rb" do
-        expect(subject[source_fixture("resultset2.rb")]).to eq([nil, 1, 1, nil])
-      end
-    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
 
-    # 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
+        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
 
-    # 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
+        it "has proper results for resultset1.rb" do
+          expect(subject[source_fixture("resultset1.rb")]).to eq([1, 1, 1, 1])
+        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
+        it "has proper results for resultset2.rb" do
+          expect(subject[source_fixture("resultset2.rb")]).to eq([nil, 1, 1, nil])
+        end
 
-      context "with stored results" do
-        before do
-          SimpleCov::ResultMerger.store_result(@result1)
-          SimpleCov::ResultMerger.store_result(@result2)
+        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 stored data in resultset_path JSON file" do
-          expect(File.readlines(SimpleCov::ResultMerger.resultset_path).length).to be > 50
+        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 "returns a hash containing keys ['result1' and 'result2'] for resultset" do
-          expect(SimpleCov::ResultMerger.resultset.keys.sort).to eq %w(result1 result2)
+        it "has proper results for conditionally_loaded_2.rb" do
+          expect(subject[source_fixture("conditionally_loaded_2.rb")]).to eq([nil, 0, 1])
         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
 
-        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])
+      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 second result way above the merge_timeout" do
+        context "with stored results" do
           before do
-            @result2.created_at = Time.now - 172_800 # two days ago
+            SimpleCov::ResultMerger.store_result(@result1)
             SimpleCov::ResultMerger.store_result(@result2)
           end
 
-          it "has only one result in SimpleCov::ResultMerger.results" do
-            expect(SimpleCov::ResultMerger.results.length).to eq(1)
+          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
 
-        context "with merging disabled" do
-          before { SimpleCov.use_merging false }
+          context "with merging disabled" do
+            before { SimpleCov.use_merging false }
 
-          it "returns nil for SimpleCov.result" do
-            expect(SimpleCov.result).to be_nil
+            it "returns nil for SimpleCov.result" do
+              expect(SimpleCov.result).to be_nil
+            end
           end
         end
       end
     end
   end
-end if SimpleCov.usable?
+end