def test_load_local_builds_platform(self, conf_system, conf_resultsdir):
load_local_builds("platform:f30")
local_modules = models.ModuleBuild.local_modules(db_session)
assert len(local_modules) == 1
assert local_modules[0].koji_tag.endswith(
"/module-platform-f30-3/results")
def test_load_local_builds_name_stream(self, conf_system, conf_resultsdir):
load_local_builds("testmodule:master")
local_modules = models.ModuleBuild.local_modules(db_session)
assert len(local_modules) == 1
assert local_modules[0].koji_tag.endswith(
"/module-testmodule-master-20170816080816/results")
def test_resolve_profiles_local_module(self, local_builds, conf_system,
formatted_testmodule_mmd,
require_empty_database):
load_local_builds(["platform:f28"])
resolver = mbs_resolver.GenericResolver.create(db_session,
conf,
backend="mbs")
result = resolver.resolve_profiles(formatted_testmodule_mmd,
("buildroot", "srpm-buildroot"))
expected = {"buildroot": {"foo"}, "srpm-buildroot": {"bar"}}
assert result == expected
def test_get_module_build_dependencies_recursive_requires(self, resultdir, conf_system):
"""
Tests that it returns the requires of the buildrequires recursively
"""
load_local_builds(["platform:f30", "parent", "child", "testmodule"])
build = models.ModuleBuild.local_modules(db_session, "child", "master")
resolver = mbs_resolver.GenericResolver.create(db_session, conf, backend="db")
result = resolver.get_module_build_dependencies(mmd=build[0].mmd()).keys()
local_path = tests.staged_data_filename("local_builds")
expected = [os.path.join(local_path, "module-parent-master-20170816080815/results")]
assert set(result) == set(expected)
def test_get_buildrequired_modulemds_local_builds(self, local_builds,
conf_system,
require_empty_database):
with app.app_context():
load_local_builds(["testmodule"])
resolver = mbs_resolver.GenericResolver.create(db_session,
conf,
backend="mbs")
result = resolver.get_buildrequired_modulemds(
"testmodule", "master", "platform:f28:1:00000000")
assert 1 == len(result)
mmd = result[0]
assert "testmodule" == mmd.get_module_name()
assert "master" == mmd.get_stream_name()
assert 20170816080816 == mmd.get_version()
assert "321" == mmd.get_context()
def test_resolve_profiles_local_module(self, local_builds, conf_system):
"""
Test that profiles get resolved recursively on local builds
"""
# This test requires a platform module loaded from local rather than
# the one added to database.
platform = db_session.query(models.ModuleBuild).filter(
models.ModuleBuild.name == "platform"
).one()
db_session.delete(platform)
db_session.commit()
load_local_builds(["platform:f28"])
mmd = models.ModuleBuild.get_by_id(db_session, 2).mmd()
resolver = mbs_resolver.GenericResolver.create(db_session, conf, backend="mbs")
result = resolver.resolve_profiles(mmd, ("buildroot", "srpm-buildroot"))
expected = {"buildroot": {"foo"}, "srpm-buildroot": {"bar"}}
assert result == expected
def build_module_locally(
local_build_nsvs=None,
yaml_file=None,
srpms=None,
stream=None,
skiptests=False,
default_streams=None,
offline=False,
platform_repofiles=None,
platform_id=None,
log_debug=False,
):
""" Performs local module build using Mock
"""
# if debug is not specified, set log level of console to INFO
if not log_debug:
for handler in logging.getLogger().handlers:
if isinstance(handler, logging.StreamHandler):
handler.setLevel(logging.INFO)
if "SERVER_NAME" not in app.config or not app.config["SERVER_NAME"]:
app.config["SERVER_NAME"] = "localhost"
if conf.resolver == "db":
raise ValueError(
"Please set RESOLVER to 'mbs' in your configuration for local builds."
)
conf.set_item("system", "mock")
conf.set_item("base_module_repofiles", platform_repofiles)
# Use our own local SQLite3 database.
confdir = os.path.abspath(os.getcwd())
dbdir = \
os.path.abspath(os.path.join(confdir, "..")) if confdir.endswith("conf") else confdir
dbpath = "/{0}".format(os.path.join(dbdir, ".mbs_local_build.db"))
dburi = "sqlite://" + dbpath
app.config["SQLALCHEMY_DATABASE_URI"] = dburi
conf.set_item("sqlalchemy_database_uri", dburi)
if os.path.exists(dbpath):
os.remove(dbpath)
db.create_all()
# Reconfigure the backend database session registry to use the new the database location
db_session.remove()
db_session.configure(bind=db.session.bind)
params = {
"local_build": True,
"default_streams": dict(ns.split(":") for ns in default_streams)
}
if srpms:
params["srpms"] = srpms
username = getpass.getuser()
if not yaml_file or not yaml_file.endswith(".yaml"):
raise IOError("Provided modulemd file is not a yaml file.")
yaml_file_path = os.path.abspath(yaml_file)
if offline:
import_builds_from_local_dnf_repos(platform_id)
load_local_builds(local_build_nsvs)
with open(yaml_file_path) as fd:
filename = os.path.basename(yaml_file)
handle = FileStorage(fd)
handle.filename = filename
try:
module_builds = submit_module_build_from_yaml(db_session,
username,
handle,
params,
stream=str(stream),
skiptests=skiptests)
except StreamAmbigous as e:
logging.error(str(e))
logging.error(
"Use '-s module_name:module_stream' to choose the stream")
return
module_build_ids = [build.id for build in module_builds]
module_build_service.scheduler.local.main(module_build_ids)
has_failed_module = db_session.query(models.ModuleBuild).filter(
models.ModuleBuild.id.in_(module_build_ids),
models.ModuleBuild.state == models.BUILD_STATES["failed"],
).count() > 0
if has_failed_module:
raise RuntimeError("Module build failed")
def test_load_local_builds_name_stream_version_non_existing(
self, conf_system, conf_resultsdir):
with pytest.raises(RuntimeError):
load_local_builds("testmodule:master:123")
models.ModuleBuild.local_modules(db_session)