290f8fd51e
tailbone grid template still duplicates much for Vue, and will until we can port the filters and anything else remaining..
574 lines
23 KiB
Python
574 lines
23 KiB
Python
# -*- coding: utf-8; -*-
|
|
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
from sqlalchemy import orm
|
|
|
|
from tailbone.grids import core as mod
|
|
from tests.util import WebTestCase
|
|
|
|
|
|
class TestGrid(WebTestCase):
|
|
|
|
def setUp(self):
|
|
self.setup_web()
|
|
self.config.setdefault('rattail.web.menus.handler_spec', 'tests.util:NullMenuHandler')
|
|
|
|
def make_grid(self, key=None, data=[], **kwargs):
|
|
return mod.Grid(self.request, key=key, data=data, **kwargs)
|
|
|
|
def test_basic(self):
|
|
grid = self.make_grid('foo')
|
|
self.assertIsInstance(grid, mod.Grid)
|
|
|
|
def test_deprecated_params(self):
|
|
|
|
# component
|
|
grid = self.make_grid()
|
|
self.assertEqual(grid.vue_tagname, 'tailbone-grid')
|
|
grid = self.make_grid(component='blarg')
|
|
self.assertEqual(grid.vue_tagname, 'blarg')
|
|
|
|
# default_sortkey, default_sortdir
|
|
grid = self.make_grid()
|
|
self.assertEqual(grid.sort_defaults, [])
|
|
grid = self.make_grid(default_sortkey='name')
|
|
self.assertEqual(grid.sort_defaults, [mod.SortInfo('name', 'asc')])
|
|
grid = self.make_grid(default_sortdir='desc')
|
|
self.assertEqual(grid.sort_defaults, [])
|
|
grid = self.make_grid(default_sortkey='name', default_sortdir='desc')
|
|
self.assertEqual(grid.sort_defaults, [mod.SortInfo('name', 'desc')])
|
|
|
|
# pageable
|
|
grid = self.make_grid()
|
|
self.assertFalse(grid.paginated)
|
|
grid = self.make_grid(pageable=True)
|
|
self.assertTrue(grid.paginated)
|
|
|
|
# default_pagesize
|
|
grid = self.make_grid()
|
|
self.assertEqual(grid.pagesize, 20)
|
|
grid = self.make_grid(default_pagesize=15)
|
|
self.assertEqual(grid.pagesize, 15)
|
|
|
|
# default_page
|
|
grid = self.make_grid()
|
|
self.assertEqual(grid.page, 1)
|
|
grid = self.make_grid(default_page=42)
|
|
self.assertEqual(grid.page, 42)
|
|
|
|
def test_vue_tagname(self):
|
|
|
|
# default
|
|
grid = self.make_grid('foo')
|
|
self.assertEqual(grid.vue_tagname, 'tailbone-grid')
|
|
|
|
# can override with param
|
|
grid = self.make_grid('foo', vue_tagname='something-else')
|
|
self.assertEqual(grid.vue_tagname, 'something-else')
|
|
|
|
# can still pass old param
|
|
grid = self.make_grid('foo', component='legacy-name')
|
|
self.assertEqual(grid.vue_tagname, 'legacy-name')
|
|
|
|
def test_vue_component(self):
|
|
|
|
# default
|
|
grid = self.make_grid('foo')
|
|
self.assertEqual(grid.vue_component, 'TailboneGrid')
|
|
|
|
# can override with param
|
|
grid = self.make_grid('foo', vue_tagname='something-else')
|
|
self.assertEqual(grid.vue_component, 'SomethingElse')
|
|
|
|
# can still pass old param
|
|
grid = self.make_grid('foo', component='legacy-name')
|
|
self.assertEqual(grid.vue_component, 'LegacyName')
|
|
|
|
def test_component(self):
|
|
|
|
# default
|
|
grid = self.make_grid('foo')
|
|
self.assertEqual(grid.component, 'tailbone-grid')
|
|
|
|
# can override with param
|
|
grid = self.make_grid('foo', vue_tagname='something-else')
|
|
self.assertEqual(grid.component, 'something-else')
|
|
|
|
# can still pass old param
|
|
grid = self.make_grid('foo', component='legacy-name')
|
|
self.assertEqual(grid.component, 'legacy-name')
|
|
|
|
def test_component_studly(self):
|
|
|
|
# default
|
|
grid = self.make_grid('foo')
|
|
self.assertEqual(grid.component_studly, 'TailboneGrid')
|
|
|
|
# can override with param
|
|
grid = self.make_grid('foo', vue_tagname='something-else')
|
|
self.assertEqual(grid.component_studly, 'SomethingElse')
|
|
|
|
# can still pass old param
|
|
grid = self.make_grid('foo', component='legacy-name')
|
|
self.assertEqual(grid.component_studly, 'LegacyName')
|
|
|
|
def test_actions(self):
|
|
|
|
# default
|
|
grid = self.make_grid('foo')
|
|
self.assertEqual(grid.actions, [])
|
|
|
|
# main actions
|
|
grid = self.make_grid('foo', main_actions=['foo'])
|
|
self.assertEqual(grid.actions, ['foo'])
|
|
|
|
# more actions
|
|
grid = self.make_grid('foo', main_actions=['foo'], more_actions=['bar'])
|
|
self.assertEqual(grid.actions, ['foo', 'bar'])
|
|
|
|
def test_set_label(self):
|
|
model = self.app.model
|
|
grid = self.make_grid(model_class=model.Setting)
|
|
self.assertEqual(grid.labels, {})
|
|
|
|
# basic
|
|
grid.set_label('name', "NAME COL")
|
|
self.assertEqual(grid.labels['name'], "NAME COL")
|
|
|
|
# can replace label
|
|
grid.set_label('name', "Different")
|
|
self.assertEqual(grid.labels['name'], "Different")
|
|
self.assertEqual(grid.get_label('name'), "Different")
|
|
|
|
# can update only column, not filter
|
|
self.assertEqual(grid.labels, {'name': "Different"})
|
|
self.assertIn('name', grid.filters)
|
|
self.assertEqual(grid.filters['name'].label, "Different")
|
|
grid.set_label('name', "COLUMN ONLY", column_only=True)
|
|
self.assertEqual(grid.get_label('name'), "COLUMN ONLY")
|
|
self.assertEqual(grid.filters['name'].label, "Different")
|
|
|
|
def test_get_view_click_handler(self):
|
|
model = self.app.model
|
|
grid = self.make_grid(model_class=model.Setting)
|
|
|
|
grid.actions.append(
|
|
mod.GridAction(self.request, 'view',
|
|
click_handler='clickHandler(props.row)'))
|
|
|
|
handler = grid.get_view_click_handler()
|
|
self.assertEqual(handler, 'clickHandler(props.row)')
|
|
|
|
def test_set_action_urls(self):
|
|
model = self.app.model
|
|
grid = self.make_grid(model_class=model.Setting)
|
|
|
|
grid.actions.append(
|
|
mod.GridAction(self.request, 'view', url='/blarg'))
|
|
|
|
setting = {'name': 'foo', 'value': 'bar'}
|
|
grid.set_action_urls(setting, setting, 0)
|
|
self.assertEqual(setting['_action_url_view'], '/blarg')
|
|
|
|
def test_default_sortkey(self):
|
|
grid = self.make_grid()
|
|
self.assertEqual(grid.sort_defaults, [])
|
|
self.assertIsNone(grid.default_sortkey)
|
|
grid.default_sortkey = 'name'
|
|
self.assertEqual(grid.sort_defaults, [mod.SortInfo('name', 'asc')])
|
|
self.assertEqual(grid.default_sortkey, 'name')
|
|
grid.default_sortkey = 'value'
|
|
self.assertEqual(grid.sort_defaults, [mod.SortInfo('value', 'asc')])
|
|
self.assertEqual(grid.default_sortkey, 'value')
|
|
|
|
def test_default_sortdir(self):
|
|
grid = self.make_grid()
|
|
self.assertEqual(grid.sort_defaults, [])
|
|
self.assertIsNone(grid.default_sortdir)
|
|
self.assertRaises(ValueError, setattr, grid, 'default_sortdir', 'asc')
|
|
grid.sort_defaults = [mod.SortInfo('name', 'asc')]
|
|
grid.default_sortdir = 'desc'
|
|
self.assertEqual(grid.sort_defaults, [mod.SortInfo('name', 'desc')])
|
|
self.assertEqual(grid.default_sortdir, 'desc')
|
|
|
|
def test_pageable(self):
|
|
grid = self.make_grid()
|
|
self.assertFalse(grid.paginated)
|
|
grid.pageable = True
|
|
self.assertTrue(grid.paginated)
|
|
grid.paginated = False
|
|
self.assertFalse(grid.pageable)
|
|
|
|
def test_get_pagesize_options(self):
|
|
grid = self.make_grid()
|
|
|
|
# default
|
|
options = grid.get_pagesize_options()
|
|
self.assertEqual(options, [5, 10, 20, 50, 100, 200])
|
|
|
|
# override default
|
|
options = grid.get_pagesize_options(default=[42])
|
|
self.assertEqual(options, [42])
|
|
|
|
# from legacy config
|
|
self.config.setdefault('tailbone.grid.pagesize_options', '1 2 3')
|
|
grid = self.make_grid()
|
|
options = grid.get_pagesize_options()
|
|
self.assertEqual(options, [1, 2, 3])
|
|
|
|
# from new config
|
|
self.config.setdefault('wuttaweb.grids.default_pagesize_options', '4, 5, 6')
|
|
grid = self.make_grid()
|
|
options = grid.get_pagesize_options()
|
|
self.assertEqual(options, [4, 5, 6])
|
|
|
|
def test_get_pagesize(self):
|
|
grid = self.make_grid()
|
|
|
|
# default
|
|
size = grid.get_pagesize()
|
|
self.assertEqual(size, 20)
|
|
|
|
# override default
|
|
size = grid.get_pagesize(default=42)
|
|
self.assertEqual(size, 42)
|
|
|
|
# override default options
|
|
self.config.setdefault('wuttaweb.grids.default_pagesize_options', '10 15 30')
|
|
grid = self.make_grid()
|
|
size = grid.get_pagesize()
|
|
self.assertEqual(size, 10)
|
|
|
|
# from legacy config
|
|
self.config.setdefault('tailbone.grid.default_pagesize', '12')
|
|
grid = self.make_grid()
|
|
size = grid.get_pagesize()
|
|
self.assertEqual(size, 12)
|
|
|
|
# from new config
|
|
self.config.setdefault('wuttaweb.grids.default_pagesize', '15')
|
|
grid = self.make_grid()
|
|
size = grid.get_pagesize()
|
|
self.assertEqual(size, 15)
|
|
|
|
def test_set_sorter(self):
|
|
model = self.app.model
|
|
grid = self.make_grid(model_class=model.Setting,
|
|
sortable=True, sort_on_backend=True)
|
|
|
|
# passing None will remove sorter
|
|
self.assertIn('name', grid.sorters)
|
|
grid.set_sorter('name', None)
|
|
self.assertNotIn('name', grid.sorters)
|
|
|
|
# can recreate sorter with just column name
|
|
grid.set_sorter('name')
|
|
self.assertIn('name', grid.sorters)
|
|
grid.remove_sorter('name')
|
|
self.assertNotIn('name', grid.sorters)
|
|
grid.set_sorter('name', 'name')
|
|
self.assertIn('name', grid.sorters)
|
|
|
|
# can recreate sorter with model property
|
|
grid.remove_sorter('name')
|
|
self.assertNotIn('name', grid.sorters)
|
|
grid.set_sorter('name', model.Setting.name)
|
|
self.assertIn('name', grid.sorters)
|
|
|
|
# extra kwargs are ignored
|
|
grid.remove_sorter('name')
|
|
self.assertNotIn('name', grid.sorters)
|
|
grid.set_sorter('name', model.Setting.name, foo='bar')
|
|
self.assertIn('name', grid.sorters)
|
|
|
|
# passing multiple args will invoke make_filter() directly
|
|
grid.remove_sorter('name')
|
|
self.assertNotIn('name', grid.sorters)
|
|
with patch.object(grid, 'make_sorter') as make_sorter:
|
|
make_sorter.return_value = 42
|
|
grid.set_sorter('name', 'foo', 'bar')
|
|
make_sorter.assert_called_once_with('foo', 'bar')
|
|
self.assertEqual(grid.sorters['name'], 42)
|
|
|
|
def test_make_simple_sorter(self):
|
|
model = self.app.model
|
|
grid = self.make_grid(model_class=model.Setting,
|
|
sortable=True, sort_on_backend=True)
|
|
|
|
# delegates to grid.make_sorter()
|
|
with patch.object(grid, 'make_sorter') as make_sorter:
|
|
make_sorter.return_value = 42
|
|
sorter = grid.make_simple_sorter('name', foldcase=True)
|
|
make_sorter.assert_called_once_with('name', foldcase=True)
|
|
self.assertEqual(sorter, 42)
|
|
|
|
def test_load_settings(self):
|
|
model = self.app.model
|
|
|
|
# nb. first use a paging grid
|
|
grid = self.make_grid(key='foo', paginated=True, paginate_on_backend=True,
|
|
pagesize=20, page=1)
|
|
|
|
# settings are loaded, applied, saved
|
|
self.assertEqual(grid.page, 1)
|
|
self.assertNotIn('grid.foo.page', self.request.session)
|
|
self.request.GET = {'pagesize': '10', 'page': '2'}
|
|
grid.load_settings()
|
|
self.assertEqual(grid.page, 2)
|
|
self.assertEqual(self.request.session['grid.foo.page'], 2)
|
|
|
|
# can skip the saving step
|
|
self.request.GET = {'pagesize': '10', 'page': '3'}
|
|
grid.load_settings(store=False)
|
|
self.assertEqual(grid.page, 3)
|
|
self.assertEqual(self.request.session['grid.foo.page'], 2)
|
|
|
|
# no error for non-paginated grid
|
|
grid = self.make_grid(key='foo', paginated=False)
|
|
grid.load_settings()
|
|
self.assertFalse(grid.paginated)
|
|
|
|
# nb. next use a sorting grid
|
|
grid = self.make_grid(key='settings', model_class=model.Setting,
|
|
sortable=True, sort_on_backend=True)
|
|
|
|
# settings are loaded, applied, saved
|
|
self.assertEqual(grid.sort_defaults, [])
|
|
self.assertFalse(hasattr(grid, 'active_sorters'))
|
|
self.request.GET = {'sort1key': 'name', 'sort1dir': 'desc'}
|
|
grid.load_settings()
|
|
self.assertEqual(grid.active_sorters, [{'key': 'name', 'dir': 'desc'}])
|
|
self.assertEqual(self.request.session['grid.settings.sorters.length'], 1)
|
|
self.assertEqual(self.request.session['grid.settings.sorters.1.key'], 'name')
|
|
self.assertEqual(self.request.session['grid.settings.sorters.1.dir'], 'desc')
|
|
|
|
# can skip the saving step
|
|
self.request.GET = {'sort1key': 'name', 'sort1dir': 'asc'}
|
|
grid.load_settings(store=False)
|
|
self.assertEqual(grid.active_sorters, [{'key': 'name', 'dir': 'asc'}])
|
|
self.assertEqual(self.request.session['grid.settings.sorters.length'], 1)
|
|
self.assertEqual(self.request.session['grid.settings.sorters.1.key'], 'name')
|
|
self.assertEqual(self.request.session['grid.settings.sorters.1.dir'], 'desc')
|
|
|
|
# no error for non-sortable grid
|
|
grid = self.make_grid(key='foo', sortable=False)
|
|
grid.load_settings()
|
|
self.assertFalse(grid.sortable)
|
|
|
|
# with sort defaults
|
|
grid = self.make_grid(model_class=model.Setting, sortable=True,
|
|
sort_on_backend=True, sort_defaults='name')
|
|
self.assertFalse(hasattr(grid, 'active_sorters'))
|
|
grid.load_settings()
|
|
self.assertEqual(grid.active_sorters, [{'key': 'name', 'dir': 'asc'}])
|
|
|
|
# with multi-column sort defaults
|
|
grid = self.make_grid(model_class=model.Setting, sortable=True,
|
|
sort_on_backend=True)
|
|
grid.sort_defaults = [
|
|
mod.SortInfo('name', 'asc'),
|
|
mod.SortInfo('value', 'desc'),
|
|
]
|
|
self.assertFalse(hasattr(grid, 'active_sorters'))
|
|
grid.load_settings()
|
|
self.assertEqual(grid.active_sorters, [{'key': 'name', 'dir': 'asc'}])
|
|
|
|
# load settings from session when nothing is in request
|
|
self.request.GET = {}
|
|
self.request.session.invalidate()
|
|
self.assertNotIn('grid.settings.sorters.length', self.request.session)
|
|
self.request.session['grid.settings.sorters.length'] = 1
|
|
self.request.session['grid.settings.sorters.1.key'] = 'name'
|
|
self.request.session['grid.settings.sorters.1.dir'] = 'desc'
|
|
grid = self.make_grid(key='settings', model_class=model.Setting,
|
|
sortable=True, sort_on_backend=True,
|
|
paginated=True, paginate_on_backend=True)
|
|
self.assertFalse(hasattr(grid, 'active_sorters'))
|
|
grid.load_settings()
|
|
self.assertEqual(grid.active_sorters, [{'key': 'name', 'dir': 'desc'}])
|
|
|
|
def test_persist_settings(self):
|
|
model = self.app.model
|
|
|
|
# nb. start out with paginated-only grid
|
|
grid = self.make_grid(key='foo', paginated=True, paginate_on_backend=True)
|
|
|
|
# invalid dest
|
|
self.assertRaises(ValueError, grid.persist_settings, {}, dest='doesnotexist')
|
|
|
|
# nb. no error if empty settings, but it saves null values
|
|
grid.persist_settings({}, dest='session')
|
|
self.assertIsNone(self.request.session['grid.foo.page'])
|
|
|
|
# provided values are saved
|
|
grid.persist_settings({'pagesize': 15, 'page': 3}, dest='session')
|
|
self.assertEqual(self.request.session['grid.foo.page'], 3)
|
|
|
|
# nb. now switch to sortable-only grid
|
|
grid = self.make_grid(key='settings', model_class=model.Setting,
|
|
sortable=True, sort_on_backend=True)
|
|
|
|
# no error if empty settings; does not save values
|
|
grid.persist_settings({}, dest='session')
|
|
self.assertNotIn('grid.settings.sorters.length', self.request.session)
|
|
|
|
# provided values are saved
|
|
grid.persist_settings({'sorters.length': 2,
|
|
'sorters.1.key': 'name',
|
|
'sorters.1.dir': 'desc',
|
|
'sorters.2.key': 'value',
|
|
'sorters.2.dir': 'asc'},
|
|
dest='session')
|
|
self.assertEqual(self.request.session['grid.settings.sorters.length'], 2)
|
|
self.assertEqual(self.request.session['grid.settings.sorters.1.key'], 'name')
|
|
self.assertEqual(self.request.session['grid.settings.sorters.1.dir'], 'desc')
|
|
self.assertEqual(self.request.session['grid.settings.sorters.2.key'], 'value')
|
|
self.assertEqual(self.request.session['grid.settings.sorters.2.dir'], 'asc')
|
|
|
|
# old values removed when new are saved
|
|
grid.persist_settings({'sorters.length': 1,
|
|
'sorters.1.key': 'name',
|
|
'sorters.1.dir': 'desc'},
|
|
dest='session')
|
|
self.assertEqual(self.request.session['grid.settings.sorters.length'], 1)
|
|
self.assertEqual(self.request.session['grid.settings.sorters.1.key'], 'name')
|
|
self.assertEqual(self.request.session['grid.settings.sorters.1.dir'], 'desc')
|
|
self.assertNotIn('grid.settings.sorters.2.key', self.request.session)
|
|
self.assertNotIn('grid.settings.sorters.2.dir', self.request.session)
|
|
|
|
def test_sort_data(self):
|
|
model = self.app.model
|
|
sample_data = [
|
|
{'name': 'foo1', 'value': 'ONE'},
|
|
{'name': 'foo2', 'value': 'two'},
|
|
{'name': 'foo3', 'value': 'ggg'},
|
|
{'name': 'foo4', 'value': 'ggg'},
|
|
{'name': 'foo5', 'value': 'ggg'},
|
|
{'name': 'foo6', 'value': 'six'},
|
|
{'name': 'foo7', 'value': 'seven'},
|
|
{'name': 'foo8', 'value': 'eight'},
|
|
{'name': 'foo9', 'value': 'nine'},
|
|
]
|
|
for setting in sample_data:
|
|
self.app.save_setting(self.session, setting['name'], setting['value'])
|
|
self.session.commit()
|
|
sample_query = self.session.query(model.Setting)
|
|
|
|
grid = self.make_grid(model_class=model.Setting,
|
|
sortable=True, sort_on_backend=True,
|
|
sort_defaults=('name', 'desc'))
|
|
grid.load_settings()
|
|
|
|
# can sort a simple list of data
|
|
sorted_data = grid.sort_data(sample_data)
|
|
self.assertIsInstance(sorted_data, list)
|
|
self.assertEqual(len(sorted_data), 9)
|
|
self.assertEqual(sorted_data[0]['name'], 'foo9')
|
|
self.assertEqual(sorted_data[-1]['name'], 'foo1')
|
|
|
|
# can also sort a data query
|
|
sorted_query = grid.sort_data(sample_query)
|
|
self.assertIsInstance(sorted_query, orm.Query)
|
|
sorted_data = sorted_query.all()
|
|
self.assertEqual(len(sorted_data), 9)
|
|
self.assertEqual(sorted_data[0]['name'], 'foo9')
|
|
self.assertEqual(sorted_data[-1]['name'], 'foo1')
|
|
|
|
# cannot sort data if sorter missing in overrides
|
|
sorted_data = grid.sort_data(sample_data, sorters=[])
|
|
# nb. sorted data is in same order as original sample (not sorted)
|
|
self.assertEqual(sorted_data[0]['name'], 'foo1')
|
|
self.assertEqual(sorted_data[-1]['name'], 'foo9')
|
|
|
|
# multi-column sorting for list data
|
|
sorted_data = grid.sort_data(sample_data, sorters=[{'key': 'value', 'dir': 'asc'},
|
|
{'key': 'name', 'dir': 'asc'}])
|
|
self.assertEqual(dict(sorted_data[0]), {'name': 'foo8', 'value': 'eight'})
|
|
self.assertEqual(dict(sorted_data[1]), {'name': 'foo3', 'value': 'ggg'})
|
|
self.assertEqual(dict(sorted_data[3]), {'name': 'foo5', 'value': 'ggg'})
|
|
self.assertEqual(dict(sorted_data[-1]), {'name': 'foo2', 'value': 'two'})
|
|
|
|
# multi-column sorting for query
|
|
sorted_query = grid.sort_data(sample_query, sorters=[{'key': 'value', 'dir': 'asc'},
|
|
{'key': 'name', 'dir': 'asc'}])
|
|
self.assertEqual(dict(sorted_data[0]), {'name': 'foo8', 'value': 'eight'})
|
|
self.assertEqual(dict(sorted_data[1]), {'name': 'foo3', 'value': 'ggg'})
|
|
self.assertEqual(dict(sorted_data[3]), {'name': 'foo5', 'value': 'ggg'})
|
|
self.assertEqual(dict(sorted_data[-1]), {'name': 'foo2', 'value': 'two'})
|
|
|
|
# cannot sort data if sortfunc is missing for column
|
|
grid.remove_sorter('name')
|
|
sorted_data = grid.sort_data(sample_data, sorters=[{'key': 'value', 'dir': 'asc'},
|
|
{'key': 'name', 'dir': 'asc'}])
|
|
# nb. sorted data is in same order as original sample (not sorted)
|
|
self.assertEqual(sorted_data[0]['name'], 'foo1')
|
|
self.assertEqual(sorted_data[-1]['name'], 'foo9')
|
|
|
|
def test_render_vue_tag(self):
|
|
model = self.app.model
|
|
|
|
# standard
|
|
grid = self.make_grid('settings', model_class=model.Setting)
|
|
html = grid.render_vue_tag()
|
|
self.assertIn('<tailbone-grid', html)
|
|
self.assertNotIn('@deleteActionClicked', html)
|
|
|
|
# with delete hook
|
|
master = MagicMock(deletable=True, delete_confirm='simple')
|
|
master.has_perm.return_value = True
|
|
grid = self.make_grid('settings', model_class=model.Setting)
|
|
html = grid.render_vue_tag(master=master)
|
|
self.assertIn('<tailbone-grid', html)
|
|
self.assertIn('@deleteActionClicked', html)
|
|
|
|
def test_render_vue_template(self):
|
|
# self.pyramid_config.include('tailbone.views.common')
|
|
model = self.app.model
|
|
|
|
# sanity check
|
|
grid = self.make_grid('settings', model_class=model.Setting)
|
|
html = grid.render_vue_template(session=self.session)
|
|
self.assertIn('<b-table', html)
|
|
|
|
def test_get_vue_columns(self):
|
|
model = self.app.model
|
|
|
|
# sanity check
|
|
grid = self.make_grid('settings', model_class=model.Setting, sortable=True)
|
|
columns = grid.get_vue_columns()
|
|
self.assertEqual(len(columns), 2)
|
|
self.assertEqual(columns[0]['field'], 'name')
|
|
self.assertTrue(columns[0]['sortable'])
|
|
self.assertEqual(columns[1]['field'], 'value')
|
|
self.assertTrue(columns[1]['sortable'])
|
|
|
|
def test_get_vue_data(self):
|
|
model = self.app.model
|
|
|
|
# sanity check
|
|
grid = self.make_grid('settings', model_class=model.Setting)
|
|
data = grid.get_vue_data()
|
|
self.assertEqual(data, [])
|
|
|
|
# calling again returns same data
|
|
data2 = grid.get_vue_data()
|
|
self.assertIs(data2, data)
|
|
|
|
|
|
class TestGridAction(WebTestCase):
|
|
|
|
def test_constructor(self):
|
|
|
|
# null by default
|
|
action = mod.GridAction(self.request, 'view')
|
|
self.assertIsNone(action.target)
|
|
self.assertIsNone(action.click_handler)
|
|
|
|
# but can set them
|
|
action = mod.GridAction(self.request, 'view',
|
|
target='_blank',
|
|
click_handler='doSomething(props.row)')
|
|
self.assertEqual(action.target, '_blank')
|
|
self.assertEqual(action.click_handler, 'doSomething(props.row)')
|