import mozpack.path as mozpath
CONTENTS = {
'bases': {
# base_path: is_addon?
'': False,
'app': False,
'addon0': 'unpacked',
'addon1': True,
},
'manifests': [
ManifestContent('chrome/f', 'oo', 'oo/'),
ManifestContent('chrome/f', 'bar', 'oo/bar/'),
ManifestResource('chrome/f', 'foo', 'resource://bar/'),
ManifestBinaryComponent('components', 'foo.so'),
ManifestContent('app/chrome', 'content', 'foo/'),
ManifestComponent('app/components', '{foo-id}', 'foo.js'),
ManifestContent('addon0/chrome', 'content', 'foo/bar/'),
ManifestContent('addon1/chrome', 'content', 'foo/bar/'),
],
'files': {
'chrome/f/oo/bar/baz': GeneratedFile('foobarbaz'),
'chrome/f/oo/baz': GeneratedFile('foobaz'),
'chrome/f/oo/qux': GeneratedFile('fooqux'),
'components/foo.so': GeneratedFile('foo.so'),
'components/foo.xpt': foo_xpt,
'components/bar.xpt': bar_xpt,
'foo': GeneratedFile('foo'),
'app/chrome/foo/foo': GeneratedFile('appfoo'),
'app/components/foo.js': GeneratedFile('foo.js'),
def test_parse_manifest(self):
manifest = [
'content global content/global/',
'content global content/global/ application=foo application=bar' +
' platform',
'locale global en-US content/en-US/',
'locale global en-US content/en-US/ application=foo',
'skin global classic/1.0 content/skin/classic/',
'skin global classic/1.0 content/skin/classic/ application=foo' +
' os=WINNT',
'',
'manifest pdfjs/chrome.manifest',
'resource gre-resources toolkit/res/',
'override chrome://global/locale/netError.dtd' +
' chrome://browser/locale/netError.dtd',
'# Comment',
'component {b2bba4df-057d-41ea-b6b1-94a10a8ede68} foo.js',
'contract @mozilla.org/foo;1' +
' {b2bba4df-057d-41ea-b6b1-94a10a8ede68}',
'interfaces foo.xpt',
'binary-component bar.so',
'category command-line-handler m-browser' +
' @mozilla.org/browser/clh;1' +
' application={ec8030f7-c20a-464f-9b0e-13a3a9e97384}',
'style chrome://global/content/viewSource.xul' +
' chrome://browser/skin/',
'overlay chrome://global/content/viewSource.xul' +
' chrome://browser/content/viewSourceOverlay.xul',
]
other_manifest = ['content global content/global/']
expected_result = [
ManifestContent('', 'global', 'content/global/'),
ManifestContent('', 'global', 'content/global/', 'application=foo',
'application=bar', 'platform'),
ManifestLocale('', 'global', 'en-US', 'content/en-US/'),
ManifestLocale('', 'global', 'en-US', 'content/en-US/',
'application=foo'),
ManifestSkin('', 'global', 'classic/1.0', 'content/skin/classic/'),
ManifestSkin('', 'global', 'classic/1.0', 'content/skin/classic/',
'application=foo', 'os=WINNT'),
Manifest('', 'pdfjs/chrome.manifest'),
ManifestResource('', 'gre-resources', 'toolkit/res/'),
ManifestOverride('', 'chrome://global/locale/netError.dtd',
'chrome://browser/locale/netError.dtd'),
ManifestComponent('', '{b2bba4df-057d-41ea-b6b1-94a10a8ede68}',
'foo.js'),
ManifestContract('', '@mozilla.org/foo;1',
'{b2bba4df-057d-41ea-b6b1-94a10a8ede68}'),
ManifestInterfaces('', 'foo.xpt'),
ManifestBinaryComponent('', 'bar.so'),
ManifestCategory(
'', 'command-line-handler', 'm-browser',
'@mozilla.org/browser/clh;1',
'application=' + '{ec8030f7-c20a-464f-9b0e-13a3a9e97384}'),
ManifestStyle('', 'chrome://global/content/viewSource.xul',
'chrome://browser/skin/'),
ManifestOverlay('', 'chrome://global/content/viewSource.xul',
'chrome://browser/content/viewSourceOverlay.xul'),
]
with mozunit.MockedOpen({
'manifest': '\n'.join(manifest),
'other/manifest': '\n'.join(other_manifest)
}):
# Ensure we have tests for all types of manifests.
self.assertEqual(set(type(e) for e in expected_result),
set(MANIFESTS_TYPES.values()))
self.assertEqual(list(parse_manifest(os.curdir, 'manifest')),
expected_result)
self.assertEqual(
list(parse_manifest(os.curdir, 'other/manifest')),
[ManifestContent('other', 'global', 'content/global/')])
def test_simple_packager(self):
class GeneratedFileWithPath(GeneratedFile):
def __init__(self, path, content):
GeneratedFile.__init__(self, content)
self.path = path
formatter = MockFormatter()
packager = SimplePackager(formatter)
curdir = os.path.abspath(os.curdir)
file = GeneratedFileWithPath(os.path.join(curdir, 'foo',
'bar.manifest'),
'resource bar bar/\ncontent bar bar/')
with errors.context('manifest', 1):
packager.add('foo/bar.manifest', file)
file = GeneratedFileWithPath(os.path.join(curdir, 'foo',
'baz.manifest'),
'resource baz baz/')
with errors.context('manifest', 2):
packager.add('bar/baz.manifest', file)
with errors.context('manifest', 3):
packager.add('qux/qux.manifest',
GeneratedFile(''.join([
'resource qux qux/\n',
'binary-component qux.so\n',
])))
bar_xpt = GeneratedFile('bar.xpt')
qux_xpt = GeneratedFile('qux.xpt')
foo_html = GeneratedFile('foo_html')
bar_html = GeneratedFile('bar_html')
with errors.context('manifest', 4):
packager.add('foo/bar.xpt', bar_xpt)
with errors.context('manifest', 5):
packager.add('foo/bar/foo.html', foo_html)
packager.add('foo/bar/bar.html', bar_html)
file = GeneratedFileWithPath(os.path.join(curdir, 'foo.manifest'),
''.join([
'manifest foo/bar.manifest\n',
'manifest bar/baz.manifest\n',
]))
with errors.context('manifest', 6):
packager.add('foo.manifest', file)
with errors.context('manifest', 7):
packager.add('foo/qux.xpt', qux_xpt)
file = GeneratedFileWithPath(os.path.join(curdir, 'addon',
'chrome.manifest'),
'resource hoge hoge/')
with errors.context('manifest', 8):
packager.add('addon/chrome.manifest', file)
install_rdf = GeneratedFile('<RDF></RDF>')
with errors.context('manifest', 9):
packager.add('addon/install.rdf', install_rdf)
with errors.context('manifest', 10):
packager.add('addon2/install.rdf', install_rdf)
packager.add('addon2/chrome.manifest',
GeneratedFile('binary-component addon2.so'))
with errors.context('manifest', 11):
packager.add('addon3/install.rdf', install_rdf)
packager.add('addon3/chrome.manifest', GeneratedFile(
'manifest components/components.manifest'))
packager.add('addon3/components/components.manifest',
GeneratedFile('binary-component addon3.so'))
with errors.context('manifest', 12):
install_rdf_addon4 = GeneratedFile(
'<RDF>\n<...>\n<em:unpack>true</em:unpack>\n<...>\n</RDF>')
packager.add('addon4/install.rdf', install_rdf_addon4)
with errors.context('manifest', 13):
install_rdf_addon5 = GeneratedFile(
'<RDF>\n<...>\n<em:unpack>false</em:unpack>\n<...>\n</RDF>')
packager.add('addon5/install.rdf', install_rdf_addon5)
with errors.context('manifest', 14):
install_rdf_addon6 = GeneratedFile(
'<RDF>\n<... em:unpack=true>\n<...>\n</RDF>')
packager.add('addon6/install.rdf', install_rdf_addon6)
with errors.context('manifest', 15):
install_rdf_addon7 = GeneratedFile(
'<RDF>\n<... em:unpack=false>\n<...>\n</RDF>')
packager.add('addon7/install.rdf', install_rdf_addon7)
with errors.context('manifest', 16):
install_rdf_addon8 = GeneratedFile(
'<RDF>\n<... em:unpack="true">\n<...>\n</RDF>')
packager.add('addon8/install.rdf', install_rdf_addon8)
with errors.context('manifest', 17):
install_rdf_addon9 = GeneratedFile(
'<RDF>\n<... em:unpack="false">\n<...>\n</RDF>')
packager.add('addon9/install.rdf', install_rdf_addon9)
with errors.context('manifest', 18):
install_rdf_addon10 = GeneratedFile(
'<RDF>\n<... em:unpack=\'true\'>\n<...>\n</RDF>')
packager.add('addon10/install.rdf', install_rdf_addon10)
with errors.context('manifest', 19):
install_rdf_addon11 = GeneratedFile(
'<RDF>\n<... em:unpack=\'false\'>\n<...>\n</RDF>')
packager.add('addon11/install.rdf', install_rdf_addon11)
we_manifest = GeneratedFile(
'{"manifest_version": 2, "name": "Test WebExtension", "version": "1.0"}')
# hybrid and hybrid2 are both bootstrapped extensions with
# embedded webextensions, they differ in the order in which
# the manifests are added to the packager.
with errors.context('manifest', 20):
packager.add('hybrid/install.rdf', install_rdf)
with errors.context('manifest', 21):
packager.add('hybrid/webextension/manifest.json', we_manifest)
with errors.context('manifest', 22):
packager.add('hybrid2/webextension/manifest.json', we_manifest)
with errors.context('manifest', 23):
packager.add('hybrid2/install.rdf', install_rdf)
with errors.context('manifest', 24):
packager.add('webextension/manifest.json', we_manifest)
non_we_manifest = GeneratedFile('{"not a webextension": true}')
with errors.context('manifest', 25):
packager.add('nonwebextension/manifest.json', non_we_manifest)
self.assertEqual(formatter.log, [])
with errors.context('dummy', 1):
packager.close()
self.maxDiff = None
# The formatter is expected to reorder the manifest entries so that
# chrome entries appear before the others.
self.assertEqual(formatter.log, [
(('dummy', 1), 'add_base', '', False),
(('dummy', 1), 'add_base', 'addon', True),
(('dummy', 1), 'add_base', 'addon10', 'unpacked'),
(('dummy', 1), 'add_base', 'addon11', True),
(('dummy', 1), 'add_base', 'addon2', 'unpacked'),
(('dummy', 1), 'add_base', 'addon3', 'unpacked'),
(('dummy', 1), 'add_base', 'addon4', 'unpacked'),
(('dummy', 1), 'add_base', 'addon5', True),
(('dummy', 1), 'add_base', 'addon6', 'unpacked'),
(('dummy', 1), 'add_base', 'addon7', True),
(('dummy', 1), 'add_base', 'addon8', 'unpacked'),
(('dummy', 1), 'add_base', 'addon9', True),
(('dummy', 1), 'add_base', 'hybrid', True),
(('dummy', 1), 'add_base', 'hybrid2', True),
(('dummy', 1), 'add_base', 'qux', False),
(('dummy', 1), 'add_base', 'webextension', True),
((os.path.join(curdir, 'foo', 'bar.manifest'), 2),
'add_manifest', ManifestContent('foo', 'bar', 'bar/')),
((os.path.join(curdir, 'foo', 'bar.manifest'), 1),
'add_manifest', ManifestResource('foo', 'bar', 'bar/')),
(('bar/baz.manifest', 1),
'add_manifest', ManifestResource('bar', 'baz', 'baz/')),
(('qux/qux.manifest', 1),
'add_manifest', ManifestResource('qux', 'qux', 'qux/')),
(('qux/qux.manifest', 2),
'add_manifest', ManifestBinaryComponent('qux', 'qux.so')),
(('manifest', 4), 'add_interfaces', 'foo/bar.xpt', bar_xpt),
(('manifest', 7), 'add_interfaces', 'foo/qux.xpt', qux_xpt),
((os.path.join(curdir, 'addon', 'chrome.manifest'), 1),
'add_manifest', ManifestResource('addon', 'hoge', 'hoge/')),
(('addon2/chrome.manifest', 1), 'add_manifest',
ManifestBinaryComponent('addon2', 'addon2.so')),
(('addon3/components/components.manifest', 1), 'add_manifest',
ManifestBinaryComponent('addon3/components', 'addon3.so')),
(('manifest', 5), 'add', 'foo/bar/foo.html', foo_html),
(('manifest', 5), 'add', 'foo/bar/bar.html', bar_html),
(('manifest', 9), 'add', 'addon/install.rdf', install_rdf),
(('manifest', 10), 'add', 'addon2/install.rdf', install_rdf),
(('manifest', 11), 'add', 'addon3/install.rdf', install_rdf),
(('manifest', 12), 'add', 'addon4/install.rdf',
install_rdf_addon4),
(('manifest', 13), 'add', 'addon5/install.rdf',
install_rdf_addon5),
(('manifest', 14), 'add', 'addon6/install.rdf',
install_rdf_addon6),
(('manifest', 15), 'add', 'addon7/install.rdf',
install_rdf_addon7),
(('manifest', 16), 'add', 'addon8/install.rdf',
install_rdf_addon8),
(('manifest', 17), 'add', 'addon9/install.rdf',
install_rdf_addon9),
(('manifest', 18), 'add', 'addon10/install.rdf',
install_rdf_addon10),
(('manifest', 19), 'add', 'addon11/install.rdf',
install_rdf_addon11),
(('manifest', 20), 'add', 'hybrid/install.rdf', install_rdf),
(('manifest', 21),
'add', 'hybrid/webextension/manifest.json', we_manifest),
(('manifest', 22),
'add', 'hybrid2/webextension/manifest.json', we_manifest),
(('manifest', 23), 'add', 'hybrid2/install.rdf', install_rdf),
(('manifest', 24),
'add', 'webextension/manifest.json', we_manifest),
(('manifest', 25),
'add', 'nonwebextension/manifest.json', non_we_manifest),
])
self.assertEqual(packager.get_bases(),
set(['', 'addon', 'addon2', 'addon3', 'addon4',
'addon5', 'addon6', 'addon7', 'addon8',
'addon9', 'addon10', 'addon11', 'qux',
'hybrid', 'hybrid2', 'webextension']))
self.assertEqual(packager.get_bases(addons=False), set(['', 'qux']))
def test_omnijar_formatter(self):
registry = FileRegistry()
formatter = OmniJarFormatter(registry, 'omni.foo')
formatter.add_base('app')
formatter.add('chrome/f/oo/bar', GeneratedFile('foobar'))
formatter.add('chrome/f/oo/baz', GeneratedFile('foobaz'))
formatter.add('chrome/f/oo/qux', GeneratedFile('fooqux'))
formatter.add_manifest(ManifestContent('chrome/f/oo', 'bar', 'bar'))
formatter.add_manifest(ManifestContent('chrome/f/oo', 'qux', 'qux'))
self.assertEqual(registry.paths(), ['omni.foo'])
self.assertEqual(registry['omni.foo'].paths(), [
'chrome/f/oo/bar',
'chrome/f/oo/baz',
'chrome/f/oo/qux',
'chrome.manifest',
'chrome/chrome.manifest',
'chrome/f/f.manifest',
'chrome/f/oo/oo.manifest',
])
self.assertEqual(registry['omni.foo']['chrome.manifest'].open().read(),
'manifest chrome/chrome.manifest\n')
self.assertEqual(
registry['omni.foo']['chrome/chrome.manifest'].open().read(),
'manifest f/f.manifest\n')
self.assertEqual(
registry['omni.foo']['chrome/f/f.manifest'].open().read(),
'manifest oo/oo.manifest\n')
self.assertEqual(
registry['omni.foo']['chrome/f/oo/oo.manifest'].open().read(),
''.join([
'content bar bar\n',
'content qux qux\n',
]))
self.assertTrue(formatter.contains('chrome/f/oo/bar'))
self.assertFalse(formatter.contains('chrome/foo/bar'))
formatter.add_interfaces('components/foo.xpt', foo_xpt)
formatter.add_interfaces('components/bar.xpt', bar_xpt)
self.assertEqual(registry['omni.foo'].paths(), [
'chrome/f/oo/bar',
'chrome/f/oo/baz',
'chrome/f/oo/qux',
'chrome.manifest',
'chrome/chrome.manifest',
'chrome/f/f.manifest',
'chrome/f/oo/oo.manifest',
'components/components.manifest',
'components/interfaces.xpt',
])
self.assertEqual(
registry['omni.foo']['chrome.manifest'].open().read(), ''.join([
'manifest chrome/chrome.manifest\n',
'manifest components/components.manifest\n'
]))
self.assertEqual(
registry['omni.foo']
['components/components.manifest'].open().read(),
'interfaces interfaces.xpt\n')
registry['omni.foo']['components/interfaces.xpt'].copy(
self.tmppath('interfaces.xpt'))
linked = read_interfaces(self.tmppath('interfaces.xpt'))
foo = read_interfaces(foo_xpt.open())
bar = read_interfaces(bar_xpt.open())
self.assertEqual(foo['foo'], linked['foo'])
self.assertEqual(bar['bar'], linked['bar'])
formatter.add('app/chrome/foo/baz', GeneratedFile('foobaz'))
formatter.add_manifest(ManifestContent('app/chrome', 'content',
'foo/'))
self.assertEqual(registry.paths(), ['omni.foo', 'app/omni.foo'])
self.assertEqual(registry['app/omni.foo'].paths(), [
'chrome/foo/baz',
'chrome.manifest',
'chrome/chrome.manifest',
])
self.assertEqual(
registry['app/omni.foo']['chrome.manifest'].open().read(),
'manifest chrome/chrome.manifest\n')
self.assertEqual(
registry['app/omni.foo']['chrome/chrome.manifest'].open().read(),
'content content foo/\n')
formatter.add_manifest(ManifestBinaryComponent('components', 'foo.so'))
formatter.add('components/foo.so', GeneratedFile('foo'))
self.assertEqual(registry.paths(), [
'omni.foo',
'app/omni.foo',
'chrome.manifest',
'components/components.manifest',
'components/foo.so',
])
self.assertEqual(registry['chrome.manifest'].open().read(),
'manifest components/components.manifest\n')
self.assertEqual(
registry['components/components.manifest'].open().read(),
'binary-component foo.so\n')
formatter.add_manifest(
ManifestBinaryComponent('app/components', 'foo.so'))
formatter.add('app/components/foo.so', GeneratedFile('foo'))
self.assertEqual(registry.paths(), [
'omni.foo',
'app/omni.foo',
'chrome.manifest',
'components/components.manifest',
'components/foo.so',
'app/chrome.manifest',
'app/components/components.manifest',
'app/components/foo.so',
])
self.assertEqual(registry['app/chrome.manifest'].open().read(),
'manifest components/components.manifest\n')
self.assertEqual(
registry['app/components/components.manifest'].open().read(),
'binary-component foo.so\n')
formatter.add('app/foo', GeneratedFile('foo'))
self.assertEqual(registry.paths(), [
'omni.foo', 'app/omni.foo', 'chrome.manifest',
'components/components.manifest', 'components/foo.so',
'app/chrome.manifest', 'app/components/components.manifest',
'app/components/foo.so', 'app/foo'
])
from test_errors import TestErrors
CONTENTS = {
"bases": {
# base_path: is_addon?
"": False,
"app": False,
"addon0": "unpacked",
"addon1": True,
"app/chrome/addons/addon2": True,
},
"manifests": [
ManifestContent("chrome/f", "oo", "oo/"),
ManifestContent("chrome/f", "bar", "oo/bar/"),
ManifestResource("chrome/f", "foo", "resource://bar/"),
ManifestBinaryComponent("components", "foo.so"),
ManifestContent("app/chrome", "content", "foo/"),
ManifestComponent("app/components", "{foo-id}", "foo.js"),
ManifestContent("addon0/chrome", "addon0", "foo/bar/"),
ManifestContent("addon1/chrome", "addon1", "foo/bar/"),
ManifestContent("app/chrome/addons/addon2/chrome", "addon2",
"foo/bar/"),
],
"files": {
"chrome/f/oo/bar/baz": GeneratedFile(b"foobarbaz"),
"chrome/f/oo/baz": GeneratedFile(b"foobaz"),
"chrome/f/oo/qux": GeneratedFile(b"fooqux"),
"components/foo.so": GeneratedFile(b"foo.so"),
"components/foo.xpt": foo_xpt,
"components/bar.xpt": bar_xpt,
"foo": GeneratedFile(b"foo"),
def test_parse_manifest(self):
manifest = [
"content global content/global/",
"content global content/global/ application=foo application=bar"
+ " platform",
"locale global en-US content/en-US/",
"locale global en-US content/en-US/ application=foo",
"skin global classic/1.0 content/skin/classic/",
"skin global classic/1.0 content/skin/classic/ application=foo"
+ " os=WINNT",
"",
"manifest pdfjs/chrome.manifest",
"resource gre-resources toolkit/res/",
"override chrome://global/locale/netError.dtd"
+ " chrome://browser/locale/netError.dtd",
"# Comment",
"component {b2bba4df-057d-41ea-b6b1-94a10a8ede68} foo.js",
"contract @mozilla.org/foo;1" + " {b2bba4df-057d-41ea-b6b1-94a10a8ede68}",
"interfaces foo.xpt",
"binary-component bar.so",
"category command-line-handler m-browser"
+ " @mozilla.org/browser/clh;1"
+ " application={ec8030f7-c20a-464f-9b0e-13a3a9e97384}",
"style chrome://global/content/viewSource.xul" + " chrome://browser/skin/",
"overlay chrome://global/content/viewSource.xul"
+ " chrome://browser/content/viewSourceOverlay.xul",
]
other_manifest = ["content global content/global/"]
expected_result = [
ManifestContent("", "global", "content/global/"),
ManifestContent(
"",
"global",
"content/global/",
"application=foo",
"application=bar",
"platform",
),
ManifestLocale("", "global", "en-US", "content/en-US/"),
ManifestLocale("", "global", "en-US", "content/en-US/", "application=foo"),
ManifestSkin("", "global", "classic/1.0", "content/skin/classic/"),
ManifestSkin(
"",
"global",
"classic/1.0",
"content/skin/classic/",
"application=foo",
"os=WINNT",
),
Manifest("", "pdfjs/chrome.manifest"),
ManifestResource("", "gre-resources", "toolkit/res/"),
ManifestOverride(
"",
"chrome://global/locale/netError.dtd",
"chrome://browser/locale/netError.dtd",
),
ManifestComponent("", "{b2bba4df-057d-41ea-b6b1-94a10a8ede68}", "foo.js"),
ManifestContract(
"", "@mozilla.org/foo;1", "{b2bba4df-057d-41ea-b6b1-94a10a8ede68}"
),
ManifestInterfaces("", "foo.xpt"),
ManifestBinaryComponent("", "bar.so"),
ManifestCategory(
"",
"command-line-handler",
"m-browser",
"@mozilla.org/browser/clh;1",
"application=" + "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}",
),
ManifestStyle(
"", "chrome://global/content/viewSource.xul", "chrome://browser/skin/"
),
ManifestOverlay(
"",
"chrome://global/content/viewSource.xul",
"chrome://browser/content/viewSourceOverlay.xul",
),
]
with mozunit.MockedOpen(
{
"manifest": "\n".join(manifest),
"other/manifest": "\n".join(other_manifest),
}
):
# Ensure we have tests for all types of manifests.
self.assertEqual(
set(type(e) for e in expected_result), set(MANIFESTS_TYPES.values())
)
self.assertEqual(
list(parse_manifest(os.curdir, "manifest")), expected_result
)
self.assertEqual(
list(parse_manifest(os.curdir, "other/manifest")),
[ManifestContent("other", "global", "content/global/")],
)
