RepoMirrors/setools
1
0
Fork 0
mirror of https://github.com/SELinuxProject/setools synced 2025-03-20 10:06:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

Convert unit tests over to assertListEqual where possible.

Browse Source 
It makes determining what's wrong easier since it has a diff-style
output.  Also put the expected list first, so the diff style makes sense.
This commit is contained in:
Chris PeBenito 2014-08-01 10:52:17 -04:00
parent 09554705c1
commit 4e995cc13f
7 changed files with 109 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
tests/boolquery.py
View File

@ -29,45 +29,30 @@ class BoolQueryTest(unittest.TestCase):
def test_000_unset(self):
"""Boolean query with no criteria."""
# query with no parameters gets all Booleans.
for numbools, b in enumerate(self.p.bools(), start=1):
pass
allbools = sorted(str(b) for b in self.p.bools())
q = BoolQuery(self.p)
for q_numbools, b in enumerate(q.results(), start=1):
pass
qbools = sorted(str(b) for b in q.results())
self.assertEqual(numbools, q_numbools)
self.assertListEqual(allbools, qbools)
def test_001_name_exact(self):
"""Boolean query with exact match"""
q = BoolQuery(self.p, name="test1")
# manually consume the generator:
bools = q.results()
b = bools.next()
self.assertEqual(b, "test1")
self.assertRaises(StopIteration, bools.next)
bools = sorted(str(b) for b in q.results())
self.assertListEqual(["test1"], bools)
def test_002_name_regex(self):
"""Boolean query with regex match."""
q = BoolQuery(self.p, name="test2(a|b)", name_regex=True)
# manually consume the generator:
b = sorted(q.results())
self.assertEqual(len(b), 2)
self.assertEqual(b[0], "test2a")
self.assertEqual(b[1], "test2b")
bools = sorted(str(b) for b in q.results())
self.assertListEqual(["test2a", "test2b"], bools)
def test_010_default(self):
"""Boolean query with default state match."""
q = BoolQuery(self.p, match_default=True, default=False)
# manually consume the generator:
b = sorted(q.results())
self.assertEqual(len(b), 2)
self.assertEqual(b[0], "test10a")
self.assertEqual(b[1], "test10b")
bools = sorted(str(b) for b in q.results())
self.assertListEqual(["test10a", "test10b"], bools)

12
tests/dta.py
View File

@ -37,12 +37,12 @@ class InfoFlowAnalysisTest(unittest.TestCase):
# removed after removing invalid domain transitions
edges = sorted(list(self.a.G.out_edges_iter()))
self.assertListEqual(edges, [("dyntrans100", "bothtrans200"),
("start", "dyntrans100"),
("start", "trans1"),
("trans1", "trans2"),
("trans2", "trans3"),
("trans3", "trans5")])
self.assertListEqual([("dyntrans100", "bothtrans200"),
("start", "dyntrans100"),
("start", "trans1"),
("trans1", "trans2"),
("trans2", "trans3"),
("trans3", "trans5")], edges)
def test_001_bothtrans(self):
"""DTA: type_transition, setexeccon(), and setcon() transitions."""

82
tests/infoflow.py
View File

