# -*- coding: utf-8 -*-
# Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Test the lint module."""

from __future__ import print_function

import collections
import os
import StringIO

from chromite.cli.cros import lint
from chromite.lib import cros_test_lib
from chromite.lib import osutils


# pylint: disable=protected-access


class DocStringSectionDetailsTest(cros_test_lib.TestCase):
  """Basic DocStringSectionDetails class tests."""

  def testInit(self):
    """Verify constructor behavior."""
    s = lint.DocStringSectionDetails()
    self.assertEqual(None, s.name)
    self.assertEqual(None, s.header)
    self.assertEqual([], s.lines)
    self.assertEqual(None, s.lineno)

    s = lint.DocStringSectionDetails(
        name='Args', header='  Args:', lines=['    foo: Yes.'], lineno=2)
    self.assertEqual('Args', s.name)
    self.assertEqual('  Args:', s.header)
    self.assertEqual(['    foo: Yes.'], s.lines)
    self.assertEqual(2, s.lineno)

  def testStr(self):
    """Sanity check __str__."""
    s = lint.DocStringSectionDetails()
    self.assertNotEqual(None, str(s))

  def testRepr(self):
    """Sanity check __repr__."""
    s = lint.DocStringSectionDetails()
    self.assertNotEqual(None, repr(s))

  def testEqual(self):
    """Sanity check __eq__."""
    s1 = lint.DocStringSectionDetails()
    s2 = lint.DocStringSectionDetails()
    self.assertEqual(s1, s2)

    s2 = lint.DocStringSectionDetails(name='Args')
    self.assertNotEqual(s1, s2)
    s2 = lint.DocStringSectionDetails(header='  Args:')
    self.assertNotEqual(s1, s2)
    s2 = lint.DocStringSectionDetails(lineno=2)
    self.assertNotEqual(s1, s2)

    s1 = lint.DocStringSectionDetails(name='n', header='h', lineno=0)
    s2 = lint.DocStringSectionDetails(name='n', header='h', lineno=0)
    self.assertEqual(s1, s2)


class PylintrcConfigTest(cros_test_lib.TempDirTestCase):
  """Basic _PylintrcConfig tests."""

  def testEmptySettings(self):
    """Check default empty names behavior."""
    lint._PylintrcConfig('/dev/null', '', ())

  def testDefaultValue(self):
    """Check we can read a default."""
    cfg_file = os.path.join(self.tempdir, 'pylintrc')
    osutils.WriteFile(cfg_file, '[sect]\nkey = "  "\n')
    cfg = lint._PylintrcConfig(cfg_file, 'sect', (
        ('key', {'default': 'KEY', 'type': 'string'}),
        ('foo', {'default': 'FOO', 'type': 'string'}),
    ))
    self.assertEqual('  ', cfg.option_value('key'))
    self.assertEqual('FOO', cfg.option_value('foo'))


class TestNode(object):
  """Object good enough to stand in for lint funcs"""

  Args = collections.namedtuple('Args', ('args', 'vararg', 'kwarg'))
  Arg = collections.namedtuple('Arg', ('name',))

  def __init__(self, doc='', fromlineno=0, path='foo.py', args=(), vararg='',
               kwarg='', names=None, lineno=0, name='module',
               display_type='Module', col_offset=None):
    if names is None:
      names = [('name', None)]
    self.doc = doc
    self.lines = doc.split('\n')
    self.fromlineno = fromlineno
    self.lineno = lineno
    self.file = path
    self.args = self.Args(args=[self.Arg(name=x) for x in args],
                          vararg=vararg, kwarg=kwarg)
    self.names = names
    self.name = name
    self._display_type = display_type
    self.col_offset = col_offset

  def argnames(self):
    return [arg.name for arg in self.args.args]

  def display_type(self):
    return self._display_type


class StatStub(object):
  """Dummy object to stand in for stat checks."""

  def __init__(self, size=0, mode=0o644):
    self.st_size = size
    self.st_mode = mode


class CheckerTestCase(cros_test_lib.TestCase):
  """Helpers for Checker modules"""

  def add_message(self, msg_id, node=None, line=None, args=None):
    """Capture lint checks"""
    # We include node.doc here explicitly so the pretty assert message
    # inclues it in the output automatically.
    doc = node.doc if node else ''
    self.results.append((msg_id, doc, line, args))

  def setUp(self):
    assert hasattr(self, 'CHECKER'), 'TestCase must set CHECKER'

    self.results = []
    self.checker = self.CHECKER()
    self.checker.add_message = self.add_message

  def assertLintPassed(self, msg='Checks failed'):
    """Assert that no lint results have been queued."""
    msg += '\nChecks failed: %s' % ([x[0] for x in self.results],)
    self.assertEqual(self.results, [], msg=msg)

  def assertLintFailed(self, msg='Checks incorrectly passed', expected=()):
    """Assert that failed results matching |expected| have been queued."""
    if expected:
      self.assertEqual(list(expected), [x[0] for x in self.results])
    else:
      self.assertNotEqual(len(self.results), 0, msg=msg)


