path: root/upstream-layers/bitbake/lib/bb/tests/setup.py

#
# Copyright BitBake Contributors
#
# SPDX-License-Identifier: GPL-2.0-only
#

from bb.tests.fetch import FetcherTest
import bb
import bb.process
import glob
import hashlib
import json
import os
import shutil
import stat
import subprocess
import sys
import tempfile
import unittest
import venv
import zipfile
from bb.tests.support.httpserver import HTTPService

class BitbakeSetupTest(FetcherTest):
    def setUp(self):
        super(BitbakeSetupTest, self).setUp()

        self.registrypath = os.path.join(self.tempdir, "bitbake-setup-configurations")

        os.makedirs(self.registrypath)
        self.git_init(cwd=self.registrypath)
        self.git(['commit', '--allow-empty', '-m', "Initial commit"], cwd=self.registrypath)

        self.testrepopath = os.path.join(self.tempdir, "test-repo")
        os.makedirs(self.testrepopath)
        self.git_init(cwd=self.testrepopath)
        self.git(['commit', '--allow-empty', '-m', "Initial commit"], cwd=self.testrepopath)

        oeinitbuildenv = """BBPATH=$1
export BBPATH
PATH={}:$PATH
""".format(os.path.join(self.testrepopath, 'scripts'))
        self.add_file_to_testrepo('oe-init-build-env',oeinitbuildenv, script=True)

        oesetupbuild = """#!/usr/bin/env python3
import getopt
import sys
import os
import shutil
opts, args = getopt.getopt(sys.argv[2:], "c:b:", ["no-shell"])
for option, value in opts:
    if option == '-c':
        template = value
    if option == '-b':
        builddir = value
confdir = os.path.join(builddir, 'conf')
os.makedirs(confdir, exist_ok=True)
with open(os.path.join(confdir, 'conf-summary.txt'), 'w') as f:
    f.write(template)
shutil.copy(os.path.join(os.path.dirname(__file__), 'test-repo/test-file'), confdir)
with open(os.path.join(builddir, 'init-build-env'), 'w') as f:
    f.write("BBPATH={}\\nexport BBPATH\\nPATH={}:$PATH".format(builddir, os.path.join(os.path.dirname(__file__), 'test-repo/scripts')))
"""
        self.add_file_to_testrepo('scripts/oe-setup-build', oesetupbuild, script=True)

        installbuildtools = """#!/usr/bin/env python3
import getopt
import sys
import os

opts, args = getopt.getopt(sys.argv[1:], "d:", ["downloads-directory=", "local-file="])
installdir = None
local_file = None
for option, value in opts:
    if option == '-d':
        installdir = value
    elif option == '--local-file':
        local_file = value
        print("install-buildtools local-file={}".format(value))

print("Buildtools installed into {}".format(installdir))
os.makedirs(installdir, exist_ok=True)
"""
        self.add_file_to_testrepo('scripts/install-buildtools', installbuildtools, script=True)

        # Dummy buildtools installer for bb.fetch testing
        self.buildtools_dir = os.path.join(self.tempdir, "buildtools-dl")
        os.makedirs(self.buildtools_dir)
        self.buildtools_filename = "x86_64-buildtools-nativesdk-standalone-test.sh"
        buildtools_filepath = os.path.join(self.buildtools_dir, self.buildtools_filename)
        with open(buildtools_filepath, 'w') as f:
            f.write("#!/bin/sh\necho dummy\n")
        with open(buildtools_filepath, 'rb') as f:
            self.buildtools_sha256 = hashlib.sha256(f.read()).hexdigest()

        bitbakeconfigbuild = """#!/usr/bin/env python3
import os
import sys
confdir = os.path.join(os.environ['BBPATH'], 'conf')
fragment = sys.argv[2]
with open(os.path.join(confdir, fragment), 'w') as f:
    f.write('')
"""
        self.add_file_to_testrepo('scripts/bitbake-config-build', bitbakeconfigbuild, script=True)

        sometargetexecutable_template = """#!/usr/bin/env python3
import os
print("This is {}")
print("BBPATH is {{}}".format(os.environ["BBPATH"]))
"""
        for e_name in ("some-target-executable-1", "some-target-executable-2"):
            sometargetexecutable = sometargetexecutable_template.format(e_name)
            self.add_file_to_testrepo('scripts/{}'.format(e_name), sometargetexecutable, script=True)

    def runbbsetup(self, cmd):
        bbsetup = os.path.abspath(os.path.dirname(__file__) +  "/../../../bin/bitbake-setup")
        # Set PYTHONPATH so subprocess can find bb module instead of relying on the current directory
        env = os.environ.copy()
        libdir = os.path.abspath(os.path.dirname(__file__) + "/../..")
        env["PYTHONPATH"] = libdir + ":" + env.get("PYTHONPATH", "")
        return bb.process.run([bbsetup, '--global-settings', os.path.join(self.tempdir, 'global-config')] + cmd, env=env, cwd=self.tempdir)


    def _add_json_config_to_registry_helper(self, name, sources):
        config = """
{
    "sources": {
%s
    },
    "description": "Test configuration",
    "bitbake-setup": {
        "configurations": [
            {
                "name": "gadget",
                "description": "Gadget configuration",
                "oe-template": "test-configuration-gadget",
                "oe-fragments": ["test-fragment-1"],
                "install-buildtools": {
                    "url": "file://%s/%s",
                    "sha256sum": "%s"
                }
            },
            {
                "name": "gizmo",
                "description": "Gizmo configuration",
                "oe-template": "test-configuration-gizmo",
                "oe-fragments": ["test-fragment-2"],
                "setup-dir-name": "this-is-a-custom-gizmo-build"
            },
            {
                "name": "gizmo-env-passthrough",
                "description": "Gizmo configuration with environment-passthrough",
                "bb-layers": ["layerC","layerD/meta-layer"],
                "oe-fragments": ["test-fragment-1"],
                "bb-env-passthrough-additions": [
                    "BUILD_ID",
                    "BUILD_DATE",
                    "BUILD_SERVER"
                ]
            },
            {
                "name": "gizmo-no-fragment",
                "description": "Gizmo no-fragment template-only configuration",
                "oe-template": "test-configuration-gizmo"
            },
            {
                "name": "gadget-notemplate",
                "description": "Gadget notemplate configuration",
                "notes": [
                    "Gadget notemplate notes",
                    "Second line"
                ],
                "bb-layers": ["layerA","layerB/meta-layer"],
                "oe-fragments": ["test-fragment-1"]
            },
            {
                "name": "gizmo-notemplate-fragments-one-of",
                "description": "Gizmo notemplate configuration",
                "bb-layers": ["layerC","layerD/meta-layer"],
                "oe-fragments": ["test-fragment-2"],
                "oe-fragments-one-of": {
                    "fragment-desc": {
                        "description": "Test fragments (with description)",
                        "options" : [
                            { "name": "fragment-desc-1", "description": "fragment 1 desc" },
                            { "name": "fragment-desc-2", "description": "fragment 2 desc" }
                        ]
                    },
                    "fragment-nodesc": {
                        "description": "Test fragments (no description)",
                        "options" : [
                            "fragment-nodesc-1",
                            "fragment-nodesc-2"
                        ]
                    }
                }
            },
            {
                "name": "gizmo-notemplate-with-filerelative-layers",
                "description": "Gizmo notemplate configuration using filerelative layers",
                "bb-layers": ["layerC","layerD/meta-layer"],
                "bb-layers-file-relative": ["layerE/meta-layer"],
                "oe-fragments": ["test-fragment-2"]
            }
        ]
    },
    "version": "1.0"
}
""" % (sources, self.buildtools_dir, self.buildtools_filename, self.buildtools_sha256)
        os.makedirs(os.path.join(self.registrypath, os.path.dirname(name)), exist_ok=True)
        with open(os.path.join(self.registrypath, name), 'w') as f:
            f.write(config)
        self.git(['add', name], cwd=self.registrypath)
        self.git(['commit', '-m', "Adding " + name], cwd=self.registrypath)
        return json.loads(config)

    def add_json_config_to_registry(self, name, rev, branch):
        sources = """
        "test-repo": {
            "git-remote": {
                "remotes": {
                    "origin": {
                        "uri": "file://%s"
                    }
                },
                "branch": "%s",
                "rev": "%s"
            }
        }
""" % (self.testrepopath, branch, rev)
        return self._add_json_config_to_registry_helper(name, sources)

    def add_local_json_config_to_registry(self, name, path):
        sources = """
        "test-repo": {
            "local": {
                "path": "%s"
            }
        }
""" % (path)
        return self._add_json_config_to_registry_helper(name, sources)

    def add_file_to_testrepo(self, name, content, script=False):
        fullname = os.path.join(self.testrepopath, name)
        os.makedirs(os.path.join(self.testrepopath, os.path.dirname(name)), exist_ok=True)
        with open(fullname, 'w') as f:
            f.write(content)
        if script:
            st = os.stat(fullname)
            os.chmod(fullname, st.st_mode | stat.S_IEXEC)
        self.git(['add', name], cwd=self.testrepopath)
        self.git(['commit', '-m', "Adding " + name], cwd=self.testrepopath)

    def config_is_unchanged(self, setuppath):
        os.environ['BBPATH'] = os.path.join(setuppath, 'build')
        out = self.runbbsetup(["status"])
        self.assertIn("Configuration in {} has not changed".format(setuppath), out[0])
        out = self.runbbsetup(["update", "--update-bb-conf=yes"])
        self.assertIn("Configuration in {} has not changed".format(setuppath), out[0])
        del os.environ['BBPATH']

    def check_setupdir_files(self, setuppath, test_file_content):
        with open(os.path.join(setuppath, 'config', "config-upstream.json")) as f:
            config_upstream = json.load(f)
        with open(os.path.join(setuppath, 'layers', 'test-repo', 'test-file')) as f:
            self.assertEqual(f.read(), test_file_content)
        bitbake_config = config_upstream["bitbake-config"]
        bb_build_path = os.path.join(setuppath, 'build')
        bb_conf_path = os.path.join(bb_build_path, 'conf')
        self.assertTrue(os.path.exists(os.path.join(bb_build_path, 'init-build-env')))

        with open(os.path.join(setuppath, 'config', "sources-fixed-revisions.json")) as f:
            sources_fixed_revisions = json.load(f)
        self.assertTrue('test-repo' in sources_fixed_revisions['sources'].keys())
        revision = self.git(['rev-parse', 'HEAD'], cwd=self.testrepopath).strip()
        self.assertEqual(revision, sources_fixed_revisions['sources']['test-repo']['git-remote']['rev'])

        if "oe-template" in bitbake_config:
            with open(os.path.join(bb_conf_path, 'conf-summary.txt')) as f:
                self.assertEqual(f.read(), bitbake_config["oe-template"])
            with open(os.path.join(bb_conf_path, 'test-file')) as f:
                self.assertEqual(f.read(), test_file_content)
        else:
            with open(os.path.join(bb_conf_path, 'conf-summary.txt')) as f:
                self.assertIn(bitbake_config["description"], f.read())
            with open(os.path.join(bb_conf_path, 'conf-notes.txt')) as f:
                expected_notes = bitbake_config.get("notes")
                if isinstance(expected_notes, list):
                    expected_notes = "\n".join(expected_notes)
                self.assertEqual(f.read(), expected_notes + "\n" if expected_notes else "")
            with open(os.path.join(bb_conf_path, 'bblayers.conf')) as f:
                bblayers = f.read()
                for l in bitbake_config["bb-layers"]:
                    self.assertIn(os.path.join(setuppath, "layers", l), bblayers)
                for l in bitbake_config.get("bb-layers-file-relative") or []:
                    filerelative_layer = os.path.join(
                            os.path.dirname(config_upstream["path"]),
                            l,
                        )
                    self.assertIn(filerelative_layer, bblayers)

        if 'oe-fragments' in bitbake_config:
            for f in bitbake_config["oe-fragments"]:
                self.assertTrue(os.path.exists(os.path.join(bb_conf_path, f)))

        if 'bb-env-passthrough-additions' in bitbake_config:
            with open(os.path.join(bb_build_path, 'init-build-env'), 'r') as f:
                init_build_env = f.read()
            self.assertTrue('BB_ENV_PASSTHROUGH_ADDITIONS' in init_build_env)
            self.assertTrue('BUILD_ID' in init_build_env)
            self.assertTrue('BUILD_DATE' in init_build_env)
            self.assertTrue('BUILD_SERVER' in init_build_env)
            # a more throrough test could be to initialize a bitbake build-env, export FOO to the shell environment, set the env-passthrough on it and finally check against 'bitbake-getvar FOO'

        self.config_is_unchanged(setuppath)

    def get_setup_path(self, cf, c):
        if c == 'gizmo':
            return os.path.join(self.tempdir, 'bitbake-builds', 'this-is-a-custom-gizmo-build')
        return os.path.join(self.tempdir, 'bitbake-builds', '{}-{}'.format(cf, "-".join(c.split())))

    def test_setup(self):
        # unset BBPATH to ensure tests run in isolation from the existing bitbake environment
        if 'BBPATH' in os.environ:
            del os.environ['BBPATH']

        # check that no arguments works
        self.runbbsetup([])

        # check that --help works
        self.runbbsetup(["--help"])

        # change to self.tempdir to work with cwd-based default settings
        os.chdir(self.tempdir)

        # check that the default top-dir-prefix is cwd (now self.tempdir) with no global settings
        out = self.runbbsetup(["settings", "list"])
        self.assertIn("default top-dir-prefix {}".format(os.getcwd()), out[0])

        # set up global location for dl-dir
        settings_path = "{}/global-config".format(self.tempdir)
        out = self.runbbsetup(["settings", "set", "--global", "default", "dl-dir", os.path.join(self.tempdir, 'downloads')])
        self.assertIn("From section 'default' the setting 'dl-dir' was changed to", out[0])
        self.assertIn("Settings written to".format(settings_path), out[0])

        # check that writing settings works and then adjust them to point to
        # test registry repo
        out = self.runbbsetup(["settings", "set", "default", "registry", "'git://{};protocol=file;branch=master;rev=master'".format(self.registrypath)])
        settings_path = "{}/bitbake-builds/settings.conf".format(self.tempdir)
        self.assertIn(settings_path, out[0])
        self.assertIn("From section 'default' the setting 'registry' was changed to", out[0])
        self.assertIn("Settings written to".format(settings_path), out[0])

        # check that listing settings works
        out = self.runbbsetup(["settings", "list"])
        self.assertIn("default top-dir-prefix {}".format(self.tempdir), out[0])
        self.assertIn("default dl-dir {}".format(os.path.join(self.tempdir, 'downloads')), out[0])
        self.assertIn("default registry {}".format('git://{};protocol=file;branch=master;rev=master'.format(self.registrypath)), out[0])

        # check that 'list' produces correct output with no configs, one config and two configs
        out = self.runbbsetup(["list"])
        self.assertNotIn("test-config-1", out[0])
        self.assertNotIn("test-config-2", out[0])

        json_1 = self.add_json_config_to_registry('test-config-1.conf.json', 'master', 'master')
        out = self.runbbsetup(["list"])
        self.assertIn("test-config-1", out[0])
        self.assertNotIn("test-config-2", out[0])

        json_2 = self.add_json_config_to_registry('config-2/test-config-2.conf.json', 'master', 'master')
        out = self.runbbsetup(["list", "--write-json={}".format(os.path.join(self.tempdir, "test-configs.json"))])
        self.assertIn("test-config-1", out[0])
        self.assertIn("test-config-2", out[0])
        with open(os.path.join(self.tempdir, "test-configs.json")) as f:
            json_configs = json.load(f)
        self.assertIn("test-config-1", json_configs)
        self.assertIn("test-config-2", json_configs)

        # check that init/status/update work
        # (the latter two should do nothing and say that config hasn't changed)
        test_file_content = 'initial\n'
        self.add_file_to_testrepo('test-file', test_file_content)

        # test-config-1 is tested as a registry config and over http, test-config-2 as a local file
        server = HTTPService(self.registrypath, host="127.0.0.1")
        server.start()
        variants = (
            'gadget',
            'gizmo',
            'gizmo-env-passthrough',
            'gizmo-no-fragment',
            'gadget-notemplate',
            'gizmo-notemplate-fragments-one-of fragment-desc-1 fragment-nodesc-1',
        )
        variants_local = variants + ('gizmo-notemplate-with-filerelative-layers',)
        test_configurations = ({'name':'test-config-1','cmdline': 'test-config-1',
                                                 'buildconfigs': variants},
                               {'name':'test-config-2','cmdline': os.path.join(self.registrypath,'config-2/test-config-2.conf.json'),
                                                 'buildconfigs': variants_local},
                               {'name':'test-config-1','cmdline':'http://127.0.0.1:{}/test-config-1.conf.json'.format(server.port),
                                                 'buildconfigs': variants}
                               )
        try:
            for v in test_configurations:
                for c in v['buildconfigs']:
                    out = self.runbbsetup(["init", "--non-interactive", v['cmdline']] + c.split())
                    setuppath = self.get_setup_path(v['name'], c)
                    self.check_setupdir_files(setuppath, test_file_content)
        finally:
            server.stop()

        # install buildtools
        out = self.runbbsetup(["install-buildtools", "--setup-dir", setuppath])
        self.assertIn("Buildtools installed into", out[0])
        self.assertTrue(os.path.exists(os.path.join(setuppath, 'buildtools')))

        # change a file in the test layer repo, make a new commit and
        # test that status/update correctly report the change and update the config
        prev_test_file_content = test_file_content
        test_file_content = 'modified\n'
        self.add_file_to_testrepo('test-file', test_file_content)
        for c in variants:
            setuppath = self.get_setup_path('test-config-1', c)
            os.environ['BBPATH'] = os.path.join(setuppath, 'build')
            out = self.runbbsetup(["status"])
            self.assertIn("Layer repository file://{} checked out into {}/layers/test-repo updated revision master from".format(self.testrepopath, setuppath), out[0])
            out = self.runbbsetup(["update", "--update-bb-conf=yes"])
            if c in ('gadget', 'gizmo'):
                self.assertIn("Leaving the previous configuration in {}/build/conf-backup.".format(setuppath), out[0])
                self.assertIn('-{}+{}'.format(prev_test_file_content, test_file_content), out[0])
            self.check_setupdir_files(setuppath, test_file_content)

        # make a new branch in the test layer repo, change a file on that branch,
        # make a new commit, update the top level json config to refer to that branch,
        # and test that status/update correctly report the change and update the config
        prev_test_file_content = test_file_content
        test_file_content = 'modified-in-branch\n'
        branch = "another-branch"
        self.git(['checkout', '-b', branch], cwd=self.testrepopath)
        self.add_file_to_testrepo('test-file', test_file_content)
        json_1 = self.add_json_config_to_registry('test-config-1.conf.json', branch, branch)
        for c in variants:
            setuppath = self.get_setup_path('test-config-1', c)
            os.environ['BBPATH'] = os.path.join(setuppath, 'build')
            out = self.runbbsetup(["status"])
            self.assertIn("Configuration in {} has changed:".format(setuppath), out[0])
            self.assertIn('-                    "rev": "master"\n+                    "rev": "another-branch"', out[0])
            out = self.runbbsetup(["update", "--update-bb-conf=yes"])
            if c in ('gadget', 'gizmo'):
                self.assertIn("Leaving the previous configuration in {}/build/conf-backup.".format(setuppath), out[0])
                self.assertIn('-{}+{}'.format(prev_test_file_content, test_file_content), out[0])
            self.check_setupdir_files(setuppath, test_file_content)

        # do the same as the previous test, but now without updating the bitbake configuration (--update-bb-conf=no)
        # and check that files have not been modified
        def _conf_chksum(confdir: str) -> list:
            sums = []
            for f in glob.glob(f'{confdir}/*'):
                if os.path.isfile(f) and not os.path.islink(f):
                    with open(f, 'rb') as fd:
                        sha = hashlib.sha256()
                        sha.update(fd.read())
                        sums.append(os.path.basename(f) + '_' + sha.hexdigest())
            return sums

        prev_test_file_content = test_file_content
        test_file_content = 'modified-in-branch-no-bb-conf-update\n'
        branch = "another-branch-no-bb-conf-update"
        self.git(['checkout', '-b', branch], cwd=self.testrepopath)
        self.add_file_to_testrepo('test-file', test_file_content)
        json_1 = self.add_json_config_to_registry('test-config-1.conf.json', branch, branch)
        for c in variants:
            setuppath = self.get_setup_path('test-config-1', c)
            os.environ['BBPATH'] = os.path.join(setuppath, 'build')
            # write something in local.conf and bblayers.conf
            for f in ["local.conf", "bblayers.conf"]:
                with open(f"{setuppath}/build/conf/{f}", "w") as fd:
                    fd.write("deadbeef")
            sums_before = _conf_chksum(f"{setuppath}/build/conf")
            out = self.runbbsetup(["update", "--update-bb-conf=no"])
            sums_after = _conf_chksum(f"{setuppath}/build/conf")
            self.assertEqual(sums_before, sums_after)

        def _check_local_sources(custom_setup_dir):
            custom_setup_path = os.path.join(self.tempdir, 'bitbake-builds', custom_setup_dir)
            custom_layer_path = os.path.join(custom_setup_path, 'layers', 'test-repo')
            self.assertTrue(os.path.islink(custom_layer_path))
            self.assertEqual(self.testrepopath, os.path.realpath(custom_layer_path))
            self.config_is_unchanged(custom_setup_path)

        def _check_layer_backups(layer_path, expected_backups):
            files = os.listdir(layer_path)
            backups = len([f for f in files if 'backup' in f])
            self.assertEqual(backups, expected_backups, msg = "Expected {} layer backups, got {}, directory listing: {}".format(expected_backups, backups, files))

        # Change the configuration to refer to a local source, then to another local source, then back to a git remote
        # Run status/update after each change and verify that nothing breaks
        # Also check that layer backups happen when expected
        c = 'gadget'
        setuppath = self.get_setup_path('test-config-1', c)
        self.config_is_unchanged(setuppath)

        layers_path = os.path.join(setuppath, 'layers')
        layer_path = os.path.join(layers_path, 'test-repo')
        _check_layer_backups(layers_path, 0)

        json_1 = self.add_local_json_config_to_registry('test-config-1.conf.json', self.testrepopath)
        os.environ['BBPATH'] = os.path.join(setuppath, 'build')
        out = self.runbbsetup(["update", "--update-bb-conf=yes"])
        _check_local_sources(setuppath)
        _check_layer_backups(layers_path, 1)

        prev_path = self.testrepopath
        self.testrepopath = prev_path + "-2"
        self.git(['clone', prev_path, self.testrepopath], cwd=self.tempdir)
        json_1 = self.add_local_json_config_to_registry('test-config-1.conf.json', self.testrepopath)
        os.environ['BBPATH'] = os.path.join(setuppath, 'build')
        out = self.runbbsetup(["update", "--update-bb-conf=yes"])
        _check_local_sources(setuppath)
        _check_layer_backups(layers_path, 1)

        self.testrepopath = prev_path
        json_1 = self.add_json_config_to_registry('test-config-1.conf.json', branch, branch)
        os.environ['BBPATH'] = os.path.join(setuppath, 'build')
        out = self.runbbsetup(["update", "--update-bb-conf=yes"])
        self.check_setupdir_files(setuppath, test_file_content)
        _check_layer_backups(layers_path, 1)

        ## edit a file without making a commit
        with open(os.path.join(layer_path, 'local-modification'), 'w') as f:
            f.write('locally-modified\n')
        test_file_content = "modified-again\n"
        self.add_file_to_testrepo('test-file', test_file_content)
        os.environ['BBPATH'] = os.path.join(setuppath, 'build')
        out = self.runbbsetup(["update", "--update-bb-conf=yes"])
        _check_layer_backups(layers_path, 1)

        ## edit a file and make a commit such that no rebase conflicts occur
        with open(os.path.join(layer_path, 'local-modification'), 'w') as f:
            f.write('locally-modified-again\n')
        self.git(['add', '.'], cwd=layer_path)
        self.git(['commit', '-m', 'Adding a local modification'], cwd=layer_path)
        test_file_content = "modified-again-and-again\n"
        self.add_file_to_testrepo('test-file', test_file_content)
        out = self.runbbsetup(["update", "--update-bb-conf=yes"])
        _check_layer_backups(layers_path, 1)

        ## edit a file and make a commit in a way that causes a rebase conflict
        with open(os.path.join(layer_path, 'test-file'), 'w') as f:
            f.write('locally-modified\n')
        self.git(['add', '.'], cwd=layer_path)
        self.git(['commit', '-m', 'Adding a local modification'], cwd=layer_path)
        test_file_content = "remotely-modified\n"
        self.add_file_to_testrepo('test-file', test_file_content)
        with self.assertRaisesRegex(bb.process.ExecutionError, "Merge conflict in test-file"):
            out = self.runbbsetup(["update", "--update-bb-conf=yes"])
        _check_layer_backups(layers_path, 1)

        # check source overrides, local sources provided with symlinks, and custom setup dir name
        source_override_content = """
{
    "sources": {
        "test-repo": {
            "local": {
                "path": "."
            }
        }
    }
}"""
        override_filename = 'source-overrides.json'
        custom_setup_dir = 'special-setup-dir'
        self.add_file_to_testrepo(override_filename, source_override_content)
        out = self.runbbsetup(["init", "--non-interactive", "--source-overrides", os.path.join(self.testrepopath, override_filename), "--setup-dir-name", custom_setup_dir, "test-config-1", "gadget"])
        _check_local_sources(custom_setup_dir)

        # same but use command line options to specify local overrides
        custom_setup_dir = 'special-setup-dir-with-cmdline-overrides'
        out = self.runbbsetup(["init", "--non-interactive", "-L", "test-repo", self.testrepopath, "--setup-dir-name", custom_setup_dir, "test-config-1", "gadget"])
        _check_local_sources(custom_setup_dir)

    def test_vscode(self):
        if 'BBPATH' in os.environ:
            del os.environ['BBPATH']
        os.chdir(self.tempdir)

        self.runbbsetup(["settings", "set", "default", "registry", "'git://{};protocol=file;branch=master;rev=master'".format(self.registrypath)])
        self.add_file_to_testrepo('test-file', 'initial\n')
        self.add_json_config_to_registry('test-config-1.conf.json', 'master', 'master')

        # --init-vscode should create bitbake.code-workspace
        self.runbbsetup(["init", "--non-interactive", "--init-vscode", "test-config-1", "gadget"])
        setuppath = self.get_setup_path('test-config-1', 'gadget')
        workspace_file = os.path.join(setuppath, 'bitbake.code-workspace')
        self.assertTrue(os.path.exists(workspace_file),
                        "bitbake.code-workspace should be created with --init-vscode")

        with open(workspace_file) as f:
            workspace = json.load(f)

        # top-level structure
        self.assertIn('folders', workspace)
        self.assertIn('settings', workspace)
        self.assertIn('extensions', workspace)
        self.assertIn('yocto-project.yocto-bitbake',
                      workspace['extensions']['recommendations'])

        # folders: conf dir + test-repo (symlinks like oe-init-build-env-dir are skipped)
        folder_names = {f['name'] for f in workspace['folders']}
        self.assertIn('conf', folder_names)
        self.assertIn('test-repo', folder_names)

        # folder paths must be relative so the workspace is portable
        for f in workspace['folders']:
            self.assertFalse(os.path.isabs(f['path']),
                             "Folder path should be relative, got: {}".format(f['path']))

        # bitbake extension settings
        settings = workspace['settings']
        self.assertTrue(settings.get('bitbake.disableConfigModification'))
        self.assertEqual(settings['bitbake.pathToBuildFolder'],
                         os.path.join(setuppath, 'build'))
        self.assertEqual(settings['bitbake.pathToEnvScript'],
                         os.path.join(setuppath, 'build', 'init-build-env'))

        # file associations
        self.assertIn('*.conf', settings.get('files.associations', {}))
        self.assertIn('*.inc', settings.get('files.associations', {}))

        # python extra paths: test-repo/scripts/ exists and should be listed
        extra_paths = settings.get('python.analysis.extraPaths', [])
        self.assertTrue(any('scripts' in p for p in extra_paths),
                        "python.analysis.extraPaths should include the scripts dir")
        self.assertEqual(settings.get('python.analysis.extraPaths'),
                         settings.get('python.autoComplete.extraPaths'))

        # --no-init-vscode should NOT create a workspace file
        self.runbbsetup(["init", "--non-interactive", "--no-init-vscode", "test-config-1", "gadget-notemplate"])
        notemplate_path = self.get_setup_path('test-config-1', 'gadget-notemplate')
        self.assertFalse(
            os.path.exists(os.path.join(notemplate_path, 'bitbake.code-workspace')),
            "bitbake.code-workspace should not be created with --no-init-vscode")

        # update with --init-vscode after a layer change should preserve
        # user-added folders and settings while still rewriting managed ones
        workspace['folders'].append({"name": "user-folder", "path": "user/custom"})
        workspace['settings']['my.user.setting'] = 'preserved'
        with open(workspace_file, 'w') as f:
            json.dump(workspace, f, indent=4)

        self.add_file_to_testrepo('test-file', 'updated\n')
        os.environ['BBPATH'] = os.path.join(setuppath, 'build')
        self.runbbsetup(["update", "--update-bb-conf=no"])
        del os.environ['BBPATH']

        with open(workspace_file) as f:
            updated = json.load(f)
        self.assertIn('user/custom', {f['path'] for f in updated['folders']},
                      "User-added folder was removed during update")
        self.assertIn('my.user.setting', updated['settings'],
                      "User-added setting was removed during update")

        # update with a corrupt workspace file should log an error and leave it unchanged
        self.add_file_to_testrepo('test-file', 'updated-again\n')
        with open(workspace_file, 'w') as f:
            f.write('{invalid json')
        os.environ['BBPATH'] = os.path.join(setuppath, 'build')
        self.runbbsetup(["update", "--update-bb-conf=no"])
        del os.environ['BBPATH']
        with open(workspace_file) as f:
            content = f.read()
        self.assertEqual(content, '{invalid json',
                         "Corrupt workspace file should not be modified")

    def _count_layer_backups(self, layers_path):
        return len([f for f in os.listdir(layers_path) if 'backup' in f])

    def test_install_buildtools_fetch(self):
        """Test that install-buildtools uses bb.fetch with sha256 and passes --local-file"""
        import shutil

        if 'BBPATH' in os.environ:
            del os.environ['BBPATH']
        os.chdir(self.tempdir)

        registry_uri = "git://{};protocol=file;branch=master;rev=master".format(
            self.registrypath)
        self.runbbsetup(["settings", "set", "default", "registry", registry_uri])
        self.add_file_to_testrepo('test-file', 'initial\n')
        self.add_json_config_to_registry('test-config-bt.conf.json', 'master', 'master')
        self.runbbsetup(["init", "--non-interactive", "test-config-bt", "gadget"])
        setuppath = self.get_setup_path('test-config-bt', 'gadget')

        # test config-driven install (url + sha256sum from config)
        out = self.runbbsetup(["install-buildtools", "--setup-dir", setuppath])
        self.assertIn("Buildtools installed into", out[0])
        self.assertIn("install-buildtools local-file=", out[0])
        self.assertTrue(os.path.exists(os.path.join(setuppath, 'buildtools')))

        # test CLI overrides (use a different file to prove precedence)
        shutil.rmtree(os.path.join(setuppath, 'buildtools'))
        alt_filename = "alt-buildtools-test.sh"
        alt_filepath = os.path.join(self.buildtools_dir, alt_filename)
        with open(alt_filepath, 'w') as f:
            f.write("#!/bin/sh\necho alt\n")
        with open(alt_filepath, 'rb') as f:
            alt_sha256 = hashlib.sha256(f.read()).hexdigest()
        alt_url = "file://{}/{}".format(self.buildtools_dir, alt_filename)
        out = self.runbbsetup(["install-buildtools", "--setup-dir", setuppath,
                               "--url", alt_url,
                               "--sha256", alt_sha256])
        self.assertIn("Buildtools installed into", out[0])
        self.assertIn("install-buildtools local-file=", out[0])
        self.assertIn(alt_filename, out[0])

        # test missing sha256sum is a hard error
        shutil.rmtree(os.path.join(setuppath, 'buildtools'), ignore_errors=True)
        with open(os.path.join(setuppath, 'config', 'config-upstream.json')) as f:
            config_upstream = json.load(f)
        config_upstream['bitbake-config']['install-buildtools'] = {
            'url': 'file://{}/{}'.format(self.buildtools_dir, self.buildtools_filename)
        }
        with open(os.path.join(setuppath, 'config', 'config-upstream.json'), 'w') as f:
            json.dump(config_upstream, f)
        with self.assertRaises(bb.process.ExecutionError):
            self.runbbsetup(["install-buildtools", "--setup-dir", setuppath, "--force"])

    def test_update_rebase_conflicts_strategy(self):
        """Test the --rebase-conflicts-strategy option for the update command.

        Covers three scenarios not exercised by test_setup:
        1. Uncommitted tracked-file change (LocalModificationsError) + default 'abort'
           strategy → clean error message containing 'has uncommitted changes' and a
           hint at --rebase-conflicts-strategy=backup; no backup directory is created.
        2. Same uncommitted change + 'backup' strategy → directory is renamed to a
           timestamped backup and the layer is re-cloned cleanly.
        3. Committed local change that conflicts with an incoming upstream commit
           (RebaseError):
           a. Default 'abort' strategy → error containing 'Merge conflict' and the
              --rebase-conflicts-strategy=backup hint; no backup directory is created.
           b. 'backup' strategy → backup + re-clone instead of a hard failure.
        """
        if 'BBPATH' in os.environ:
            del os.environ['BBPATH']
        os.chdir(self.tempdir)

        self.runbbsetup(["settings", "set", "default", "registry", "'git://{};protocol=file;branch=master;rev=master'".format(self.registrypath)])
        self.add_file_to_testrepo('test-file', 'initial\n')
        self.add_json_config_to_registry('test-config-1.conf.json', 'master', 'master')
        self.runbbsetup(["init", "--non-interactive", "test-config-1", "gadget"])

        setuppath = self.get_setup_path('test-config-1', 'gadget')
        layer_path = os.path.join(setuppath, 'layers', 'test-repo')
        layers_path = os.path.join(setuppath, 'layers')

        # Scenario 1: uncommitted tracked change, default 'abort' strategy
        # Advance upstream so an update is required.
        self.add_file_to_testrepo('test-file', 'upstream-v2\n')
        # Modify the same tracked file in the layer without committing.
        with open(os.path.join(layer_path, 'test-file'), 'w') as f:
            f.write('locally-modified\n')

        os.environ['BBPATH'] = os.path.join(setuppath, 'build')
        with self.assertRaises(bb.process.ExecutionError) as ctx:
            self.runbbsetup(["update", "--update-bb-conf=no"])
        self.assertIn('has uncommitted changes', str(ctx.exception))
        self.assertIn('--rebase-conflicts-strategy=backup', str(ctx.exception))
        # No backup directory must have been created.
        self.assertEqual(self._count_layer_backups(layers_path), 0,
                         "abort strategy must not create any backup")

        # Scenario 2: same uncommitted change, 'backup' strategy
        out = self.runbbsetup(["update", "--update-bb-conf=no", "--rebase-conflicts-strategy=backup"])
        # One backup directory must now exist.
        self.assertEqual(self._count_layer_backups(layers_path), 1,
                         "backup strategy must create exactly one backup")
        # The re-cloned layer must be clean and at the upstream revision.
        with open(os.path.join(layer_path, 'test-file')) as f:
            self.assertEqual(f.read(), 'upstream-v2\n',
                             "re-cloned layer must contain the upstream content")
        status = self.git(['status', '--porcelain'], cwd=layer_path).strip()
        self.assertEqual(status, '',
                         "re-cloned layer must have no local modifications")
        del os.environ['BBPATH']

        # Scenario 3: committed conflicting change, 'backup' strategy
        # Re-initialise a fresh setup so we start from a clean state.
        self.runbbsetup(["init", "--non-interactive", "--setup-dir-name", "rebase-conflict-setup", "test-config-1", "gadget"])
        conflict_setup = os.path.join(self.tempdir, 'bitbake-builds', 'rebase-conflict-setup')
        conflict_layer = os.path.join(conflict_setup, 'layers', 'test-repo')
        conflict_layers = os.path.join(conflict_setup, 'layers')

        # Commit a local change that touches the same file as the next upstream commit.
        with open(os.path.join(conflict_layer, 'test-file'), 'w') as f:
            f.write('conflicting-local\n')
        self.git(['add', 'test-file'], cwd=conflict_layer)
        self.git(['commit', '-m', 'Local conflicting change'], cwd=conflict_layer)

        # Advance upstream with a conflicting edit.
        self.add_file_to_testrepo('test-file', 'conflicting-upstream\n')

        os.environ['BBPATH'] = os.path.join(conflict_setup, 'build')
        # Default stop strategy must still fail with a conflict error and include
        # the --rebase-conflicts-strategy=backup hint (same handler as LocalModificationsError).
        with self.assertRaises(bb.process.ExecutionError) as ctx:
            self.runbbsetup(["update", "--update-bb-conf=no"])
        self.assertIn('Merge conflict in test-file', str(ctx.exception))
        self.assertIn('--rebase-conflicts-strategy=backup', str(ctx.exception))
        self.assertEqual(self._count_layer_backups(conflict_layers), 0)

        # Backup strategy must succeed: backup the conflicted dir and re-clone.
        self.runbbsetup(["update", "--update-bb-conf=no", "--rebase-conflicts-strategy=backup"])
        self.assertEqual(self._count_layer_backups(conflict_layers), 1,
                         "backup strategy must create exactly one backup after a conflict")
        with open(os.path.join(conflict_layer, 'test-file')) as f:
            self.assertEqual(f.read(), 'conflicting-upstream\n',
                             "re-cloned layer must contain the upstream content after conflict backup")
        del os.environ['BBPATH']

