def test_sort_noforce_reverse_w_limit_timsort(self):
from BTrees.IFBTree import IFSet
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5])
# Add enough items to make 'fwscan_wins' return False.
for i in range(100, 10000):
index.index_doc(i, i)
c1.insert(i)
result = index.sort(c1, reverse=True, limit=301) # waaa
self.assertEqual(list(result), range(9999, 9698, -1))
def test_sort_noforce_reverse_w_limit_timsort(self):
from BTrees.IFBTree import IFSet
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5])
# Add enough items to make 'fwscan_wins' return False.
for i in range(100, 10000):
index.index_doc(i, i)
c1.insert(i)
result = index.sort(c1, reverse=True, limit=301) # waaa
self.assertEqual(list(result), range(9999, 9698, -1))
def test_search_index_returns_empty(self):
from BTrees.IFBTree import IFSet
catalog = self._makeOne()
c1 = IFSet([])
idx1 = DummyIndex(c1)
catalog['name1'] = idx1
c2 = IFSet([3, 4, 5])
idx2 = DummyIndex(c2)
catalog['name2'] = idx2
numdocs, result = catalog.search(name1={}, name2={})
self.assertEqual(numdocs, 0)
self.assertEqual(list(result), [])
def test_apply(self):
catalog = self._makeOne()
from BTrees.IFBTree import IFSet
c1 = IFSet([1, 2, 3])
idx1 = DummyIndex(c1)
catalog['name1'] = idx1
c2 = IFSet([3, 4, 5])
idx2 = DummyIndex(c2)
catalog['name2'] = idx2
numdocs, result = catalog.apply({'name1': {}, 'name2': {}})
self.assertEqual(numdocs, 1)
self.assertEqual(list(result), [3])
def test_search(self):
from BTrees.IFBTree import IFSet
catalog = self._makeOne()
c1 = IFSet([1, 2, 3])
idx1 = DummyIndex(c1)
catalog['name1'] = idx1
c2 = IFSet([3, 4, 5])
idx2 = DummyIndex(c2)
catalog['name2'] = idx2
numdocs, result = catalog.search(name1={}, name2={})
self.assertEqual(numdocs, 1)
self.assertEqual(numdocs.total, 1)
self.assertEqual(list(result), [3])
def test_search_with_sortindex_ascending(self):
catalog = self._makeOne()
from BTrees.IFBTree import IFSet
c1 = IFSet([1, 2, 3, 4, 5])
idx1 = DummyIndex(c1)
catalog['name1'] = idx1
c2 = IFSet([3, 4, 5])
idx2 = DummyIndex(c2)
catalog['name2'] = idx2
numdocs, result = catalog.search(name1={},
name2={},
sort_index='name1')
self.assertEqual(numdocs, 3)
self.assertEqual(list(result), ['sorted1', 'sorted2', 'sorted3'])
def test_sort_bad_sort_type_reverse(self):
from BTrees.IFBTree import IFSet
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5])
self.assertRaises(ValueError,
index.sort, c1, reverse=True, sort_type='nonesuch')
def test_sort_badlimit(self):
from BTrees.IFBTree import IFSet
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5])
result = index.sort(c1, limit=0)
self.assertRaises(ValueError, list, result)
def test_sort_noforce_no_limit(self):
from BTrees.IFBTree import IFSet
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5])
result = index.sort(c1)
self.assertEqual(list(result), [5, 2, 1, 3, 4])
def test_sort_force_nbest_no_limit_raises(self):
from BTrees.IFBTree import IFSet
from repoze.catalog.indexes.field import NBEST
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5])
self.assertRaises(ValueError, index.sort, c1, sort_type=NBEST)
def test_sort_noforce_reverse_w_limit(self):
from BTrees.IFBTree import IFSet
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5])
result = index.sort(c1, reverse=True, limit=3)
self.assertEqual(list(result), [4, 3, 1])
def test_sort_nonlazy_withlimit(self):
from BTrees.IFBTree import IFSet
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5])
result = index.sort(c1, limit=3)
self.assertEqual(list(result), [5, 2, 1])
def test_sort_no_docids(self):
from BTrees.IFBTree import IFSet
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet()
result = index.sort(c1)
self.assertEqual(list(result), [])
def test_sort_nonlazy_missingdocid(self):
from BTrees.IFBTree import IFSet
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5, 99])
result = index.sort(c1)
self.assertEqual(list(result), [5, 2, 1, 3, 4]) # 99 not present
def test_sort_force_timsort_reverse_withlimit(self):
from BTrees.IFBTree import IFSet
from repoze.catalog.indexes.field import TIMSORT
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5])
result = index.sort(c1, reverse=True, limit=3, sort_type=TIMSORT)
self.assertEqual(list(result), [4, 3, 1])
def test_sort_bad_sort_type_reverse_fwscan(self):
from BTrees.IFBTree import IFSet
from repoze.catalog.indexes.field import FWSCAN
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5])
self.assertRaises(ValueError,
index.sort, c1, reverse=True, sort_type=FWSCAN)
def test_sort_force_nbest_reverse_missing_docid(self):
from BTrees.IFBTree import IFSet
from repoze.catalog.indexes.field import NBEST
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5, 99])
result = index.sort(c1, reverse=True, limit=3, sort_type=NBEST)
self.assertEqual(list(result), [4, 3, 1])
def test_it(self):
from pyramid.security import Allow, Deny, Everyone
from karl.security.policy import ALL
acl_one = ((Allow, 'a', 'view'), (Allow, 'b', 'view'))
acl_two = (
(Allow, 'c', 'view'),
(Allow, 'd', 'view'),
)
acl_three = (
(Allow, 'd', ALL),
(Allow, 'e', 'view'),
(Deny, Everyone, ALL),
)
from BTrees.IFBTree import IFSet
data = []
data.append([(
0,
[acl_one],
), IFSet([0])])
data.append([(1, [acl_one, acl_two]), IFSet([1, 2, 3])])
data.append([(2, [acl_one, acl_two, acl_three]), IFSet([4, 5, 6])])
data.append([(3, [acl_one]), IFSet()])
checker = self._makeOne(('a', Everyone), 'view')
result = checker(data)
self.assertEqual(list(result), [0, 1, 2, 3])
checker = self._makeOne(('b', Everyone), 'view')
result = checker(data)
self.assertEqual(list(result), [0, 1, 2, 3])
checker = self._makeOne(('c', Everyone), 'view')
result = checker(data)
self.assertEqual(list(result), [1, 2, 3])
checker = self._makeOne(('d', Everyone), 'view')
result = checker(data)
self.assertEqual(list(result), [1, 2, 3, 4, 5, 6])
checker = self._makeOne(('e', Everyone), 'view')
result = checker(data)
self.assertEqual(list(result), [4, 5, 6])
checker = self._makeOne(('nobody', Everyone), 'view')
result = checker(data)
self.assertEqual(list(result), [])
def test_sort_force_nbest(self):
from BTrees.IFBTree import IFSet
from repoze.catalog.indexes.field import NBEST
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5])
result = index.sort(c1, limit=3, sort_type=NBEST)
self.assertEqual(list(result), [5, 2, 1])
def test_sort_nbest_missing_reverse(self):
from BTrees.IFBTree import IFSet
index = self._makeOne()
index._use_nbest = True
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5, 99])
result = index.sort(c1, reverse=True, limit=3)
self.assertEqual(list(result), [4, 3, 1])
def apply(self, cache, context=None):
index = self.getIndex(context)
try:
return index.apply(self.text)
except ParseError:
logger.error('search text "{}" yielded a ParseError'.format(
self.text))
return IFSet()
def test_sort_force_timsort_reverse_missing_docid(self):
from BTrees.IFBTree import IFSet
from repoze.catalog.indexes.field import TIMSORT
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5, 99])
result = index.sort(c1, reverse=True, sort_type=TIMSORT)
r = list(result)
self.assertEqual(r, [4, 3, 1, 2, 5]) # 99 not present
def test_sort_force_fwscan_missing_docid(self):
from BTrees.IFBTree import IFSet
from repoze.catalog.indexes.field import FWSCAN
index = self._makeOne()
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5, 99])
result = index.sort(c1, sort_type=FWSCAN)
r = list(result)
self.assertEqual(r, [5, 2, 1, 3, 4]) # 99 not present
def test_sort_force_fwscan_no_limit(self):
from BTrees.IFBTree import IFSet
from repoze.catalog.indexes.field import FWSCAN
index = self._makeOne()
index.force_scan = True
self._populateIndex(index)
c1 = IFSet([1, 2, 3, 4, 5])
result = index.sort(c1, sort_type=FWSCAN)
self.assertEqual(list(result), [5, 2, 1, 3, 4])
def test_limited(self):
catalog = self._makeOne()
from BTrees.IFBTree import IFSet
c1 = IFSet([1, 2, 3, 4, 5])
idx1 = DummyIndex(c1)
catalog['name1'] = idx1
numdocs, result = catalog.search(name1={}, sort_index='name1', limit=1)
self.assertEqual(numdocs, 1)
self.assertEqual(idx1.limit, 1)
def test_search_with_sort_type(self):
catalog = self._makeOne()
from BTrees.IFBTree import IFSet
c1 = IFSet([1, 2, 3, 4, 5])
idx1 = DummyIndex(c1)
catalog['name1'] = idx1
from repoze.catalog.indexes.field import FWSCAN
numdocs, result = catalog.search(name1={}, sort_index='name1',
limit=1, sort_type=FWSCAN)
self.assertEqual(idx1.sort_type, FWSCAN)
def __call__(self, result):
sets = []
for (docid, acls), set in result:
if not set:
continue
if self.check_acls(acls):
sets.append(set)
if not sets:
return IFSet()
return multiunion(sets)
def test_sort_noforce_nbest(self):
from BTrees.IFBTree import IFSet
index = self._makeOne()
self._populateIndex(index)
# Add enough items to make 'fwscan_wins' return False.
for i in range(100, 10000):
index.index_doc(i, i)
c1 = IFSet([1, 2, 3, 4, 5])
# Reasonable 'limit' means nbest
result = index.sort(c1, limit=3)
self.assertEqual(list(result), [5, 2, 1])
def apply(self, cache, context=None):
results = []
for term in self.terms:
result = term.cached_apply(cache, context)
# empty results
if not result:
continue
results.append(result)
if len(results) == 0:
return IFSet()
if len(results) == 1:
return results[0]
return multiunion(results)
def apply(self, cache, context=None):
results = []
index = self.getIndex(context)
for value in self.values:
r = index.apply((value, value))
# empty results
if not r:
continue
results.append(r)
if len(results) == 0:
return IFSet()
if len(results) == 1:
return results[0]
return multiunion(results)
def apply(self, cache, context=None):
results = []
for index, term in enumerate(self.terms):
result = term.cached_apply(cache, context)
# If we do not have any results for the first index, just
# return an empty set and stop here.
if not result:
if not index:
return IFSet()
continue # pragma: no cover (peephole optimizer interferes)
results.append(result)
result = results.pop(0)
for other in results:
result = difference(result, other)
if not result:
# Empty results
return result
return result
