def __create_product(product_kwargs):
""" Create a product according to the provided arguments. """
art_kwargs = product_kwargs.pop("art", dict())
if art_kwargs:
component = domain.Product(**art_kwargs)
product_kwargs["art"] = component
return domain.Product(**product_kwargs)
def test_sonar_id_empty(self):
""" Test that the Sonar id of a product can be retrieved. """
sonar = 'Sonar'
project = domain.Project('organization', metric_sources={metric_source.Sonar: sonar})
product = domain.Product(metric_source_ids={sonar: ''})
quality_report = report.QualityReport(project)
self.assertEqual((None, ''), quality_report.sonar_id(product))
def setUp(self):
sonar = FakeSonar()
project = domain.Project(metric_sources={metric_source.Sonar: sonar})
product = domain.Product(short_name='PR',
name='FakeSubject',
metric_source_ids={sonar: 'sonar id'})
self._metric = metric.JavaDuplication(subject=product, project=project)
def setUp(self):
sonar = FakeSonar()
subject = domain.Product(short_name='PR',
name='FakeSubject',
metric_source_ids={sonar: "sonar id"})
project = domain.Project(metric_sources={metric_source.Sonar: sonar})
self._metric = metric.NoSonar(subject=subject, project=project)
def test_prefix_product(self):
""" Test that the prefix contains the version of the products that not have been released
(i.e. the version of the trunk). """
report = fake_report.Report([domain.Product()])
self.assertEqual(
'{"Product-version": "2", "date": "2012-01-01 12:00:00", ',
self.__formatter.prefix(report))
def test_extra_info(self):
""" Test that correct extra info is returned."""
subversion = MagicMock()
subversion.unmerged_branches.return_value = [
metric_source.Branch("some_branch", 22,
datetime.datetime(2018, 1, 1))
]
subversion.branch_folder_for_branch.return_value = "http://some_branch"
project = domain.Project(
metric_sources={metric_source.VersionControlSystem: subversion})
subject = domain.Product(metric_source_ids={subversion: '_'})
expected_result = domain.ExtraInfo(
link="Branch",
comment="Aantal ongemergde revisies__detail-column-number",
date_last_change="Datum laatste wijziging__detail-column-number")
expected_result.data = \
[{"link": {"href": "http://some_branch", "text": "some_branch"}, "comment": 22,
"date_last_change": "01-01-2018"}]
obj = metric.UnmergedBranches(project=project, subject=subject)
result = obj.extra_info()
self.assertDictEqual(expected_result.headers, result.headers)
self.assertEqual(expected_result.data, result.data)
self.assertEqual('Niet gemergde branches', result.title)
def setUp(self):
with patch.object(metric_source.Sonar, 'version_number') as mock_version_number:
mock_version_number.return_value = '6.3'
sonar = metric_source.Sonar('unimportant')
project = domain.Project(metric_sources={metric_source.Sonar: sonar})
subject = domain.Product(short_name='PR', name='FakeSubject', metric_source_ids={sonar: 'sonar id'})
self._metric = metric.ProductLOC(subject=subject, project=project)
def test_is_perfect(self):
""" Test that the metric is perfect when the number of violations is zero. """
sonar = FakeSonar()
project = domain.Project(metric_sources={metric_source.Sonar: sonar})
product = domain.Product(metric_source_ids={sonar: "sonar id"})
violations = self.metric_class(subject=product, project=project)
self.assertEqual('perfect', violations.status())
def test_vcs_id_when_no_metric_source_id(self):
""" Test that the empty VCS id is retrieved when there is no metric source id """
vcs = 'VCS'
project = domain.Project('organization', metric_sources={metric_source.VersionControlSystem: vcs})
product = domain.Product(metric_source_ids={})
quality_report = report.QualityReport(project)
self.assertEqual((None, ''), quality_report.vcs_id(product))
def test_vcs_id(self):
""" Test that the VCS id can be retrieved. """
vcs = 'VCS'
project = domain.Project('organization', metric_sources={metric_source.VersionControlSystem: vcs})
product = domain.Product(metric_source_ids={vcs: 'vcs_id'})
quality_report = report.QualityReport(project)
self.assertEqual(('VCS', 'vcs_id'), quality_report.vcs_id(product))
def test_report_without_metric_source(self):
""" Test the report without a metric source. """
self.assertEqual(
'De hoeveelheid ongemergde branches van <no name> kon niet gemeten worden omdat de bron '
'VersionControlSystem niet is geconfigureerd.',
metric.UnmergedBranches(subject=domain.Product(),
project=domain.Project()).report())
def test_multiple_metric_sources(self):
""" Test that the correct metric source id is returned when there are multiple metric source instances. """
MetricUnderTest.metric_source_class = metric_source.Birt
project = domain.Project(metric_sources={metric_source.Birt: ['Birt1', 'Birt2']})
product = domain.Product(metric_source_ids={'Birt2': 'birt id'})
# pylint: disable=protected-access
self.assertEqual('birt id', MetricUnderTest(project=project, subject=product)._metric_source_id)
MetricUnderTest.metric_source_class = None
def test_no_matching_metric_source(self):
""" Test that no metric source id is returned when there is no metric source instance for the product. """
MetricUnderTest.metric_source_class = metric_source.Birt
project = domain.Project(metric_sources={metric_source.Birt: ['Birt1']})
product = domain.Product(metric_source_ids={'Birt2': 'birt id'})
# pylint: disable=protected-access
self.assertFalse(MetricUnderTest(project=project, subject=product)._metric_source_id)
MetricUnderTest.metric_source_class = None
def test_product(self):
""" Test that the report has two sections when we add a product:
one for the product itself, and one for meta metrics. """
project = domain.Project()
project.add_product(
domain.Product(short_name='FP',
requirements=[requirement.CodeQuality]))
self.assertEqual(2, len(report.QualityReport(project).sections()))
def test_comment_urls_no_ignored_branches(self):
""" Test the comment urls when there are no ignored branches. """
product = domain.Product(
short_name='Product',
metric_source_ids={self.__subversion: 'http://svn/trunk/foo/'})
unmerged_branches = metric.UnmergedBranches(subject=product,
project=self.__project)
self.assertEqual({}, unmerged_branches.comment_urls())
def setUp(self): # pylint: disable=invalid-name,missing-docstring
self.__nr_violations = 51
self.__sonar = FakeSonar(blocker_violations=self.__nr_violations,
critical_violations=self.__nr_violations,
major_violations=self.__nr_violations)
project = domain.Project(metric_sources={metric_source.Sonar: self.__sonar})
self.__subject = domain.Product(short_name='PR', name='FakeSubject',
metric_source_ids={self.__sonar: "sonar id"})
self._metric = self.metric_class(subject=self.__subject, project=project)
def setUp(self):
self.__metric_source = domain.MetricSource()
self.__subject = domain.Product(
name='Product',
metric_source_ids={self.__metric_source: 'http://url'})
self.__project = domain.Project(
metric_sources={domain.MetricSource: self.__metric_source})
self.__metric = MetricSourceAgeMetricUnderTest(self.__subject,
project=self.__project)
def setUp(self):
with patch.object(metric_source.Sonar, 'version_number') as mock_version_number:
mock_version_number.return_value = '6.3'
self.__sonar = metric_source.Sonar('unimportant')
project = domain.Project(
metric_sources={metric_source.Sonar: self.__sonar, metric_source.History: metric_source.CompactHistory('')},
metric_options={metric.TotalLOC: dict(target=1000000, low_target=2000000)},
metric_source_ids={self.__sonar: 'dummy'})
product1 = domain.Product(short_name='PR1', name='FakeSubject1', metric_source_ids={self.__sonar: 'sonar id1'})
product2 = domain.Product(short_name='PR2', name='FakeSubject2', metric_source_ids={self.__sonar: 'sonar id2'})
product_without_sonar_id = domain.Product(short_name='PW', name='ProductWithoutSonarId')
test_product = domain.Product(short_name='TP', is_main=False, metric_source_ids={self.__sonar: 'sonar id'})
project.add_product(product1)
project.add_product(product2)
# Add products that should be ignored:
project.add_product(product_without_sonar_id)
project.add_product(test_product)
self.__metric = metric.TotalLOC(subject=project, project=project)
def setUp(self):
self.__metric_source = self.metric_source_class_mock()
project = domain.Project(
metric_sources={self.metric_source_class: self.__metric_source})
subject = domain.Product(
short_name='PR',
name='FakeSubject',
metric_source_ids={self.__metric_source: 'id'})
self.__metric = self.metric_class(subject=subject, project=project)
def test_one_metric_source(self):
""" Test that the correct metric source id is returned when there is one metric source instance. """
MetricUnderTest.metric_source_class = metric_source.Birt
metric_source_instance = metric_source.Birt(birt_url='http://birt')
project = domain.Project(metric_sources={metric_source.Birt: metric_source_instance})
product = domain.Product(metric_source_ids={metric_source_instance: 'birt id'})
# pylint: disable=protected-access
self.assertEqual('birt id', MetricUnderTest(project=project, subject=product)._metric_source_id)
MetricUnderTest.metric_source_class = None
def test_url_without_sonar_id(self):
""" Test that the metric has a url when the product has no Sonar id configured. """
with patch.object(metric_source.Sonar,
'version_number') as mock_version_number:
mock_version_number.return_value = '6.3'
sonar = metric_source.Sonar('http://sonar/')
project = domain.Project(metric_sources={metric_source.Sonar: sonar})
product = domain.Product()
self.assertEqual(dict(), SonarMetric(product, project).url())
def setUp(self):
jira = FakeJiraFilter()
self.__project = domain.Project(
metric_sources={metric_source.BugTracker: jira})
self.__product = domain.Product(
metric_source_ids={jira: '1234'},
added_requirements=[requirement.TrackBugs])
self.__metric = metric.OpenBugs(project=self.__project,
subject=self.__product)
def test_url(self):
""" Test the url. """
with patch.object(metric_source.Sonar,
'version_number') as mock_version_number:
mock_version_number.return_value = '6.3'
sonar = metric_source.Sonar('http://sonar/')
project = domain.Project(metric_sources={metric_source.Sonar: sonar})
product = domain.Product(metric_source_ids={sonar: 'sonar id'})
self.assertEqual({sonar.metric_source_name: sonar.url()},
SonarMetric(product, project).url())
def test_comment_urls_without_metric_source(self):
""" Test the comment urls when the metric source is missing """
subject = domain.Product(metric_options={
metric.UnmergedBranches:
dict(branches_to_ignore=['ignored branch'])
})
self.assertEqual(
{'ignored branch': ''},
metric.UnmergedBranches(subject=subject,
project=domain.Project()).comment_urls())
def test_comment_with_re_only(self):
""" Test that comment for regular expression. """
subject = domain.Product(
metric_options={
metric.UnmergedBranches: dict(
branches_to_ignore_re='feature.*')
})
unmerged_branches = metric.UnmergedBranches(subject=subject,
project=self.__project)
self.assertEqual(
"Branches die voldoen aan de reguliere expressie feature.* zijn genegeerd.",
unmerged_branches.comment())
def test_combined_comment(self):
""" Test that the metric comment is combined with the branch comment. """
subject = domain.Product(
metric_options={
metric.UnmergedBranches:
dict(comment="Comment.", branches_to_include=['branch'])
})
unmerged_branches = metric.UnmergedBranches(subject=subject,
project=self.__project)
self.assertEqual(
"Comment. Alleen deze branches worden bewaakt: branch.",
unmerged_branches.comment())
def test_last_product_change_date(self):
""" Test that the report can retrieve the last changed date of a product. """
class FakeVCS(object): # pylint: disable=too-few-public-methods
""" Fake VCS metric source with a fixed changed date. """
@staticmethod
def last_changed_date(vcs_id): # pylint: disable=unused-argument
""" Return the date the product was last changed. """
return datetime.datetime(2017, 1, 1)
vcs = FakeVCS()
project = domain.Project('organization', metric_sources={metric_source.VersionControlSystem: vcs})
product = domain.Product(metric_source_ids={vcs: 'vcs_id'})
quality_report = report.QualityReport(project)
self.assertEqual(datetime.datetime(2017, 1, 1), quality_report.latest_product_change_date(product))
def test_technical_debt(self, mock_ncloc):
""" Test that technical debt can be specified via the project. """
project = domain.Project(
metric_sources={metric_source.Sonar: self.__sonar, metric_source.History: MagicMock()},
metric_source_ids={self.__sonar: "dummy"},
metric_options={metric.TotalLOC: dict(target=100, low_target=110,
debt_target=domain.TechnicalDebtTarget(150))})
product = domain.Product(short_name='PR', name='FakeSubject', metric_source_ids={self.__sonar: 'sonar id'})
project.add_product(product)
total_loc = metric.TotalLOC(subject=project, project=project)
mock_ncloc.return_value = 111
self.assertEqual('grey', total_loc.status())
def test_extra_info_no_unmerged_branches(self):
""" Test that None is returned as extra info when there are no unmerged branches."""
subversion = MagicMock()
subversion.unmerged_branches.return_value = {}
subversion.branch_folder_for_branch.return_value = "unimportant"
project = domain.Project(
metric_sources={metric_source.VersionControlSystem: subversion})
subject = domain.Product(metric_source_ids={subversion: '_'})
obj = metric.UnmergedBranches(project=project, subject=subject)
result = obj.extra_info()
self.assertIsNone(result)
def setUp(self):
self.__subversion = FakeSubversion()
self.__project = domain.Project(
metric_sources={
metric_source.VersionControlSystem: self.__subversion
})
self.__subject = domain.Product(
name='Product',
short_name='PR',
metric_source_ids={self.__subversion: 'http://svn/trunk/foo/'},
metric_options={
metric.UnmergedBranches:
dict(branches_to_include=['branch', 'ignored branch'],
branches_to_ignore=['ignored branch'],
branches_to_ignore_re='feature.*')
})
self.__metric = metric.UnmergedBranches(subject=self.__subject,
project=self.__project)
