def test_can_limit_items_returned_by_iteration(self): self.proxy = QueryResultProxy(self.query).limit(2) assert_equals(['foo', 'bar'], self._names(self.proxy)) self.proxy = QueryResultProxy(self.query).limit(20) assert_equals(['foo', 'bar', 'baz', 'quux', 'quuux'], self._names(self.proxy))
def test_can_iterate_over_results(self): filter_ = lambda item: item.activity >= 2 self.proxy = QueryResultProxy(self.query, filter_=filter_) assert_true(hasattr(self.proxy, '__iter__')) results = list(self.proxy) assert_equals(['baz', 'quux', 'quuux'], self._names(results))
def filter_restricted_items(self, query, permission_name, perm): if self._can_apply_access_restrictions_to_query(query, permission_name): return self._apply_access_restrictions_to_query(query, permission_name, perm) can_access_item = \ lambda item: perm.contains_permission(permission_name, item.resource) return QueryResultProxy(query, filter_=can_access_item)
def test_can_tell_length_if_no_more_items_available(self): filter_ = lambda item: item.activity >= 2 self.proxy = QueryResultProxy(self.query, filter_=filter_) assert_true(hasattr(self.proxy, '__len__')) assert_length(3, self.proxy.fetch(10)) assert_false(self.proxy.more_available()) assert_length(3, self.proxy)
def _apply_access_restrictions_to_query(self, query, permission_name, perm): conditions = [] for policy in self.policies_for_permission(permission_name): result = policy.access_condition_for_query(query, permission_name, perm) if result == True: return QueryResultProxy(query) elif result == False: return StaticQuery([]) elif result is None: continue condition = result if isinstance(result, tuple): condition, query = result conditions.append(condition) if len(conditions) == 0: # if there is no condition which can possibly allow the access, # we should not return any items return StaticQuery([]) restricted_query = query.distinct().filter(or_(*conditions)) return QueryResultProxy(restricted_query)
def test_can_fetch_single_item(self): filter_ = lambda item: item.activity >= 4 self.proxy = QueryResultProxy(self.query, filter_=filter_) assert_equals('quuux', self._name(self.proxy.first())) assert_equals(None, self.proxy.first())
def setUp(self): self.engine = create_engine('sqlite:///:memory:') self.session = self._create_session() self._populate_database() self.query = self.session.query(User).order_by(asc(User.id)) self.proxy = QueryResultProxy(self.query)
def test_can_specify_how_many_items_should_be_fetched_by_default(self): self.proxy = QueryResultProxy(self.query, default_fetch=3) self.proxy.more_available() assert_equals(3, len(self.proxy._prefetched_items))
def test_can_tell_length(self): filter_ = lambda item: item.activity >= 2 self.proxy = QueryResultProxy(self.query, filter_=filter_) assert_length(3, self.proxy)
def test_accepts_strings_for_offset(self): # that's what SQLAlchemy does (sic!) self.proxy = QueryResultProxy(self.query).offset('1') assert_equals(['bar', 'baz', 'quux', 'quuux'], self._names(self.proxy))
def test_can_offset_for_iteration(self): self.proxy = QueryResultProxy(self.query).offset(3) assert_equals(['quux', 'quuux'], self._names(self.proxy))
def test_accepts_strings_for_limit(self): # that's what SQLAlchemy does (sic!) self.proxy = QueryResultProxy(self.query).limit('1') assert_equals(['foo'], self._names(self.proxy))
def test_proxy_returns_always_specified_number_of_items_if_possible(self): filter_ = lambda item: item.activity >= 2 self.proxy = QueryResultProxy(self.query, filter_=filter_) assert_equals(['baz', 'quux', 'quuux'], self._next_names(n=3)) assert_false(self.proxy.more_available())
def test_can_specify_filter_callable(self): filter_ = lambda item: item.activity % 2 == 1 self.proxy = QueryResultProxy(self.query, filter_=filter_) assert_equals(['bar', 'quux'], self._next_names(n=5)) assert_false(self.proxy.more_available())
def test_can_initialize_proxy_with_offset(self): self.proxy = QueryResultProxy(self.query, start=2) assert_equals(['baz', 'quux'], self._next_names(n=2))