| # Copyright 2023 The ChromiumOS Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Tests for query.py.""" |
| |
| from pathlib import Path |
| from typing import Dict |
| |
| import pytest |
| |
| from chromite.lib import build_query |
| |
| |
| # fake_build_query_overlays is a fixture, and the value need not always be used |
| # by the tests. |
| # pylint: disable=unused-argument |
| |
| |
| def test_query_overlays(fake_build_query_overlays) -> None: |
| """Test listing all overlays.""" |
| overlays = {x.name: x for x in build_query.Overlay.find_all()} |
| assert overlays["baseboard-fake"].board_name is None |
| assert overlays["baseboard-fake"].is_private is False |
| assert overlays["fake"].board_name == "fake" |
| assert overlays["fake"].is_private is False |
| assert overlays["baseboard-fake-private"].board_name is None |
| assert overlays["baseboard-fake-private"].is_private is True |
| assert overlays["fake-private"].board_name == "fake" |
| assert overlays["fake-private"].is_private is True |
| |
| |
| def test_query_profiles(fake_build_query_overlays) -> None: |
| """Test listing all profiles.""" |
| profiles: Dict[str, build_query.Profile] = { |
| str(x): x for x in build_query.Profile.find_all() |
| } |
| assert profiles["baseboard-fake:base"].overlay.name == "baseboard-fake" |
| assert profiles["baseboard-fake:base"].name == "base" |
| assert profiles["baseboard-fake:base"].parents == [] |
| assert profiles["fake:base"].overlay.name == "fake" |
| assert profiles["fake:base"].name == "base" |
| assert profiles["fake:base"].parents == [profiles["baseboard-fake:base"]] |
| assert ( |
| profiles["baseboard-fake-private:base"].overlay.name |
| == "baseboard-fake-private" |
| ) |
| assert profiles["baseboard-fake-private:base"].name == "base" |
| assert profiles["baseboard-fake-private:base"].parents == [ |
| profiles["baseboard-fake:base"] |
| ] |
| assert profiles["fake-private:alt-profile"].overlay.name == "fake-private" |
| assert profiles["fake-private:alt-profile"].name == "alt-profile" |
| assert profiles["fake-private:alt-profile"].parents == [ |
| profiles["fake-private:base"] |
| ] |
| assert profiles["fake-private:base"].overlay.name == "fake-private" |
| assert profiles["fake-private:base"].name == "base" |
| assert profiles["fake-private:base"].parents == [ |
| profiles["baseboard-fake-private:base"], |
| profiles["fake:base"], |
| ] |
| |
| |
| def test_query_boards(fake_build_query_overlays) -> None: |
| """Test listing all boards.""" |
| board = ( |
| build_query.Query(build_query.Board) |
| .filter(lambda x: x.name == "fake") |
| .one() |
| ) |
| assert board.arch == "amd64" |
| overlay = [ |
| x for x in fake_build_query_overlays if x.name == "fake-private" |
| ][0] |
| assert board.top_level_overlay.path == overlay.path |
| assert ( |
| board.top_level_profile.path == overlay.profiles[Path("base")].full_path |
| ) |
| |
| |
| def test_query_ebuilds(fake_build_query_overlays) -> None: |
| """Test listing all ebuilds.""" |
| ebuilds = list(build_query.Ebuild.find_all()) |
| found_packages = {str(ebuild) for ebuild in ebuilds} |
| assert found_packages == { |
| "chromeos-base/chromeos-bsp-fake-0.0.1-r256::fake", |
| "chromeos-base/chromeos-bsp-fake-9999::fake", |
| "chromeos-base/chromeos-bsp-fake-private-0.0.1::fake-private", |
| "chromeos-base/chromeos-bsp-fake-private-9999::fake-private", |
| } |
| assert all(x.eapi == 7 for x in ebuilds) |
| assert all(x.eclasses == ["cros-workon", "chromeos-bsp"] for x in ebuilds) |
| assert all(x.iuse == {"another", "internal", "static"} for x in ebuilds) |
| assert all(x.iuse_default == {"static"} for x in ebuilds) |
| |
| |
| @pytest.mark.parametrize( |
| ["board_name", "is_variant"], |
| [ |
| ("fake", False), |
| ("faux", True), |
| ], |
| ) |
| def test_is_variant(fake_build_query_overlays, board_name, is_variant) -> None: |
| """Test the is_variant property of boards.""" |
| board = ( |
| build_query.Query(build_query.Board) |
| .filter(lambda x: x.name == board_name) |
| .one() |
| ) |
| assert board.is_variant == is_variant |
| |
| |
| @pytest.mark.parametrize( |
| ["cpvr", "arch", "expected_stability"], |
| [ |
| ( |
| "chromeos-base/chromeos-bsp-fake-0.0.1-r256", |
| "amd64", |
| build_query.Stability.STABLE, |
| ), |
| ( |
| "chromeos-base/chromeos-bsp-fake-9999", |
| "amd64", |
| build_query.Stability.UNSTABLE, |
| ), |
| ( |
| "chromeos-base/chromeos-bsp-fake-private-0.0.1", |
| "amd64", |
| build_query.Stability.UNSTABLE, |
| ), |
| ( |
| "chromeos-base/chromeos-bsp-fake-private-0.0.1", |
| "arm", |
| build_query.Stability.BAD, |
| ), |
| ( |
| "chromeos-base/chromeos-bsp-fake-private-9999", |
| "arm", |
| build_query.Stability.UNSTABLE, |
| ), |
| ( |
| "chromeos-base/chromeos-bsp-fake-private-9999", |
| "amd64", |
| build_query.Stability.STABLE, |
| ), |
| ], |
| ) |
| def test_ebuild_stability( |
| fake_build_query_overlays, cpvr, arch, expected_stability |
| ) -> None: |
| """Test the ebuild stability evaluator.""" |
| ebuild = ( |
| build_query.Query(build_query.Ebuild) |
| .filter(lambda ebuild: ebuild.package_info.cpvr == cpvr) |
| .one() |
| ) |
| assert ebuild.get_stability(arch) == expected_stability |
| |
| |
| def test_make_conf_vars(fake_build_query_overlays) -> None: |
| """Test reading make.conf variables from an overlay.""" |
| overlay = ( |
| build_query.Query(build_query.Overlay) |
| .filter(lambda overlay: overlay.name == "fake-private") |
| .one() |
| ) |
| assert overlay.make_conf_vars == { |
| "CHOST": "x86_64-pc-linux-gnu", |
| "USE": "internal", |
| } |
| |
| |
| def test_overlay_parents(fake_build_query_overlays) -> None: |
| overlays = {x.name: x for x in build_query.Overlay.find_all()} |
| assert list(overlays["baseboard-fake-private"].parents) == [ |
| overlays["portage-stable"], |
| overlays["chromiumos"], |
| overlays["eclass-overlay"], |
| overlays["baseboard-fake"], |
| ] |
| |
| |
| def test_use_flags(fake_build_query_overlays) -> None: |
| """Test getting the USE flags on a board.""" |
| board = ( |
| build_query.Query(build_query.Board) |
| .filter(lambda x: x.name == "fake") |
| .one() |
| ) |
| assert board.use_flags == { |
| "amd64", |
| "board_use_fake", |
| "not_masked", |
| "some", |
| "fake", |
| "internal", |
| "some_var_board_val", |
| "some_var_private_val", |
| "another_var_one_val", |
| "another_var_another_val", |
| "kernel-6_1", |
| "bootimage", |
| } |
| |
| |
| def test_use_flags_set(fake_build_query_overlays) -> None: |
| """Test querying the flags set by a profile.""" |
| overlay = ( |
| build_query.Query(build_query.Overlay) |
| .filter(lambda overlay: overlay.name == "baseboard-fake") |
| .one() |
| ) |
| profile = overlay.profiles[0] |
| assert profile.use_flags_set == { |
| "amd64", |
| "some", |
| "another", |
| "masked", |
| "not_masked", |
| "some_var_baseboard_val", |
| "bootimage", |
| } |
| |
| |
| def test_use_flags_unset(fake_build_query_overlays) -> None: |
| """Test querying the flags unset by a profile.""" |
| overlay = ( |
| build_query.Query(build_query.Overlay) |
| .filter(lambda overlay: overlay.name == "fake") |
| .one() |
| ) |
| profile = overlay.profiles[0] |
| assert profile.use_flags_unset == { |
| "another", |
| "baseboard_fake_private", |
| "some_var_*", |
| } |
| |
| |
| def test_masked_use_flags(fake_build_query_overlays) -> None: |
| """Test getting the masked_use_flags on a profile.""" |
| board = ( |
| build_query.Query(build_query.Board) |
| .filter(lambda x: x.name == "fake") |
| .one() |
| ) |
| assert board.top_level_profile.masked_use_flags == {"masked"} |
| |
| |
| def test_board_get(fake_build_query_overlays) -> None: |
| """Test Board.get() convenience classmethod.""" |
| board = build_query.Board.get("fake") |
| assert board.name == "fake" |
| |
| |
| def test_board_get_fail(fake_build_query_overlays) -> None: |
| """Test Board.get() convenience classmethod on a bad board name.""" |
| with pytest.raises(ValueError): |
| build_query.Board.get("notfake") |
| |
| |
| def test_board_get_profile(fake_build_query_overlays) -> None: |
| """Test Board.get() with a profile.""" |
| board = build_query.Board.get("fake", profile="alt-profile") |
| assert board.name == "fake" |
| assert "alt_profile" in board.use_flags |
| |
| |
| def test_query_one(fake_build_query_overlays) -> None: |
| """Test .one() on a query which yields one result.""" |
| board = ( |
| build_query.Query(build_query.Board) |
| .filter(lambda x: x.name == "fake") |
| .one() |
| ) |
| assert board.name == "fake" |
| |
| |
| def test_query_one_fail_zero(fake_build_query_overlays) -> None: |
| """Test .one() on a query which yields zero results fails.""" |
| with pytest.raises(StopIteration): |
| build_query.Query(build_query.Board).filter( |
| lambda x: x.name == "notfake" |
| ).one() |
| |
| |
| def test_query_one_fail_multiple(fake_build_query_overlays) -> None: |
| """Test .one() on a query which yields multiple results fails.""" |
| with pytest.raises(ValueError): |
| build_query.Query(build_query.Ebuild).one() |
| |
| |
| def test_query_one_or_none(fake_build_query_overlays) -> None: |
| """Test .one_or_none() on a query which yields no results returns None.""" |
| board = ( |
| build_query.Query(build_query.Board) |
| .filter(lambda x: x.name == "notfake") |
| .one_or_none() |
| ) |
| assert not board |
| |
| |
| def test_query_all(fake_build_query_overlays) -> None: |
| """Test .all() on a query.""" |
| boards = build_query.Query(build_query.Board).all() |
| assert [str(x) for x in boards] == ["fake", "faux", "foo"] |
| |
| |
| def test_resolve_incremental_variable(fake_build_query_overlays) -> None: |
| """Test correctness Profile.resolve_incremental_variable.""" |
| board = ( |
| build_query.Query(build_query.Board) |
| .filter(lambda x: x.name == "fake") |
| .one() |
| ) |
| assert board.top_level_profile.resolve_var_incremental("SOME_VAR") == { |
| "board_val", |
| "private_val", |
| } |