def _parse_requirements(self, node):
reqs = []
for child in node.children:
req_text = child.get_text(child.NODE_FLAT)
next_reqs = requirement_list.parse(req_text)
reqs.extend(next_reqs)
return requirement_list(reqs)
def __init__(self, origin=None, values=None):
super(value_requirement_list, self).__init__(origin)
values = values or requirement_list()
if not check.is_requirement_list(values):
values = requirement_list.parse(values)
check.check_requirement_list(values)
self.values = values
def test_resolve_requirements(self):
text = 'apple(linux) >= 1.2.3 kiwi orange(macos) == 6.6.6 pear(ios) lychee(all) corn(desktop) tomato(linux|macos) <= 9.8.7'
reqs = RL.parse(text)
self.assertEqual( [
( 'apple', '>=', '1.2.3', 'linux', None ),
( 'kiwi', None, None, None, None ),
( 'lychee', None, None, 'all', None ),
( 'corn', None, None, 'desktop', None ),
( 'tomato', '<=', '9.8.7', 'linux|macos', None ),
], reqs.resolve('linux') )
self.assertEqual( [
( 'kiwi', None, None, None, None ),
( 'orange', '==', '6.6.6', 'macos', None ),
( 'lychee', None, None, 'all', None ),
( 'corn', None, None, 'desktop', None ),
( 'tomato', '<=', '9.8.7', 'linux|macos', None ),
], reqs.resolve('macos') )
self.assertEqual( [
( 'kiwi', None, None, None, None ),
( 'pear', None, None, 'ios', None ),
( 'lychee', None, None, 'all', None ),
], reqs.resolve('ios') )
self.assertEqual( [
( 'kiwi', None, None, None, None ),
( 'lychee', None, None, 'all', None ),
], reqs.resolve('android') )
def __new__(clazz, filename, name, version, revision, epoch, system, level,
arch, distro, distro_version, requirements, properties, files):
check.check_string(filename)
check.check_string(name)
check.check_string(version)
revision = int(revision)
check.check_int(revision)
epoch = int(epoch)
check.check_int(epoch)
check.check_string(system)
check.check_string(level)
arch = build_arch.check_arch(arch, system, distro)
check.check_tuple(arch)
check.check_string(distro)
check.check_string(distro_version)
if check.is_string(requirements):
requirements = requirement_list.parse(requirements)
requirements = requirements or requirement_list()
check.check_requirement_list(requirements)
properties = properties or {}
check.check_dict(properties)
check.check_package_files(files)
return clazz.__bases__[0].__new__(clazz, 2, filename, name, version,
revision, epoch, system, level, arch,
distro, distro_version, requirements,
properties, files)
def xtest_performance(self):
db = DB(self._make_tmp_db_path())
TEST_REQUIREMENTS = RL.parse('foo >= 1.2.3-1 bar >= 6.6.6-1',
default_system_mask=build_system.ALL)
TEST_FILES = FCL([('lib/libfoo.a', 'c1'), ('include/libfoo.h', 'c2')])
TEST_PROPERTIES = {'p1': 'v1', 'p2': 6}
t = debug_timer('x', level='error')
n = 1000
t.start('insert %d ()' % (n))
for i in range(1, n + 1):
name = 'n%s' % (i)
version = '1.0.0'
files = FCL([('lib/libfoo%s.a' % (i), 'c1'),
('include/libfoo%s.h' % (i), 'c2')])
p = PE(name, version, 0, 0, TEST_REQUIREMENTS, TEST_PROPERTIES,
files)
db.add_package(p)
t.stop()
t.start('%s: list_all()')
db.list_all()
t.stop()
t.start('%s: names()')
names = db.names()
print(len(names))
for name in names:
files = db.files(name)
#print('%s: %s' % (name, len(files)))
t.stop()
def test_filter_by_system(self):
text = 'a(linux) >= 1.2 b(macos) >= 2.3 c(android) >= 3.4 d(desktop) >= 5.6 e(mobile) >= 6.7 f(ios) >= 7.8'
r = RL.parse(text)
self.assertEqual( [
( 'a', '>=', '1.2', 'linux', None ),
( 'd', '>=', '5.6', 'desktop', None ),
], r.filter_by_system('linux') )
def _parse_requirements(clazz, text):
'Parse the "Requires" property of a pc file.'
ll = text_line_parser(text, delimiter=',').texts(strip_head=True,
strip_tail=True)
result = []
for s in ll:
result.extend(requirement_list.parse(s))
return result
def parse(clazz, origin, text, node):
if origin:
check.check_value_origin(origin)
check.check_node(node)
if not text:
values = requirement_list()
else:
values = requirement_list.parse(text)
return clazz(origin=origin, values=values)
def test_filter_by_hardness(self):
text = 'a >= 1.2 RUN b >= 2.3 TOOL c >= 3.4 BUILD d >= 5.6 e >= 6.7'
r = RL.parse(text)
self.assertEqual( [
( 'a', '>=', '1.2', None, None ),
( 'b', '>=', '2.3', None, 'RUN' ),
( 'e', '>=', '6.7', None, None ),
], r.filter_by_hardness('RUN') )
self.assertEqual( [
( 'c', '>=', '3.4', None, 'TOOL' ),
], r.filter_by_hardness('TOOL') )
self.assertEqual( [
( 'd', '>=', '5.6', None, 'BUILD' ),
], r.filter_by_hardness('BUILD') )
def test_parse(self):
recipe = \
R(AD('foo', '1.2.3', 0, 0, 'linux', 'release', 'x86_64', 'ubuntu', '18'),
[
temp_item('bin/tfoo.py', '#!/usr/bin/env python\nprint(\'foo\')\nraise SystemExit(0)\n', 0o755),
temp_item('bin/tbar.py', '#!/usr/bin/env python\nprint(\'bar\')\nraise SystemExit(0)\n', 0o755),
],
[
temp_item('tfoo_env.sh', 'export TFOO_ENV1=tfoo_env1\n', 0o755),
temp_item('tbar_env.sh', 'export TBAR_ENV1=tbar_env1\n', 0o755),
],
RL.parse('apple >= 1.2.3 orange >= 6.6.6'),
{ 'prop1': '5', 'prop2': 'hi' },
{}
)
content = '''
fake_package foo 1.2.3 0 0 linux release x86_64 ubuntu 18
files
bin/tfoo.py
\#!/usr/bin/env python
print('foo')
raise SystemExit(0)
bin/tbar.py
\#!/usr/bin/env python
print('bar')
raise SystemExit(0)
env_files
tfoo_env.sh
export TFOO_ENV1=tfoo_env1
tbar_env.sh
export TBAR_ENV1=tbar_env1
requirements
apple >= 1.2.3
orange >= 6.6.6
properties
prop1=5
prop2=hi
'''
actual = self._parse(content)
self.assertEqual(recipe.metadata, actual[0].metadata)
self.assertEqual(recipe.properties, actual[0].properties)
self.assertEqual(recipe.requirements, actual[0].requirements)
self.assertEqual(recipe.files, actual[0].files)
self.assertEqual(recipe.env_files, actual[0].env_files)
def test_package_descriptor_with_requirements(self):
tmp_tarball = fake_package_unit_test.create_one_package(self._ORANGE)
p = package(tmp_tarball)
self.assertEqual('orange', p.package_descriptor.name)
self.assertEqual(build_version('6.5.4', '3', 0),
p.package_descriptor.version)
self.assertEqual(
requirement_list.parse('fruit >= 1.0.0-0 citrus >= 1.0.0-0'),
p.package_descriptor.requirements)
self.assertEqual({}, p.package_descriptor.properties)
self.assertEqual([
'bin/orange_script.sh', 'docs/orange_bar.txt',
'docs/orange_foo.txt', 'lib/pkgconfig/orange.pc'
], p.files)
self.assertEqual(['lib/pkgconfig/orange.pc'], p.pkg_config_files)
def test_parse_dups(self):
text = 'foo >= 1.2.3 orange >= 6.6.6 bar baz bar orange >= 6.6.6'
requirements = RL.parse(text)
self.assertEqual( [
( 'foo', '>=', '1.2.3', None, None ),
( 'orange', '>=', '6.6.6', None, None ),
( 'bar', None, None, None, None ),
( 'baz', None, None, None, None ),
], requirements )
self.assertEqual( [
( 'foo', '>=', '1.2.3', None, None ),
( 'orange', '>=', '6.6.6', None, None ),
( 'bar', None, None, None, None ),
( 'baz', None, None, None, None ),
], requirements )
def test_parse_string_seq_list(self):
text = [ 'foo >= 1.2.3', 'orange >= 6.6.6', 'bar', 'baz', 'bar', 'orange >= 6.6.6' ]
requirements = RL.parse(text)
self.assertEqual( [
( 'foo', '>=', '1.2.3', None, None ),
( 'orange', '>=', '6.6.6', None, None ),
( 'bar', None, None, None, None ),
( 'baz', None, None, None, None ),
], requirements )
self.assertEqual( [
( 'foo', '>=', '1.2.3', None, None ),
( 'orange', '>=', '6.6.6', None, None ),
( 'bar', None, None, None, None ),
( 'baz', None, None, None, None ),
], requirements )
class test_package_metadata_list(unit_test):
__unit_test_data_dir__ = '${BES_TEST_DATA_DIR}/lib/rebuild/package'
TEST_REQUIREMENTS = RL.parse('foo >= 1.2.3-1 bar >= 6.6.6-1')
TEST_FILES = PF(FCL([
('f1', 'fchk1'),
('f2', 'fchk2'),
]), FCL([
('e1', 'echk1'),
('e2', 'echk2'),
]), 'files_chk', 'env_files_chk')
TEST_PROPERTIES = {'p1': 'v1', 'p2': 6}
def test_sort(self):
l = PML()
l.append(self._make_md('foo', '1.0.1', 'macos', 'release'))
l.append(self._make_md('foo', '1.0.0', 'macos', 'release'))
l.append(self._make_md('bar', '2.0.0', 'macos', 'release'))
l.append(self._make_md('bar', '2.0.1', 'macos', 'release'))
l.sort()
self.assertEqual('bar-2.0.0', l[0].full_name)
self.assertEqual('bar-2.0.1', l[1].full_name)
self.assertEqual('foo-1.0.0', l[2].full_name)
self.assertEqual('foo-1.0.1', l[3].full_name)
def test_latest_versions(self):
l = PML()
l.append(self._make_md('foo', '1.0.0', 'macos', 'release'))
l.append(self._make_md('foo', '1.0.1', 'macos', 'release'))
l.append(self._make_md('bar', '2.0.0', 'macos', 'release'))
l.append(self._make_md('bar', '2.0.1', 'macos', 'release'))
latest = l.latest_versions()
self.assertEqual(2, len(latest))
self.assertEqual('bar-2.0.1', latest[0].full_name)
self.assertEqual('foo-1.0.1', latest[1].full_name)
def _make_md(self, name, version, system, level):
artifact = '%s-%s.tar.gz' % (name, version)
return PM(artifact, name, version, 0, 0, system, level, 'x86_64', '',
'', self.TEST_REQUIREMENTS, self.TEST_PROPERTIES,
self.TEST_FILES)
def test___str__(self):
r = R(
AD('foo', '1.2.3', 0, 0, 'linux', 'release', 'x86_64', 'ubuntu',
'18'), [
temp_item('bin/foo.sh', '#!/bin/bash\necho foo\nexit 0\n',
0o755),
temp_item('bin/bar.sh', '#!/bin/bash\necho bar\nexit 1\n',
0o755),
], [
temp_item('foo_env.sh',
'#@REBUILD_HEAD@\nexport FOO_ENV=foo\n', 0o644),
temp_item('bar_env.sh',
'#@REBUILD_HEAD@\nexport BAR_ENV=bar\n', 0o644),
], RL.parse('apple >= 1.2.3 orange >= 6.6.6'), {
'prop1': 5,
'prop2': 'hi'
}, {})
expected = '''fake_package
metadata
name foo
version 1.2.3
revision 0
epoch 0
system linux
level release
arch ('x86_64',)
distro ubuntu
distro_version 18
requirements
all: apple >= 1.2.3
all: orange >= 6.6.6
properties
prop1=5
prop2=hi'''
self.assertMultiLineEqual(expected, str(r))
from rebuild.package.artifact_db import artifact_db as DB
from rebuild.package import package_metadata as MD, artifact_descriptor as AD
from rebuild.base import build_system, build_target, package_descriptor, requirement as R, requirement_list as RL
from bes.fs import file_checksum_list
db = DB('art.db')
TEST_REQUIREMENTS = RL.parse('foo >= 1.2.3-1 bar >= 6.6.6-1',
default_system_mask=build_system.ALL)
TEST_FILES = file_checksum_list([('lib/libfoo.a', 'c1'),
('include/libfoo.h', 'c2')])
TEST_FILES.sort()
TEST_PROPERTIES = {'p1': 'v1', 'p2': 6}
kiwi = MD('kiwi-6.7.8-2.tar.gz', 'kiwi', '6.7.8', 2, 0, 'macos', 'release',
['x86_64'], '', TEST_REQUIREMENTS, TEST_PROPERTIES, TEST_FILES,
'chk1')
apple = MD('apple-1.2.3.tar.gz', 'apple', '1.2.3', 0, 0, 'macos', 'release',
['x86_64'], '', TEST_REQUIREMENTS, TEST_PROPERTIES, TEST_FILES,
'chk1')
print(db.has_artifact(kiwi.artifact_descriptor))
db.add_artifact(apple)
db.add_artifact(kiwi)
print(db.has_artifact(kiwi.artifact_descriptor))
def _parse_requirements(clazz, l):
check.check_string_seq(l)
reqs = requirement_list()
for n in l:
reqs.extend(requirement_list.parse(n))
return reqs
def requirements_from_string_list(clazz, l):
check.check_string_seq(l)
result = requirement_list()
for n in l:
result.extend(requirement_list.parse(n))
return result
class test_package_db_entry(unit_test):
TEST_REQUIREMENTS = RL.parse('foo >= 1.2.3-1 bar >= 6.6.6-1')
TEST_FILES = package_files(FCL([
('f1', 'fchk1'),
('f2', 'fchk2'),
]), FCL([
('e1', 'echk1'),
('e2', 'echk2'),
]), 'files_chk', 'env_files_chk')
TEST_PROPERTIES = {'p1': 'v1', 'p2': 6}
TEST_ENTRY = PE('kiwi', '6.7.8', 2, 0, TEST_REQUIREMENTS, TEST_PROPERTIES,
TEST_FILES)
def test_descriptor(self):
self.assertEqual(
package_descriptor('kiwi', '6.7.8-2', self.TEST_PROPERTIES,
self.TEST_REQUIREMENTS),
self.TEST_ENTRY.descriptor)
def test_to_json(self):
self.maxDiff = None
expected_json = '''\
{
"_format_version": 2,
"epoch": 0,
"files": {
"env_files": [
[
"e1",
"echk1"
],
[
"e2",
"echk2"
]
],
"env_files_checksum": "env_files_chk",
"files": [
[
"f1",
"fchk1"
],
[
"f2",
"fchk2"
]
],
"files_checksum": "files_chk"
},
"name": "kiwi",
"properties": {
"p1": "v1",
"p2": 6
},
"requirements": [
"foo >= 1.2.3-1",
"bar >= 6.6.6-1"
],
"revision": 2,
"version": "6.7.8"
}'''
self.assertMultiLineEqual(expected_json, self.TEST_ENTRY.to_json())
def test_parse_json_v2(self):
json = '''\
{
"_format_version": 2,
"epoch": 0,
"files": {
"env_files": [
[
"e1",
"echk1"
],
[
"e2",
"echk2"
]
],
"env_files_checksum": "env_files_chk",
"files": [
[
"f1",
"fchk1"
],
[
"f2",
"fchk2"
]
],
"files_checksum": "files_chk"
},
"name": "kiwi",
"properties": {
"p1": "v1",
"p2": 6
},
"requirements": [
"foo >= 1.2.3-1",
"bar >= 6.6.6-1"
],
"revision": 2,
"version": "6.7.8"
}'''
actual_entry = PE.parse_json(json)
self.maxDiff = None
self.assertEqual(self.TEST_ENTRY, actual_entry)
def test_to_simple_dict(self):
expected = {
'_format_version': 2,
'epoch': 0,
'files': {
'env_files': [['e1', 'echk1'], ['e2', 'echk2']],
'env_files_checksum': 'env_files_chk',
'files': [['f1', 'fchk1'], ['f2', 'fchk2']],
'files_checksum': 'files_chk'
},
'name': 'kiwi',
'properties': {
'p1': 'v1',
'p2': 6
},
'requirements': ['foo >= 1.2.3-1', 'bar >= 6.6.6-1'],
'revision': 2,
'version': '6.7.8',
}
self.assertEqual(expected, self.TEST_ENTRY.to_simple_dict())
def __dedup_requirements(clazz, value):
reqs = requirement_list.parse(value)
reqs.remove_dups()
return reqs.to_string()