Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 419 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..95d26f189c
--- /dev/null
+++ b/testing/mozbase/mozprofile/tests/test_preferences.py
@@ -0,0 +1,419 @@
+#!/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_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()