Move the run() method in Manager, and make the needs_servers method private.

third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/controllers/manager.py

 # Copyright (C) 2010 Google Inc. All rights reserved.
 # Copyright (C) 2010 Gabor Rapcsanyi (rgabor@inf.u-szeged.hu), University of Szeged
 #
 # 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
@@ skipping 78 matching lines @@
         self.LAYOUT_TESTS_DIRECTORY = 'LayoutTests'
         self.ARCHIVED_RESULTS_LIMIT = 25
         self._http_server_started = False
         self._wptserve_started = False
         self._websockets_server_started = False
 
         self._results_directory = self._port.results_directory()
         self._finder = LayoutTestFinder(self._port, self._options)
         self._runner = LayoutTestRunner(self._options, self._port, self._printer, self._results_directory, self._test_is_slow)
 
+    def run(self, args):
+        """Run the tests and return a RunDetails object with the results."""
+        start_time = time.time()
+        self._printer.write_update("Collecting tests ...")
+        running_all_tests = False
+        try:
+            paths, test_names, running_all_tests = self._collect_tests(args)
+        except IOError:
+            # This is raised if --test-list doesn't exist
+            return test_run_results.RunDetails(exit_code=test_run_results.NO_TESTS_EXIT_STATUS)
+
+        self._printer.write_update("Parsing expectations ...")
+        self._expectations = test_expectations.TestExpectations(self._port, test_names)
+
+        tests_to_run, tests_to_skip = self._prepare_lists(paths, test_names)
+        self._printer.print_found(len(test_names), len(tests_to_run), self._options.repeat_each, self._options.iterations)
+
+        # Check to make sure we're not skipping every test.
+        if not tests_to_run:
+            _log.critical('No tests to run.')
+            return test_run_results.RunDetails(exit_code=test_run_results.NO_TESTS_EXIT_STATUS)
+
+        exit_code = self._set_up_run(tests_to_run)
+        if exit_code:
+            return test_run_results.RunDetails(exit_code=exit_code)
+
+        # Don't retry failures if an explicit list of tests was passed in.
+        if self._options.retry_failures is None:
+            should_retry_failures = len(paths) < len(test_names)
+        else:
+            should_retry_failures = self._options.retry_failures
+
+        enabled_pixel_tests_in_retry = False
+        try:
+            self._start_servers(tests_to_run)
+
+            num_workers = self._port.num_workers(int(self._options.child_processes))
+
+            initial_results = self._run_tests(
+                tests_to_run, tests_to_skip, self._options.repeat_each, self._options.iterations,
+                num_workers)
+
+            # Don't retry failures when interrupted by user or failures limit exception.
+            should_retry_failures = should_retry_failures and not (
+                initial_results.interrupted or initial_results.keyboard_interrupted)
+
+            tests_to_retry = self._tests_to_retry(initial_results)
+            all_retry_results = []
+            if should_retry_failures and tests_to_retry:
+                enabled_pixel_tests_in_retry = self._force_pixel_tests_if_needed()
+
+                for retry_attempt in xrange(1, self._options.num_retries + 1):
+                    if not tests_to_retry:
+                        break
+
+                    _log.info('')
+                    _log.info('Retrying %s, attempt %d of %d...' %
+                              (grammar.pluralize('unexpected failure', len(tests_to_retry)),
+                               retry_attempt, self._options.num_retries))
+
+                    retry_results = self._run_tests(tests_to_retry,
+                                                    tests_to_skip=set(),
+                                                    repeat_each=1,
+                                                    iterations=1,
+                                                    num_workers=num_workers,
+                                                    retry_attempt=retry_attempt)
+                    all_retry_results.append(retry_results)
+
+                    tests_to_retry = self._tests_to_retry(retry_results)
+
+                if enabled_pixel_tests_in_retry:
+                    self._options.pixel_tests = False
+        finally:
+            self._stop_servers()
+            self._clean_up_run()
+
+        # Some crash logs can take a long time to be written out so look
+        # for new logs after the test run finishes.
+        self._printer.write_update("looking for new crash logs")
+        self._look_for_new_crash_logs(initial_results, start_time)
+        for retry_attempt_results in all_retry_results:
+            self._look_for_new_crash_logs(retry_attempt_results, start_time)
+
+        _log.debug("summarizing results")
+        summarized_full_results = test_run_results.summarize_results(
+            self._port, self._expectations, initial_results, all_retry_results,
+            enabled_pixel_tests_in_retry)
+        summarized_failing_results = test_run_results.summarize_results(
+            self._port, self._expectations, initial_results, all_retry_results,
+            enabled_pixel_tests_in_retry, only_include_failing=True)
+
+        exit_code = summarized_failing_results['num_regressions']
+        if exit_code > test_run_results.MAX_FAILURES_EXIT_STATUS:
+            _log.warning('num regressions (%d) exceeds max exit status (%d)' %
+                         (exit_code, test_run_results.MAX_FAILURES_EXIT_STATUS))
+            exit_code = test_run_results.MAX_FAILURES_EXIT_STATUS
+
+        if not self._options.dry_run:
+            self._write_json_files(summarized_full_results, summarized_failing_results, initial_results, running_all_tests)
+
+            if self._options.write_full_results_to:
+                self._filesystem.copyfile(self._filesystem.join(self._results_directory, "full_results.json"),
+                                          self._options.write_full_results_to)
+
+            self._upload_json_files()
+
+            results_path = self._filesystem.join(self._results_directory, "results.html")
+            self._copy_results_html_file(results_path)
+            if initial_results.keyboard_interrupted:
+                exit_code = test_run_results.INTERRUPTED_EXIT_STATUS
+            else:
+                if initial_results.interrupted:
+                    exit_code = test_run_results.EARLY_EXIT_STATUS
+                if self._options.show_results and (exit_code or (self._options.full_results_html and initial_results.total_failures)):
+                    self._port.show_results_html_file(results_path)
+                self._printer.print_results(time.time() - start_time, initial_results, summarized_failing_results)
+
+        return test_run_results.RunDetails(
+            exit_code, summarized_full_results, summarized_failing_results,
+            initial_results, all_retry_results, enabled_pixel_tests_in_retry)
+
     def _collect_tests(self, args):
         return self._finder.find_tests(args, test_list=self._options.test_list,
                                        fastest_percentile=self._options.fastest)
 
     def _is_http_test(self, test):
         return (
             test.startswith(self.HTTP_SUBDIR) or
             self._is_websocket_test(test) or
             self.VIRTUAL_HTTP_SUBDIR in test
         )
