#!/usr/bin/python

# -*- 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 (chris.jerdonek@gmail.com)

#

# 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

import checker as style

from webkitpy.style_references import LogTesting

from webkitpy.style_references import TestLogStream

from checker import _BASE_FILTER_RULES

from checker import _MAX_REPORTS_PER_CATEGORY

from checker import _PATH_RULES_SPECIFIER as PATH_RULES_SPECIFIER

from checker import _all_categories

from checker import check_webkit_style_configuration

from checker import check_webkit_style_parser

from checker import configure_logging

from checker import CheckerDispatcher

from checker import ProcessorBase

from checker import StyleProcessor

from checker import StyleProcessorConfiguration

from checkers.cpp import CppChecker

from checkers.python import PythonChecker

from checkers.text import TextChecker

from error_handlers import DefaultStyleErrorHandler

from filter import validate_filter_rules

from filter import FilterConfiguration

from optparser import ArgumentParser

from optparser import CommandOptionValues

from webkitpy.common.system.logtesting import LoggingTestCase

from webkitpy.style.filereader import TextFileReader

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().

    """

    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 test-webkitpy 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 test-webkitpy 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.warn("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):

        return style._check_webkit_style_defaults()

    def test_webkit_base_filter_rules(self):

        base_filter_rules = _BASE_FILTER_RULES

        defaults = self.defaults()

        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.assertEquals(rule, rule.strip())

            # All categories are on by default, so defaults should

            # begin with -.

            self.assertTrue(rule.startswith('-'))

            # Check no rule occurs twice.

            self.assertFalse(rule in 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):

        all_categories = self._all_categories()

        for (sub_paths, path_rules) in PATH_RULES_SPECIFIER:

            validate_filter_rules(path_rules, self._all_categories())

        config = FilterConfiguration(path_specific=PATH_RULES_SPECIFIER)

        def assertCheck(path, category):

            """Assert that the given category should be checked."""

            message = ('Should check category "%s" for path "%s".'

                       % (category, path))

            self.assertTrue(config.should_check(category, path))

        def assertNoCheck(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)

        assertCheck("random_path.cpp",

                    "build/include")

        assertNoCheck("WebKitTools/WebKitAPITest/main.cpp",

                      "build/include")

        assertNoCheck("WebKit/qt/QGVLauncher/main.cpp",

                      "build/include")

        assertNoCheck("WebKit/qt/QGVLauncher/main.cpp",

                      "readability/streams")

        assertCheck("random_path.cpp",

                    "readability/naming")

        assertNoCheck("WebKit/gtk/webkit/webkit.h",

                      "readability/naming")

        assertNoCheck("WebKitTools/DumpRenderTree/gtk/DumpRenderTree.cpp",

                      "readability/null")

        assertNoCheck("WebKit/efl/ewk/ewk_view.h",

                      "readability/naming")

        assertNoCheck("WebCore/css/CSSParser.cpp",

                      "readability/naming")

        assertNoCheck("WebKit/qt/tests/qwebelement/tst_qwebelement.cpp",

                      "readability/naming")

        assertNoCheck(

            "JavaScriptCore/qt/tests/qscriptengine/tst_qscriptengine.cpp",

            "readability/naming")

        assertNoCheck("WebCore/ForwardingHeaders/debugger/Debugger.h",

                      "build/header_guard")

        # Third-party Python code: webkitpy/thirdparty

        path = "WebKitTools/Scripts/webkitpy/thirdparty/mock.py"

        assertNoCheck(path, "build/include")

        assertNoCheck(path, "pep8/E401")  # A random pep8 category.

        assertCheck(path, "pep8/W191")

        assertCheck(path, "pep8/W291")

        assertCheck(path, "whitespace/carriage_return")

    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.iterkeys():

            self.assertTrue(category in all_categories,

                            'Key "%s" is not a category' % category)

class CheckWebKitStyleFunctionTest(unittest.TestCase):

    """Tests the functions with names of the form check_webkit_style_*."""

    def test_check_webkit_style_configuration(self):

        # Exercise the code path to make sure the function does not error out.

        option_values = CommandOptionValues()

        configuration = check_webkit_style_configuration(option_values)

    def test_check_webkit_style_parser(self):

        # Exercise the code path to make sure the function does not error out.

        parser = check_webkit_style_parser()

class CheckerDispatcherSkipTest(unittest.TestCase):

    """Tests the "should skip" methods of the CheckerDispatcher class."""

    def setUp(self):

        self._dispatcher = CheckerDispatcher()

    def test_should_skip_with_warning(self):

        """Test should_skip_with_warning()."""

        # Check a non-skipped file.

        self.assertFalse(self._dispatcher.should_skip_with_warning("foo.txt"))

        # Check skipped files.

        paths_to_skip = [

           "gtk2drawing.c",

           "gtkdrawing.h",

           "JavaScriptCore/qt/api/qscriptengine_p.h",

           "WebCore/platform/gtk/gtk2drawing.c",

           "WebCore/platform/gtk/gtkdrawing.h",

           "WebKit/gtk/tests/testatk.c",

           "WebKit/qt/Api/qwebpage.h",

           "WebKit/qt/tests/qwebsecurityorigin/tst_qwebsecurityorigin.cpp",

            ]

        for path in paths_to_skip:

            self.assertTrue(self._dispatcher.should_skip_with_warning(path),

                            "Checking: " + path)

    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.assertEquals(checker is None, is_checker_none, message)

        self.assertEquals(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('LayoutTests', '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."""

        paths = ['foo.txt',

                 os.path.join('LayoutTests', 'ChangeLog'),

        ]

        for path in paths:

            self._assert_should_skip_without_warning(path,

                                                     is_checker_none=False,

                                                     expected=False)

