simplecov-compare 0.1.0

data/test/fixtures/sample_resultset.json

@@ -0,0 +1,59 @@
+{
+  "RSpec": {
+    "coverage": {
+      "/path/to/app/helpers/application_helper.rb": {
+        "lines": [
+          1,
+          null
+        ]
+      },
+      "/path/to/app/models/model_name.rb": {
+        "lines": [
+          1,
+          1,
+          null,
+          1,
+          1,
+          null,
+          1,
+          6,
+          null,
+          null,
+          null,
+          1,
+          null,
+          7,
+          12,
+          0,
+          null,
+          0,
+          null,
+          null,
+          null,
+          null
+        ]
+      },
+      "/path/to/app/models/other_model.rb": {
+        "lines": [
+          7,
+          5,
+          5,
+          4,
+          4,
+          4,
+          null,
+          0,
+          0,
+          0,
+          null,
+          0,
+          0,
+          0,
+          null
+        ],
+        "branches": {}
+      }
+    },
+    "timestamp": 1770264586
+  }
+}

data/test/simplecov/compare/file_comparison_test.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Simplecov
+  module Compare
+    describe FileComparison do
+      describe "#same_file?" do
+        it "is true when the file names of both file results are the same" do
+          base = FileResult.new("name.txt", coverage_data: nil)
+          other = FileResult.new("name.txt", coverage_data: nil)
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal true, comparison.same_file?
+        end
+
+        it "is false when the file names of both file results are different" do
+          base = FileResult.new("name.txt", coverage_data: nil)
+          other = FileResult.new("different.txt", coverage_data: nil)
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal false, comparison.same_file?
+        end
+
+        it "is false when there is no base" do
+          other = FileResult.new("different.txt", coverage_data: nil)
+
+          comparison = FileComparison.new(nil, to: other)
+
+          assert_equal false, comparison.same_file?
+        end
+      end
+
+      describe "#filename" do
+        it "is the name of the base file when base exists" do
+          base = FileResult.new("name.txt", coverage_data: nil)
+          other = FileResult.new("different.txt", coverage_data: nil)
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal "name.txt", comparison.filename
+        end
+
+        it "is the name of the other file when there is no base" do
+          other = FileResult.new("different.txt", coverage_data: nil)
+
+          comparison = FileComparison.new(nil, to: other)
+
+          assert_equal "different.txt", comparison.filename
+        end
+
+        it "is nil when there is neither a base nor another file" do
+          comparison = FileComparison.new(nil, to: nil)
+
+          assert_nil comparison.filename
+        end
+      end
+
+      describe "#lines_coverage_different?" do
+        it "is true when the lines coverage is different" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 5 }
+
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 6 }
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal true, comparison.lines_coverage_different?
+        end
+
+        it "is false when the lines coverage is the same" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 5 }
+
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 5 }
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal false, comparison.lines_coverage_different?
+        end
+      end
+
+      describe "#lines_coverage_equal?" do
+        it "is true when the lines coverage is the same" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 5 }
+
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 5 }
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal true, comparison.lines_coverage_equal?
+        end
+
+        it "is false when the lines coverage is different" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 5 }
+
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 6 }
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal false, comparison.lines_coverage_equal?
+        end
+      end
+
+      describe "#lines_coverage_increased?" do
+        it "is true when the lines coverage of the other is higher" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 5 }
+
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 6 }
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal true, comparison.lines_coverage_increased?
+        end
+
+        it "is false when the lines coverage of the base is higher" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 6 }
+
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 5 }
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal false, comparison.lines_coverage_increased?
+        end
+
+        it "is false when the lines coverage is the same" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 5 }
+
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 5 }
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal false, comparison.lines_coverage_increased?
+        end
+      end
+
+      describe "#lines_coverage_decreased?" do
+        it "is true when the lines coverage of the base is higher" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 6 }
+
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 5 }
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal true, comparison.lines_coverage_decreased?
+        end
+
+        it "is false when the lines coverage of the other is higher" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 5 }
+
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 6 }
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal false, comparison.lines_coverage_decreased?
+        end
+
+        it "is false when the lines coverage is the same" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 5 }
+
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 5 }
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal false, comparison.lines_coverage_decreased?
+        end
+      end
+
+      describe "#lines_coverage_delta_points" do
+        it "is the positive difference between the base and the higher other coverage" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 50 }
+
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 60 }
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal 10, comparison.lines_coverage_delta_points
+        end
+
+        it "is the negative difference between the base and the lower other coverage" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 60 }
+
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 50 }
+
+          comparison = FileComparison.new(base, to: other)
+
+          assert_equal(-10, comparison.lines_coverage_delta_points)
+        end
+
+        it "is a positive amount of the other lines coverage when there is no base" do
+          other = Mocktail.of(FileResult)
+          stubs { other.lines_covered_percent }.with { 50 }
+
+          comparison = FileComparison.new(nil, to: other)
+
+          assert_equal(50, comparison.lines_coverage_delta_points)
+        end
+
+        it "is a negative amount of the base lines coverage when there is no other" do
+          base = Mocktail.of(FileResult)
+          stubs { base.lines_covered_percent }.with { 50 }
+
+          comparison = FileComparison.new(base, to: nil)
+
+          assert_equal(-50, comparison.lines_coverage_delta_points)
+        end
+      end
+    end
+  end
+end

