# Copyright 2021 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Android service unittests."""

import os
import re
from typing import Dict

from chromite.lib import cros_test_lib
from chromite.lib import gs
from chromite.lib import gs_unittest
from chromite.lib import osutils
from chromite.service import android


_STAT_OUTPUT = """%s:
    Creation time:    Sat, 23 Aug 2014 06:53:20 GMT
    Content-Language: en
    Content-Length:   74
    Content-Type:   application/octet-stream
    Hash (crc32c):    BBPMPA==
    Hash (md5):   ms+qSYvgI9SjXn8tW/5UpQ==
    ETag:     CNCgocbmqMACEAE=
    Generation:   1408776800850000
    Metageneration:   1
"""


def _RaiseGSNoSuchKey(*_args, **_kwargs) -> None:
    raise gs.GSNoSuchKey("file does not exist")


class ArtifactsConfigTest(cros_test_lib.TestCase):
    """Tests to ensure artifacts configs are properly written."""

    def testAllTargetsAreConfigured(self) -> None:
        """Ensure artifact patterns are configured for all pkgs and targets."""
        self.assertSetEqual(
            set(android.ARTIFACTS_TO_COPY),
            set(android.ANDROID_PACKAGE_TO_BUILD_TARGETS),
            "Branches configured in ARTIFACTS_TO_COPY doesn't "
            "match list of all Android branches",
        )
        for (
            package,
            ebuild_target,
        ) in android.ANDROID_PACKAGE_TO_BUILD_TARGETS.items():
            self.assertSetEqual(
                set(android.ARTIFACTS_TO_COPY[package]),
                set(ebuild_target.values()),
                f"For package {package}, targets configured in "
                "ARTIFACTS_TO_COPY doesn't match list of all "
                "supported targets",
            )


class GetAndroidBranchForPackageTest(cros_test_lib.TestCase):
    """Tests for GetAndroidBranchForPackage."""

    def testAllPackagesAreMapped(self) -> None:
        """Ensure all possible Android packages are mapped to valid branches."""
        for package in android.GetAllAndroidPackages():
            android.GetAndroidBranchForPackage(package)

    def testRaisesOnUnknownPackage(self) -> None:
        """Ensure passing an unknown package raises an exception."""
        with self.assertRaises(ValueError):
            android.GetAndroidBranchForPackage("not-an-android-package")


class GetAndroidEbuildTargetsForPackageTest(cros_test_lib.TestCase):
    """Tests for GetAndroidEbuildTargetsForPackage."""

    def testAllPackagesAreMapped(self) -> None:
        """Ensure all possible Android packages are mapped."""
        for package in android.GetAllAndroidPackages():
            android.GetAndroidEbuildTargetsForPackage(package)

    def testRaisesOnUnknownPackage(self) -> None:
        """Ensure passing an unknown package raises an exception."""
        with self.assertRaises(ValueError):
            android.GetAndroidEbuildTargetsForPackage("not-an-android-package")


