pax_global_header00006660000000000000000000000064146105011440014506gustar00rootroot0000000000000052 comment=dc57ace00292e7e364e5d9abb5a5bb621bbd4228 pkg-testing-tools-0.2.5/000077500000000000000000000000001461050114400151045ustar00rootroot00000000000000pkg-testing-tools-0.2.5/.github/000077500000000000000000000000001461050114400164445ustar00rootroot00000000000000pkg-testing-tools-0.2.5/.github/dependabot.yml000066400000000000000000000015021461050114400212720ustar00rootroot00000000000000# To get started with Dependabot version updates, you'll need to specify which # package ecosystems to update and where the package manifests are located. # Please see the documentation for all configuration options: # https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates version: 2 updates: - package-ecosystem: "pip" # See documentation for possible values directory: "/" # Location of package manifests schedule: interval: "weekly" - package-ecosystem: "github-actions" # See documentation for possible values directory: "/" # Location of package manifests schedule: interval: "weekly" - package-ecosystem: "docker" # See documentation for possible values directory: "/" # Location of package manifests schedule: interval: "weekly" pkg-testing-tools-0.2.5/.github/workflows/000077500000000000000000000000001461050114400205015ustar00rootroot00000000000000pkg-testing-tools-0.2.5/.github/workflows/pre-commit.yml000066400000000000000000000003511461050114400232770ustar00rootroot00000000000000name: pre-commit on: pull_request: push: branches: [master] jobs: pre-commit: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: actions/setup-python@v3 - uses: pre-commit/action@v3.0.1 pkg-testing-tools-0.2.5/.github/workflows/python-package.yml000066400000000000000000000026071461050114400241430ustar00rootroot00000000000000# This workflow will install Python dependencies, run tests and lint with a variety of Python versions # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python name: Python package on: push: branches: [ "master" ] pull_request: branches: [ "master" ] jobs: build: runs-on: ubuntu-latest strategy: fail-fast: false matrix: python-version: ["3.10", "3.11", "3.12"] steps: - uses: actions/checkout@v3 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v3 with: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python -m pip install --upgrade pip python -m pip install poetry poetry install --with test --with dev # python -m pip install flake8 pytest # if [ -f requirements.txt ]; then pip install -r requirements.txt; fi # - name: Lint with flake8 # run: | # # stop the build if there are Python syntax errors or undefined names # flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics # # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide # flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics - name: Test with pytest run: | poetry run pytest pkg-testing-tools-0.2.5/.github/workflows/test-self.yml000066400000000000000000000027511461050114400231370ustar00rootroot00000000000000name: test self on: push: branches: [ "master" ] pull_request: branches: [ "master" ] jobs: build: runs-on: ubuntu-latest container: apnpucky/gentoo-apn:latest strategy: fail-fast: false matrix: args: [ '-C -p "=pkg-testing-tools-9999" --pretend', '-C -p "=pkg-testing-tools-9999"', '-f sci/sci-physics/collier/collier-*.ebuild --append-emerge "--autounmask=y --autounmask-write --autounmask-continue --autounmask-use=y" --max-use-combinations 1', '-p =pkg-testing-tools-9999', # https://github.com/APN-Pucky/pkg-testing-tools/issues/28 "--test-feature-scope never --append-required-use '!pgo' --max-use-combinations 6 -p www-client/firefox --pretend", # https://bugs.gentoo.org/918693 an ebuild without -r0 but any other -rN "-p '~sci-physics/lhapdf-6.3.0' --max-use-combinations 0", ] steps: - run: emerge --sync - run: git clone --depth 1 https://github.com/gentoo/sci.git - run: echo 'app-portage/pkg-testing-tools **' > /etc/portage/package.accept_keywords/pkg-testing-tools - run: echo "EGIT_COMMIT=${{ github.sha }}" >> /var/db/repos/gentoo/app-portage/pkg-testing-tools/pkg-testing-tools-9999.ebuild - run: echo "EGIT_BRANCH=${GITHUB_HEAD_REF:-${GITHUB_REF#refs/heads/}}" >> /var/db/repos/gentoo/app-portage/pkg-testing-tools/pkg-testing-tools-9999.ebuild - run: emerge =pkg-testing-tools-9999 - run: pkg-testing-tool ${{ matrix.args }} pkg-testing-tools-0.2.5/.gitignore000066400000000000000000000000211461050114400170650ustar00rootroot00000000000000__pycache__ .pyc pkg-testing-tools-0.2.5/.pre-commit-config.yaml000066400000000000000000000007761461050114400213770ustar00rootroot00000000000000# See https://pre-commit.com for more information # See https://pre-commit.com/hooks.html for more hooks repos: - repo: https://github.com/pre-commit/pre-commit-hooks rev: v4.5.0 hooks: - id: check-toml - id: check-yaml - id: end-of-file-fixer - id: mixed-line-ending - repo: https://github.com/psf/black rev: 23.11.0 hooks: - id: black - repo: https://github.com/PyCQA/isort rev: 5.13.0 hooks: - id: isort args: ["--profile", "black"] pkg-testing-tools-0.2.5/CHANGELOG.md000066400000000000000000000034001461050114400167120ustar00rootroot00000000000000# Changelog All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ## [Unreleased] ### Added - --pretend flag: only show the commands that would be executed - --test-feature-scope=force also sets EBUILD_FORCE_TEST=1 ### Changed - `--max-use-combinations 1` is now one random use flag set instead of the default. The default is still availbale with `--max-use-combinations 0` ## [0.2.4] - 2024-03-16 ### Fixed - temporary repositories are only injected once - passing no -f should not crash ### Changed - `--file` also appends `::{repo}` to the package atom ## [0.2.3] - 2024-03-16 ### Added - -C/--unmerge flag: unmerge package before each test - -f/--file flag: read from ebuild file and temporary inject its hosting repository ## [0.2.2] - 2024-02-17 ### Added - prefix argument ### Fixed - swap of job definition order and temporary unmask/keyword files ## [0.2.1] - 2023-12-10 ### Added - (doc-)tests - CI pipeline ### Changed - Removed python/ruby targets from default ignore list - Format/Lint code with black ## [0.2.0] - 2023-11-28 ### Fixed - cpv matching for '~category/package-version' works now [unreleased]: https://github.com/APN-Pucky/pkg-testing-tools/compare/0.2.4...HEAD [0.2.4]: https://github.com/APN-Pucky/pkg-testing-tools/compare/0.2.3...0.2.4 [0.2.3]: https://github.com/APN-Pucky/pkg-testing-tools/compare/0.2.2...0.2.3 [0.2.2]: https://github.com/APN-Pucky/pkg-testing-tools/compare/0.2.1...0.2.2 [0.2.1]: https://github.com/APN-Pucky/pkg-testing-tools/compare/0.2.0...0.2.1 [0.2.0]: https://github.com/APN-Pucky/pkg-testing-tools/compare/0.1.1...0.2.0 pkg-testing-tools-0.2.5/LICENSE.md000066400000000000000000000027461461050114400165210ustar00rootroot00000000000000BSD 3-Clause License Copyright (c) 2023, Alexander Puck Neuwirth Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. pkg-testing-tools-0.2.5/README.md000066400000000000000000000056441461050114400163740ustar00rootroot00000000000000# pkg-testing-tool Package testing tool for arch stabilizations, regular bumps of packages and testing of masked packages. ## Motivation Currently there's hardy any tool that beside arch testing can also do regular testing of packages specified by atoms. The only real alternative is `tatt`, which however is not really suitable for unattended testing, as it lacks some proper machine readable output formats and have limited quality of life features. I wanted a tool that can be both unattended and flexible enough to allow end-user to exclude some USE flags from scope, like systemd or libressl, if neither of those are currently used on the system, with configurable switch to control how many combinations of USE flags one want to test. With optional machine-readable JSON format of reports, this tool can be integrated into CI machintery with limited effort. ## Scope The tool is limited to single runtime environment, lacks any network features like remote parallel testing and bugzilla integration -- all of those are supposed to be supported by another tool, while leaving pkg-testing-tool as a single tool for single job. ## Prerequisites One need to have `env` and `package.*` under /etc/portage as directories in order for the tool to work. ``` install -m 0750 -o portage -g portage -d /etc/portage/env /etc/portage/package.{accept_keywords,env,unmask,use} ``` ## How to use It's highly recommend to use `pkg-testing-tool` along with `binpkgs`, `ccache` and parallel `emerge` jobs, especially when using a clean environment like chroot or virtual machine with shared binary packages. Unless `make.conf` already have all of those enabled, one can use something like the code below to switch those features on, although it should be tweaked depending on one's capacity: ``` export PKGDIR="/var/cache/binpkgs" export CCACHE_DIR="/var/cache/ccache" export CCACHE_SIZE="4G" export MAKEOPTS="--quiet -j$(nproc) -l$(nproc)" install -m 0750 -o portage -g portage -d "${PKGDIR}" install -m 0750 -o portage -g portage -d "${CCACHE_DIR}" ``` Rather paranoid run of `git` without libressl, with json report saved to file, with FEATURES=test enabled on every run ``` pkg-testing-tool \ --binpkg --ccache \ --package-atom '=dev-vcs/git-2.23.0-r1' \ --append-required-use '!libressl' \ --report /tmp/test-git-2.23.0-r1.json \ --test-feature-scope always ``` Local to package atom flags are sometimes not desired, especially when one flag on package we test requires the same flag on it's dependencies. For this, one should switch to global flags, that work as if someone set the `$USE` environmental variable with them. ``` pkg-testing-tool --use-flags-scope global --package-atom '=dev-libs/boost-1.71.0' ``` ## Poetry development As root: ``` $ poetry config virtualenvs.options.system-site-packages true $ poetry install $ poetry shell $ pkg-testing-tool --help ``` Then, changes to pkg-testing-tools source code become immediately active. pkg-testing-tools-0.2.5/pkg_testing_tools/000077500000000000000000000000001461050114400206425ustar00rootroot00000000000000pkg-testing-tools-0.2.5/pkg_testing_tools/__init__.py000066400000000000000000000001331461050114400227500ustar00rootroot00000000000000""" pkg_testing_tools is a package for testing Gentoo packages. """ from .main import main pkg-testing-tools-0.2.5/pkg_testing_tools/job.py000066400000000000000000000100221461050114400217610ustar00rootroot00000000000000import argparse import datetime import json import os import shlex import subprocess import sys from contextlib import ExitStack from tempfile import NamedTemporaryFile import portage from .log import edebug, edie, eerror, einfo from .use import atom_to_cpv, get_package_flags, get_use_combinations def get_package_metadata(atom): # This handles revisions properly, but not live ebuilds: https://bugs.gentoo.org/918693 https://github.com/APN-Pucky/pkg-testing-tools/issues/10 cpv = atom_to_cpv(atom) # cpv is None on missing/masked packages if cpv: edebug(f"cpv through match(): {cpv}") else: edebug(f"could not find unmasked package {atom}, assuming it is available") # This handles live ebuilds properly, but not revisions: https://bugs.gentoo.org/918693 https://github.com/APN-Pucky/pkg-testing-tools/issues/10 cpv = portage.dep.dep_getcpv(atom) edebug(f"cpv through dep_getcpv(): {cpv}") cp, version, revision = portage.versions.pkgsplit(cpv) iuse, ruse = get_package_flags(cpv) phases = portage.portdb.aux_get(cpv, ["DEFINED_PHASES"])[0].split() return { "atom": atom, "cp": cp, "cpv": cpv, "version": version, "revision": revision, "has_tests": ("test" in phases), "iuse": iuse, "ruse": ruse, } def define_jobs(atom, args): jobs = [] package_metadata = get_package_metadata(atom) common = { "cpv": atom, "cp": package_metadata["cp"], "extra_env_files": ( " ".join(args.extra_env_file) if args.extra_env_file else [] ), } if args.debug: edebug("common: {}".format(common)) edebug("package_metadata: {}".format(package_metadata)) if args.append_required_use: package_metadata["ruse"].append(args.append_required_use) if package_metadata["iuse"] and args.max_use_combinations > 0: use_combinations = get_use_combinations( package_metadata["iuse"], package_metadata["ruse"], args.max_use_combinations, ) edebug("Use flags found for {}: {}".format(atom, use_combinations)) else: edebug("No use flags found for {}".format(atom)) use_combinations = None if use_combinations: if ( package_metadata["has_tests"] and args.test_feature_scope == "always" ) or args.test_feature_scope == "force": test_feature_toggle = True else: test_feature_toggle = False for flags_set in use_combinations: job = {} job.update(common) job.update( { "test_feature_toggle": test_feature_toggle, "use_flags": flags_set, "use_flags_scope": args.use_flags_scope, } ) jobs.append(job) if package_metadata["has_tests"] and args.test_feature_scope == "once": job = {} job.update(common) job.update( { "test_feature_toggle": True, "use_flags": [], "use_flags_scope": args.use_flags_scope, } ) jobs.append(job) else: if not package_metadata["has_tests"] or args.test_feature_scope == "never": job = {} job.update(common) job.update( { # This is effectively false "test_feature_toggle": args.test_feature_scope == "force", "use_flags": [], "use_flags_scope": args.use_flags_scope, } ) jobs.append(job) else: job = {} job.update(common) job.update({"test_feature_toggle": False, "use_flags": []}) jobs.append(job) job = {} job.update(common) job.update({"test_feature_toggle": True, "use_flags": []}) jobs.append(job) return jobs pkg-testing-tools-0.2.5/pkg_testing_tools/log.py000066400000000000000000000003531461050114400217760ustar00rootroot00000000000000import sys def eerror(msg): print("[ERROR] >>> {}".format(msg)) def einfo(msg): print("[INFO] >>> {}".format(msg)) def edebug(msg): print("[DEBUG] >>> {}".format(msg)) def edie(msg): eerror(msg) sys.exit(1) pkg-testing-tools-0.2.5/pkg_testing_tools/main.py000077500000000000000000000223651461050114400221530ustar00rootroot00000000000000#!/usr/bin/env python3 import argparse import json import os import subprocess import sys from contextlib import ExitStack from .job import define_jobs from .log import edebug, edie, eerror, einfo from .test import run_testing from .tmp import get_etc_portage_tmp_file def process_args(sysargs): parser = argparse.ArgumentParser() # required = parser.add_argument_group("Required") group = parser.add_mutually_exclusive_group(required=True) group.add_argument( "-p", "--package-atom", action="append", default=[], help="Valid Portage package atom, like '=app-category/foo-1.2.3'. Can be specified multiple times to unmask/keyword all of them and test them one by one.", ) group.add_argument( "-f", "--file", action="append", default=[], help="Portage ebuild file like 'foo-1.2.3.ebuild'. Must reside in a repository.", ) optional = parser.add_argument_group("Optional") optional.add_argument( "-C", "--unmerge", action="store_true", required=False, help="Explicit unmerge before each test install.", ) optional.add_argument( "--ask", action="store_true", required=False, help="Ask for confirmation before executing actual tests.", ) optional.add_argument( "--pretend", "--dry-run", action="store_true", required=False, help="Do not execute the tests.", ) optional.add_argument( "--binpkg", action="store_true", required=False, help="Append --usepkg to emerge command and add buildpkg to FEATURES.", ) optional.add_argument( "--ccache", action="store_true", required=False, help="Add ccache to FEATURES." ) optional.add_argument( "--append-required-use", action="store", type=str, required=False, help="Append REQUIRED_USE entries, useful for blacklisting flags, like '!systemd !libressl' on systems that runs neither. The more complex REQUIRED_USE, the longer it take to get USE flags combinations.", ) optional.add_argument( "--max-use-combinations", action="store", type=int, required=False, default=16, help="Generate up to N combinations of USE flags, the combinations are random out of those which pass check for REQUIRED_USE. Default: 16.", ) optional.add_argument( "--use-flags-scope", action="store", type=str, required=False, default="local", choices=["local", "global"], help="Local sets USE flags for package specified by atom, global sets flags for */*.", ) optional.add_argument( "--test-feature-scope", action="store", type=str, required=False, default="once", choices=["once", "always", "force", "never"], help="Enables FEATURES='test' once, for default use flags, always, for every run or never. force also sets EBUILD_FORCE_TEST=1. Default: 'once'.", ) optional.add_argument( "--report", action="store", type=str, required=False, help="Save report in JSON format under specified path.", ) optional.add_argument( "--prefix", action="store", default="", type=str, required=False, help="Set the prefix for the portage configuration files. Default: ''.", ) optional.add_argument( "--debug", action="store_true", required=False, help="Enable debug output, like printing emerge command line.", default=False, ) optional.add_argument( "--extra-env-file", action="append", type=str, required=False, help="Extra /etc/portage/env/ file name, to be used while testing packages. Can be passed multile times.", ) optional.add_argument( "--append-emerge", action="store", type=str, required=False, help="Append flags or parameters to the actual emerge call.", ) args, extra_args = parser.parse_known_args(sysargs) if extra_args: if extra_args[0] != "--": parser.error( "Custom arguments that are meant to be passed to pkg-testing-tool are to be palced after '--'." ) extra_args.remove("--") if len(sysargs) == 0: parser.print_help(sys.stderr) sys.exit(1) if args.debug: edebug("{}".format(args)) return args, extra_args def yes_no(question): reply = input(question).lower() if reply == "y": return True return False def pkg_testing_tool(args, extra_args): results = [] # Unconditionally unmask and keyword packages selected by atom. # No much of a reason to check what arch we're running or if package is masked in first place. with ExitStack() as stack: tmp_files = {} for directory in ["package.accept_keywords", "package.unmask", "repos.conf"]: tmp_files[directory] = stack.enter_context( get_etc_portage_tmp_file(directory, args.prefix) ) repos = [] for ebuild in args.file: # test that file ends in ".ebuild" if not ebuild.endswith(".ebuild"): edie("File {} does not end with '.ebuild'.".format(ebuild)) repo = os.path.dirname( os.path.dirname(os.path.dirname(os.path.abspath(ebuild))) ) # read repo_name from repo profiles/repo_name repo_name = "zzzpkgtestingtool" with open(os.path.join(repo, "profiles/repo_name"), "r") as f: repo_name = f.read().strip() # only add repo once if repo_name not in repos: repos += [repo_name] tmp_files["repos.conf"].write( f"[{repo_name}]\npriority=9999\nlocation = {repo}\n" ) # ebuild to category/package-X.Y.Z # get parent directory name of ebuild category = os.path.basename( os.path.dirname(os.path.dirname(os.path.abspath(ebuild))) ) package_version = os.path.basename(ebuild).replace(".ebuild", "") args.package_atom += [ "=" + category + "/" + package_version + "::" + repo_name ] # make sure we have the right manifest already if args.debug: edebug(f"ebuild {ebuild} manifest") subprocess.run(["ebuild", ebuild, "manifest"]) jobs = [] for atom in args.package_atom: # Unmask and keyword all the packages prior to testing them. tmp_files["package.accept_keywords"].write("{atom} **\n".format(atom=atom)) tmp_files["package.unmask"].write("{atom}\n".format(atom=atom)) for handler in tmp_files: tmp_files[handler].flush() for atom in args.package_atom: for new_job in define_jobs(atom, args): jobs.append(new_job) padding = max(len(i["cpv"]) for i in jobs) + 3 einfo("Following testing jobs will be executed:") for job in jobs: print( "{cpv:<{padding}} USE: {use_flags}{test_feature}".format( cpv=job["cpv"], use_flags=( "" if not job["use_flags"] else " ".join(job["use_flags"]) ), test_feature=( ", FEATURES: test" if job["test_feature_toggle"] else "" ), padding=padding, ) ) if args.ask: if not yes_no(">>> Do you want to continue? [y/N]: "): sys.exit(1) i = 0 for job in jobs: i += 1 einfo( "Running ({i} of {max_i}) {cpv} with USE: {use_flags}{test_feature}".format( i=i, max_i=len(jobs), cpv=job["cpv"], use_flags=( "" if not job["use_flags"] else " ".join(job["use_flags"]) ), test_feature=( ", FEATURES: test" if job["test_feature_toggle"] else "" ), ) ) results.append(run_testing(job, args)) failures = [] for item in results: if item["exit_code"] != 0: failures.append(item) if args.report: with open(args.report, "w") as report: report.write(json.dumps(results, indent=4, sort_keys=True)) if len(failures) > 0: eerror("Not all runs were successful.") for entry in failures: print( "atom: {atom}, USE flags: '{use_flags}'".format( atom=entry["atom"], use_flags=entry["use_flags"] ) ) sys.exit(1) else: einfo("All good.") def run(sysargs): args, extra_args = process_args(sysargs) pkg_testing_tool(args, extra_args) def main(): run(sys.argv[1:]) if __name__ == "__main__": main() pkg-testing-tools-0.2.5/pkg_testing_tools/test.py000066400000000000000000000070101461050114400221710ustar00rootroot00000000000000import argparse import datetime import json import os import shlex import subprocess import sys from contextlib import ExitStack import portage from .log import edie, eerror from .tmp import get_etc_portage_tmp_file def run_testing(job, args): global_features = [] time_started = datetime.datetime.now().replace(microsecond=0).isoformat() emerge_cmdline = [ "emerge", "--verbose", "y", "--usepkg-exclude", job["cp"], "--deep", "--backtrack", "300", ] unmerge_cmdline = [ "emerge", "--rage-clean", job["cp"], ] if args.append_emerge: emerge_cmdline += shlex.split(args.append_emerge) if args.binpkg: emerge_cmdline.append("--usepkg") global_features.append("buildpkg") if args.ccache: if not portage.settings.get("CCACHE_DIR") or not portage.settings.get( "CCACHE_SIZE" ): edie("The CCACHE_DIR and/or CCACHE_SIZE is not set!") global_features.append("ccache") emerge_cmdline.append(job["cpv"]) with ExitStack() as stack: tmp_files = {} for directory in ["env", "package.env", "package.use"]: tmp_files[directory] = stack.enter_context( get_etc_portage_tmp_file(directory, args.prefix) ) tested_cpv_features = ["qa-unresolved-soname-deps", "multilib-strict"] if job["test_feature_toggle"]: tested_cpv_features.append("test") if tested_cpv_features: tmp_files["env"].write( 'FEATURES="{}"\n'.format(" ".join(tested_cpv_features)) ) env_files = [os.path.basename(tmp_files["env"].name)] if job["extra_env_files"]: env_files.append(job["extra_env_files"]) tmp_files["package.env"].write( "{cp} {env_files}\n".format(cp=job["cp"], env_files=" ".join(env_files)) ) if job["use_flags"]: tmp_files["package.use"].write( "{prefix} {flags}\n".format( prefix=( "*/*" if job["use_flags_scope"] == "global" else job["cpv"] ), flags=" ".join(job["use_flags"]), ) ) for handler in tmp_files: tmp_files[handler].flush() env = os.environ.copy() if args.unmerge and not args.pretend: subprocess.run(unmerge_cmdline, env=env) if args.test_feature_scope == "force": env["EBUILD_FORCE_TEST"] = "1" if global_features: if "FEATURES" in env: env["FEATURES"] = "{} {}".format( env["FEATURES"], " ".join(global_features) ) else: env["FEATURES"] = " ".join(global_features) emerge_result = None if not args.pretend: emerge_result = subprocess.run(emerge_cmdline, env=env) print("") return { "use_flags": " ".join(job["use_flags"]), "exit_code": 0 if emerge_result is None else emerge_result.returncode, "features": portage.settings.get("FEATURES"), "emerge_default_opts": portage.settings.get("EMERGE_DEFAULT_OPTS"), "emerge_cmdline": " ".join(emerge_cmdline), "test_feature_toggle": job["test_feature_toggle"], "atom": job["cpv"], "time": { "started": time_started, "finished": datetime.datetime.now().replace(microsecond=0).isoformat(), }, } pkg-testing-tools-0.2.5/pkg_testing_tools/tmp.py000066400000000000000000000011331461050114400220120ustar00rootroot00000000000000import os from tempfile import NamedTemporaryFile from .log import edebug, edie, eerror, einfo def get_etc_portage_tmp_file(directory_name, prefix): target_location = os.path.join(prefix + "/etc/portage", directory_name) if not os.path.isdir(target_location): edie( "The location {} needs to exist and be a directory".format(target_location) ) handler = NamedTemporaryFile( mode="w", prefix="zzz_pkg_testing_tool_", dir=target_location ) umask = os.umask(0) os.umask(umask) os.chmod(handler.name, 0o644 & ~umask) return handler pkg-testing-tools-0.2.5/pkg_testing_tools/use.py000066400000000000000000000124601461050114400220130ustar00rootroot00000000000000#!/usr/bin/env python3 import random import portage from pkg_testing_tools.log import edebug def iuse_match_always_true(flag): """ Dummy function to pass to portage.dep.check_required_use(). """ return True def strip_use_flags(flags): """ Remove the leading + or - from use flags. :param flags: list of use flags :return: list of use flags without the leading + or - >>> strip_use_flags(["-flag1", "+flag2", "flag3"]) ['flag1', 'flag2', 'flag3'] """ stripped_flags = [] for flag in flags: if flag[0] in ["+", "-"]: flag = flag[1:] stripped_flags.append(flag) return stripped_flags def filter_out_use_flags(flags): """ Remove use flags that we don't want to test. :param flags: list of use flags :return: list of use flags without the ones we don't want to test >>> filter_out_use_flags(["flag1", "flag2", "debug"]) ['flag1', 'flag2'] """ new_flags = [] ignore_flags_with_prefix = ( "elibc_", "eglibc_", "video_cards_", "linguas_", "l10n_", "kernel_", "abi_", # "python_target_", # "python_targets_", # "ruby_targets_", "cpu_flags_", ) ignore_flags = set(["debug", "doc", "test", "selinux", "split-usr", "pic"]) # some flags that *most* likely we shouldn't shuffle and test. for flag in flags: if not flag.startswith(ignore_flags_with_prefix) and flag not in ignore_flags: new_flags.append(flag) return new_flags def atom_to_cpv(atom): """ Get the cpv for an atom. """ matched = portage.db[portage.root]["porttree"].dbapi.match(atom) if len(matched) == 0: return None return matched[0] def get_package_flags(cpv): """ Get the use flags and required use flags for a package. """ flags = portage.db[portage.root]["porttree"].dbapi.aux_get( cpv, ["IUSE", "REQUIRED_USE"] ) use_flags = strip_use_flags(flags[0].split()) use_flags = filter_out_use_flags(use_flags) use_flags = sorted(use_flags) ruse_flags = flags[1].split() return [use_flags, ruse_flags] def get_use_flags_toggles(index, iuse): """ Toggle use flags based on the index. :param index: index of the use flag combination :param iuse: list of use flags :return: list of use flags with the toggled flags >>> get_use_flags_toggles(0, ["flag1", "flag2", "flag3"]) ['-flag1', '-flag2', '-flag3'] >>> get_use_flags_toggles(1, ["flag1", "flag2", "flag3"]) ['flag1', '-flag2', '-flag3'] >>> get_use_flags_toggles(2, ["flag1", "flag2", "flag3"]) ['-flag1', 'flag2', '-flag3'] >>> get_use_flags_toggles(3, ["flag1", "flag2", "flag3"]) ['flag1', 'flag2', '-flag3'] >>> get_use_flags_toggles(4, ["flag1", "flag2", "flag3"]) ['-flag1', '-flag2', 'flag3'] >>> get_use_flags_toggles(7, ["flag1", "flag2", "flag3"]) ['flag1', 'flag2', 'flag3'] """ on_off_switches = [] for i in range(len(iuse)): if (2**i) & index: on_off_switches.append("") else: on_off_switches.append("-") flags = list("".join(flag) for flag in list(zip(on_off_switches, iuse))) return flags def get_use_combinations(iuse, ruse, max_use_combinations): """ Iterate through all possible use flag combinations and return the ones that :param iuse: list of use flags :param ruse: list of required use flags :param max_use_combinations: maximum number of use flag combinations to return :return: list of valid use flag combinations >>> get_use_combinations(["flag1", "flag2", "flag3"], ["flag1"], 999) [['flag1', '-flag2', '-flag3'], ['flag1', 'flag2', '-flag3'], ['flag1', '-flag2', 'flag3'], ['flag1', 'flag2', 'flag3']] >>> get_use_combinations(["flag1", "flag2", "flag3"], ["-flag1"], 999) [['-flag1', '-flag2', '-flag3'], ['-flag1', 'flag2', '-flag3'], ['-flag1', '-flag2', 'flag3'], ['-flag1', 'flag2', 'flag3']] >>> get_use_combinations(["flag1", "flag2", "flag3"], ["!flag1"], 999) [['-flag1', '-flag2', '-flag3'], ['-flag1', 'flag2', '-flag3'], ['-flag1', '-flag2', 'flag3'], ['-flag1', 'flag2', 'flag3']] """ all_combinations_count = 2 ** len(iuse) valid_use_flags_combinations = [] if all_combinations_count > max_use_combinations: random.seed() checked_combinations = set() while ( len(valid_use_flags_combinations) < max_use_combinations and len(checked_combinations) < all_combinations_count ): index = random.randint(0, all_combinations_count - 1) if index in checked_combinations: continue else: checked_combinations.add(index) flags = get_use_flags_toggles(index, iuse) if portage.dep.check_required_use( " ".join(ruse), flags, iuse_match_always_true ): valid_use_flags_combinations.append(flags) else: for index in range(0, all_combinations_count): flags = get_use_flags_toggles(index, iuse) if portage.dep.check_required_use( " ".join(ruse), flags, iuse_match_always_true ): valid_use_flags_combinations.append(flags) return valid_use_flags_combinations pkg-testing-tools-0.2.5/poetry.lock000066400000000000000000000100701461050114400172760ustar00rootroot00000000000000# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand. [[package]] name = "colorama" version = "0.4.6" description = "Cross-platform colored terminal text." optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" files = [ {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] [[package]] name = "exceptiongroup" version = "1.2.0" description = "Backport of PEP 654 (exception groups)" optional = false python-versions = ">=3.7" files = [ {file = "exceptiongroup-1.2.0-py3-none-any.whl", hash = "sha256:4bfd3996ac73b41e9b9628b04e079f193850720ea5945fc96a08633c66912f14"}, {file = "exceptiongroup-1.2.0.tar.gz", hash = "sha256:91f5c769735f051a4290d52edd0858999b57e5876e9f85937691bd4c9fa3ed68"}, ] [package.extras] test = ["pytest (>=6)"] [[package]] name = "iniconfig" version = "2.0.0" description = "brain-dead simple config-ini parsing" optional = false python-versions = ">=3.7" files = [ {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, ] [[package]] name = "packaging" version = "24.0" description = "Core utilities for Python packages" optional = false python-versions = ">=3.7" files = [ {file = "packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5"}, {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"}, ] [[package]] name = "pluggy" version = "1.4.0" description = "plugin and hook calling mechanisms for python" optional = false python-versions = ">=3.8" files = [ {file = "pluggy-1.4.0-py3-none-any.whl", hash = "sha256:7db9f7b503d67d1c5b95f59773ebb58a8c1c288129a88665838012cfb07b8981"}, {file = "pluggy-1.4.0.tar.gz", hash = "sha256:8c85c2876142a764e5b7548e7d9a0e0ddb46f5185161049a79b7e974454223be"}, ] [package.extras] dev = ["pre-commit", "tox"] testing = ["pytest", "pytest-benchmark"] [[package]] name = "portage" version = "3.0.63" description = "Portage is the package management and distribution system for Gentoo" optional = false python-versions = ">=3.9" files = [ {file = "portage-3.0.63-py3-none-any.whl", hash = "sha256:ab42e525892fb83f8da38ec4c603122e870be21022d4a447b343f332f6e128c2"}, {file = "portage-3.0.63.tar.gz", hash = "sha256:0e72a6c2c0d23954bad5e1e3ae2e0c93aed5f10b1ea01501c8dd51a84c80c489"}, ] [[package]] name = "pytest" version = "8.1.1" description = "pytest: simple powerful testing with Python" optional = false python-versions = ">=3.8" files = [ {file = "pytest-8.1.1-py3-none-any.whl", hash = "sha256:2a8386cfc11fa9d2c50ee7b2a57e7d898ef90470a7a34c4b949ff59662bb78b7"}, {file = "pytest-8.1.1.tar.gz", hash = "sha256:ac978141a75948948817d360297b7aae0fcb9d6ff6bc9ec6d514b85d5a65c044"}, ] [package.dependencies] colorama = {version = "*", markers = "sys_platform == \"win32\""} exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} iniconfig = "*" packaging = "*" pluggy = ">=1.4,<2.0" tomli = {version = ">=1", markers = "python_version < \"3.11\""} [package.extras] testing = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] [[package]] name = "tomli" version = "2.0.1" description = "A lil' TOML parser" optional = false python-versions = ">=3.7" files = [ {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"}, {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, ] [metadata] lock-version = "2.0" python-versions = "^3.10" content-hash = "476d2b5a346247d7c788d06491b0238583c1085aa3fce2e2abac10388a4dac0a" pkg-testing-tools-0.2.5/pyproject.toml000066400000000000000000000013731461050114400200240ustar00rootroot00000000000000[tool.poetry] name = "pkg-testing-tools" version = "0.2.5" description = "Packages testing tools for Gentoo" authors = ["Alexander Puck Neuwirth ", "Piotr Karbowski "] license = "BSD" readme = "README.md" [tool.poetry.dependencies] python = "^3.10" [tool.poetry.group.dev] optional = true [tool.poetry.group.dev.dependencies] portage = "*" [tool.poetry.scripts] pkg-testing-tool = "pkg_testing_tools.main:main" [tool.poetry.group.test] optional = true [tool.poetry.group.test.dependencies] pytest = "*" [build-system] requires = ["poetry-core"] build-backend = "poetry.core.masonry.api" [tool.pytest.ini_options] minversion = "6.0" #testpaths = ["tests"] addopts = [ "-v", "--doctest-modules"]