def test_badge_width_with_long_value_text(self):
"""Test the width of a badge generated with a long text value."""
badge = Badge(label='CppCheck',
value='err: 2 | warn: 9 | info: 99 | style: 365',
default_color='red')
badge.write_badge('test_badge_1.svg', overwrite=True)
self.assertLessEqual(badge.badge_width, 326)
def test_multiple_badges_get_different_mask_id(self):
badges = [
Badge('something',
value='100',
value_suffix='%',
num_padding_chars=0),
Badge('coverage', value='1234567890'),
]
self.assertNotEqual(badges[0].mask_id, badges[1].mask_id)
def create_badge(
self,
ver: str,
badge_file: str,
badge_label: str,
badge_color: str,
) -> None:
"""This functions will create badge as per run results"""
badge = Badge(label=badge_label, value=ver, default_color=badge_color)
badge.write_badge(badge_file, overwrite=True)
def test_multiple_badges_in_one_session(self):
badges = [
Badge('multiple 1',
value='100',
value_suffix='%',
num_padding_chars=0),
Badge('multiple 2', value='1234567890'),
]
self.assertNotEqual(badges[0].badge_width, badges[1].badge_width)
def test_badge_width_with_medium_value_text_zero_pad(self):
"""Test the width of a badge generated with a medium text value."""
badge = Badge(label='medium no padding',
value='89.67%',
default_color='green',
num_padding_chars=0)
badge.write_badge('test_badge_medium_no_padding.svg', overwrite=True)
self.assertLessEqual(badge.badge_width, 156)
def test_badge_width_with_short_value_text_zero_pad(self):
"""Test the width of a badge generated with a short text value."""
badge = Badge(label='short value no padding',
value='1',
default_color='green',
num_padding_chars=0)
badge.write_badge('test_badge_short_no_padding.svg', overwrite=True)
self.assertLessEqual(badge.badge_width, 143)
class Badge(Result):
def __init__(self, filename, png=False, **any_badge_kwargs):
self.badge = AnyBadge(**any_badge_kwargs)
self.filename = filename
self.png = png
def _to(self, dest):
badge_path = dest / "{}.svg".format(self.filename)
self.badge.write_badge(str(badge_path), overwrite=True)
badges = [badge_path]
if self.png:
png_path = dest / "{}.png".format(self.filename)
cairosvg.svg2png(url=str(badge_path), write_to=str(png_path))
badges.append(png_path)
return badges
def get_vulnerabilities_badge(vulnerabilities_report, use_shields=False):
""" return vulnerabilities badge based off of vulnerabilities_report
High - Red
Medium - Orange
Low - Yellow
Undefined - Gray
None - BrightGreen
"""
if use_shields:
color = 'brightgreen'
else:
color = 'green'
value = 'None'
metrics = vulnerabilities_report['metrics']['_totals']
if metrics['SEVERITY.UNDEFINED'] > 0:
color = 'gray'
value = 'Undefined'
if metrics['SEVERITY.LOW'] > 0:
color = 'yellow'
value = 'Low'
if metrics['SEVERITY.MEDIUM'] > 0:
color = 'orange'
value = 'Medium'
if metrics['SEVERITY.HIGH'] > 0:
color = 'red'
value = 'High'
if use_shields:
badge = f'https://img.shields.io/badge/vulnerabilities-{value}-{color}'
else:
badge = Badge('vulnerabilities', value=value, default_color=color)
return badge
def test_str_value_with_threshold_and_default(self):
badge = Badge('label',
value='fred',
thresholds={
'pass': '******',
'fail': 'red'
},
default_color='orange')
self.assertTrue('orange', badge.badge_color)
def get_python_badge(use_shields=False):
""" return badge for python version
"""
value = f'{sys.version_info.major}.{sys.version_info.minor}'
color = 'teal'
if use_shields:
badge = f'https://img.shields.io/badge/python-{value}-{color}'
else:
badge = Badge('python', value=value, default_color=color)
return badge
def generate_badge():
"""cr-badge
Usage: cr-badge [--config <config_file>] <badge_file> <session-file>
Generate badge file.
options:
--config <config_file> Configuration file to use instead of session configuration
"""
arguments = docopt.docopt(generate_badge.__doc__, version='cr-format 0.1')
config_file = arguments['--config']
badge_filename = arguments['<badge_file>']
with use_db(arguments['<session-file>'], WorkDB.Mode.open) as db:
assert isinstance(db, WorkDB)
if config_file:
config = load_config(config_file)
else:
config = db.get_config()
percent = 100 - survival_rate(db)
config = config['badge']
badge = Badge(
label=config['label'],
value=percent,
value_format=config['format'],
thresholds=config['thresholds'],
)
log.info("Generating badge: " + config['format'], percent) # pylint: disable=logging-not-lazy
try:
os.unlink(badge_filename)
except OSError:
pass
badge.write_badge(badge_filename)
def test_invalid_write_path(self):
badge = Badge('label', 'value')
with self.assertRaisesRegexp(
ValueError, r'File location may not be a directory\.'):
badge.write_badge('tests/')
with self.assertRaisesRegexp(
RuntimeError, r'File ".*tests\/exists\.svg" already exists\.'):
badge.write_badge('tests/exists')
badge.write_badge('tests/exists')
def get_complexity_badge(complexity_report,
use_average=False,
use_shields=False):
""" return complexity badge based off of complexity_report
https://radon.readthedocs.io/en/latest/api.html#radon.complexity.cc_rank
1 - 5 : Simple - BrightGreen
6 - 10 : Stable - Olive
11 - 20 : Slight - Yellow
21 - 30 : Complex - Orange
31 - 40 : Alarming - Red
40+ : Unstable - BrightRed
"""
score = complexity_report['highest']['score']
if use_average:
score = complexity_report['average']
if score <= 5:
value = 'Simple'
if use_shields:
color = 'brightgreen'
else:
color = 'green'
elif score <= 10:
value = 'Stable'
color = 'olive'
elif score <= 20:
value = 'Slight'
color = 'yellow'
elif score <= 30:
value = 'Complex'
color = 'orange'
elif score <= 40:
value = 'Alarming'
color = 'red'
else:
value = 'Unstable'
color = 'brightred'
if use_shields:
badge = f'https://img.shields.io/badge/complexity-{value}: {score}-{color}'
badge = badge.replace(' ', '%20')
else:
badge = Badge('complexity',
value=f'{value}: {score}',
default_color=color)
return badge
def get_coverage_badge(coverage, use_shields=False):
""" return coverage badge based off of coverage report
"""
color = 'green'
if coverage < 85:
color = 'yellow'
if coverage < 70:
color = 'orange'
if coverage < 55:
color = 'red'
value = f'{round(coverage, 2)}%'
if use_shields:
badge = f'https://img.shields.io/badge/coverage-{value}-{color}'
badge = badge.replace('%', '%25')
else:
badge = Badge('coverage', value=value, default_color=color)
return badge
def test_padding_label(self):
badge = Badge('label padding',
value='10.01',
num_label_padding_chars=2)
badge.write_badge('test_badge_padding_label.svg', overwrite=True)
def test_version_comparison(self):
# Define thresholds: <3.0.0=red, <3.2.0=orange <999.0.0=green
badge = Badge('Version',
value='1.0.0',
thresholds={
'3.0.0': 'red',
'3.2.0': 'orange',
'999.0.0': 'green'
},
semver=True)
self.assertEqual('red', badge.badge_color)
# Define thresholds: <3.0.0=red, <3.2.0=orange <999.0.0=green
badge = Badge('Version',
value='3.0.0',
thresholds={
'3.0.0': 'red',
'3.2.0': 'orange',
'999.0.0': 'green'
},
semver=True)
self.assertEqual('orange', badge.badge_color)
# Define thresholds: <3.0.0=red, <3.2.0=orange <999.0.0=green
badge = Badge('Version',
value='3.1.0',
thresholds={
'3.0.0': 'red',
'3.2.0': 'orange',
'999.0.0': 'green'
},
semver=True)
self.assertEqual('orange', badge.badge_color)
# Define thresholds: <3.0.0=red, <3.2.0=orange <999.0.0=green
badge = Badge('Version',
value='3.2.0',
thresholds={
'3.0.0': 'red',
'3.2.0': 'orange',
'999.0.0': 'green'
},
semver=True)
self.assertEqual('green', badge.badge_color)
badge = Badge('Version',
value='3.2.1',
thresholds={
'3.0.0': 'red',
'3.2.0': 'orange',
'999.0.0': 'green'
},
semver=True)
self.assertEqual('green', badge.badge_color)
# Define thresholds: <3.0.0=red, <3.2.0=orange <999.0.0=green
badge = Badge('Version',
value='10.20.30',
thresholds={
'3.0.0': 'red',
'3.2.0': 'orange',
'999.0.0': 'green'
},
semver=True)
self.assertEqual('green', badge.badge_color)
# Define thresholds: <3.0.0=red, <13.2.0=orange <999.0.0=green
badge = Badge('Version',
value='14.0.0',
thresholds={
'3.0.0': 'red',
'13.2.0': 'orange',
'999.0.0': 'green'
},
semver=True)
self.assertEqual('green', badge.badge_color)
badge = Badge('Version',
value='12.0.0',
thresholds={
'3.0.0': 'red',
'13.2.0': 'orange',
'999.0.0': 'green'
},
semver=True)
self.assertEqual('orange', badge.badge_color)
def test_badge_equal_label_value_width(self):
"""Test that label and value widths are equal when text is the same."""
badge = Badge(label='a', value='a', num_padding_chars=0)
self.assertEqual(badge.label_width, badge.value_width)
def test_invalid_color(self):
with self.assertRaises(ValueError):
badge = Badge('label', value='fred', default_color='floberry')
_ = badge.badge_color_code
def test_integer_int_value_is_handled_as_integer(self):
badge = Badge('integer', value=1234)
self.assertTrue(badge.value_is_int)
self.assertFalse(badge.value_is_float)
badge.write_badge('test_badge_int.svg', overwrite=True)
def test_repr_svg(self):
badge = Badge('label', 'value')
self.assertEqual(badge.badge_svg_text, badge._repr_svg_())
def test_float_value_is_handled_as_float(self):
badge = Badge('float int', value=1234.1)
self.assertFalse(badge.value_is_int)
self.assertTrue(badge.value_is_float)
badge.write_badge('test_badge_float.svg', overwrite=True)
def test_font_size_repr(self):
badge = Badge('font size', value=10, font_size=10)
badge_repr = repr(badge)
self.assertTrue("font_size=10" in badge_repr)
def test_template_from_file(self):
file = "tests/template.svg"
badge = Badge('template from file', value=file, template=file)
_ = badge.badge_svg_text
def test_font_size(self):
for size in [10, 11, 12]:
badge = Badge('font size', value=size, font_size=size)
badge.write_badge('test_badge_font_size_%s.svg' % size,
overwrite=True)
def test_invalid_font_name(self):
font = 'Invalid font'
with self.assertRaises(ValueError):
_ = Badge('font', value=font, font_name=font)
def test_value_formatting(self):
badge = Badge('value formatting',
value="10",
value_format="%s hits/sec")
self.assertEqual("10 hits/sec", badge.value_text)
def test_float_value_with_zero_decimal(self):
badge = Badge('float with zeros', value='10.00')
self.assertFalse(badge.value_is_int)
self.assertTrue(badge.value_is_float)
badge.write_badge('test_badge_float_zeros.svg', overwrite=True)
def test_badge_equal_split_no_padding(self):
"""Test that the color split is in the middle when label and value are equal width."""
badge = Badge(label='a', value='a', num_padding_chars=0)
self.assertEqual(int(badge.badge_width / 2),
badge.color_split_position)
def __init__(self, filename, png=False, **any_badge_kwargs):
self.badge = AnyBadge(**any_badge_kwargs)
self.filename = filename
self.png = png
def test_padding_value(self):
badge = Badge('value padding',
value='10.01',
num_value_padding_chars=2)
badge.write_badge('test_badge_padding_value.svg', overwrite=True)
