def testQueryAttributes(self):
q = query.Query(kind='Foo')
self.assertEqual(q.kind, 'Foo')
self.assertEqual(q.ancestor, None)
self.assertEqual(q.filters, None)
self.assertEqual(q.orders, None)
key = model.Key('Barba', 'papa')
q = query.Query(kind='Foo', ancestor=key)
self.assertEqual(q.kind, 'Foo')
self.assertEqual(q.ancestor, key)
self.assertEqual(q.filters, None)
self.assertEqual(q.orders, None)
q = q.filter(Foo.rate == 1)
self.assertEqual(q.kind, 'Foo')
self.assertEqual(q.ancestor, key)
self.assertEqual(q.filters, query.FilterNode('rate', '=', 1))
self.assertEqual(q.orders, None)
q = q.order(-Foo.name)
self.assertEqual(q.kind, 'Foo')
self.assertEqual(q.ancestor, key)
self.assertEqual(q.filters, query.FilterNode('rate', '=', 1))
expected_order = [('name', query.DESC)]
self.assertEqual(query.orders_to_orderings(q.orders), expected_order)
def testGqlFilter(self):
qry, options, bindings = query.parse_gql(
"SELECT * FROM Kind WHERE prop1 = 1 AND prop2 = 'a'")
self.assertEqual(qry.kind, 'Kind')
self.assertEqual(qry.ancestor, None)
self.assertEqual(qry.filters,
query.ConjunctionNode(
[query.FilterNode('prop1', '=', 1),
query.FilterNode('prop2', '=', 'a')]))
self.assertEqual(qry.orders, None)
self.assertEqual(bindings, {})
def testOrQuery(self):
class Employee(model.Model):
name = model.StringProperty()
age = model.IntegerProperty('Age')
rank = model.IntegerProperty()
q = Employee.query().filter(query.OR(Employee.age >= 42))
self.assertEqual(q.filters, query.FilterNode('Age', '>=', 42))
q = Employee.query(query.OR(Employee.age < 42, Employee.rank > 5))
self.assertEqual(q.filters,
query.DisjunctionNode(
query.FilterNode('Age', '<', 42),
query.FilterNode('rank', '>', 5)))
def testInFilter(self):
class Employee(model.Model):
name = model.StringProperty()
q = Employee.query(Employee.name.IN(['a', 'b']))
self.assertEqual(q.filters,
query.DisjunctionNode(
query.FilterNode('name', '=', 'a'),
query.FilterNode('name', '=', 'b')))
a = Employee(name='a')
a.put()
b = Employee(name='b')
b.put()
self.assertEqual(list(q), [a, b])
def testGqlBindings(self):
qry, options, bindings = query.parse_gql(
'SELECT * FROM Kind WHERE prop1 = :1 AND prop2 = :foo')
self.assertEqual(qry.kind, 'Kind')
self.assertEqual(qry.ancestor, None)
self.assertEqual(qry.filters,
query.ConjunctionNode(
[query.FilterNode('prop1', '=',
query.Binding(None, 1)),
query.FilterNode('prop2', '=',
query.Binding(None, 'foo'))]))
self.assertEqual(qry.orders, None)
self.assertEqual(bindings, {1: query.Binding(None, 1),
'foo': query.Binding(None, 'foo')})
def testAndQuery(self):
class Employee(model.Model):
name = model.StringProperty()
age = model.IntegerProperty('Age')
rank = model.IntegerProperty()
q = Employee.query().filter(query.AND(Employee.age >= 42))
self.assertEqual(q.filters, query.FilterNode('Age', '>=', 42))
q = Employee.query(query.AND(Employee.age >= 42, Employee.rank <= 5))
self.assertEqual(
q.filters,
query.ConjunctionNode([
query.FilterNode('Age', '>=', 42),
query.FilterNode('rank', '<=', 5)
]))
def testModernQuerySyntax(self):
class Employee(model.Model):
name = model.StringProperty()
age = model.IntegerProperty('Age')
rank = model.IntegerProperty()
@classmethod
def seniors(cls, min_age, min_rank):
q = cls.query().filter(cls.age >= min_age, cls.rank <= min_rank)
q = q.order(cls.name, -cls.age)
return q
q = Employee.seniors(42, 5)
self.assertEqual(q.filters,
query.ConjunctionNode(
[query.FilterNode('Age', '>=', 42),
query.FilterNode('rank', '<=', 5)]))
self.assertEqual(query.orders_to_orderings(q.orders),
[('name', query.ASC), ('Age', query.DESC)])
def testSingletonInFilter(self):
class Employee(model.Model):
name = model.StringProperty()
q = Employee.query(Employee.name.IN(['xyzzy']))
self.assertEqual(q.filters, query.FilterNode('name', '=', 'xyzzy'))
self.assertNotEqual(q.filters, 42)
e = Employee(name='xyzzy')
e.put()
self.assertEqual(q.get(), e)
def testNodeComparisons(self):
a = query.FilterNode('foo', '=', 1)
b = query.FilterNode('foo', '=', 1)
c = query.FilterNode('foo', '=', 2)
d = query.FilterNode('foo', '<', 1)
# Don't use assertEqual/assertNotEqual; we want to be sure that
# __eq__ or __ne__ is really called here!
self.assertTrue(a == b)
self.assertTrue(a != c)
self.assertTrue(b != d)
self.assertRaises(TypeError, lambda: a < b)
self.assertRaises(TypeError, lambda: a <= b)
self.assertRaises(TypeError, lambda: a > b)
self.assertRaises(TypeError, lambda: a >= b)
x = query.AND(a, b, c)
y = query.AND(a, b, c)
z = query.AND(a, d)
self.assertTrue(x == y)
self.assertTrue(x != z)
def send_rfps_to_subscribers(self):
"""
As the function name implies, all subscribed users will receive an RFP update to their
email accounts. By comparing an RFP's parse date to a subscription's last update date,
we ensure dups aren't being sent out.
Returns a list of results based on what happened for each subscription.
"""
results = []
subs = Subscription.all()
for sub in subs:
try:
# Grab what user info, add first, last name later
user = User.query(
query.FilterNode('username', '=', sub.username)).get()
# Ensure the the sub's username is associated with an actual account
# by checking if the email exists.
if user.email:
self._send_rfps_to_subscribers(sub, user.first_name,
user.email, results)
else:
msg = 'No email found for username: %s and keyword: %s' % (
sub.username, sub.keyword)
logging.info(msg)
results.append('Error: ' + msg)
except:
msg = 'Problem with sending RFPs for some subscription, maybe bad user object'
logging.info(msg)
results.append('Error: ' + msg)
return results
