Merge pull request #18 from cqse/path_prefix_option

Path prefix option

Author: AnonymFx

teamscale_precommit_client/precommit_client.py

@@ -1,37 +1,43 @@
 from __future__ import absolute_import
-from __future__ import unicode_literals
 from __future__ import print_function
+from __future__ import unicode_literals
 
+import argparse
+import copy
 import datetime
-import time
 import os
 import sys
-import argparse
+import time
 
-from teamscale_precommit_client.git_utils import get_current_branch, get_current_timestamp
-from teamscale_precommit_client.git_utils import get_changed_files_and_content, get_deleted_files
-from teamscale_precommit_client.data import PreCommitUploadData
 from teamscale_client import TeamscaleClient
+
 from teamscale_precommit_client.client_configuration_utils import get_teamscale_client_configuration
+from teamscale_precommit_client.data import PreCommitUploadData
+from teamscale_precommit_client.git_utils import get_changed_files_and_content, get_deleted_files
+from teamscale_precommit_client.git_utils import get_current_branch, get_current_timestamp
 from teamscale_precommit_client.git_utils import get_repo_root_from_file_in_repo
 
 # Filename of the precommit configuration. The client expects this config file at the root of the repository.
 PRECOMMIT_CONFIG_FILENAME = '.teamscale-precommit.config'
+DEFAULT_PATH_PREFIX = ''
 
 
 class PrecommitClient:
     """Client for precommit analysis"""
     # Number of seconds the client waits until fetching precommit results from the server.
     PRECOMMIT_WAITING_TIME_IN_SECONDS = 2
 
-    def __init__(self, teamscale_config, repository_path, analyzed_file=None, verify=True,
+    def __init__(self, teamscale_config, repository_path, path_prefix=DEFAULT_PATH_PREFIX, analyzed_file=None,
+                 verify=True,
                  omit_links_to_findings=False, exclude_findings_in_changed_code=False, fetch_existing_findings=False,
                  fetch_all_findings=False, fetch_existing_findings_in_changes=False, fail_on_red_findings=False,
                  log_to_stderr=False):
         """Constructor"""
         self.teamscale_client = TeamscaleClient(teamscale_config.url, teamscale_config.username,
                                                 teamscale_config.access_token, teamscale_config.project_id, verify)
         self.repository_path = repository_path
+        # calling os.path.join ensures a tailing '/'
+        self.path_prefix = os.path.join(path_prefix, '')
         self.analyzed_file = analyzed_file
         self.omit_links_to_findings = omit_links_to_findings
         self.exclude_findings_in_changed_code = exclude_findings_in_changed_code
@@ -58,7 +64,7 @@ def run(self):
 
         if self.changed_files or self.deleted_files:
             self._do_precommit_analysis()
-            self._print_precommit_results_as_error_string() # Always uses precommit branch
+            self._print_precommit_results_as_error_string()  # Always uses precommit branch
         elif not self.fetch_all_findings and not self.fetch_existing_findings:
             print("No changed files found. Did you forget to `git add` new files?")
             exit(0)
@@ -104,11 +110,22 @@ def _upload_precommit_data(self):
         self.teamscale_client.branch = self.current_branch
 
         print("Uploading changes on branch '%s' in '%s'..." % (self.current_branch, self.repository_path))
-        precommit_data = PreCommitUploadData(uniformPathToContentMap=self.changed_files,
-                                             deletedUniformPaths=self.deleted_files)
+        changed_files_with_path_prefix = self._apply_path_prefix_to_changed_files()
+        deleted_files_with_path_prefix = self._apply_path_prefix_to_deleted_files()
+        precommit_data = PreCommitUploadData(uniformPathToContentMap=changed_files_with_path_prefix,
+                                             deletedUniformPaths=deleted_files_with_path_prefix)
         self.teamscale_client.upload_files_for_precommit_analysis(
             datetime.datetime.fromtimestamp(self.parent_commit_timestamp), precommit_data)
 
+    def _apply_path_prefix_to_changed_files(self):
+        map_with_prefixes = {}
+        for key in self.changed_files.keys():
+            map_with_prefixes[self.path_prefix + key] = self.changed_files[key]
+        return map_with_prefixes
+
+    def _apply_path_prefix_to_deleted_files(self):
+        return list(map(lambda path: self.path_prefix + path, self.deleted_files))
+
     def _wait_and_get_precommit_result(self):
         """Gets the current precommit results. Waits synchronously until server is ready. """
         self.added_findings, self.removed_findings, self.findings_in_changed_code = \
@@ -182,14 +199,16 @@ def _format_findings(self, findings, branch):
         if len(findings) == 0:
             return ['> No findings.']
 
-        sorted_findings = sorted(findings)
+        findings_without_path_prefix = list(
+            map(lambda finding: self._copy_finding_without_path_prefix(finding), findings))
+        sorted_findings = sorted(findings_without_path_prefix)
         return [self._format_message(finding) for finding in sorted_findings]
 
     def _format_message(self, finding):
         location = os.path.join(self.repository_path, finding.uniformPath)
         severity = self._get_finding_severity_message(finding=finding)
         link = '%s&t=%s' % (self.teamscale_client.get_finding_url(finding),
-                self.teamscale_client._get_timestamp_parameter(timestamp=None))
+                            self.teamscale_client._get_timestamp_parameter(timestamp=None))
 
         message = finding.message
         if not self.omit_links_to_findings:
