mojo/PRESUBMIT_test.py

#!/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.

import os
import sys
import unittest

import PRESUBMIT

sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from PRESUBMIT_test_mocks import MockFile
from PRESUBMIT_test_mocks import MockInputApi, MockOutputApi

_SDK_BUILD_FILE = 'mojo/public/some/path/BUILD.gn'
_EDK_BUILD_FILE = 'mojo/edk/some/path/BUILD.gn'
_SERVICE_BUILD_FILE = 'mojo/services/some_service/public/BUILD.gn'
_IRRELEVANT_BUILD_FILE = 'mojo/foo/some/path/BUILD.gn'

_PACKAGE_BUILDFILES = {
    'SDK' : _SDK_BUILD_FILE,
    'EDK' : _EDK_BUILD_FILE,
    'services' : _SERVICE_BUILD_FILE
}

class AbsoluteReferencesInBuildFilesTest(unittest.TestCase):
  """Tests the checking for illegal absolute paths within SDK/EDK buildfiles.
  """
  def setUp(self):
    self.sdk_absolute_path = '//mojo/public/some/absolute/path'
    self.sdk_relative_path = 'mojo/public/some/relative/path'
    self.edk_absolute_path = '//mojo/edk/some/absolute/path'
    self.edk_relative_path = 'mojo/edk/some/relative/path'
    self.service_absolute_path = '//mojo/services/some/service'
    self.service_relative_path = '../../../some/service'
    self.whitelisted_external_path = '//testing/gtest'
    self.non_whitelisted_external_path = '//base'

  def inputApiContainingFileWithPaths(self, filename, paths):
    """Returns a MockInputApi object with a single file having |filename| as
    its name and |paths| as its contents, with each path being wrapped in a
    pair of double-quotes to match the syntax for strings within BUILD.gn
    files."""
    contents = [ '"%s"' % path for path in paths ]
    mock_file = MockFile(filename, contents)
    mock_input_api = MockInputApi()
    mock_input_api.files.append(mock_file)
    return mock_input_api

  def checkWarningWithSingleItem(self,
                                 warning,
                                 expected_message,
                                 build_file,
                                 line_num,
                                 referenced_path):
    """Checks that |warning| has a message of |expected_message| and a single
    item whose contents are the absolute path warning item for
    (build_file, line_num, referenced_path)."""
    self.assertEqual(expected_message, warning.message)
    self.assertEqual(1, len(warning.items))
    expected_item = PRESUBMIT._PathReferenceInBuildFileWarningItem(
        build_file, line_num, referenced_path)
    self.assertEqual(expected_item, warning.items[0])

  def checkSDKAbsolutePathWarningWithSingleItem(self,
                                                warning,
                                                package,
                                                build_file,
                                                line_num,
                                                referenced_path):
    """Checks that |warning| has the message for an absolute SDK path within
    |package| and a single item whose contents are the absolute path warning
    item for (build_file, line_num, referenced_path)."""
    expected_message = \
        PRESUBMIT._ILLEGAL_SDK_ABSOLUTE_PATH_WARNING_MESSAGES[package]
    self.checkWarningWithSingleItem(warning,
                                    expected_message,
                                    build_file,
                                    line_num,
                                    referenced_path)

  def _testAbsoluteSDKReferenceInPackage(self, package):
    """Tests that an absolute SDK path within |package| is flagged."""
    buildfile = _PACKAGE_BUILDFILES[package]
    mock_input_api = self.inputApiContainingFileWithPaths(
        buildfile,
        [ self.sdk_relative_path, self.sdk_absolute_path ])
    warnings = PRESUBMIT._BuildFileChecks(mock_input_api, MockOutputApi())

    self.assertEqual(1, len(warnings))
    self.checkSDKAbsolutePathWarningWithSingleItem(warnings[0],
                                                   package,
                                                   buildfile,
                                                   2,
                                                   self.sdk_absolute_path)

  def _testExternalReferenceInPackage(self, package):
    """Tests that an illegal external path within |package| is flagged."""
    buildfile = _PACKAGE_BUILDFILES[package]
    mock_input_api = self.inputApiContainingFileWithPaths(
        buildfile,
        [ self.non_whitelisted_external_path, self.whitelisted_external_path ])
    warnings = PRESUBMIT._BuildFileChecks(mock_input_api, MockOutputApi())

    if package == 'EDK':
      # All external paths are allowed in the EDK.
      self.assertEqual(0, len(warnings))
      return

    self.assertEqual(1, len(warnings))
    expected_message = PRESUBMIT._ILLEGAL_EXTERNAL_PATH_WARNING_MESSAGE
    self.checkWarningWithSingleItem(warnings[0],
                                    expected_message,
                                    buildfile,
                                    1,
                                    self.non_whitelisted_external_path)

  def testAbsoluteSDKReferenceInSDKBuildFile(self):
    """Tests that an absolute SDK path within an SDK buildfile is flagged."""
    self._testAbsoluteSDKReferenceInPackage('SDK')

  def testExternalReferenceInSDKBuildFile(self):
    """Tests that an illegal external path in an SDK buildfile is flagged."""
    self._testExternalReferenceInPackage('SDK')

  def testAbsoluteEDKReferenceInSDKBuildFile(self):
    """Tests that an absolute EDK path in an SDK buildfile is flagged."""
    mock_input_api = self.inputApiContainingFileWithPaths(
        _SDK_BUILD_FILE,
        [ self.edk_absolute_path ])
    warnings = PRESUBMIT._BuildFileChecks(mock_input_api, MockOutputApi())

    self.assertEqual(1, len(warnings))
    expected_message = PRESUBMIT._ILLEGAL_EXTERNAL_PATH_WARNING_MESSAGE
    self.checkWarningWithSingleItem(warnings[0],
                                    expected_message,
                                    _SDK_BUILD_FILE,
                                    1,
                                    self.edk_absolute_path)

  def testAbsoluteSDKReferenceInEDKBuildFile(self):
    """Tests that an absolute SDK path within an EDK buildfile is flagged."""
    self._testAbsoluteSDKReferenceInPackage('EDK')

  def testAbsoluteEDKReferenceInEDKBuildFile(self):
    """Tests that an absolute EDK path in an EDK buildfile is flagged."""
    mock_input_api = self.inputApiContainingFileWithPaths(
        _EDK_BUILD_FILE,
        [ self.edk_absolute_path, self.edk_relative_path ])
    warnings = PRESUBMIT._BuildFileChecks(mock_input_api, MockOutputApi())

    self.assertEqual(1, len(warnings))
    expected_message = PRESUBMIT._ILLEGAL_EDK_ABSOLUTE_PATH_WARNING_MESSAGE
    self.checkWarningWithSingleItem(warnings[0],
                                    expected_message,
                                    _EDK_BUILD_FILE,
                                    1,
                                    self.edk_absolute_path)

  def testExternalReferenceInEDKBuildFile(self):
    """Tests that an external path in an EDK buildfile is not flagged."""
    self._testExternalReferenceInPackage('EDK')

  def testAbsoluteSDKReferenceInServiceBuildFile(self):
    """Tests that an absolute SDK path within a service's public buildfile is
    flagged."""
    self._testAbsoluteSDKReferenceInPackage("services")

  def testAbsoluteServiceReferenceInServiceBuildFile(self):
    """Tests that an absolute path to a service within a service's public
    buildfile is flagged."""
    mock_input_api = self.inputApiContainingFileWithPaths(
        _SERVICE_BUILD_FILE,
        [ self.service_relative_path, self.service_absolute_path ])
    warnings = PRESUBMIT._BuildFileChecks(mock_input_api, MockOutputApi())

    self.assertEqual(1, len(warnings))
    expected_message = \
        PRESUBMIT._ILLEGAL_SERVICES_ABSOLUTE_PATH_WARNING_MESSAGE
    self.checkWarningWithSingleItem(warnings[0],
                                    expected_message,
                                    _SERVICE_BUILD_FILE,
                                    2,
                                    self.service_absolute_path)

  def testExternalReferenceInServiceBuildFile(self):
    """Tests that an illegal external path in a service's buildfile is flagged
    ."""
    self._testExternalReferenceInPackage("services")

  def testIrrelevantBuildFile(self):
    """Tests that nothing is flagged in a non SDK/EDK buildfile."""
    mock_input_api = self.inputApiContainingFileWithPaths(
        _IRRELEVANT_BUILD_FILE,
        [ self.sdk_absolute_path,
          self.sdk_relative_path,
          self.edk_absolute_path,
          self.edk_relative_path,
          self.non_whitelisted_external_path,
          self.whitelisted_external_path ])
    warnings = PRESUBMIT._BuildFileChecks(mock_input_api, MockOutputApi())
    self.assertEqual(0, len(warnings))

