Add checks for READMEs for each virtual test suite.

Tools/Scripts/webkitpy/layout_tests/lint_test_expectations_unittest.py

 # Copyright (C) 2012 Google Inc. All rights reserved.
 #
 # 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
@@ skipping 54 matching lines @@
     def path_to_generic_test_expectations_file(self):
         return ''
 
 class FakeFactory(object):
     def __init__(self, host, ports):
         self.host = host
         self.ports = {}
         for port in ports:
             self.ports[port.name] = port
 
-    def get(self, port_name, *args, **kwargs):  # pylint: disable=W0613,E0202
+    def get(self, port_name='a', *args, **kwargs):  # pylint: disable=W0613,E0202
         return self.ports[port_name]
 
     def all_port_names(self, platform=None):  # pylint: disable=W0613,E0202
         return sorted(self.ports.keys())
 
 
 class LintTest(unittest.TestCase):
     def test_all_configurations(self):
         host = MockHost()
         host.ports_parsed = []
         host.port_factory = FakeFactory(host, (FakePort(host, 'a', 'path-to-a'),
                                                FakePort(host, 'b', 'path-to-b'),
                                                FakePort(host, 'b-win', 'path-to-b')))
 
         logging_stream = StringIO.StringIO()
         options = optparse.Values({'platform': None})
-        res = lint_test_expectations.lint(host, options, logging_stream)
+        logger, handler = lint_test_expectations.set_up_logging(logging_stream)
+        try:
+            res = lint_test_expectations.lint(host, options)
+        finally:
+            lint_test_expectations.tear_down_logging(logger, handler)
         self.assertEqual(res, 0)
         self.assertEqual(host.ports_parsed, ['a', 'b', 'b-win'])
 
     def test_lint_test_files(self):
         logging_stream = StringIO.StringIO()
         options = optparse.Values({'platform': 'test-mac-leopard'})
         host = MockHost()
 
         # pylint appears to complain incorrectly about the method overrides pylint: disable=E0202,C0322
         # FIXME: incorrect complaints about spacing pylint: disable=C0322
         host.port_factory.all_port_names = lambda platform=None: [platform]
 
-        res = lint_test_expectations.lint(host, options, logging_stream)
+        logger, handler = lint_test_expectations.set_up_logging(logging_stream)
+        try:
+            res = lint_test_expectations.lint(host, options)
+            self.assertEqual(res, 0)
+        finally:
+            lint_test_expectations.tear_down_logging(logger, handler)
 
-        self.assertEqual(res, 0)
-        self.assertIn('Lint succeeded', logging_stream.getvalue())
 
     def test_lint_test_files__errors(self):
         options = optparse.Values({'platform': 'test', 'debug_rwt_logging': False})
         host = MockHost()
 
         # FIXME: incorrect complaints about spacing pylint: disable=C0322
         port = host.port_factory.get(options.platform, options=options)
         port.expectations_dict = lambda: {'foo': '-- syntax error1', 'bar': '-- syntax error2'}
 
         host.port_factory.get = lambda platform, options=None: port
         host.port_factory.all_port_names = lambda platform=None: [port.name()]
 
         logging_stream = StringIO.StringIO()
+        logger, handler = lint_test_expectations.set_up_logging(logging_stream)
+        try:
+            res = lint_test_expectations.lint(host, options)
+        finally:
+            lint_test_expectations.tear_down_logging(logger, handler)
 
-        res = lint_test_expectations.lint(host, options, logging_stream)
-
-        self.assertEqual(res, -1)
-        self.assertIn('Lint failed', logging_stream.getvalue())
+        self.assertTrue(res)
         self.assertIn('foo:1', logging_stream.getvalue())
         self.assertIn('bar:1', logging_stream.getvalue())
 
 
+class CheckVirtualSuiteTest(unittest.TestCase):
+    def test_check_virtual_test_suites(self):
+        host = MockHost()
+        options = optparse.Values({'platform': 'test', 'debug_rwt_logging': False})
+        orig_get = host.port_factory.get
+        host.port_factory.get = lambda options: orig_get('test', options=options)
+
+        logging_stream = StringIO.StringIO()
+        logger, handler = lint_test_expectations.set_up_logging(logging_stream)
+        try:
+            res = lint_test_expectations.check_virtual_test_suites(host, options)
+            self.assertTrue(res)
+
+            host.filesystem.exists = lambda path: True
+            res = lint_test_expectations.check_virtual_test_suites(host, options)
+            self.assertFalse(res)
+        finally:
+            lint_test_expectations.tear_down_logging(logger, handler)
+
+
 class MainTest(unittest.TestCase):
+    # unused args pylint: disable=W0613
+
+    def setUp(self):
+        self.orig_lint_fn = lint_test_expectations.lint
+        self.orig_check_fn = lint_test_expectations.check_virtual_test_suites
+        lint_test_expectations.check_virtual_test_suites = lambda host, options: False
+
+        self.stdout = StringIO.StringIO()
+        self.stderr = StringIO.StringIO()
+
+    def tearDown(self):
+        lint_test_expectations.lint = self.orig_lint_fn
+        lint_test_expectations.check_virtual_test_suites = self.orig_check_fn
+
     def test_success(self):
-        orig_lint_fn = lint_test_expectations.lint
+        lint_test_expectations.lint = lambda host, options: False
+        res = lint_test_expectations.main(['--platform', 'test'], self.stdout, self.stderr)
+        self.assertTrue('Lint succeeded' in self.stderr.getvalue())
+        self.assertEqual(res, 0)
 
-        # unused args pylint: disable=W0613
-        def interrupting_lint(host, options, logging_stream):
+    def test_failure(self):
+        lint_test_expectations.lint = lambda host, options: True
+        res = lint_test_expectations.main(['--platform', 'test'], self.stdout, self.stderr)
+        self.assertTrue('Lint failed' in self.stderr.getvalue())
+        self.assertEqual(res, 1)
+
+    def test_interrupt(self):
+        def interrupting_lint(host, options):
             raise KeyboardInterrupt
 
-        def successful_lint(host, options, logging_stream):
-            return 0
+        lint_test_expectations.lint = interrupting_lint
+        res = lint_test_expectations.main([], self.stdout, self.stderr)
+        self.assertEqual(res, lint_test_expectations.INTERRUPTED_EXIT_STATUS)
 
-        def exception_raising_lint(host, options, logging_stream):
+    def test_exception(self):
+        def exception_raising_lint(host, options):
             assert False
-
-        stdout = StringIO.StringIO()
-        stderr = StringIO.StringIO()
-        try:
-            lint_test_expectations.lint = interrupting_lint
-            res = lint_test_expectations.main([], stdout, stderr)
-            self.assertEqual(res, lint_test_expectations.INTERRUPTED_EXIT_STATUS)
-
-            lint_test_expectations.lint = successful_lint
-            res = lint_test_expectations.main(['--platform', 'test'], stdout, stderr)
-            self.assertEqual(res, 0)
-
-            lint_test_expectations.lint = exception_raising_lint
-            res = lint_test_expectations.main([], stdout, stderr)
-            self.assertEqual(res, lint_test_expectations.EXCEPTIONAL_EXIT_STATUS)
-        finally:
-            lint_test_expectations.lint = orig_lint_fn
+        lint_test_expectations.lint = exception_raising_lint
+        res = lint_test_expectations.main([], self.stdout, self.stderr)
+        self.assertEqual(res, lint_test_expectations.EXCEPTIONAL_EXIT_STATUS)