summaryrefslogtreecommitdiffstats
path: root/testing/mozbase/mozprofile/tests/test_preferences.py
diff options
context:
space:
mode:
Diffstat (limited to 'testing/mozbase/mozprofile/tests/test_preferences.py')
-rwxr-xr-xtesting/mozbase/mozprofile/tests/test_preferences.py428
1 files changed, 428 insertions, 0 deletions
diff --git a/testing/mozbase/mozprofile/tests/test_preferences.py b/testing/mozbase/mozprofile/tests/test_preferences.py
new file mode 100755
index 0000000000..6cc62546e3
--- /dev/null
+++ b/testing/mozbase/mozprofile/tests/test_preferences.py
@@ -0,0 +1,428 @@
+#!/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 os
+import shutil
+import tempfile
+
+import mozfile
+import mozunit
+import pytest
+from mozprofile.cli import MozProfileCLI
+from mozprofile.prefs import Preferences, PreferencesReadError
+from mozprofile.profile import Profile
+from wptserve import server
+
+here = os.path.dirname(os.path.abspath(__file__))
+
+
+# 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",
+}
+
+
+@pytest.fixture
+def run_command():
+ """
+ invokes mozprofile command line via the CLI factory
+ - args : command line arguments (equivalent of sys.argv[1:])
+ """
+
+ def inner(*args):
+ # instantiate the factory
+ cli = MozProfileCLI(list(args))
+
+ # create the profile
+ profile = cli.profile()
+
+ # return path to profile
+ return profile.profile
+
+ return inner
+
+
+@pytest.fixture
+def compare_generated(run_command):
+ """
+ writes out to a new profile with mozprofile command line
+ reads the generated preferences with prefs.py
+ compares the results
+ cleans up
+ """
+
+ def inner(prefs, commandline):
+ profile = run_command(*commandline)
+ prefs_file = os.path.join(profile, "user.js")
+ assert os.path.exists(prefs_file)
+ read = Preferences.read_prefs(prefs_file)
+ if isinstance(prefs, dict):
+ read = dict(read)
+ assert prefs == read
+ shutil.rmtree(profile)
+
+ return inner
+
+
+def test_basic_prefs(compare_generated):
+ """test setting a pref from the command line entry point"""
+
+ _prefs = {"browser.startup.homepage": "http://planet.mozilla.org/"}
+ commandline = []
+ for pref, value in _prefs.items():
+ commandline += ["--pref", "%s:%s" % (pref, value)]
+ compare_generated(_prefs, commandline)
+
+
+def test_ordered_prefs(compare_generated):
+ """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]
+ compare_generated(_prefs, commandline)
+
+
+def test_ini(compare_generated):
+ # 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", text=True)
+ os.write(fd, _ini.encode())
+ os.close(fd)
+ commandline = ["--preferences", name]
+
+ # test the [DEFAULT] section
+ _prefs = {"browser.startup.homepage": "http://planet.mozilla.org/"}
+ compare_generated(_prefs, commandline)
+
+ # test a specific section
+ _prefs = {"browser.startup.homepage": "http://github.com/"}
+ commandline[-1] = commandline[-1] + ":foo"
+ compare_generated(_prefs, commandline)
+
+ finally:
+ # cleanup
+ os.remove(name)
+
+
+def test_ini_keep_case(compare_generated):
+ """
+ Read a preferences config file with a preference in camel-case style.
+ Check that the read preference name has not been lower-cased
+ """
+ # write the .ini file
+ _ini = """[DEFAULT]
+network.dns.disableIPv6 = True
+"""
+ try:
+ fd, name = tempfile.mkstemp(suffix=".ini", text=True)
+ os.write(fd, _ini.encode())
+ os.close(fd)
+ commandline = ["--preferences", name]
+
+ # test the [DEFAULT] section
+ _prefs = {"network.dns.disableIPv6": "True"}
+ compare_generated(_prefs, commandline)
+
+ finally:
+ # cleanup
+ os.remove(name)
+
+
+def test_reset_should_remove_added_prefs():
+ """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)
+ assert not initial_prefs
+ initial_prefs = open(prefs_file).read().strip()
+ assert not initial_prefs
+
+ # add some preferences
+ prefs1 = [("mr.t.quotes", "i aint getting on no plane!")]
+ profile.set_preferences(prefs1)
+ assert prefs1 == Preferences.read_prefs(prefs_file)
+ lines = open(prefs_file).read().strip().splitlines()
+ assert any(line.startswith("#MozRunner Prefs Start") for line in lines)
+ assert any(line.startswith("#MozRunner Prefs End") for line in lines)
+
+ profile.reset()
+ assert prefs1 != Preferences.read_prefs(os.path.join(profile.profile, "user.js"))
+
+
+def test_reset_should_keep_user_added_prefs():
+ """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)
+ assert not initial_prefs
+ initial_prefs = open(prefs_file).read().strip()
+ assert not initial_prefs
+
+ # add some preferences
+ prefs1 = [("mr.t.quotes", "i aint getting on no plane!")]
+ profile.set_persistent_preferences(prefs1)
+ assert prefs1 == Preferences.read_prefs(prefs_file)
+ lines = open(prefs_file).read().strip().splitlines()
+ assert any(line.startswith("#MozRunner Prefs Start") for line in lines)
+ assert any(line.startswith("#MozRunner Prefs End") for line in lines)
+
+ profile.reset()
+ assert prefs1 == Preferences.read_prefs(os.path.join(profile.profile, "user.js"))
+
+
+def test_magic_markers():
+ """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)
+ assert not initial_prefs
+ initial_prefs = open(prefs_file).read().strip()
+ assert not initial_prefs
+
+ # add some preferences
+ prefs1 = [
+ ("browser.startup.homepage", "http://planet.mozilla.org/"),
+ ("zoom.minPercent", 30),
+ ]
+ profile.set_preferences(prefs1)
+ assert prefs1 == Preferences.read_prefs(prefs_file)
+ lines = open(prefs_file).read().strip().splitlines()
+ assert bool([line for line in lines if line.startswith("#MozRunner Prefs Start")])
+ assert 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)
+ assert prefs1 + prefs2 == Preferences.read_prefs(prefs_file)
+ lines = open(prefs_file).read().strip().splitlines()
+ assert (
+ len([line for line in lines if line.startswith("#MozRunner Prefs Start")]) == 2
+ )
+ assert 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)
+ assert not final_prefs
+ lines = open(prefs_file).read().strip().splitlines()
+ assert "#MozRunner Prefs Start" not in lines
+ assert "#MozRunner Prefs End" not in lines
+
+
+def test_preexisting_preferences():
+ """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 = open(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),
+ ]
+ assert 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)
+ assert 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)
+ assert prefs == original_prefs
+ finally:
+ shutil.rmtree(tempdir)
+
+
+def test_can_read_prefs_with_multiline_comments():
+ """
+ Ensure that multiple comments in the file header do not break reading
+ the prefs (https://bugzilla.mozilla.org/show_bug.cgi?id=1233534).
+ """
+ user_js = tempfile.NamedTemporaryFile(suffix=".js", delete=False)
+ try:
+ with user_js:
+ user_js.write(
+ """
+# Mozilla User Preferences
+
+/* Do not edit this file.
+*
+* If you make changes to this file while the application is running,
+* the changes will be overwritten when the application exits.
+*
+* To make a manual change to preferences, you can visit the URL about:config
+*/
+
+user_pref("webgl.enabled_for_all_sites", true);
+user_pref("webgl.force-enabled", true);
+""".encode()
+ )
+ assert Preferences.read_prefs(user_js.name) == [
+ ("webgl.enabled_for_all_sites", True),
+ ("webgl.force-enabled", True),
+ ]
+ finally:
+ mozfile.remove(user_js.name)
+
+
+def test_json(compare_generated):
+ _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
+ with mozfile.NamedTemporaryFile(suffix=".json") as f:
+ f.write(json.encode())
+ f.flush()
+
+ commandline = ["--preferences", f.name]
+ compare_generated(_prefs, commandline)
+
+
+def test_json_datatypes():
+ # minPercent is at 30.1 to test if non-integer data raises an exception
+ json = """{"zoom.minPercent": 30.1, "zoom.maxPercent": 300}"""
+
+ with mozfile.NamedTemporaryFile(suffix=".json") as f:
+ f.write(json.encode())
+ f.flush()
+
+ with pytest.raises(PreferencesReadError):
+ Preferences.read_json(f._path)
+
+
+def test_prefs_write():
+ """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, mode="w+t") 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)
+
+ assert read_prefs == _prefs
+
+
+def test_read_prefs_with_comments():
+ """test reading preferences from a prefs.js file that contains comments"""
+
+ path = os.path.join(here, "files", "prefs_with_comments.js")
+ assert dict(Preferences.read_prefs(path)) == _prefs_with_comments
+
+
+def test_read_prefs_with_interpolation():
+ """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)
+ assert dict(read_prefs) == expected_prefs
+
+
+def test_read_prefs_with_multiline():
+ """test reading preferences from a prefs.js file that contains multiline prefs"""
+
+ path = os.path.join(here, "files", "prefs_with_multiline.js")
+ assert dict(Preferences.read_prefs(path)) == {
+ "browser.long.preference.name.that.causes.the.line.to.wrap": "itislong"
+ }
+
+
+def test_read_prefs_ttw():
+ """test reading preferences through the web via wptserve"""
+
+ # create a WebTestHttpd instance
+ docroot = os.path.join(here, "files")
+ host = "127.0.0.1"
+ port = 8888
+ httpd = server.WebTestHttpd(host=host, port=port, doc_root=docroot)
+
+ # create a preferences instance
+ prefs = Preferences()
+
+ try:
+ # start server
+ httpd.start()
+
+ # read preferences through the web
+ read = prefs.read_prefs("http://%s:%d/prefs_with_comments.js" % (host, port))
+ assert dict(read) == _prefs_with_comments
+ finally:
+ httpd.stop()
+
+
+if __name__ == "__main__":
+ mozunit.main()