@ -38,23 +38,23 @@ class InfoFlowAnalysisTest(unittest.TestCase):
a._build_graph()
nodes = sorted(list(a.G.nodes_iter()))
self.assertListEqual(nodes, ["disconnected1", "disconnected2", "node1",
"node2", "node3", "node4", "node5",
"node6", "node7", "node8", "node9"])
self.assertListEqual(["disconnected1", "disconnected2", "node1",
"node2", "node3", "node4", "node5",
"node6", "node7", "node8", "node9"], nodes)
edges = sorted(list(a.G.out_edges_iter()))
self.assertListEqual(edges, [("disconnected1", "disconnected2"),
("disconnected2", "disconnected1"),
("node1", "node2"),
("node1", "node3"),
("node2", "node4"),
("node3", "node5"),
("node4", "node6"),
("node5", "node8"),
("node6", "node5"),
("node6", "node7"),
("node8", "node9"),
("node9", "node8")])
self.assertListEqual([("disconnected1", "disconnected2"),
("disconnected2", "disconnected1"),
("node1", "node2"),
("node1", "node3"),
("node2", "node4"),
("node3", "node5"),
("node4", "node6"),
("node5", "node8"),
("node6", "node5"),
("node6", "node7"),
("node8", "node9"),
("node9", "node8")], edges)
r = a.G.edge["disconnected1"]["disconnected2"]["rules"]
self.assertEqual(len(r), 1)
@ -178,22 +178,22 @@ class InfoFlowAnalysisTest(unittest.TestCase):
a._build_graph()
nodes = sorted(list(a.G.nodes_iter()))
self.assertListEqual(nodes, ["disconnected1", "disconnected2", "node1",
"node2", "node3", "node4", "node5",
"node6", "node7", "node8", "node9"])
self.assertListEqual(["disconnected1", "disconnected2", "node1",
"node2", "node3", "node4", "node5",
"node6", "node7", "node8", "node9"], nodes)
edges = sorted(list(a.G.out_edges_iter()))
self.assertListEqual(edges, [("disconnected1", "disconnected2"),
("disconnected2", "disconnected1"),
("node1", "node2"),
("node1", "node3"),
("node2", "node4"),
("node4", "node6"),
("node5", "node8"),
("node6", "node5"),
("node6", "node7"),
("node8", "node9"),
("node9", "node8")])
self.assertListEqual([("disconnected1", "disconnected2"),
("disconnected2", "disconnected1"),
("node1", "node2"),
("node1", "node3"),
("node2", "node4"),
("node4", "node6"),
("node5", "node8"),
("node6", "node5"),
("node6", "node7"),
("node8", "node9"),
("node9", "node8")], edges)
r = a.G.edge["disconnected1"]["disconnected2"]["rules"]
self.assertEqual(len(r), 1)
@ -308,20 +308,20 @@ class InfoFlowAnalysisTest(unittest.TestCase):
a._build_graph()
nodes = sorted(list(a.G.nodes_iter()))
self.assertListEqual(nodes, ["disconnected1", "disconnected2", "node1",
"node2", "node4", "node5",
"node6", "node7", "node8", "node9"])
self.assertListEqual(["disconnected1", "disconnected2", "node1",
"node2", "node4", "node5",
"node6", "node7", "node8", "node9"], nodes)
edges = sorted(list(a.G.out_edges_iter()))
self.assertListEqual(edges, [("disconnected1", "disconnected2"),
("disconnected2", "disconnected1"),
("node1", "node2"),
("node2", "node4"),
("node4", "node6"),
("node5", "node8"),
("node6", "node7"),
("node8", "node9"),
("node9", "node8")])
self.assertListEqual([("disconnected1", "disconnected2"),
("disconnected2", "disconnected1"),
("node1", "node2"),
("node2", "node4"),
("node4", "node6"),
("node5", "node8"),
("node6", "node7"),
("node8", "node9"),
("node9", "node8")], edges)
r = a.G.edge["disconnected1"]["disconnected2"]["rules"]
self.assertEqual(len(r), 1)

26
tests/polcapquery.py
View File

@ -29,35 +29,23 @@ class PolCapQueryTest(unittest.TestCase):
def test_000_unset(self):
"""Policy capability query with no criteria"""
# query with no parameters gets all capabilities.
for numcaps, c in enumerate(self.p.polcaps(), start=1):
pass
allcaps = sorted(str(c) for c in self.p.polcaps())
q = PolCapQuery(self.p)
for q_numcaps, c in enumerate(q.results(), start=1):
pass
qcaps = sorted(str(c) for c in q.results())
self.assertEqual(numcaps, q_numcaps)
self.assertListEqual(allcaps, qcaps)
def test_001_name_exact(self):
"""Policy capability query with exact match"""
q = PolCapQuery(self.p, name="open_perms", name_regex=False)
# manually consume the generator:
caps = q.results()
c = caps.next()
self.assertEqual(c, "open_perms")
self.assertRaises(StopIteration, caps.next)
caps = sorted(str(c) for c in q.results())
self.assertListEqual(["open_perms"], caps)
def test_002_name_regex(self):
"""Policy capability query with regex match"""
q = PolCapQuery(self.p, name="pe?er", name_regex=True)
# manually consume the generator:
c = sorted(q.results())
self.assertEqual(len(c), 2)
self.assertEqual(c[0], "network_peer_controls")
self.assertEqual(c[1], "open_perms")
caps = sorted(str(c) for c in q.results())
self.assertListEqual(["network_peer_controls", "open_perms"], caps)

48
tests/rolequery.py
View File

