Regenerate MANIFEST.json when WPT tests are run

third_party/WebKit/Tools/Scripts/webkitpy/common/host_mock.py

 # Copyright (C) 2011 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 13 matching lines @@
 # 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.
 
 from webkitpy.common.config.builders import BUILDERS
 from webkitpy.common.checkout.git_mock import MockGit
 from webkitpy.common.net.buildbot_mock import MockBuildBot
 from webkitpy.common.net.web_mock import MockWeb
 from webkitpy.common.system.system_host_mock import MockSystemHost
+from webkitpy.common.webkit_finder import WebKitFinder
 
 # New-style ports need to move down into webkitpy.common.
 from webkitpy.layout_tests.builder_list import BuilderList
 from webkitpy.layout_tests.port.factory import PortFactory
 from webkitpy.layout_tests.port.test import add_unit_tests_to_mock_filesystem
 
 
 class MockHost(MockSystemHost):
 
     def __init__(self,
                  log_executive=False,
                  web=None,
                  git=None,
                  os_name=None,
                  os_version=None,
                  time_return_val=123):
         super(MockHost, self).__init__(
             log_executive=log_executive,
             os_name=os_name,
             os_version=os_version,
             time_return_val=time_return_val)
 
         add_unit_tests_to_mock_filesystem(self.filesystem)
+        self._add_base_manifest_to_mock_filesystem(self.filesystem)
         self.web = web or MockWeb()
         self._git = git
 
         self.buildbot = MockBuildBot()
 
         # Note: We're using a real PortFactory here.  Tests which don't wish to depend
         # on the list of known ports should override this with a MockPortFactory.
         self.port_factory = PortFactory(self)
 
         self.builders = BuilderList(BUILDERS)
 
     def git(self, path=None):
         if path:
             return MockGit(cwd=path, filesystem=self.filesystem, executive=self.executive)
         if not self._git:
             self._git = MockGit(filesystem=self.filesystem, executive=self.executive)
         # Various pieces of code (wrongly) call filesystem.chdir(checkout_root).
         # Making the checkout_root exist in the mock filesystem makes that chdir not raise.
         self.filesystem.maybe_make_directory(self._git.checkout_root)
         return self._git
+
+    def _add_base_manifest_to_mock_filesystem(self, filesystem):
+        webkit_finder = WebKitFinder(filesystem)
+        wpt_dir = webkit_finder.path_from_webkit_base('LayoutTests', 'external', 'wpt')
+        filesystem.maybe_make_directory(wpt_dir)
+
+        manifest_base_path = webkit_finder.path_from_webkit_base(
+            'LayoutTests', 'external', 'WPT_BASE_MANIFEST.json')

[foolip, 2017/02/28 04:49:17]

Had an idea while looking at this line. Would it be possible to put the
generated MANIFEST.json in the same dir next to this to trivially get around it
including itself? Or even better, somewhere in the out/ directory?

Presumably the code that knows where MANIFEST.json is expected to be is under
our control so we could just change that? (If there's some upstream code that
uses the location of MANIFEST.json, that'd be a problem, but we could change
that too probably if it's the right thing.)

[qyearsley, 2017/02/28 18:54:45]

This sounds reasonable to me -- I'd be fine with this change in this CL or a
follow-up CL if you think it's a good idea. The manifest generator script takes
a --path argument which should be the path to the manifest file. The
_ensure_manifest method would still copy the base over to the manifest path and
then run the manifest generator command.

If this is done, the knowledge about where the manifest file is should be kept
in one place, probably webkitpy/w3c/wpt_manifest.py.

+        filesystem.files[manifest_base_path] = '{}'