Merge lp:~bjornt/python-apt/package-broken-dependency-info into lp:~mvo/python-apt/debian-sid-mirrored

[Björn Tillenius]

Add a method to get information about broken dependency in a format like
apt-get and aptitude displays, e.g.:

    package-name: Depends: missing-name but is not installable

I made the method return a list of such strings so that callsites can
construct their own error message from it. I was considering returning
objects having the necessary information, providing even more freedom to
construct your own formatting, but didn't have time to do it.

I also added an AptTestHelper object to make it easier to test the
things I wanted to test. I brought over functionality I had added to
landscape-client already, so I put it in apt.testing.py rather than in
the tests directory so that it's possible to import it in other
projects.

I also had to save/restore the apt config in the aptsources tests, since
otherwise my added tests would fail when running test_all.py.

Unmerged revisions

597. By Björn Tillenius on 2012-02-15

Save/restore apt config in tests, not to break other tests.

596. By Björn Tillenius on 2012-02-15

Document AptTestHelper.

595. By Björn Tillenius on 2012-02-15

Correct docstring.

594. By Björn Tillenius on 2012-02-15

Document tests.

593. By Björn Tillenius on 2012-02-15

Improve docstrings.

592. By Björn Tillenius on 2012-02-15

Rename method, add docstring.

591. By Björn Tillenius on 2012-02-15

Rename method.

590. By Björn Tillenius on 2012-02-15

Handle broken installed packages.

589. By Björn Tillenius on 2012-02-15

Don't include non-broken dependencies.

588. By Björn Tillenius on 2012-02-15

Add a test for multiple dependencies.

