simplecov-small-badge 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c891eb965bf86dd10dba84497d95ce99e324e00779806238c1f61b509e9fd223
-  data.tar.gz: 2e8ec88ac9d5c54ee45be5103a7c805669c2ed8440e1c3953027a1f8c0c66f67
+  metadata.gz: a7bd5b6b9a5569875b9fe95d181f63b32a9cf742d0ff26f6e2082fc9437abf9c
+  data.tar.gz: 44ad2758219eb48ead4fb2bb75d4a42c1ff8184291f4673f6d7959508c36b7d9
 SHA512:
-  metadata.gz: 20d57e909c584f8b7550a8cdcd9f2bdb5d88a025be5bb8005bba7752bf4ef995553733d303573b74778895f603ddef959d1699608ddde41cb168ce9542249f77
-  data.tar.gz: 3ec207d43bbf88b6ca0b914a5964d21a4e4d5e61bcc9d5b566346e04295ea55be2dfb72058454291bb0b295878d0a0d749624100e7da8d4db722b090a70a4f16
+  metadata.gz: 456fea795c5468308737242c4103387042c39ecde8c7ac5ebc2c6b8236601894750934e4ecd08b3860f6ca715e1c44266c724e38bb58ce124f08a7bad33e4896
+  data.tar.gz: '08aae60fd42146dacaf3ca6928778a370c6baa43c8bcdc7e868ad69b3068d6d5bb3830432c20c358577affc793a0feed8bcf21ab2e66c416000e4fa1b7257b43'

data/lib/simplecov_small_badge/formatter.rb

@@ -46,7 +46,7 @@ module SimpleCovSmallBadge
 
     def line_coverage_minimum
       minimums = SimpleCov.minimum_coverage
-      minimums.is_a?(Hash) ? minimums[SimpleCov.primary_coverage] : minimums
+      minimums[SimpleCov.primary_coverage]
     end
 
     def map_image_config(state)

data/lib/simplecov_small_badge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCovSmallBadge
-  VERSION = '0.2.6'
+  VERSION = '0.2.7'
 end

data/spec/simplecov_small_badge_formatter_spec.rb

@@ -7,13 +7,6 @@ describe SimpleCovSmallBadge::Formatter do
 
   describe '#format' do
     context 'bad result' do
-      it do
-        allow(SimpleCov).to receive(:minimum_coverage).and_return(90)
-        mock_repo_badge_image(cov: '50%', state: 'bad')
-        result = mock_result(50)
-        expect(subject.format(result)).to be_truthy
-      end
-
       it do
         allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 90)
         mock_repo_badge_image(cov: '50%', state: 'bad')
@@ -23,26 +16,6 @@ describe SimpleCovSmallBadge::Formatter do
     end
 
     context 'good result' do
