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)