#!/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()
