def testMultiQueryIterator(self): q = query.Query(kind='Foo').filter(Foo.tags.IN(['joe', 'jill'])) q = q.order(Foo.name) @tasklets.synctasklet def foo(): it = iter(q) res = [] while (yield it.has_next_async()): val = it.next() res.append(val) self.assertEqual(res, [self.jill, self.joe]) foo()
def testFetchAsync(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) @tasklets.synctasklet def foo(): res = yield q.fetch_async(10) self.assertEqual(res, [self.jill, self.joe]) res = yield q.fetch_async(2) self.assertEqual(res, [self.jill, self.joe]) res = yield q.fetch_async(1) self.assertEqual(res, [self.jill]) foo()
def testIterAsync(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) @tasklets.synctasklet def foo(): it = iter(q) res = [] while (yield it.has_next_async()): val = it.next() res.append(val) self.assertEqual(res, [self.jill, self.joe]) foo()
def testFullDistributiveLaw(self): q = query.Query(kind='Foo').filter(Foo.tags.IN(['jill', 'hello'])) q = q.filter(Foo.rate.IN([1, 2])) DisjunctionNode = query.DisjunctionNode ConjunctionNode = query.ConjunctionNode FilterNode = query.FilterNode expected = DisjunctionNode( [ConjunctionNode([FilterNode('tags', '=', 'jill'), FilterNode('rate', '=', 1)]), ConjunctionNode([FilterNode('tags', '=', 'jill'), FilterNode('rate', '=', 2)]), ConjunctionNode([FilterNode('tags', '=', 'hello'), FilterNode('rate', '=', 1)]), ConjunctionNode([FilterNode('tags', '=', 'hello'), FilterNode('rate', '=', 2)])]) self.assertEqual(q.filters, expected)
def testMapAsync(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) callback = lambda e: e.name @tasklets.tasklet def callback_async(e): yield tasklets.sleep(0.01) raise tasklets.Return(e.name) @tasklets.synctasklet def foo(): fut = q.map_async(callback) res = yield fut self.assertEqual(res, ['jill', 'joe']) fut = q.map_async(callback_async) res = yield fut self.assertEqual(res, ['jill', 'joe']) foo()
def testCursorsKeysOnly(self): q = query.Query(kind='Foo') it = q.iter(produce_cursors=True, keys_only=True) expected = [self.joe.key, self.jill.key, self.moe.key] self.assertRaises(datastore_errors.BadArgumentError, it.cursor_before) self.assertRaises(datastore_errors.BadArgumentError, it.cursor_after) before = [] after = [] for i, ent in enumerate(it): self.assertEqual(ent, expected[i]) before.append(it.cursor_before()) after.append(it.cursor_after()) before.append(it.cursor_before()) after.append(it.cursor_after()) self.assertEqual(before[1], after[0]) self.assertEqual(before[2], after[1]) self.assertEqual(before[3], after[2]) self.assertEqual(before[3], after[3]) # !!!
def foo(): key1 = model.Key(flat=('Foo', 1)) key2 = model.Key(flat=('Foo', 2)) ent1 = model.Expando(key=key1, foo=42, bar='hello') ent2 = model.Expando(key=key2, foo=1, bar='world') key1a, key2a = yield self.ctx.put(ent1), self.ctx.put(ent2) self.assertTrue(key1 in self.ctx._cache) # Whitebox. self.assertTrue(key2 in self.ctx._cache) # Whitebox. self.assertEqual(key1, key1a) self.assertEqual(key2, key2a) @tasklets.tasklet def callback(ent): return ent qry = query.Query(kind='Foo') results = yield self.ctx.map_query(qry, callback) self.assertEqual(results, [ent1, ent2]) self.assertTrue(results[0] is ent1) self.assertTrue(results[1] is ent2)
def testCursorsEfficientPaging(self): # We want to read a 'page' of data, get the cursor just past the # page, and know whether there is another page, all with a single # RPC. To do this, set limit=pagesize+1, batch_size=pagesize. q = query.Query(kind='Foo') cursors = {} mores = {} for pagesize in [1, 2, 3, 4]: it = q.iter(produce_cursors=True, limit=pagesize+1, batch_size=pagesize) todo = pagesize for ent in it: todo -= 1 if todo <= 0: break cursors[pagesize] = it.cursor_after() mores[pagesize] = it.probably_has_next() self.assertEqual(mores, {1: True, 2: True, 3: False, 4: False}) self.assertEqual(cursors[3], cursors[4])
def testFetchPage(self): # This test implicitly also tests fetch_page_async(). q = query.Query(kind='Foo') page_size = 1 res, curs, more = q.fetch_page(page_size) self.assertEqual(res, [self.joe]) self.assertTrue(more) res, curs, more = q.fetch_page(page_size, start_cursor=curs) self.assertEqual(res, [self.jill]) self.assertTrue(more) res, curs, more = q.fetch_page(page_size, start_cursor=curs) self.assertEqual(res, [self.moe]) self.assertFalse(more) res, curs, more = q.fetch_page(page_size, start_cursor=curs) self.assertEqual(res, []) self.assertFalse(more) page_size = 2 res, curs, more = q.fetch_page(page_size) self.assertEqual(res, [self.joe, self.jill]) self.assertTrue(more) res, curs, more = q.fetch_page(page_size, start_cursor=curs) self.assertEqual(res, [self.moe]) self.assertFalse(more) res, curs, more = q.fetch_page(page_size, start_cursor=curs) self.assertEqual(res, []) self.assertFalse(more) page_size = 3 res, curs, more = q.fetch_page(page_size) self.assertEqual(res, [self.joe, self.jill, self.moe]) self.assertFalse(more) res, curs, more = q.fetch_page(page_size, start_cursor=curs) self.assertEqual(res, []) self.assertFalse(more) page_size = 4 res, curs, more = q.fetch_page(page_size) self.assertEqual(res, [self.joe, self.jill, self.moe]) self.assertFalse(more) res, curs, more = q.fetch_page(page_size, start_cursor=curs) self.assertEqual(res, []) self.assertFalse(more)
def testCursors(self): qo = query.QueryOptions(produce_cursors=True) q = query.Query(kind='Foo') it = q.iter(options=qo) expected = [self.joe, self.jill, self.moe] self.assertRaises(datastore_errors.BadArgumentError, it.cursor_before) self.assertRaises(datastore_errors.BadArgumentError, it.cursor_after) before = [] after = [] for i, ent in enumerate(it): self.assertEqual(ent, expected[i]) before.append(it.cursor_before()) after.append(it.cursor_after()) before.append(it.cursor_before()) after.append(it.cursor_after()) self.assertEqual(before[1], after[0]) self.assertEqual(before[2], after[1]) self.assertEqual(before[3], after[2]) self.assertEqual(before[3], after[3]) # !!!
def testCountEmpty(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jillian') self.assertEqual(q.count(1), 0)
def testCount(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) self.assertEqual(q.count(10), 2) self.assertEqual(q.count(1), 1)
def testGetKeysOnly(self): qo = query.QueryOptions(keys_only=True) q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) self.assertEqual(q.get(options=qo), self.jill.key)
def testGetEmpty(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jillian') self.assertEqual(q.get(), None)
def foo(): yield self.create_entities() qry = query.Query(kind='Foo') res = yield self.ctx.map_query(qry, None) raise tasklets.Return(res)
def testOrderedQuery(self): q = query.Query(kind='Foo') q = q.order(Foo.rate).order().order(-Foo.name) res = list(q) self.assertEqual(res, [self.moe, self.joe, self.jill])
def testNotEqualOperator(self): q = query.Query(kind='Foo').filter(Foo.rate != 2) res = list(q) self.assertEqual(res, [self.joe, self.moe])
def testInOperator(self): q = query.Query(kind='Foo').filter(Foo.tags.IN(('jill', 'hello'))) res = list(q) self.assertEqual(res, [self.joe, self.jill])
def testFetch(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) self.assertEqual(q.fetch(10), [self.jill, self.joe]) self.assertEqual(q.fetch(1), [self.jill])
def testBasicQuery(self): q = query.Query(kind='Foo') q = q.filter(Foo.name >= 'joe').filter(Foo.name <= 'moe').filter() res = list(q) self.assertEqual(res, [self.joe, self.moe])
def testFetchEmpty(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jillian') self.assertEqual(q.fetch(1), [])
def testFetchKeysOnly(self): qo = query.QueryOptions(keys_only=True) q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) self.assertEqual(q.fetch(10, options=qo), [self.jill.key, self.joe.key])
def testGet(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) self.assertEqual(q.get(), self.jill)
def foo(): yield self.create_entities() qry = query.Query(kind='Foo') res = yield self.ctx.map_query(qry, callback, options=qo) raise tasklets.Return(res)
def testMultiQuery(self): q1 = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) q2 = query.Query(kind='Foo').filter(Foo.tags == 'joe').order(Foo.name) qq = query._MultiQuery([q1, q2]) res = list(qq) self.assertEqual(res, [self.jill, self.joe])