337 lines
10 KiB
Python
337 lines
10 KiB
Python
from __future__ import annotations
|
|
|
|
import sys
|
|
|
|
import pytest
|
|
|
|
from cibuildwheel.__main__ import main
|
|
from cibuildwheel.architecture import Architecture
|
|
from cibuildwheel.selector import EnableGroup
|
|
|
|
from ..conftest import MOCK_PACKAGE_DIR
|
|
|
|
TYPE_CHECKING = False
|
|
if TYPE_CHECKING:
|
|
from cibuildwheel.typing import PlatformName
|
|
|
|
from .conftest import ArgsInterceptor
|
|
|
|
|
|
@pytest.mark.parametrize("option_value", [None, "auto", ""])
|
|
def test_platform_unset_or_auto(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
intercepted_build_args: ArgsInterceptor,
|
|
option_value: str | None,
|
|
) -> None:
|
|
if option_value is None:
|
|
monkeypatch.delenv("CIBW_PLATFORM", raising=False)
|
|
else:
|
|
monkeypatch.setenv("CIBW_PLATFORM", option_value)
|
|
|
|
main()
|
|
|
|
options = intercepted_build_args.args[0]
|
|
|
|
# check that the platform was auto detected to build for the current system
|
|
if sys.platform.startswith("linux"):
|
|
assert options.platform == "linux"
|
|
elif sys.platform == "darwin":
|
|
assert options.platform == "macos"
|
|
elif sys.platform == "win32":
|
|
assert options.platform == "windows"
|
|
else:
|
|
pytest.fail(f"Unknown platform: {sys.platform}")
|
|
|
|
|
|
def test_unknown_platform_on_ci(
|
|
monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
|
|
) -> None:
|
|
monkeypatch.setenv("CI", "true")
|
|
monkeypatch.setattr(sys, "platform", "nonexistent")
|
|
monkeypatch.delenv("CIBW_PLATFORM", raising=False)
|
|
|
|
with pytest.raises(SystemExit) as exit:
|
|
main()
|
|
assert exit.value.code == 2
|
|
_, err = capsys.readouterr()
|
|
|
|
assert 'Unable to detect platform from "sys.platform"' in err
|
|
|
|
|
|
def test_unknown_platform(
|
|
monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
|
|
) -> None:
|
|
monkeypatch.setenv("CIBW_PLATFORM", "nonexistent")
|
|
|
|
with pytest.raises(SystemExit) as exit:
|
|
main()
|
|
_, err = capsys.readouterr()
|
|
|
|
assert exit.value.code == 2
|
|
assert "Unsupported platform: nonexistent" in err
|
|
|
|
|
|
def test_platform_argument(
|
|
platform: str, intercepted_build_args: ArgsInterceptor, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
monkeypatch.setenv("CIBW_PLATFORM", "nonexistent")
|
|
monkeypatch.setattr(sys, "argv", [*sys.argv, "--platform", platform])
|
|
|
|
main()
|
|
|
|
options = intercepted_build_args.args[0]
|
|
|
|
assert options.globals.package_dir == MOCK_PACKAGE_DIR.resolve()
|
|
|
|
|
|
@pytest.mark.usefixtures("platform")
|
|
def test_platform_environment(intercepted_build_args: ArgsInterceptor) -> None:
|
|
main()
|
|
options = intercepted_build_args.args[0]
|
|
|
|
assert options.globals.package_dir == MOCK_PACKAGE_DIR.resolve()
|
|
|
|
|
|
def test_archs_default(platform: str, intercepted_build_args: ArgsInterceptor) -> None:
|
|
main()
|
|
options = intercepted_build_args.args[0]
|
|
|
|
if platform == "linux":
|
|
assert options.globals.architectures == {Architecture.x86_64}
|
|
elif platform == "windows":
|
|
assert options.globals.architectures == {Architecture.AMD64, Architecture.x86}
|
|
else:
|
|
assert options.globals.architectures == {Architecture.x86_64}
|
|
|
|
|
|
@pytest.mark.parametrize("use_env_var", [False, True])
|
|
def test_archs_argument(
|
|
platform: str,
|
|
intercepted_build_args: ArgsInterceptor,
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
use_env_var: bool,
|
|
) -> None:
|
|
if use_env_var:
|
|
monkeypatch.setenv("CIBW_ARCHS", "ppc64le")
|
|
else:
|
|
monkeypatch.setenv("CIBW_ARCHS", "unused")
|
|
monkeypatch.setattr(sys, "argv", [*sys.argv, "--archs", "ppc64le"])
|
|
|
|
if platform in {"macos", "windows"}:
|
|
with pytest.raises(SystemExit) as exit:
|
|
main()
|
|
assert exit.value.args == (4,)
|
|
|
|
else:
|
|
main()
|
|
options = intercepted_build_args.args[0]
|
|
assert options.globals.architectures == {Architecture.ppc64le}
|
|
|
|
|
|
def test_archs_platform_specific(
|
|
platform: str, intercepted_build_args: ArgsInterceptor, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
monkeypatch.setenv("CIBW_ARCHS", "unused")
|
|
monkeypatch.setenv("CIBW_ARCHS_LINUX", "ppc64le")
|
|
monkeypatch.setenv("CIBW_ARCHS_WINDOWS", "x86")
|
|
monkeypatch.setenv("CIBW_ARCHS_MACOS", "x86_64")
|
|
|
|
main()
|
|
options = intercepted_build_args.args[0]
|
|
|
|
if platform == "linux":
|
|
assert options.globals.architectures == {Architecture.ppc64le}
|
|
elif platform == "windows":
|
|
assert options.globals.architectures == {Architecture.x86}
|
|
elif platform == "macos":
|
|
assert options.globals.architectures == {Architecture.x86_64}
|
|
|
|
|
|
def test_archs_platform_native(
|
|
platform: str, intercepted_build_args: ArgsInterceptor, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
monkeypatch.setenv("CIBW_ARCHS", "native")
|
|
|
|
main()
|
|
options = intercepted_build_args.args[0]
|
|
|
|
if platform in {"linux", "macos"}:
|
|
assert options.globals.architectures == {Architecture.x86_64}
|
|
elif platform == "windows":
|
|
assert options.globals.architectures == {Architecture.AMD64}
|
|
|
|
|
|
def test_archs_platform_auto64(
|
|
platform: str, intercepted_build_args: ArgsInterceptor, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
monkeypatch.setenv("CIBW_ARCHS", "auto64")
|
|
|
|
main()
|
|
options = intercepted_build_args.args[0]
|
|
|
|
if platform in {"linux", "macos"}:
|
|
assert options.globals.architectures == {Architecture.x86_64}
|
|
elif platform == "windows":
|
|
assert options.globals.architectures == {Architecture.AMD64}
|
|
|
|
|
|
def test_archs_platform_auto32(
|
|
platform: str, intercepted_build_args: ArgsInterceptor, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
monkeypatch.setenv("CIBW_ARCHS", "auto32")
|
|
|
|
if platform == "macos":
|
|
with pytest.raises(SystemExit) as exit:
|
|
main()
|
|
assert exit.value.args == (4,)
|
|
|
|
else:
|
|
main()
|
|
|
|
options = intercepted_build_args.args[0]
|
|
|
|
if platform == "linux":
|
|
assert options.globals.architectures == {Architecture.i686}
|
|
elif platform == "windows":
|
|
assert options.globals.architectures == {Architecture.x86}
|
|
|
|
|
|
def test_archs_platform_all(
|
|
platform: str, intercepted_build_args: ArgsInterceptor, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
monkeypatch.setenv("CIBW_ARCHS", "all")
|
|
|
|
main()
|
|
options = intercepted_build_args.args[0]
|
|
|
|
if platform == "linux":
|
|
assert options.globals.architectures == {
|
|
Architecture.x86_64,
|
|
Architecture.i686,
|
|
Architecture.aarch64,
|
|
Architecture.ppc64le,
|
|
Architecture.s390x,
|
|
Architecture.armv7l,
|
|
Architecture.riscv64,
|
|
}
|
|
elif platform == "windows":
|
|
assert options.globals.architectures == {
|
|
Architecture.x86,
|
|
Architecture.AMD64,
|
|
Architecture.ARM64,
|
|
}
|
|
elif platform == "macos":
|
|
assert options.globals.architectures == {
|
|
Architecture.x86_64,
|
|
Architecture.arm64,
|
|
Architecture.universal2,
|
|
}
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("only", "plat"),
|
|
(
|
|
("cp311-manylinux_x86_64", "linux"),
|
|
("cp310-win_amd64", "windows"),
|
|
("cp310-win32", "windows"),
|
|
("cp311-macosx_x86_64", "macos"),
|
|
),
|
|
)
|
|
def test_only_argument(
|
|
intercepted_build_args: ArgsInterceptor,
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
only: str,
|
|
plat: PlatformName,
|
|
) -> None:
|
|
monkeypatch.setenv("CIBW_BUILD", "unused")
|
|
monkeypatch.setenv("CIBW_SKIP", "unused")
|
|
monkeypatch.setattr(sys, "argv", [*sys.argv, "--only", only])
|
|
|
|
main()
|
|
|
|
options = intercepted_build_args.args[0]
|
|
assert options.globals.build_selector.build_config == only
|
|
assert options.globals.build_selector.skip_config == ""
|
|
assert options.platform == plat
|
|
assert options.globals.architectures == Architecture.all_archs(plat)
|
|
assert EnableGroup.PyPy in options.globals.build_selector.enable
|
|
|
|
|
|
@pytest.mark.parametrize("only", ("cp311-manylxinux_x86_64", "some_linux_thing"))
|
|
def test_only_failed(monkeypatch: pytest.MonkeyPatch, only: str) -> None:
|
|
monkeypatch.setattr(sys, "argv", [*sys.argv, "--only", only])
|
|
|
|
with pytest.raises(SystemExit):
|
|
main()
|
|
|
|
|
|
def test_only_no_platform(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
monkeypatch.setattr(
|
|
sys, "argv", [*sys.argv, "--only", "cp311-manylinux_x86_64", "--platform", "macos"]
|
|
)
|
|
|
|
with pytest.raises(SystemExit):
|
|
main()
|
|
|
|
|
|
def test_only_no_archs(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
monkeypatch.setattr(
|
|
sys, "argv", [*sys.argv, "--only", "cp311-manylinux_x86_64", "--archs", "x86_64"]
|
|
)
|
|
|
|
with pytest.raises(SystemExit):
|
|
main()
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("envvar_name", "envvar_value"),
|
|
(
|
|
("CIBW_BUILD", "cp310-*"),
|
|
("CIBW_SKIP", "cp311-*"),
|
|
("CIBW_ARCHS", "auto32"),
|
|
("CIBW_PLATFORM", "macos"),
|
|
),
|
|
)
|
|
def test_only_overrides_env_vars(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
intercepted_build_args: ArgsInterceptor,
|
|
envvar_name: str,
|
|
envvar_value: str,
|
|
) -> None:
|
|
monkeypatch.setattr(sys, "argv", [*sys.argv, "--only", "cp311-manylinux_x86_64"])
|
|
monkeypatch.setenv(envvar_name, envvar_value)
|
|
|
|
main()
|
|
|
|
options = intercepted_build_args.args[0]
|
|
assert options.globals.build_selector.build_config == "cp311-manylinux_x86_64"
|
|
assert options.globals.build_selector.skip_config == ""
|
|
assert options.platform == "linux"
|
|
assert options.globals.architectures == Architecture.all_archs("linux")
|
|
|
|
|
|
def test_pyodide_on_windows(
|
|
monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
|
|
) -> None:
|
|
monkeypatch.setattr(sys, "platform", "win32")
|
|
monkeypatch.setattr(sys, "argv", [*sys.argv, "--only", "cp314-pyodide_wasm32"])
|
|
|
|
with pytest.raises(SystemExit) as exit:
|
|
main()
|
|
|
|
_, err = capsys.readouterr()
|
|
|
|
assert exit.value.code == 2
|
|
assert "Building for pyodide is not supported on Windows" in err
|
|
|
|
|
|
def test_empty_archs_platform(
|
|
platform: PlatformName, intercepted_build_args: ArgsInterceptor, monkeypatch: pytest.MonkeyPatch
|
|
) -> None:
|
|
monkeypatch.setenv("CIBW_ARCHS", "")
|
|
|
|
main()
|
|
|
|
options = intercepted_build_args.args[0]
|
|
assert options.globals.architectures == Architecture.auto_archs(platform)
|