@ -43,59 +43,35 @@ class RoleQueryTest(unittest.TestCase):
"""Role query with exact name match."""
q = RoleQuery(self.p, name="test1")
# manually consume the generator:
r = sorted(q.results())
self.assertEqual(len(r), 1)
self.assertEqual(r[0], "test1")
roles = sorted(str(r) for r in q.results())
self.assertListEqual(["test1"], roles)
def test_002_name_regex(self):
"""Role query with regex name match."""
q = RoleQuery(self.p, name="test2(a|b)", name_regex=True)
# manually consume the generator:
r = sorted(q.results())
self.assertEqual(len(r), 2)
self.assertEqual(r[0], "test2a")
self.assertEqual(r[1], "test2b")
roles = sorted(str(r) for r in q.results())
self.assertListEqual(["test2a", "test2b"], roles)
def test_010_type_intersect(self):
"""Role query with type set intersection."""
q = RoleQuery(self.p, types=["test10a", "test10b"])
# manually consume the generator:
r = sorted(q.results())
self.assertEqual(len(r), 6)
self.assertEqual(r[0], "test10r1")
self.assertEqual(r[1], "test10r2")
self.assertEqual(r[2], "test10r3")
self.assertEqual(r[3], "test10r4")
self.assertEqual(r[4], "test10r5")
self.assertEqual(r[5], "test10r6")
roles = sorted(str(r) for r in q.results())
self.assertListEqual(["test10r1", "test10r2", "test10r3",
"test10r4", "test10r5", "test10r6"], roles)
def test_011_type_equality(self):
"""Role query with type set equality."""
q = RoleQuery(self.p, types=["test11a", "test11b"], types_equal=True)
# manually consume the generator:
r = sorted(q.results())
self.assertEqual(len(r), 1)
self.assertEqual(r[0], "test11r2")
roles = sorted(str(r) for r in q.results())
self.assertListEqual(["test11r2"], roles)
def test_012_type_regex(self):
"""Role query with type set match."""
q = RoleQuery(self.p, types="test12(a|b)", types_regex=True)
# manually consume the generator:
r = sorted(q.results())
self.assertEqual(len(r), 6)
self.assertEqual(r[0], "test12r1")
self.assertEqual(r[1], "test12r2")
self.assertEqual(r[2], "test12r3")
self.assertEqual(r[3], "test12r4")
self.assertEqual(r[4], "test12r5")
self.assertEqual(r[5], "test12r6")
roles = sorted(str(r) for r in q.results())
self.assertListEqual(["test12r1", "test12r2", "test12r3",
"test12r4", "test12r5", "test12r6"], roles)

77
tests/typequery.py
View File

@ -29,99 +29,60 @@ class TypeQueryTest(unittest.TestCase):
def test_000_unset(self):
"""Type query with no criteria."""
# query with no parameters gets all types.
for numtypes, t in enumerate(self.p.types(), start=1):
pass
alltypes = sorted(str(t) for t in self.p.types())
q = TypeQuery(self.p)
for q_numtypes, t in enumerate(q.results(), start=1):
pass
qtypes = sorted(str(t) for t in q.results())
self.assertEqual(numtypes, q_numtypes)
self.assertListEqual(alltypes, qtypes)
def test_001_name_exact(self):
"""Type query with exact name match."""
q = TypeQuery(self.p, name="test1")
# manually consume the generator:
types = q.results()
t = types.next()
self.assertEqual(t, "test1")
self.assertRaises(StopIteration, types.next)
types = sorted(str(t) for t in q.results())
self.assertListEqual(["test1"], types)
def test_002_name_regex(self):
"""Type query with regex name match."""
q = TypeQuery(self.p, name="test2(a|b)", name_regex=True)
# manually consume the generator:
t = sorted(q.results())
self.assertEqual(len(t), 2)
self.assertEqual(t[0], "test2a")
self.assertEqual(t[1], "test2b")
types = sorted(str(t) for t in q.results())
self.assertListEqual(["test2a", "test2b"], types)
def test_010_attr_intersect(self):
"""Type query with attribute set intersection."""
q = TypeQuery(self.p, attrs=["test10a", "test10b"])
# manually consume the generator:
t = sorted(q.results())
self.assertEqual(len(t), 6)
self.assertEqual(t[0], "test10t1")
self.assertEqual(t[1], "test10t2")
self.assertEqual(t[2], "test10t3")
self.assertEqual(t[3], "test10t4")
self.assertEqual(t[4], "test10t5")
self.assertEqual(t[5], "test10t6")
types = sorted(str(t) for t in q.results())
self.assertListEqual(["test10t1", "test10t2", "test10t3",
"test10t4", "test10t5", "test10t6"], types)
def test_011_attr_equality(self):
"""Type query with attribute set equality."""
q = TypeQuery(self.p, attrs=["test11a", "test11b"], attrs_equal=True)
# manually consume the generator:
types = q.results()
t = types.next()
self.assertEqual(t, "test11t2")
self.assertRaises(StopIteration, types.next)
types = sorted(str(t) for t in q.results())
self.assertListEqual(["test11t2"], types)
def test_012_attr_regex(self):
"""Type query with attribute regex match."""
q = TypeQuery(self.p, attrs="test12(a|b)", attrs_regex=True)
# manually consume the generator:
t = sorted(q.results())
self.assertEqual(len(t), 6)
self.assertEqual(t[0], "test12t1")
self.assertEqual(t[1], "test12t2")
self.assertEqual(t[2], "test12t3")
self.assertEqual(t[3], "test12t4")
self.assertEqual(t[4], "test12t5")
self.assertEqual(t[5], "test12t6")
types = sorted(str(t) for t in q.results())
self.assertListEqual(["test12t1", "test12t2", "test12t3",
"test12t4", "test12t5", "test12t6"], types)
def test_020_alias_exact(self):
"""Type query with exact alias match."""
q = TypeQuery(self.p, alias="test20a")
# manually consume the generator:
types = q.results()
t = types.next()
self.assertEqual(t, "test20t1")
self.assertRaises(StopIteration, types.next)
types = sorted(str(t) for t in q.results())
self.assertListEqual(["test20t1"], types)
def test_021_alias_regex(self):
"""Type query with regex alias match."""
q = TypeQuery(self.p, alias="test21(a|b)", alias_regex=True)
# manually consume the generator:
t = sorted(q.results())
self.assertEqual(len(t), 2)
self.assertEqual(t[0], "test21t1")
self.assertEqual(t[1], "test21t2")
types = sorted(str(t) for t in q.results())
self.assertListEqual(["test21t1", "test21t2"], types)

