зеркало из https://github.com/mozilla/gecko-dev.git
200 строки
8.2 KiB
Python
200 строки
8.2 KiB
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 mozbuild.util import ensureParentDir
|
|
|
|
from mozpack.unify import (
|
|
UnifiedFinder,
|
|
UnifiedBuildFinder,
|
|
)
|
|
import mozunit
|
|
from mozpack.test.test_files import TestWithTmpDir
|
|
from mozpack.files import FileFinder
|
|
from mozpack.mozjar import JarWriter
|
|
from mozpack.test.test_files import MockDest
|
|
from cStringIO import StringIO
|
|
import os
|
|
import sys
|
|
from mozpack.errors import (
|
|
ErrorMessage,
|
|
AccumulatedErrors,
|
|
errors,
|
|
)
|
|
|
|
|
|
class TestUnified(TestWithTmpDir):
|
|
def create_one(self, which, path, content):
|
|
file = self.tmppath(os.path.join(which, path))
|
|
ensureParentDir(file)
|
|
open(file, 'wb').write(content)
|
|
|
|
def create_both(self, path, content):
|
|
for p in ['a', 'b']:
|
|
self.create_one(p, path, content)
|
|
|
|
|
|
class TestUnifiedFinder(TestUnified):
|
|
def test_unified_finder(self):
|
|
self.create_both('foo/bar', 'foobar')
|
|
self.create_both('foo/baz', 'foobaz')
|
|
self.create_one('a', 'bar', 'bar')
|
|
self.create_one('b', 'baz', 'baz')
|
|
self.create_one('a', 'qux', 'foobar')
|
|
self.create_one('b', 'qux', 'baz')
|
|
self.create_one('a', 'test/foo', 'a\nb\nc\n')
|
|
self.create_one('b', 'test/foo', 'b\nc\na\n')
|
|
self.create_both('test/bar', 'a\nb\nc\n')
|
|
|
|
finder = UnifiedFinder(FileFinder(self.tmppath('a')),
|
|
FileFinder(self.tmppath('b')),
|
|
sorted=['test'])
|
|
self.assertEqual(sorted([(f, c.open().read())
|
|
for f, c in finder.find('foo')]),
|
|
[('foo/bar', 'foobar'), ('foo/baz', 'foobaz')])
|
|
self.assertRaises(ErrorMessage, any, finder.find('bar'))
|
|
self.assertRaises(ErrorMessage, any, finder.find('baz'))
|
|
self.assertRaises(ErrorMessage, any, finder.find('qux'))
|
|
self.assertEqual(sorted([(f, c.open().read())
|
|
for f, c in finder.find('test')]),
|
|
[('test/bar', 'a\nb\nc\n'),
|
|
('test/foo', 'a\nb\nc\n')])
|
|
|
|
|
|
class TestUnifiedBuildFinder(TestUnified):
|
|
def test_unified_build_finder(self):
|
|
finder = UnifiedBuildFinder(FileFinder(self.tmppath('a')),
|
|
FileFinder(self.tmppath('b')))
|
|
|
|
# Test chrome.manifest unification
|
|
self.create_both('chrome.manifest', 'a\nb\nc\n')
|
|
self.create_one('a', 'chrome/chrome.manifest', 'a\nb\nc\n')
|
|
self.create_one('b', 'chrome/chrome.manifest', 'b\nc\na\n')
|
|
self.assertEqual(sorted([(f, c.open().read()) for f, c in
|
|
finder.find('**/chrome.manifest')]),
|
|
[('chrome.manifest', 'a\nb\nc\n'),
|
|
('chrome/chrome.manifest', 'a\nb\nc\n')])
|
|
|
|
# Test buildconfig.html unification
|
|
self.create_one('a', 'chrome/browser/foo/buildconfig.html',
|
|
'\n'.join([
|
|
'<html>',
|
|
'<body>',
|
|
'<h1>about:buildconfig</h1>',
|
|
'<div>foo</div>',
|
|
'</body>',
|
|
'</html>',
|
|
]))
|
|
self.create_one('b', 'chrome/browser/foo/buildconfig.html',
|
|
'\n'.join([
|
|
'<html>',
|
|
'<body>',
|
|
'<h1>about:buildconfig</h1>',
|
|
'<div>bar</div>',
|
|
'</body>',
|
|
'</html>',
|
|
]))
|
|
self.assertEqual(sorted([(f, c.open().read()) for f, c in
|
|
finder.find('**/buildconfig.html')]),
|
|
[('chrome/browser/foo/buildconfig.html', '\n'.join([
|
|
'<html>',
|
|
'<body>',
|
|
'<h1>about:buildconfig</h1>',
|
|
'<div>foo</div>',
|
|
'<hr> </hr>',
|
|
'<div>bar</div>',
|
|
'</body>',
|
|
'</html>',
|
|
]))])
|
|
|
|
# Test xpi file unification
|
|
xpi = MockDest()
|
|
with JarWriter(fileobj=xpi, compress=True) as jar:
|
|
jar.add('foo', 'foo')
|
|
jar.add('bar', 'bar')
|
|
foo_xpi = xpi.read()
|
|
self.create_both('foo.xpi', foo_xpi)
|
|
|
|
with JarWriter(fileobj=xpi, compress=True) as jar:
|
|
jar.add('foo', 'bar')
|
|
self.create_one('a', 'bar.xpi', foo_xpi)
|
|
self.create_one('b', 'bar.xpi', xpi.read())
|
|
|
|
errors.out = StringIO()
|
|
with self.assertRaises(AccumulatedErrors), errors.accumulate():
|
|
self.assertEqual([(f, c.open().read()) for f, c in
|
|
finder.find('*.xpi')],
|
|
[('foo.xpi', foo_xpi)])
|
|
errors.out = sys.stderr
|
|
|
|
# Test install.rdf unification
|
|
x86_64 = 'Darwin_x86_64-gcc3'
|
|
x86 = 'Darwin_x86-gcc3'
|
|
target_tag = '<{em}targetPlatform>{platform}</{em}targetPlatform>'
|
|
target_attr = '{em}targetPlatform="{platform}" '
|
|
|
|
rdf_tag = ''.join([
|
|
'<{RDF}Description {em}bar="bar" {em}qux="qux">',
|
|
'<{em}foo>foo</{em}foo>',
|
|
'{targets}',
|
|
'<{em}baz>baz</{em}baz>',
|
|
'</{RDF}Description>'
|
|
])
|
|
rdf_attr = ''.join([
|
|
'<{RDF}Description {em}bar="bar" {attr}{em}qux="qux">',
|
|
'{targets}',
|
|
'<{em}foo>foo</{em}foo><{em}baz>baz</{em}baz>',
|
|
'</{RDF}Description>'
|
|
])
|
|
|
|
for descr_ns, target_ns in (('RDF:', ''), ('', 'em:'), ('RDF:', 'em:')):
|
|
# First we need to infuse the above strings with our namespaces and
|
|
# platform values.
|
|
ns = { 'RDF': descr_ns, 'em': target_ns }
|
|
target_tag_x86_64 = target_tag.format(platform=x86_64, **ns)
|
|
target_tag_x86 = target_tag.format(platform=x86, **ns)
|
|
target_attr_x86_64 = target_attr.format(platform=x86_64, **ns)
|
|
target_attr_x86 = target_attr.format(platform=x86, **ns)
|
|
|
|
tag_x86_64 = rdf_tag.format(targets=target_tag_x86_64, **ns)
|
|
tag_x86 = rdf_tag.format(targets=target_tag_x86, **ns)
|
|
tag_merged = rdf_tag.format(targets=target_tag_x86_64 + target_tag_x86, **ns)
|
|
tag_empty = rdf_tag.format(targets="", **ns)
|
|
|
|
attr_x86_64 = rdf_attr.format(attr=target_attr_x86_64, targets="", **ns)
|
|
attr_x86 = rdf_attr.format(attr=target_attr_x86, targets="", **ns)
|
|
attr_merged = rdf_attr.format(attr="", targets=target_tag_x86_64 + target_tag_x86, **ns)
|
|
|
|
# This table defines the test cases, columns "a" and "b" being the
|
|
# contents of the install.rdf of the respective platform and
|
|
# "result" the exepected merged content after unification.
|
|
testcases = (
|
|
#_____a_____ _____b_____ ___result___#
|
|
(tag_x86_64, tag_x86, tag_merged ),
|
|
(tag_x86_64, tag_empty, tag_empty ),
|
|
(tag_empty, tag_x86, tag_empty ),
|
|
(tag_empty, tag_empty, tag_empty ),
|
|
|
|
(attr_x86_64, attr_x86, attr_merged ),
|
|
(tag_x86_64, attr_x86, tag_merged ),
|
|
(attr_x86_64, tag_x86, attr_merged ),
|
|
|
|
(attr_x86_64, tag_empty, tag_empty ),
|
|
(tag_empty, attr_x86, tag_empty )
|
|
)
|
|
|
|
# Now create the files from the above table and compare
|
|
results = []
|
|
for emid, (rdf_a, rdf_b, result) in enumerate(testcases):
|
|
filename = 'ext/id{0}/install.rdf'.format(emid)
|
|
self.create_one('a', filename, rdf_a)
|
|
self.create_one('b', filename, rdf_b)
|
|
results.append((filename, result))
|
|
|
|
self.assertEqual(sorted([(f, c.open().read()) for f, c in
|
|
finder.find('**/install.rdf')]), results)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
mozunit.main()
|