@@ skipping 52 matching lines @@
         """
         return self._is_http_test(test_file) or self._is_perf_test(test_file)
 
     def _test_is_expected_missing(self, test_file):
         expectations = self._expectations.model().get_expectations(test_file)
         return test_expectations.MISSING in expectations or test_expectations.NEEDS_REBASELINE in expectations or test_expectations.NEEDS_MANUAL_REBASELINE in expectations
 
     def _test_is_slow(self, test_file):
         return test_expectations.SLOW in self._expectations.model().get_expectations(test_file)
 
-    def needs_servers(self, test_names):
+    def _needs_servers(self, test_names):
         return any(self._test_requires_lock(test_name) for test_name in test_names)
 
     def _rename_results_folder(self):
         try:
             timestamp = time.strftime(
                 "%Y-%m-%d-%H-%M-%S", time.localtime(self._filesystem.mtime(self._filesystem.join(self._results_directory, "results.html"))))
         except (IOError, OSError), e:
             # It might be possible that results.html was not generated in previous run, because the test
             # run was interrupted even before testing started. In those cases, don't archive the folder.
             # Simply override the current folder contents with new results.
@@ skipping 17 matching lines @@
             file_path = self._filesystem.join(results_directory_path, dir)
             if self._filesystem.isdir(file_path) and self._results_directory in file_path:
                 results_directories.append(file_path)
         results_directories.sort(key=lambda x: self._filesystem.mtime(x))
         self._printer.write_update("Clobbering excess archived results in %s" % results_directory_path)
         self._delete_dirs(results_directories[:-self.ARCHIVED_RESULTS_LIMIT])
 
     def _set_up_run(self, test_names):
         self._printer.write_update("Checking build ...")
         if self._options.build:
-            exit_code = self._port.check_build(self.needs_servers(test_names), self._printer)
+            exit_code = self._port.check_build(self._needs_servers(test_names), self._printer)
             if exit_code:
                 _log.error("Build check failed")
                 return exit_code
 
         # This must be started before we check the system dependencies,
         # since the helper may do things to make the setup correct.
         if self._options.pixel_tests:
             self._printer.write_update("Starting pixel test helper ...")
             self._port.start_helper()
 
         # Check that the system dependencies (themes, fonts, ...) are correct.
         if not self._options.nocheck_sys_deps:
             self._printer.write_update("Checking system dependencies ...")
-            exit_code = self._port.check_sys_deps(self.needs_servers(test_names))
+            exit_code = self._port.check_sys_deps(self._needs_servers(test_names))
             if exit_code:
                 self._port.stop_helper()
                 return exit_code
 
         if self._options.clobber_old_results:
             self._clobber_old_results()
         elif self._filesystem.exists(self._results_directory):
             self._limit_archived_results_count()
             # Rename the existing results folder for archiving.
             self._rename_results_folder()
 
         # Create the output directory if it doesn't already exist.
         self._port.host.filesystem.maybe_make_directory(self._results_directory)
 
         self._port.setup_test_run()
         return test_run_results.OK_EXIT_STATUS
 
-    def run(self, args):
-        """Run the tests and return a RunDetails object with the results."""
-        start_time = time.time()
-        self._printer.write_update("Collecting tests ...")
-        running_all_tests = False
-        try:
-            paths, test_names, running_all_tests = self._collect_tests(args)
-        except IOError:
-            # This is raised if --test-list doesn't exist
-            return test_run_results.RunDetails(exit_code=test_run_results.NO_TESTS_EXIT_STATUS)
-
-        self._printer.write_update("Parsing expectations ...")
-        self._expectations = test_expectations.TestExpectations(self._port, test_names)
-
-        tests_to_run, tests_to_skip = self._prepare_lists(paths, test_names)
-        self._printer.print_found(len(test_names), len(tests_to_run), self._options.repeat_each, self._options.iterations)
-
-        # Check to make sure we're not skipping every test.
-        if not tests_to_run:
-            _log.critical('No tests to run.')
-            return test_run_results.RunDetails(exit_code=test_run_results.NO_TESTS_EXIT_STATUS)
-
-        exit_code = self._set_up_run(tests_to_run)
-        if exit_code:
-            return test_run_results.RunDetails(exit_code=exit_code)
-
-        # Don't retry failures if an explicit list of tests was passed in.
-        if self._options.retry_failures is None:
-            should_retry_failures = len(paths) < len(test_names)
-        else:
-            should_retry_failures = self._options.retry_failures
-
-        enabled_pixel_tests_in_retry = False
-        try:
-            self._start_servers(tests_to_run)
-
-            num_workers = self._port.num_workers(int(self._options.child_processes))
-
-            initial_results = self._run_tests(
-                tests_to_run, tests_to_skip, self._options.repeat_each, self._options.iterations,
-                num_workers)
-
-            # Don't retry failures when interrupted by user or failures limit exception.
-            should_retry_failures = should_retry_failures and not (
-                initial_results.interrupted or initial_results.keyboard_interrupted)
-
-            tests_to_retry = self._tests_to_retry(initial_results)
-            all_retry_results = []
-            if should_retry_failures and tests_to_retry:
-                enabled_pixel_tests_in_retry = self._force_pixel_tests_if_needed()
-
-                for retry_attempt in xrange(1, self._options.num_retries + 1):
-                    if not tests_to_retry:
-                        break
-
-                    _log.info('')
-                    _log.info('Retrying %s, attempt %d of %d...' %
-                              (grammar.pluralize('unexpected failure', len(tests_to_retry)),
-                               retry_attempt, self._options.num_retries))
-
-                    retry_results = self._run_tests(tests_to_retry,
-                                                    tests_to_skip=set(),
-                                                    repeat_each=1,
-                                                    iterations=1,
-                                                    num_workers=num_workers,
-                                                    retry_attempt=retry_attempt)
-                    all_retry_results.append(retry_results)
-
-                    tests_to_retry = self._tests_to_retry(retry_results)
-
-                if enabled_pixel_tests_in_retry:
-                    self._options.pixel_tests = False
-        finally:
-            self._stop_servers()
-            self._clean_up_run()
-
-        # Some crash logs can take a long time to be written out so look
-        # for new logs after the test run finishes.
-        self._printer.write_update("looking for new crash logs")
-        self._look_for_new_crash_logs(initial_results, start_time)
-        for retry_attempt_results in all_retry_results:
-            self._look_for_new_crash_logs(retry_attempt_results, start_time)
-
-        _log.debug("summarizing results")
-        summarized_full_results = test_run_results.summarize_results(
-            self._port, self._expectations, initial_results, all_retry_results,
-            enabled_pixel_tests_in_retry)
-        summarized_failing_results = test_run_results.summarize_results(
-            self._port, self._expectations, initial_results, all_retry_results,
-            enabled_pixel_tests_in_retry, only_include_failing=True)
-
-        exit_code = summarized_failing_results['num_regressions']
-        if exit_code > test_run_results.MAX_FAILURES_EXIT_STATUS:
-            _log.warning('num regressions (%d) exceeds max exit status (%d)' %
-                         (exit_code, test_run_results.MAX_FAILURES_EXIT_STATUS))
-            exit_code = test_run_results.MAX_FAILURES_EXIT_STATUS
-
-        if not self._options.dry_run:
-            self._write_json_files(summarized_full_results, summarized_failing_results, initial_results, running_all_tests)
-
-            if self._options.write_full_results_to:
-                self._filesystem.copyfile(self._filesystem.join(self._results_directory, "full_results.json"),
-                                          self._options.write_full_results_to)
-
-            self._upload_json_files()
-
-            results_path = self._filesystem.join(self._results_directory, "results.html")
-            self._copy_results_html_file(results_path)
-            if initial_results.keyboard_interrupted:
-                exit_code = test_run_results.INTERRUPTED_EXIT_STATUS
-            else:
-                if initial_results.interrupted:
-                    exit_code = test_run_results.EARLY_EXIT_STATUS
-                if self._options.show_results and (exit_code or (self._options.full_results_html and initial_results.total_failures)):
-                    self._port.show_results_html_file(results_path)
-                self._printer.print_results(time.time() - start_time, initial_results, summarized_failing_results)
-
-        return test_run_results.RunDetails(
-            exit_code, summarized_full_results, summarized_failing_results,
-            initial_results, all_retry_results, enabled_pixel_tests_in_retry)
-
     def _run_tests(self, tests_to_run, tests_to_skip, repeat_each, iterations,
                    num_workers, retry_attempt=0):
 
         test_inputs = []
         for _ in xrange(iterations):
             for test in tests_to_run:
                 for _ in xrange(repeat_each):
                     test_inputs.append(self._test_input_for_file(test))
         return self._runner.run_tests(self._expectations, test_inputs,
                                       tests_to_skip, num_workers, retry_attempt)
@@ skipping 178 matching lines @@
 
         stats = {}
         for result in initial_results.results_by_name.values():
             if result.type != test_expectations.SKIP:
                 stats[result.test_name] = {'results': (_worker_number(result.worker_name), result.test_number, result.pid, int(
                     result.test_run_time * 1000), int(result.total_run_time * 1000))}
         stats_trie = {}
         for name, value in stats.iteritems():
             json_results_generator.add_path_to_trie(name, value, stats_trie)
         return stats_trie