class SourceSetTypesInBuildFilesTest(unittest.TestCase):
  """Tests checking of correct source set types within SDK/EDK buildfiles."""

  def inputApiContainingFileWithSourceSets(self, filename, source_sets):
    """Returns a MockInputApi object containing a single file having |filename|
    as its name and |source_sets| as its contents."""
    mock_file = MockFile(filename, source_sets)
    mock_input_api = MockInputApi()
    mock_input_api.files.append(mock_file)
    return mock_input_api

  def checkWarningWithSingleItem(self,
                                 warning,
                                 package,
                                 build_file,
                                 line_num):
    """Checks that warning has the expected incorrect source set type message
    for |package| and a single item whose contents are the incorrect source
    set type item for (build_file, line_num)."""
    expected_message = \
        PRESUBMIT._INCORRECT_SOURCE_SET_TYPE_WARNING_MESSAGES[package]
    self.assertEqual(expected_message, warning.message)
    self.assertEqual(1, len(warning.items))
    expected_item = PRESUBMIT._IncorrectSourceSetTypeWarningItem(
        build_file, line_num)
    self.assertEqual(expected_item, warning.items[0])

  def _testNakedSourceSetInPackage(self, package):
    """Tests that a source_set within |package| is flagged."""
    buildfile = _PACKAGE_BUILDFILES[package]
    naked_source_set = 'source_set('
    correct_source_set = 'mojo_sdk_source_set('
    if package == 'EDK':
      correct_source_set = 'mojo_edk_source_set('
    mock_input_api = self.inputApiContainingFileWithSourceSets(
        buildfile,
        [ correct_source_set, naked_source_set ])
    warnings = PRESUBMIT._BuildFileChecks(mock_input_api, MockOutputApi())

    self.assertEqual(1, len(warnings))
    self.checkWarningWithSingleItem(warnings[0], package, buildfile, 2)

  def _testWrongTypeOfWrapperSourceSetInPackage(self, package):
    """Tests that the wrong type of wrapper source_set in |package| is flagged
    (e.g., mojo_edk_source_set within the SDK)."""
    buildfile = _PACKAGE_BUILDFILES[package]
    mock_input_api = self.inputApiContainingFileWithSourceSets(
        buildfile,
        [ 'mojo_sdk_source_set(', 'mojo_edk_source_set(' ])
    warnings = PRESUBMIT._BuildFileChecks(mock_input_api, MockOutputApi())

    self.assertEqual(1, len(warnings))
    warning_line = 2
    if package == 'EDK':
      warning_line = 1
    self.checkWarningWithSingleItem(warnings[0],
                                    package,
                                    buildfile,
                                    warning_line)

  def testNakedSourceSetInSDKBuildFile(self):
    """Tests that a source_set within the SDK is flagged."""
    self._testNakedSourceSetInPackage('SDK')

  def testPythonSourceSetInSDKBuildFile(self):
    """Tests that a python_binary_source_set within an SDK buildfile is
    accepted."""
    mock_input_api = self.inputApiContainingFileWithSourceSets(
        _SDK_BUILD_FILE,
        [ 'mojo_sdk_source_set(', 'python_binary_source_set(' ])
    warnings = PRESUBMIT._BuildFileChecks(mock_input_api, MockOutputApi())

    self.assertEqual(0, len(warnings))

  def testEDKSourceSetInSDKBuildFile(self):
    """Tests that a mojo_edk_source_set within an SDK buildfile is flagged."""
    self._testWrongTypeOfWrapperSourceSetInPackage('SDK')

  def testNakedSourceSetInEDKBuildFile(self):
    """Tests that a source_set within the EDK is flagged."""
    self._testNakedSourceSetInPackage('EDK')

  def testSDKSourceSetInEDKBuildFile(self):
    """Tests that a mojo_sdk_source_set within an EDK buildfile is flagged."""
    self._testWrongTypeOfWrapperSourceSetInPackage('EDK')

  def testNakedSourceSetInServiceBuildFile(self):
    """Tests that a source_set within a service's public buildfile is flagged.
    """
    self._testNakedSourceSetInPackage("services")

  def testEDKSourceSetInServiceBuildFile(self):
    """Tests that a mojo_edk_source_set within a service's public buildfile is
    flagged."""
    self._testWrongTypeOfWrapperSourceSetInPackage("services")

  def testIrrelevantBuildFile(self):
    """Tests that a source_set in a non-SDK/EDK buildfile isn't flagged."""
    mock_input_api = self.inputApiContainingFileWithSourceSets(
        _IRRELEVANT_BUILD_FILE,
        [ 'source_set(' ])
    warnings = PRESUBMIT._BuildFileChecks(mock_input_api, MockOutputApi())
    self.assertEqual(0, len(warnings))

if __name__ == '__main__':
  unittest.main()