The Tor Browser: dom/bindings/mozwebidlcodegen/test/test_mozwebidlcodegen.py@6474c204b198 (annotated)

dom/bindings/mozwebidlcodegen/test/test_mozwebidlcodegen.py@6474c204b198 (annotated)

dom/bindings/mozwebidlcodegen/test/test_mozwebidlcodegen.py

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 from __future__ import unicode_literals
 import imp
 import json
 import os
 import shutil
 import sys
 import tempfile
 import unittest
 import mozpack.path as mozpath
 from mozwebidlcodegen import (
     WebIDLCodegenManager,
     WebIDLCodegenManagerState,
 )
 from mozfile import NamedTemporaryFile
 from mozunit import (
     MockedOpen,
     main,
 )
 OUR_DIR = mozpath.abspath(mozpath.dirname(__file__))
 TOPSRCDIR = mozpath.normpath(mozpath.join(OUR_DIR, '..', '..', '..', '..'))
 class TestWebIDLCodegenManager(unittest.TestCase):
     TEST_STEMS = {
         'Child',
         'Parent',
         'ExampleBinding',
         'TestEvent',
     }
     @property
     def _static_input_paths(self):
         s = {mozpath.join(OUR_DIR, p) for p in os.listdir(OUR_DIR)
             if p.endswith('.webidl')}
         return s
     @property
     def _config_path(self):
         config = mozpath.join(TOPSRCDIR, 'dom', 'bindings', 'Bindings.conf')
         self.assertTrue(os.path.exists(config))
         return config
     def _get_manager_args(self):
         tmp = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp)
         cache_dir = mozpath.join(tmp, 'cache')
         os.mkdir(cache_dir)
         ip = self._static_input_paths
         inputs = (
             ip,
             {mozpath.splitext(mozpath.basename(p))[0] for p in ip},
             set(),
             set(),
         )
         return dict(
             config_path=self._config_path,
             inputs=inputs,
             exported_header_dir=mozpath.join(tmp, 'exports'),
             codegen_dir=mozpath.join(tmp, 'codegen'),
             state_path=mozpath.join(tmp, 'state.json'),
             make_deps_path=mozpath.join(tmp, 'codegen.pp'),
             make_deps_target='codegen.pp',
             cache_dir=cache_dir,
         )
     def _get_manager(self):
         return WebIDLCodegenManager(**self._get_manager_args())
     def test_unknown_state_version(self):
         """Loading a state file with a too new version resets state."""
         args = self._get_manager_args()
         p = args['state_path']
         with open(p, 'wb') as fh:
             json.dump({
                 'version': WebIDLCodegenManagerState.VERSION + 1,
                 'foobar': '1',
             }, fh)
         manager = WebIDLCodegenManager(**args)
         self.assertEqual(manager._state['version'],
             WebIDLCodegenManagerState.VERSION)
         self.assertNotIn('foobar', manager._state)
     def test_generate_build_files(self):
         """generate_build_files() does the right thing from empty."""
         manager = self._get_manager()
         result = manager.generate_build_files()
         self.assertEqual(len(result.inputs), 5)
         output = manager.expected_build_output_files()
         self.assertEqual(result.created, output)
         self.assertEqual(len(result.updated), 0)
         self.assertEqual(len(result.unchanged), 0)
         for f in output:
             self.assertTrue(os.path.isfile(f))
         for f in manager.GLOBAL_DECLARE_FILES:
             self.assertIn(mozpath.join(manager._exported_header_dir, f), output)
         for f in manager.GLOBAL_DEFINE_FILES:
             self.assertIn(mozpath.join(manager._codegen_dir, f), output)
         for s in self.TEST_STEMS:
             self.assertTrue(os.path.isfile(mozpath.join(
                 manager._exported_header_dir, '%sBinding.h' % s)))
             self.assertTrue(os.path.isfile(mozpath.join(
                 manager._codegen_dir, '%sBinding.cpp' % s)))
         self.assertTrue(os.path.isfile(manager._state_path))
         with open(manager._state_path, 'rb') as fh:
             state = json.load(fh)
             self.assertEqual(state['version'], 1)
             self.assertIn('webidls', state)
             child = state['webidls']['Child.webidl']
             self.assertEqual(len(child['inputs']), 2)
             self.assertEqual(len(child['outputs']), 2)
             self.assertEqual(child['sha1'], 'c41527cad3bc161fa6e7909e48fa11f9eca0468b')
     def test_generate_build_files_load_state(self):
         """State should be equivalent when instantiating a new instance."""
         args = self._get_manager_args()
         m1 = WebIDLCodegenManager(**args)
         self.assertEqual(len(m1._state['webidls']), 0)
         m1.generate_build_files()
         m2 = WebIDLCodegenManager(**args)
         self.assertGreater(len(m2._state['webidls']), 2)
         self.assertEqual(m1._state, m2._state)
     def test_no_change_no_writes(self):
         """If nothing changes, no files should be updated."""
         args = self._get_manager_args()
         m1 = WebIDLCodegenManager(**args)
         m1.generate_build_files()
         m2 = WebIDLCodegenManager(**args)
         result = m2.generate_build_files()
         self.assertEqual(len(result.inputs), 0)
         self.assertEqual(len(result.created), 0)
         self.assertEqual(len(result.updated), 0)
     def test_output_file_regenerated(self):
         """If an output file disappears, it is regenerated."""
         args = self._get_manager_args()
         m1 = WebIDLCodegenManager(**args)
         m1.generate_build_files()
         rm_count = 0
         for p in m1._state['webidls']['Child.webidl']['outputs']:
             rm_count += 1
             os.unlink(p)
         for p in m1.GLOBAL_DECLARE_FILES:
             rm_count += 1
             os.unlink(mozpath.join(m1._exported_header_dir, p))
         m2 = WebIDLCodegenManager(**args)
         result = m2.generate_build_files()
         self.assertEqual(len(result.created), rm_count)
     def test_only_rebuild_self(self):
         """If an input file changes, only rebuild that one file."""
         args = self._get_manager_args()
         m1 = WebIDLCodegenManager(**args)
         m1.generate_build_files()
         child_path = None
         for p in m1._input_paths:
             if p.endswith('Child.webidl'):
                 child_path = p
                 break
         self.assertIsNotNone(child_path)
         child_content = open(child_path, 'rb').read()
         with MockedOpen({child_path: child_content + '\n/* */'}):
             m2 = WebIDLCodegenManager(**args)
             result = m2.generate_build_files()
             self.assertEqual(result.inputs, set([child_path]))
             self.assertEqual(len(result.updated), 0)
             self.assertEqual(len(result.created), 0)
     def test_rebuild_dependencies(self):
         """Ensure an input file used by others results in others rebuilding."""
         args = self._get_manager_args()
         m1 = WebIDLCodegenManager(**args)
         m1.generate_build_files()
         parent_path = None
         child_path = None
         for p in m1._input_paths:
             if p.endswith('Parent.webidl'):
                 parent_path = p
             elif p.endswith('Child.webidl'):
                 child_path = p
         self.assertIsNotNone(parent_path)
         parent_content = open(parent_path, 'rb').read()
         with MockedOpen({parent_path: parent_content + '\n/* */'}):
             m2 = WebIDLCodegenManager(**args)
             result = m2.generate_build_files()
             self.assertEqual(result.inputs, {child_path, parent_path})
             self.assertEqual(len(result.updated), 0)
             self.assertEqual(len(result.created), 0)
     def test_python_change_regenerate_everything(self):
         """If a Python file changes, we should attempt to rebuild everything."""
         # We don't want to mutate files in the source directory because we want
         # to be able to build from a read-only filesystem. So, we install a
         # dummy module and rewrite the metadata to say it comes from the source
         # directory.
         #
         # Hacking imp to accept a MockedFile doesn't appear possible. So for
         # the first iteration we read from a temp file. The second iteration
         # doesn't need to import, so we are fine with a mocked file.
         fake_path = mozpath.join(OUR_DIR, 'fakemodule.py')
         with NamedTemporaryFile('wt') as fh:
             fh.write('# Original content')
             fh.flush()
             mod = imp.load_source('mozwebidlcodegen.fakemodule', fh.name)
             mod.__file__ = fake_path
             args = self._get_manager_args()
             m1 = WebIDLCodegenManager(**args)
             with MockedOpen({fake_path: '# Original content'}):
                 old_exists = os.path.exists
                 try:
                     def exists(p):
                         if p == fake_path:
                             return True
                         return old_exists(p)
                     os.path.exists = exists
                     result = m1.generate_build_files()
                     l = len(result.inputs)
                     with open(fake_path, 'wt') as fh:
                         fh.write('# Modified content')
                     m2 = WebIDLCodegenManager(**args)
                     result = m2.generate_build_files()
                     self.assertEqual(len(result.inputs), l)
                     result = m2.generate_build_files()
                     self.assertEqual(len(result.inputs), 0)
                 finally:
                     os.path.exists = old_exists
                     del sys.modules['mozwebidlcodegen.fakemodule']
     def test_copy_input(self):
         """Ensure a copied .webidl file is handled properly."""
         # This test simulates changing the type of a WebIDL from static to
         # preprocessed. In that scenario, the original file still exists but
         # it should no longer be consulted during codegen.
         args = self._get_manager_args()
         m1 = WebIDLCodegenManager(**args)
         m1.generate_build_files()
         old_path = None
         for p in args['inputs'][0]:
             if p.endswith('Parent.webidl'):
                 old_path = p
                 break
         self.assertIsNotNone(old_path)
         new_path = mozpath.join(args['cache_dir'], 'Parent.webidl')
         shutil.copy2(old_path, new_path)
         args['inputs'][0].remove(old_path)
         args['inputs'][0].add(new_path)
         m2 = WebIDLCodegenManager(**args)
         result = m2.generate_build_files()
         self.assertEqual(len(result.updated), 0)
 if __name__ == '__main__':
     main()

The Tor Browser / annotate

dom/bindings/mozwebidlcodegen/test/test_mozwebidlcodegen.py@6474c204b198 (annotated)

dom/bindings/mozwebidlcodegen/test/test_mozwebidlcodegen.py