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_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_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_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_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_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_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_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_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_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 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 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_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_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_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 __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_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 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 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 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