forked from Mirror/pmbootstrap
af4b817c21
Since PR #1247 we are using the virtual package `.pmbootstrap` to mark packages as not explcitly installed. In case `pmbootstrap` doesn't finish the installation because of a bug, the `.pmbootstrap` virtual package may not get uninstalled. As virtual packages don't have the "timestamp" attribute set in the package database (which indicates when the package was built), the APKINDEX parser fails to parse them. Changes: * pmb.parse.apkindex.parse_next_block(): don't require the "timestamp" attribute to be set (but the arch attribute instead, which is always present) * pmb.parse.apkindex.parse(): when a block does not have a `timestamp` attribute, skip it, because it must be a virtual package. * add test cases for both functions with a package database that contains a virtual package.
350 lines
12 KiB
Python
350 lines
12 KiB
Python
"""
|
|
Copyright 2018 Oliver Smith
|
|
|
|
This file is part of pmbootstrap.
|
|
|
|
pmbootstrap is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
pmbootstrap is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with pmbootstrap. If not, see <http://www.gnu.org/licenses/>.
|
|
"""
|
|
|
|
"""
|
|
This file tests all functions from pmb.parse.apkindex.
|
|
"""
|
|
|
|
import collections
|
|
import os
|
|
import pytest
|
|
import sys
|
|
|
|
# Import from parent directory
|
|
sys.path.append(os.path.realpath(
|
|
os.path.join(os.path.dirname(__file__) + "/..")))
|
|
import pmb.parse.apkindex
|
|
import pmb.helpers.logging
|
|
import pmb.helpers.repo
|
|
|
|
|
|
@pytest.fixture
|
|
def args(tmpdir, request):
|
|
import pmb.parse
|
|
sys.argv = ["pmbootstrap", "init"]
|
|
args = pmb.parse.arguments()
|
|
args.log = args.work + "/log_testsuite.txt"
|
|
pmb.helpers.logging.init(args)
|
|
request.addfinalizer(args.logfd.close)
|
|
return args
|
|
|
|
|
|
def test_parse_next_block_exceptions(args):
|
|
# Mapping of input files (inside the /test/testdata/apkindex) to
|
|
# error message substrings
|
|
mapping = {"key_twice": "specified twice",
|
|
"key_missing": "Missing required key",
|
|
"new_line_missing": "does not end with a new line!"}
|
|
|
|
# Parse the files
|
|
for file, error_substr in mapping.items():
|
|
path = pmb.config.pmb_src + "/test/testdata/apkindex/" + file
|
|
with open(path, "r", encoding="utf-8") as handle:
|
|
lines = handle.readlines()
|
|
|
|
with pytest.raises(RuntimeError) as e:
|
|
pmb.parse.apkindex.parse_next_block(args, path, lines, [0])
|
|
assert error_substr in str(e.value)
|
|
|
|
|
|
def test_parse_next_block_no_error(args):
|
|
# Read the file
|
|
func = pmb.parse.apkindex.parse_next_block
|
|
path = pmb.config.pmb_src + "/test/testdata/apkindex/no_error"
|
|
with open(path, "r", encoding="utf-8") as handle:
|
|
lines = handle.readlines()
|
|
|
|
# First block
|
|
start = [0]
|
|
block = {'arch': 'x86_64',
|
|
'depends': [],
|
|
'origin': 'musl',
|
|
'pkgname': 'musl',
|
|
'provides': ['so:libc.musl-x86_64.so.1'],
|
|
'timestamp': '1515217616',
|
|
'version': '1.1.18-r5'}
|
|
assert func(args, path, lines, start) == block
|
|
assert start == [24]
|
|
|
|
# Second block
|
|
block = {'arch': 'x86_64',
|
|
'depends': ['ca-certificates',
|
|
'so:libc.musl-x86_64.so.1',
|
|
'so:libcurl.so.4',
|
|
'so:libz.so.1'],
|
|
'origin': 'curl',
|
|
'pkgname': 'curl',
|
|
'provides': ['cmd:curl'],
|
|
'timestamp': '1512030418',
|
|
'version': '7.57.0-r0'}
|
|
assert func(args, path, lines, start) == block
|
|
assert start == [45]
|
|
|
|
# No more blocks
|
|
assert func(args, path, lines, start) is None
|
|
assert start == [45]
|
|
|
|
|
|
def test_parse_next_block_virtual(args):
|
|
"""
|
|
Test parsing a virtual package from an APKINDEX.
|
|
"""
|
|
# Read the file
|
|
func = pmb.parse.apkindex.parse_next_block
|
|
path = pmb.config.pmb_src + "/test/testdata/apkindex/virtual_package"
|
|
with open(path, "r", encoding="utf-8") as handle:
|
|
lines = handle.readlines()
|
|
|
|
# First block
|
|
start = [0]
|
|
block = {'arch': 'x86_64',
|
|
'depends': ['so:libc.musl-x86_64.so.1'],
|
|
'origin': 'hello-world',
|
|
'pkgname': 'hello-world',
|
|
'provides': ['cmd:hello-world'],
|
|
'timestamp': '1500000000',
|
|
'version': '2-r0'}
|
|
assert func(args, path, lines, start) == block
|
|
assert start == [20]
|
|
|
|
# Second block: virtual package
|
|
block = {'arch': 'noarch',
|
|
'depends': ['hello-world'],
|
|
'pkgname': '.pmbootstrap',
|
|
'provides': [],
|
|
'version': '0'}
|
|
assert func(args, path, lines, start) == block
|
|
assert start == [31]
|
|
|
|
# No more blocks
|
|
assert func(args, path, lines, start) is None
|
|
assert start == [31]
|
|
|
|
|
|
def test_parse_add_block(args):
|
|
func = pmb.parse.apkindex.parse_add_block
|
|
multiple_providers = False
|
|
|
|
# One package without alias
|
|
ret = {}
|
|
block = {"pkgname": "test", "version": "2"}
|
|
alias = None
|
|
func(ret, block, alias, multiple_providers)
|
|
assert ret == {"test": block}
|
|
|
|
# Older packages must not overwrite newer ones
|
|
block_old = {"pkgname": "test", "version": "1"}
|
|
func(ret, block_old, alias, multiple_providers)
|
|
assert ret == {"test": block}
|
|
|
|
# Newer packages must overwrite older ones
|
|
block_new = {"pkgname": "test", "version": "3"}
|
|
func(ret, block_new, alias, multiple_providers)
|
|
assert ret == {"test": block_new}
|
|
|
|
# Add package with alias
|
|
alias = "test_alias"
|
|
func(ret, block_new, alias, multiple_providers)
|
|
assert ret == {"test": block_new, "test_alias": block_new}
|
|
|
|
|
|
def test_parse_add_block_multiple_providers(args):
|
|
func = pmb.parse.apkindex.parse_add_block
|
|
|
|
# One package without alias
|
|
ret = {}
|
|
block = {"pkgname": "test", "version": "2"}
|
|
alias = None
|
|
func(ret, block, alias)
|
|
assert ret == {"test": {"test": block}}
|
|
|
|
# Older packages must not overwrite newer ones
|
|
block_old = {"pkgname": "test", "version": "1"}
|
|
func(ret, block_old, alias)
|
|
assert ret == {"test": {"test": block}}
|
|
|
|
# Newer packages must overwrite older ones
|
|
block_new = {"pkgname": "test", "version": "3"}
|
|
func(ret, block_new, alias)
|
|
assert ret == {"test": {"test": block_new}}
|
|
|
|
# Add package with alias
|
|
alias = "test_alias"
|
|
func(ret, block_new, alias)
|
|
assert ret == {"test": {"test": block_new},
|
|
"test_alias": {"test": block_new}}
|
|
|
|
# Add another package with the same alias
|
|
alias = "test_alias"
|
|
block_test2 = {"pkgname": "test2", "version": "1"}
|
|
func(ret, block_test2, alias)
|
|
assert ret == {"test": {"test": block_new},
|
|
"test_alias": {"test": block_new, "test2": block_test2}}
|
|
|
|
|
|
def test_parse_invalid_path(args):
|
|
assert pmb.parse.apkindex.parse(args, "/invalid/path/APKINDEX") == {}
|
|
|
|
|
|
def test_parse_cached(args, tmpdir):
|
|
# Create a real file (cache looks at the last modified date)
|
|
path = str(tmpdir) + "/APKINDEX"
|
|
pmb.helpers.run.user(args, ["touch", path])
|
|
lastmod = os.path.getmtime(path)
|
|
|
|
# Fill the cache
|
|
args.cache["apkindex"][path] = {
|
|
"lastmod": lastmod,
|
|
"multiple": "cached_result_multiple",
|
|
"single": "cached_result_single",
|
|
}
|
|
|
|
# Verify cache usage
|
|
func = pmb.parse.apkindex.parse
|
|
assert func(args, path, True) == "cached_result_multiple"
|
|
assert func(args, path, False) == "cached_result_single"
|
|
|
|
# Make cache invalid
|
|
args.cache["apkindex"][path]["lastmod"] -= 10
|
|
assert func(args, path, True) == {}
|
|
|
|
# Delete the cache (run twice for both code paths)
|
|
assert pmb.parse.apkindex.clear_cache(args, path) is True
|
|
assert args.cache["apkindex"] == {}
|
|
assert pmb.parse.apkindex.clear_cache(args, path) is False
|
|
|
|
|
|
def test_parse(args):
|
|
path = pmb.config.pmb_src + "/test/testdata/apkindex/no_error"
|
|
block_musl = {'arch': 'x86_64',
|
|
'depends': [],
|
|
'origin': 'musl',
|
|
'pkgname': 'musl',
|
|
'provides': ['so:libc.musl-x86_64.so.1'],
|
|
'timestamp': '1515217616',
|
|
'version': '1.1.18-r5'}
|
|
block_curl = {'arch': 'x86_64',
|
|
'depends': ['ca-certificates',
|
|
'so:libc.musl-x86_64.so.1',
|
|
'so:libcurl.so.4',
|
|
'so:libz.so.1'],
|
|
'origin': 'curl',
|
|
'pkgname': 'curl',
|
|
'provides': ['cmd:curl'],
|
|
'timestamp': '1512030418',
|
|
'version': '7.57.0-r0'}
|
|
|
|
# Test without multiple_providers
|
|
ret_single = {'cmd:curl': block_curl,
|
|
'curl': block_curl,
|
|
'musl': block_musl,
|
|
'so:libc.musl-x86_64.so.1': block_musl}
|
|
assert pmb.parse.apkindex.parse(args, path, False) == ret_single
|
|
assert args.cache["apkindex"][path]["single"] == ret_single
|
|
|
|
# Test with multiple_providers
|
|
ret_multiple = {'cmd:curl': {"curl": block_curl},
|
|
'curl': {"curl": block_curl},
|
|
'musl': {"musl": block_musl},
|
|
'so:libc.musl-x86_64.so.1': {"musl": block_musl}}
|
|
assert pmb.parse.apkindex.parse(args, path, True) == ret_multiple
|
|
assert args.cache["apkindex"][path]["multiple"] == ret_multiple
|
|
|
|
|
|
def test_parse_virtual(args):
|
|
"""
|
|
This APKINDEX contains a virtual package .pbmootstrap. It must not be part
|
|
of the output.
|
|
"""
|
|
path = pmb.config.pmb_src + "/test/testdata/apkindex/virtual_package"
|
|
block = {'arch': 'x86_64',
|
|
'depends': ['so:libc.musl-x86_64.so.1'],
|
|
'origin': 'hello-world',
|
|
'pkgname': 'hello-world',
|
|
'provides': ['cmd:hello-world'],
|
|
'timestamp': '1500000000',
|
|
'version': '2-r0'}
|
|
ret = {"hello-world": block, "cmd:hello-world": block}
|
|
assert pmb.parse.apkindex.parse(args, path, False) == ret
|
|
assert args.cache["apkindex"][path]["single"] == ret
|
|
|
|
|
|
def test_providers_invalid_package(args, tmpdir):
|
|
# Create empty APKINDEX
|
|
path = str(tmpdir) + "/APKINDEX"
|
|
pmb.helpers.run.user(args, ["touch", path])
|
|
|
|
# Test with must_exist=False
|
|
func = pmb.parse.apkindex.providers
|
|
package = "test"
|
|
indexes = [path]
|
|
assert func(args, package, None, False, indexes) == {}
|
|
|
|
# Test with must_exist=True
|
|
with pytest.raises(RuntimeError) as e:
|
|
func(args, package, None, True, indexes)
|
|
assert str(e.value).startswith("Could not find package")
|
|
|
|
|
|
def test_providers_highest_version(args, monkeypatch):
|
|
"""
|
|
In this test, we simulate 3 APKINDEX files ("i0", "i1", "i2" instead of
|
|
full paths to real APKINDEX.tar.gz files), and each of them has a different
|
|
version of the same package. The highest version must win, no matter in
|
|
which order the APKINDEX files are processed.
|
|
"""
|
|
# Fake parse function
|
|
def return_fake_parse(args, path):
|
|
version_mapping = {"i0": "2", "i1": "3", "i2": "1"}
|
|
package_block = {"pkgname": "test", "version": version_mapping[path]}
|
|
return {"test": {"test": package_block}}
|
|
monkeypatch.setattr(pmb.parse.apkindex, "parse", return_fake_parse)
|
|
|
|
# Verify that it picks the highest version
|
|
func = pmb.parse.apkindex.providers
|
|
providers = func(args, "test", indexes=["i0", "i1", "i2"])
|
|
assert providers["test"]["version"] == "3"
|
|
|
|
|
|
def test_package(args, monkeypatch):
|
|
# Override pmb.parse.apkindex.providers()
|
|
providers = collections.OrderedDict()
|
|
|
|
def return_providers(*args, **kwargs):
|
|
return providers
|
|
monkeypatch.setattr(pmb.parse.apkindex, "providers", return_providers)
|
|
|
|
# Provider with the same pkgname
|
|
func = pmb.parse.apkindex.package
|
|
pkgname = "test"
|
|
providers = {"test2": {"pkgname": "test2"}, "test": {"pkgname": "test"}}
|
|
assert func(args, pkgname) == {"pkgname": "test"}
|
|
|
|
# First provider
|
|
providers = {"test2": {"pkgname": "test2"}, "test3": {"pkgname": "test3"}}
|
|
assert func(args, pkgname) == {"pkgname": "test2"}
|
|
|
|
# No provider (with must_exist)
|
|
providers = {}
|
|
with pytest.raises(RuntimeError) as e:
|
|
func(args, pkgname)
|
|
assert "not found in any APKINDEX" in str(e.value)
|
|
|
|
# No provider (without must_exist)
|
|
assert func(args, pkgname, must_exist=False) is None
|