class MockAndroidBuildArtifactsTest(cros_test_lib.MockTempDirTestCase):
    """Tests using a mocked GS bucket containing Android build artifacts."""

    def setUp(self) -> None:
        """Setup vars and create mock dir."""
        self.android_package = "android-package"
        self.mock_android_dir = os.path.join(self.tempdir, "android-package")

        self.arm_acl_data = "-g google.com:READ"
        self.x86_acl_data = "-g google.com:WRITE"
        self.public_acl_data = "-u AllUsers:READ"
        self.arm_acl = os.path.join(
            self.mock_android_dir, android.ARC_BUCKET_ACL_ARM
        )
        self.x86_acl = os.path.join(
            self.mock_android_dir, android.ARC_BUCKET_ACL_X86
        )
        self.public_acl = os.path.join(
            self.mock_android_dir, android.ARC_BUCKET_ACL_PUBLIC
        )

        osutils.WriteFile(self.arm_acl, self.arm_acl_data, makedirs=True)
        osutils.WriteFile(self.x86_acl, self.x86_acl_data, makedirs=True)
        osutils.WriteFile(self.public_acl, self.public_acl_data, makedirs=True)

        self.bucket_url = "gs://u"
        self.gs_mock = self.StartPatcher(gs_unittest.GSContextMock())
        self.arc_bucket_url = "gs://a"
        self.targets = {
            "apps": "^(foo|bar)$",
            "target_arm": r"\.zip$",
            "target_x86": r"\.zip$",
        }

        self.PatchDict(
            android.ARTIFACTS_TO_COPY, {self.android_package: self.targets}
        )

    def setupMockTarget(
        self, branch: str, target: str, versions: Dict[str, bool]
    ) -> None:
        """Mocks GS responses for one build target.

        Mocks GS responses for the following paths:
        {src_bucket}/{branch}-linux-{target}
        {src_bucket}/{branch}-linux-{target}/{version}
        {src_bucket}/{branch}-linux-{target}/{version}/{subpath}
        {src_bucket}/{branch}-linux-{target}/{version}/{subpath}/*
        {dst_bucket}/{branch}-linux-{target}
        {dst_bucket}/{branch}-linux-{target}/{version}
        {dst_bucket}/{branch}-linux-{target}/{version}/*

        Each version can be either valid (artifacts exist) or invalid (returns
        file not found error), specified via the `versions` dict.

        Args:
            branch: The branch.
            target: The build target.
            versions: A mapping between versions to mock for this target and
                whether each version is valid.
        """
        # `gsutil ls gs://<bucket>/<target>` shows all available versions.
        url = f"{self.bucket_url}/{branch}-linux-{target}"
        stdout = "\n".join(f"{url}/{version}" for version in versions)
        self.gs_mock.AddCmdResult(["ls", "--", url], stdout=stdout)

        for version, valid in versions.items():
            self.mockOneTargetVersion(branch, target, version, valid)

    def mockOneTargetVersion(self, branch, target, version, valid) -> None:
        """Mock GS responses for one (target, version). See setupMockTarget."""

        src_url = f"{self.bucket_url}/{branch}-linux-{target}/{version}"
        if not valid:
            self.gs_mock.AddCmdResult(
                ["ls", "--", src_url], side_effect=_RaiseGSNoSuchKey
            )
            return

        # Show source subpath directory.
        src_subdir = f"{src_url}/{target}{version}"
        self.gs_mock.AddCmdResult(["ls", "--", src_url], stdout=src_subdir)

        # Show files.
        mock_file_template_list = {
            "apps": ["foo", "bar", "baz"],
            "target_arm": [
                "foo-%(version)s.zip",
                "bar.zip",
                "baz",
            ],
            "target_x86": [
                "foo-%(version)s.zip",
                "bar.zip",
                "baz",
            ],
        }
        filelist = [
            template % {"version": version}
            for template in mock_file_template_list[target]
        ]
        src_filelist = [
            os.path.join(src_subdir, filename) for filename in filelist
        ]
        self.gs_mock.AddCmdResult(
            ["ls", "--", src_subdir], stdout="\n".join(src_filelist)
        )
        for src_file in src_filelist:
            self.gs_mock.AddCmdResult(
                ["stat", "--", src_file],
                stdout=_STAT_OUTPUT % src_url,
            )

        # Show nothing in destination.
        dst_url = f"{self.arc_bucket_url}/{branch}-linux-{target}/{version}"
        filelist = [
            template % {"version": version}
            for template in mock_file_template_list[target]
        ]
        dst_filelist = [
            os.path.join(dst_url, filename) for filename in filelist
        ]
        for dst_file in dst_filelist:
            self.gs_mock.AddCmdResult(
                ["stat", "--", dst_file], side_effect=_RaiseGSNoSuchKey
            )

        for src_file, dst_file in zip(src_filelist, dst_filelist):
            # Only allow copying if file name matches target pattern. Otherwise
            # raise an error to fail the test.
            side_effect = (
                None
                if re.search(self.targets[target], src_file)
                else Exception(
                    f"file gets copied while it shouldn't: {src_file}"
                )
            )
            self.gs_mock.AddCmdResult(
                ["cp", "-v", "--", src_file, dst_file], side_effect=side_effect
            )

        # Allow setting ACL on dest files.
        acls = {
            "apps": self.public_acl_data,
            "target_arm": self.arm_acl_data,
            "target_x86": self.x86_acl_data,
        }
        for dst_file in dst_filelist:
            self.gs_mock.AddCmdResult(
                ["acl", "ch"] + acls[target].split() + [dst_file]
            )

    def testIsBuildIdValid_success(self) -> None:
        """Test IsBuildIdValid with a valid build."""
        self.setupMockTarget("android-branch", "apps", {"1000": True})
        self.setupMockTarget("android-branch", "target_arm", {"1000": True})
        self.setupMockTarget("android-branch", "target_x86", {"1000": True})

        subpaths = android.IsBuildIdValid(
            self.android_package, "android-branch", "1000", self.bucket_url
        )
        self.assertDictEqual(
            subpaths,
            {
                "apps": "apps1000",
                "target_arm": "target_arm1000",
                "target_x86": "target_x861000",
            },
        )

    def testIsBuildIdValid_partialExist(self) -> None:
        """Test IsBuildIdValid with a partially populated build."""
        self.setupMockTarget("android-branch", "apps", {"1000": False})
        self.setupMockTarget("android-branch", "target_arm", {"1000": True})
        self.setupMockTarget("android-branch", "target_x86", {"1000": True})

        subpaths = android.IsBuildIdValid(
            self.android_package,
            "android-branch",
            "1000",
            self.bucket_url,
        )
        self.assertIsNone(subpaths)

    def testIsBuildIdValid_notExist(self) -> None:
        """Test IsBuildIdValid with a nonexistent build."""
        self.setupMockTarget("android-branch", "apps", {"1000": False})
        self.setupMockTarget("android-branch", "target_arm", {"1000": False})
        self.setupMockTarget("android-branch", "target_x86", {"1000": False})

        subpaths = android.IsBuildIdValid(
            self.android_package,
            "android-branch",
            "1000",
            self.bucket_url,
        )
        self.assertIsNone(subpaths)

    def testGetLatestBuild_basic(self) -> None:
        """Test determination of latest build from gs bucket."""
        # - build 900 is valid (all targets are populated)
        # - build 1000 is valid
        # - build 1100 is invalid (partially populated)
        self.setupMockTarget(
            "android-branch", "apps", {"900": True, "1000": True, "1100": False}
        )
        self.setupMockTarget(
            "android-branch",
            "target_arm",
            {"900": True, "1000": True, "1100": True},
        )
        self.setupMockTarget(
            "android-branch",
            "target_x86",
            {"900": True, "1000": True, "1100": True},
        )

        version, subpaths = android.GetLatestBuild(
            self.android_package,
            build_branch="android-branch",
            bucket_url=self.bucket_url,
        )
        self.assertEqual(version, "1000")
        self.assertDictEqual(
            subpaths,
            {
                "apps": "apps1000",
                "target_arm": "target_arm1000",
                "target_x86": "target_x861000",
            },
        )

    def testGetLatestBuild_defaultBranch(self) -> None:
        """Test if default branch is used when no branch is specified."""
        self.setupMockTarget("default-branch", "apps", {"1000": True})
        self.setupMockTarget("default-branch", "target_arm", {"1000": True})
        self.setupMockTarget("default-branch", "target_x86", {"1000": True})
        self.PatchObject(
            android,
            "GetAndroidBranchForPackage",
            return_value="default-branch",
        )

        version, subpaths = android.GetLatestBuild(
            self.android_package,
            bucket_url=self.bucket_url,
        )
        self.assertEqual(version, "1000")
        self.assertDictEqual(
            subpaths,
            {
                "apps": "apps1000",
                "target_arm": "target_arm1000",
                "target_x86": "target_x861000",
            },
        )

    def testCopyToArcBucket(self) -> None:
        """Test copying of images to ARC bucket."""
        self.setupMockTarget("android-branch", "apps", {"1000": True})
        self.setupMockTarget("android-branch", "target_arm", {"1000": True})
        self.setupMockTarget("android-branch", "target_x86", {"1000": True})

        android.CopyToArcBucket(
            self.bucket_url,
            self.android_package,
            "android-branch",
            "1000",
            {
                "apps": "apps1000",
                "target_arm": "target_arm1000",
                "target_x86": "target_x861000",
            },
            self.arc_bucket_url,
            self.mock_android_dir,
        )