@unittest.skipIf(os.environ.get("BB_SKIP_PYPI_TESTS", "yes") != "no",
                 "PyPI packaging test (set BB_SKIP_PYPI_TESTS=no to run)")
class PyPIPackagingTest(unittest.TestCase):
    """Tests for PyPI packaging of bitbake-setup.

    These tests build a wheel from source, install it in an isolated venv,
    and verify the package works correctly. Skipped by default unless
    BB_SKIP_PYPI_TESTS=no is set.
    """

    wheel_path = None
    build_tempdir = None
    workspace_dir = None

    @classmethod
    def setUpClass(cls):
        """Build wheel once for all tests in this class."""
        # Locate packaging-pypi/bitbake-setup directory
        cls.pypi_dir = os.path.abspath(
            os.path.join(os.path.dirname(__file__), '..', '..', '..', 'packaging-pypi', 'bitbake-setup')
        )

        # Check for required build tools
        cls._check_build_tools()

        # Create temporary directory for packaging workspace
        cls.build_tempdir = tempfile.mkdtemp(prefix="bitbake-pypi-build-")

        # Run package-bitbake-setup.py to create packaging workspace
        cls._create_packaging_workspace()

        # Build the wheel
        cls._build_wheel()

    @classmethod
    def _check_build_tools(cls):
        """Verify build tools are available, skip if not."""
        try:
            result = subprocess.run(
                [sys.executable, "-m", "build", "--version"],
                capture_output=True, check=True
            )
        except (subprocess.CalledProcessError, FileNotFoundError):
            raise unittest.SkipTest("'build' package not installed (pip install build)")

    @classmethod
    def _create_packaging_workspace(cls):
        """Create packaging workspace using package-bitbake-setup.py."""
        script = os.path.join(cls.pypi_dir, 'package-bitbake-setup.py')
        cls.workspace_dir = os.path.join(cls.build_tempdir, 'workspace')
        result = subprocess.run(
            [sys.executable, script, '-d', cls.workspace_dir],
            capture_output=True, text=True
        )
        if result.returncode != 0:
            raise unittest.SkipTest(f"Packaging workspace creation failed: {result.stderr}")

    @classmethod
    def _build_wheel(cls):
        """Build the wheel in the packaging workspace."""
        result = subprocess.run(
            [sys.executable, "-m", "build", "--wheel"],
            cwd=cls.workspace_dir,
            capture_output=True, text=True
        )
        if result.returncode != 0:
            raise unittest.SkipTest(f"Wheel build failed: {result.stderr}")

        # Find the built wheel
        dist_dir = os.path.join(cls.workspace_dir, 'dist')
        wheels = glob.glob(os.path.join(dist_dir, '*.whl'))
        if not wheels:
            raise unittest.SkipTest("No wheel file found after build")
        cls.wheel_path = wheels[0]

    @classmethod
    def tearDownClass(cls):
        """Clean up the shared wheel build artifacts."""
        if cls.build_tempdir and os.environ.get("BB_TMPDIR_NOCLEAN") != "yes":
            shutil.rmtree(cls.build_tempdir, ignore_errors=True)
        elif cls.build_tempdir:
            print(f"Not cleaning up {cls.build_tempdir}. Please remove manually.")

    def setUp(self):
        """Create isolated venv for testing the installed package."""
        self.venv_dir = tempfile.mkdtemp(prefix="bitbake-pypi-venv-")

        # Create venv without pip (faster, no network needed)
        venv.create(self.venv_dir, with_pip=False, symlinks=True)

        # Get paths to venv python and bin directory
        self.venv_python = os.path.join(self.venv_dir, 'bin', 'python')
        self.venv_bin = os.path.join(self.venv_dir, 'bin')

        # Install wheel using pip from the outer environment (offline, no-deps)
        site_packages = self._get_site_packages()
        result = subprocess.run(
            [sys.executable, "-m", "pip", "install",
             "--target", site_packages,
             "--no-deps", "--no-index",
             self.wheel_path],
            capture_output=True, text=True
        )
        if result.returncode != 0:
            self.fail(f"Failed to install wheel: {result.stderr}")

        # Install console script entry point manually
        self._install_console_script()

    def _get_site_packages(self):
        """Get the site-packages directory in the venv."""
        lib_dir = os.path.join(self.venv_dir, 'lib')
        # Find python version directory
        for d in os.listdir(lib_dir):
            if d.startswith('python'):
                return os.path.join(lib_dir, d, 'site-packages')
        raise RuntimeError("Could not find site-packages in venv")

    def _install_console_script(self):
        """Create console script wrapper in venv bin directory."""
        site_packages = self._get_site_packages()
        script_path = os.path.join(self.venv_bin, 'bitbake-setup')
        script_content = f'''#!{self.venv_python}
import sys
sys.path.insert(0, "{site_packages}")
from bitbake_setup.__main__ import main
sys.exit(main())
'''
        with open(script_path, 'w') as f:
            f.write(script_content)
        os.chmod(script_path, 0o755)

    def tearDown(self):
        """Remove venv after test."""
        if os.environ.get("BB_TMPDIR_NOCLEAN") != "yes":
            shutil.rmtree(self.venv_dir, ignore_errors=True)
        else:
            print(f"Not cleaning up {self.venv_dir}. Please remove manually.")

    def test_imports(self):
        """Verify all expected modules can be imported from installed package."""

        site_packages = self._get_site_packages()
        imports = ['bb', 'bitbake_setup']
        for module in imports:
            result = subprocess.run(
                [self.venv_python, '-c', f'import sys; sys.path.insert(0, "{site_packages}"); import {module}'],
                capture_output=True, text=True
            )
            self.assertEqual(result.returncode, 0,
                f"Failed to import {module}: {result.stderr}")

    def test_console_script_help(self):
        """Verify bitbake-setup --help runs successfully."""
        script = os.path.join(self.venv_bin, 'bitbake-setup')
        result = subprocess.run(
            [script, '--help'],
            capture_output=True, text=True
        )
        self.assertEqual(result.returncode, 0,
            f"bitbake-setup --help failed: {result.stderr}")
        self.assertIn('usage:', result.stdout.lower())

    def test_console_script_list(self):
        """Verify bitbake-setup list runs successfully."""
        script = os.path.join(self.venv_bin, 'bitbake-setup')
        result = subprocess.run(
            [script, 'list'],
            capture_output=True, text=True
        )
        # List may return 0 even with no configurations
        self.assertEqual(result.returncode, 0,
            f"bitbake-setup list failed: {result.stderr}")

    def test_package_metadata(self):
        """Verify package metadata is correctly set."""
        site_packages = self._get_site_packages()
        code = '''
import json
import sys
sys.path.insert(0, "{}")
from importlib.metadata import metadata
m = metadata("bitbake-setup")
print(json.dumps({{
    "name": m["Name"],
    "version": m["Version"],
    "requires_python": m.get("Requires-Python", ""),
    "license": m.get("License", ""),
}}))
'''.format(site_packages)
        result = subprocess.run(
            [self.venv_python, '-c', code],
            capture_output=True, text=True
        )
        self.assertEqual(result.returncode, 0,
            f"Failed to get metadata: {result.stderr}")

        meta = json.loads(result.stdout)
        self.assertEqual(meta['name'], 'bitbake-setup')
        self.assertIn('>=3.9', meta['requires_python'])

    def test_vendored_dependencies(self):
        """Verify vendored dependencies (bs4, ply, progressbar, simplediff) are not bundled in package."""
        # Check that vendored packages do not exist in root of wheel
        with zipfile.ZipFile(self.wheel_path, 'r') as whl:
            names = whl.namelist()

            # Check for expected package directories
            expected = ['bs4/', 'ply/', 'progressbar/', 'simplediff/']
            for pkg in expected:
                found = any(n.startswith(pkg) for n in names)
                self.assertFalse(found,
                    f"Unexpected vendored package '{pkg}' found in wheel")

    def test_version_from_wheel(self):
        """Verify version is set correctly (not fallback 0.0.0 unless expected)."""
        import re
        # Extract version from wheel filename
        wheel_name = os.path.basename(self.wheel_path)
        # Wheel format: {name}-{version}(-{build})?-{python}-{abi}-{platform}.whl
        parts = wheel_name.split('-')
        version = parts[1]

        # Check version format (should be semver-like or contain git info)
        version_pattern = r'^\d+\.\d+\.\d+.*$'
        self.assertTrue(re.match(version_pattern, version),
            f"Version '{version}' doesn't match expected pattern")

        print(f"Extracted version from wheel: {version}")

        self.assertNotEqual(version, '0.0.0',
            "Version is fallback 0.0.0 - no git tags found")

    def test_wheel_metadata_file(self):
        """Verify wheel METADATA file contains required fields."""
        with zipfile.ZipFile(self.wheel_path, 'r') as whl:
            # Find METADATA file in dist-info
            metadata_path = None
            for name in whl.namelist():
                if name.endswith('.dist-info/METADATA'):
                    metadata_path = name
                    break

            self.assertIsNotNone(metadata_path, "METADATA file not found in wheel")

            # Parse metadata
            metadata_content = whl.read(metadata_path).decode('utf-8')

            # Check required fields
            self.assertIn('Metadata-Version:', metadata_content)
            self.assertIn('Name: bitbake-setup', metadata_content)
            self.assertIn('Version:', metadata_content)
            self.assertIn('Requires-Python:', metadata_content)

    def test_entry_points(self):
        """Verify console script entry points are correctly defined."""
        with zipfile.ZipFile(self.wheel_path, 'r') as whl:
            # Find entry_points.txt in dist-info
            entry_points_path = None
            for name in whl.namelist():
                if name.endswith('.dist-info/entry_points.txt'):
                    entry_points_path = name
                    break

            self.assertIsNotNone(entry_points_path,
                "entry_points.txt not found in wheel")

            content = whl.read(entry_points_path).decode('utf-8')
            self.assertIn('[console_scripts]', content)
            self.assertIn('bitbake-setup', content)
            self.assertIn('bitbake_setup.__main__:main', content)