coverband 5.0.1 → 5.1.0

data/lib/coverband/utils/method_definition_scanner.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+if defined?(RubyVM::AbstractSyntaxTree)
+  module Coverband
+    module Utils
+      class MethodDefinitionScanner
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+        end
+
+        def scan
+          scan_node(RubyVM::AbstractSyntaxTree.parse_file(path), nil)
+        end
+
+        def self.scan(path)
+          new(path).scan
+        end
+
+        class MethodBody
+          def initialize(method_definition)
+            @method_definition = method_definition
+          end
+
+          def coverage?(file_coverage)
+            body_coverage =
+              file_coverage[(first_line_number - 1)..(last_line_number - 1)]
+            body_coverage.map(&:to_i).any?(&:positive?)
+          end
+
+          private
+
+          def first_line_number
+            @method_definition.first_line_number + 1
+          end
+
+          def last_line_number
+            @method_definition.last_line_number - 1
+          end
+        end
+
+        class MethodDefinition
+          attr_reader :last_line_number,
+            :first_line_number,
+            :name,
+            :class_name,
+            :file_path
+
+          def initialize(
+            first_line_number:,
+            last_line_number:,
+            name:,
+            class_name:,
+            file_path:
+          )
+            @first_line_number = first_line_number
+            @last_line_number = last_line_number
+            @name = name
+            @class_name = class_name
+            @file_path = file_path
+          end
+
+          def body
+            MethodBody.new(self)
+          end
+        end
+
+        private
+
+        def scan_node(node, class_name)
+          definitions = []
+          return definitions unless node.is_a?(RubyVM::AbstractSyntaxTree::Node)
+          current_class = node.type == :CLASS ? node.children.first.children.last : class_name
+          if node.type == :DEFN
+            definitions <<
+              MethodDefinition.new(
+                first_line_number: node.first_lineno,
+                last_line_number: node.last_lineno,
+                name: node.children.first,
+                class_name: current_class,
+                file_path: path
+              )
+          end
+          definitions + scan_children(node, current_class)
+        end
+
+        def scan_children(node, current_class)
+          node.children.flatten.compact.map { |child|
+            scan_node(child, current_class)
+          }.flatten
+        end
+      end
+    end
+  end
+end

data/lib/coverband/utils/tasks.rb

@@ -9,11 +9,25 @@ namespace :coverband do
     Coverband::Reporters::ConsoleReport.report(Coverband.configuration.store)
   end
 
+  if defined?(RubyVM::AbstractSyntaxTree)
+    require "coverband/utils/dead_methods"
+
+    desc "Output all dead methods"
+    task :dead_methods do
+      Coverband::Utils::DeadMethods.output_all
+    end
+  end
+
   desc "report runtime Coverband code coverage"
   task :coverage_server do
-    Rake.application["environment"].invoke if Rake::Task.task_defined?("environment")
-    Coverband.configuration.store.merge_mode = true if Coverband.configuration.store.is_a?(Coverband::Adapters::FileStore)
-    Rack::Server.start app: Coverband::Reporters::Web.new, Port: ENV.fetch("COVERBAND_COVERAGE_PORT", 1022).to_i
+    if Rake::Task.task_defined?("environment")
+      Rake.application["environment"].invoke
+    end
+    if Coverband.configuration.store.is_a?(Coverband::Adapters::FileStore)
+      Coverband.configuration.store.merge_mode = true
+    end
+    Rack::Server.start app: Coverband::Reporters::Web.new,
+                       Port: ENV.fetch("COVERBAND_COVERAGE_PORT", 9022).to_i
   end
 
   ###

data/lib/coverband/version.rb

@@ -5,5 +5,5 @@
 # use format '4.2.1.rc.1' ~> 4.2.1.rc to prerelease versions like v4.2.1.rc.2 and v4.2.1.rc.3
 ###
 module Coverband
-  VERSION = "5.0.1"
+  VERSION = '5.1.0'
 end

data/test/coverband/collectors/view_tracker_test.rb

@@ -42,6 +42,16 @@ class ReporterTest < Minitest::Test
     assert_equal [file_path], tracker.used_views.keys
   end
 
+  test "track partials that include the word _mailer in the path" do
+    Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
+    store = fake_store
+    file_path = "#{File.expand_path(Coverband.configuration.root)}/_mailer/file"
+    tracker = Coverband::Collectors::ViewTracker.new(store: store, roots: "dir")
+    tracker.track_views("name", "start", "finish", "id", identifier: file_path)
+    tracker.report_views_tracked
+    assert_equal [file_path], tracker.used_views.keys
+  end
+
   test "ignore partials that include the folder vendor in the path" do
     Coverband::Collectors::ViewTracker.expects(:supported_version?).returns(true)
     store = fake_store