class LKGBTest(cros_test_lib.TempDirTestCase):
    """Tests ReadLKGB/WriteLKGB."""

    def testWriteReadLGKB(self) -> None:
        android_package_dir = self.tempdir
        build_id = "build-id"

        lkgb = android.LKGB(build_id=build_id)
        android.WriteLKGB(android_package_dir, lkgb)
        self.assertEqual(
            android.ReadLKGB(android_package_dir)["build_id"], build_id
        )

    def testReadLKGBMissing(self) -> None:
        android_package_dir = self.tempdir

        with self.assertRaises(android.MissingLKGBError):
            android.ReadLKGB(android_package_dir)

    def testReadLKGBNotJSON(self) -> None:
        android_package_dir = self.tempdir
        (android_package_dir / "LKGB.json").write_text(
            "not-a-json-file", encoding="utf-8"
        )

        with self.assertRaises(android.InvalidLKGBError):
            android.ReadLKGB(android_package_dir)

    def testReadLKGBMissingBuildID(self) -> None:
        android_package_dir = self.tempdir
        (android_package_dir / "LKGB.json").write_text(
            '{"not_build_id": "foo"}', encoding="utf-8"
        )

        with self.assertRaises(android.InvalidLKGBError):
            android.ReadLKGB(android_package_dir)

    def testReadLKGBDiscardUnusedFields(self) -> None:
        android_package_dir = self.tempdir
        (android_package_dir / "LKGB.json").write_text(
            """{
    "build_id": "build-id",
    "branch": "branch",
    "runtime_artifacts_pin": "runtime-artifacts-pin",
    "unused": "foo"
}""",
            encoding="utf-8",
        )

        lkgb = android.ReadLKGB(android_package_dir)
        self.assertEqual(
            lkgb,
            dict(
                build_id="build-id",
                branch="branch",
                runtime_artifacts_pin="runtime-artifacts-pin",
            ),
        )


