simplecov-patched 0.14.2

data/spec/deleted_source_spec.rb

@@ -0,0 +1,12 @@
+require "helper"
+
+# Test to verify correct handling of deleted files
+# See https://github.com/colszowka/simplecov/issues/9
+describe "A source file which is subsequently deleted" do
+  it "does not cause an error" do
+    Dir.chdir(File.join(File.dirname(__FILE__), "fixtures")) do
+      `ruby deleted_source_sample.rb`
+      expect($?.exitstatus).to be_zero
+    end
+  end
+end

data/spec/faked_project/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem "simplecov", :path => "../../../"
+gem "rake"
+gem "rspec", ">= 2.6.0"
+gem "cucumber"

data/spec/faked_project/Rakefile

@@ -0,0 +1,8 @@
+require "bundler"
+
+require "rake/testtask"
+Rake::TestTask.new(:test) do |test|
+  test.libs << "lib" << "test"
+  test.test_files = FileList["test/**/*_test.rb"].sort
+  test.verbose = true
+end

data/spec/faked_project/cucumber.yml

@@ -0,0 +1,13 @@
+<%
+rerun = File.file?('rerun.txt') ? IO.read('rerun.txt') : ""
+rerun_opts = rerun.to_s.strip.empty? ? "--format #{ENV['CUCUMBER_FORMAT'] || 'progress'} features" : "--format #{ENV['CUCUMBER_FORMAT'] || 'pretty'} #{rerun}"
+std_opts = "--format #{ENV['CUCUMBER_FORMAT'] || 'progress'} --strict --tags ~@wip"
+interp_opts = if defined?(RUBY_ENGINE)
+  " --tags ~@exclude-#{RUBY_ENGINE}"
+else
+  ''
+end
+%>
+default: <%= std_opts %><%= interp_opts %> features
+wip: --tags @wip:30 --wip features<%= interp_opts %>
+rerun: <%= rerun_opts %> --format rerun --out rerun.txt --strict --tags ~@wip<%= interp_opts %>

data/spec/faked_project/features/step_definitions/my_steps.rb

@@ -0,0 +1,22 @@
+Given /^I want to keep stuff simple$/ do
+  expect(1).to eq(1)
+end
+
+When /^I write my cukes for the fake project$/ do
+  expect(1).to eq(1)
+end
+
+Then /^I make all necessary tests in a single step$/ do
+  expect(FakedProject.foo).to eq("bar")
+
+  expect(FrameworkSpecific.cucumber).to eq("Only tested in Cucumber")
+
+  expect(FakedProject.a_class_method).to eq("this is a mixed-in class method")
+
+  expect(FakedProject.new.an_instance_method).to eq("this is a mixed-in instance method")
+  expect(FakedProject.new.dynamic).to eq("A dynamically defined instance method")
+
+  something = SomeClass.new("foo")
+  expect(something.reverse).to eq("oof")
+  expect(something.compare_with("foo")).to be true
+end

data/spec/faked_project/features/support/env.rb

@@ -0,0 +1,12 @@
+require "bundler/setup"
+
+# We're injecting simplecov_config via aruba in cucumber here
+# depending on what the test case is...
+begin
+  require File.join(File.dirname(__FILE__), "simplecov_config")
+rescue LoadError
+  $stderr.puts "No SimpleCov config file found!"
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "/../../lib"))
+require "faked_project"

data/spec/faked_project/features/test_stuff.feature

@@ -0,0 +1,6 @@
+Feature: Foo
+
+  Scenario: Test stuff
+    Given I want to keep stuff simple
+    When I write my cukes for the fake project
+    Then I make all necessary tests in a single step

data/spec/faked_project/lib/faked_project.rb

@@ -0,0 +1,11 @@
+class FakedProject
+  def self.foo
+    "bar"
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), "faked_project/*.rb")].reject { |f| /untested/.match(f) }.each do |file|
+  require file # Require all source files in project dynamically so we can inject some stuff depending on test situation
+end
+
+FakedProject.send :include, MetaMagic

data/spec/faked_project/lib/faked_project/framework_specific.rb

@@ -0,0 +1,18 @@
+# A pile of methods that only get tested in their frameworks
+# and thus make this file only 100% covered when all framework test
+# results are merged
+module FrameworkSpecific
+  class << self
+    def cucumber
+      "Only tested in Cucumber"
+    end
+
+    def rspec
+      "Only tested in RSpec"
+    end
+
+    def test_unit
+      "Only tested in Test/Unit"
+    end
+  end
+end

data/spec/faked_project/lib/faked_project/meta_magic.rb

@@ -0,0 +1,24 @@
+module MetaMagic
+  module ClassMethods
+    def a_class_method
+      "this is a mixed-in class method"
+    end
+  end
+
+  module InstanceMethods
+    def an_instance_method
+      "this is a mixed-in instance method"
+    end
+  end
+
+  def self.included(base)
+    base.send :extend, ClassMethods
+    base.send :include, InstanceMethods
+
+    base.class_eval do
+      define_method :dynamic do
+        "A dynamically defined instance method"
+      end
+    end
+  end
+end

data/spec/faked_project/lib/faked_project/some_class.rb

