Add simple tests for get_installation_order()

The implementation is improved a bit to make the sorting result more
predictable for easier testing.

src/pip/_internal/resolution/resolvelib/resolver.py

+import functools
+
+from pip._vendor.packaging.utils import canonicalize_name
 from pip._vendor.resolvelib import BaseReporter
 from pip._vendor.resolvelib import Resolver as RLResolver
 
@@ -90,7 +93,7 @@ class Resolver(BaseResolver):
         The current implementation walks the resolved dependency graph, and
         make sure every node has a greater "weight" than all its parents.
         """
-        assert self._result is not None
+        assert self._result is not None, "must call resolve() first"
         weights = {None: 0}  # type: Dict[Optional[str], int]
 
         graph = self._result.graph
@@ -112,7 +115,22 @@ class Resolver(BaseResolver):
 
         sorted_items = sorted(
             req_set.requirements.items(),
-            key=lambda item: weights[item[0]],
+            key=functools.partial(_req_set_item_sorter, weights=weights),
             reverse=True,
         )
         return [ireq for _, ireq in sorted_items]
+
+
+def _req_set_item_sorter(
+    item,     # type: Tuple[str, InstallRequirement]
+    weights,  # type: Dict[Optional[str], int]
+):
+    # type: (...) -> Tuple[int, str]
+    """Key function used to sort install requirements for installation.
+
+    Based on the "weight" mapping calculated in ``get_installation_order()``.
+    The canonical package name is returned as the second member as a tie-
+    breaker to ensure the result is predictable, which is useful in tests.
+    """
+    name = canonicalize_name(item[0])
+    return weights[name], name

tests/unit/resolution_resolvelib/test_resolver.py

+import mock
+import pytest
+from pip._vendor.packaging.utils import canonicalize_name
+from pip._vendor.resolvelib.resolvers import Result
+from pip._vendor.resolvelib.structs import DirectedGraph
+
+from pip._internal.req.constructors import install_req_from_line
+from pip._internal.req.req_set import RequirementSet
+from pip._internal.resolution.resolvelib.resolver import Resolver
+
+
+@pytest.fixture()
+def resolver(preparer, finder):
+    resolver = Resolver(
+        preparer=preparer,
+        finder=finder,
+        make_install_req=mock.Mock(),
+        use_user_site="not-used",
+        ignore_dependencies="not-used",
+        ignore_installed="not-used",
+        ignore_requires_python="not-used",
+        force_reinstall="not-used",
+        upgrade_strategy="not-used",
+    )
+    return resolver
+
+
+@pytest.mark.parametrize(
+    "edges, ordered_reqs",
+    [
+        (
+            [(None, "require-simple"), ("require-simple", "simple")],
+            ["simple==3.0", "require-simple==1.0"],
+        ),
+        (
+            [(None, "meta"), ("meta", "simple"), ("meta", "simple2")],
+            ["simple2==3.0", "simple==3.0", "meta==1.0"],
+        ),
+        (
+            [
+                (None, "toporequires"),
+                (None, "toporequire2"),
+                (None, "toporequire3"),
+                (None, "toporequire4"),
+                ("toporequires2", "toporequires"),
+                ("toporequires3", "toporequires"),
+                ("toporequires4", "toporequires"),
+                ("toporequires4", "toporequires2"),
+                ("toporequires4", "toporequires3"),
+            ],
+            [
+                "toporequires==0.0.1",
+                "toporequires3==0.0.1",
+                "toporequires2==0.0.1",
+                "toporequires4==0.0.1",
+            ],
+        ),
+    ],
+)
+def test_rlr_resolver_get_installation_order(resolver, edges, ordered_reqs):
+    # Build graph from edge declarations.
+    graph = DirectedGraph()
+    for parent, child in edges:
+        parent = canonicalize_name(parent) if parent else None
+        child = canonicalize_name(child) if child else None
+        for v in (parent, child):
+            if v not in graph:
+                graph.add(v)
+        graph.connect(parent, child)
+
+    # Mapping values and criteria are not used in test, so we stub them out.
+    mapping = {vertex: None for vertex in graph if vertex is not None}
+    resolver._result = Result(mapping, graph, criteria=None)
+
+    reqset = RequirementSet()
+    for r in ordered_reqs:
+        reqset.add_named_requirement(install_req_from_line(r))
+
+    ireqs = resolver.get_installation_order(reqset)
+    req_strs = [str(r.req) for r in ireqs]
+    assert req_strs == ordered_reqs