data/test/simplecov/compare/file_line_test.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Simplecov
+  module Compare
+    describe FileLine do
+      describe "#irrelevant?" do
+        it "is true when the covered count is nil" do
+          line = FileLine.new(line_number: 3, covered_count: nil)
+
+          assert_equal true, line.irrelevant?
+        end
+
+        it "is false when the covered count is a number" do
+          line = FileLine.new(line_number: 3, covered_count: 1)
+
+          assert_equal false, line.irrelevant?
+        end
+      end
+
+      describe "#relevant?" do
+        it "is false when the covered count is nil" do
+          line = FileLine.new(line_number: 3, covered_count: nil)
+
+          assert_equal false, line.relevant?
+        end
+
+        it "is true when the covered count is a number" do
+          line = FileLine.new(line_number: 3, covered_count: 1)
+
+          assert_equal true, line.relevant?
+        end
+      end
+
+      describe "#missed?" do
+        it "is true when a relevant line has a covered count of zero" do
+          line = FileLine.new(line_number: 3, covered_count: 0)
+
+          assert_equal true, line.missed?
+        end
+
+        it "is false when the line is irrelevant" do
+          line = FileLine.new(line_number: 3, covered_count: nil)
+
+          assert_equal false, line.missed?
+        end
+
+        it "is false for a relevant line with a covered count" do
+          line = FileLine.new(line_number: 3, covered_count: 1)
+
+          assert_equal false, line.missed?
+        end
+      end
+
+      describe "#covered?" do
+        it "is true for a relevant line with a covered count" do
+          line = FileLine.new(line_number: 3, covered_count: 1)
+
+          assert_equal true, line.covered?
+        end
+
+        it "is false when a relevant line has a covered count of zero" do
+          line = FileLine.new(line_number: 3, covered_count: 0)
+
+          assert_equal false, line.covered?
+        end
+
+        it "is false when the line is irrelevant" do
+          line = FileLine.new(line_number: 3, covered_count: nil)
+
+          assert_equal false, line.covered?
+        end
+      end
+    end
+  end
+end