@@ -0,0 +1,28 @@
+class SomeClass
+  attr_reader :label
+  attr_accessor :some_attr
+
+  def initialize(label)
+    @label = label
+  end
+
+  def reverse
+    label.reverse
+  end
+
+  def compare_with(item)
+    if item == label
+      return true
+    else
+      raise "Item does not match label"
+    end
+  rescue
+    false
+  end
+
+private
+
+  def uncovered
+    "private method"
+  end
+end

data/spec/faked_project/lib/faked_project/untested_class.rb

@@ -0,0 +1,11 @@
+class UntestedClass
+  def initialize(yogurts)
+    @yogurts = yogurts
+  end
+
+  def power_level
+    @yogurts.map do |yo|
+      yo.experience_points**2
+    end.reduce(0, &:+)
+  end
+end

data/spec/faked_project/spec/faked_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe FakedProject do
+  it "should return proper foo" do
+    expect(FakedProject.foo).to eq("bar")
+  end
+
+  it "should test it's framework specific method" do
+    expect(FrameworkSpecific.rspec).to eq("Only tested in RSpec")
+  end
+end

data/spec/faked_project/spec/forking_spec.rb

@@ -0,0 +1,8 @@
+require "spec_helper"
+
+describe "forking" do
+  it do
+    # TODO: The defined?(RUBY_ENGINE) check can be dropped for simplecov 1.0.0
+    Process.waitpid(Kernel.fork {}) unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+  end
+end

data/spec/faked_project/spec/meta_magic_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe FakedProject do
+  it "should have added a class method to FakedProject" do
+    expect(FakedProject.a_class_method).to eq("this is a mixed-in class method")
+  end
+
+  it "should have added a mixed-in instance method to FakedProject" do
+    expect(subject.an_instance_method).to eq("this is a mixed-in instance method")
+  end
+
+  it "should have added a dyntamically-defined instance method to FakedProject" do
+    expect(subject.dynamic).to eq("A dynamically defined instance method")
+  end
+end

data/spec/faked_project/spec/some_class_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe SomeClass do
+  subject { SomeClass.new("foo") }
+
+  it "should be reversible" do
+    expect(subject.reverse).to eq("oof")
+  end
+
+  it "should compare with 'foo'" do
+    expect(subject.compare_with("foo")).to be true
+  end
+end

data/spec/faked_project/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require "bundler/setup"
+
+# We're injecting simplecov_config via aruba in cucumber here
+# depending on what the test case is...
+begin
+  require File.join(File.dirname(__FILE__), "simplecov_config")
+rescue LoadError
+  $stderr.puts "No SimpleCov config file found!"
+end
+
+require "faked_project"

data/spec/faked_project/test/faked_test.rb

@@ -0,0 +1,11 @@
+require "test_helper"
+
+class FakedTest < Test::Unit::TestCase
+  def test_something
+    assert_equal "bar", FakedProject.foo
+  end
+
+  def test_framework_specific
+    assert_equal "Only tested in Test/Unit", FrameworkSpecific.test_unit
+  end
+end

data/spec/faked_project/test/meta_magic_test.rb

@@ -0,0 +1,13 @@
+require "test_helper"
+
+class MetaMagicTest < Test::Unit::TestCase
+  def test_class_methods
+    assert_equal "this is a mixed-in class method", FakedProject.a_class_method
+  end
+
+  def test_instance_methods
+    p = FakedProject.new
+    assert_equal "this is a mixed-in instance method", p.an_instance_method
+    assert_equal "A dynamically defined instance method", p.dynamic
+  end
+end

data/spec/faked_project/test/some_class_test.rb

@@ -0,0 +1,15 @@
+require "test_helper"
+
+class SomeClassTest < Test::Unit::TestCase
+  def setup
+    @instance = SomeClass.new("foo")
+  end
+
+  def test_reverse
+    assert_equal "oof", @instance.reverse
+  end
+
+  def test_comparison
+    assert @instance.compare_with("foo")
+  end
+end

data/spec/faked_project/test/test_helper.rb

@@ -0,0 +1,12 @@
+require "bundler/setup"
+
+# We're injecting simplecov_config via aruba in cucumber here
+# depending on what the test case is...
+begin
+  require File.join(File.dirname(__FILE__), "simplecov_config")
+rescue LoadError
+  $stderr.puts "No SimpleCov config file found!"
+end
+
+require "faked_project"
+require "test/unit"

data/spec/file_list_spec.rb

@@ -0,0 +1,50 @@
+require "helper"
+
+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 17 never lines" do
+      expect(subject.never_lines).to eq(17)
+    end
+
+    it "has 14 lines of code" do
+      expect(subject.lines_of_code).to eq(14)
+    end
+
+    it "has 5 skipped lines" do
+      expect(subject.skipped_lines).to eq(5)
+    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

@@ -0,0 +1,98 @@
+require "helper"
+
+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 "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
+
+    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 "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::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::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
+
+    context "with no filters set up and a basic source file in an array" do
+      before do
+        @prev_filters = SimpleCov.filters
+        SimpleCov.filters = []
+      end
+
+      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
+
+      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