From 4e995cc13f3dcbfbd6ae72890469125bafca3e94 Mon Sep 17 00:00:00 2001 From: Chris PeBenito Date: Fri, 1 Aug 2014 10:52:17 -0400 Subject: [PATCH] Convert unit tests over to assertListEqual where possible. 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. --- tests/boolquery.py | 33 +++++------------- tests/dta.py | 12 +++---- tests/infoflow.py | 82 ++++++++++++++++++++++---------------------- tests/polcapquery.py | 26 ++++---------- tests/rolequery.py | 48 +++++++------------------- tests/typequery.py | 77 ++++++++++------------------------------- tests/userquery.py | 56 ++++++++---------------------- 7 files changed, 109 insertions(+), 225 deletions(-) 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)