# frozen_string_literal: true
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            
            

            
              
            

            # Ensure we are using a compatible version of SimpleCov
          
        
      
        

          

            
            skipped

            
              
            

            # :nocov:
          
        
      
        

          

            
            skipped

            
              
            

            if defined?(SimpleCov::VERSION) &&
          
        
      
        

          

            
            skipped

            
              
            

               Gem::Version.new(SimpleCov::VERSION) < Gem::Version.new('0.7.1')
          
        
      
        

          

            
            skipped

            
              
            

              raise 'The version of SimpleCov you are using is too old. '\
          
        
      
        

          

            
            skipped

            
              
            

                'Please update with `gem install simplecov` or `bundle update simplecov`'
          
        
      
        

          

            
            skipped

            
              
            

            end
          
        
      
        

          

            
            skipped

            
              
            

            # :nocov:
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

            require 'simplecov_small_badge/configuration'
          
        
      
        

          

            
            

            
              
            

            # :nodoc:
          
        
      
        

          

            1
            

            
              
            

            module SimpleCovSmallBadge
          
        
      
        

          

            1
            

            
              
            

              @configuration = Configuration.new
          
        
      
        

          

            1
            

            
              
            

              def self.configure
          
        
      
        

          

            1
            

            
              
            

                yield config
          
        
      
        

          

            
            

            
              
            

              end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

              def self.config
          
        
      
        

          

            14
            

            
              
            

                @configuration
          
        
      
        

          

            
            

            
              
            

              end
          
        
      
        

          

            
            

            
              
            

            end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

            $LOAD_PATH.unshift(File.join(File.dirname(__FILE__)))
          
        
      
        

          

            1
            

            
              
            

            require 'simplecov_small_badge/version'
          
        
      
        

          

            1
            

            
              
            

            require 'simplecov_small_badge/formatter'
          
        
      
    
  

    

      
        

          

            
            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

            module SimpleCovSmallBadge
          
        
      
        

          

            
            

            
              
            

              # Class to keep all the valid documentations that are required to build the
          
        
      
        

          

            
            

            
              
            

              # badge
          
        
      
        

          

            1
            

            
              
            

              class Configuration
          
        
      
        

          

            
            

            
              
            

                # Set up config variables.
          
        
      
        

          

            
            

            
              
            

                # rubocop:disable Metrics/MethodLength
          
        
      
        

          

            1
            

            
              
            

                def self.options
          
        
      
        

          

            
            

            
              
            

                  {
          
        
      
        

          

            48
            

            
              
            

                    with_groups: false,
          
        
      
        

          

            
            

            
              
            

                    background: '#fff',
          
        
      
        

          

            
            

            
              
            

                    title_prefix: 'scov',
          
        
      
        

          

            
            

            
              
            

                    title_background: '#555',
          
        
      
        

          

            
            

            
              
            

                    title_font: 'Verdana,sans-serif',
          
        
      
        

          

            
            

            
              
            

                    font_size: 11,
          
        
      
        

          

            
            

            
              
            

                    title_color: '#fff',
          
        
      
        

          

            
            

            
              
            

                    coverage_background_bad: '#ff0000',
          
        
      
        

          

            
            

            
              
            

                    coverage_background_unknown: '#cccc00',
          
        
      
        

          

            
            

            
              
            

                    coverage_background_good: '#4dc71f',
          
        
      
        

          

            
            

            
              
            

                    coverage_font: 'Verdana,sans-serif',
          
        
      
        

          

            
            

            
              
            

                    coverage_font_color: '#fff',
          
        
      
        

          

            
            

            
              
            

                    coverage_font_size: 11,
          
        
      
        

          

            
            

            
              
            

                    badge_height: 20,
          
        
      
        

          

            
            

            
              
            

                    badge_width: 120,
          
        
      
        

          

            
            

            
              
            

                    filename_prefix: 'coverage_badge',
          
        
      
        

          

            
            

            
              
            

                    output_path: SimpleCov.coverage_path,
          
        
      
        

          

            
            

            
              
            

                    log_level: 'info',
          
        
      
        

          

            
            

            
              
            

                    rounded_border: true,
          
        
      
        

          

            
            

            
              
            

                    rounded_edge_radius: 3,
          
        
      
        

          

            
            

            
              
            

                    percent_sign: '%'
          
        
      
        

          

            
            

            
              
            

                  }
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

                # rubocop:enable Metrics/MethodLength
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            
            

            
              
            

                # set up class variables and getters/setters
          
        
      
        

          

            1
            

            
              
            

                options.each_key do |opt|
          
        
      
        

          

            64
            

            
              
            

                  define_method(opt) { instance_variable_get "@#{opt}" }
          
        
      
        

          

            504
            

            
              
            

                  define_method("#{opt}=") { |val| instance_variable_set("@#{opt}", val) }
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                def initialize(**opts)
          
        
      
        

          

            23
            

            
              
            

                  SimpleCovSmallBadge::Configuration
          
        
      
        

          

            483
            

            
              
            

                    .options.merge(opts).each { |opt, v| send(:"#{opt}=", v) }
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                def to_hash
          
        
      
        

          

            36
            

            
              
            

                  hash = {}
          
        
      
        

          

            36
            

            
              
            

                  instance_variables.each do |var|
          
        
      
        

          

            756
            

            
              
            

                    hash[var.to_s.delete('@').to_sym] = instance_variable_get(var)
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            36
            

            
              
            

                  hash
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

              end
          
        
      
        

          

            
            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            
            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

            require 'repo_small_badge/image'
          
        
      
        

          

            1
            

            
              
            

            require 'simplecov_small_badge/configuration'
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

            module SimpleCovSmallBadge
          
        
      
        

          

            
            

            
              
            

              # Basic Badge Formater Class that creates the badges.
          
        
      
        

          

            1
            

            
              
            

              class Formatter
          
        
      
        

          

            1
            

            
              
            

                def initialize(output = nil)
          
        
      
        

          

            13
            

            
              
            

                  @output = output || $stdout
          
        
      
        

          

            13
            

            
              
            

                  @config = SimpleCovSmallBadge.config
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                def format(result)
          
        
      
        

          

            13
            

            
              
            

                  percent = result.source_files.covered_percent.round(0)
          
        
      
        

          

            13
            

            
              
            

                  @image = RepoSmallBadge::Image.new(map_image_config(state(percent)))
          
        
      
        

          

            13
            

            
              
            

                  badge('total', 'total', percent)
          
        
      
        

          

            13
            

            
              
            

                  group_percent_from_result(result) do |name, title, cov_percent|
          
        
      
        

          

            9
            

            
              
            

                    badge(name, title, cov_percent.round(0))
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                private
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                def badge(name, title, percent)
          
        
      
        

          

            22
            

            
              
            

                  percent_txt = percent_text(percent)
          
        
      
        

          

            22
            

            
              
            

                  @image.config_merge(map_image_config(state(percent)))
          
        
      
        

          

            22
            

            
              
            

                  @image.badge(name, title, percent_txt)
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                def percent_text(percent)
          
        
      
        

          

            22
            

            
              
            

                  "#{percent}#{@config.percent_sign}"
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                def state(covered_percent)
          
        
      
        

          

            35
            

            
              
            

                  if line_coverage_minimum&.positive?
          
        
      
        

          

            27
            

            
              
            

                    if covered_percent >= line_coverage_minimum
          
        
      
        

          

            13
            

            
              
            

                      'good'
          
        
      
        

          

            
            

            
              
            

                    else
          
        
      
        

          

            14
            

            
              
            

                      'bad'
          
        
      
        

          

            
            

            
              
            

                    end
          
        
      
        

          

            
            

            
              
            

                  else
          
        
      
        

          

            8
            

            
              
            

                    'unknown'
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                def line_coverage_minimum
          
        
      
        

          

            62
            

            
              
            

                  minimums = SimpleCov.minimum_coverage
          
        
      
        

          

            62
            

            
              
            

                  minimums[SimpleCov.primary_coverage]
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                def map_image_config(state)
          
        
      
        

          

            35
            

            
              
            

                  hash = {}
          
        
      
        

          

            35
            

            
              
            

                  @config.to_hash.map do |key, value|
          
        
      
        

          

            735
            

            
              
            

                    key = key
          
        
      
        

          

            
            

            
              
            

                          .to_s.sub(/^coverage_background_#{state}/, 'value_background')
          
        
      
        

          

            
            

            
              
            

                          .to_sym
          
        
      
        

          

            735
            

            
              
            

                    key = key.to_s.sub(/^coverage_/, 'value_').to_sym
          
        
      
        

          

            735
            

            
              
            

                    hash[key] = value
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            35
            

            
              
            

                  hash
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            
            

            
              
            

                # converts the result to a hash consisting of the groupname
          
        
      
        

          

            
            

            
              
            

                # array of percentage (integer in percent), strength float
          
        
      
        

          

            
            

            
              
            

                # and the state [ 'good', 'bad', 'unknown' ]
          
        
      
        

          

            
            

            
              
            

                # consolidated for each group.
          
        
      
        

          

            1
            

            
              
            

                def group_percent_from_result(result)
          
        
      
        

          

            13
            

            
              
            

                  result.groups.each do |name, files|
          
        
      
        

          

            9
            

            
              
            

                    covered = files.covered_percent.round(0)
          
        
      
        

          

            9
            

            
              
            

                    yield name, name, covered, covered
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

              end
          
        
      
        

          

            
            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            
            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

            require 'spec_helper'
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

            describe SimpleCovSmallBadge::Formatter do
          
        
      
        

          

            1
            

            
              
            

              include TestSimpleCovSmallBadge::Mocks
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

              describe '#format' do
          
        
      
        

          

            1
            

            
              
            

                context 'bad result' do
          
        
      
        

          

            1
            

            
              
            

                  it do
          
        
      
        

          

            1
            

            
              
            

                    allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 90)
          
        
      
        

          

            1
            

            
              
            

                    mock_repo_badge_image(cov: '50%', state: 'bad')
          
        
      
        

          

            1
            

            
              
            

                    result = mock_result(50)
          
        
      
        

          

            1
            

            
              
            

                    expect(subject.format(result)).to be_truthy
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                context 'good result' do
          
        
      
        

          

            1
            

            
              
            

                  it do
          
        
      
        

          

            1
            

            
              
            

                    allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 100)
          
        
      
        

          

            1
            

            
              
            

                    image_mock = mock_repo_badge_image(title: 'total', name: 'total',
          
        
      
        

          

            
            

            
              
            

                                                       cov: '100%')
          
        
      
        

          

            1
            

            
              
            

                    mock_repo_badge_image(title: 'library', name: 'library',
          
        
      
        

          

            
            

            
              
            

                                          cov: '100%', mock: image_mock)
          
        
      
        

          

            1
            

            
              
            

                    result = mock_result(100, 'library' => mock_result_group(100))
          
        
      
        

          

            1
            

            
              
            

                    expect(subject.format(result)).to be_truthy
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                  it do
          
        
      
        

          

            1
            

            
              
            

                    allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 90)
          
        
      
        

          

            1
            

            
              
            

                    image_mock = mock_repo_badge_image(title: 'total', name: 'total',
          
        
      
        

          

            
            

            
              
            

                                                       cov: '90%')
          
        
      
        

          

            1
            

            
              
            

                    mock_repo_badge_image(title: 'library', name: 'library',
          
        
      
        

          

            
            

            
              
            

                                          cov: '90%', mock: image_mock)
          
        
      
        

          

            1
            

            
              
            

                    result = mock_result(90, 'library' => mock_result_group(90))
          
        
      
        

          

            1
            

            
              
            

                    expect(subject.format(result)).to be_truthy
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                context 'bad result' do
          
        
      
        

          

            1
            

            
              
            

                  it do
          
        
      
        

          

            1
            

            
              
            

                    allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 91)
          
        
      
        

          

            1
            

            
              
            

                    image_mock = mock_repo_badge_image(title: 'total', name: 'total',
          
        
      
        

          

            
            

            
              
            

                                                       cov: '90%', state: 'bad')
          
        
      
        

          

            1
            

            
              
            

                    mock_repo_badge_image(title: 'library', name: 'library',
          
        
      
        

          

            
            

            
              
            

                                          cov: '90%', state: 'bad', mock: image_mock)
          
        
      
        

          

            1
            

            
              
            

                    result = mock_result(90, 'library' => mock_result_group(90))
          
        
      
        

          

            1
            

            
              
            

                    expect(subject.format(result)).to be_truthy
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                context 'unknown result' do
          
        
      
        

          

            1
            

            
              
            

                  it do
          
        
      
        

          

            1
            

            
              
            

                    allow(SimpleCov).to receive(:minimum_coverage).and_return({})
          
        
      
        

          

            1
            

            
              
            

                    image_mock = mock_repo_badge_image(title: 'total', name: 'total',
          
        
      
        

          

            
            

            
              
            

                                                       cov: '90%', state: 'unknown')
          
        
      
        

          

            1
            

            
              
            

                    mock_repo_badge_image(title: 'library', name: 'library',
          
        
      
        

          

            
            

            
              
            

                                          cov: '90%', state: 'unknown', mock: image_mock)
          
        
      
        

          

            1
            

            
              
            

                    result = mock_result(90, 'library' => mock_result_group(90))
          
        
      
        

          

            1
            

            
              
            

                    expect(subject.format(result)).to be_truthy
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                context 'mixed result' do
          
        
      
        

          

            1
            

            
              
            

                  it do
          
        
      
        

          

            1
            

            
              
            

                    allow(SimpleCov).to receive(:minimum_coverage).and_return(line: 90)
          
        
      
        

          

            1
            

            
              
            

                    image_mock = mock_repo_badge_image(title: 'total', name: 'total',
          
        
      
        

          

            
            

            
              
            

                                                       cov: '89%', state: 'bad')
          
        
      
        

          

            1
            

            
              
            

                    mock_repo_badge_image(title: 'library', name: 'library',
          
        
      
        

          

            
            

            
              
            

                                          cov: '90%', state: 'good', mock: image_mock)
          
        
      
        

          

            1
            

            
              
            

                    result = mock_result(89, 'library' => mock_result_group(90))
          
        
      
        

          

            1
            

            
              
            

                    expect(subject.format(result)).to be_truthy
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                context 'with branch coverage' do
          
        
      
        

          

            1
            

            
              
            

                  before do
          
        
      
        

          

            7
            

            
              
            

                    SimpleCov.enable_coverage :branch
          
        
      
        

          

            7
            

            
              
            

                    SimpleCov.primary_coverage :branch
          
        
      
        

          

            7
            

            
              
            

                    allow(SimpleCov).to receive(:minimum_coverage)
          
        
      
        

          

            
            

            
              
            

                      .and_return(minimum_coverage)
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                  after do
          
        
      
        

          

            7
            

            
              
            

                    SimpleCov.clear_coverage_criteria
          
        
      
        

          

            7
            

            
              
            

                    SimpleCov.enable_coverage :line
          
        
      
        

          

            7
            

            
              
            

                    SimpleCov.primary_coverage :line
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                  context 'when coverage is lower than required' do
          
        
      
        

          

            2
            

            
              
            

                    let(:minimum_coverage) { { branch: 90, line: 100 } }
          
        
      
        

          

            2
            

            
              
            

                    let(:coverage) { 50 }
          
        
      
        

          

            2
            

            
              
            

                    let(:expected_state) { 'bad' }
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                    it 'is bad' do
          
        
      
        

          

            1
            

            
              
            

                      mock_repo_badge_image(cov: "#{coverage}%", state: expected_state)
          
        
      
        

          

            1
            

            
              
            

                      result = mock_result(coverage)
          
        
      
        

          

            1
            

            
              
            

                      subject.format(result)
          
        
      
        

          

            
            

            
              
            

                    end
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                  context 'when coverage is lower than required with groups' do
          
        
      
        

          

            2
            

            
              
            

                    let(:minimum_coverage) { { branch: 91, line: 100 } }
          
        
      
        

          

            2
            

            
              
            

                    let(:coverage) { 90 }
          
        
      
        

          

            2
            

            
              
            

                    let(:expected_state) { 'bad' }
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                    it 'is bad' do
          
        
      
        

          

            1
            

            
              
            

                      image_mock = mock_repo_badge_image(title: 'total', name: 'total',
          
        
      
        

          

            
            

            
              
            

                                                         cov: "#{coverage}%",
          
        
      
        

          

            
            

            
              
            

                                                         state: expected_state)
          
        
      
        

          

            1
            

            
              
            

                      mock_repo_badge_image(title: 'library', name: 'library',
          
        
      
        

          

            
            

            
              
            

                                            cov: "#{coverage}%", state: expected_state,
          
        
      
        

          

            
            

            
              
            

                                            mock: image_mock)
          
        
      
        

          

            1
            

            
              
            

                      result = mock_result(coverage,
          
        
      
        

          

            
            

            
              
            

                                           'library' => mock_result_group(coverage))
          
        
      
        

          

            1
            

            
              
            

                      subject.format(result)
          
        
      
        

          

            
            

            
              
            

                    end
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                  context 'when coverage is greater than or equal to that required' do
          
        
      
        

          

            2
            

            
              
            

                    let(:minimum_coverage) { { branch: 100, line: 10 } }
          
        
      
        

          

            2
            

            
              
            

                    let(:coverage) { 100 }
          
        
      
        

          

            2
            

            
              
            

                    let(:expected_state) { 'good' }
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                    it 'is good' do
          
        
      
        

          

            1
            

            
              
            

                      mock_repo_badge_image(cov: '100%', state: expected_state)
          
        
      
        

          

            1
            

            
              
            

                      result = mock_result(coverage)
          
        
      
        

          

            1
            

            
              
            

                      subject.format(result)
          
        
      
        

          

            
            

            
              
            

                    end
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                  context 'when coverage is greater than or equal to that required with groups' do
          
        
      
        

          

            2
            

            
              
            

                    let(:minimum_coverage) { { branch: 100, line: 10 } }
          
        
      
        

          

            2
            

            
              
            

                    let(:coverage) { 100 }
          
        
      
        

          

            1
            

            
              
            

                    let(:expected_state) { 'good' }
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                    it 'is good' do
          
        
      
        

          

            1
            

            
              
            

                      image_mock = mock_repo_badge_image(title: 'total', name: 'total',
          
        
      
        

          

            
            

            
              
            

                                                         cov: "#{coverage}%")
          
        
      
        

          

            1
            

            
              
            

                      mock_repo_badge_image(title: 'library', name: 'library',
          
        
      
        

          

            
            

            
              
            

                                            cov: "#{coverage}%", mock: image_mock)
          
        
      
        

          

            1
            

            
              
            

                      result = mock_result(coverage, 'library' => mock_result_group(coverage))
          
        
      
        

          

            1
            

            
              
            

                      subject.format(result)
          
        
      
        

          

            
            

            
              
            

                    end
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                  context 'when minimum coverage is not set' do
          
        
      
        

          

            2
            

            
              
            

                    let(:minimum_coverage) { {} }
          
        
      
        

          

            2
            

            
              
            

                    let(:coverage) { 90 }
          
        
      
        

          

            2
            

            
              
            

                    let(:expected_state) { 'unknown' }
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                    it 'is unknown' do
          
        
      
        

          

            1
            

            
              
            

                      mock_repo_badge_image(cov: "#{coverage}%",
          
        
      
        

          

            
            

            
              
            

                                            state: expected_state)
          
        
      
        

          

            1
            

            
              
            

                      result = mock_result(coverage)
          
        
      
        

          

            1
            

            
              
            

                      expect(subject.format(result)).to be_truthy
          
        
      
        

          

            
            

            
              
            

                    end
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                  context 'when minimum coverage is not set with groups' do
          
        
      
        

          

            2
            

            
              
            

                    let(:minimum_coverage) { {} }
          
        
      
        

          

            2
            

            
              
            

                    let(:coverage) { 90 }
          
        
      
        

          

            2
            

            
              
            

                    let(:expected_state) { 'unknown' }
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                    it 'is unknown' do
          
        
      
        

          

            1
            

            
              
            

                      image_mock = mock_repo_badge_image(title: 'total', name: 'total',
          
        
      
        

          

            
            

            
              
            

                                                         cov: "#{coverage}%",
          
        
      
        

          

            
            

            
              
            

                                                         state: expected_state)
          
        
      
        

          

            1
            

            
              
            

                      mock_repo_badge_image(title: 'library', name: 'library',
          
        
      
        

          

            
            

            
              
            

                                            cov: "#{coverage}%", state: expected_state,
          
        
      
        

          

            
            

            
              
            

                                            mock: image_mock)
          
        
      
        

          

            1
            

            
              
            

                      result = mock_result(coverage,
          
        
      
        

          

            
            

            
              
            

                                           'library' => mock_result_group(coverage))
          
        
      
        

          

            1
            

            
              
            

                      expect(subject.format(result)).to be_truthy
          
        
      
        

          

            
            

            
              
            

                    end
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                  context 'when global coverage is lower but group coverage is as required' do
          
        
      
        

          

            2
            

            
              
            

                    let(:minimum_coverage) { { branch: 90, line: 10 } }
          
        
      
        

          

            2
            

            
              
            

                    let(:global_coverage) { 89 }
          
        
      
        

          

            2
            

            
              
            

                    let(:group_coverage) { 90 }
          
        
      
        

          

            2
            

            
              
            

                    let(:global_state) { 'bad' }
          
        
      
        

          

            2
            

            
              
            

                    let(:group_state) { 'good' }
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                    it 'is mixed' do
          
        
      
        

          

            1
            

            
              
            

                      image_mock = mock_repo_badge_image(title: 'total', name: 'total',
          
        
      
        

          

            
            

            
              
            

                                                         cov: "#{global_coverage}%",
          
        
      
        

          

            
            

            
              
            

                                                         state: global_state)
          
        
      
        

          

            1
            

            
              
            

                      mock_repo_badge_image(title: 'library', name: 'library',
          
        
      
        

          

            
            

            
              
            

                                            cov: "#{group_coverage}%",
          
        
      
        

          

            
            

            
              
            

                                            state: group_state,
          
        
      
        

          

            
            

            
              
            

                                            mock: image_mock)
          
        
      
        

          

            1
            

            
              
            

                      result = mock_result(global_coverage,
          
        
      
        

          

            
            

            
              
            

                                           'library' => mock_result_group(group_coverage))
          
        
      
        

          

            1
            

            
              
            

                      subject.format(result)
          
        
      
        

          

            
            

            
              
            

                    end
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

              end
          
        
      
        

          

            
            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            
            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

            module TestSimpleCovSmallBadge
          
        
      
        

          

            1
            

            
              
            

              module Mocks
          
        
      
        

          

            
            

            
              
            

                # rubocop:disable Metrics/ParameterLists
          
        
      
        

          

            1
            

            
              
            

                def mock_repo_badge_image(cov: 100, name: 'total',
          
        
      
        

          

            
            

            
              
            

                                          title: 'total',
          
        
      
        

          

            
            

            
              
            

                                          state: 'good',
          
        
      
        

          

            
            

            
              
            

                                          config: {},
          
        
      
        

          

            
            

            
              
            

                                          mock: instance_double('Image'))
          
        
      
        

          

            22
            

            
              
            

                  config = map_config_options(config, state)
          
        
      
        

          

            22
            

            
              
            

                  allow(RepoSmallBadge::Image).to receive(:new)
          
        
      
        

          

            
            

            
              
            

                    .with(config).and_return(mock)
          
        
      
        

          

            22
            

            
              
            

                  allow(mock).to receive(:config_merge).with(config).and_return(config)
          
        
      
        

          

            22
            

            
              
            

                  allow(mock).to receive(:badge).with(name, title, cov)
          
        
      
        

          

            22
            

            
              
            

                  mock
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

                # rubocop:enable Metrics/ParameterLists
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                def map_config_options(config_hash, state)
          
        
      
        

          

            22
            

            
              
            

                  hash = {}
          
        
      
        

          

            22
            

            
              
            

                  SimpleCovSmallBadge::Configuration.options.merge(config_hash)
          
        
      
        

          

            
            

            
              
            

                                                    .map do |key, value|
          
        
      
        

          

            462
            

            
              
            

                    key = key.to_s
          
        
      
        

          

            
            

            
              
            

                             .sub(/^coverage_background_#{state}/, 'value_background')
          
        
      
        

          

            
            

            
              
            

                             .to_sym
          
        
      
        

          

            462
            

            
              
            

                    key = key.to_s.sub(/^coverage_/, 'value_').to_sym
          
        
      
        

          

            462
            

            
              
            

                    hash[key] = value
          
        
      
        

          

            
            

            
              
            

                  end
          
        
      
        

          

            22
            

            
              
            

                  hash
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                def mock_result(total_cov, groups_hash = {})
          
        
      
        

          

            13
            

            
              
            

                  result_double = instance_double('Result')
          
        
      
        

          

            13
            

            
              
            

                  allow(result_double)
          
        
      
        

          

            
            

            
              
            

                    .to receive_message_chain('source_files.covered_percent')
          
        
      
        

          

            
            

            
              
            

                    .and_return(total_cov)
          
        
      
        

          

            13
            

            
              
            

                  allow(result_double).to receive('groups').and_return(groups_hash)
          
        
      
        

          

            13
            

            
              
            

                  result_double
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

            
          
        
      
        

          

            1
            

            
              
            

                def mock_result_group(cov, strength = 1)
          
        
      
        

          

            9
            

            
              
            

                  group_double = instance_double('Group')
          
        
      
        

          

            9
            

            
              
            

                  allow(group_double)
          
        
      
        

          

            
            

            
              
            

                    .to receive('covered_percent')
          
        
      
        

          

            
            

            
              
            

                    .and_return(cov)
          
        
      
        

          

            9
            

            
              
            

                  allow(group_double)
          
        
      
        

          

            
            

            
              
            

                    .to receive('covered_strength')
          
        
      
        

          

            
            

            
              
            

                    .and_return(strength)
          
        
      
        

          

            9
            

            
              
            

                  group_double
          
        
      
        

          

            
            

            
              
            

                end
          
        
      
        

          

            
            

            
              
            

              end
          
        
      
        

          

            
            

            
              
            

            end