def test_set_skbuild_plat_name():
try:
previous_plat_name = skbuild_plat_name()
set_skbuild_plat_name("plat-name")
assert os.path.join(
"_skbuild",
"plat-name-{}.{}".format(*sys.version_info[:2])) == SKBUILD_DIR()
finally:
set_skbuild_plat_name(previous_plat_name)
def test_hello_clean(capfd):
with push_dir():
@project_setup_py_test("hello-pure", ["build"], disable_languages_test=True)
def run_build():
pass
tmp_dir = run_build()[0]
assert tmp_dir.join(SKBUILD_DIR()).exists()
@project_setup_py_test("hello-pure", ["clean"], tmp_dir=tmp_dir, disable_languages_test=True)
def run_clean():
pass
run_clean()
assert not tmp_dir.join(SKBUILD_DIR()).exists()
out = capfd.readouterr()[0]
assert 'Build files have been written to' not in out
def test_hello_clean(dry_run, capfd):
with push_dir():
dry_run = dry_run == 'with-dry-run'
@project_setup_py_test("hello-cpp", ["build"])
def run_build():
pass
tmp_dir = run_build()[0]
assert tmp_dir.join(SKBUILD_DIR()).exists()
# XXX Since using capfd.disabled() context manager prevents
# the output from being captured atfer it exits, we display
# a separator allowing to differentiate the build and clean output.
print("<<-->>")
clean_args = ["clean"]
if dry_run:
clean_args.append("--dry-run")
@project_setup_py_test("hello-cpp", clean_args, tmp_dir=tmp_dir)
def run_clean():
pass
run_clean()
if not dry_run:
assert not tmp_dir.join(SKBUILD_DIR()).exists()
else:
assert tmp_dir.join(SKBUILD_DIR()).exists()
build_out, clean_out = capfd.readouterr()[0].split('<<-->>')
assert 'Build files have been written to' in build_out
assert 'Build files have been written to' not in clean_out
def test_hello_cleans(capfd):
with push_dir():
tmp_dir = _tmpdir("test_hello_cleans")
_copy_dir(tmp_dir, os.path.join(SAMPLES_DIR, "hello-cpp"))
@project_setup_py_test("hello-cpp", ["build"], tmp_dir=tmp_dir)
def run_build():
pass
@project_setup_py_test("hello-cpp", ["clean"], tmp_dir=tmp_dir)
def run_clean():
pass
# Check that a project can be cleaned twice in a row
run_build()
print("<<-->>")
run_clean()
print("<<-->>")
run_clean()
_, clean1_out, clean2_out = \
capfd.readouterr()[0].split('<<-->>')
clean1_out = clean1_out.strip()
clean2_out = clean2_out.strip()
assert "running clean" == clean1_out.splitlines()[0]
assert "removing '{}'".format(
CMAKE_INSTALL_DIR()) == clean1_out.splitlines()[1]
assert "removing '{}'".format(
CMAKE_BUILD_DIR()) == clean1_out.splitlines()[2]
assert "removing '{}'".format(SKBUILD_DIR()) == clean1_out.splitlines()[3]
assert "running clean" == clean2_out
class CleanUp(set_build_base_mixin, new_style(_clean)):
"""Custom implementation of ``clean`` setuptools command.
Overriding clean in order to get rid if "dist" folder and etc
"""
skroot = dirname(SKBUILD_DIR())
CLEANFOLDERS = (
CMAKE_INSTALL_DIR(),
CMAKE_BUILD_DIR(),
SKBUILD_DIR(),
skroot,
"TMP",
"__pycache__",
"pip-wheel-metadata",
".eggs",
"dist",
"sdist",
"wheel",
".pytest_cache",
"docs/apiref",
"docs/_build",
"docs/_static",
"docs/_templates",
"htmlcov",
)
CLEANFOLDERSRECURSIVE = ["__pycache__", "_tmp_*", "xtgeo.egg-info"]
CLEANFILESRECURSIVE = ["*.pyc", "*.pyo", ".coverage", "coverage.xml"]
CLEANFILES = glob("src/xtgeo/cxtgeo/cxtgeo*")
CLEANFILES.extend(glob("src/xtgeo/cxtgeo/_cxtgeo*"))
@staticmethod
def ffind(pattern, path):
result = []
for root, dirs, files in os.walk(path):
for name in files:
if fnmatch.fnmatch(name, pattern):
result.append(os.path.join(root, name))
return result
@staticmethod
def dfind(pattern, path):
result = []
for root, dirs, files in os.walk(path):
for name in dirs:
if fnmatch.fnmatch(name, pattern):
result.append(os.path.join(root, name))
return result
def run(self):
"""After calling the super class implementation, this function removes
the directories specific to scikit-build ++."""
super(CleanUp, self).run()
for dir_ in CleanUp.CLEANFOLDERS:
if exists(dir_):
print("Removing: {}".format(dir_))
if not self.dry_run and exists(dir_):
rmtree(dir_)
for dir_ in CleanUp.CLEANFOLDERSRECURSIVE:
for pd in self.dfind(dir_, "."):
print("Remove folder {}".format(pd))
rmtree(pd)
for fil_ in CleanUp.CLEANFILESRECURSIVE:
for pf in self.ffind(fil_, "."):
print("Remove file {}".format(pf))
os.unlink(pf)
for fil_ in CleanUp.CLEANFILES:
if exists(fil_):
print("Removing: {}".format(fil_))
if not self.dry_run and exists(fil_):
os.remove(fil_)
def test_cmake_install_into_pure_package(with_cmake_source_dir, capsys):
# -------------------------------------------------------------------------
# "SOURCE" tree layout:
#
# (1) with_cmake_source_dir == 0
#
# ROOT/
#
# CMakeLists.txt
# setup.py
#
# fruits/
# __init__.py
#
#
# (2) with_cmake_source_dir == 1
#
# ROOT/
#
# setup.py
#
# fruits/
# __init__.py
#
# src/
#
# CMakeLists.txt
#
# -------------------------------------------------------------------------
# "BINARY" distribution layout:
#
# ROOT/
#
# fruits/
#
# __init__.py
# apple.py
# banana.py
#
# data/
#
# apple.dat
# banana.dat
#
tmp_dir = _tmpdir('cmake_install_into_pure_package')
cmake_source_dir = 'src' if with_cmake_source_dir else ''
tmp_dir.join('setup.py').write(
textwrap.dedent("""
from skbuild import setup
setup(
name="test_py_modules_keyword",
version="1.2.3",
description="a package testing use of py_modules keyword",
author='The scikit-build team',
license="MIT",
packages=['fruits'],
cmake_install_dir='fruits',
cmake_source_dir='{cmake_source_dir}',
)
""".format(cmake_source_dir=cmake_source_dir)))
cmake_src_dir = tmp_dir.ensure(cmake_source_dir, dir=1)
cmake_src_dir.join('CMakeLists.txt').write(
textwrap.dedent("""
cmake_minimum_required(VERSION 3.5.0)
project(test NONE)
file(WRITE "${CMAKE_BINARY_DIR}/apple.py" "# apple.py")
file(WRITE "${CMAKE_BINARY_DIR}/banana.py" "# banana.py")
install(
FILES
"${CMAKE_BINARY_DIR}/apple.py"
"${CMAKE_BINARY_DIR}/banana.py"
DESTINATION "."
)
file(WRITE "${CMAKE_BINARY_DIR}/apple.dat" "# apple.dat")
file(WRITE "${CMAKE_BINARY_DIR}/banana.dat" "# banana.dat")
install(
FILES
"${CMAKE_BINARY_DIR}/apple.dat"
"${CMAKE_BINARY_DIR}/banana.dat"
DESTINATION "data"
)
"""))
tmp_dir.ensure('fruits/__init__.py')
with execute_setup_py(tmp_dir, ['build'], disable_languages_test=True):
pass
messages = [
"copying {}/{} -> "
"{}/setuptools/lib".format(CMAKE_INSTALL_DIR(), module, SKBUILD_DIR())
for module in [
'fruits/__init__.py',
'fruits/apple.py',
'fruits/banana.py',
'fruits/data/apple.dat',
'fruits/data/banana.dat',
]
]
out, _ = capsys.readouterr()
for message in messages:
assert to_platform_path(message) in out
def test_py_modules_keyword(distribution_type, capsys):
# -------------------------------------------------------------------------
#
# "SOURCE" tree layout for "pure" distribution:
#
# ROOT/
# setup.py
# foo.py
# bar.py
#
# "SOURCE" tree layout for "skbuild" distribution:
#
# ROOT/
# setup.py
# CMakeLists.txt
#
# -------------------------------------------------------------------------
# "BINARY" distribution layout is identical for both
#
# ROOT/
# foo.py
# bar.py
#
tmp_dir = _tmpdir('py_modules_keyword')
tmp_dir.join('setup.py').write(
textwrap.dedent("""
from skbuild import setup
setup(
name="test_py_modules_keyword",
version="1.2.3",
description="a package testing use of py_modules keyword",
author='The scikit-build team',
license="MIT",
py_modules=['foo', 'bar']
)
"""))
if distribution_type == 'skbuild':
tmp_dir.join('CMakeLists.txt').write(
textwrap.dedent("""
cmake_minimum_required(VERSION 3.5.0)
project(foobar NONE)
file(WRITE "${CMAKE_BINARY_DIR}/foo.py" "# foo.py")
file(WRITE "${CMAKE_BINARY_DIR}/bar.py" "# bar.py")
install(
FILES
"${CMAKE_BINARY_DIR}/foo.py"
"${CMAKE_BINARY_DIR}/bar.py"
DESTINATION "."
)
"""))
messages = [
"copying {}/{}.py -> "
"{}/setuptools/lib".format(CMAKE_INSTALL_DIR(), module,
SKBUILD_DIR())
for module in ['foo', 'bar']
]
elif distribution_type == 'pure':
tmp_dir.join('foo.py').write("# foo.py")
tmp_dir.join('bar.py').write("# bar.py")
messages = [
"copying {}.py -> "
"{}/setuptools/lib".format(module, SKBUILD_DIR())
for module in ['foo', 'bar']
]
with execute_setup_py(tmp_dir, ['build'], disable_languages_test=True):
pass
out, _ = capsys.readouterr()
for message in messages:
assert to_platform_path(message) in out