data/test/coverband/reporters/web_test.rb

@@ -43,4 +43,38 @@ if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.2.0")
       end
     end
   end
+
+  module Coverband
+    class AuthWebTest < Minitest::Test
+      include Rack::Test::Methods
+
+      def setup
+        super
+        @store = Coverband.configuration.store
+        Coverband.configure do |config|
+          config.password = "test_pass"
+        end
+      end
+
+      def app
+        Coverband::Reporters::Web.new
+      end
+
+      def teardown
+        super
+      end
+
+      test "renders index with basic auth" do
+        basic_authorize "anything", "test_pass"
+        get "/"
+        assert last_response.ok?
+        assert_match "Coverband Home", last_response.body
+      end
+
+      test "renders 401 auth error when not provided" do
+        get "/"
+        assert_equal 401, last_response.status
+      end
+    end
+  end
 end

data/test/coverband/utils/dead_methods_test.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
+
+if defined?(RubyVM::AbstractSyntaxTree)
+  require "coverband/utils/dead_methods"
+  module Coverband
+    module Utils
+      class DeadMethodsTest < Minitest::Test
+        attr_accessor :coverband
+
+        def setup
+          super
+          @coverband = Coverband::Collectors::Coverage.instance
+        end
+
+        def test_dog_dead_methods
+          file_path = require_unique_file
+          coverage = [nil, nil, 1, 1, 0, nil, nil]
+          dead_methods =
+            DeadMethods.scan(file_path: file_path, coverage: coverage)
+          assert_equal(1, dead_methods.length)
+          dead_method = dead_methods.first
+          assert_equal(4, dead_method.first_line_number)
+          assert_equal(6, dead_method.last_line_number)
+          assert_equal(file_path, dead_method.file_path)
+        end
+
+        def test_all_dead_methods
+          require_unique_file
+          @coverband.report_coverage
+          dead_methods = DeadMethods.scan_all
+          dead_method = dead_methods.find { |method| method.class_name == :Dog }
+          assert(dead_method)
+          assert_equal(4, dead_method.first_line_number)
+          assert_equal(6, dead_method.last_line_number)
+        end
+
+        def test_output_all
+          require_unique_file
+          @coverband.report_coverage
+          DeadMethods.output_all
+        end
+
+        def test_dog_methods_not_dead
+          file = require_unique_file
+          coverage = [nil, nil, 1, 1, 1, nil, nil]
+          assert_empty(DeadMethods.scan(file_path: file, coverage: coverage))
+        end
+      end
+    end
+  end
+end

data/test/coverband/utils/method_definition_scanner_test.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require File.expand_path("../../test_helper", File.dirname(__FILE__))
+
+if defined?(RubyVM::AbstractSyntaxTree)
+  require "coverband/utils/method_definition_scanner"
+  module Coverband
+    module Utils
+      class MethodBodyTest < Minitest::Test
+        def test_no_method_body_coverage
+          method_body =
+            MethodDefinitionScanner::MethodBody.new(
+              MethodDefinitionScanner::MethodDefinition.new(
+                first_line_number: 4,
+                last_line_number: 6,
+                name: :bark,
+                class_name: :Dog,
+                file_path: "./test/dog.rb"
+              )
+            )
+          refute(method_body.coverage?([nil, nil, 1, 1, 0, nil, 1]))
+        end
+
+        def test_method_body_coverage
+          method_body =
+            MethodDefinitionScanner::MethodBody.new(
+              MethodDefinitionScanner::MethodDefinition.new(
+                first_line_number: 4,
+                last_line_number: 6,
+                name: :bark,
+                class_name: :Dog,
+                file_path: "./test/dog.rb"
+              )
+            )
+          assert(method_body.coverage?([nil, nil, 1, 1, 1, nil, 1]))
+        end
+      end
+
+      class MethodDefinitionScannerTest < Minitest::Test
+        def test_scan
+          method_definitions = MethodDefinitionScanner.scan("./test/dog.rb")
+          assert(method_definitions)
+          assert_equal(1, method_definitions.length)
+          method_definition = method_definitions.first # assert_equal(4, method.first_line)
+          assert_equal(4, method_definition.first_line_number)
+          assert_equal(6, method_definition.last_line_number)
+          assert_equal(:bark, method_definition.name)
+          assert_equal(:Dog, method_definition.class_name)
+        end
+
+        def test_scan_large_class
+          method_definitions =
+            MethodDefinitionScanner.scan("./test/fixtures/casting_invitor.rb")
+          method_first_line_numbers =
+            method_definitions.map(&:first_line_number)
+          assert_equal(
+            [6, 13, 17, 35, 40, 44, 48, 52],
+            method_first_line_numbers
+          )
+          method_last_line_numbers = method_definitions.map(&:last_line_number)
+          assert_equal(
+            [11, 15, 31, 38, 42, 46, 50, 59],
+            method_last_line_numbers
+          )
+          method_names = method_definitions.map(&:name)
+          assert_equal(
+            %i[
+              initialize
+              valid?
+              deliver
+              invalid_invitees
+              invitee_list
+              valid_message?
+              valid_invitees?
+              create_invitation
+            ],
+            method_names
+          )
+          class_names = method_definitions.map(&:class_name)
+          assert_equal(8.times.map { :CastingInviter }, class_names)
+        end
+      end
+    end
+  end
+end

