| #!/usr/bin/env python |
| # Copyright 2014 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Unit tests for Copyright Scanner utilities.""" |
| |
| import os |
| import re |
| import sys |
| import unittest |
| |
| test_dir = os.path.dirname(os.path.abspath(__file__)) |
| sys.path.extend([ |
| os.path.normpath(os.path.join(test_dir, '..', '..', 'tools')), |
| os.path.join(test_dir), |
| ]) |
| |
| import find_depot_tools |
| from testing_support.super_mox import SuperMoxTestBase |
| |
| import copyright_scanner |
| |
| class FindCopyrightsTest(SuperMoxTestBase): |
| def setUp(self): |
| SuperMoxTestBase.setUp(self) |
| self.input_api = self.mox.CreateMockAnything() |
| self.input_api.re = re |
| self.input_api.os_path = os.path |
| self.input_api.os_walk = os.walk |
| |
| def ShouldMatchReferenceOutput(self, test_data, expected_output): |
| for data in test_data: |
| self.input_api.ReadFile = lambda _1, _2: data |
| actual_output = copyright_scanner.FindCopyrights(self.input_api, '', ['']) |
| self.assertEqual( |
| expected_output, |
| actual_output, |
| 'Input """\n%s""", expected output: "%s", actual: "%s"' % \ |
| (data, expected_output, actual_output)); |
| |
| def testCopyrightedFiles(self): |
| test_data = [ |
| '// (c) 2014 Google Inc.\n//\n// (a) One\n//\n// (b) Two\n//\n', |
| 'Copyright 2014 Google Inc.\n', |
| 'Copr. 2014 Google Inc.', |
| '\xc2\xa9 2014 Google Inc.', |
| 'Copyright 2014 Google Inc.' |
| ] |
| self.ShouldMatchReferenceOutput(test_data, [['2014 Google Inc.']]) |
| |
| def testGeneratedFiles(self): |
| test_data = [ |
| 'ALL CHANGES MADE IN THIS FILE WILL BE LOST\nCopyright 2014 Google\n', |
| 'GENERATED FILE. DO NOT EDIT\nCopyright 2014 Google\n', |
| 'GENERATED. DO NOT DELETE THIS FILE.\nCopyright 2014 Google\n', |
| 'DO NOT EDIT\nCopyright 2014 Google\n', |
| 'DO NOT DELETE THIS FILE\nCopyright 2014 Google\n', |
| 'All changes made in this file will be lost\nCopyright 2014 Google\n', |
| 'Automatically generated file\nCopyright 2014 Google\n', |
| 'Synthetically generated dummy file\nCopyright 2014 Google\n', |
| 'Generated data (by gnugnu)\nCopyright 2014 Google\n' |
| ] |
| self.ShouldMatchReferenceOutput(test_data, [['GENERATED FILE']]) |
| |
| def testNonCopyrightedFiles(self): |
| test_data = [ |
| 'std::cout << "Copyright 2014 Google"\n', |
| '// Several points can be made:\n//\n// (a) One\n//\n// (b) Two\n' |
| '//\n// (c) Three\n//\n', |
| 'See \'foo\' for copyright information.\n', |
| 'See \'foo\' for the copyright notice.\n', |
| 'See \'foo\' for the copyright and other things.\n' |
| ] |
| self.ShouldMatchReferenceOutput(test_data, [['*No copyright*']]) |
| |
| def testNonGeneratedFiles(self): |
| test_data = [ |
| 'This file was prohibited from being generated.\n', |
| 'Please do not delete our files! They are valuable to us.\n', |
| 'Manually generated from dice rolls.\n', |
| '"""This Python script produces generated data\n"""\n', |
| '\'\'\'This Python script produces generated data\n\'\'\'\n' |
| ] |
| self.ShouldMatchReferenceOutput(test_data, [['*No copyright*']]) |
| |
| |
| class FindFilesTest(SuperMoxTestBase): |
| def setUp(self): |
| SuperMoxTestBase.setUp(self) |
| self.input_api = self.mox.CreateMockAnything() |
| self.input_api.re = re |
| self.input_api.os_path = os.path |
| |
| def testFilesAsStartPaths(self): |
| self.input_api.os_path.isfile = lambda _: True |
| input_files = [ |
| 'a', |
| 'a.cc', |
| 'a.txt', |
| 'foo/a', |
| 'foo/a.cc', |
| 'foo/a.txt', |
| 'third_party/a', |
| 'third_party/a.cc', |
| 'third_party/a.txt', |
| 'foo/third_party/a', |
| 'foo/third_party/a.cc' |
| 'foo/third_party/a.txt', |
| ] |
| root_dir = '/src' |
| actual = copyright_scanner.FindFiles( |
| self.input_api, root_dir, input_files, ['']) |
| self.assertEqual(['a.cc', 'foo/a.cc'], actual) |
| actual = copyright_scanner.FindFiles( |
| self.input_api, root_dir, input_files, ['third_party']) |
| self.assertEqual(['a.cc', 'foo/a.cc'], actual) |
| actual = copyright_scanner.FindFiles( |
| self.input_api, root_dir, input_files, ['foo']) |
| self.assertEqual(['a.cc'], actual) |
| actual = copyright_scanner.FindFiles( |
| self.input_api, root_dir, input_files, ['foo', 'third_party']) |
| self.assertEqual(['a.cc'], actual) |
| actual = copyright_scanner.FindFiles( |
| self.input_api, root_dir, input_files, ['foo/third_party']) |
| self.assertEqual(['a.cc', 'foo/a.cc'], actual) |
| |
| def testDirAsStartPath(self): |
| self.input_api.os_path.isfile = lambda _: False |
| join = self.input_api.os_path.join |
| normpath = self.input_api.os_path.normpath |
| root_dir = '/src' |
| scan_from = '.' |
| base_path = join(root_dir, scan_from) |
| |
| def mock_os_walk(path): |
| return lambda _: [(join(base_path, path), [''], ['a', 'a.cc', 'a.txt'])] |
| |
| self.input_api.os_walk = mock_os_walk('') |
| actual = map(normpath, copyright_scanner.FindFiles( |
| self.input_api, root_dir, [scan_from], [''])) |
| self.assertEqual(['a.cc'], actual) |
| |
| self.input_api.os_walk = mock_os_walk('third_party') |
| actual = map(normpath, copyright_scanner.FindFiles( |
| self.input_api, root_dir, [scan_from], [''])) |
| self.assertEqual([], actual) |
| |
| self.input_api.os_walk = mock_os_walk('foo') |
| actual = map(normpath, copyright_scanner.FindFiles( |
| self.input_api, root_dir, [scan_from], [''])) |
| self.assertEqual(['foo/a.cc'], actual) |
| |
| self.input_api.os_walk = mock_os_walk('foo') |
| actual = map(normpath, copyright_scanner.FindFiles( |
| self.input_api, root_dir, [scan_from], ['foo'])) |
| self.assertEqual([], actual) |
| |
| self.input_api.os_walk = mock_os_walk('foo/bar') |
| actual = map(normpath, copyright_scanner.FindFiles( |
| self.input_api, root_dir, [scan_from], ['foo'])) |
| self.assertEqual([], actual) |
| |
| self.input_api.os_walk = mock_os_walk('foo/third_party') |
| actual = map(normpath, copyright_scanner.FindFiles( |
| self.input_api, root_dir, [scan_from], [''])) |
| self.assertEqual([], actual) |
| |
| self.input_api.os_walk = mock_os_walk('foo/third_party') |
| actual = map(normpath, copyright_scanner.FindFiles( |
| self.input_api, root_dir, [scan_from], ['foo/third_party'])) |
| self.assertEqual([], actual) |
| |
| |
| class AnalyzeScanResultsTest(SuperMoxTestBase): |
| def setUp(self): |
| SuperMoxTestBase.setUp(self) |
| self.input_api = self.mox.CreateMockAnything() |
| self.input_api.os_path = os.path |
| |
| def testAnalyzeScanResults(self): |
| # Tests whitelisted vs. current files state logic. |
| # |
| # Whitelisted - in whitelist, and contains 3rd party code => OK |
| # Missing - in whitelist, but doesn't exist |
| # Stale - in whitelist, but is clean |
| # Unknown - not in whitelist, but contains 3rd party code |
| self.input_api.os_path.isfile = lambda x: x != 'Missing' |
| self.assertEqual( |
| (['Unknown'], ['Missing'], ['Stale']), |
| copyright_scanner.AnalyzeScanResults(self.input_api, \ |
| ['Whitelisted', 'Missing', 'Stale'], ['Whitelisted', 'Unknown'])) |
| |
| |
| class ScanAtPresubmitTest(SuperMoxTestBase): |
| def setUp(self): |
| SuperMoxTestBase.setUp(self) |
| self.input_api = self.mox.CreateMockAnything() |
| self.input_api.re = re |
| self.input_api.os_path = os.path |
| self.output_api = self.mox.CreateMockAnything() |
| def tearDown(self): |
| self.mox.UnsetStubs() |
| SuperMoxTestBase.tearDown(self) |
| |
| class AffectedFileMock(object): |
| def __init__(self, local_path, action): |
| self._local_path = local_path |
| self._action = action |
| def LocalPath(self): |
| return self._local_path |
| def Action(self): |
| return self._action |
| |
| def CreateAffectedFilesFunc(self, paths_and_actions): |
| result = [] |
| for i in range(0, len(paths_and_actions), 2): |
| result.append(ScanAtPresubmitTest.AffectedFileMock( |
| paths_and_actions[i], paths_and_actions[i + 1])) |
| return lambda: result |
| |
| def CreateDoScanAtPresubmitFunc(self): |
| self._whitelisted_files = None |
| self._files_to_check = None |
| def ScanAtPresubmitStub(_, whitelisted, to_check): |
| self._whitelisted_files = whitelisted |
| self._files_to_check = to_check |
| return ([], [], []) |
| return ScanAtPresubmitStub |
| |
| def GetWhitelistedFiles(self): |
| return sorted(self._whitelisted_files) |
| |
| def GetFilesToCheck(self): |
| return sorted(self._files_to_check) |
| |
| def testWhitelistedUntouched(self): |
| # When a change doesn't touch the whitelist file, any updated files |
| # (except deleted) must be checked. The whitelist used for analysis |
| # must be trimmed to the changed files subset. |
| # |
| # A_NW.cc - added, not whitelisted => check |
| # A_W.cc - added, whitelisted => check, remain on the trimmed whitelist |
| # D_NW.cc - deleted, not whitelisted => ignore |
| # D_W.cc - deleted and whitelisted => remain on w/l |
| # M_NW.cc - modified, not whitelisted => check |
| # M_W.cc - modified and whitelisted => check, remain on w/l |
| # NM_W.cc - not modified, whitelisted => trim from w/l |
| # W - the whitelist file |
| |
| self.input_api.AffectedFiles = self.CreateAffectedFilesFunc( |
| ['A_NW.cc', 'A', 'A_W.cc', 'A', 'D_NW.cc', 'D', 'D_W.cc', 'D', |
| 'M_NW.cc', 'M', 'M_W.cc', 'M']) |
| self.mox.StubOutWithMock(copyright_scanner, '_GetWhitelistFileName') |
| copyright_scanner._GetWhitelistFileName = lambda _: 'W' |
| self.mox.StubOutWithMock(copyright_scanner, 'LoadWhitelistedFilesList') |
| copyright_scanner.LoadWhitelistedFilesList = \ |
| lambda _: ['A_W.cc', 'D_W.cc', 'M_W.cc', 'NM_W.cc'] |
| self.mox.StubOutWithMock(copyright_scanner, '_DoScanAtPresubmit') |
| copyright_scanner._DoScanAtPresubmit = self.CreateDoScanAtPresubmitFunc() |
| self.mox.ReplayAll() |
| copyright_scanner.ScanAtPresubmit(self.input_api, self.output_api) |
| self.assertEqual( |
| ['A_W.cc', 'D_W.cc', 'M_W.cc'], self.GetWhitelistedFiles()) |
| self.assertEqual( |
| ['A_NW.cc', 'A_W.cc', 'M_NW.cc', 'M_W.cc'], self.GetFilesToCheck()) |
| |
| def testWhitelistTouched(self): |
| # When the whitelist file is touched by the change, all the files listed in |
| # it, including deleted entries, must be re-checked. All modified files |
| # (including the deleted ones) must be checked as well. The current contents |
| # of the whitelist are used for analysis. |
| # Whitelist addition or deletion are not considered. |
| # |
| # All the files from names testWhitelistedUntouched are re-used, but now |
| # action for all of them is 'check' (except for the w/l file itself). |
| # A_DW.cc - added, deleted from w/l => check |
| # D_DW.cc - deleted from repo and w/l => check |
| # M_DW.cc - modified, deleted from w/l => check |
| self.input_api.AffectedFiles = self.CreateAffectedFilesFunc( |
| ['A_DW.cc', 'A', 'A_NW.cc', 'A', 'A_W.cc', 'A', |
| 'D_DW.cc', 'D', 'D_NW.cc', 'D', 'D_W.cc', 'D', |
| 'M_DW.cc', 'M', 'M_NW.cc', 'M', 'M_W.cc', 'M', 'W', 'M']) |
| self.mox.StubOutWithMock(copyright_scanner, '_GetWhitelistFileName') |
| copyright_scanner._GetWhitelistFileName = lambda _: 'W' |
| self.mox.StubOutWithMock(copyright_scanner, '_GetDeletedContents') |
| def GetDeletedContentsStub(affected_file): |
| self.assertEqual('W', affected_file.LocalPath()) |
| return ['A_DW.cc', 'D_DW.cc', 'M_DW.cc'] |
| copyright_scanner._GetDeletedContents = GetDeletedContentsStub |
| self.mox.StubOutWithMock(copyright_scanner, 'LoadWhitelistedFilesList') |
| copyright_scanner.LoadWhitelistedFilesList = \ |
| lambda _: ['A_W.cc', 'D_W.cc', 'M_W.cc', 'NM_W.cc'] |
| self.mox.StubOutWithMock(copyright_scanner, '_DoScanAtPresubmit') |
| copyright_scanner._DoScanAtPresubmit = self.CreateDoScanAtPresubmitFunc() |
| self.mox.ReplayAll() |
| copyright_scanner.ScanAtPresubmit(self.input_api, self.output_api) |
| self.assertEqual( |
| ['A_W.cc', 'D_W.cc', 'M_W.cc', 'NM_W.cc'], self.GetWhitelistedFiles()) |
| self.assertEqual( |
| ['A_DW.cc', 'A_NW.cc', 'A_W.cc', 'D_DW.cc', 'D_NW.cc', 'D_W.cc', |
| 'M_DW.cc', 'M_NW.cc', 'M_W.cc', 'NM_W.cc' ], self.GetFilesToCheck()) |
| |
| if __name__ == '__main__': |
| unittest.main() |