@@ -201,6 +220,15 @@ def _format_message(self, finding):
 
         return '%s | (%s)' % (message, link)
 
+    def _copy_finding_without_path_prefix(self, finding):
+        finding_without_path_prefix = copy.deepcopy(finding)
+        finding_without_path_prefix.uniformPath = self._remove_path_prefix(finding_without_path_prefix.uniformPath)
+        return finding_without_path_prefix
+
+    def _remove_path_prefix(self, path):
+        if path.startswith(self.path_prefix):
+            return path[len(self.path_prefix):]
+        return path
 
     @staticmethod
     def _get_finding_severity_message(finding):
@@ -243,6 +271,10 @@ def _parse_args():
     parser.add_argument('--log-to-stderr', dest='log_to_stderr', action='store_true',
                         help='When this option is set, any finding will be logged to stderr instead of stdout: '
                              '(default: False)')
+    parser.add_argument('--path-prefix', metavar='PATH_PREFIX', type=str,
+                        help='Path prefix on Teamscale as configured with "Prepend repository identifier" or '
+                             '"Path prefix transformation". Please use "/" to separate folders.',
+                        default=DEFAULT_PATH_PREFIX)
     return parser.parse_args()
 
 
@@ -261,7 +293,8 @@ def _configure_precommit_client(parsed_args):
     repo_path = get_repo_root_from_file_in_repo(os.path.normpath(path_to_file_in_repo))
     config_file = os.path.join(repo_path, PRECOMMIT_CONFIG_FILENAME)
     config = get_teamscale_client_configuration(config_file)