data/test/simplecov/compare/file_result_test.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Simplecov
+  module Compare
+    describe FileResult do
+      describe "#lines" do
+        it "converts the lines coverage data into a collection of file lines" do
+          coverage_data = { "lines" => [0, 1, nil, 47] }
+          file = FileResult.new(nil, coverage_data:)
+
+          assert_equal 4, file.lines.size
+          assert_equal FileLine, file.lines.first.class
+          assert_equal [1, 2, 3, 4], file.lines.map { _1.line_number }
+          assert_equal [false, true, false, true], file.lines.map { _1.covered? }
+        end
+
+        it "is an empty collection when no coverage data is provided" do
+          file = FileResult.new(nil, coverage_data: nil)
+
+          assert_empty file.lines
+        end
+
+        it "is an empty collection with no lines coverage" do
+          file = FileResult.new(nil, coverage_data: {})
+
+          assert_empty file.lines
+        end
+      end
+
+      describe "#relevant_lines" do
+        it "provides the lines with relevant coverage information" do
+          coverage_data = { "lines" => [0, 1, nil, 47] }
+          file = FileResult.new(nil, coverage_data:)
+
+          assert_equal [1, 2, 4], file.relevant_lines.map { _1.line_number }
+        end
+      end
+
+      describe "#covered_lines" do
+        it "provides the lines that have been covered in the coverage report" do
+          coverage_data = { "lines" => [0, 1, nil, 47] }
+          file = FileResult.new(nil, coverage_data:)
+
+          assert_equal [2, 4], file.covered_lines.map { _1.line_number }
+        end
+      end
+
+      describe "#lines_covered_percent" do
+        it "is the percentage of relevant lines in the file that have been covered" do
+          coverage_data = { "lines" => [0, 1, nil, 47] }
+          file = FileResult.new(nil, coverage_data:)
+
+          assert_equal 66.67, file.lines_covered_percent
+        end
+
+        it "is 100 when there are no relevant lines" do
+          file = FileResult.new(nil, coverage_data: nil)
+
+          assert_equal 100, file.lines_covered_percent
+        end
+      end
+
+      describe "#same_file?" do
+        it "is true when file results share the same name" do
+          file = FileResult.new("name.txt", coverage_data: nil)
+          other = FileResult.new("name.txt", coverage_data: nil)
+
+          assert_equal true, file.same_file?(other)
+        end
+
+        it "is true when file results share the same name with different casing" do
+          file = FileResult.new("name.txt", coverage_data: nil)
+          other = FileResult.new("NAme.txt", coverage_data: nil)
+
+          assert_equal true, file.same_file?(other)
+        end
+
+        it "is false when the file results have a different name" do
+          file = FileResult.new("name.txt", coverage_data: nil)
+          other = FileResult.new("different.txt", coverage_data: nil)
+
+          assert_equal false, file.same_file?(other)
+        end
+
+        it "is false when the passed in comparison is not a file result" do
+          file = FileResult.new("name.txt", coverage_data: nil)
+
+          assert_equal false, file.same_file?(1)
+        end
+
+        it "is false when the file result has no filename" do
+          file = FileResult.new(nil, coverage_data: nil)
+          other = FileResult.new("different.txt", coverage_data: nil)
+
+          assert_equal false, file.same_file?(other)
+        end
+
+        it "is false when the other file result has no filename" do
+          file = FileResult.new("name.txt", coverage_data: nil)
+          other = FileResult.new(nil, coverage_data: nil)
+
+          assert_equal false, file.same_file?(other)
+        end
+      end
+    end
+  end
+end

