def testFilter(self):
self.assertValuesEqual(
solve.solve(
q.Query("select * from Process where (pid == 1)"), {
"Process":
repeated.meld(mocks.Process(2, None, None),
mocks.Process(1, None, None))
}).value, mocks.Process(1, None, None))
def testEach(self):
self.assertFalse(
solve.solve(
q.Query("each(Process.parent, (pid == 1))"), {
"Process": {
"parent":
repeated.meld(mocks.Process(1, None, None),
mocks.Process(2, None, None))
}
}).value)
def testEquivalence(self):
self.assertTrue(
solve.solve(q.Query("pid == 1"), mocks.Process(1, None,
None)).value)
# repeated elements are expanded in the usual way.
self.assertTrue(
solve.solve(q.Query("[1] == 1"), mocks.Process(1, None,
None)).value)
# Same as [1,2] == [1, None]
self.assertFalse(
solve.solve(q.Query("[1, 2] == [1]"), mocks.Process(1, None,
None)).value)
def testProduct(self):
# Multiplying a constant to a list, adds it to each element.
query = q.Query(
"SELECT ages * 10 as x FROM (bind('ages': [10, 20, 30]))")
value = list(solve.solve(query, {}).value)
x = structured.resolve(value[0], "x")
self.assertEqual(x, [100, 200, 300])
# Multiplying a constant to a list, multiply each element.
query = q.Query(
"10 * (SELECT age FROM (bind('age': 10), bind('age': 20)))")
value = list(solve.solve(query, {}).value)
self.assertEqual(value, [100, 200])
# Multiplying two subselects multiplies each element.
query = q.Query(
"""(SELECT age FROM (bind('age': 10), bind('age': 20))) *
(SELECT age FROM (bind('age': 20), bind('age': 30)))
""")
value = list(solve.solve(query, {}).value)
self.assertEqual(value, [200, 600])
self.assertEqual(
solve.solve(q.Query("5 * 5 * 5"),
mocks.Process(1, None, None)).value, [125])
def testSum(self):
# Adding a constant to a list, adds it to each element.
query = q.Query(
"SELECT ages + 10 as sum FROM (bind('ages': [10, 20, 30]))")
value = list(solve.solve(query, {}).value)
sum = structured.resolve(value[0], "sum")
self.assertEqual(sum, [20, 30, 40])
# Adding a list to a list, pads the short list with zeros.
query = q.Query(
"SELECT ages + [10, 20] as sum FROM (bind('ages': [10, 20, 30]))")
value = list(solve.solve(query, {}).value)
sum = structured.resolve(value[0], "sum")
self.assertEqual(sum, [20, 40, 30])
# Repeated integers add item by item to the
query = q.Query(
"[5, 1, 2] + 10 + SELECT age FROM"
" (bind('age': 10, 'name': 'Tom'), bind('age': 8, 'name': 'Jerry'))"
" WHERE name == 'Jerry'")
self.assertEqual(solve.solve(query, {}).value, [23, 11, 12])
self.assertEqual(
solve.solve(q.Query("5 + 15 + 25"),
mocks.Process(1, None, None)).value, [45])
def testAny(self):
self.assertTrue(
solve.solve(
q.Query("any Process.parent where (pid == 1)"), {
"Process": {
"parent":
repeated.meld(mocks.Process(1, None, None),
mocks.Process(2, None, None))
}
}).value)
# Test that unary ANY works as expected.
query = q.Query(ast.Any(ast.Var("x")))
self.assertFalse(solve.solve(query, {"x": None}).value)
self.assertTrue(solve.solve(query, {"x": 1}).value)
self.assertTrue(
solve.solve(query, {
"x": repeated.meld(1, 2, 3)
}).value)
def testQuotient(self):
self.assertEqual(
solve.solve(q.Query("10.0 / 4"), mocks.Process(1, None,
None)).value, [2.5])
def testUnion(self):
self.assertTrue(
solve.solve(q.Query("pid or not pid"),
mocks.Process(1, None, None)).value)
def testSum(self):
self.assertEqual(
solve.solve(q.Query("pid + 10 + 20"),
mocks.Process(1, None, None)).value, 31)
def testPartialOrderedSet(self):
self.assertTrue(
solve.solve(q.Query("pid >= 2"), mocks.Process(2, None,
None)).value)
def testSort(self):
self.assertEqual(
solve.solve(
q.Query("select * from Process order by pid"), {
"Process":
repeated.meld(mocks.Process(2, None, None),
mocks.Process(1, None, None))
}).value,
repeated.meld(mocks.Process(1, None, None),
mocks.Process(2, None, None)))
# How about nested repeated fields? This should sort the process
# children and return those.
self.assertEqual(
solve.solve(
q.Query("select * from Process.children order by pid"), {
"Process": {
"children":
repeated.meld(mocks.Process(2, None, None),
mocks.Process(1, None, None))
}
}).value,
repeated.meld(mocks.Process(1, None, None),
mocks.Process(2, None, None)))
# Sorting BY a repeated expression should be the same as sorting by
# a tuple.
self.assertValuesEqual(
solve.solve(
q.Query("select name, surname from people order by "
"[lower(surname), lower(name)]"), {
"people": [
{
"name": "John",
"surname": "Smith"
},
{
"name": "John",
"surname": "Brown"
},
{
"name": "John",
"surname": "Lennon"
},
{
"name": "Alice",
"surname": "Brown"
},
]
}).value,
repeated.meld(
{
"name": "Alice",
"surname": "Brown"
},
{
"name": "John",
"surname": "Brown"
},
{
"name": "John",
"surname": "Lennon"
},
{
"name": "John",
"surname": "Smith"
},
))
self.assertValuesEqual(
solve.solve(
q.Query("select name, surname from people order by "
"(lower(surname), lower(name))"), {
"people": [
{
"name": "John",
"surname": "Smith"
},
{
"name": "John",
"surname": "Brown"
},
{
"name": "John",
"surname": "Lennon"
},
{
"name": "Alice",
"surname": "Brown"
},
]
}).value,
repeated.meld(
{
"name": "Alice",
"surname": "Brown"
},
{
"name": "John",
"surname": "Brown"
},
{
"name": "John",
"surname": "Lennon"
},
{
"name": "John",
"surname": "Smith"
},
))
def testEquivalence(self):
self.assertTrue(
solve.solve(q.Query("pid == 1"), mocks.Process(1, None,
None)).value)
def testProduct(self):
self.assertEqual(
solve.solve(q.Query("5 * 5 * 5"), mocks.Process(1, None,
None)).value, 125)
def testDifference(self):
self.assertEqual(
solve.solve(q.Query("(10 - pid) + 5"),
mocks.Process(1, None, None)).value, 14)
def testRegexFilter(self):
self.assertTrue(
solve.solve(q.Query("name =~ 'ini.*'"),
mocks.Process(1, "initd", None)).value)
def testStrictOrderedSet(self):
self.assertEqual(
solve.solve(q.Query("pid > 2"),
mocks.Process(1, None, None)).value, [False])
def testComplement(self):
self.assertFalse(
solve.solve(q.Query("not pid"), mocks.Process(1, None,
None)).value)
def testMatchTrace(self):
"""Make sure that matching branch is recorded where applicable."""
result = solve.solve(q.Query("pid == 1 or pid == 2 or pid == 3"),
mocks.Process(2, None, None))
self.assertEqual(q.Query(result.branch), q.Query("pid == 2"))
def testIntersection(self):
self.assertFalse(
solve.solve(q.Query("pid and not pid"),
mocks.Process(1, None, None)).value)
