diff options
Diffstat (limited to 'qpid/python')
| -rw-r--r-- | qpid/python/qmf2/common.py | 304 | ||||
| -rw-r--r-- | qpid/python/qmf2/console.py | 39 | ||||
| -rw-r--r-- | qpid/python/qmf2/tests/agent_discovery.py | 6 | ||||
| -rw-r--r-- | qpid/python/qmf2/tests/basic_method.py | 18 | ||||
| -rw-r--r-- | qpid/python/qmf2/tests/basic_query.py | 106 | ||||
| -rw-r--r-- | qpid/python/qmf2/tests/events.py | 2 | ||||
| -rw-r--r-- | qpid/python/qmf2/tests/obj_gets.py | 2 |
7 files changed, 264 insertions, 213 deletions
diff --git a/qpid/python/qmf2/common.py b/qpid/python/qmf2/common.py index f050ec87e2..affc49f85b 100644 --- a/qpid/python/qmf2/common.py +++ b/qpid/python/qmf2/common.py @@ -1,4 +1,3 @@ - # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information @@ -17,7 +16,7 @@ # under the License. # import time -import logging +from logging import getLogger from threading import Lock from threading import Condition try: @@ -27,7 +26,8 @@ except ImportError: import md5 _md5Obj = md5.new - +log = getLogger("qmf") +log_query = getLogger("qmf.query") ## @@ -423,7 +423,10 @@ class QmfData(_mapEncoder): return self._tag def get_value(self, name): - # meta-properties: + """ + Will throw an AttributeError exception if the named value does not exist. + """ + # meta-properties first: if name == SchemaClassId.KEY_PACKAGE: if self._schema_id: return self._schema_id.get_package_name() @@ -453,7 +456,10 @@ class QmfData(_mapEncoder): if name == self.KEY_DELETE_TS: return self._dtime - return self._values.get(name) + try: + return self._values[name] + except KeyError: + raise AttributeError("no value named '%s' in this object" % name) def has_value(self, name): @@ -515,8 +521,7 @@ class QmfData(_mapEncoder): try: result += unicode(self._values[key]) except: - logging.error("get_object_id(): cannot convert value '%s'." - % key) + log.error("get_object_id(): cannot convert value '%s'." % key) return None self._object_id = result return result @@ -931,23 +936,32 @@ class QmfQuery(_mapEncoder): # QmfData.KEY_DELETE_TS # <name of data value> - CMP_EQ="eq" - CMP_NE="ne" - CMP_LT="lt" - CMP_LE="le" - CMP_GT="gt" - CMP_GE="ge" - CMP_RE_MATCH="re_match" - CMP_EXISTS="exists" - CMP_TRUE="true" - CMP_FALSE="false" - - LOGIC_AND="and" - LOGIC_OR="or" - LOGIC_NOT="not" + # supported predicate operators + + # evaluation operators + QUOTE="quote" + UNQUOTE="unquote" + # boolean operators + EQ="eq" + NE="ne" + LT="lt" + LE="le" + GT="gt" + GE="ge" + RE_MATCH="re_match" + EXISTS="exists" + TRUE="true" + FALSE="false" + # logic operators + AND="and" + OR="or" + NOT="not" _valid_targets = [TARGET_PACKAGES, TARGET_OBJECT_ID, TARGET_SCHEMA, TARGET_SCHEMA_ID, TARGET_OBJECT, TARGET_AGENT] + _valid_bool_ops = [EQ, NE, LT, GT, LE, GE, EXISTS, RE_MATCH, TRUE, FALSE] + _valid_logic_ops = [AND, OR, NOT] + _valid_eval_ops = [QUOTE, UNQUOTE] def __init__(self, _target=None, _target_params=None, _predicate=None, _id=None, _map=None): @@ -972,9 +986,7 @@ class QmfQuery(_mapEncoder): if _target == self.TARGET_SCHEMA: _id = SchemaClassId.from_map(_id) else: - pred = _map.get(self.KEY_PREDICATE) - if pred: - _predicate = QmfQueryPredicate(pred) + _predicate = _map.get(self.KEY_PREDICATE, _predicate) self._target = _target if not self._target: @@ -1038,7 +1050,7 @@ class QmfQuery(_mapEncoder): raise Exception("Unsupported query target '%s'" % str(self._target)) if self._predicate: - return self._predicate.evaluate(qmfData) + return self._eval_pred(self._predicate, qmfData) # no predicate and no id - always match return True @@ -1050,163 +1062,131 @@ class QmfQuery(_mapEncoder): else: _map[self.KEY_ID] = self._id elif self._predicate is not None: - _map[self.KEY_PREDICATE] = self._predicate.map_encode() + _map[self.KEY_PREDICATE] = self._predicate return _map - def __repr__(self): - return "QmfQuery=<<" + str(self.map_encode()) + ">>" - - - -class QmfQueryPredicate(_mapEncoder): - """ - Class for Query predicates. - """ - _valid_cmp_ops = [QmfQuery.CMP_EQ, QmfQuery.CMP_NE, QmfQuery.CMP_LT, - QmfQuery.CMP_GT, QmfQuery.CMP_LE, QmfQuery.CMP_GE, - QmfQuery.CMP_EXISTS, QmfQuery.CMP_RE_MATCH, - QmfQuery.CMP_TRUE, QmfQuery.CMP_FALSE] - _valid_logic_ops = [QmfQuery.LOGIC_AND, QmfQuery.LOGIC_OR, QmfQuery.LOGIC_NOT] - - - def __init__( self, pmap): - """ - {"op": listOf(operands)} - """ - self._oper = None - self._operands = [] - - logic_op = False - if type(pmap) == dict: - for key in pmap.iterkeys(): - if key in self._valid_cmp_ops: - # comparison operation - may have "name" and "value" - self._oper = key - break - if key in self._valid_logic_ops: - logic_op = True - self._oper = key - break - - if not self._oper: - raise TypeError("invalid predicate expression: '%s'" % str(pmap)) - - if type(pmap[self._oper]) == list or type(pmap[self._oper]) == tuple: - if logic_op: - for exp in pmap[self._oper]: - self.append(QmfQueryPredicate(exp)) - else: - self._operands = list(pmap[self._oper]) - - else: - raise TypeError("invalid predicate: '%s'" % str(pmap)) - - - def append(self, operand): - """ - Append another operand to a predicate expression - """ - self._operands.append(operand) - - - - def evaluate( self, qmfData ): + def _eval_pred(self, pred, qmfData): """ + Evaluate the predicate expression against a QmfData object. """ if not isinstance(qmfData, QmfData): raise TypeError("Query expects to evaluate QmfData types.") - if self._oper == QmfQuery.CMP_TRUE: - logging.debug("query evaluate TRUE") - return True - if self._oper == QmfQuery.CMP_FALSE: - logging.debug("query evaluate FALSE") + if not isinstance(pred, type([])): + log_query.warning("Invalid type for predicate expression: '%s'" % str(pred)) return False - if self._oper in [QmfQuery.CMP_EQ, QmfQuery.CMP_NE, QmfQuery.CMP_LT, - QmfQuery.CMP_LE, QmfQuery.CMP_GT, QmfQuery.CMP_GE, - QmfQuery.CMP_RE_MATCH]: - if len(self._operands) != 2: - logging.warning("Malformed query compare expression received: '%s, %s'" % - (self._oper, str(self._operands))) - return False - # @todo: support regular expression match - name = self._operands[0] - logging.debug("looking for: '%s'" % str(name)) - if not qmfData.has_value(name): - logging.warning("Malformed query, attribute '%s' not present." - % name) - return False + # empty predicate - match all??? + if len(pred) == 0: + return True - arg1 = qmfData.get_value(name) - arg2 = self._operands[1] - logging.debug("query evaluate %s: '%s' '%s' '%s'" % - (name, str(arg1), self._oper, str(arg2))) - try: - if self._oper == QmfQuery.CMP_EQ: return arg1 == arg2 - if self._oper == QmfQuery.CMP_NE: return arg1 != arg2 - if self._oper == QmfQuery.CMP_LT: return arg1 < arg2 - if self._oper == QmfQuery.CMP_LE: return arg1 <= arg2 - if self._oper == QmfQuery.CMP_GT: return arg1 > arg2 - if self._oper == QmfQuery.CMP_GE: return arg1 >= arg2 - if self._oper == QmfQuery.CMP_RE_MATCH: - logging.error("!!! RE QUERY TBD !!!") - return False - except: - pass - logging.warning("Malformed query - %s: '%s' '%s' '%s'" % - (name, str(arg1), self._oper, str(self._operands[1]))) - return False + oper = pred[0] + if oper == QmfQuery.TRUE: + log_query.debug("query evaluate TRUE") + return True + if oper == QmfQuery.FALSE: + log_query.debug("query evaluate FALSE") + return False - if self._oper == QmfQuery.CMP_EXISTS: - if len(self._operands) != 1: - logging.warning("Malformed query present expression received") - return False - name = self._operands[0] - logging.debug("query evaluate PRESENT: [%s]" % str(name)) - return qmfData.has_value(name) - - if self._oper == QmfQuery.LOGIC_AND: - logging.debug("query evaluate AND: '%s'" % str(self._operands)) - for exp in self._operands: - if not exp.evaluate(qmfData): + if oper == QmfQuery.AND: + log_query.debug("query evaluate AND: '%s'" % str(pred)) + for exp in pred[1:]: + if not self._eval_pred(exp, qmfData): + log_query.debug("---> False") return False + log_query.debug("---> True") return True - if self._oper == QmfQuery.LOGIC_OR: - logging.debug("query evaluate OR: [%s]" % str(self._operands)) - for exp in self._operands: - if exp.evaluate(qmfData): + if oper == QmfQuery.OR: + log_query.debug("query evaluate OR: [%s]" % str(pred)) + for exp in pred[1:]: + if self._eval_pred(exp, qmfData): + log_query.debug("---> True") return True + log_query.debug("---> False") return False - if self._oper == QmfQuery.LOGIC_NOT: - logging.debug("query evaluate NOT: [%s]" % str(self._operands)) - for exp in self._operands: - if exp.evaluate(qmfData): + if oper == QmfQuery.NOT: + log_query.debug("query evaluate NOT: [%s]" % str(pred)) + for exp in pred[1:]: + if self._eval_pred(exp, qmfData): + log_query.debug("---> False") return False + log_query.debug("---> True") return True - logging.warning("Unrecognized query operator: [%s]" % str(self._oper)) + if oper == QmfQuery.EXISTS: + if len(pred) != 2: + log_query.warning("Malformed query: 'exists' operator" + " - bad arguments '%s'" % str(pred)) + return False + ### Q: Should we assume "quote", or should it be explicit? + ### "foo" or ["quote" "foo"] + ### my guess is "explicit" + log_query.debug("query evaluate EXISTS: [%s]" % str(pred)) + try: + arg = self._fetch_pred_arg(pred[1], qmfData) + except AttributeError: + log_query.debug("query parameter not found: '%s'" % str(pred)) + return False + v = qmfData.has_value(arg) + log_query.debug("---> %s" % str(v)) + return v + + # binary operators + if oper in [QmfQuery.EQ, QmfQuery.NE, QmfQuery.LT, + QmfQuery.LE, QmfQuery.GT, QmfQuery.GE, + QmfQuery.RE_MATCH]: + if len(pred) != 3: + log_query.warning("Malformed query: '%s' operator" + " - requires 2 arguments '%s'" % + (oper, str(pred))) + return False + # @todo: support regular expression match + log_query.debug("query evaluate binary op: [%s]" % str(pred)) + try: + arg1 = self._fetch_pred_arg(pred[1], qmfData) + arg2 = self._fetch_pred_arg(pred[2], qmfData) + except AttributeError: + log_query.debug("query parameter not found: '%s'" % str(pred)) + return False + log_query.debug("query evaluate %s: %s, %s" % (oper, str(arg1), str(arg2))) + v = False + try: + if oper == QmfQuery.EQ: v = arg1 == arg2 + elif oper == QmfQuery.NE: v = arg1 != arg2 + elif oper == QmfQuery.LT: v = arg1 < arg2 + elif oper == QmfQuery.LE: v = arg1 <= arg2 + elif oper == QmfQuery.GT: v = arg1 > arg2 + elif oper == QmfQuery.GE: v = arg1 >= arg2 + except TypeError: + log_query.warning("query comparison failed: '%s'" % str(pred)) + log_query.debug("---> %s" % str(v)) + return v + + log_query.warning("Unrecognized query operator: [%s]" % str(pred[0])) return False - - def map_encode(self): - _map = {} - _list = [] - for exp in self._operands: - if isinstance(exp, QmfQueryPredicate): - _list.append(exp.map_encode()) - else: - _list.append(exp) - _map[self._oper] = _list - return _map - + def _fetch_pred_arg(self, arg, qmfData): + """ + Determine the value of a predicate argument by evaluating quoted + arguments. + """ + if isinstance(arg, basestring): + return qmfData.get_value(arg) + if isinstance(arg, type([])) and len(arg) == 2: + if arg[0] == QmfQuery.QUOTE: + return arg[1] + if arg[0] == QmfQuery.UNQUOTE: + return qmfData.get_value(arg[1]) + return arg def __repr__(self): - return "QmfQueryPredicate=<<" + str(self.map_encode()) + ">>" - + return "QmfQuery=<<" + str(self.map_encode()) + ">>" + + + ##============================================================================== @@ -1924,13 +1904,3 @@ class SchemaEventClass(SchemaClass): return cls(_map=map_) from_map = classmethod(__from_map) - - - - - - - - - - diff --git a/qpid/python/qmf2/console.py b/qpid/python/qmf2/console.py index 94d0fd7583..84209e255c 100644 --- a/qpid/python/qmf2/console.py +++ b/qpid/python/qmf2/console.py @@ -31,7 +31,7 @@ from threading import Condition from qpid.messaging import Connection, Message, Empty, SendError from common import (make_subject, parse_subject, OpCode, QmfQuery, Notifier, - QmfQueryPredicate, MsgKey, QmfData, QmfAddress, + MsgKey, QmfData, QmfAddress, SchemaClass, SchemaClassId, SchemaEventClass, SchemaObjectClass, WorkItem, SchemaMethod, QmfEvent) @@ -992,26 +992,19 @@ class Console(Thread): # query by object id query = QmfQuery.create_id(QmfQuery.TARGET_OBJECT, _object_id) elif _schema_id is not None: - pred = QmfQueryPredicate({QmfQuery.CMP_EQ: - [QmfData.KEY_SCHEMA_ID, - _schema_id.map_encode()]}) + pred = [QmfQuery.EQ, QmfData.KEY_SCHEMA_ID, _schema_id.map_encode()] query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT, pred) elif _pname is not None: # query by package name (and maybe class name) if _cname is not None: - pred = QmfQueryPredicate({QmfQuery.LOGIC_AND: - [{QmfQuery.CMP_EQ: - [SchemaClassId.KEY_PACKAGE, - _pname]}, - {QmfQuery.CMP_EQ: - [SchemaClassId.KEY_CLASS, - _cname]}]}) + pred = [QmfQuery.AND, [QmfQuery.EQ, SchemaClassId.KEY_PACKAGE, + [QmfQuery.QUOTE, _pname]], + [QmfQuery.EQ, SchemaClassId.KEY_CLASS, + [QmfQuery.QUOTE, _cname]]] else: - pred = QmfQueryPredicate({QmfQuery.CMP_EQ: - [SchemaClassId.KEY_PACKAGE, - _pname]}) + pred = [QmfQuery.EQ, SchemaClassId.KEY_PACKAGE, + [QmfQuery.QUOTE, _pname]] query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT, pred) - else: raise Exception("invalid arguments") @@ -1977,13 +1970,13 @@ if __name__ == '__main__': logging.info( "******** Messing around with Queries ********" ) _q1 = QmfQuery.create_predicate(QmfQuery.TARGET_AGENT, - QmfQueryPredicate({QmfQuery.LOGIC_AND: - [{QmfQuery.CMP_EQ: ["vendor", "AVendor"]}, - {QmfQuery.CMP_EQ: ["product", "SomeProduct"]}, - {QmfQuery.CMP_EQ: ["name", "Thingy"]}, - {QmfQuery.LOGIC_OR: - [{QmfQuery.CMP_LE: ["temperature", -10]}, - {QmfQuery.CMP_FALSE: None}, - {QmfQuery.CMP_EXISTS: ["namey"]}]}]})) + [QmfQuery.AND, + [QmfQuery.EQ, "vendor", [QmfQuery.QUOTE, "AVendor"]], + [QmfQuery.EQ, [QmfQuery.QUOTE, "SomeProduct"], "product"], + [QmfQuery.EQ, [QmfQuery.UNQUOTE, "name"], [QmfQuery.QUOTE, "Thingy"]], + [QmfQuery.OR, + [QmfQuery.LE, "temperature", -10], + [QmfQuery.FALSE], + [QmfQuery.EXISTS, "namey"]]]) print("_q1.mapEncode() = [%s]" % _q1.map_encode()) diff --git a/qpid/python/qmf2/tests/agent_discovery.py b/qpid/python/qmf2/tests/agent_discovery.py index ce346d84e6..59b65221e0 100644 --- a/qpid/python/qmf2/tests/agent_discovery.py +++ b/qpid/python/qmf2/tests/agent_discovery.py @@ -180,9 +180,9 @@ class BaseTest(unittest.TestCase): self.console.add_connection(self.conn) query = qmf2.common.QmfQuery.create_predicate( - qmf2.common.QmfQuery.TARGET_AGENT, - qmf2.common.QmfQueryPredicate({qmf2.common.QmfQuery.CMP_EQ: - [qmf2.common.QmfQuery.KEY_AGENT_NAME, "agent1"]})) + qmf2.common.QmfQuery.TARGET_AGENT, + [qmf2.common.QmfQuery.EQ, qmf2.common.QmfQuery.KEY_AGENT_NAME, + [qmf2.common.QmfQuery.QUOTE, "agent1"]]) self.console.enable_agent_discovery(query) agent1_found = agent2_found = False diff --git a/qpid/python/qmf2/tests/basic_method.py b/qpid/python/qmf2/tests/basic_method.py index a12bbe7c4a..a1847efee9 100644 --- a/qpid/python/qmf2/tests/basic_method.py +++ b/qpid/python/qmf2/tests/basic_method.py @@ -22,7 +22,7 @@ from threading import Thread, Event import qpid.messaging from qmf2.common import (Notifier, SchemaObjectClass, SchemaClassId, SchemaProperty, qmfTypes, SchemaMethod, QmfQuery, - QmfData, QmfQueryPredicate, WorkItem) + QmfData, WorkItem) import qmf2.console from qmf2.agent import(QmfAgentData, Agent, MethodCallParams) @@ -247,11 +247,9 @@ class BaseTest(unittest.TestCase): self.assertTrue(agent and agent.get_name() == aname) query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT, - QmfQueryPredicate( - {QmfQuery.LOGIC_AND: - [{QmfQuery.CMP_EXISTS: [SchemaClassId.KEY_PACKAGE]}, - {QmfQuery.CMP_EQ: [SchemaClassId.KEY_PACKAGE, - "MyPackage"]}]})) + [QmfQuery.AND, + [QmfQuery.EXISTS, [QmfQuery.QUOTE, SchemaClassId.KEY_PACKAGE]], + [QmfQuery.EQ, SchemaClassId.KEY_PACKAGE, [QmfQuery.QUOTE, "MyPackage"]]]) obj_list = self.console.do_query(agent, query) self.assertTrue(len(obj_list) == 2) @@ -297,11 +295,9 @@ class BaseTest(unittest.TestCase): self.assertTrue(agent and agent.get_name() == aname) query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT, - QmfQueryPredicate( - {QmfQuery.LOGIC_AND: - [{QmfQuery.CMP_EXISTS: [SchemaClassId.KEY_PACKAGE]}, - {QmfQuery.CMP_EQ: [SchemaClassId.KEY_PACKAGE, - "MyPackage"]}]})) + [QmfQuery.AND, + [QmfQuery.EXISTS, [QmfQuery.QUOTE, SchemaClassId.KEY_PACKAGE]], + [QmfQuery.EQ, [QmfQuery.UNQUOTE, SchemaClassId.KEY_PACKAGE], [QmfQuery.QUOTE, "MyPackage"]]]) obj_list = self.console.do_query(agent, query) self.assertTrue(len(obj_list) == 2) diff --git a/qpid/python/qmf2/tests/basic_query.py b/qpid/python/qmf2/tests/basic_query.py index 61002976a2..5a1f4c55c8 100644 --- a/qpid/python/qmf2/tests/basic_query.py +++ b/qpid/python/qmf2/tests/basic_query.py @@ -22,7 +22,7 @@ from threading import Thread, Event import qpid.messaging from qmf2.common import (Notifier, SchemaObjectClass, SchemaClassId, SchemaProperty, qmfTypes, SchemaMethod, QmfQuery, - QmfData, QmfQueryPredicate) + QmfData) import qmf2.console from qmf2.agent import(QmfAgentData, Agent) @@ -107,6 +107,7 @@ class _agentApp(Thread): _obj2.set_value("field2", 2) _obj2.set_value("field3", {"a":1, "map":2, "value":3}) _obj2.set_value("field4", ["a", "list", "value"]) + _obj2.set_value("index1", 50) self.agent.add_object(_obj2) self.running = False @@ -296,9 +297,9 @@ class BaseTest(unittest.TestCase): self.assertTrue(agent and agent.get_name() == aname) query = QmfQuery.create_predicate(QmfQuery.TARGET_SCHEMA, - QmfQueryPredicate( - {QmfQuery.CMP_EQ: [SchemaClassId.KEY_PACKAGE, - "MyPackage"]})) + [QmfQuery.EQ, + SchemaClassId.KEY_PACKAGE, + [QmfQuery.QUOTE, "MyPackage"]]) schema_list = self.console.do_query(agent, query) self.assertTrue(len(schema_list)) @@ -330,9 +331,9 @@ class BaseTest(unittest.TestCase): self.assertTrue(agent and agent.get_name() == aname) query = QmfQuery.create_predicate(QmfQuery.TARGET_SCHEMA, - QmfQueryPredicate( - {QmfQuery.CMP_EQ: [SchemaClassId.KEY_PACKAGE, - "No-Such-Package"]})) + [QmfQuery.EQ, + [QmfQuery.UNQUOTE, SchemaClassId.KEY_PACKAGE], + [QmfQuery.QUOTE, "No-Such-Package"]]) schema_list = self.console.do_query(agent, query) self.assertTrue(len(schema_list) == 0) @@ -340,3 +341,94 @@ class BaseTest(unittest.TestCase): self.console.destroy(10) + def test_predicate_match_string(self): + # create console + # find agents + # synchronous query for all objects with a value named + # set_string which is < or equal to "UNSET" + self.notifier = _testNotifier() + self.console = qmf2.console.Console(notifier=self.notifier, + agent_timeout=3) + self.conn = qpid.messaging.Connection(self.broker.host, + self.broker.port, + self.broker.user, + self.broker.password) + self.conn.connect() + self.console.add_connection(self.conn) + + for aname in ["agent1", "agent2"]: + agent = self.console.find_agent(aname, timeout=3) + self.assertTrue(agent and agent.get_name() == aname) + + query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT, + [QmfQuery.AND, + [QmfQuery.EXISTS, [QmfQuery.QUOTE, "set_string"]], + [QmfQuery.EQ, "set_string", [QmfQuery.QUOTE, "UNSET"]]]) + + obj_list = self.console.do_query(agent, query) + self.assertTrue(len(obj_list) == 2) + for obj in obj_list: + self.assertTrue(obj.has_value("set_string")) + self.assertTrue(obj.get_value("set_string") == "UNSET") + + self.console.destroy(10) + + + + def test_predicate_match_integer(self): + # create console + # find agents + # synchronous query for all objects with a value named + # "index1" which is < or equal to various values + self.notifier = _testNotifier() + self.console = qmf2.console.Console(notifier=self.notifier, + agent_timeout=3) + self.conn = qpid.messaging.Connection(self.broker.host, + self.broker.port, + self.broker.user, + self.broker.password) + self.conn.connect() + self.console.add_connection(self.conn) + + for aname in ["agent1", "agent2"]: + agent = self.console.find_agent(aname, timeout=3) + self.assertTrue(agent and agent.get_name() == aname) + + # == 99 + query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT, + [QmfQuery.AND, + [QmfQuery.EXISTS, [QmfQuery.QUOTE, "index1"]], + [QmfQuery.EQ, "index1", 99]]) + + obj_list = self.console.do_query(agent, query) + self.assertTrue(len(obj_list) == 1) + self.assertTrue(obj_list[0].has_value("index1")) + self.assertTrue(obj_list[0].get_value("index1") == 99) + + # <= 99 + query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT, + [QmfQuery.AND, + [QmfQuery.EXISTS, [QmfQuery.QUOTE, "index1"]], + [QmfQuery.LE, "index1", 99]]) + + obj_list = self.console.do_query(agent, query) + self.assertTrue(len(obj_list) == 2) + for obj in obj_list: + self.assertTrue(obj.has_value("index1")) + self.assertTrue(obj.get_value("index1") <= 99) + + + # > 99 + query = QmfQuery.create_predicate(QmfQuery.TARGET_OBJECT, + [QmfQuery.AND, + [QmfQuery.EXISTS, [QmfQuery.QUOTE, "index1"]], + [QmfQuery.GT, "index1", 99]]) + + obj_list = self.console.do_query(agent, query) + self.assertTrue(len(obj_list) == 1) + for obj in obj_list: + self.assertTrue(obj.has_value("index1")) + self.assertTrue(obj.get_value("index1") > 99) + + self.console.destroy(10) + diff --git a/qpid/python/qmf2/tests/events.py b/qpid/python/qmf2/tests/events.py index 9ee6b6af8d..a621aa0392 100644 --- a/qpid/python/qmf2/tests/events.py +++ b/qpid/python/qmf2/tests/events.py @@ -25,7 +25,7 @@ import qpid.messaging from qpid.harness import Skipped from qmf2.common import (Notifier, SchemaObjectClass, SchemaClassId, SchemaProperty, qmfTypes, SchemaMethod, QmfQuery, - QmfData, QmfQueryPredicate, SchemaEventClass, + QmfData, SchemaEventClass, QmfEvent) import qmf2.console from qmf2.agent import(QmfAgentData, Agent) diff --git a/qpid/python/qmf2/tests/obj_gets.py b/qpid/python/qmf2/tests/obj_gets.py index 50d585a718..514121980e 100644 --- a/qpid/python/qmf2/tests/obj_gets.py +++ b/qpid/python/qmf2/tests/obj_gets.py @@ -22,7 +22,7 @@ from threading import Thread, Event import qpid.messaging from qmf2.common import (Notifier, SchemaObjectClass, SchemaClassId, SchemaProperty, qmfTypes, SchemaMethod, QmfQuery, - QmfData, QmfQueryPredicate) + QmfData) import qmf2.console from qmf2.agent import(QmfAgentData, Agent) |