def create_notes(self):
notes = [
Note.create(user=self.admin, message='admin'),
Note.create(user=self.normal, message='normal'),
]
self.admin_note, self.normal_note = notes
return notes
def test_filtering(self):
users, notes = self.get_users_and_notes()
# do a simple filter on a related model
resp = self.app.get('/api/note/?user=%s&ordering=id' % self.normal.id)
resp_json = self.response_json(resp)
self.assertAPIMeta(resp_json, {
'model': 'note',
'previous': '',
'next': '',
'page': 1,
})
self.assertAPINotes(resp_json, self.normal.note_set.order_by(Note.id))
# do a filter following a join
resp = self.app.get('/api/note/?user__username=admin&ordering=id')
resp_json = self.response_json(resp)
self.assertAPIMeta(resp_json, {
'model': 'note',
'previous': '',
'next': '',
'page': 1,
})
self.assertAPINotes(resp_json, self.admin.note_set.order_by(Note.id))
# filter multiple fields
notes = list(self.admin.note_set.order_by(Note.id))
third_id = notes[3].id
resp = self.app.get(
'/api/note/?user__username=admin&id__lt=%s&ordering=id' % third_id)
resp_json = self.response_json(resp)
self.assertAPINotes(resp_json, notes[:3])
# do a filter using multiple values
resp = self.app.get(
'/api/note/?user__username=admin&user__username=inactive&ordering=id'
)
resp_json = self.response_json(resp)
self.assertAPIMeta(resp_json, {
'model': 'note',
'previous': '',
'next': '',
'page': 1,
})
self.assertAPINotes(
resp_json,
Note.filter(user__in=[self.admin, self.inactive]).order_by(
Note.id))
# do a filter with a negation
resp = self.app.get('/api/note/?-user__username=admin&ordering=id')
resp_json = self.response_json(resp)
self.assertAPINotes(
resp_json,
Note.filter(user__in=[self.normal, self.inactive]).order_by(
Note.id))
def create_notes(self):
notes = [
Note.create(user=self.admin, message='admin'),
Note.create(user=self.normal, message='normal'),
]
self.admin_note, self.normal_note = notes
return notes
def setUp(self):
Note.drop_table(True)
Message.drop_table(True)
User.drop_table(True)
User.create_table()
Message.create_table()
Note.create_table()
self.flask_app = test_app.app
self.flask_app._template_context = {}
self.app = test_app.app.test_client()
def setUp(self):
Note.drop_table(True)
Message.drop_table(True)
User.drop_table(True)
User.create_table()
Message.create_table()
Note.create_table()
self.flask_app = test_app.app
self.flask_app._template_context = {}
self.app = test_app.app.test_client()
def test_filtering(self):
users, notes = self.get_users_and_notes()
# do a simple filter on a related model
resp = self.app.get('/api/note/?user=%s&ordering=id' % self.normal.id)
resp_json = self.response_json(resp)
self.assertAPIMeta(resp_json, {
'model': 'note',
'previous': '',
'next': '',
'page': 1,
})
self.assertAPINotes(resp_json, self.normal.note_set.order_by(Note.id))
# do a filter following a join
resp = self.app.get('/api/note/?user__username=admin&ordering=id')
resp_json = self.response_json(resp)
self.assertAPIMeta(resp_json, {
'model': 'note',
'previous': '',
'next': '',
'page': 1,
})
self.assertAPINotes(resp_json, self.admin.note_set.order_by(Note.id))
# filter multiple fields
notes = list(self.admin.note_set.order_by(Note.id))
third_id = notes[3].id
resp = self.app.get('/api/note/?user__username=admin&id__lt=%s&ordering=id' % third_id)
resp_json = self.response_json(resp)
self.assertAPINotes(resp_json, notes[:3])
# do a filter using multiple values
resp = self.app.get('/api/note/?user__username=admin&user__username=inactive&ordering=id')
resp_json = self.response_json(resp)
self.assertAPIMeta(resp_json, {
'model': 'note',
'previous': '',
'next': '',
'page': 1,
})
self.assertAPINotes(resp_json, Note.filter(user__in=[self.admin, self.inactive]).order_by(Note.id))
# do a filter with a negation
resp = self.app.get('/api/note/?-user__username=admin&ordering=id')
resp_json = self.response_json(resp)
self.assertAPINotes(resp_json, Note.filter(user__in=[
self.normal, self.inactive]).order_by(Note.id))
def test_panel_simple(self):
users = self.create_users()
with self.flask_app.test_client() as c:
self.login(c)
self.assertEqual(Note.select().count(), 0)
resp = c.post('/admin/notes/create/', data={'message': 'testing'})
self.assertEqual(resp.status_code, 302)
self.assertTrue(resp.headers['location'].endswith('/admin/'))
self.assertEqual(Note.select().count(), 1)
note = Note.get(user=self.admin)
self.assertEqual(note.message, 'testing')
def test_model_admin_index_pagination(self):
users = self.create_users()
notes = {}
for user in users:
notes[user] = [Note.create(user=user, message='test-%d' % i) for i in range(20)]
with self.flask_app.test_client() as c:
self.login(c)
# test a simple lookup
resp = c.get('/admin/note/?ordering=id')
self.assertEqual(resp.status_code, 200)
query = self.get_context('query')
self.assertEqual(list(query.get_list()), notes[users[0]])
resp = c.get('/admin/note/?ordering=id&page=2')
self.assertEqual(resp.status_code, 200)
query = self.get_context('query')
self.assertEqual(list(query.get_list()), notes[users[1]])
resp = c.get('/admin/note/?ordering=id&page=1&user=%d&user=%d' % (users[1].id, users[2].id))
self.assertEqual(resp.status_code, 200)
query = self.get_context('query')
self.assertEqual(list(query.get_list()), notes[users[1]])
resp = c.get('/admin/note/?ordering=id&page=2&user=%d&user=%d' % (users[1].id, users[2].id))
self.assertEqual(resp.status_code, 200)
query = self.get_context('query')
self.assertEqual(list(query.get_list()), notes[users[2]])
def get_users_and_notes(self):
users = self.create_users()
notes = []
for i in range(10):
for user in users:
notes.append(Note.create(user=user, message='%s-%s' % (user.username, i)))
return users, notes
def get_users_and_notes(self):
users = self.create_users()
notes = []
for i in range(10):
for user in users:
notes.append(Note.create(user=user, message='%s-%s' % (user.username, i)))
return users, notes
def test_delete(self):
self.create_notes()
url = '/api/note/%s/' % self.admin_note.id
# authorized as an admin
resp = self.app.delete(url, headers=self.auth_headers('normal', 'normal'))
self.assertEqual(resp.status_code, 200)
self.assertEqual(Note.select().count(), 1)
resp_json = self.response_json(resp)
self.assertEqual(resp_json, {'deleted': 1})
def test_create(self):
note_data = {'message': 'test', 'user': self.inactive.id}
serialized = json.dumps(note_data)
# authorized as an admin
resp = self.app.post('/api/note/', data=serialized, headers=self.auth_headers('normal', 'normal'))
self.assertEqual(resp.status_code, 200)
new_note = Note.get(message='test')
self.assertEqual(new_note.user, self.inactive)
resp_json = self.response_json(resp)
self.assertAPINote(resp_json, new_note)
def test_create(self):
note_data = {'message': 'test', 'user': self.inactive.id}
serialized = json.dumps(note_data)
# authorized as an admin
resp = self.app.post('/api/note/', data=serialized, headers=self.auth_headers('normal', 'normal'))
self.assertEqual(resp.status_code, 200)
new_note = Note.get(message='test')
self.assertEqual(new_note.user, self.inactive)
resp_json = self.response_json(resp)
self.assertAPINote(resp_json, new_note)
def test_delete(self):
self.create_notes()
url = '/api/note/%s/' % self.admin_note.id
# authorized as an admin
resp = self.app.delete(url, headers=self.auth_headers('normal', 'normal'))
self.assertEqual(resp.status_code, 200)
self.assertEqual(Note.select().count(), 1)
resp_json = self.response_json(resp)
self.assertEqual(resp_json, {'deleted': 1})
def test_edit(self):
self.create_notes()
note_data = {'message': 'edited'}
serialized = json.dumps(note_data)
url = '/api/note/%s/' % self.admin_note.id
# authorized as an admin
resp = self.app.put(url, data=serialized, headers=self.auth_headers('normal', 'normal'))
self.assertEqual(resp.status_code, 200)
note = Note.get(id=self.admin_note.id)
self.assertEqual(note.message, 'edited')
resp_json = self.response_json(resp)
self.assertAPINote(resp_json, note)
def test_edit(self):
self.create_notes()
note_data = {'message': 'edited'}
serialized = json.dumps(note_data)
url = '/api/note/%s/' % self.admin_note.id
# authorized as an admin
resp = self.app.put(url, data=serialized, headers=self.auth_headers('normal', 'normal'))
self.assertEqual(resp.status_code, 200)
note = Note.get(id=self.admin_note.id)
self.assertEqual(note.message, 'edited')
resp_json = self.response_json(resp)
self.assertAPINote(resp_json, note)
def test_model_admin_index_filters(self):
users = self.create_users()
notes = {}
for user in users:
notes[user] = [Note.create(user=user, message='test-%d' % i) for i in range(3)]
norm2 = self.create_user('normal2', 'normal2')
with self.flask_app.test_client() as c:
self.login(c)
# test a simple lookup
resp = c.get('/admin/user/?username__eq=admin')
self.assertEqual(resp.status_code, 200)
self.assertContext('user', self.admin)
self.assertContext('model_admin', admin._registry[User])
self.assertContext('ordering', '')
query = self.get_context('query')
self.assertEqual(list(query.get_list()), [
self.admin,
])
# test a lookup using multiple values joined with "eq"
resp = c.get('/admin/user/?username__eq=admin&username__eq=normal&ordering=-username')
self.assertEqual(resp.status_code, 200)
query = self.get_context('query')
self.assertEqual(list(query.get_list()), [
self.normal,
self.admin,
])
resp = c.get('/admin/user/?username__eq=admin&username__eq=normal&ordering=-username')
self.assertEqual(resp.status_code, 200)
query = self.get_context('query')
self.assertEqual(list(query.get_list()), [
self.normal,
self.admin,
])
# test a lookup using partial string
resp = c.get('/admin/user/?username__istartswith=norm&ordering=-username')
self.assertEqual(resp.status_code, 200)
query = self.get_context('query')
self.assertEqual(list(query.get_list()), [
norm2,
self.normal,
])
# test a lookup spanning a relation
resp = c.get('/admin/note/?user__eq=%d' % self.normal.id)
self.assertEqual(resp.status_code, 200)
self.assertContext('model_admin', admin._registry[Note])
query = self.get_context('query')
self.assertEqual(list(query.get_list()), notes[self.normal])
# test a multi-value lookup spanning a relation
resp = c.get('/admin/note/?user__in=%d&user__in=%d' % (self.normal.id, self.admin.id))
self.assertEqual(resp.status_code, 200)
self.assertContext('model_admin', admin._registry[Note])
query = self.get_context('query')
expected_notes = notes[self.admin] + notes[self.normal]
self.assertEqual(list(query.get_list()), expected_notes)
def test_model_admin_recursive_delete(self):
self.create_users()
m1 = Message.create(user=self.normal, content='test1')
m2 = Message.create(user=self.normal, content='test2')
m3 = Message.create(user=self.admin, content='test3')
n1 = Note.create(user=self.normal, message='test1')
n2 = Note.create(user=self.normal, message='test2')
n3 = Note.create(user=self.admin, message='test3')
a1 = AModel.create(a_field='a1')
a2 = AModel.create(a_field='a2')
b1 = BModel.create(b_field='b1', a=a1)
b2 = BModel.create(b_field='b2', a=a2)
bd1= BDetails.create(b=b1)
bd2= BDetails.create(b=b2)
c1 = CModel.create(c_field='c1', b=b1)
c2 = CModel.create(c_field='c2', b=b2)
d1 = DModel.create(d_field='d1', c=c1)
d2 = DModel.create(d_field='d2', c=c2)
with self.flask_app.test_client() as c:
self.login(c)
resp = c.get('/admin/amodel/delete/?id=%d' % (a1.id))
self.assertEqual(resp.status_code, 200)
collected = self.get_context('collected')
self.assertEqual(collected, {
a1.id: [
(1, BModel, 'a', [b1]),
(2, BDetails, 'a', [bd1]),
(2, CModel, 'a', [c1]),
(3, DModel, 'a', [d1]),
]
})
resp = c.post('/admin/amodel/delete/', data={'id': a1.id})
self.assertEqual(resp.status_code, 302)
self.assertEqual(AModel.select().count(), 1)
self.assertEqual(BModel.select().count(), 1)
self.assertEqual(BDetails.select().count(), 1)
self.assertEqual(CModel.select().count(), 1)
self.assertEqual(DModel.select().count(), 1)
# send it a single id
resp = c.get('/admin/user/delete/?id=%d' % (self.normal.id))
self.assertEqual(resp.status_code, 200)
query = self.get_context('query')
self.assertEqual(list(query), [self.normal])
collected = self.get_context('collected')
self.assertEqual(len(collected), 1)
u_k = collected[self.normal.id]
self.assertEqual(len(u_k), 2)
self.assertEqual(u_k, [
(1, Message, 'user', [m1, m2]),
(1, Note, 'user', [n1, n2]),
])
# post to it, get a redirect on success
resp = c.post('/admin/user/delete/', data={'id': self.normal.id})
self.assertEqual(resp.status_code, 302)
self.assertEqual(User.select().count(), 2)
self.assertEqual(Message.select().count(), 1)
self.assertEqual(Note.select().count(), 1)
resp = c.get('/admin/user/delete/?id=%d&id=%d' % (self.admin.id, self.inactive.id))
self.assertEqual(resp.status_code, 200)
collected = self.get_context('collected')
self.assertEqual(len(collected), 2)
u_k = collected[self.admin.id]
self.assertEqual(len(u_k), 2)
self.assertEqual(u_k, [
(1, Message, 'user', [m3]),
(1, Note, 'user', [n3]),
])
u_k = collected[self.inactive.id]
self.assertEqual(len(u_k), 0)
# post to it, get a redirect on success
resp = c.post('/admin/user/delete/', data={'id': [self.admin.id, self.inactive.id]})
self.assertEqual(resp.status_code, 302)
self.assertEqual(User.select().count(), 0)
self.assertEqual(Message.select().count(), 0)
self.assertEqual(Note.select().count(), 0)
def test_filtering(self):
users, notes = self.get_users_and_notes()
# do a simple filter on a related model
resp = self.app.get('/api/note/?user=%s&ordering=id' % self.normal.id)
resp_json = self.response_json(resp)
self.assertAPIMeta(resp_json, {
'model': 'note',
'previous': '',
'next': '',
'page': 1,
})
self.assertAPINotes(resp_json, self.normal.note_set.order_by(Note.id))
# do a filter following a join
resp = self.app.get('/api/note/?user__username=admin&ordering=id')
resp_json = self.response_json(resp)
self.assertAPIMeta(resp_json, {
'model': 'note',
'previous': '',
'next': '',
'page': 1,
})
self.assertAPINotes(resp_json, self.admin.note_set.order_by(Note.id))
# filter multiple fields
notes = list(self.admin.note_set.order_by(Note.id))
third_id = notes[3].id
resp = self.app.get('/api/note/?user__username=admin&id__lt=%s&ordering=id' % third_id)
resp_json = self.response_json(resp)
self.assertAPINotes(resp_json, notes[:3])
# do a filter using multiple values
resp = self.app.get('/api/note/?user__username=admin&user__username=inactive&ordering=id')
resp_json = self.response_json(resp)
self.assertAPIMeta(resp_json, {
'model': 'note',
'previous': '',
'next': '',
'page': 1,
})
self.assertAPINotes(resp_json, Note.filter(user__in=[self.admin, self.inactive]).order_by(Note.id))
# do a filter with a negation
resp = self.app.get('/api/note/?-user__username=admin&ordering=id')
resp_json = self.response_json(resp)
self.assertAPINotes(resp_json, Note.filter(user__in=[
self.normal, self.inactive]).order_by(Note.id))
# do a filter with an IN operator and multiple IDs
# https://github.com/coleifer/flask-peewee/issues/112
resp = self.app.get('/api/note/?id__in=1,2,5')
resp_json = self.response_json(resp)
self.assertAPINotes(resp_json, Note.filter(id__in=[1,2,5]).order_by(Note.id))
# also test that the IN operator works with list of strings
resp = self.app.get('/api/user/?username__in=admin,normal')
resp_json = self.response_json(resp)
self.assertAPIUsers(resp_json, User.filter(username__in=['admin', 'normal']).order_by(User.id))
def test_filtering(self):
users, notes = self.get_users_and_notes()
# do a simple filter on a related model
resp = self.app.get('/api/note/?user=%s&ordering=id' % self.normal.id)
resp_json = self.response_json(resp)
self.assertAPIMeta(resp_json, {
'model': 'note',
'previous': '',
'next': '',
'page': 1,
})
self.assertAPINotes(resp_json, self.normal.note_set.order_by(Note.id))
# do a filter following a join
resp = self.app.get('/api/note/?user__username=admin&ordering=id')
resp_json = self.response_json(resp)
self.assertAPIMeta(resp_json, {
'model': 'note',
'previous': '',
'next': '',
'page': 1,
})
self.assertAPINotes(resp_json, self.admin.note_set.order_by(Note.id))
# filter multiple fields
notes = list(self.admin.note_set.order_by(Note.id))
third_id = notes[3].id
resp = self.app.get(
'/api/note/?user__username=admin&id__lt=%s&ordering=id' % third_id)
resp_json = self.response_json(resp)
self.assertAPINotes(resp_json, notes[:3])
# do a filter using multiple values
resp = self.app.get(
'/api/note/?user__username=admin&user__username=inactive&ordering=id'
)
resp_json = self.response_json(resp)
self.assertAPIMeta(resp_json, {
'model': 'note',
'previous': '',
'next': '',
'page': 1,
})
self.assertAPINotes(
resp_json,
Note.filter(user__in=[self.admin, self.inactive]).order_by(
Note.id))
# do a filter with a negation
resp = self.app.get('/api/note/?-user__username=admin&ordering=id')
resp_json = self.response_json(resp)
self.assertAPINotes(
resp_json,
Note.filter(user__in=[self.normal, self.inactive]).order_by(
Note.id))
# do a filter with an IN operator and multiple IDs
# https://github.com/coleifer/flask-peewee/issues/112
resp = self.app.get('/api/note/?id__in=1,2,5')
resp_json = self.response_json(resp)
self.assertAPINotes(resp_json,
Note.filter(id__in=[1, 2, 5]).order_by(Note.id))
# also test that the IN operator works with list of strings
resp = self.app.get('/api/user/?username__in=admin,normal')
resp_json = self.response_json(resp)
self.assertAPIUsers(
resp_json,
User.filter(username__in=['admin', 'normal']).order_by(User.id))