class DocStringCheckerTest(CheckerTestCase):
  """Tests for DocStringChecker module"""

  GOOD_FUNC_DOCSTRINGS = (
      'Some string',
      """Short summary

      Body of text.
      """,
      """line o text

      Body and comments on
      more than one line.

      Args:
        moo: cow

      Returns:
        some value

      Raises:
        something else
      """,
      """Short summary.

      Args:
        fat: cat

      Yields:
        a spoon
      """,
      """Don't flag args variables as sections.

      Args:
        return: Foo!
      """,
      """the indentation is extra special

      Returns:
        First line is two spaces which is ok.
          Then we indent some more!
      """,
  )

  BAD_FUNC_DOCSTRINGS = (
      """
      bad first line
      """,
      """The first line is good
      but the second one isn't
      """,
      """ whitespace is wrong""",
      """whitespace is wrong	""",
      """ whitespace is wrong

      Multiline tickles differently.
      """,
      """Should be no trailing blank lines

      Returns:
        a value

      """,
      """ok line

      cuddled end""",
      """we want Args, not Arguments

      Arguments:
        some: arg
      """,
      """section order is wrong here

      Raises:
        It raised.

      Returns:
        It returned
      """,
      """sections are duplicated

      Returns:
        True

      Returns:
        or was it false
      """,
      """sections lack whitespace between them

      Args:
        foo: bar
      Returns:
        yeah
      """,
      """yields is misspelled

      Yield:
        a car
      """,
      """We want Examples, not Usage.

      Usage:
        a car
      """,
      """Section name has bad spacing

      Args:\x20\x20\x20
        key: here
      """,
      """too many blank lines


      Returns:
        None
      """,
      """wrongly uses javadoc

      @returns None
      """,
      """the indentation is incorrect

        Args:
          some: day
      """,
      """the final indentation is incorrect

      Blah.
       """,
      """the indentation is incorrect

      Returns:
       one space but should be two
      """,
      """the indentation is incorrect

      Returns:
         three spaces but should be two (and we have just one line)
      """,
      """the indentation is incorrect

      Args:
         some: has three spaces but should be two
      """,
      """the indentation is incorrect

      Args:
       some: has one space but should be two
      """,
      """the indentation is incorrect

      Args:
          some: has four spaces but should be two
      """,
  )

  # The current linter isn't good enough yet to detect these.
  TODO_BAD_FUNC_DOCSTRINGS = (
      """The returns section isn't a proper section

      Args:
        bloop: de

      returns something
      """,
  )

  CHECKER = lint.DocStringChecker

  def testGood_visit_function(self):
    """Allow known good docstrings"""
    for dc in self.GOOD_FUNC_DOCSTRINGS:
      self.results = []
      node = TestNode(doc=dc, display_type=None, col_offset=4)
      self.checker.visit_function(node)
      self.assertLintPassed(msg='docstring was not accepted:\n"""%s"""' % dc)

  def testBad_visit_function(self):
    """Reject known bad docstrings"""
    for dc in self.BAD_FUNC_DOCSTRINGS:
      self.results = []
      node = TestNode(doc=dc, display_type=None, col_offset=4)
      self.checker.visit_function(node)
      self.assertLintFailed(msg='docstring was not rejected:\n"""%s"""' % dc)

  def testSmoke_visit_module(self):
    """Smoke test for modules"""
    self.checker.visit_module(TestNode(doc='foo'))
    self.assertLintPassed()
    self.checker.visit_module(TestNode(doc='', path='/foo/__init__.py'))
    self.assertLintPassed()

  def testSmoke_visit_class(self):
    """Smoke test for classes"""
    self.checker.visit_class(TestNode(doc='bar'))

  def testGood_check_first_line(self):
    """Verify _check_first_line accepts good inputs"""
    docstrings = (
        'Some string',
    )
    for dc in docstrings:
      self.results = []
      node = TestNode(doc=dc)
      self.checker._check_first_line(node, node.lines)
      self.assertLintPassed(msg='docstring was not accepted:\n"""%s"""' % dc)

  def testBad_check_first_line(self):
    """Verify _check_first_line rejects bad inputs"""
    docstrings = (
        '\nSome string\n',
    )
    for dc in docstrings:
      self.results = []
      node = TestNode(doc=dc)
      self.checker._check_first_line(node, node.lines)
      self.assertLintFailed(expected=('C9009',))

  def testGood_check_second_line_blank(self):
    """Verify _check_second_line_blank accepts good inputs"""
    docstrings = (
        'Some string\n\nThis is the third line',
        'Some string',
    )
    for dc in docstrings:
      self.results = []
      node = TestNode(doc=dc)
      self.checker._check_second_line_blank(node, node.lines)
      self.assertLintPassed(msg='docstring was not accepted:\n"""%s"""' % dc)

  def testBad_check_second_line_blank(self):
    """Verify _check_second_line_blank rejects bad inputs"""
    docstrings = (
        'Some string\nnonempty secondline',
    )
    for dc in docstrings:
      self.results = []
      node = TestNode(doc=dc)
      self.checker._check_second_line_blank(node, node.lines)
      self.assertLintFailed(expected=('C9014',))

  def testGoodFuncVarKwArg(self):
    """Check valid inputs for *args and **kwargs"""
    for vararg in (None, 'args', '_args'):
      for kwarg in (None, 'kwargs', '_kwargs'):
        self.results = []
        node = TestNode(vararg=vararg, kwarg=kwarg)
        self.checker._check_func_signature(node)
        self.assertLintPassed()

  def testMisnamedFuncVarKwArg(self):
    """Reject anything but *args and **kwargs"""
    for vararg in ('arg', 'params', 'kwargs', '_moo'):
      self.results = []
      node = TestNode(vararg=vararg)
      self.checker._check_func_signature(node)
      self.assertLintFailed(expected=('C9011',))

    for kwarg in ('kwds', '_kwds', 'args', '_moo'):
      self.results = []
      node = TestNode(kwarg=kwarg)
      self.checker._check_func_signature(node)
      self.assertLintFailed(expected=('C9011',))

  def testGoodFuncArgs(self):
    """Verify normal args in Args are allowed"""
    datasets = (
        ("""args are correct, and cls is ignored

         Args:
           moo: cow
         """,
         ('cls', 'moo',), None, None,
        ),
        ("""args are correct, and self is ignored

         Args:
           moo: cow
           *args: here
         """,
         ('self', 'moo',), 'args', 'kwargs',
        ),
        ("""args are allowed to have annotations

         Args:
           moo (Cow): cow
         """,
         ('moo',), None, None,
        ),
        ("""args are allowed to wrap

         Args:
           moo:
             a big fat cow
             that takes many lines
             to describe its fatness
         """,
         ('moo',), None, 'kwargs',
        ),
    )
    for dc, args, vararg, kwarg in datasets:
      self.results = []
      node = TestNode(doc=dc, args=args, vararg=vararg, kwarg=kwarg)
      sections = self.checker._parse_docstring_sections(node, node.lines)
      self.checker._check_all_args_in_doc(node, node.lines, sections)
      self.assertLintPassed()

  def testBadFuncArgs(self):
    """Verify bad/missing args in Args are caught"""
    datasets = (
        ("""missing 'bar'

         Args:
           moo: cow
         """,
         ('moo', 'bar',),
        ),
        ("""missing 'cow' but has 'bloop'

         Args:
           moo: cow
         """,
         ('bloop',),
        ),
        ("""too much space after colon

         Args:
           moo:  cow
         """,
         ('moo',),
        ),
        ("""not enough space after colon

         Args:
           moo:cow
         """,
         ('moo',),
        ),
        ("""too much space after type and colon

         Args:
           moo (Cow):  cow
         """,
         ('moo',),
        ),
    )
    for dc, args in datasets:
      self.results = []
      node = TestNode(doc=dc, args=args)
      sections = self.checker._parse_docstring_sections(node, node.lines)
      self.checker._check_all_args_in_doc(node, node.lines, sections)
      self.assertLintFailed()

  def test_parse_docstring_sections(self):
    """Check docstrings are parsed."""
    datasets = (
        ("""Some docstring

         Args:
           foo: blah

         Raises:
           blaaaaaah

         Note:
           This section shouldn't be checked.

         Returns:
           some value
         """, [
             ('Args', lint.DocStringSectionDetails(
                 name='Args',
                 header='         Args:',
                 lines=['           foo: blah'],
                 lineno=3)),
             ('Raises', lint.DocStringSectionDetails(
                 name='Raises',
                 header='         Raises:',
                 lines=['           blaaaaaah'],
                 lineno=6)),
             ('Returns', lint.DocStringSectionDetails(
                 name='Returns',
                 header='         Returns:',
                 lines=['           some value'],
                 lineno=12)),
         ]),
    )
    for dc, expected in datasets:
      node = TestNode(doc=dc)
      sections = self.checker._parse_docstring_sections(node, node.lines)
      self.assertEqual(expected, sections.items())