data/test/fixtures/casting_invitor.rb

@@ -0,0 +1,60 @@
+class CastingInviter
+  EMAIL_REGEX = /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/
+
+  attr_reader :message, :invitees, :casting
+
+  def initialize(attributes = {})
+    @message = attributes[:message] || ""
+    @invitees = attributes[:invitees] || ""
+    @sender = attributes[:sender]
+    @casting = attributes[:casting]
+  end
+
+  def valid?
+    valid_message? && valid_invitees?
+  end
+
+  def deliver
+    if valid?
+      invitee_list.each do |email|
+        invitation = create_invitation(email)
+        Mailer.invitation_notification(invitation, @message)
+      end
+    else
+      failure_message =
+        "Your #{
+          @casting
+        } message couldn’t be sent. Invitees emails or message are invalid"
+      invitation = create_invitation(@sender)
+      Mailer.invitation_notification(invitation, failure_message)
+    end
+  end
+
+  private
+
+  def invalid_invitees
+    @invalid_invitees ||=
+      invitee_list.map { |item| item unless item.match(EMAIL_REGEX) }.compact
+  end
+
+  def invitee_list
+    @invitee_list ||= @invitees.gsub(/\s+/, "").split(/[\n,;]+/)
+  end
+
+  def valid_message?
+    @message.present?
+  end
+
+  def valid_invitees?
+    invalid_invitees.empty?
+  end
+
+  def create_invitation(email)
+    Invitation.create(
+      casting: @casting,
+      sender: @sender,
+      invitee_email: email,
+      status: "pending"
+    )
+  end
+end

data/test/forked/rails_full_stack_test.rb

@@ -35,7 +35,7 @@ class RailsFullStackTest < Minitest::Test
       end
 
       # Test eager load data stored separately
-      dummy_controller = "./test/rails#{Rails::VERSION::MAJOR}_dummy/app/controllers/dummy_controller.rb"
+      dummy_controller = "./app/controllers/dummy_controller.rb"
       store.type = :eager_loading
       eager_expected = [1, 1, 0, nil, nil]
       results = store.coverage[dummy_controller]["data"]

data/test/forked/rails_full_stack_views_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require File.expand_path("../rails_test_helper", File.dirname(__FILE__))
+
+class RailsFullStackTest < Minitest::Test
+  include Capybara::DSL
+  include Capybara::Minitest::Assertions
+
+  def setup
+    super
+    rails_setup
+    Coverband.report_coverage
+  end
+
+  def teardown
+    super
+    Capybara.reset_sessions!
+    Capybara.use_default_driver
+  end
+
+  test "verify erb haml slim support" do
+    visit "/dummy_view/show"
+    assert_content("I am no dummy view tracker text")
+    Coverband.report_coverage
+    Coverband.configuration.view_tracker&.report_views_tracked
+    visit "/coverage/view_tracker"
+    assert_content("Used Views: (1)")
+    assert_content("Unused Views: (2)")
+    assert_selector("li.used-views", text: "dummy_view/show.html.erb")
+    assert_selector("li.unused-views", text: "dummy_view/show_haml.html.haml")
+    assert_selector("li.unused-views", text: "dummy_view/show_slim.html.slim")
+
+    visit "/dummy_view/show_haml"
+    assert_content("I am haml text")
+    Coverband.report_coverage
+    Coverband.configuration.view_tracker&.report_views_tracked
+    visit "/coverage/view_tracker"
+    assert_content("Used Views: (2)")
+    assert_content("Unused Views: (1)")
+    assert_selector("li.used-views", text: "dummy_view/show_haml.html.haml")
+
+    visit "/dummy_view/show_slim"
+    assert_content("I am slim text")
+    Coverband.report_coverage
+    Coverband.configuration.view_tracker&.report_views_tracked
+    visit "/coverage/view_tracker"
+    assert_content("Used Views: (3)")
+    assert_content("Unused Views: (0)")
+    assert_selector("li.used-views", text: "dummy_view/show_slim.html.slim")
+  end
+end