def test_all_feed_with_permission(self):
actual = apply_feed_filter(self.query,
'bid',
'all',
user=self.hidden_user)
expected = self.query
self.assertSetEqual(set(actual), set(expected))
def test_to_process_feed_with_permission(self):
actual = apply_feed_filter(self.query,
'donation',
'toprocess',
user=self.donation_user)
expected = self.query.filter(
Q(commentstate='PENDING') | Q(readstate='PENDING'))
self.assertSetEqual(set(actual), set(expected))
def queryset(self, request, queryset):
if self.value() is not None:
feed, params = ReadOffsetTokenPair(self.value())
params['noslice'] = True
return search_feeds.apply_feed_filter(queryset, 'donation', feed,
params, request.user)
else:
return queryset
def test_todraw_feed_after_event_with_date(self):
actual = apply_feed_filter(
self.query,
'prize',
'todraw',
{'time': self.event.prize_drawing_date},
self.prize_user,
)
expected = self.accepted_prizes
self.assertSetEqual(set(actual), set(expected))
def test_todraw_feed_during_event_with_date(self):
actual = apply_feed_filter(
self.query,
'prize',
'todraw',
{'time': self.event.speedrun_set.last().endtime},
self.prize_user,
)
expected = []
self.assertSetEqual(set(actual), set(expected))
def run_model_query(model, params, user=None):
user = user or AnonymousUser()
params = params.copy() if params else {}
model = normalize_model_param(model)
filtered = _ModelMap[model].objects.all()
filter_accumulator = Q()
if model in _ModelDefaultQuery:
filter_accumulator &= _ModelDefaultQuery[model]
pk = single(params, 'id', None)
pks = single(params, 'ids', None)
# technically speaking it's a viable query but why would you do this
if pk and pks:
raise KeyError('Cannot combine `id` with `ids` query')
if pk:
filter_accumulator &= Q(pk=pk)
if pks:
filter_accumulator &= Q(pk__in=pks.split(','))
# arguably does not make sense if combined with id or ids, but I can think of some use cases, so just let it go for now
q = params.pop('q', None)
if q:
filter_accumulator &= model_general_filter(model, q, user)
feed = single(params, 'feed', None)
feed_params = {
k: single(params, k)
for k in [
'noslice',
'delta',
'time',
'maxDonations',
'minDonations',
'maxRuns',
'minRuns',
]
if k in params
}
filter_accumulator &= model_specific_filter(model, params, user)
filtered = filtered.filter(filter_accumulator)
if model in ['bid', 'bidtarget', 'allbids']:
filtered = filtered.order_by(*Bid._meta.ordering)
filtered = apply_feed_filter(filtered, model, feed, feed_params, user)
if 'maxRuns' in feed_params or 'minRuns' in feed_params:
return filtered # stupid hack
return filtered.distinct()
def test_todraw_feed_with_expired_winner(self):
# hasn't expired yet
models.PrizeWinner.objects.create(
winner=self.donations[0].donor,
prize=self.accepted_prizes[0],
acceptdeadline=self.event.prize_drawing_date +
datetime.timedelta(days=14),
)
# accepted
models.PrizeWinner.objects.create(
winner=self.donations[0].donor,
prize=self.accepted_prizes[1],
acceptcount=1,
pendingcount=0,
acceptdeadline=self.event.prize_drawing_date +
datetime.timedelta(days=12),
)
# no expiration
models.PrizeWinner.objects.create(
winner=self.donations[0].donor,
prize=self.accepted_prizes[2],
)
# expired
models.PrizeWinner.objects.create(
winner=self.donations[0].donor,
prize=self.accepted_prizes[3],
acceptdeadline=self.event.prize_drawing_date +
datetime.timedelta(days=12),
)
actual = apply_feed_filter(
self.query,
'prize',
'todraw',
{
'time':
self.event.prize_drawing_date + datetime.timedelta(days=14)
},
self.prize_user,
)
expected = self.accepted_prizes[3:]
self.assertSetEqual(set(actual), set(expected))
def test_pending_feed_with_permission(self):
actual = apply_feed_filter(self.query, 'bid', 'pending', user=self.hidden_user)
expected = self.query.filter(state='PENDING')
self.assertSetEqual(set(actual), set(expected))
def test_all_feed_without_permission(self):
with self.assertRaises(PermissionDenied):
apply_feed_filter(self.query, 'prize', 'all')
def test_all_feed(self):
actual = apply_feed_filter(self.query, 'prize', 'all', {}, self.prize_user)
expected = self.query
self.assertSetEqual(set(actual), set(expected))
def test_to_read_feed_with_permission(self):
actual = apply_feed_filter(self.query, 'donation', 'toread')
expected = self.query.filter(Q(readstate='READY'))
self.assertSetEqual(set(actual), set(expected))
def test_default_feed(self):
actual = apply_feed_filter(self.query, 'prize', None)
expected = self.query.filter(state='ACCEPTED')
self.assertSetEqual(set(actual), set(expected))
def test_to_process_feed_without_permission(self):
with self.assertRaises(PermissionDenied):
apply_feed_filter(self.query, 'donation', 'toprocess')
def test_no_feed(self):
actual = apply_feed_filter(self.query, 'donation', None)
expected = self.query.filter(transactionstate='COMPLETED')
self.assertSetEqual(set(actual), set(expected))
def test_open_feed(self):
actual = apply_feed_filter(self.query, 'bid', 'open')
expected = self.query.filter(state='OPENED')
self.assertSetEqual(set(actual), set(expected))
def test_pending_feed_without_permission(self):
with self.assertRaises(PermissionDenied):
apply_feed_filter(self.query, 'bid', 'pending')
def test_closed_feed(self):
actual = apply_feed_filter(self.query, 'bid', 'closed')
expected = self.query.filter(state='CLOSED')
self.assertSetEqual(set(actual), set(expected))
