def test_cc_to_terminal(cc_config, mocker):
reset_mock = mocker.patch('radon.cli.harvest.RESET')
ranks_mock = mocker.patch('radon.cli.harvest.RANKS_COLORS')
c2t_mock = mocker.patch('radon.cli.harvest.cc_to_terminal')
h = harvest.CCHarvester([], cc_config)
h._results = [('a', {'error': 'mystr'}), ('b', {})]
c2t_mock.return_value = (['res'], 9, 3)
ranks_mock.__getitem__.return_value = '<|A|>'
reset_mock.__eq__.side_effect = lambda o: o == '__R__'
results = list(h.to_terminal())
c2t_mock.assert_called_once_with(
{},
cc_config.show_complexity,
cc_config.min,
cc_config.max,
cc_config.total_average,
)
assert results == [
('a', ('mystr', ), {
'error': True
}),
('b', (), {}),
(['res'], (), {
'indent': 1
}),
('\n{0} blocks (classes, functions, methods) analyzed.', (3, ), {}),
(
'Average complexity: {0}{1} ({2}){3}',
('<|A|>', 'A', 3, '__R__'),
{},
),
]
def test_cc_as_md(cc_config, mocker):
d2md_mock = mocker.patch('radon.cli.harvest.dict_to_md')
to_dicts_mock = mocker.MagicMock()
to_dicts_mock.return_value = {'a': {'rank': 'A'}}
h = harvest.CCHarvester([], cc_config)
h._to_dicts = to_dicts_mock
assert h.as_md()
assert d2md_mock.called
d2md_mock.assert_called_with(to_dicts_mock.return_value)
assert to_dicts_mock.call_count == 1
def __init__(self, config, targets):
"""
Instantiate a new Cyclomatic Complexity operator.
:param config: The wily configuration.
:type config: :class:`WilyConfig`
"""
# TODO: Import config for harvester from .wily.cfg
logger.debug(f"Using {targets} with {self.defaults} for CC metrics")
self.harvester = harvesters.CCHarvester(targets, config=Config(**self.defaults))
def test_as_json_xml(self, d2x_mock):
to_dicts_mock = mock.MagicMock()
to_dicts_mock.return_value = {'a': {'rank': 'A'}}
h = harvest.CCHarvester([], self.config)
h._to_dicts = to_dicts_mock
self.assertEqual(h.as_json(), '{"a": {"rank": "A"}}')
h.as_xml()
self.assertTrue(d2x_mock.called)
d2x_mock.assert_called_with(to_dicts_mock.return_value)
self.assertEqual(to_dicts_mock.call_count, 2)
def test_cc_as_json_xml(cc_config, mocker):
d2x_mock = mocker.patch('radon.cli.harvest.dict_to_xml')
to_dicts_mock = mocker.MagicMock()
to_dicts_mock.return_value = {'a': {'rank': 'A'}}
h = harvest.CCHarvester([], cc_config)
h._to_dicts = to_dicts_mock
assert h.as_json() == '{"a": {"rank": "A"}}'
h.as_xml()
assert d2x_mock.called
d2x_mock.assert_called_with(to_dicts_mock.return_value)
assert to_dicts_mock.call_count == 2
def test_gobble(self, cc_mock, sr_mock):
cc_mock.return_value = []
fobj = mock.MagicMock()
fobj.read.return_value = mock.sentinel.one
h = harvest.CCHarvester([], self.config)
h.config.show_closures = True
h.gobble(fobj)
self.assertTrue(fobj.read.called)
cc_mock.assert_called_with(mock.sentinel.one,
no_assert=self.config.no_assert)
sr_mock.assert_called_with([], order=self.config.order)
def test_cc_to_dicts(cc_config, mocker):
c2d_mock = mocker.patch('radon.cli.harvest.cc_to_dict')
c2d_mock.side_effect = lambda i: i
h = harvest.CCHarvester([], cc_config)
sample_results = [('a', [{'rank': 'A'}]), ('b', [{'rank': 'B'}]),
('c', {'error': 'An ERROR!'})]
h._results = sample_results
assert h._to_dicts() == dict(sample_results)
assert c2d_mock.call_count == 2
h.config.min = 'B'
h._results = sample_results[1:]
assert h._to_dicts() == dict(sample_results[1:])
def test_cc_gobble(cc_config, mocker):
sr_mock = mocker.patch('radon.cli.harvest.sorted_results')
cc_mock = mocker.patch('radon.cli.harvest.cc_visit')
cc_mock.return_value = []
fobj = mocker.MagicMock()
fobj.read.return_value = mocker.sentinel.one
h = harvest.CCHarvester([], cc_config)
h.config.show_closures = True
h.gobble(fobj)
assert fobj.read.called
cc_mock.assert_called_with(mocker.sentinel.one,
no_assert=cc_config.no_assert)
sr_mock.assert_called_with([], order=cc_config.order)
def test_to_dicts(self, c2d_mock):
c2d_mock.side_effect = lambda i: i
h = harvest.CCHarvester([], self.config)
sample_results = [('a', [{
'rank': 'A'
}]), ('b', [{
'rank': 'B'
}]), ('c', {
'error': 'An ERROR!'
})]
h._results = sample_results
self.assertEqual(h._to_dicts(), dict(sample_results))
self.assertEqual(c2d_mock.call_count, 2)
h.config.min = 'B'
h._results = sample_results[1:]
self.assertEqual(h._to_dicts(), dict(sample_results[1:]))
def test_to_terminal(self, c2t_mock, ranks_mock, reset_mock):
h = harvest.CCHarvester([], self.config)
h._results = [('a', {'error': 'mystr'}), ('b', {})]
c2t_mock.return_value = (['res'], 9, 3)
ranks_mock.__getitem__.return_value = '<|A|>'
reset_mock.__eq__.side_effect = lambda o: o == '__R__'
results = list(h.to_terminal())
c2t_mock.assert_called_once_with({}, self.config.show_complexity,
self.config.min, self.config.max,
self.config.total_average)
self.assertEqual(results, [
('a', ('mystr', ), {
'error': True
}),
('b', (), {}),
(['res'], (), {
'indent': 1
}),
('\n{0} blocks (classes, functions, methods) analyzed.',
(3, ), {}),
('Average complexity: {0}{1} ({2}){3}',
('<|A|>', 'A', 3, '__R__'), {}),
])