56
tests/userquery.py
View File

@ -29,73 +29,47 @@ class UserQueryTest(unittest.TestCase):
def test_000_unset(self):
"""User query with no criteria."""
# query with no parameters gets all types.
for numusers, u in enumerate(self.p.users(), start=1):
pass
allusers = sorted(str(u) for u in self.p.users())
q = UserQuery(self.p)
for q_numusers, u in enumerate(q.results(), start=1):
pass
qusers = sorted(str(u) for u in q.results())
self.assertEqual(numusers, q_numusers)
self.assertListEqual(allusers, qusers)
def test_001_name_exact(self):
"""User query with exact name match."""
q = UserQuery(self.p, name="test1_u")
# manually consume the generator:
u = sorted(q.results())
self.assertEqual(len(u), 1)
self.assertEqual(u[0], "test1_u")
users = sorted(str(u) for u in q.results())
self.assertListEqual(["test1_u"], users)
def test_002_name_regex(self):
"""User query with regex name match."""
q = UserQuery(self.p, name="test2_u(1|2)", name_regex=True)
# manually consume the generator:
u = sorted(q.results())
self.assertEqual(len(u), 2)
self.assertEqual(u[0], "test2_u1")
self.assertEqual(u[1], "test2_u2")
users = sorted(str(u) for u in q.results())
self.assertListEqual(["test2_u1", "test2_u2"], users)
def test_010_role_intersect(self):
"""User query with role set intersection."""
q = UserQuery(self.p, roles=["test10a_r", "test10b_r"])
# manually consume the generator:
u = sorted(q.results())
self.assertEqual(len(u), 6)
self.assertEqual(u[0], "test10_u1")
self.assertEqual(u[1], "test10_u2")
self.assertEqual(u[2], "test10_u3")
self.assertEqual(u[3], "test10_u4")
self.assertEqual(u[4], "test10_u5")
self.assertEqual(u[5], "test10_u6")
users = sorted(str(u) for u in q.results())
self.assertListEqual(["test10_u1", "test10_u2", "test10_u3",
"test10_u4", "test10_u5", "test10_u6"], users)
def test_011_role_equality(self):
"""User query with role set equality."""
q = UserQuery(
self.p, roles=["test11a_r", "test11b_r"], roles_equal=True)
# manually consume the generator:
u = sorted(q.results())
self.assertEqual(len(u), 1)
self.assertEqual(u[0], "test11_u2")
users = sorted(str(u) for u in q.results())
self.assertListEqual(["test11_u2"], users)
def test_012_role_regex(self):
"""User query with role regex match."""
q = UserQuery(self.p, roles="test12(a|b)_r", roles_regex=True)
# manually consume the generator:
u = sorted(q.results())
self.assertEqual(len(u), 6)
self.assertEqual(u[0], "test12_u1")
self.assertEqual(u[1], "test12_u2")
self.assertEqual(u[2], "test12_u3")
self.assertEqual(u[3], "test12_u4")
self.assertEqual(u[4], "test12_u5")
self.assertEqual(u[5], "test12_u6")
users = sorted(str(u) for u in q.results())
self.assertListEqual(["test12_u1", "test12_u2", "test12_u3",
"test12_u4", "test12_u5", "test12_u6"], users)