=== modified file 'apt/package.py'
--- apt/package.py	2012-01-30 14:46:34 +0000
+++ apt/package.py	2012-02-15 19:31:18 +0000
@@ -1319,6 +1319,69 @@
         """
         self._pcache._depcache.commit(fprogress, iprogress)
 
+    def _is_dependency_broken(self, dependency, dep_type):
+        """Return whether the dependency is broken.
+
+        The dependency parameter is a list of apt_pkg.Dependency objects
+        of which one needs to be satisified to be considered not broken.
+        """
+        is_negative = dep_type in ["Breaks", "Conflicts"]
+        depcache = self._pcache._depcache
+        for or_dep in dependency:
+            for target in or_dep.all_targets():
+                package = target.parent_pkg
+                if ((package.current_state == apt_pkg.CURSTATE_INSTALLED
+                     or depcache.marked_install(package))
+                    and not depcache.marked_delete(package)):
+                    return is_negative
+        return not is_negative
+
+    def _get_broken_dependency_relation_info(self, dep_relation):
+        """Return a string representation of a specific dependency relation.
+
+        The dep_relation parameter is an apt_pkg.Dependency object.
+        """
+        info = dep_relation.target_pkg.name
+        if dep_relation.target_ver:
+            info += " (%s %s)" % (
+                dep_relation.comp_type, dep_relation.target_ver)
+        reason = " but is not installable"
+        if (dep_relation.target_pkg and
+                dep_relation.target_pkg.name in self._pcache):
+            dep_package = self._pcache[dep_relation.target_pkg.name]
+            if dep_package.installed or dep_package.marked_install:
+                version = dep_package.candidate.version
+                if dep_package not in self._pcache.get_changes():
+                    version = dep_package.installed.version
+                reason = " but %s is to be installed" % version
+        info += reason
+        return info
+
+    def get_broken_dependency_info(self):
+        """Get information about the broken dependencies for this package
+
+        It returns a list of strings similar to the ones apt-get and
+        aptitude display (e.g. "package-name: Depends: missing-package
+        but is not installable") for each dependency that isn't satisfied.
+
+        Pre-Depends, Depends, Conflicts and Breaks dependencies are checked.
+        """
+        broken_info = []
+        for dep_type in ["PreDepends", "Depends", "Conflicts", "Breaks"]:
+            target = self.installed or self.candidate
+            dependencies = target._cand.depends_list.get(dep_type, [])
+            for dependency in dependencies:
+                if not self._is_dependency_broken(dependency, dep_type):
+                    continue
+                relation_infos = []
+                for relation in dependency:
+                    relation_infos.append(
+                        self._get_broken_dependency_relation_info(relation))
+                info = "%s: %s: " % (self.name, dep_type)
+                or_divider = " or\n" + " " * len(info)
+                broken_info.append(info + or_divider.join(relation_infos))
+        return broken_info
+
 
     if not apt_pkg._COMPAT_0_7:
         del installedVersion
 
=== added file 'apt/testing.py'
--- apt/testing.py	1970-01-01 00:00:00 +0000
+++ apt/testing.py	2012-02-15 19:31:18 +0000
@@ -0,0 +1,167 @@
+# Copyright (C) 2012 Canonical Ltd.
+#
+# Authors:
+#  Bjorn Tillenius <[e-mail]>
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License as
+#  published by the Free Software Foundation; either version 2 of the
+#  License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+"""Classes and methods useful for testing."""
+
+import os
+import shutil
+import tempfile
+import textwrap
+
+import apt
+import apt_pkg
+
+
+class AptTestHelper(object):
+    """A helper object to test apt functionality.
+
+    An apt.Cache with a tempdir as the root is available in the cache
+    attribute after set_up() has been called. Call tear_down() to clean
+    up when testing is done.
+    """
+
+    def set_up(self):
+        """Set up the helper object.
+
+        An apt.Cache is created with a tempdir as the root.
+
+        The apt config is also stored so that it can be restored later.
+        """
+        # reset any config manipulations done in the individual tests
+        apt_pkg.init_config()
+        # save/restore the apt config
+        self._cnf = {}
+        for item in apt_pkg.config.keys():
+            self._cnf[item] = apt_pkg.config.find(item)
+        self.apt_root = tempfile.mkdtemp()
+        self._ensure_dir_structure()
+        self.cache = apt.Cache(rootdir=self.apt_root)
+        self.repo = None
+
+    def tear_down(self):
+        """Clean up what the helper object created.
+
+        All created tempdirs are removed and the apt config is restored.
+        """
+        shutil.rmtree(self.apt_root)
+        if self.repo is not None:
+            shutil.rmtree(self.repo)
+        for item in self._cnf:
+            apt_pkg.config.set(item, self._cnf[item])
+
+    def _ensure_dir_structure(self):
+        """Ensure that all directores and files apt.Cache needs are there."""
+        self._ensure_sub_dir("etc/apt")
+        self._ensure_sub_dir("etc/apt/sources.list.d")
+        self._ensure_sub_dir("var/cache/apt/archives/partial")
+        self._ensure_sub_dir("var/lib/apt/lists/partial")
+        dpkg_dir = self._ensure_sub_dir("var/lib/dpkg")
+        self._ensure_sub_dir("var/lib/dpkg/info")
+        self._ensure_sub_dir("var/lib/dpkg/updates")
+        self._ensure_sub_dir("var/lib/dpkg/triggers")
+        self.dpkg_status = os.path.join(dpkg_dir, "status")
+        self._ensure_file(os.path.join(dpkg_dir, "available"))
+        self._ensure_file(self.dpkg_status)
+
+    def _ensure_sub_dir(self, sub_dir):
+        """Ensure that a dir in the Apt root exists."""
+        full_path = os.path.join(self.apt_root, sub_dir)
+        if not os.path.exists(full_path):
+            os.makedirs(full_path)
+        return full_path
+
+    def _ensure_file(self, file_path):
+        """Ensure that a file in the Apt root exists."""
+        if os.path.exists(file_path):
+            return
+        with open(file_path, "w") as empty_file:
+            empty_file.write("")
+
+    def _ensure_repo(self):
+        """Ensure that the internal deb-dir repository exists."""
+        if self.repo is not None:
+            return
+        self.repo = tempfile.mkdtemp()
+        sources_dir = apt_pkg.config.find_dir("Dir::Etc::sourceparts")
+        self.sources_file_path = os.path.join(
+            sources_dir, "apt-test-helper.list")
+        sources_line = "deb file://%s ./" % self.repo
+        with open(self.sources_file_path, "w") as sources_file:
+            sources_file.write(sources_line + "\n")
+
+
+    def add_package(self, packages_filepath, name, architecture="all",
+                     version="1.0", control_fields=None):
+        """Add package information to a Packages file.
+
+        A package stanza is added with all required values needed for
+        Apt to parse it. Individual fields can be overrided by passing a
+        dict as the control_fields parameter. Only package information
+        will be added to the Packages file, there won't be an actual
+        package in the dir.
+        """
+        if control_fields is None:
+            control_fields = {}
+        package_stanza = textwrap.dedent("""
+                Package: %(name)s
+                Priority: optional
+                Section: misc
+                Installed-Size: 1234
+                Maintainer: Someone
+                Architecture: %(architecture)s
+                Source: source
+                Version: %(version)s
+                Description: description
+                """ % {"name": name, "version": version,
+                       "architecture": architecture})
+        package_stanza = apt_pkg.rewrite_section(
+            apt_pkg.TagSection(package_stanza), apt_pkg.REWRITE_PACKAGE_ORDER,
+            control_fields.items())
+        with open(packages_filepath, "a") as packages_file:
+            packages_file.write("\n" + package_stanza + "\n")
+
+    def add_installed_package(self, name, architecture="all", version="1.0",
+                              control_fields=None):
+        """Add a package to the dpkg status file.
+
+        See add_package() for more information.
+        """
+        system_control_fields = {"Status": "install ok installed"}
+        if control_fields is not None:
+            system_control_fields.update(control_fields)
+        self.add_package(
+            self.dpkg_status, name, architecture=architecture, version=version,
+            control_fields=system_control_fields)
+
+    def add_available_package(self, name, architecture="all",
+                                version="1.0", control_fields=None):
+        """Add a package to the internal deb-dir repo.
+
+        See add_package() for more information.
+        """
+        self._ensure_repo()
+        self.add_package(
+            os.path.join(self.repo, "Packages"), name,
+            architecture=architecture,
+            version=version, control_fields=control_fields)
+
+    def update(self):
+        """Update the cache and make it ready to use."""
+        self.cache.open(None)
+        self.cache.update()
+        self.cache.open(None)
 
=== modified file 'tests/test_aptsources.py'
--- tests/test_aptsources.py	2011-10-19 15:40:03 +0000
+++ tests/test_aptsources.py	2012-02-15 19:31:18 +0000
@@ -14,6 +14,10 @@
 
     def setUp(self):
         apt_pkg.init_config()
+        # save/restore the apt config
+        self._cnf = {}
+        for item in apt_pkg.config.keys():
+            self._cnf[item] = apt_pkg.config.find(item)
         apt_pkg.init_system()
         if apt_pkg.config["APT::Architecture"] not in ('i386', 'amd64'):
             apt_pkg.config.set("APT::Architecture", "i386")
@@ -26,6 +30,10 @@
         else:
             self.templates = "/usr/share/python-apt/templates/"
 
+    def tearDown(self):
+        for item in self._cnf:
+            apt_pkg.config.set(item, self._cnf[item])
+
     def testIsMirror(self):
         """aptsources: Test mirror detection."""
         yes = aptsources.sourceslist.is_mirror("http://archive.ubuntu.com",
 
=== modified file 'tests/test_aptsources_ports.py'
--- tests/test_aptsources_ports.py	2011-07-29 17:17:06 +0000
+++ tests/test_aptsources_ports.py	2012-02-15 19:31:18 +0000
@@ -13,6 +13,10 @@
 
     def setUp(self):
         apt_pkg.init_config()
+        # save/restore the apt config
+        self._cnf = {}
+        for item in apt_pkg.config.keys():
+            self._cnf[item] = apt_pkg.config.find(item)
         apt_pkg.init_system()
         apt_pkg.config.set("APT::Architecture", "powerpc")
         apt_pkg.config.set("Dir::Etc",
@@ -23,6 +27,10 @@
         else:
             self.templates = "/usr/share/python-apt/templates/"
 
+    def tearDown(self):
+        for item in self._cnf:
+            apt_pkg.config.set(item, self._cnf[item])
+
     def testMatcher(self):
         """aptsources_ports: Test matcher."""
         apt_pkg.config.set("Dir::Etc::sourcelist", "sources.list")
 
=== added file 'tests/test_package.py'
--- tests/test_package.py	1970-01-01 00:00:00 +0000
+++ tests/test_package.py	2012-02-15 19:31:18 +0000
@@ -0,0 +1,319 @@
+#!/usr/bin/python
+#
+# Copyright (C) 2012 Canonical Ltd.
+#
+# Copying and distribution of this file, with or without modification,
+# are permitted in any medium without royalty provided the copyright
+# notice and this notice are preserved.
+"""Unit tests for the apt.package.Package class."""
+
+import unittest
+
+from test_all import get_library_dir
+import sys
+sys.path.insert(0, get_library_dir())
+
+from apt.testing import AptTestHelper
+
+
+class TestPackageBrokenDependenyInfo(unittest.TestCase):
+    """Tests for getting info about broken dependencies for a package."""
+
+    def setUp(self):
+        self.helper = AptTestHelper()
+        self.helper.set_up()
+        self.cache = self.helper.cache
+
+    def tearDown(self):
+        self.helper.tear_down()
+
+    def test_not_broken(self):
+        """An empty list is returned for packages that aren't broken."""
+        self.helper.add_installed_package("not-broken")
+        self.helper.update()
+        not_broken = self.cache["not-broken"]
+        self.assertFalse(not_broken.is_inst_broken)
+        self.assertEqual([], not_broken.get_broken_dependency_info())
+
+    def test_broken_depends(self):
+        """Broken Depends relations are reported."""
+        self.helper.add_installed_package(
+            "broken-depends", control_fields={"Depends": "missing"})
+        self.helper.update()
+        broken_depends = self.cache["broken-depends"]
+        self.assertTrue(broken_depends.is_inst_broken)
+        self.assertEqual(
+            ["broken-depends: Depends: missing but is not installable"],
+            broken_depends.get_broken_dependency_info())
+
+    def test_broken_predepends(self):
+        """Broken Pre-Depends relations are reported."""
+        self.helper.add_installed_package(
+            "broken-predepends", control_fields={"Pre-Depends": "missing"})
+        self.helper.update()
+        broken_predepends = self.cache["broken-predepends"]
+        self.assertTrue(broken_predepends.is_inst_broken)
+        self.assertEqual(
+            ["broken-predepends: PreDepends: missing but is not installable"],
+            broken_predepends.get_broken_dependency_info())
+
+    def test_broken_conflicts(self):
+        """Broken Conflicts relations are reported."""
+        self.helper.add_installed_package("conflict")
+        self.helper.add_available_package(
+            "broken-conflicts", control_fields={"Conflicts": "conflict"})
+        self.helper.update()
+        broken_conflicts = self.cache["broken-conflicts"]
+        conflict = self.cache["conflict"]
+        broken_conflicts.mark_install(auto_fix=False)
+        conflict.mark_keep()
+        self.assertTrue(broken_conflicts.is_inst_broken)
+        self.assertEqual(
+            ["broken-conflicts: Conflicts: conflict but 1.0 is to be installed"],
+            broken_conflicts.get_broken_dependency_info())
+
+    def test_broken_breaks(self):
+        """Broken Breaks relations are reported."""
+        self.helper.add_installed_package("breakage")
+        self.helper.add_available_package(
+            "broken-breaks", control_fields={"Breaks": "breakage"})
+        self.helper.update()
+        broken_breaks = self.cache["broken-breaks"]
+        breakage = self.cache["breakage"]
+        broken_breaks.mark_install(auto_fix=False)
+        breakage.mark_keep()
+        self.assertTrue(broken_breaks.is_inst_broken)
+        self.assertEqual(
+            ["broken-breaks: Breaks: breakage but 1.0 is to be installed"],
+            broken_breaks.get_broken_dependency_info())
+
+    def test_broken_with_version(self):
+        """
+        If a broken dependency includes a version relation, it's
+        included in the error information about the broken dependencies.
+        """
+        self.helper.add_installed_package(
+            "broken-ver", control_fields={"Depends": "missing (>= 1.0)"})
+        self.helper.update()
+        broken_ver = self.cache["broken-ver"]
+        self.assertTrue(broken_ver.is_inst_broken)
+        self.assertEqual(
+            ["broken-ver: Depends: missing (>= 1.0) but is not installable"],
+            broken_ver.get_broken_dependency_info())
+
+    def test_broken_marked_install(self):
+        """
+        If a broken package is being installed the dependencies of the
+        candidate version is used when looking for broken dependencies.
+        """
+        self.helper.add_available_package(
+            "broken", version="1.0", control_fields={"Depends": "missing1"})
+        self.helper.add_available_package(
+            "broken", version="2.0", control_fields={"Depends": "missing2"})
+        self.helper.add_available_package(
+            "broken", version="3.0", control_fields={"Depends": "missing3"})
+        self.helper.update()
+        broken = self.cache["broken"]
+        broken.candidate = sorted(broken.versions)[1]
+        broken.mark_install(auto_fix=False)
+        self.assertTrue(broken.is_inst_broken)
+        self.assertEqual(
+            ["broken: Depends: missing2 but is not installable"],
+            broken.get_broken_dependency_info())
+
+    def test_broken_installed(self):
+        """
+        If a broken package is installed the dependencies of the
+        installed version is used when looking for broken dependencies.
+        """
+        self.helper.add_installed_package(
+            "broken", version="1.0", control_fields={"Depends": "missing1"})
+        self.helper.add_available_package(
+            "broken", version="2.0", control_fields={"Depends": "missing2"})
+        self.helper.update()
+        broken = self.cache["broken"]
+        self.assertTrue(broken.is_inst_broken)
+        self.assertEqual(
+            ["broken: Depends: missing1 but is not installable"],
+            broken.get_broken_dependency_info())
+
+    def test_broken_with_dep_marked_install(self):
+        """
+        If a broken dependency is being installed (but still doesn't
+        meet the version requirements), the version being installed is
+        included in the error information about the broken dependency.
+        """
+        self.helper.add_installed_package(
+            "broken", control_fields={"Depends": "missing (>= 2.0)"})
+        self.helper.add_available_package("missing", version="1.0")
+        self.helper.update()
+        broken = self.cache["broken"]
+        missing = self.cache["missing"]
+        missing.mark_install(auto_fix=False)
+        self.assertTrue(broken.is_inst_broken)
+        self.assertEqual(
+            ["broken: Depends: missing (>= 2.0) but 1.0 is to be installed"],
+            broken.get_broken_dependency_info())
+
+    def test_broken_with_dep_installed(self):
+        """
+        If an unmet dependency is already installed (but still doesn't
+        meet the version requirements), the version that is installed is
+        included in the error information about the broken dependency.
+        """
+        self.helper.add_available_package(
+            "broken", control_fields={"Depends": "missing (>= 2.0)"})
+        self.helper.add_installed_package("missing", version="1.0")
+        self.helper.update()
+        broken = self.cache["broken"]
+        broken.mark_install(auto_fix=False)
+        self.assertTrue(broken.is_inst_broken)
+        self.assertEqual(
+            ["broken: Depends: missing (>= 2.0) but 1.0 is to be installed"],
+            broken.get_broken_dependency_info())
+
+    def test_broken_with_dep_upgraded(self):
+        """
+        If a broken dependency is being upgraded (but still doesn't meet
+        the version requirements), the version that it is upgraded to is
+        included in the error information about the broken dependeny.
+        """
+        self.helper.add_available_package(
+            "broken", control_fields={"Depends": "missing (>= 3.0)"})
+        self.helper.add_installed_package("missing", version="1.0")
+        self.helper.add_available_package("missing", version="2.0")
+        self.helper.update()
+        broken = self.cache["broken"]
+        broken.mark_install(auto_fix=False)
+        missing = self.cache["missing"]
+        missing.mark_install(auto_fix=False)
+        self.assertTrue(broken.is_inst_broken)
+        self.assertEqual(
+            ["broken: Depends: missing (>= 3.0) but 2.0 is to be installed"],
+            broken.get_broken_dependency_info())
+
+    def test_broken_with_dep_downgraded(self):
+        """
+        If a broken dependency is being downgraded (but still doesn't meet
+        the version requirements), the version that it is downgraded to is
+        included in the error information about the broken dependency.
+        """
+        self.helper.add_installed_package(
+            "broken", control_fields={"Depends": "missing (>= 3.0)"})
+        self.helper.add_installed_package("missing", version="2.0")
+        self.helper.add_available_package("missing", version="1.0")
+        self.helper.update()
+        broken = self.cache["broken"]
+        missing = self.cache["missing"]
+        missing.candidate = sorted(missing.versions)[0]
+        missing.mark_install(auto_fix=False)
+        self.assertTrue(broken.is_inst_broken)
+        self.assertEqual(
+            ["broken: Depends: missing (>= 3.0) but 1.0 is to be installed"],
+            broken.get_broken_dependency_info())
+
+    def test_broken_with_or_deps(self):
+        """
+        If a broken dependency includes an or relation, all of the
+        possible options are included in the error information about the
+        broken dependency.
+        """
+        self.helper.add_installed_package(
+            "broken",
+            control_fields={"Depends": "missing1 | missing2 (>= 1.0)"})
+        self.helper.update()
+        broken = self.cache["broken"]
+        self.assertTrue(broken.is_inst_broken)
+        self.assertEqual(
+            ["broken: Depends: missing1 but is not installable or\n" +
+             "                 missing2 (>= 1.0) but is not installable"],
+            broken.get_broken_dependency_info())
+
+    def test_broken_with_multiple(self):
+        """
+        If a package has multiple broken dependencies, all of the
+        broken ones are included in the error information about the
+        broken dependency.
+        """
+        self.helper.add_installed_package(
+            "broken",
+            control_fields={"Depends": "missing1, missing2"})
+        self.helper.update()
+        broken = self.cache["broken"]
+        self.assertTrue(broken.is_inst_broken)
+        self.assertEqual(
+            ["broken: Depends: missing1 but is not installable",
+             "broken: Depends: missing2 but is not installable"],
+            broken.get_broken_dependency_info())
+
+    def test_broken_with_conflicts_not_installed(self):
+        """
+        If a broken package conflicts or breaks a package that isn't
+        installed or marked for installation, information about that
+        conflict isn't included in the error information about broken
+        dependency.
+        """
+        self.helper.add_installed_package("needed")
+        self.helper.add_available_package(
+            "broken",
+            control_fields={"Conflicts": "needed, not-installed",
+                            "Breaks": "needed, not-installed"})
+        self.helper.add_available_package("not-installed")
+        self.helper.update()
+        broken = self.cache["broken"]
+        broken.mark_install(auto_fix=False)
+        needed = self.cache["needed"]
+        needed.mark_keep()
+        self.assertTrue(broken.is_inst_broken)
+        self.assertEqual(
+            ["broken: Conflicts: needed but 1.0 is to be installed",
+             "broken: Breaks: needed but 1.0 is to be installed"],
+            broken.get_broken_dependency_info())
+
+    def test_get_unmet_dependency_info_with_conflicts_marked_delete(self):
+        """
+        If a broken package conflicts or breaks an installed package
+        that is marekd for removal, information about that conflict
+        isn't included in the error information about broken dependency.
+        """
+        self.helper.add_installed_package("needed")
+        self.helper.add_available_package(
+            "broken",
+            control_fields={"Conflicts": "needed, not-installed",
+                            "Breaks": "needed, not-installed"})
+        self.helper.add_installed_package("removed")
+        self.helper.update()
+        removed = self.cache["removed"]
+        removed.mark_delete(auto_fix=False)
+        broken = self.cache["broken"]
+        broken.mark_install(auto_fix=False)
+        needed = self.cache["needed"]
+        needed.mark_keep()
+        self.assertTrue(broken.is_inst_broken)
+        self.assertEqual(
+            ["broken: Conflicts: needed but 1.0 is to be installed",
+             "broken: Breaks: needed but 1.0 is to be installed"],
+            broken.get_broken_dependency_info())
+
+    def test_get_unmet_dependency_info_only_unmet(self):
+        """
+        If a broken package has some dependencies that are being
+        fulfilled, those aren't included in the error information from
+        C{_get_unmet_dependency_info}.
+        """
+        self.helper.add_installed_package("there1")
+        self.helper.add_installed_package("there2")
+        self.helper.add_available_package(
+            "broken",
+            control_fields={"Depends": "there1, missing1, there2 | missing2"})
+        self.helper.update()
+        broken = self.cache["broken"]
+        broken.mark_install(auto_fix=False)
+        self.assertTrue(broken.is_inst_broken)
+        self.assertEqual(
+            ["broken: Depends: missing1 but is not installable"],
+            broken.get_broken_dependency_info())
+
+
+if __name__ == "__main__":
+    unittest.main()