simplecov 0.15.1 → 0.16.0

data/spec/result_spec.rb

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

data/spec/return_codes_spec.rb

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

@@ -1,109 +0,0 @@
-require "helper"
-
-if SimpleCov.usable?
-  describe SimpleCov do
-    describe ".result" do
-      before do
-        SimpleCov.clear_result
-        allow(Coverage).to receive(:result).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(__FILE__ => [0, 1])
-            expect(SimpleCov.result.filenames).to eq [__FILE__]
-          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).not_to receive(:store_result)
-            SimpleCov.result
-          end
-
-          it "doesn't merge the result" do
-            expect(SimpleCov::ResultMerger).not_to receive(:merged_result)
-            SimpleCov.result
-          end
-
-          it "caches its result" do
-            result = SimpleCov.result
-            expect(SimpleCov.result).to be(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 be(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 be(the_merged_result)
-          end
-
-          it "caches its result" do
-            result = SimpleCov.result
-            expect(SimpleCov.result).to be(result)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/source_file_line_spec.rb

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