The Tor Browser: testing/mozbase/mozprofile/tests/test_preferences.py@6474c204b198 (annotated)

testing/mozbase/mozprofile/tests/test_preferences.py@6474c204b198 (annotated)

testing/mozbase/mozprofile/tests/test_preferences.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: -rwxr-xr-x

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

 #!/usr/bin/env python
 # 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/.
 import mozfile
 import mozhttpd
 import os
 import shutil
 import tempfile
 import unittest
 from mozprofile.cli import MozProfileCLI
 from mozprofile.prefs import Preferences
 from mozprofile.profile import Profile
 here = os.path.dirname(os.path.abspath(__file__))
 class PreferencesTest(unittest.TestCase):
     """test mozprofile preference handling"""
     # preferences from files/prefs_with_comments.js
     _prefs_with_comments = {'browser.startup.homepage': 'http://planet.mozilla.org',
                             'zoom.minPercent': 30,
                             'zoom.maxPercent': 300,
                             'webgl.verbose': 'false'}
     def run_command(self, *args):
         """
         invokes mozprofile command line via the CLI factory
         - args : command line arguments (equivalent of sys.argv[1:])
         """
         # instantiate the factory
         cli = MozProfileCLI(list(args))
         # create the profile
         profile = cli.profile()
         # return path to profile
         return profile.profile
     def compare_generated(self, _prefs, commandline):
         """
         writes out to a new profile with mozprofile command line
         reads the generated preferences with prefs.py
         compares the results
         cleans up
         """
         profile = self.run_command(*commandline)
         prefs_file = os.path.join(profile, 'user.js')
         self.assertTrue(os.path.exists(prefs_file))
         read = Preferences.read_prefs(prefs_file)
         if isinstance(_prefs, dict):
             read = dict(read)
         self.assertEqual(_prefs, read)
         shutil.rmtree(profile)
     def test_basic_prefs(self):
         """test setting a pref from the command line entry point"""
         _prefs = {"browser.startup.homepage": "http://planet.mozilla.org/"}
         commandline = []
         _prefs = _prefs.items()
         for pref, value in _prefs:
             commandline += ["--pref", "%s:%s" % (pref, value)]
         self.compare_generated(_prefs, commandline)
     def test_ordered_prefs(self):
         """ensure the prefs stay in the right order"""
         _prefs = [("browser.startup.homepage", "http://planet.mozilla.org/"),
                   ("zoom.minPercent", 30),
                   ("zoom.maxPercent", 300),
                   ("webgl.verbose", 'false')]
         commandline = []
         for pref, value in _prefs:
             commandline += ["--pref", "%s:%s" % (pref, value)]
         _prefs = [(i, Preferences.cast(j)) for i, j in _prefs]
         self.compare_generated(_prefs, commandline)
     def test_ini(self):
         # write the .ini file
         _ini = """[DEFAULT]
 browser.startup.homepage = http://planet.mozilla.org/
 [foo]
 browser.startup.homepage = http://github.com/
 """
         try:
             fd, name = tempfile.mkstemp(suffix='.ini')
             os.write(fd, _ini)
             os.close(fd)
             commandline = ["--preferences", name]
             # test the [DEFAULT] section
             _prefs = {'browser.startup.homepage': 'http://planet.mozilla.org/'}
             self.compare_generated(_prefs, commandline)
             # test a specific section
             _prefs = {'browser.startup.homepage': 'http://github.com/'}
             commandline[-1] = commandline[-1] + ':foo'
             self.compare_generated(_prefs, commandline)
         finally:
             # cleanup
             os.remove(name)
     def test_reset_should_remove_added_prefs(self):
         """Check that when we call reset the items we expect are updated"""
         profile = Profile()
         prefs_file = os.path.join(profile.profile, 'user.js')
         # we shouldn't have any initial preferences
         initial_prefs = Preferences.read_prefs(prefs_file)
         self.assertFalse(initial_prefs)
         initial_prefs = file(prefs_file).read().strip()
         self.assertFalse(initial_prefs)
         # add some preferences
         prefs1 = [("mr.t.quotes", "i aint getting on no plane!")]
         profile.set_preferences(prefs1)
         self.assertEqual(prefs1, Preferences.read_prefs(prefs_file))
         lines = file(prefs_file).read().strip().splitlines()
         self.assertTrue(bool([line for line in lines
                               if line.startswith('#MozRunner Prefs Start')]))
         self.assertTrue(bool([line for line in lines
                               if line.startswith('#MozRunner Prefs End')]))
         profile.reset()
         self.assertNotEqual(prefs1,
                             Preferences.read_prefs(os.path.join(profile.profile, 'user.js')),
                             "I pity the fool who left my pref")
     def test_magic_markers(self):
         """ensure our magic markers are working"""
         profile = Profile()
         prefs_file = os.path.join(profile.profile, 'user.js')
         # we shouldn't have any initial preferences
         initial_prefs = Preferences.read_prefs(prefs_file)
         self.assertFalse(initial_prefs)
         initial_prefs = file(prefs_file).read().strip()
         self.assertFalse(initial_prefs)
         # add some preferences
         prefs1 = [("browser.startup.homepage", "http://planet.mozilla.org/"),
                    ("zoom.minPercent", 30)]
         profile.set_preferences(prefs1)
         self.assertEqual(prefs1, Preferences.read_prefs(prefs_file))
         lines = file(prefs_file).read().strip().splitlines()
         self.assertTrue(bool([line for line in lines
                               if line.startswith('#MozRunner Prefs Start')]))
         self.assertTrue(bool([line for line in lines
                               if line.startswith('#MozRunner Prefs End')]))
         # add some more preferences
         prefs2 = [("zoom.maxPercent", 300),
                    ("webgl.verbose", 'false')]
         profile.set_preferences(prefs2)
         self.assertEqual(prefs1 + prefs2, Preferences.read_prefs(prefs_file))
         lines = file(prefs_file).read().strip().splitlines()
         self.assertTrue(len([line for line in lines
                              if line.startswith('#MozRunner Prefs Start')]) == 2)
         self.assertTrue(len([line for line in lines
                              if line.startswith('#MozRunner Prefs End')]) == 2)
         # now clean it up
         profile.clean_preferences()
         final_prefs = Preferences.read_prefs(prefs_file)
         self.assertFalse(final_prefs)
         lines = file(prefs_file).read().strip().splitlines()
         self.assertTrue('#MozRunner Prefs Start' not in lines)
         self.assertTrue('#MozRunner Prefs End' not in lines)
     def test_preexisting_preferences(self):
         """ensure you don't clobber preexisting preferences"""
         # make a pretend profile
         tempdir = tempfile.mkdtemp()
         try:
             # make a user.js
             contents = """
 user_pref("webgl.enabled_for_all_sites", true);
 user_pref("webgl.force-enabled", true);
 """
             user_js = os.path.join(tempdir, 'user.js')
             f = file(user_js, 'w')
             f.write(contents)
             f.close()
             # make sure you can read it
             prefs = Preferences.read_prefs(user_js)
             original_prefs = [('webgl.enabled_for_all_sites', True), ('webgl.force-enabled', True)]
             self.assertTrue(prefs == original_prefs)
             # now read this as a profile
             profile = Profile(tempdir, preferences={"browser.download.dir": "/home/jhammel"})
             # make sure the new pref is now there
             new_prefs = original_prefs[:] + [("browser.download.dir", "/home/jhammel")]
             prefs = Preferences.read_prefs(user_js)
             self.assertTrue(prefs == new_prefs)
             # clean up the added preferences
             profile.cleanup()
             del profile
             # make sure you have the original preferences
             prefs = Preferences.read_prefs(user_js)
             self.assertTrue(prefs == original_prefs)
         finally:
             shutil.rmtree(tempdir)
     def test_json(self):
         _prefs = {"browser.startup.homepage": "http://planet.mozilla.org/"}
         json = '{"browser.startup.homepage": "http://planet.mozilla.org/"}'
         # just repr it...could use the json module but we don't need it here
         fd, name = tempfile.mkstemp(suffix='.json')
         os.write(fd, json)
         os.close(fd)
         commandline = ["--preferences", name]
         self.compare_generated(_prefs, commandline)
     def test_prefs_write(self):
         """test that the Preferences.write() method correctly serializes preferences"""
         _prefs = {'browser.startup.homepage': "http://planet.mozilla.org",
                   'zoom.minPercent': 30,
                   'zoom.maxPercent': 300}
         # make a Preferences manager with the testing preferences
         preferences = Preferences(_prefs)
         # write them to a temporary location
         path = None
         read_prefs = None
         try:
             with mozfile.NamedTemporaryFile(suffix='.js', delete=False) as f:
                 path = f.name
                 preferences.write(f, _prefs)
             # read them back and ensure we get what we put in
             read_prefs = dict(Preferences.read_prefs(path))
         finally:
             # cleanup
             if path and os.path.exists(path):
                 os.remove(path)
         self.assertEqual(read_prefs, _prefs)
     def test_read_prefs_with_comments(self):
         """test reading preferences from a prefs.js file that contains comments"""
         path = os.path.join(here, 'files', 'prefs_with_comments.js')
         self.assertEqual(dict(Preferences.read_prefs(path)), self._prefs_with_comments)
     def test_read_prefs_with_interpolation(self):
         """test reading preferences from a prefs.js file whose values
         require interpolation"""
         expected_prefs = {
             "browser.foo": "http://server-name",
             "zoom.minPercent": 30,
             "webgl.verbose": "false",
             "browser.bar": "somethingxyz"
             }
         values = {
             "server": "server-name",
             "abc": "something"
             }
         path = os.path.join(here, 'files', 'prefs_with_interpolation.js')
         read_prefs = Preferences.read_prefs(path, interpolation=values)
         self.assertEqual(dict(read_prefs), expected_prefs)
     def test_read_prefs_ttw(self):
         """test reading preferences through the web via mozhttpd"""
         # create a MozHttpd instance
         docroot = os.path.join(here, 'files')
         host = '127.0.0.1'
         port = 8888
         httpd = mozhttpd.MozHttpd(host=host, port=port, docroot=docroot)
         # create a preferences instance
         prefs = Preferences()
         try:
             # start server
             httpd.start(block=False)
             # read preferences through the web
             read = prefs.read_prefs('http://%s:%d/prefs_with_comments.js' % (host, port))
             self.assertEqual(dict(read), self._prefs_with_comments)
         finally:
             httpd.stop()
 if __name__ == '__main__':
     unittest.main()

The Tor Browser / annotate

testing/mozbase/mozprofile/tests/test_preferences.py@6474c204b198 (annotated)

testing/mozbase/mozprofile/tests/test_preferences.py