diff --git a/tests/boolquery.py b/tests/boolquery.py
index a24d73c..318d006 100644
--- a/tests/boolquery.py
+++ b/tests/boolquery.py
@@ -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)
diff --git a/tests/dta.py b/tests/dta.py
index f9ae34c..9a885c4 100644
--- a/tests/dta.py
+++ b/tests/dta.py
@@ -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."""
diff --git a/tests/infoflow.py b/tests/infoflow.py
index d5fe49a..fd538c1 100644
--- a/tests/infoflow.py
+++ b/tests/infoflow.py
@@ -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)
diff --git a/tests/polcapquery.py b/tests/polcapquery.py
index 5bba206..a274e1d 100644
--- a/tests/polcapquery.py
+++ b/tests/polcapquery.py
@@ -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)
diff --git a/tests/rolequery.py b/tests/rolequery.py
index 608b87f..fcf6d52 100644
--- a/tests/rolequery.py
+++ b/tests/rolequery.py
@@ -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)
diff --git a/tests/typequery.py b/tests/typequery.py
index 1fbabc0..c3d32a3 100644
--- a/tests/typequery.py
+++ b/tests/typequery.py
@@ -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)
diff --git a/tests/userquery.py b/tests/userquery.py
index 5b669ea..588f958 100644
--- a/tests/userquery.py
+++ b/tests/userquery.py
@@ -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)