-      it do
-        allow(SimpleCov).to receive(:minimum_coverage).and_return(100)
-        image_mock = mock_repo_badge_image(title: 'total', name: 'total',
-                                           cov: '100%')
-        mock_repo_badge_image(title: 'library', name: 'library',
-                              cov: '100%', mock: image_mock)
-        result = mock_result(100, 'library' => mock_result_group(100))
-        expect(subject.format(result)).to be_truthy
-      end
-
-      it do
-        allow(SimpleCov).to receive(:minimum_coverage).and_return(90)
-        image_mock = mock_repo_badge_image(title: 'total', name: 'total',
-                                           cov: '90%')
-        mock_repo_badge_image(title: 'library', name: 'library',
-                              cov: '90%', mock: image_mock)
-        result = mock_result(90, 'library' => mock_result_group(90))
-        expect(subject.format(result)).to be_truthy
-      end
-
       it do
         allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 100)
         image_mock = mock_repo_badge_image(title: 'total', name: 'total',
@@ -65,16 +38,6 @@ describe SimpleCovSmallBadge::Formatter do
     end
 
     context 'bad result' do
-      it do
-        allow(SimpleCov).to receive(:minimum_coverage).and_return(91)
-        image_mock = mock_repo_badge_image(title: 'total', name: 'total',
-                                           cov: '90%', state: 'bad')
-        mock_repo_badge_image(title: 'library', name: 'library',
-                              cov: '90%', state: 'bad', mock: image_mock)
-        result = mock_result(90, 'library' => mock_result_group(90))
-        expect(subject.format(result)).to be_truthy
-      end
-
       it do
         allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 91)
         image_mock = mock_repo_badge_image(title: 'total', name: 'total',
@@ -87,16 +50,6 @@ describe SimpleCovSmallBadge::Formatter do
     end
 
     context 'unknown result' do
-      it do
-        allow(SimpleCov).to receive(:minimum_coverage).and_return(nil)
-        image_mock = mock_repo_badge_image(title: 'total', name: 'total',
-                                           cov: '90%', state: 'unknown')
-        mock_repo_badge_image(title: 'library', name: 'library',
-                              cov: '90%', state: 'unknown', mock: image_mock)
-        result = mock_result(90, 'library' => mock_result_group(90))
-        expect(subject.format(result)).to be_truthy
-      end
-
       it do
         allow(SimpleCov).to receive(:minimum_coverage).and_return({})
         image_mock = mock_repo_badge_image(title: 'total', name: 'total',
@@ -110,7 +63,7 @@ describe SimpleCovSmallBadge::Formatter do
 
     context 'mixed result' do
       it do
-        allow(SimpleCov).to receive(:minimum_coverage).and_return(90)
+        allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 90)
         image_mock = mock_repo_badge_image(title: 'total', name: 'total',
                                            cov: '89%', state: 'bad')
         mock_repo_badge_image(title: 'library', name: 'library',
@@ -118,15 +71,129 @@ describe SimpleCovSmallBadge::Formatter do
         result = mock_result(89, 'library' => mock_result_group(90))
         expect(subject.format(result)).to be_truthy
       end
+    end
 
-      it do
-        allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 90)
-        image_mock = mock_repo_badge_image(title: 'total', name: 'total',
-                                           cov: '89%', state: 'bad')
-        mock_repo_badge_image(title: 'library', name: 'library',
-                              cov: '90%', state: 'good', mock: image_mock)
-        result = mock_result(89, 'library' => mock_result_group(90))
-        expect(subject.format(result)).to be_truthy
+    context 'with branch coverage' do
+      before do
+        SimpleCov.enable_coverage :branch
+        SimpleCov.primary_coverage :branch
+        allow(SimpleCov).to receive(:minimum_coverage)
+          .and_return(minimum_coverage)
+      end
+
+      after do
+        SimpleCov.clear_coverage_criteria
+        SimpleCov.enable_coverage :line
+        SimpleCov.primary_coverage :line
+      end
+
+      context 'when coverage is lower than required' do
+        let(:minimum_coverage) { { branch: 90, line: 100 } }
+        let(:coverage) { 50 }
+        let(:expected_state) { 'bad' }
+
+        it 'is bad' do
+          mock_repo_badge_image(cov: "#{coverage}%", state: expected_state)
+          result = mock_result(coverage)
+          subject.format(result)
+        end
+      end
+
+      context 'when coverage is lower than required with groups' do
+        let(:minimum_coverage) { { branch: 91, line: 100 } }
+        let(:coverage) { 90 }
+        let(:expected_state) { 'bad' }
+
+        it 'is bad' do
+          image_mock = mock_repo_badge_image(title: 'total', name: 'total',
+                                             cov: "#{coverage}%",
+                                             state: expected_state)
+          mock_repo_badge_image(title: 'library', name: 'library',
+                                cov: "#{coverage}%", state: expected_state,
+                                mock: image_mock)
+          result = mock_result(coverage,
+                               'library' => mock_result_group(coverage))
+          subject.format(result)
+        end
+      end
+
+      context 'when coverage is greater than or equal to that required' do
+        let(:minimum_coverage) { { branch: 100, line: 10 } }
+        let(:coverage) { 100 }
+        let(:expected_state) { 'good' }
+
+        it 'is good' do
+          mock_repo_badge_image(cov: '100%', state: expected_state)
+          result = mock_result(coverage)
+          subject.format(result)
+        end
+      end
+
+      context 'when coverage is greater than or equal to that required with groups' do
+        let(:minimum_coverage) { { branch: 100, line: 10 } }
+        let(:coverage) { 100 }
+        let(:expected_state) { 'good' }
+
+        it 'is good' do
+          image_mock = mock_repo_badge_image(title: 'total', name: 'total',
+                                             cov: "#{coverage}%")
+          mock_repo_badge_image(title: 'library', name: 'library',
+                                cov: "#{coverage}%", mock: image_mock)
+          result = mock_result(coverage, 'library' => mock_result_group(coverage))
+          subject.format(result)
+        end
+      end
+
+      context 'when minimum coverage is not set' do
+        let(:minimum_coverage) { {} }
+        let(:coverage) { 90 }
+        let(:expected_state) { 'unknown' }
+
+        it 'is unknown' do
+          mock_repo_badge_image(cov: "#{coverage}%",
+                                state: expected_state)
+          result = mock_result(coverage)
+          expect(subject.format(result)).to be_truthy
+        end
+      end
+
+      context 'when minimum coverage is not set with groups' do
+        let(:minimum_coverage) { {} }
+        let(:coverage) { 90 }
+        let(:expected_state) { 'unknown' }
+
+        it 'is unknown' do
+          image_mock = mock_repo_badge_image(title: 'total', name: 'total',
+                                             cov: "#{coverage}%",
+                                             state: expected_state)
+          mock_repo_badge_image(title: 'library', name: 'library',
+                                cov: "#{coverage}%", state: expected_state,
+                                mock: image_mock)
+          result = mock_result(coverage,
+                               'library' => mock_result_group(coverage))
+          expect(subject.format(result)).to be_truthy
+        end
+      end
+
+      context 'when global coverage is lower but group coverage is as required' do
+        let(:minimum_coverage) { { branch: 90, line: 10 } }
+        let(:global_coverage) { 89 }
+        let(:group_coverage) { 90 }
+        let(:global_state) { 'bad' }
+        let(:group_state) { 'good' }
+
+        it 'is mixed' do
+          image_mock = mock_repo_badge_image(title: 'total', name: 'total',
+                                             cov: "#{global_coverage}%",
+                                             state: global_state)
+          mock_repo_badge_image(title: 'library', name: 'library',
+                                cov: "#{group_coverage}%",
+                                state: group_state,
+                                mock: image_mock)
+          result = mock_result(global_coverage,
+                               'library' => mock_result_group(group_coverage))
+          subject.format(result)
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplecov-small-badge
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors:
 - Marc Grimme
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-04 00:00:00.000000000 Z
+date: 2023-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: repo-small-badge