-    return PrecommitClient(config, repository_path=repo_path, analyzed_file=path_to_file_in_repo,
+    return PrecommitClient(config, repository_path=repo_path, path_prefix=parsed_args.path_prefix,
+                           analyzed_file=path_to_file_in_repo,
                            verify=parsed_args.verify, omit_links_to_findings=parsed_args.omit_links_to_findings,
                            exclude_findings_in_changed_code=parsed_args.exclude_findings_in_changed_code,
                            fetch_existing_findings=parsed_args.fetch_existing_findings,

tests/precommit_test.py

@@ -1,6 +1,8 @@
-import responses
 import re
 import sys
+from io import StringIO
+
+import responses
 
 # The mock package is only available from Python 3.3 onwards. Thank you, Python.
 if sys.version_info >= (3, 3):
@@ -11,6 +13,7 @@
 from unittest import TestCase
 from teamscale_client.teamscale_client_config import TeamscaleClientConfig
 from teamscale_precommit_client import PrecommitClient
+from teamscale_precommit_client.precommit_client import DEFAULT_PATH_PREFIX
 from teamscale_client.utils import to_json
 
 URL = 'http://localhost:8080'
@@ -19,7 +22,9 @@
 USERNAME = 'johndoe'
 ACCESS_TOKEN = 'secret'
 REPO_PATH = 'path/to/repo/'
-ANALYZED_FILE = REPO_PATH + 'file.ext'
+ANALYZED_FILE_NAME = 'file.ext'
+ANALYZED_FILE_PATH = REPO_PATH + ANALYZED_FILE_NAME
+DELETED_FILE_NAME = 'deletedFile.ext'
 CURRENT_BRANCH = 'my_feature_branch'
 
 
@@ -131,22 +136,56 @@ def test_get_added_and_existing_findings_in_changes_for_changes(self):
         self.assert_findings_ids(self.precommit_client.findings_in_changed_code, [])
         self.assert_findings_ids(self.precommit_client.existing_findings, [4, 5, 6, 7])
 
+    @responses.activate
+    def test_adding_path_prefix(self):
+        path_prefix = 'prefix'
+        self.precommit_client = self._get_precommit_client(self._get_changed_file(),
+                                                           [DELETED_FILE_NAME], path_prefix=path_prefix)
+        self.mock_precommit_findings_churn(added_findings=[1], path_prefix=path_prefix + '/')
+        self.precommit_client.run()
+
+        changed_file_path_with_prefix = path_prefix + '/' + ANALYZED_FILE_NAME
+        deleted_file_path_with_prefix = path_prefix + '/' + DELETED_FILE_NAME
+        precommit_request = next(call.request for call in responses.calls if call.request.method == 'PUT')
+
+        # Check if the path prefix was applied and sent correctly in the request's body
+        self.assertIn(changed_file_path_with_prefix, precommit_request.body)
+        self.assertIn(deleted_file_path_with_prefix, precommit_request.body)
+
+    @responses.activate
+    def test_stripping_path_prefix(self):
+        path_prefix = 'prefix'
+        self.precommit_client = self._get_precommit_client(self._get_changed_file(),
+                                                           [DELETED_FILE_NAME], path_prefix=path_prefix)
+        self.mock_precommit_findings_churn(added_findings=[1], path_prefix=path_prefix + '/')
+
+        captured_output = StringIO()
+        sys.stdout = captured_output
+
+        self.precommit_client.run()
+
+        # Check if the path prefix was applied and sent correctly in the request's body
+        self.assertNotIn(path_prefix, captured_output.getvalue())
+
     @staticmethod
-    def mock_precommit_findings_churn(added_findings=None, findings_in_changed_code=None, removed_findings=None):
+    def mock_precommit_findings_churn(added_findings=None, findings_in_changed_code=None, removed_findings=None,
+                                      path_prefix=DEFAULT_PATH_PREFIX):
         """Mocks returning the findings churn for the given added, removed, and findings in changed code.
         Findings can be provided as list of integers each of which represents a finding instance."""
-        precommit_response = to_json(PrecommitClientTest._get_findings_churn(added_findings, findings_in_changed_code,
-                                                                             removed_findings))
+        precommit_response = to_json(
+            PrecommitClientTest._get_findings_churn(path_prefix, added_findings, findings_in_changed_code,
+                                                    removed_findings))
         responses.add(responses.PUT, PrecommitClientTest.get_project_service_mock('pre-commit'), body=SUCCESS,
                       status=200)
         responses.add(responses.GET, PrecommitClientTest.get_project_service_mock('pre-commit'),
                       body=precommit_response, status=200, content_type="application/json", )
 
     @staticmethod
-    def mock_existing_findings(branch, existing_findings=None):
+    def mock_existing_findings(branch, existing_findings=None, path_prefix=DEFAULT_PATH_PREFIX):
         """Mocks returning the given existing findings for the provided branch.
         Findings can be provided as list of integers each of which represents a finding instance."""
-        existing_findings_from_current_branch = to_json(PrecommitClientTest._get_findings_as_dicts(existing_findings))
+        existing_findings_from_current_branch = to_json(
+            PrecommitClientTest._get_findings_as_dicts(existing_findings, path_prefix))
         responses.add(responses.GET, PrecommitClientTest.get_project_service_mock('findings', branch),
                       body=existing_findings_from_current_branch, status=200,
                       content_type="application/json", )
@@ -162,13 +201,15 @@ def get_project_service_mock(service_id, branch=''):
         return re.compile(r'%s/p/%s/%s/.*%s.*' % (URL, PROJECT, service_id, branch))
 
     @staticmethod
-    def _get_precommit_client(changed_files, deleted_files, fetch_existing_findings=False,
+    def _get_precommit_client(changed_files, deleted_files, path_prefix=DEFAULT_PATH_PREFIX,
+                              fetch_existing_findings=False,
                               fetch_existing_findings_in_changes=False):
         """Gets a precommit client some of whose methods are mocked out for testing."""
         responses.add(responses.GET, PrecommitClientTest.get_global_service_mock('service-api-info'), status=200,
                       content_type="application/json", body='{"apiVersion": 6}')
         precommit_client = PrecommitClient(PrecommitClientTest._get_precommit_client_config(),
-                                           repository_path=REPO_PATH, analyzed_file=ANALYZED_FILE, verify=False,
+                                           repository_path=REPO_PATH, path_prefix=path_prefix,
+                                           analyzed_file=ANALYZED_FILE_PATH, verify=False,
                                            omit_links_to_findings=True, fetch_existing_findings=fetch_existing_findings,
                                            fetch_existing_findings_in_changes=fetch_existing_findings_in_changes)
         precommit_client._calculate_modifications = Mock()
@@ -195,35 +236,42 @@ def _get_no_changed_files():
     @staticmethod
     def _get_changed_file():
         """Helper that returns a single changed path and content."""
-        return {ANALYZED_FILE: 'def foo():\n  pass'}
+        return {ANALYZED_FILE_NAME: 'def foo():\n  pass'}
 
     @staticmethod
     def _get_no_deleted_files():
         """Helper that provides an empty list of deleted files."""
         return []
 
     @staticmethod
-    def _get_findings_churn(added_findings=None, findings_in_changed_code=None, removed_findings=None):
+    def _get_findings_churn(path_prefix, added_findings=None, findings_in_changed_code=None, removed_findings=None):
         """Returns the precommit findings churn as dict for the provided findings number list.
         Findings can be provided as list of integers each of which represents a finding instance."""
-        return {"addedFindings": PrecommitClientTest._get_findings_as_dicts(added_findings),
-                "findingsInChangedCode": PrecommitClientTest._get_findings_as_dicts(findings_in_changed_code),
-                'removedFindings': PrecommitClientTest._get_findings_as_dicts(removed_findings)}
+        return {"addedFindings": PrecommitClientTest._get_findings_as_dicts(added_findings, path_prefix),
+                "findingsInChangedCode": PrecommitClientTest._get_findings_as_dicts(findings_in_changed_code,
+                                                                                    path_prefix),
+                'removedFindings': PrecommitClientTest._get_findings_as_dicts(removed_findings, path_prefix)}
 
     @staticmethod
-    def _get_findings_as_dicts(findings_number_list):
+    def _get_findings_as_dicts(findings_number_list, path_prefix):
         """Transforms a list of integers each of which represents a finding instance into a list of dicts."""
         if not findings_number_list:
             return []
         findings_dicts = []
         for finding_number in findings_number_list:
             findings_dict = {'id': str(finding_number), 'typeId': 'id%i' % finding_number,
                              'message': 'message%i' % finding_number, 'assessment': 'RED',
-                             'location': {'uniformPath': ANALYZED_FILE, 'rawStartLine': finding_number}}
+                             'location': {'uniformPath': path_prefix + ANALYZED_FILE_NAME,
+                                          'rawStartLine': finding_number}}
             findings_dicts.append(findings_dict)
         return findings_dicts
 
     def assert_findings_ids(self, actual_findings, expected_ids):
         """Asserts that the given findings have the specified ids."""
         actual_findings_ids = [int(actual_finding.finding_id) for actual_finding in actual_findings]
         self.assertListEqual(actual_findings_ids, expected_ids)
+
+    def assert_findings_paths(self, actual_findings, expected_paths):
+        """Asserts that the given findings have the specified paths."""
+        actual_findings_paths = [actual_finding.uniformPath for actual_finding in actual_findings]
+        self.assertListEqual(actual_findings_paths, expected_paths)