class CheckerDispatcherDispatchTest(unittest.TestCase):

    """Tests dispatch() method of CheckerDispatcher class."""

    def mock_handle_style_error(self):

        pass

    def dispatch(self, file_path):

        """Call dispatch() with the given file path."""

        dispatcher = CheckerDispatcher()

        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.assertTrue(checker is None, '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.assertEquals(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_python(self, file_path):

        """Assert that the dispatched checker is a PythonChecker."""

        self.assert_checker(file_path, PythonChecker)

    def assert_checker_text(self, file_path):

        """Assert that the dispatched checker is a TextChecker."""

        self.assert_checker(file_path, TextChecker)

    def test_cpp_paths(self):

        """Test paths that should be checked as C++."""

        paths = [

            "-",

            "foo.c",

            "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.assertEquals(checker.file_extension, file_extension)

        self.assertEquals(checker.file_path, file_path)

        self.assertEquals(checker.handle_style_error, self.mock_handle_style_error)

        self.assertEquals(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.assertEquals(checker.file_extension, file_extension)

        self.assertEquals(checker.file_path, file_path)

    def test_python_paths(self):

        """Test paths that should be checked as Python."""

        paths = [

           "foo.py",

           "WebKitTools/Scripts/modules/text_style.py",

        ]

        for path in paths:

            self.assert_checker_python(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.assertEquals(checker.file_path, file_path)

        self.assertEquals(checker.handle_style_error,

                          self.mock_handle_style_error)

    def test_text_paths(self):

        """Test paths that should be checked as text."""

        paths = [

           "ChangeLog",

           "ChangeLog-2009-06-16",

           "foo.ac",

           "foo.cc",

           "foo.cgi",

           "foo.css",

           "foo.exp",

           "foo.flex",

           "foo.gyp",

           "foo.gypi",

           "foo.html",

           "foo.idl",

           "foo.in",

           "foo.js",

           "foo.mm",

           "foo.php",

           "foo.pl",

           "foo.pm",

           "foo.pri",

           "foo.pro",

           "foo.rb",

           "foo.sh",

           "foo.txt",

           "foo.wm",

           "foo.xhtml",

           "foo.y",

           os.path.join("WebCore", "ChangeLog"),

           os.path.join("WebCore", "inspector", "front-end", "inspector.js"),

           os.path.join("WebKitTools", "Scripts", "check-webkit-style"),

        ]

        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.assertEquals(checker.file_path, file_path)

        self.assertEquals(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.png",

           "foo.exe",

           "foo.vcproj",

            ]

        for path in paths:

            self.assert_checker_none(path)

class StyleProcessorConfigurationTest(unittest.TestCase):

    """Tests the StyleProcessorConfiguration class."""

    def setUp(self):

        self._error_messages = []

        """The messages written to _mock_stderr_write() of this class."""

    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.assertEquals(configuration.max_reports_per_category,

                          {"whitespace/newline": 1})

        self.assertEquals(configuration.stderr_write, self._mock_stderr_write)

        self.assertEquals(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.