Source code

Revision control

Other Tools

Test Info:

#!/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/.
from __future__ import absolute_import
import mozfile
import os
import shutil
import tempfile
import mozunit
import pytest
from wptserve import server
from mozprofile.cli import MozProfileCLI
from mozprofile.prefs import Preferences, PreferencesReadError
from mozprofile.profile import Profile
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
"""
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()