data/test/simplecov/compare/formatter/markdown_formatter_test.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Simplecov
+  module Compare
+    module Formatter
+      describe MarkdownFormatter do
+        describe "#format" do
+          it "is a string of text in markdown describing the difference between two coverage reports with the biggest decreases in coverage in files at the top" do
+            comparison = Mocktail.of(ResultSetComparison)
+            stubs { comparison.original_lines_covered_percent }.with { 33 }
+            stubs { comparison.new_lines_covered_percent }.with { 42 }
+            stubs { comparison.lines_coverage_increased? }.with { true }
+            stubs { comparison.lines_coverage_delta_points }.with { 9 }
+            stubs { comparison.file_differences? }.with { true }
+
+            big_decrease = Mocktail.of(FileComparison)
+            stubs { big_decrease.filename }.with { "big_decrease.rb" }
+            stubs { big_decrease.lines_coverage_delta_points }.with { -20 }
+            small_decrease = Mocktail.of(FileComparison)
+            stubs { small_decrease.filename }.with { "small_decrease.rb" }
+            stubs { small_decrease.lines_coverage_delta_points }.with { -3 }
+            small_increase = Mocktail.of(FileComparison)
+            stubs { small_increase.filename }.with { "small_increase.rb" }
+            stubs { small_increase.lines_coverage_delta_points }.with { 7 }
+            big_increase = Mocktail.of(FileComparison)
+            stubs { big_increase.filename }.with { "big_increase.rb" }
+            stubs { big_increase.lines_coverage_delta_points }.with { 25 }
+
+            stubs { comparison.file_differences }.with { [big_increase, small_decrease, big_decrease, small_increase] }
+
+            markdown_result = <<~MARKDOWN
+              # Coverage Comparison
+
+              ## Overall Impact: 📈
+
+              Coverage increased 9 points from 33% to 42%.
+
+              ## File Differences
+
+              | File Name | Coverage Change |
+              | --------- | --------------- |
+              | big_decrease.rb | -20 |
+              | small_decrease.rb | -3 |
+              | small_increase.rb | 7 |
+              | big_increase.rb | 25 |
+
+
+            MARKDOWN
+
+            formatter = MarkdownFormatter.new
+
+            assert_equal markdown_result, formatter.format(comparison)
+          end
+
+          it "shows a positive change when the coverage increased" do
+            comparison = Mocktail.of(ResultSetComparison)
+            stubs { comparison.original_lines_covered_percent }.with { 33 }
+            stubs { comparison.new_lines_covered_percent }.with { 42 }
+            stubs { comparison.lines_coverage_increased? }.with { true }
+            stubs { comparison.lines_coverage_delta_points }.with { 9 }
+
+            formatter = MarkdownFormatter.new
+
+            assert_includes formatter.format(comparison), "## Overall Impact: 📈\n\nCoverage increased 9 points from 33% to 42%."
+          end
+
+          it "shows a negative change when the coverage decreased" do
+            comparison = Mocktail.of(ResultSetComparison)
+            stubs { comparison.original_lines_covered_percent }.with { 42 }
+            stubs { comparison.new_lines_covered_percent }.with { 33 }
+            stubs { comparison.lines_coverage_increased? }.with { false }
+            stubs { comparison.lines_coverage_decreased? }.with { true }
+            stubs { comparison.lines_coverage_delta_points }.with { -9 }
+
+            formatter = MarkdownFormatter.new
+
+            assert_includes formatter.format(comparison), "## Overall Impact: 📉\n\nCoverage decreased 9 points from 42% to 33%."
+          end
+
+          it "shows no change when the coverage is the same" do
+            comparison = Mocktail.of(ResultSetComparison)
+            stubs { comparison.original_lines_covered_percent }.with { 33 }
+            stubs { comparison.new_lines_covered_percent }.with { 33 }
+            stubs { comparison.lines_coverage_increased? }.with { false }
+            stubs { comparison.lines_coverage_decreased? }.with { false }
+            formatter = MarkdownFormatter.new
+
+            assert_includes formatter.format(comparison), "## Overall Impact: 🟰\n\nCoverage maintained at 33%."
+          end
+
+          it "tells that all files have the same coverage when there are no file differences" do
+            comparison = Mocktail.of(ResultSetComparison)
+            stubs { comparison.file_differences? }.with { false }
+
+            formatter = MarkdownFormatter.new
+
+            assert_includes formatter.format(comparison), "## File Differences\n\nAll files maintained the same level of coverage."
+          end
+        end
+      end
+    end
+  end
+end

data/test/simplecov/compare/reporter/simple_reporter_test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Simplecov
+  module Compare
+    module Reporter
+      describe SimpleReporter do
+        describe "#report" do
+          it "outputs the provided information to std-out" do
+            assert_output("here are all the differences\n") { SimpleReporter.new.report("here are all the differences") }
+          end
+        end
+      end
+    end
+  end
+end

data/test/simplecov/compare/result_file_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Simplecov
+  module Compare
+    describe ResultFile do
+      describe "#coverage_data" do
+        it "extracts the coverage data out of the provided file as a hash" do
+          file = ResultFile.new("test/fixtures/sample_resultset.json")
+
+          hash_from_file = {
+            "/path/to/app/helpers/application_helper.rb" => {
+              "lines" => [1, nil],
+            },
+            "/path/to/app/models/model_name.rb" => {
+              "lines" => [1, 1, nil, 1, 1, nil, 1, 6, nil, nil, nil, 1, nil, 7, 12, 0, nil, 0, nil, nil, nil, nil],
+            },
+            "/path/to/app/models/other_model.rb" => {
+              "lines" => [7, 5, 5, 4, 4, 4, nil, 0, 0, 0, nil, 0, 0, 0, nil],
+              "branches" => {}},
+          }
+
+          assert_equal(hash_from_file, file.coverage_data)
+        end
+      end
+    end
+  end
+end