# -*- coding: utf-8; -*-
#
# Copyright (C) 2009 Google Inc. All rights reserved.
# Copyright (C) 2009 Torch Mobile Inc.
# Copyright (C) 2009 Apple Inc. All rights reserved.
# Copyright (C) 2010 Chris Jerdonek ([email protected])
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
# * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""Unit tests for style.py."""
import logging
import os
import unittest
from blinkpy.common.system.log_testing import LoggingTestCase
from blinkpy.common.system.log_testing import TestLogStream
from blinkpy.style import checker as style
from blinkpy.style.checker import _all_categories
from blinkpy.style.checker import _BASE_FILTER_RULES
from blinkpy.style.checker import _MAX_REPORTS_PER_CATEGORY
from blinkpy.style.checker import _PATH_RULES_SPECIFIER as PATH_RULES_SPECIFIER
from blinkpy.style.checker import check_blink_style_configuration
from blinkpy.style.checker import check_blink_style_parser
from blinkpy.style.checker import CheckerDispatcher
from blinkpy.style.checker import configure_logging
from blinkpy.style.checker import StyleProcessor
from blinkpy.style.checker import StyleProcessorConfiguration
from blinkpy.style.checkers.cpp import CppChecker
from blinkpy.style.checkers.jsonchecker import JSONChecker
from blinkpy.style.checkers.text import TextChecker
from blinkpy.style.checkers.xml import XMLChecker
from blinkpy.style.error_handlers import DefaultStyleErrorHandler
from blinkpy.style.filter import FilterConfiguration
from blinkpy.style.filter import validate_filter_rules
from blinkpy.style.optparser import ArgumentParser
from blinkpy.style.optparser import CommandOptionValues
class ConfigureLoggingTestBase(unittest.TestCase):
"""Base class for testing configure_logging().
Sub-classes should implement:
is_verbose: The is_verbose value to pass to configure_logging().
"""
is_verbose = False
def setUp(self):
is_verbose = self.is_verbose
log_stream = TestLogStream(self)
# Use a logger other than the root logger or one prefixed with
# webkit so as not to conflict with run_blinkpy_tests.py logging.
logger = logging.getLogger("unittest")
# Configure the test logger not to pass messages along to the
# root logger. This prevents test messages from being
# propagated to loggers used by run_blinkpy_tests.py logging (e.g.
# the root logger).
logger.propagate = False
self._handlers = configure_logging(
stream=log_stream, logger=logger, is_verbose=is_verbose)
self._log = logger
self._log_stream = log_stream
def tearDown(self):
"""Reset logging to its original state.
This method ensures that the logging configuration set up
for a unit test does not affect logging in other unit tests.
"""
logger = self._log
for handler in self._handlers:
logger.removeHandler(handler)
def assert_log_messages(self, messages):
"""Assert that the logged messages equal the given messages."""
self._log_stream.assertMessages(messages)
class ConfigureLoggingTest(ConfigureLoggingTestBase):
"""Tests the configure_logging() function."""
is_verbose = False
def test_warning_message(self):
self._log.warning("test message")
self.assert_log_messages(["WARNING: test message\n"])
def test_below_warning_message(self):
# We test the boundary case of a logging level equal to 29.
# In practice, we will probably only be calling log.info(),
# which corresponds to a logging level of 20.
level = logging.WARNING - 1 # Equals 29.
self._log.log(level, "test message")
self.assert_log_messages(["test message\n"])
def test_debug_message(self):
self._log.debug("test message")
self.assert_log_messages([])
def test_two_messages(self):
self._log.info("message1")
self._log.info("message2")
self.assert_log_messages(["message1\n", "message2\n"])
class ConfigureLoggingVerboseTest(ConfigureLoggingTestBase):
"""Tests the configure_logging() function with is_verbose True."""
is_verbose = True
def test_debug_message(self):
self._log.debug("test message")
self.assert_log_messages(["unittest: DEBUG test message\n"])
class GlobalVariablesTest(unittest.TestCase):
"""Tests validity of the global variables."""
def _all_categories(self):
return _all_categories()
def defaults(self):
# Access to a protected member _check_blink_style_defaults
# pylint: disable=W0212
return style._check_blink_style_defaults()
def test_blink_base_filter_rules(self):
base_filter_rules = _BASE_FILTER_RULES
already_seen = []
validate_filter_rules(base_filter_rules, self._all_categories())
# Also do some additional checks.
for rule in base_filter_rules:
# Check no leading or trailing white space.
self.assertEqual(rule, rule.strip())
# All categories are on by default, so defaults should
# begin with -.
self.assertTrue(rule.startswith('-'))
# Check no rule occurs twice.
self.assertNotIn(rule, already_seen)
already_seen.append(rule)
def test_defaults(self):
"""Check that default arguments are valid."""
default_options = self.defaults()
# FIXME: We should not need to call parse() to determine
# whether the default arguments are valid.
parser = ArgumentParser(
all_categories=self._all_categories(),
base_filter_rules=[],
default_options=default_options)
# No need to test the return value here since we test parse()
# on valid arguments elsewhere.
#
# The default options are valid: no error or SystemExit.
parser.parse(args=[])
def test_path_rules_specifier(self):
for _, path_rules in PATH_RULES_SPECIFIER:
validate_filter_rules(path_rules, self._all_categories())
config = FilterConfiguration(path_specific=PATH_RULES_SPECIFIER)
def assert_check(path, category):
"""Assert that the given category should be checked."""
self.assertTrue(config.should_check(category, path))
def assert_no_check(path, category):
"""Assert that the given category should not be checked."""
message = ('Should not check category "%s" for path "%s".' %
(category, path))
self.assertFalse(config.should_check(category, path), message)
assert_check("random_path.cpp", "build/include")
assert_check("random_path.cpp", "readability/naming")
def test_max_reports_per_category(self):
"""Check that _MAX_REPORTS_PER_CATEGORY is valid."""
all_categories = self._all_categories()
for category in _MAX_REPORTS_PER_CATEGORY.keys():
self.assertIn(category, all_categories,
'Key "%s" is not a category' % category)
class CheckBlinkStyleFunctionTest(unittest.TestCase):
"""Tests the functions with names of the form check_blink_style_*."""
def test_check_blink_style_configuration(self):
# Exercise the code path to make sure the function does not error out.
option_values = CommandOptionValues()
check_blink_style_configuration(option_values)
def test_check_blink_style_parser(self):
# Exercise the code path to make sure the function does not error out.
check_blink_style_parser()
class CheckerDispatcherSkipTest(unittest.TestCase):
"""Tests the "should skip" methods of the CheckerDispatcher class."""
def setUp(self):
self._dispatcher = CheckerDispatcher()
def _assert_should_skip_without_warning(self, path, is_checker_none,
expected):
# Check the file type before asserting the return value.
checker = self._dispatcher.dispatch(
file_path=path, handle_style_error=None, min_confidence=3)
message = 'while checking: %s' % path
self.assertEqual(checker is None, is_checker_none, message)
self.assertEqual(
self._dispatcher.should_skip_without_warning(path), expected,
message)
def test_should_skip_without_warning__true(self):
"""Test should_skip_without_warning() for True return values."""
# Check a file with NONE file type.
path = 'foo.asdf' # Non-sensical file extension.
self._assert_should_skip_without_warning(
path, is_checker_none=True, expected=True)
# Check files with non-NONE file type. These examples must be
# drawn from the _SKIPPED_FILES_WITHOUT_WARNING configuration
# variable.
path = os.path.join('web_tests', 'foo.txt')
self._assert_should_skip_without_warning(
path, is_checker_none=False, expected=True)
def test_should_skip_without_warning__false(self):
"""Test should_skip_without_warning() for False return values."""
self._assert_should_skip_without_warning('foo.txt',
is_checker_none=False,
expected=False)
class CheckerDispatcherCarriageReturnTest(unittest.TestCase):
def test_should_check_and_strip_carriage_returns(self):
files = {
'foo.txt': True,
'foo.cpp': True,
'foo.vcproj': False,
'foo.vsprops': False,
}
dispatcher = CheckerDispatcher()
for file_path, expected_result in files.items():
self.assertEqual(
dispatcher.should_check_and_strip_carriage_returns(file_path),
expected_result, 'Checking: %s' % file_path)
class CheckerDispatcherDispatchTest(unittest.TestCase):
"""Tests dispatch() method of CheckerDispatcher class."""
def dispatch(self, file_path):
"""Call dispatch() with the given file path."""
dispatcher = CheckerDispatcher()
self.mock_handle_style_error = DefaultStyleErrorHandler(
'', None, None, [])
checker = dispatcher.dispatch(
file_path, self.mock_handle_style_error, min_confidence=3)
return checker
def assert_checker_none(self, file_path):
"""Assert that the dispatched checker is None."""
checker = self.dispatch(file_path)
self.assertIsNone(checker, 'Checking: "%s"' % file_path)
def assert_checker(self, file_path, expected_class):
"""Assert the type of the dispatched checker."""
checker = self.dispatch(file_path)
got_class = checker.__class__
self.assertEqual(
got_class, expected_class,
'For path "%(file_path)s" got %(got_class)s when '
"expecting %(expected_class)s." % {
"file_path": file_path,
"got_class": got_class,
"expected_class": expected_class
})
def assert_checker_cpp(self, file_path):
"""Assert that the dispatched checker is a CppChecker."""
self.assert_checker(file_path, CppChecker)
def assert_checker_json(self, file_path):
"""Assert that the dispatched checker is a JSONChecker."""
self.assert_checker(file_path, JSONChecker)
def assert_checker_text(self, file_path):
"""Assert that the dispatched checker is a TextChecker."""
self.assert_checker(file_path, TextChecker)
def assert_checker_xml(self, file_path):
"""Assert that the dispatched checker is a XMLChecker."""
self.assert_checker(file_path, XMLChecker)
def test_cpp_paths(self):
"""Test paths that should be checked as C++."""
paths = [
"-",
"foo.c",
"foo.cc",
"foo.cpp",
"foo.h",
]
for path in paths:
self.assert_checker_cpp(path)
# Check checker attributes on a typical input.
file_base = "foo"
file_extension = "c"
file_path = file_base + "." + file_extension
self.assert_checker_cpp(file_path)
checker = self.dispatch(file_path)
self.assertEqual(checker.file_extension, file_extension)
self.assertEqual(checker.file_path, file_path)
self.assertEqual(checker.handle_style_error,
self.mock_handle_style_error)
self.assertEqual(checker.min_confidence, 3)
# Check "-" for good measure.
file_base = "-"
file_extension = ""
file_path = file_base
self.assert_checker_cpp(file_path)
checker = self.dispatch(file_path)
self.assertEqual(checker.file_extension, file_extension)
self.assertEqual(checker.file_path, file_path)
def test_json_paths(self):
"""Test paths that should be checked as JSON."""
paths = [
"Source/WebCore/inspector/Inspector.json",
"Tools/BuildSlaveSupport/build.webkit.org-config/config.json",
]
for path in paths:
self.assert_checker_json(path)
# Check checker attributes on a typical input.
file_base = "foo"
file_extension = "json"
file_path = file_base + "." + file_extension
self.assert_checker_json(file_path)
checker = self.dispatch(file_path)
self.assertEqual(checker._handle_style_error,
self.mock_handle_style_error)
def test_text_paths(self):
"""Test paths that should be checked as text."""
paths = [
"foo.cgi",
"foo.css",
"foo.gyp",
"foo.gypi",
"foo.html",
"foo.idl",
"foo.in",
"foo.js",
"foo.mm",
"foo.php",
"foo.pl",
"foo.pm",
"foo.rb",
"foo.sh",
"foo.txt",
"foo.xhtml",
"foo.y",
os.path.join("Source", "WebCore", "inspector", "front-end",
"Main.js"),
]
for path in paths:
self.assert_checker_text(path)
# Check checker attributes on a typical input.
file_base = "foo"
file_extension = "css"
file_path = file_base + "." + file_extension
self.assert_checker_text(file_path)
checker = self.dispatch(file_path)
self.assertEqual(checker.file_path, file_path)
self.assertEqual(checker.handle_style_error,
self.mock_handle_style_error)
def test_xml_paths(self):
"""Test paths that should be checked as XML."""
paths = [
"Source/WebCore/WebCore.vcproj/WebCore.vcproj",
"WebKitLibraries/win/tools/vsprops/common.vsprops",
]
for path in paths:
self.assert_checker_xml(path)
# Check checker attributes on a typical input.
file_base = "foo"
file_extension = "vcproj"
file_path = file_base + "." + file_extension
self.assert_checker_xml(file_path)
checker = self.dispatch(file_path)
self.assertEqual(checker._handle_style_error,
self.mock_handle_style_error)
def test_none_paths(self):
"""Test paths that have no file type.."""
paths = [
"Makefile",
"foo.asdf", # Non-sensical file extension.
"foo.exe",
]
for path in paths:
self.assert_checker_none(path)
class StyleProcessorConfigurationTest(unittest.TestCase):
"""Tests the StyleProcessorConfiguration class."""
def setUp(self):
# The messages written to _mock_stderr_write() of this class.
self._error_messages = []
def _mock_stderr_write(self, message):
self._error_messages.append(message)
def _style_checker_configuration(self, output_format="vs7"):
"""Return a StyleProcessorConfiguration instance for testing."""
base_rules = ["-whitespace", "+whitespace/tab"]
filter_configuration = FilterConfiguration(base_rules=base_rules)
return StyleProcessorConfiguration(
filter_configuration=filter_configuration,
max_reports_per_category={"whitespace/newline": 1},
min_confidence=3,
output_format=output_format,
stderr_write=self._mock_stderr_write)
def test_init(self):
"""Test the __init__() method."""
configuration = self._style_checker_configuration()
# Check that __init__ sets the "public" data attributes correctly.
self.assertEqual(configuration.max_reports_per_category,
{"whitespace/newline": 1})
self.assertEqual(configuration.stderr_write, self._mock_stderr_write)
self.assertEqual(configuration.min_confidence, 3)
def test_is_reportable(self):
"""Test the is_reportable() method."""
config = self._style_checker_configuration()
self.assertTrue(config.is_reportable("whitespace/tab", 3, "foo.txt"))
# Test the confidence check code path by varying the confidence.
self.assertFalse(config.is_reportable("whitespace/tab", 2, "foo.txt"))
# Test the category check code path by varying the category.
self.assertFalse(config.is_reportable("whitespace/line", 4, "foo.txt"))
def _call_write_style_error(self, output_format):
config = self._style_checker_configuration(output_format=output_format)
config.write_style_error(
category="whitespace/tab",
confidence_in_error=5,
file_path="foo.h",
line_number=100,
message="message")
def test_write_style_error_emacs(self):
"""Test the write_style_error() method."""
self._call_write_style_error("emacs")
self.assertEqual(self._error_messages,
["foo.h:100: message [whitespace/tab] [5]\n"])
def test_write_style_error_vs7(self):
"""Test the write_style_error() method."""
self._call_write_style_error("vs7")
self.assertEqual(self._error_messages,
["foo.h(100): message [whitespace/tab] [5]\n"])
class StyleProcessor_EndToEndTest(LoggingTestCase):
"""Test the StyleProcessor class with an emphasis on end-to-end tests."""
def setUp(self):
LoggingTestCase.setUp(self)
self._messages = []
def _mock_stderr_write(self, message):
"""Save a message so it can later be asserted."""
self._messages.append(message)
def test_init(self):
"""Test __init__ constructor."""
configuration = StyleProcessorConfiguration(
filter_configuration=FilterConfiguration(),
max_reports_per_category={},
min_confidence=3,
output_format="vs7",
stderr_write=self._mock_stderr_write)
processor = StyleProcessor(configuration)
self.assertEqual(processor.error_count, 0)
self.assertEqual(self._messages, [])
def test_process(self):
configuration = StyleProcessorConfiguration(
filter_configuration=FilterConfiguration(),
max_reports_per_category={},
min_confidence=3,
output_format="vs7",
stderr_write=self._mock_stderr_write)
processor = StyleProcessor(configuration)
processor.process(
lines=['line1', 'Line with tab:\t'], file_path='foo.txt')
self.assertEqual(processor.error_count, 1)
expected_messages = [
'foo.txt(2): Line contains tab character. '
'[whitespace/tab] [5]\n'
]
self.assertEqual(self._messages, expected_messages)
class StyleProcessor_CodeCoverageTest(LoggingTestCase):
"""Test the StyleProcessor class with an emphasis on code coverage.
This class makes heavy use of mock objects.
"""
class MockDispatchedChecker(object):
"""A mock checker dispatched by the MockDispatcher."""
def __init__(self, file_path, min_confidence, style_error_handler):
self.file_path = file_path
self.min_confidence = min_confidence
self.style_error_handler = style_error_handler
self.lines = None
def check(self, lines):
self.lines = lines
class MockDispatcher(object):
"""A mock CheckerDispatcher class."""
def __init__(self):
self.dispatched_checker = None
def should_skip_without_warning(self, file_path):
return file_path.endswith('skip_without_warning.txt')
def should_check_and_strip_carriage_returns(self, file_path):
return not file_path.endswith('carriage_returns_allowed.txt')
def dispatch(self, file_path, style_error_handler, min_confidence):
if file_path.endswith('do_not_process.txt'):
return None
checker = StyleProcessor_CodeCoverageTest.MockDispatchedChecker(
file_path, min_confidence, style_error_handler)
# Save the dispatched checker so the current test case has a
# way to access and check it.
self.dispatched_checker = checker
return checker
def setUp(self):
LoggingTestCase.setUp(self)
# We can pass an error-message swallower here because error message
# output is tested instead in the end-to-end test case above.
configuration = StyleProcessorConfiguration(
filter_configuration=FilterConfiguration(),
max_reports_per_category={"whitespace/newline": 1},
min_confidence=3,
output_format="vs7",
stderr_write=self._swallow_stderr_message)
mock_carriage_checker_class = self._create_carriage_checker_class()
mock_dispatcher = self.MockDispatcher()
# We do not need to use a real incrementer here because error-count
# incrementing is tested instead in the end-to-end test case above.
mock_increment_error_count = self._do_nothing
processor = StyleProcessor(
configuration=configuration,
mock_carriage_checker_class=mock_carriage_checker_class,
mock_dispatcher=mock_dispatcher,
mock_increment_error_count=mock_increment_error_count)
self._configuration = configuration
self._mock_dispatcher = mock_dispatcher
self._processor = processor
def _do_nothing(self):
# We provide this function so the caller can pass it to the
# StyleProcessor constructor. This lets us assert the equality of
# the DefaultStyleErrorHandler instance generated by the process()
# method with an expected instance.
pass
def _swallow_stderr_message(self, message):
"""Swallow a message passed to stderr.write()."""
# This is a mock stderr.write() for passing to the constructor
# of the StyleProcessorConfiguration class.
def _create_carriage_checker_class(self):
# Create a reference to self with a new name so its name does not
# conflict with the self introduced below.
test_case = self
class MockCarriageChecker(object):
"""A mock carriage-return checker."""
def __init__(self, style_error_handler):
self.style_error_handler = style_error_handler
# This gives the current test case access to the
# instantiated carriage checker.
test_case.carriage_checker = self
def check(self, lines):
# Save the lines so the current test case has a way to access
# and check them.
self.lines = lines
return lines
return MockCarriageChecker
def test_should_process__skip_without_warning(self):
"""Test should_process() for a skip-without-warning file."""
file_path = "foo/skip_without_warning.txt"
self.assertFalse(self._processor.should_process(file_path))
def test_should_process__true_result(self):
"""Test should_process() for a file that should be processed."""
file_path = "foo/skip_process.txt"
self.assertTrue(self._processor.should_process(file_path))
def test_process__checker_dispatched(self):
"""Test the process() method for a path with a dispatched checker."""
file_path = 'foo.txt'
lines = ['line1', 'line2']
line_numbers = [100]
expected_error_handler = DefaultStyleErrorHandler(
configuration=self._configuration,
file_path=file_path,
increment_error_count=self._do_nothing,
line_numbers=line_numbers)
self._processor.process(
lines=lines, file_path=file_path, line_numbers=line_numbers)
# Check that the carriage-return checker was instantiated correctly
# and was passed lines correctly.
carriage_checker = self.carriage_checker
self.assertEqual(carriage_checker.style_error_handler,
expected_error_handler)
self.assertEqual(carriage_checker.lines, ['line1', 'line2'])
# Check that the style checker was dispatched correctly and was
# passed lines correctly.
checker = self._mock_dispatcher.dispatched_checker
self.assertEqual(checker.file_path, 'foo.txt')
self.assertEqual(checker.min_confidence, 3)
self.assertEqual(checker.style_error_handler, expected_error_handler)
self.assertEqual(checker.lines, ['line1', 'line2'])
def test_process__no_checker_dispatched(self):
"""Test the process() method for a path with no dispatched checker."""
path = os.path.join('foo', 'do_not_process.txt')
with self.assertRaises(AssertionError):
self._processor.process(
lines=['line1', 'line2'], file_path=path, line_numbers=[100])
def test_process__carriage_returns_not_stripped(self):
"""Test that carriage returns aren't stripped from files that are allowed to contain them."""
file_path = 'carriage_returns_allowed.txt'
lines = ['line1\r', 'line2\r']
line_numbers = [100]
self._processor.process(
lines=lines, file_path=file_path, line_numbers=line_numbers)
# The carriage return checker should never have been invoked, and so
# should not have saved off any lines.
self.assertFalse(hasattr(self.carriage_checker, 'lines'))
Codebase Browser
chromium