class RuntimeArtifactsTest(cros_test_lib.MockTestCase):
    """Tests runtime artifacts functions."""

    def setUp(self) -> None:
        self.android_package = "android-package"
        self.android_branch = "android-branch"
        self.runtime_artifacts_bucket_url = "gs://r"
        self.milestone = "99"

        self.gs_mock = self.StartPatcher(gs_unittest.GSContextMock())

    def setupMockRuntimeDataBuild(self, android_version) -> None:
        """Helper to mock a build for runtime data."""

        _ARCHS = ("arm", "arm64", "arm64only", "x86", "x86_64", "x64only")
        _BUILD_TYPES = ("user", "userdebug")
        _RUNTIME_DATAS = (
            "packages_reference",
            "gms_core_cache",
            "tts_cache",
            "dex_opt_cache",
        )

        for arch in _ARCHS:
            for build_type in _BUILD_TYPES:
                for runtime_data in _RUNTIME_DATAS:
                    path = (
                        f"{self.runtime_artifacts_bucket_url}/"
                        f"{self.android_package}/"
                        f"{runtime_data}_{arch}_"
                        f"{build_type}_{android_version}.tar"
                    )
                    self.gs_mock.AddCmdResult(
                        ["stat", "--", path], side_effect=_RaiseGSNoSuchKey
                    )

        _UREADAHEAD_DATA = "ureadahead_pack"
        _BINARY_TRANSLATION_TYPES = ("houdini", "ndk", "native")
        for arch in _ARCHS:
            for build_type in _BUILD_TYPES:
                for binary_translation_type in _BINARY_TRANSLATION_TYPES:
                    if (
                        "x86" in arch and binary_translation_type == "native"
                    ) or (
                        "arm" in arch and binary_translation_type != "native"
                    ):
                        continue

                    path = (
                        f"{self.runtime_artifacts_bucket_url}/"
                        f"{self.android_package}/"
                        f"{_UREADAHEAD_DATA}_{arch}_{binary_translation_type}_"
                        f"{build_type}_{android_version}.tar"
                    )
                    self.gs_mock.AddCmdResult(
                        ["stat", "--", path], side_effect=_RaiseGSNoSuchKey
                    )

    def setupMockRuntimeArtifactsPin(self, pin_version) -> None:
        """Helper to mock a runtime artifacts pin on GS."""
        pin_paths = [
            (
                f"{self.runtime_artifacts_bucket_url}/"
                f"{self.android_package}/M{self.milestone}_pin_version"
            ),
            (
                f"{self.runtime_artifacts_bucket_url}/"
                f"{self.android_branch}_pin_version"
            ),
        ]
        for _, pin_path in enumerate(pin_paths):
            if pin_version:
                self.gs_mock.AddCmdResult(
                    ["stat", "--", pin_path], stdout=_STAT_OUTPUT % pin_path
                )
                self.gs_mock.AddCmdResult(["cat", pin_path], stdout=pin_version)
            else:
                self.gs_mock.AddCmdResult(
                    ["stat", "--", pin_path], side_effect=_RaiseGSNoSuchKey
                )

    def testFindDataCollectorArtifacts(self) -> None:
        android_version = "100"
        # Mock by default runtime artifacts are not found.
        self.setupMockRuntimeDataBuild(android_version)

        # Override few as existing.
        path0 = (
            "gs://r/android-package/"
            "ureadahead_pack_x86_64_houdini_user_100.tar"
        )
        path1 = "gs://r/android-package/ureadahead_pack_x86_64_ndk_user_100.tar"
        path2 = (
            "gs://r/android-package/ureadahead_pack_arm64_native_user_100.tar"
        )
        path3 = (
            "gs://r/android-package/"
            "ureadahead_pack_x86_64_houdini_userdebug_100.tar"
        )
        path4 = (
            "gs://r/android-package/packages_reference_arm_userdebug_100.tar"
        )
        path5 = "gs://r/android-package/gms_core_cache_arm_userdebug_100.tar"
        path6 = "gs://r/android-package/tts_cache_arm64_user_100.tar"
        path7 = "gs://r/android-package/dex_opt_cache_x86_user_100.tar"
        path8 = (
            "gs://r/android-package/"
            "packages_reference_x64only_userdebug_100.tar"
        )
        path9 = "gs://r/android-package/gms_core_cache_arm64only_user_100.tar"
        path10 = (
            "gs://r/android-package/"
            "ureadahead_pack_x64only_houdini_userdebug_100.tar"
        )
        path11 = (
            "gs://r/android-package/"
            "ureadahead_pack_arm64only_native_user_100.tar"
        )

        self.gs_mock.AddCmdResult(
            ["stat", "--", path0], stdout=_STAT_OUTPUT % path0
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", path1], stdout=_STAT_OUTPUT % path1
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", path2], stdout=_STAT_OUTPUT % path2
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", path3], stdout=_STAT_OUTPUT % path3
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", path4], stdout=_STAT_OUTPUT % path4
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", path5], stdout=_STAT_OUTPUT % path5
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", path6], stdout=_STAT_OUTPUT % path6
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", path7], stdout=_STAT_OUTPUT % path7
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", path8], stdout=_STAT_OUTPUT % path8
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", path9], stdout=_STAT_OUTPUT % path9
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", path10], stdout=_STAT_OUTPUT % path10
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", path11], stdout=_STAT_OUTPUT % path11
        )

        variables = android.FindDataCollectorArtifacts(
            self.android_package,
            android_version,
            "${PV}",
            self.runtime_artifacts_bucket_url,
        )

        expectation0 = (
            "gs://r/android-package/"
            "ureadahead_pack_x86_64_houdini_user_${PV}.tar"
        )
        expectation1 = (
            "gs://r/android-package/"
            "ureadahead_pack_x86_64_ndk_user_${PV}.tar"
        )
        expectation2 = (
            "gs://r/android-package/"
            "ureadahead_pack_arm64_native_user_${PV}.tar"
        )
        expectation3 = (
            "gs://r/android-package/"
            "ureadahead_pack_x86_64_houdini_userdebug_${PV}.tar"
        )
        expectation4 = (
            "gs://r/android-package/packages_reference_arm_userdebug_${PV}.tar"
        )
        expectation5 = (
            "gs://r/android-package/gms_core_cache_arm_userdebug_${PV}.tar"
        )
        expectation6 = "gs://r/android-package/tts_cache_arm64_user_${PV}.tar"
        expectation7 = "gs://r/android-package/dex_opt_cache_x86_user_${PV}.tar"
        expectation8 = (
            "gs://r/android-package/"
            "packages_reference_x64only_userdebug_${PV}.tar"
        )
        expectation9 = (
            "gs://r/android-package/gms_core_cache_arm64only_user_${PV}.tar"
        )
        expectation10 = (
            "gs://r/android-package/"
            "ureadahead_pack_x64only_houdini_userdebug_${PV}.tar"
        )
        expectation11 = (
            "gs://r/android-package/"
            "ureadahead_pack_arm64only_native_user_${PV}.tar"
        )

        self.assertDictEqual(
            variables,
            {
                "X86_64_HOUDINI_USER_UREADAHEAD_PACK": expectation0,
                "X86_64_NDK_USER_UREADAHEAD_PACK": expectation1,
                "ARM64_NATIVE_USER_UREADAHEAD_PACK": expectation2,
                "X86_64_HOUDINI_USERDEBUG_UREADAHEAD_PACK": expectation3,
                "ARM_USERDEBUG_PACKAGES_REFERENCE": expectation4,
                "ARM_USERDEBUG_GMS_CORE_CACHE": expectation5,
                "ARM64_USER_TTS_CACHE": expectation6,
                "X86_USER_DEX_OPT_CACHE": expectation7,
                "X64ONLY_USERDEBUG_PACKAGES_REFERENCE": expectation8,
                "ARM64ONLY_USER_GMS_CORE_CACHE": expectation9,
                "X64ONLY_HOUDINI_USERDEBUG_UREADAHEAD_PACK": expectation10,
                "ARM64ONLY_NATIVE_USER_UREADAHEAD_PACK": expectation11,
            },
        )

    def testFindDataCollectorArtifactsNotExist(self) -> None:
        android_version = "100"
        # Mock by default runtime artifacts are not found.
        self.setupMockRuntimeDataBuild(android_version)

        # Invalid paths that should be ignored.
        invalid_path1 = (
            "gs://r/android-package/"
            "ureadahead_pack_arm64_houdini_user_100.tar"
        )
        invalid_path2 = (
            "gs://r/android-package/"
            "ureadahead_pack_x86_64_native_user_100.tar"
        )
        invalid_path3 = (
            "gs://r/android-package/ureadahead_pack_arm64_ndk_user_100.tar"
        )
        invalid_path4 = (
            "gs://r/android-package/ureadahead_pack_x86_64_user_100.tar"
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", invalid_path1], stdout=_STAT_OUTPUT % invalid_path1
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", invalid_path2], stdout=_STAT_OUTPUT % invalid_path2
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", invalid_path3], stdout=_STAT_OUTPUT % invalid_path3
        )
        self.gs_mock.AddCmdResult(
            ["stat", "--", invalid_path4], stdout=_STAT_OUTPUT % invalid_path4
        )

        variables = android.FindDataCollectorArtifacts(
            self.android_package,
            android_version,
            "${PV}",
            self.runtime_artifacts_bucket_url,
        )

        self.assertDictEqual(variables, {})

    def testFindRuntimeArtifactsPin(self) -> None:
        self.setupMockRuntimeArtifactsPin("pin-version")

        pin_version = android.FindRuntimeArtifactsPin(
            self.android_package,
            self.milestone,
            self.runtime_artifacts_bucket_url,
        )
        self.assertEqual(pin_version, "pin-version")

    def testFindRuntimeArtifactsPinNotExist(self) -> None:
        self.setupMockRuntimeArtifactsPin(None)

        pin_version = android.FindRuntimeArtifactsPin(
            self.android_package,
            self.milestone,
            self.runtime_artifacts_bucket_url,
        )
        self.assertIsNone(pin_version)