cpython/Lib/packaging/tests/test_depgraph.py

311 lines
11 KiB
Python

"""Tests for packaging.depgraph """
import os
import re
import sys
from io import StringIO
from packaging import depgraph
from packaging.database import get_distribution, enable_cache, disable_cache
from packaging.tests import unittest, support
from packaging.tests.support import requires_zlib
class DepGraphTestCase(support.LoggingCatcher,
unittest.TestCase):
DISTROS_DIST = ('choxie', 'grammar', 'towel-stuff')
DISTROS_EGG = ('bacon', 'banana', 'strawberry', 'cheese')
BAD_EGGS = ('nut',)
EDGE = re.compile(
r'"(?P<from>.*)" -> "(?P<to>.*)" \[label="(?P<label>.*)"\]')
def checkLists(self, l1, l2):
""" Compare two lists without taking the order into consideration """
self.assertListEqual(sorted(l1), sorted(l2))
def setUp(self):
super(DepGraphTestCase, self).setUp()
path = os.path.join(os.path.dirname(__file__), 'fake_dists')
path = os.path.abspath(path)
sys.path.insert(0, path)
self.addCleanup(sys.path.remove, path)
self.addCleanup(enable_cache)
disable_cache()
def test_generate_graph(self):
dists = []
for name in self.DISTROS_DIST:
dist = get_distribution(name)
self.assertNotEqual(dist, None)
dists.append(dist)
choxie, grammar, towel = dists
graph = depgraph.generate_graph(dists)
deps = [(x.name, y) for x, y in graph.adjacency_list[choxie]]
self.checkLists([('towel-stuff', 'towel-stuff (0.1)')], deps)
self.assertIn(choxie, graph.reverse_list[towel])
self.checkLists(graph.missing[choxie], ['nut'])
deps = [(x.name, y) for x, y in graph.adjacency_list[grammar]]
self.checkLists([], deps)
self.checkLists(graph.missing[grammar], ['truffles (>=1.2)'])
deps = [(x.name, y) for x, y in graph.adjacency_list[towel]]
self.checkLists([], deps)
self.checkLists(graph.missing[towel], ['bacon (<=0.2)'])
@requires_zlib
def test_generate_graph_egg(self):
dists = []
for name in self.DISTROS_DIST + self.DISTROS_EGG:
dist = get_distribution(name, use_egg_info=True)
self.assertNotEqual(dist, None)
dists.append(dist)
choxie, grammar, towel, bacon, banana, strawberry, cheese = dists
graph = depgraph.generate_graph(dists)
deps = [(x.name, y) for x, y in graph.adjacency_list[choxie]]
self.checkLists([('towel-stuff', 'towel-stuff (0.1)')], deps)
self.assertIn(choxie, graph.reverse_list[towel])
self.checkLists(graph.missing[choxie], ['nut'])
deps = [(x.name, y) for x, y in graph.adjacency_list[grammar]]
self.checkLists([('bacon', 'truffles (>=1.2)')], deps)
self.checkLists(graph.missing[grammar], [])
self.assertIn(grammar, graph.reverse_list[bacon])
deps = [(x.name, y) for x, y in graph.adjacency_list[towel]]
self.checkLists([('bacon', 'bacon (<=0.2)')], deps)
self.checkLists(graph.missing[towel], [])
self.assertIn(towel, graph.reverse_list[bacon])
deps = [(x.name, y) for x, y in graph.adjacency_list[bacon]]
self.checkLists([], deps)
self.checkLists(graph.missing[bacon], [])
deps = [(x.name, y) for x, y in graph.adjacency_list[banana]]
self.checkLists([('strawberry', 'strawberry (>=0.5)')], deps)
self.checkLists(graph.missing[banana], [])
self.assertIn(banana, graph.reverse_list[strawberry])
deps = [(x.name, y) for x, y in graph.adjacency_list[strawberry]]
self.checkLists([], deps)
self.checkLists(graph.missing[strawberry], [])
deps = [(x.name, y) for x, y in graph.adjacency_list[cheese]]
self.checkLists([], deps)
self.checkLists(graph.missing[cheese], [])
def test_dependent_dists(self):
dists = []
for name in self.DISTROS_DIST:
dist = get_distribution(name)
self.assertNotEqual(dist, None)
dists.append(dist)
choxie, grammar, towel = dists
deps = [d.name for d in depgraph.dependent_dists(dists, choxie)]
self.checkLists([], deps)
deps = [d.name for d in depgraph.dependent_dists(dists, grammar)]
self.checkLists([], deps)
deps = [d.name for d in depgraph.dependent_dists(dists, towel)]
self.checkLists(['choxie'], deps)
@requires_zlib
def test_dependent_dists_egg(self):
dists = []
for name in self.DISTROS_DIST + self.DISTROS_EGG:
dist = get_distribution(name, use_egg_info=True)
self.assertNotEqual(dist, None)
dists.append(dist)
choxie, grammar, towel, bacon, banana, strawberry, cheese = dists
deps = [d.name for d in depgraph.dependent_dists(dists, choxie)]
self.checkLists([], deps)
deps = [d.name for d in depgraph.dependent_dists(dists, grammar)]
self.checkLists([], deps)
deps = [d.name for d in depgraph.dependent_dists(dists, towel)]
self.checkLists(['choxie'], deps)
deps = [d.name for d in depgraph.dependent_dists(dists, bacon)]
self.checkLists(['choxie', 'towel-stuff', 'grammar'], deps)
deps = [d.name for d in depgraph.dependent_dists(dists, strawberry)]
self.checkLists(['banana'], deps)
deps = [d.name for d in depgraph.dependent_dists(dists, cheese)]
self.checkLists([], deps)
@requires_zlib
def test_graph_to_dot(self):
expected = (
('towel-stuff', 'bacon', 'bacon (<=0.2)'),
('grammar', 'bacon', 'truffles (>=1.2)'),
('choxie', 'towel-stuff', 'towel-stuff (0.1)'),
('banana', 'strawberry', 'strawberry (>=0.5)'),
)
dists = []
for name in self.DISTROS_DIST + self.DISTROS_EGG:
dist = get_distribution(name, use_egg_info=True)
self.assertNotEqual(dist, None)
dists.append(dist)
graph = depgraph.generate_graph(dists)
buf = StringIO()
depgraph.graph_to_dot(graph, buf)
buf.seek(0)
matches = []
lines = buf.readlines()
for line in lines[1:-1]: # skip the first and the last lines
if line[-1] == '\n':
line = line[:-1]
match = self.EDGE.match(line.strip())
self.assertIsNot(match, None)
matches.append(match.groups())
self.checkLists(matches, expected)
@requires_zlib
def test_graph_disconnected_to_dot(self):
dependencies_expected = (
('towel-stuff', 'bacon', 'bacon (<=0.2)'),
('grammar', 'bacon', 'truffles (>=1.2)'),
('choxie', 'towel-stuff', 'towel-stuff (0.1)'),
('banana', 'strawberry', 'strawberry (>=0.5)'),
)
disconnected_expected = ('cheese', 'bacon', 'strawberry')
dists = []
for name in self.DISTROS_DIST + self.DISTROS_EGG:
dist = get_distribution(name, use_egg_info=True)
self.assertNotEqual(dist, None)
dists.append(dist)
graph = depgraph.generate_graph(dists)
buf = StringIO()
depgraph.graph_to_dot(graph, buf, skip_disconnected=False)
buf.seek(0)
lines = buf.readlines()
dependencies_lines = []
disconnected_lines = []
# First sort output lines into dependencies and disconnected lines.
# We also skip the attribute lines, and don't include the "{" and "}"
# lines.
disconnected_active = False
for line in lines[1:-1]: # Skip first and last line
if line.startswith('subgraph disconnected'):
disconnected_active = True
continue
if line.startswith('}') and disconnected_active:
disconnected_active = False
continue
if disconnected_active:
# Skip the 'label = "Disconnected"', etc. attribute lines.
if ' = ' not in line:
disconnected_lines.append(line)
else:
dependencies_lines.append(line)
dependencies_matches = []
for line in dependencies_lines:
if line[-1] == '\n':
line = line[:-1]
match = self.EDGE.match(line.strip())
self.assertIsNot(match, None)
dependencies_matches.append(match.groups())
disconnected_matches = []
for line in disconnected_lines:
if line[-1] == '\n':
line = line[:-1]
line = line.strip('"')
disconnected_matches.append(line)
self.checkLists(dependencies_matches, dependencies_expected)
self.checkLists(disconnected_matches, disconnected_expected)
@requires_zlib
def test_graph_bad_version_to_dot(self):
expected = (
('towel-stuff', 'bacon', 'bacon (<=0.2)'),
('grammar', 'bacon', 'truffles (>=1.2)'),
('choxie', 'towel-stuff', 'towel-stuff (0.1)'),
('banana', 'strawberry', 'strawberry (>=0.5)'),
)
dists = []
for name in self.DISTROS_DIST + self.DISTROS_EGG + self.BAD_EGGS:
dist = get_distribution(name, use_egg_info=True)
self.assertNotEqual(dist, None)
dists.append(dist)
graph = depgraph.generate_graph(dists)
buf = StringIO()
depgraph.graph_to_dot(graph, buf)
buf.seek(0)
matches = []
lines = buf.readlines()
for line in lines[1:-1]: # skip the first and the last lines
if line[-1] == '\n':
line = line[:-1]
match = self.EDGE.match(line.strip())
self.assertIsNot(match, None)
matches.append(match.groups())
self.checkLists(matches, expected)
@requires_zlib
def test_repr(self):
dists = []
for name in self.DISTROS_DIST + self.DISTROS_EGG + self.BAD_EGGS:
dist = get_distribution(name, use_egg_info=True)
self.assertNotEqual(dist, None)
dists.append(dist)
graph = depgraph.generate_graph(dists)
self.assertTrue(repr(graph))
@requires_zlib
def test_main(self):
tempout = StringIO()
old = sys.stdout
sys.stdout = tempout
oldargv = sys.argv[:]
sys.argv[:] = ['script.py']
try:
try:
depgraph.main()
except SystemExit:
pass
finally:
sys.stdout = old
sys.argv[:] = oldargv
# checks what main did XXX could do more here
tempout.seek(0)
res = tempout.read()
self.assertIn('towel', res)
def test_suite():
return unittest.makeSuite(DepGraphTestCase)
if __name__ == "__main__":
unittest.main(defaultTest="test_suite")