| # encoding: utf-8 |
| # |
| # Licensed to the Apache Software Foundation (ASF) under one or more |
| # contributor license agreements. See the NOTICE.txt file distributed with |
| # this work for additional information regarding copyright ownership. The ASF |
| # licenses this file to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| # License for the specific language governing permissions and limitations |
| # under the License. |
| |
| '''Unit tests for the query module. |
| |
| This module tests various query classes and the query expression parser. |
| ''' |
| |
| __docformat__ = 'restructuredtext' |
| |
| import unittest, xml.dom, oodt.xmlutils |
| from oodt.query import QueryElement, QueryHeader, QueryResult, Query, _parseQuery, ExpressionParseError |
| |
| class QueryElementTest(unittest.TestCase): |
| '''Test the `QueryElement` class. |
| ''' |
| def testDefaults(self): |
| '''Test to see if defaults are reasonable. |
| ''' |
| qe = QueryElement() |
| self.assertEqual('UNKNOWN', qe.role) |
| self.assertEqual('UNKNOWN', qe.value) |
| |
| def testArgs(self): |
| '''Test to see if initializer arguments are used. |
| ''' |
| qe = QueryElement(role='role', value='value') |
| self.assertEqual('role', qe.role) |
| self.assertEqual('value', qe.value) |
| |
| def testComparisons(self): |
| '''Test comparison operators. |
| ''' |
| a = QueryElement('a', '1') |
| b = QueryElement('a', '1') |
| c = QueryElement('b', '1') |
| d = QueryElement('a', '2') |
| self.assertEqual(a, a) |
| self.assertEqual(a, b) |
| self.assertEqual(b, a) |
| self.assertNotEqual(a, c) |
| self.assertNotEqual(c, a) |
| self.assertNotEqual(a, d) |
| self.assertNotEqual(d, a) |
| self.assertNotEqual(c, d) |
| self.assert_(a <= a) |
| self.assert_(a <= c) |
| self.assert_(a < c) |
| self.assert_(a <= d) |
| self.assert_(a < d) |
| |
| def testBadArgs(self): |
| '''Test reactions to bad arugments. |
| ''' |
| domImpl = xml.dom.getDOMImplementation() |
| doc = domImpl.createDocument(None, None, None) # namespace URI, qualified Name, doctype |
| self.assertRaises(ValueError, QueryElement, node=doc.createElement('notAQueryElement')) |
| |
| def testXML(self): |
| '''Test XML serialization. |
| ''' |
| domImpl = xml.dom.getDOMImplementation() |
| doc = domImpl.createDocument(None, None, None) # namespace URI, qualified Name, doctype |
| q1 = QueryElement(role='a', value='1') |
| root = q1.toXML(doc) |
| self.assertEqual('queryElement', root.nodeName) |
| for child in root.childNodes: |
| if 'tokenRole' == child.nodeName: |
| self.assertEquals('a', oodt.xmlutils.text(child)) |
| elif 'tokenValue' == child.nodeName: |
| self.assertEquals('1', oodt.xmlutils.text(child)) |
| else: |
| self.fail('Unknown node "' + child.nodeName + '" in XML result') |
| |
| q2 = QueryElement(node=root) |
| self.assertEqual(q1, q2) |
| |
| root = doc.createElement('queryElement') |
| doc.appendChild(root) |
| elem = doc.createElement('tokenRole') |
| root.appendChild(elem) |
| elem.appendChild(doc.createTextNode('a')) |
| elem = doc.createElement('tokenValue') |
| root.appendChild(elem) |
| elem.appendChild(doc.createTextNode('2')) |
| q3 = QueryElement(node=root) |
| self.assertNotEqual(q1, q3) |
| |
| |
| _QUERY_HEADER_ATTRS = { |
| 'queryId': 'id', |
| 'queryTitle': 'title', |
| 'queryDesc': 'desc', |
| 'queryType': 'type', |
| 'queryStatusId': 'status', |
| 'querySecurityType': 'security', |
| 'queryRevisionNote': 'rev', |
| 'queryDataDictId': 'dataDict' |
| } |
| |
| class QueryHeaderTest(unittest.TestCase): |
| '''Unit test for the `QueryHeader` class. |
| ''' |
| def testDefaults(self): |
| '''Test if defaults are reasonable. |
| ''' |
| qh = QueryHeader() |
| self.assertEqual('UNKNOWN', qh.id) |
| self.assertEqual('UNKNOWN', qh.title) |
| self.assertEqual('UNKNOWN', qh.desc) |
| self.assertEqual('QUERY', qh.type) |
| self.assertEqual('ACTIVE', qh.status) |
| self.assertEqual('UNKNOWN', qh.security) |
| self.assertEqual('2005-10-01 SCK v0.0.0 Under Development', qh.rev) |
| self.assertEqual('UNKNOWN', qh.dataDict) |
| |
| def testArgs(self): |
| '''Test if initializer arguments are used. |
| ''' |
| qh = QueryHeader('id', 'title', 'desc', 'type', 'status', 'security', 'rev', 'dataDict') |
| self.assertEqual(qh.id, 'id') |
| self.assertEqual(qh.title, 'title') |
| self.assertEqual(qh.desc, 'desc') |
| self.assertEqual(qh.type, 'type') |
| self.assertEqual(qh.status, 'status') |
| self.assertEqual(qh.security, 'security') |
| self.assertEqual(qh.rev, 'rev') |
| self.assertEqual(qh.dataDict, 'dataDict') |
| |
| def testBadArgs(self): |
| '''Test reaction to bad arguments. |
| ''' |
| domImpl = xml.dom.getDOMImplementation() |
| doc = domImpl.createDocument(None, None, None) # namespace URI, qualified Name, doctype |
| self.assertRaises(ValueError, QueryHeader, node=doc.createElement('notAQueryHeader')) |
| |
| def testXML(self): |
| '''Test XML serialization. |
| ''' |
| domImpl = xml.dom.getDOMImplementation() |
| doc = domImpl.createDocument(None, None, None) # namespace URI, qualified Name, doctype |
| q1 = QueryHeader('id', 'title', 'desc', 'type', 'status', 'security', 'rev', 'dataDict') |
| root = q1.toXML(doc) |
| self.assertEqual('queryAttributes', root.nodeName) |
| for child in root.childNodes: |
| self.check(child.nodeName, oodt.xmlutils.text(child)) |
| q2 = QueryHeader(node=root) |
| self.assertEqual(q1, q2) |
| |
| def check(self, name, value): |
| '''Check if the given tag name is valid. |
| ''' |
| if name in _QUERY_HEADER_ATTRS: |
| self.assertEqual(value, _QUERY_HEADER_ATTRS[name]) |
| else: |
| fail('Unknown element ' + name + ' in query header') |
| |
| |
| class QueryResultTest(unittest.TestCase): |
| '''Unit test for the `QueryResults` class. |
| ''' |
| def testDefaults(self): |
| '''Test if defaults are reasonable. |
| ''' |
| qr = QueryResult() |
| self.assertEquals(0, len(qr.results)) |
| self.assertEquals(0, len(qr)) |
| self.assertRaises(IndexError, qr.__getitem__, 0) |
| |
| def testBadArgs(self): |
| '''Test reaction to bad arguments. |
| ''' |
| domImpl = xml.dom.getDOMImplementation() |
| doc = domImpl.createDocument(None, None, None) # namespace URI, qualified Name, doctype |
| self.assertRaises(ValueError, QueryResult, node=doc.createElement('notAQueryResult')) |
| |
| def testXML(self): |
| '''Test XML serialization. |
| ''' |
| domImpl = xml.dom.getDOMImplementation() |
| doc = domImpl.createDocument(None, None, None) # namespace URI, qualified Name, doctype |
| q1 = QueryResult() |
| root = q1.toXML(doc) |
| self.assertEqual('queryResultSet', root.nodeName) |
| q2 = QueryResult(node=root) |
| self.assertEqual(q1, q2) |
| |
| |
| class QueryTest(unittest.TestCase): |
| '''Unit test for the `Query` class. |
| ''' |
| def testDefaults(self): |
| '''Test if defaults are reasonable. |
| ''' |
| q = Query() |
| self.assertEqual(QueryHeader(), q.header) |
| self.assertEqual('ATTRIBUTE', q.resultModeID) |
| self.assertEqual('BROADCAST', q.propType) |
| self.assertEqual('N/A', q.propLevels) |
| self.assertEqual(1, q.maxResults) |
| self.assertEqual(0, len(q.mimeAccept)) |
| |
| def testParser(self): |
| '''Test the query expresion parser. |
| ''' |
| # Empty |
| self.assertEqual(([], []), _parseQuery('')) |
| |
| # Simple |
| self.assertEqual(([ QueryElement(role='elemName', value='x'), QueryElement(role='LITERAL', value='1'), |
| QueryElement(role='RELOP', value='EQ') ], []), _parseQuery('x = 1')) |
| |
| # Logical or |
| self.assertEqual(([ QueryElement(role='elemName', value='x'), QueryElement(role='LITERAL', value='1'), |
| QueryElement(role='RELOP', value='LT'), QueryElement(role='elemName', value='y'), |
| QueryElement(role='LITERAL', value='-2'), QueryElement(role='RELOP', value='GT'), |
| QueryElement(role='LOGOP', value='OR') ], []), _parseQuery('x < 1 or y > -2')) |
| |
| # Logical and has higher precendence |
| self.assertEqual(([ QueryElement(role='elemName', value='x'), QueryElement(role='LITERAL', value='1'), |
| QueryElement(role='RELOP', value='LE'), QueryElement(role='elemName', value='y'), |
| QueryElement(role='LITERAL', value='2'), QueryElement(role='RELOP', value='GE'), |
| QueryElement(role='elemName', value='z'), QueryElement(role='LITERAL', value='-3.96'), |
| QueryElement(role='RELOP', value='NE'), QueryElement(role='LOGOP', value='AND'), |
| QueryElement(role='LOGOP', value='OR') ], []), _parseQuery('x <= 1 | y >= 2 and z != -3.96')) |
| |
| # Logical or has lower precedence |
| self.assertEqual(([ QueryElement(role='elemName', value='x'), QueryElement(role='LITERAL', value='1'), |
| QueryElement(role='RELOP', value='LT'), QueryElement(role='elemName', value='y'), |
| QueryElement(role='LITERAL', value='2'), QueryElement(role='RELOP', value='GT'), |
| QueryElement(role='LOGOP', value='AND'), QueryElement(role='elemName', value='z'), |
| QueryElement(role='LITERAL', value='3'), QueryElement(role='RELOP', value='NE'), |
| QueryElement(role='LOGOP', value='OR') ], []), _parseQuery('x LT 1 & y GT 2 or z NE 3')) |
| |
| # Parenthesis |
| self.assertEqual(([ QueryElement(role='elemName', value='x'), QueryElement(role='LITERAL', value='1'), |
| QueryElement(role='RELOP', value='LE'), QueryElement(role='elemName', value='y'), \ |
| QueryElement(role='LITERAL', value='2'), QueryElement(role='RELOP', value='GE'), |
| QueryElement(role='LOGOP', value='OR'), QueryElement(role='elemName', value='z'), |
| QueryElement(role='LITERAL', value='3'), QueryElement(role='RELOP', value='EQ'), |
| QueryElement(role='LOGOP', value='AND') ], []), _parseQuery('(x LE 1 or y GE 2) and z EQ 3')) |
| |
| # Logical not |
| self.assertEqual(([ QueryElement(role='elemName', value='x'), QueryElement(role='LITERAL', value='1'), |
| QueryElement(role='RELOP', value='LE'), QueryElement(role='elemName', value='y'), |
| QueryElement(role='LITERAL', value='2'), QueryElement(role='RELOP', value='GE'), |
| QueryElement(role='LOGOP', value='OR'), QueryElement(role='LOGOP', value='NOT'), |
| QueryElement(role='elemName', value='z'), QueryElement(role='LITERAL', value='3'), |
| QueryElement(role='RELOP', value='EQ'), QueryElement(role='LOGOP', value='NOT'), |
| QueryElement(role='LOGOP', value='AND') ], []), _parseQuery('not (x LE 1 or y GE 2) and ! z EQ 3')) |
| |
| # Quoted strings |
| self.assertEqual(([ QueryElement(role='elemName', value='x'), QueryElement(role='LITERAL', value='Fish Poop'), |
| QueryElement(role='RELOP', value='EQ'), QueryElement(role='elemName', value='y'), |
| QueryElement(role='LITERAL', value='Monkey Poop'), QueryElement(role='RELOP', value='EQ'), |
| QueryElement(role='LOGOP', value='AND') ], []), |
| _parseQuery("""x = "Fish Poop" and y = 'Monkey Poop'""")) |
| |
| # RETURN elements |
| self.assertEqual(([ QueryElement(role='elemName', value='x'), QueryElement(role='LITERAL', value='Fish Poop'), |
| QueryElement(role='RELOP', value='EQ'), QueryElement(role='elemName', value='y'), |
| QueryElement(role='LITERAL', value='Monkey Poop'), QueryElement(role='RELOP', value='EQ'), |
| QueryElement(role='LOGOP', value='AND') ], [QueryElement(role='elemName', value='fish')]), |
| _parseQuery("""x = "Fish Poop" and RETURN > fish and y = 'Monkey Poop'""")) |
| |
| # RETURN at beginning and middle |
| self.assertEqual(([ QueryElement(role='elemName', value='x'), QueryElement(role='LITERAL', value='Fish Poop'), |
| QueryElement(role='RELOP', value='EQ'), QueryElement(role='elemName', value='y'), |
| QueryElement(role='LITERAL', value='Monkey Poop'), QueryElement(role='RELOP', value='EQ'), |
| QueryElement(role='LOGOP', value='AND') ], [QueryElement(role='elemName', value='fish'), |
| QueryElement(role='elemName', value='poop')]), |
| _parseQuery("""RETURN < fish and x = "Fish Poop" and RETURN > poop and y = 'Monkey Poop'""")) |
| |
| # Bad expressions |
| for expr in ('heya', 'RETURN =', 'AND', 'LAT ~ fish', 'NOT', '(', ')'): |
| self.assertRaises(ExpressionParseError, _parseQuery, expr) |
| |
| # Unusual symbols |
| self.assertEqual(([QueryElement('elemName', 'DATA_SET_ID'), QueryElement('LITERAL', 'ARCB-L-RTLS-3-70CM-V1.0'), |
| QueryElement('RELOP', 'EQ')], []), _parseQuery('''DATA_SET_ID = ARCB-L-RTLS-3-70CM-V1.0''')) |
| self.assertEqual(([QueryElement('elemName', 'file'), QueryElement('LITERAL', '/usr/local/bin/poop'), |
| QueryElement('RELOP', 'EQ')], []), _parseQuery('''file = /usr/local/bin/poop''')) |
| self.assertEqual(([QueryElement('elemName', 'start_time'), QueryElement('LITERAL', '2006-02-06T13:12:13'), |
| QueryElement('RELOP', 'EQ')], []), _parseQuery('''start_time = 2006-02-06T13:12:13''')) |
| |
| def testCmp(self): |
| '''Test comparison operators. |
| ''' |
| a = Query('lat > 3 and lon < -92.6') |
| b = Query('lat > 3 and lon < -92.6') |
| c = Query('lat < 3 and lon > -92.6') |
| self.assert_(a == a) |
| self.assert_(a == b) |
| self.assert_(a < c) |
| self.assert_(c > a) |
| self.assert_(a <= b) |
| self.assert_(a >= b) |
| self.assert_(a <= c) |
| self.assert_(c >= a) |
| self.assert_(c != a) |
| |
| def testXML(self): |
| '''Test XML serialization. |
| ''' |
| domImpl = xml.dom.getDOMImplementation() |
| doc = domImpl.createDocument(None, None, None) # namespace URI, qualified Name, doctype |
| q1 = Query('lat > 3 and lon < -92.6') |
| root = q1.toXML(doc) |
| self.assertEqual('query', root.nodeName) |
| q2 = Query(node=root) |
| self.assertEqual(q1, q2) |
| |
| |
| def test_suite(): |
| '''Create the suite of tests. |
| ''' |
| suite = unittest.TestSuite() |
| suite.addTest(unittest.makeSuite(QueryElementTest)) |
| suite.addTest(unittest.makeSuite(QueryHeaderTest)) |
| suite.addTest(unittest.makeSuite(QueryResultTest)) |
| suite.addTest(unittest.makeSuite(QueryTest)) |
| return suite |
| |
| |
| if __name__ == '__main__': |
| unittest.main(defaultTest='test_suite') |
| |
