blob: e0fd3595cae787491f04c6c1c619ee93583dd652 [file] [log] [blame]
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Pylint doesn't play well with fixtures and dependency injection from pytest
# pylint: disable=redefined-outer-name
import os
import shutil
import pytest
from buildstream import _yaml
from buildstream._testing import cli_integration as cli # pylint: disable=unused-import
from buildstream._testing._utils.site import HAVE_SANDBOX
pytestmark = pytest.mark.integration
DATA_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), "project")
def create_manual_element(name, path, config, variables, environment, sources=None):
element = {
"kind": "manual",
"depends": [{"filename": "base.bst", "type": "build"}],
"config": config,
"variables": variables,
"environment": environment,
}
if sources:
element["sources"] = sources
os.makedirs(os.path.dirname(os.path.join(path, name)), exist_ok=True)
_yaml.roundtrip_dump(element, os.path.join(path, name))
@pytest.mark.datafiles(DATA_DIR)
@pytest.mark.skipif(not HAVE_SANDBOX, reason="Only available with a functioning sandbox")
def test_manual_element(cli, datafiles):
project = str(datafiles)
checkout = os.path.join(cli.directory, "checkout")
element_path = os.path.join(project, "elements")
element_name = "import/import.bst"
create_manual_element(
element_name,
element_path,
{
"configure-commands": ["echo './configure' >> test"],
"build-commands": ["echo 'make' >> test"],
"install-commands": ["echo 'make install' >> test", "cp test %{install-root}"],
"strip-commands": ["echo 'strip' >> %{install-root}/test"],
},
{},
{},
)
res = cli.run(project=project, args=["build", element_name])
assert res.exit_code == 0
res = cli.run(project=project, args=["artifact", "checkout", element_name, "--directory", checkout])
assert res.exit_code == 0
with open(os.path.join(checkout, "test"), encoding="utf-8") as f:
text = f.read()
assert (
text
== """./configure
make
make install
strip
"""
)
@pytest.mark.datafiles(DATA_DIR)
@pytest.mark.skipif(not HAVE_SANDBOX, reason="Only available with a functioning sandbox")
def test_manual_element_environment(cli, datafiles):
project = str(datafiles)
checkout = os.path.join(cli.directory, "checkout")
element_path = os.path.join(project, "elements")
element_name = "import/import.bst"
create_manual_element(
element_name, element_path, {"install-commands": ["echo $V >> test", "cp test %{install-root}"]}, {}, {"V": 2}
)
res = cli.run(project=project, args=["build", element_name])
assert res.exit_code == 0
res = cli.run(project=project, args=["artifact", "checkout", element_name, "--directory", checkout])
assert res.exit_code == 0
with open(os.path.join(checkout, "test"), encoding="utf-8") as f:
text = f.read()
assert text == "2\n"
@pytest.mark.datafiles(DATA_DIR)
@pytest.mark.skipif(not HAVE_SANDBOX, reason="Only available with a functioning sandbox")
def test_manual_element_noparallel(cli, datafiles):
project = str(datafiles)
checkout = os.path.join(cli.directory, "checkout")
element_path = os.path.join(project, "elements")
element_name = "import/import.bst"
create_manual_element(
element_name,
element_path,
{"install-commands": ["echo $MAKEFLAGS >> test", "echo $V >> test", "cp test %{install-root}"]},
{"notparallel": True},
{"MAKEFLAGS": "-j%{max-jobs} -Wall", "V": 2},
)
res = cli.run(project=project, args=["build", element_name])
assert res.exit_code == 0
res = cli.run(project=project, args=["artifact", "checkout", element_name, "--directory", checkout])
assert res.exit_code == 0
with open(os.path.join(checkout, "test"), encoding="utf-8") as f:
text = f.read()
assert (
text
== """-j1 -Wall
2
"""
)
@pytest.mark.datafiles(DATA_DIR)
@pytest.mark.skipif(not HAVE_SANDBOX, reason="Only available with a functioning sandbox")
def test_manual_element_logging(cli, datafiles):
project = str(datafiles)
element_path = os.path.join(project, "elements")
element_name = "import/import.bst"
create_manual_element(
element_name,
element_path,
{
"configure-commands": ["echo configure"],
"build-commands": ["echo build"],
"install-commands": ["echo install"],
"strip-commands": ["echo strip"],
},
{},
{},
)
res = cli.run(project=project, args=["build", element_name])
assert res.exit_code == 0
# Verify that individual commands are logged
assert "echo configure" in res.stderr
assert "echo build" in res.stderr
assert "echo install" in res.stderr
assert "echo strip" in res.stderr
# Regression test for https://gitlab.com/BuildStream/buildstream/-/issues/1295.
#
# Test that the command-subdir variable works as expected.
@pytest.mark.datafiles(DATA_DIR)
@pytest.mark.skipif(not HAVE_SANDBOX, reason="Only available with a functioning sandbox")
def test_manual_command_subdir(cli, datafiles):
project = str(datafiles)
checkout = os.path.join(cli.directory, "checkout")
element_path = os.path.join(project, "elements")
element_name = "manual/command-subdir.bst"
sources = [{"kind": "local", "path": "files/manual-element/root"}]
create_manual_element(
element_name,
element_path,
{"install-commands": ["cp hello %{install-root}"]},
{},
{},
sources=sources,
)
# First, verify that element builds, and has the correct expected output.
result = cli.run(project=project, args=["build", element_name])
result.assert_success()
result = cli.run(project=project, args=["artifact", "checkout", element_name, "--directory", checkout])
result.assert_success()
with open(os.path.join(checkout, "hello"), encoding="utf-8") as f:
assert f.read() == "hello from root\n"
# Now, change element configuration to have a different command-subdir.
# This should result in a different cache key.
create_manual_element(
element_name,
element_path,
{"install-commands": ["cp hello %{install-root}"]},
{"command-subdir": "subdir"},
{},
sources=sources,
)
# Verify that the element needs to be rebuilt.
assert cli.get_element_state(project, element_name) == "buildable"
# Finally, ensure that the variable actually takes effect.
result = cli.run(project=project, args=["build", element_name])
result.assert_success()
shutil.rmtree(checkout)
result = cli.run(project=project, args=["artifact", "checkout", element_name, "--directory", checkout])
result.assert_success()
with open(os.path.join(checkout, "hello"), encoding="utf-8") as f:
assert f.read() == "hello from subdir\n"
# Test staging artifacts into subdirectories
@pytest.mark.datafiles(DATA_DIR)
@pytest.mark.skipif(not HAVE_SANDBOX, reason="Only available with a functioning sandbox")
def test_manual_stage_custom(cli, datafiles):
project = str(datafiles)
checkout = os.path.join(cli.directory, "checkout")
# Verify that the element builds, and has the correct expected output.
result = cli.run(project=project, args=["build", "manual/manual-stage-custom.bst"])
result.assert_success()
result = cli.run(
project=project, args=["artifact", "checkout", "manual/manual-stage-custom.bst", "--directory", checkout]
)
result.assert_success()
with open(os.path.join(checkout, "test.txt"), encoding="utf-8") as f:
assert f.read() == "This is another test\n"