class ChromiteLoggingCheckerTest(CheckerTestCase):
  """Tests for ChromiteLoggingChecker module"""

  CHECKER = lint.ChromiteLoggingChecker

  def testLoggingImported(self):
    """Test that import logging is flagged."""
    node = TestNode(names=[('logging', None)], lineno=15)
    self.checker.visit_import(node)
    self.assertEqual(self.results, [('R9301', '', 15, None)])

  def testLoggingNotImported(self):
    """Test that importing something else (not logging) is not flagged."""
    node = TestNode(names=[('myModule', None)], lineno=15)
    self.checker.visit_import(node)
    self.assertLintPassed()


class SourceCheckerTest(CheckerTestCase):
  """Tests for SourceChecker module"""

  CHECKER = lint.SourceChecker

  def _testShebang(self, shebangs, exp, mode):
    """Helper for shebang tests"""
    for shebang in shebangs:
      self.results = []
      node = TestNode()
      stream = StringIO.StringIO(shebang)
      st = StatStub(size=len(shebang), mode=mode)
      self.checker._check_shebang(node, stream, st)
      msg = 'processing shebang failed: %r' % shebang
      if not exp:
        self.assertLintPassed(msg=msg)
      else:
        self.assertLintFailed(msg=msg, expected=exp)

  def testBadShebang(self):
    """Verify _check_shebang rejects bad shebangs"""
    shebangs = (
        '#!/usr/bin/python\n',
        '#! /usr/bin/python2 \n',
        '#!/usr/bin/env python\n',
        '#! /usr/bin/env python2 \n',
        '#!/usr/bin/python2\n',
    )
    self._testShebang(shebangs, ('R9200',), 0o755)

  def testGoodShebangNoExec(self):
    """Verify _check_shebang rejects shebangs on non-exec files"""
    shebangs = (
        '#!/usr/bin/env python2\n',
        '#!/usr/bin/env python3\n',
    )
    self._testShebang(shebangs, ('R9202',), 0o644)

  def testGoodShebang(self):
    """Verify _check_shebang accepts good shebangs"""
    shebangs = (
        '#!/usr/bin/env python2\n',
        '#!/usr/bin/env python3\n',
        '#!/usr/bin/env python2\t\n',
    )
    self._testShebang(shebangs, (), 0o755)

  def testEmptyFileNoEncoding(self):
    """_check_encoding should ignore 0 byte files"""
    node = TestNode()
    self.results = []
    stream = StringIO.StringIO('')
    self.checker._check_encoding(node, stream, StatStub())
    self.assertLintPassed()

  def testMissingEncoding(self):
    """_check_encoding should fail when there is no encoding"""
    headers = (
        '#',
        '#\n',
        '#\n#',
        '#\n#\n',
        '#!/usr/bin/python\n# foo\n'
        '#!/usr/bin/python\n',
        '# some comment\n',
        '# some comment\n# another line\n',
        '# first line is not a shebang\n# -*- coding: utf-8 -*-\n',
        '#!/usr/bin/python\n# second line\n# -*- coding: utf-8 -*-\n',
    )
    node = TestNode()
    for header in headers:
      self.results = []
      stream = StringIO.StringIO(header)
      self.checker._check_encoding(node, stream, StatStub(size=len(header)))
      self.assertLintFailed(expected=('R9204',))

  def testBadEncoding(self):
    """_check_encoding should reject non-"utf-8" encodings"""
    encodings = (
        'UTF8', 'UTF-8', 'utf8', 'ISO-8859-1',
    )
    node = TestNode()
    for encoding in encodings:
      self.results = []
      header = '# -*- coding: %s -*-\n' % (encoding,)
      stream = StringIO.StringIO(header)
      self.checker._check_encoding(node, stream, StatStub(size=len(header)))
      self.assertLintFailed(expected=('R9205',))

  def testGoodEncodings(self):
    """Verify _check_encoding accepts various correct encoding forms"""
    shebang = '#!/usr/bin/python\n'
    encodings = (
        '# -*- coding: utf-8 -*-',
    )
    node = TestNode()
    self.results = []
    for first in ('', shebang):
      for encoding in encodings:
        data = first + encoding + '\n'
        stream = StringIO.StringIO(data)
        self.checker._check_encoding(node, stream, StatStub(size=len(data)))
        self.assertLintPassed()

  def testGoodUnittestName(self):
    """Verify _check_module_name accepts good unittest names"""
    module_names = (
        'lint_unittest',
    )
    for name in module_names:
      node = TestNode(name=name)
      self.results = []
      self.checker._check_module_name(node)
      self.assertLintPassed()

  def testBadUnittestName(self):
    """Verify _check_module_name rejects bad unittest names"""
    module_names = (
        'lint_unittests',
    )
    for name in module_names:
      node = TestNode(name=name)
      self.results = []
      self.checker._check_module_name(node)
      self.assertLintFailed(expected=('R9203',))