kodjo/MyManagingTools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
14be07720fc243aa1332d7268d82a5af5e499b3b
MyManagingTools/tests/test_datagrid.py

2106 lines
62 KiB
Python
Raw Blame History

from collections import OrderedDict
from datetime import datetime
import pytest
from components.datagrid.DataGrid import *
from helpers import matches, extract_popup_content, extract_table_values, Empty, to_array, search_elements_by_name, get_selected, \
get_context_menu
TEST_GRID_ID = "testing_grid_id"
@pytest.fixture()
def dg():
df = pd.DataFrame({
'Name': ['Alice', 'Bob'],
'Age': [20, 25]
})
return DataGrid(df, id=TEST_GRID_ID)
@pytest.fixture()
def dg2():
"""
More elements
:return:
"""
df = pd.DataFrame({
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [20, 25, 30, 35],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston'],
'Student': [True, False, True, False],
'Date': [datetime(2020, 1, 10), datetime(2022, 10, 1), datetime(2007, 1, 1), datetime(2000, 12, 31), ]
})
return DataGrid(df, id=TEST_GRID_ID)
@pytest.fixture()
def grid_id(dg):
return dg.get_grid_id()
def test_i_can_manage_instance():
datagrid_1 = DataGrid(id="id1")
datagrid_2 = DataGrid(id="id2")
datagrid_3 = DataGrid(id="id1")
assert datagrid_1 is not datagrid_2
assert datagrid_1 is datagrid_3
def test_i_can_render_empty_data_grid():
grid_id = "testing_grid"
dg = DataGrid(id=grid_id)
expected = Div(
Div(), # container for keyboard handlers
Div(
Div(id=f"tt_datagrid-{grid_id}"), # tooltip
Div(id=f"fa_datagrid-{grid_id}"), # filter component
Div(name="dt-controls"), # reset filter, resize, ...
cls="flex justify-between"),
Div(
Div(id=f"tsm_datagrid-{grid_id}"), # selection management
Div(id=f"tdd_datagrid-{grid_id}"), # drag and drop indicator
Div(id=f"tcdd_datagrid-{grid_id}"), # cell drop down
Div(), # navigation keyboards
Div(
Div(id=f"th_datagrid-{grid_id}"),
Div(id=f"tb_datagrid-{grid_id}"),
Div(id=f"tf_datagrid-{grid_id}"),
),
Script(),
id=f"t_datagrid-{grid_id}",
cls="dt-table"
)
)
res = dg.__ft__()
assert matches(res, expected)
def test_test_there_is_no_filter_input_when_gs_filter_input_is_false():
grid_id = "testing_grid"
grid_setting = {DG_FILTER_INPUT: False}
dg = DataGrid(id=grid_id, grid_settings=grid_setting)
expected = Div(
Div(), # container for keyboard handlers
Div(
Div(id=f"tt_datagrid-{grid_id}"), # tooltip
Div(Empty), # filter component
Div(name="dt-controls"), # reset filter, resize, ...
cls="flex justify-between"),
Div(
Div(id=f"tsm_datagrid-{grid_id}"), # selection management
Div(id=f"tdd_datagrid-{grid_id}"), # drag and drop indicator
Div(id=f"tcdd_datagrid-{grid_id}"), # cell drop down
Div(), # navigation keyboards
Div(
Div(id=f"th_datagrid-{grid_id}"),
Div(id=f"tb_datagrid-{grid_id}"),
Div(id=f"tf_datagrid-{grid_id}")),
Script(),
id=f"t_datagrid-{grid_id}",
cls="dt-table"
)
)
res = dg.__ft__()
assert matches(res, expected)
def test_there_is_no_filter_button_in_header_when_gs_filter_input_is_false():
grid_id = "testing_grid"
grid_setting = {DG_FILTER_INPUT: False}
df = pd.DataFrame({
'Name': ['Alice', 'Bob'],
'Age': [20, 25]
})
dg = DataGrid(df, id=grid_id, grid_settings=grid_setting)
header = dg.mk_table_header()
expected = Div(
Div(
Div(Div("Name")), # name
Div(Div()), # sort
Div(), # column clickable extension
Div(Empty), # No filtering icon
Div(Empty), # No filtering icon
Div(), # resize handle
cls='dt-cell dt-draggable dt-resizable', data_col='name'),
Div(
Div(Div("Age")), # name
Div(Div()), # sort
Div(), # column clickable extension
Div(Empty), # No filtering icon
Div(Empty), # No filtering icon
Div(), # resize handle
cls='dt-cell dt-draggable dt-resizable', data_col='age'),
)
assert matches(header, expected)
def test_i_can_generate_grid_html(dg, grid_id):
resize_attr = {"hx-on::after-settle": f"setColumnsWidths('{grid_id}', false);"}
expected = Div(
Div(
Div(
Div(Div("Name")),
Div(Div(), hx_post=f"/{DATAGRID_PATH}/sort"), # sort
Div(cls="dt-flex-grow"), # column clickable extension
Div(cls='icon-24 dt-filter-icon icon-btn'),
Div(cls="dt-filter-popup"),
Div(cls="dt-resize-handle"),
data_col="name"
),
Div(
Div(Div("Age")),
Div(Div(), hx_post=f"/{DATAGRID_PATH}/sort"), # sort
Div(cls="dt-flex-grow"), # column clickable extension
Div(cls='icon-24 dt-filter-icon icon-btn'),
Div(cls="dt-filter-popup"),
Div(cls="dt-resize-handle"),
data_col="age"
),
cls="dt-row dt-header",
id=f"th_{grid_id}"),
Div(
Div(
Div(Div("Alice"), data_col="name"),
Div(Div("20"), data_col="age"),
),
Div(
Div(Div("Bob"), data_col="name"),
Div(Div("25"), data_col="age"),
),
cls="dt-body",
id=f"tb_{grid_id}",
**resize_attr,
),
Div(
Div(
Div(Div(), data_col="name"),
Div(Div(), data_col="age"),
),
id=f"tf_{grid_id}")
)
res = dg.mk_table()
table = search_elements_by_name(res, None, {"class": "dt-inner-table"})[0]
# as_ft = debug_print(res)
matches(table, expected)
def test_i_can_render_boolean():
df = pd.DataFrame({
'Name': ['Alice', 'Bob'],
'Age': [20, 25],
'Is_Good': [True, False]
})
dg = DataGrid(df)
_grid_id = dg.get_grid_id()
expected = Div(
Div(
Div(Div("Alice")),
Div(Div("20")),
Div(Div(NotStr('<svg name="CheckboxChecked16Regular"'))),
),
Div(
Div(Div("Bob")),
Div(Div("25")),
Div(Div(NotStr('<svg name="CheckboxUnchecked16Regular"'))),
),
cls="dt-body",
id=f"tb_{_grid_id}")
res = dg.mk_table_body()
matches(res, expected)
def test_i_can_render_when_width_is_set():
grid_id = "testing_grid"
grid_setting = {DG_COLUMNS: {
"age": {
"index": 0,
"title": "Age",
"type": DG_DATATYPE_NUMBER,
"width": "150px"
},
"name": {
"index": 1,
"title": "Name",
"type": DG_DATATYPE_STRING,
}
}}
df = pd.DataFrame({
'Name': ['Alice', 'Bob'],
'Age': [20, 25]
})
dg = DataGrid(df, id=grid_id, grid_settings=grid_setting)
header = dg.mk_table_header()
expected = Div(
Div(
Div(Div("Age")),
cls='dt-cell dt-draggable dt-resizable dt-fixed-col', data_col='age', style="width:150px;"),
Div(
Div(Div("Name")),
cls='dt-cell dt-draggable dt-resizable', data_col='name')
)
assert matches(header, expected)
def test_i_can_compute_choices_values():
grid_settings = {DG_COLUMNS: {
"name": {
"index": 0,
"title": "Name",
},
"choice1": {
"index": 3, # Safe index should be used instead of this value
"title": "Choice1",
"type": DG_DATATYPE_CHOICE,
"values": ["A", "B", "C"],
},
"choice2": {
"index": 4, # Safe index should be used instead of this value
"title": "Choice2",
"type": DG_DATATYPE_CHOICE,
"values": ["Alpha", "Beta", "Gamma"],
}
}}
df = pd.DataFrame({
'Name': ['Alice', 'Bob', 'Charlie', 'Dave'],
'Choice1': ['A', 'B', 'C', None],
'Choice2': ['Gamma', 'Alpha', None, 'Beta'],
})
dg = DataGrid(df, grid_settings=grid_settings)
assert dg.get_state().choice_columns_values == {
1: {0: [True, False, False], 1: [False, True, False], 2: [False, False, True], 3: [False, False, False]},
2: {0: [False, False, True], 1: [True, False, False], 2: [False, False, False], 3: [False, True, False]},
}
#
# def test_i_can_render_choice():
# grid_settings = {DG_COLUMNS: {
# "name": {
# "index": 0,
# "title": "Name",
# },
# "choice": {
# "index": 1,
# "title": "Choice",
# "type": DG_DATATYPE_CHOICE,
# "values": ["A", "B", "C"],
# }
# }}
#
# df = pd.DataFrame({
# 'Name': ['Alice', 'Bob', 'Charlie'],
# })
#
# dg = DataGrid(df, grid_settings=grid_settings)
#
# _grid_id = dg.get_grid_id()
# expected_header = Div(
# Div(
# Div(Div("Name")),
# Div(Div(), hx_post=f"/{DATAGRID_PATH}/sort"), # sort
# Div(cls="dt-flex-grow"), # column clickable extension
# Div(cls='icon-24 dt-filter-icon icon-btn'),
# Div(cls="dt-filter-popup"),
# Div(cls="dt-resize-handle"),
# data_col="name"
# ),
# Div(
# Div(Div("Choice")),
# Div(Div(), hx_post=f"/{DATAGRID_PATH}/sort"), # sort
# Div(cls="dt-flex-grow"), # column clickable extension
# Div(cls='icon-24 dt-filter-icon icon-btn'),
# Div(cls="dt-filter-popup"),
# Div(cls="dt-resize-handle"),
# data_col="choice"
# ),
# cls="dt-row dt-header",
# id=f"th_{_grid_id}")
#
# res_header = dg.mk_table_header()
# matches(res_header, expected_header)
# def test_i_can_update_choice_value_column():
# assert False
def test_there_is_no_header_when_gs_header_is_false():
grid_id = "testing_grid"
grid_setting = {DG_TABLE_HEADER: False}
df = pd.DataFrame({
'Name': ['Alice', 'Bob'],
'Age': [20, 25]
})
dg = DataGrid(df, id=grid_id, grid_settings=grid_setting)
header = dg.mk_table_header()
assert matches(header, Div(cls="dt-row dt-header hidden"))
def test_there_is_no_footer_when_gs_footer_is_false():
grid_id = "testing_grid"
grid_setting = {DG_TABLE_FOOTER: False}
df = pd.DataFrame({
'Name': ['Alice', 'Bob'],
'Age': [20, 25]
})
dg = DataGrid(df, id=grid_id, grid_settings=grid_setting)
footer = dg.mk_table_footer()
assert matches(footer, Div(Empty))
def test_i_can_render_when_some_columns_are_not_visible(dg, grid_id):
grid_id = "testing_grid"
grid_setting = {DG_COLUMNS: {
"name": {VISIBLE_KEY: False, INDEX_KEY: 0, "agg_func": DG_AGGREGATE_SUM},
"age": {INDEX_KEY: 1, "agg_func": DG_AGGREGATE_SUM},
}}
df = pd.DataFrame({
'Name': ['Alice', 'Bob'],
'Age': [20, 25]
})
dg = DataGrid(df, id=grid_id, grid_settings=grid_setting)
table_header = dg.mk_table_header()
table_body = dg.mk_table_body()
table_footer = dg.mk_table_footer()
expected_header = Div(
Div(cls="dt-header-hidden", hx_post=f"/{DATAGRID_PATH}/on_state_changed", ),
Div(data_col="age", data_tooltip="Age"),
)
assert matches(table_header, expected_header)
expected_body = Div(
Div(Div(cls="dt-col-hidden"), Div(data_col="age", data_tooltip="20"), ), # first row
Div(Div(cls="dt-col-hidden"), Div(data_col="age", data_tooltip="25"), ), # second row
)
assert matches(table_body, expected_body)
expected_footer = Div(
Div(Div(cls="dt-col-hidden"), Div(data_col="age"))
)
assert matches(table_footer, expected_footer)
def test_i_can_hide_a_column(dg, grid_id):
dg.manage_grid_state(DG_STATE_COLUMN_VISIBILITY, ["name"], "true", "false")
table_header = dg.mk_table_header()
table_body = dg.mk_table_body()
table_footer = dg.mk_table_footer()
expected_header = Div(
Div(cls="dt-header-hidden", hx_post=f"/{DATAGRID_PATH}/on_state_changed", ),
Div(data_col="age", data_tooltip="Age"),
)
assert matches(table_header, expected_header)
expected_body = Div(
Div(Div(cls="dt-col-hidden"), Div(data_col="age", data_tooltip="20"), ), # first row
Div(Div(cls="dt-col-hidden"), Div(data_col="age", data_tooltip="25"), ), # second row
)
assert matches(table_body, expected_body)
expected_footer = Div(
Div(Div(cls="dt-col-hidden"), Div(data_col="age"))
)
assert matches(table_footer, expected_footer)
def test_i_can_generate_sorting_capabilities(dg, grid_id):
name_attrs = {
"hx_post": f"/{DATAGRID_PATH}/sort",
"hx_vals": f'{{"g_id": "{grid_id}", "c_id":"name"}}',
"hx_target": f"#tb_{grid_id}",
}
age_attrs = {
"hx_post": f"/{DATAGRID_PATH}/sort",
"hx_vals": f'{{"g_id": "{grid_id}", "c_id":"age"}}',
"hx_target": f"#tb_{grid_id}",
}
expected = Div(
Div(
Div(Div("Name")),
Div(
Div(id=f"tsi_datagrid-testing_grid_id_name"),
**name_attrs)),
Div(
Div(Div("Age")),
Div(
Div(id=f"tsi_datagrid-testing_grid_id_age"),
**age_attrs))
)
res = dg.mk_table_header()
# as_ft = debug_print(res[0])
matches(res, expected)
def test_i_can_sort(dg):
state = dg.get_state()
assert state.sorted == []
assert dg.get_sort_icons() == {}
dg.sort("name") # asc
assert state.sorted == [SortDefinition(column_id='name', direction=1)]
assert "name" in dg.get_sort_icons()
assert matches(dg.mk_table_body(), Div(
Div(
Div(Div("Alice")),
Div(Div("20")),
),
Div(
Div(Div("Bob")),
Div(Div("25")),
),
))
dg.sort("name") # desc
assert state.sorted == [SortDefinition(column_id='name', direction=2)]
assert "name" in dg.get_sort_icons()
assert matches(dg.mk_table_body(), Div(
Div(
Div(Div("Bob")),
Div(Div("25")),
),
Div(
Div(Div("Alice")),
Div(Div("20")),
),
))
dg.sort("name") # back to default
assert state.sorted == [SortDefinition(column_id='name', direction=0)]
assert "name" not in dg.get_sort_icons()
assert matches(dg.mk_table_body(), Div(
Div(
Div(Div("Alice")),
Div(Div("20")),
),
Div(
Div(Div("Bob")),
Div(Div("25")),
),
))
dg.sort("name") # asc again
assert state.sorted == [SortDefinition(column_id='name', direction=1)]
assert "name" in dg.get_sort_icons()
assert matches(dg.mk_table_body(), Div(
Div(
Div(Div("Alice")),
Div(Div("20")),
),
Div(
Div(Div("Bob")),
Div(Div("25")),
),
))
def test_i_can_filter_when_found(dg, grid_id):
dg.filter(FILTER_INPUT_CID, 'Ali') # filter is not case-sensitive !
expected = Div(
Div(
Div(
Div(Span('Ali', cls='dt-highlight-1'),
Span('ce'))
),
Div(Div("20"))
),
id=f"tb_{grid_id}"
)
res = dg.mk_table_body()
matches(res, expected)
table_content = extract_table_values(res, header=False)
assert len(table_content) == 1
def test_i_can_filter_when_not_found(dg, grid_id):
dg.filter(FILTER_INPUT_CID, 'not found')
expected = Div(id=f"tb_{grid_id}") # empty grid
res = dg.mk_table_body()
matches(res, expected)
def test_i_can_filter_a_column(dg):
dg.filter('name', ['Alice'])
expected = Div(
Div(
Div(Div('Alice')),
Div(Div("20"))
),
)
res = dg.mk_table_body()
matches(res, expected)
table_content = extract_table_values(res, header=False)
assert len(table_content) == 1
def test_i_can_filter_an_int_column(dg):
dg.filter('age', ['20']) # not that we filter as string
expected = Div(
Div(
Div(Div('Alice')),
Div(Div("20"))
),
)
res = dg.mk_table_body()
matches(res, expected)
table_content = extract_table_values(res, header=False)
assert len(table_content) == 1
def test_i_can_reset_filter(dg):
expected = Div(
Div(
Div(Div("Alice")),
Div(Div("20")),
),
Div(
Div(Div("Bob")),
Div(Div("25")),
),
)
dg.filter(FILTER_INPUT_CID, 'ali')
dg.reset_filter(None)
res = dg.mk_table_body()
matches(res, expected)
def test_compute_grid_settings():
df = pd.DataFrame({
'Name': ['Bob', 'Alice'],
'Age': [25, 20]
})
settings = DataGrid.compute_grid_settings(df)
assert settings[DG_COLUMNS] == {'age': {'index': 1, 'safe_index': 1, 'title': 'Age', 'type': 'number'},
'name': {'index': 0, 'safe_index': 0, 'title': 'Name', 'type': 'string'}}
settings = DataGrid.compute_grid_settings(df, grid_setting={})
assert settings[DG_COLUMNS] == {'age': {'index': 1, 'safe_index': 1, 'title': 'Age', 'type': 'number'},
'name': {'index': 0, 'safe_index': 0, 'title': 'Name', 'type': 'string'}}
settings = DataGrid.compute_grid_settings(df, grid_setting={DG_COLUMNS: {}})
assert settings[DG_COLUMNS] == {}
def test_i_can_compute_safe_index():
grid_settings = {DG_COLUMNS: {'age': {'index': 15},
'name': {'index': 10, },
}}
settings = DataGrid.compute_grid_settings(None, grid_setting=grid_settings)
assert settings[DG_COLUMNS] == {'age': {'index': 15, 'safe_index': 1, 'title': 'Age'},
'name': {'index': 10, 'safe_index': 0, 'title': 'Name'}, }
def test_i_can_filter_the_columns_using_compute_grid_settings():
df = pd.DataFrame({
'Name': ['Bob', 'Alice'],
'Age': [25, 20]
})
settings = DataGrid.compute_grid_settings(df, columns=["age"])
assert settings[DG_COLUMNS] == {'age': {'safe_index': 0, 'title': 'Age'}}
def test_i_can_add_new_columns_when_compute_grid_settings():
df = pd.DataFrame({
'Name': ['Bob', 'Alice'],
'Age': [25, 20]
})
settings = DataGrid.compute_grid_settings(df, columns=["new_column", "age"])
assert settings[DG_COLUMNS] == {'new_column': {'safe_index': 0, 'title': 'New Column'},
'age': {'safe_index': 1, 'title': 'Age'}}
def test_i_can_add_new_columns_when_compute_grid_settings_from_nothing():
settings = DataGrid.compute_grid_settings(None, columns=["new_column", "age"])
assert settings[DG_COLUMNS] == {'new_column': {'safe_index': 0, 'title': 'New Column'},
'age': {'safe_index': 1, 'title': 'Age'}}
def test_i_can_rearrange_columns_using_compute_grid_settings():
df = pd.DataFrame({
'Name': ['Bob', 'Alice'],
'Age': [25, 20]
})
settings = DataGrid.compute_grid_settings(df, columns=["age", "other_column_1", "other_column_2"])
assert settings[DG_COLUMNS] == {
'age': {'safe_index': 0, 'title': 'Age'},
'other_column_1': {'safe_index': 1, 'title': 'Other Column 1'},
'other_column_2': {'safe_index': 2, 'title': 'Other Column 2'}}
def test_i_can_init_with_simplified_grid_settings():
grid_settings = {DG_COLUMNS: ["Age", "Other Column 1", "Other Column 2"]}
dg = DataGrid(grid_settings=grid_settings)
settings = dg._grid_settings
assert settings[DG_COLUMNS] == {'age': {'index': 0, 'safe_index': 0, 'title': 'Age'},
'other_column_1': {'index': 1, 'safe_index': 1, 'title': 'Other Column 1'},
'other_column_2': {'index': 2, 'safe_index': 2, 'title': 'Other Column 2'}}
def test_i_can_update_dataframe():
df = pd.DataFrame({
'Name': ['Bob', 'Alice'],
'Age': [25, 20]
})
expected = pd.DataFrame({
'name': ['Bob', 'Alice'],
'age': [25, 20]
})
grid_settings = DataGrid.compute_grid_settings(df)
df = DataGrid._get_updated_dataframe(df, grid_settings)
assert df.equals(expected)
def test_i_can_update_dataframe_when_changing_column_order():
df = pd.DataFrame({
'Name': ['Bob', 'Alice'],
'Age': [25, 20]
})
expected = pd.DataFrame({
'age': [25, 20],
'name': ['Bob', 'Alice'],
})
grid_settings = {
DG_COLUMNS: {
'age': {'index': 0, 'title': 'Age'},
'name': {'index': 1, 'title': 'Name'}
}
}
df = DataGrid._get_updated_dataframe(df, grid_settings)
assert df.equals(expected)
def test_i_can_update_dataframe_when_changing_column_order_and_adding_new_columns():
df = pd.DataFrame({
'Name': ['Bob', 'Alice'],
'Age': [25, 20]
})
expected = pd.DataFrame({
'age': [25, 20],
'new_column': [None, None],
'name': ['Bob', 'Alice'],
})
grid_settings = {
DG_COLUMNS: {
'age': {'index': 0, 'title': 'Age'},
'new_column': {'index': 1, 'title': 'New Column'},
'name': {'index': 2, 'title': 'Name'}
}
}
df = DataGrid._get_updated_dataframe(df, grid_settings)
assert df.equals(expected)
def test_i_can_import_file_when_none():
dg = DataGrid()
dg.import_file(None, None)
assert dg._df is None
assert dg._grid_settings[DG_COLUMNS] == {}
def test_i_can_reset_df_when_import_none(dg):
assert dg._df is not None
assert dg._grid_settings[DG_COLUMNS] != {}
dg.import_file(None, None)
assert dg._df is None
assert dg._grid_settings[DG_COLUMNS] == {}
def test_i_can_import_a_file(excel_file_content):
dg = DataGrid()
dg.import_file("file_name", excel_file_content)
assert dg._df is not None
assert dg._grid_settings[DG_COLUMNS] == {
'column_1': {'index': 0, 'safe_index': 0, 'title': 'Column 1', 'type': 'string'},
'column_2': {'index': 1, 'safe_index': 1, 'title': 'Column 2', 'type': 'string'}}
def test_i_can_reimport_a_file(dg, excel_file_content):
dg.import_file("file_name", excel_file_content)
assert dg._df is not None
assert dg._grid_settings[DG_COLUMNS] == {
'column_1': {'index': 0, 'safe_index': 0, 'title': 'Column 1', 'type': 'string'},
'column_2': {'index': 1, 'safe_index': 1, 'title': 'Column 2', 'type': 'string'}}
def test_grid_setting_is_kept_on_import(dg, excel_file_content):
grid_settings = {DG_FILTER_INPUT: False}
dg = DataGrid(grid_settings=grid_settings)
dg.import_file("file_name", excel_file_content)
assert dg._grid_settings[DG_FILTER_INPUT] is False
def test_i_can_get_filter_content(dg2):
res = dg2.mk_filter_popup_content('name')
checkboxes = extract_popup_content(res, filter_input=False)
assert checkboxes == OrderedDict({
'Alice': False,
'Bob': False,
'Charlie': False,
'David': False})
dg2.filter('name', ['Bob', 'Charlie'])
res = dg2.mk_filter_popup_content('name')
checkboxes = extract_popup_content(res, filter_input=False)
assert checkboxes == OrderedDict({
'Alice': False,
'Bob': True,
'Charlie': True,
'David': False})
def test_i_can_get_filter_content_when_multiple_filter_set(dg2):
dg2.filter('name', ['Bob', 'Charlie', 'David'])
res = dg2.mk_filter_popup_content('age')
checkboxes = extract_popup_content(res, filter_input=False)
assert checkboxes == OrderedDict({
'25': False,
'30': False,
'35': False,
})
# second filter
dg2.filter('age', ["25", "30"])
res = dg2.mk_filter_popup_content('city')
checkboxes = extract_popup_content(res, filter_input=False)
assert checkboxes == OrderedDict({
'Los Angeles': False,
'Chicago': False,
})
# previous filters are remembered
res = dg2.mk_filter_popup_content('name')
checkboxes = extract_popup_content(res, filter_input=False)
assert checkboxes == OrderedDict({
'Alice': False,
'Bob': True,
'Charlie': True,
'David': True,
})
res = dg2.mk_filter_popup_content('age')
checkboxes = extract_popup_content(res, filter_input=False)
assert checkboxes == OrderedDict({
'25': True,
'30': True,
'35': False,
})
res = dg2.mk_filter_popup_content('city')
checkboxes = extract_popup_content(res, filter_input=False)
assert checkboxes == OrderedDict({
'Los Angeles': False,
'Chicago': False,
})
def test_i_can_import_data(dg):
new_data = pd.DataFrame({
'City': ['New York', 'Los Angeles'],
'Population': [8_331_237, 3_965_117]
})
dg.import_dataframe(new_data)
table = dg.mk_table()
content = extract_table_values(table)
assert content == OrderedDict({'City': ['New York', 'Los Angeles'],
'Population': ['8331237', '3965117']})
assert dg._grid_settings[DG_COLUMNS] == {
'city': {'index': 0, 'safe_index': 0, 'title': 'City', 'type': 'string'},
'population': {'index': 1, 'safe_index': 1, 'title': 'Population', 'type': 'number'}
}
def test_i_can_import_data_when_none():
dg = DataGrid()
dg.import_dataframe(None)
assert dg._df is None
assert dg._grid_settings[DG_COLUMNS] == {}
def test_i_can_import_data_when_empty():
dg = DataGrid()
dg.import_dataframe(pd.DataFrame())
assert dg._df.empty
assert dg._grid_settings[DG_COLUMNS] == {}
def test_grid_setting_is_kept_when_no_data():
grid_settings = {
DG_COLUMNS: {
"name": {
"index": 0,
"title": "Name",
"type": "string",
},
}
}
dg = DataGrid(grid_settings=grid_settings) # df is None
assert dg._grid_settings[DG_COLUMNS] == grid_settings[DG_COLUMNS]
def test_grid_settings_is_kept_after_load_data(dg):
grid_settings = {
DG_COLUMNS: {
"name": {
"index": 0,
"title": "Name",
"type": "string",
},
}
}
df = pd.DataFrame({"name": ["Alice", "Bob"],
"age": [20, 25]})
dg = DataGrid(grid_settings=grid_settings)
dg.import_dataframe(df, reset=False)
assert dg._grid_settings[DG_COLUMNS] == {
"name": {
"index": 0,
'safe_index': 0,
"title": "Name",
"type": "string",
}
}
def test_i_can_apply_style_depending_on_column_type():
grid_settings = {
DG_COLUMNS: {
"name": {
"index": 5,
"title": "Name",
"type": DG_DATATYPE_STRING,
},
"age": {
"index": 10,
"title": "Age",
"type": DG_DATATYPE_NUMBER,
},
"male": {
"index": 15,
"title": "Male",
"type": DG_DATATYPE_BOOL,
},
}
}
df = pd.DataFrame({
'Name': ['Alice', 'Bob'],
'Age': [20, 25],
'male': [True, False],
})
dg = DataGrid(df, grid_settings=grid_settings)
expected = Div(
Div(
Div(Div("Alice")),
Div(Div("20"), style="text-align: right;"),
Div(Div(), style="text-align: center; display: flex; justify-content: center;"),
),
Div(
Div(Div("Bob")),
Div(Div("25"), style="text-align: right;"),
Div(Div(), style="text-align: center; display: flex; justify-content: center;"),
)
)
actual = dg.mk_table_body()
assert matches(actual, expected)
def test_by_default_table_is_ready_only(dg):
# by default the grid is readonly
# The cell will be selected, but no input
for cell in [(0, 0), (1, 0), (0, 1), (1, 1)]:
res = dg.try_enter_edit_mode(*cell)
assert res is None
def test_i_can_try_edit_with_invalid_values(dg):
assert dg.try_enter_edit_mode(-1, 0) is None
assert dg.try_enter_edit_mode(0, 3) is None
dg.get_grid_settings()[DG_READ_ONLY] = False
assert dg.try_enter_edit_mode(-1, 0) is None
assert dg.try_enter_edit_mode(0, 3) is None
def test_i_can_try_edit_a_text_cell(dg2, grid_id):
# make the grid editable
dg2.get_grid_settings()[DG_READ_ONLY] = False
res = dg2.try_enter_edit_mode(0, 1)
expected = Div(
Input(name="new_value", value="Bob", cls="dt-cell-content"),
cls="dt-cell-is-editing"
)
assert matches(res, expected)
def test_i_can_edit_a_number_cell(dg2, grid_id):
# make the grid editable
dg2.get_grid_settings()[DG_READ_ONLY] = False
res = dg2.try_enter_edit_mode(1, 1)
expected = Div(
Input(name="new_value", value=25, cls="dt-cell-content"),
cls="dt-cell-is-editing"
)
assert matches(res, expected)
def test_i_can_edit_a_bool_cell(dg2, grid_id):
# 'Student': [True, False, True, False],
# make the grid editable
dg2.get_grid_settings()[DG_READ_ONLY] = False
res = dg2.try_enter_edit_mode(3, 1)
assert res is None # bool cell never enters in edit mode
def test_i_can_manage_click_when_read_only(dg, grid_id):
# The cell is selected, but no input
dg.get_grid_settings()[DG_READ_ONLY] = True
res = dg.manage_cell_click(0, 0)
input_elt = search_elements_by_name(res, "input")
assert input_elt is None
under_edition = search_elements_by_name(res, None, {"class": "dt-cell-is-editing"})
assert under_edition is None
def test_i_can_manage_click_for_text_when_not_read_only(dg, grid_id):
# the cell is selected and the input element is returned
dg.get_grid_settings()[DG_READ_ONLY] = False
res = dg.manage_cell_click(0, 0)
under_edition = search_elements_by_name(res, None, {"class": "dt-cell-is-editing"})
assert under_edition is not None
input_elt = search_elements_by_name(res, "input")
assert input_elt is not None
def test_i_can_manage_click_for_number_when_not_read_only(dg, grid_id):
# the cell is selected and the input element is returned
dg.get_grid_settings()[DG_READ_ONLY] = False
res = dg.manage_cell_click(1, 0)
under_edition = search_elements_by_name(res, None, {"class": "dt-cell-is-editing"})
assert under_edition is not None
input_elt = search_elements_by_name(res, "input")
assert input_elt is not None
def test_i_can_manage_click_for_bool_when_not_read_only(dg2, grid_id):
# the value is changed, the cell is selected, no input is returned
dg2.get_grid_settings()[DG_READ_ONLY] = False
old_value = dg2.get_table_value(3, 0)
res = dg2.manage_cell_click(3, 0)
under_edition = search_elements_by_name(res, None, {"class": "dt-cell-is-editing"})
assert under_edition is None
input_elt = search_elements_by_name(res, "input")
assert input_elt is None
assert dg2.get_table_value(3, 0) == (not old_value)
def test_i_can_manage_multiple_click_when_not_read_only(dg, grid_id):
dg.get_grid_settings()[DG_READ_ONLY] = False
dg.manage_cell_click(0, 0)
res = dg.manage_cell_click(1, 0)
expected = [Div(Div("Alice"), hx_swap_oob="innerHTML", id=f"tc_{grid_id}-0-0"), # reset the previous edition
Div(Div(cls="dt-cell-is-editing"), id=f"tc_{grid_id}-1-0"), # new input
Div(id=f"tsm_{grid_id}", )]
assert matches(res, expected)
def test_i_can_edit_one_when_the_column_is_editable():
grid_settings = {DG_COLUMNS: {
"name": {
"index": 0,
"title": "Name",
"type": "string",
},
"age": {
"index": 1,
"title": "Age",
"type": "number",
DG_READ_ONLY: False,
}}}
df = pd.DataFrame({
'Name': ['Alice', 'Bob'],
'Age': [20, 25]
})
dg = DataGrid(df, grid_settings=grid_settings)
# I cannot modify a column that is readonly
res = dg.try_enter_edit_mode(0, 0)
assert res is None
# I can modify when it's not readonly
res = dg.try_enter_edit_mode(1, 0)
expected = Div(
Input(name="new_value", value=20, cls="dt-cell-content"),
cls="dt-cell-is-editing"
)
assert matches(res, expected)
def test_i_cannot_edit_bool_when_the_column_is_not_editable(dg2, grid_id):
dg2.get_grid_settings()[DG_READ_ONLY] = True
old_value = dg2.get_table_value(3, 0)
dg2.manage_cell_click(3, 0)
assert dg2.get_table_value(3, 0) == old_value
@pytest.mark.parametrize("mode, expected", [
(None, DG_SELECTION_MODE_CELL),
(DG_SELECTION_MODE_CELL, DG_SELECTION_MODE_CELL),
(DG_SELECTION_MODE_COLUMN, DG_SELECTION_MODE_COLUMN),
(DG_SELECTION_MODE_ROW, DG_SELECTION_MODE_ROW),
])
def test_i_can_set_selection_mode(mode, expected):
grid_settings = {
DG_SELECTION_MODE: mode
}
dg = DataGrid(grid_settings=grid_settings)
assert dg.get_state().selection_mode == expected
@pytest.mark.parametrize("read_only", [True, False])
def test_i_can_manage_cell_selection_when_selection_mode_is_cell(dg, grid_id, read_only):
# The cell is selected, but no input
dg.get_state().selection_mode = DG_SELECTION_MODE_CELL
dg.get_grid_settings()[DG_READ_ONLY] = read_only
res = dg.manage_cell_click(0, 0)
assert get_selected(res) == [
("cell", 0, 0),
]
@pytest.mark.parametrize("read_only", [True, False])
def test_i_can_manage_cell_selection_when_selection_mode_is_row(dg, grid_id, read_only):
# The cell is selected, but no input
dg.get_grid_settings()[DG_READ_ONLY] = read_only
dg.get_state().selection_mode = DG_SELECTION_MODE_ROW
res = dg.manage_cell_click(0, 0)
assert get_selected(res) == [
("row", 0),
("cell", 0, 0),
]
@pytest.mark.parametrize("read_only", [True, False])
def test_i_can_manage_cell_selection_when_selection_mode_is_column(dg, grid_id, read_only):
# The cell is selected, but no input
dg.get_grid_settings()[DG_READ_ONLY] = read_only
dg.get_state().selection_mode = DG_SELECTION_MODE_COLUMN
res = dg.manage_cell_click(0, 0)
assert get_selected(res) == [
("column", "name"),
("cell", 0, 0),
]
def test_i_can_manage_multiple_cells_selection_using_control_key(dg, grid_id):
dg.manage_cell_click(0, 0)
res = dg.manage_cell_click(1, 0, "ctrl-")
selected = get_selected(res)
assert selected == [("cell", 1, 0), ('cellx', 0, 0), ('cellx', 1, 0)]
assert dg.get_state().extra_selected == [('cell', 'tc_datagrid-testing_grid_id-0-0'),
('cell', 'tc_datagrid-testing_grid_id-1-0')]
def test_i_can_manage_multiple_cells_selection_in_colum_mode_using_control_key(dg, grid_id):
dg.get_state().selection_mode = DG_SELECTION_MODE_COLUMN
dg.manage_cell_click(0, 0)
res = dg.manage_cell_click(1, 0, "ctrl-")
selected = get_selected(res)
assert selected == [('column', "age"), ('cell', 1, 0), ('column', "name")]
assert dg.get_state().extra_selected == [('column', "name"), ('column', "age")]
def test_i_can_manage_multiple_cells_selection_in_row_mode_using_control_key(dg, grid_id):
dg.get_state().selection_mode = DG_SELECTION_MODE_ROW
dg.manage_cell_click(0, 0)
res = dg.manage_cell_click(0, 1, "ctrl-")
selected = get_selected(res)
assert selected == [('row', 1), ('cell', 0, 1), ('row', 0)]
assert dg.get_state().extra_selected == [('row', 'tr_datagrid-testing_grid_id-0'),
('row', 'tr_datagrid-testing_grid_id-1')]
def test_i_can_manage_multiple_cells_selection_using_shift_key(dg2, grid_id):
dg2.manage_cell_click(1, 0)
res = dg2.manage_cell_click(2, 2, "shift-")
selected = get_selected(res)
assert selected == [('cell', 2, 2),
('cellx', 1, 0),
('cellx', 1, 1),
('cellx', 1, 2),
('cellx', 2, 0),
('cellx', 2, 1),
('cellx', 2, 2)]
assert dg2.get_state().extra_selected == [('cell', 'tc_datagrid-testing_grid_id-1-0'),
('cell', 'tc_datagrid-testing_grid_id-1-1'),
('cell', 'tc_datagrid-testing_grid_id-1-2'),
('cell', 'tc_datagrid-testing_grid_id-2-0'),
('cell', 'tc_datagrid-testing_grid_id-2-1'),
('cell', 'tc_datagrid-testing_grid_id-2-2')]
def test_i_can_manage_multiple_cells_selection_in_colum_mode_using_shift_key(dg2, grid_id):
dg2.get_state().selection_mode = DG_SELECTION_MODE_COLUMN
dg2.manage_cell_click(1, 0)
res = dg2.manage_cell_click(3, 3, "shift-")
selected = get_selected(res)
assert selected == [('column', 'student'), ('cell', 3, 3), ('column', "age"), ('column', "city")]
assert dg2.get_state().extra_selected == [('column', "age"), ('column', "city"), ('column', "student")]
def test_i_can_manage_multiple_cells_selection_in_row_mode_using_shift_key(dg2, grid_id):
dg2.get_state().selection_mode = DG_SELECTION_MODE_ROW
dg2.manage_cell_click(1, 0)
res = dg2.manage_cell_click(3, 3, "shift-")
selected = get_selected(res)
assert selected == [('row', 3), ('cell', 3, 3), ('row', 0), ('row', 1), ('row', 2)]
assert dg2.get_state().extra_selected == [('row', 'tr_datagrid-testing_grid_id-0'),
('row', 'tr_datagrid-testing_grid_id-1'),
('row', 'tr_datagrid-testing_grid_id-2'),
('row', 'tr_datagrid-testing_grid_id-3')]
def test_i_can_manage_multiple_cells_selection_using_shift_key_when_the_table_is_sorted(dg2, grid_id):
dg2.sort("city")
# name age city student date
# 2 Charlie 30 Chicago True 2007-01-01
# 3 David 35 Houston False 2000-12-31
# 1 Bob 25 Los Angeles False 2022-10-01
# 0 Alice 20 New York True 2020-01-10
# I click on age=35 (pos=1,1) then on city='Los Angeles' (pos=2,2)
dg2.manage_cell_click(1, 3) # age=35 position is 1,1
res = dg2.manage_cell_click(2, 1, "shift-") # city=los angeles is position 2,2
selected = get_selected(res)
assert selected == [('cell', 2, 1),
('cellx', 1, 3),
('cellx', 1, 1),
('cellx', 2, 3),
('cellx', 2, 1)]
assert dg2.get_state().extra_selected == [('cell', 'tc_datagrid-testing_grid_id-1-3'),
('cell', 'tc_datagrid-testing_grid_id-1-1'),
('cell', 'tc_datagrid-testing_grid_id-2-3'),
('cell', 'tc_datagrid-testing_grid_id-2-1')]
def test_i_can_select_column(dg, grid_id):
res = dg.manage_column_click(1, '')
assert get_selected(res) == [
("column", "age"),
]
# without any modifier, the selection is replaced
res = dg.manage_column_click(0, '')
assert get_selected(res) == [
("column", "name"),
]
def test_i_can_select_multiple_columns_with_control_key(dg, grid_id):
dg.manage_column_click(1, '')
# I can add column using ctrl
res = dg.manage_column_click(0, "ctrl-")
assert get_selected(res) == [
("column", "age"),
("column", "name"),
]
# I can remove column using control
res = dg.manage_column_click(1, "ctrl-")
assert get_selected(res) == [
("column", "name"),
]
def test_i_can_select_multiple_columns_with_shift_key(dg2, grid_id):
res = dg2.manage_column_click(1, "shift-")
assert get_selected(res) == [
("column", "age"),
]
res = dg2.manage_column_click(3, "shift-")
assert get_selected(res) == [
("column", "age"),
("column", "city"),
("column", "student"),
]
res = dg2.manage_column_click(2, "shift-")
assert get_selected(res) == [
("column", "age"),
("column", "city"),
]
res = dg2.manage_column_click(0, "shift-")
assert get_selected(res) == [
("column", "name"),
("column", "age"),
]
def test_i_can_press_enter_when_readonly(dg, grid_id):
dg.get_grid_settings()[DG_READ_ONLY] = True
dg.manage_cell_click(0, 0) # select the top left
res = dg.manage_key_pressed("Enter", None)
expected = [Div(Div(selection_type="cell", element_id=f"tc_{grid_id}-0-1"),
id=f"tsm_{grid_id}")]
assert matches(res, expected)
res = dg.manage_key_pressed("Enter", None)
expected = [Div(Div(selection_type="cell", element_id=f"tc_{grid_id}-0-0"),
id=f"tsm_{grid_id}", )]
assert matches(res, expected)
def test_i_can_press_tab_when_readonly(dg, grid_id):
dg.get_grid_settings()[DG_READ_ONLY] = True
dg.manage_cell_click(0, 0) # select the top left
res = dg.manage_key_pressed("Tab", None)
expected = [Div(Div(selection_type="cell", element_id=f"tc_{grid_id}-1-0"),
id=f"tsm_{grid_id}")]
assert matches(res, expected)
res = dg.manage_key_pressed("Tab", None)
expected = [Div(Div(selection_type="cell", element_id=f"tc_{grid_id}-0-1"),
id=f"tsm_{grid_id}")]
assert matches(res, expected)
def test_i_can_press_enter_when_not_readonly(dg, grid_id):
dg.get_grid_settings()[DG_READ_ONLY] = False
dg.manage_cell_click(0, 0) # select the top left
res = dg.manage_key_pressed("Enter", "Alice")
expected = [
Div(
Div("Alice"),
hx_swap_oob="innerHTML",
id=f"tc_{grid_id}-0-0"),
Div(
Div(Input()),
hx_swap_oob="innerHTML",
id=f"tc_{grid_id}-0-1"),
Div(
Div(selection_type="cell", element_id=f"tc_{grid_id}-0-1"),
id=f"tsm_{grid_id}",
)]
assert matches(res, expected)
res = dg.manage_key_pressed("Enter", "Bob")
expected = [
Div(
Div("Bob"),
hx_swap_oob="innerHTML",
id=f"tc_{grid_id}-0-1"),
Div(
Div(Input()),
hx_swap_oob="innerHTML",
id=f"tc_{grid_id}-0-0"),
Div(
Div(selection_type="cell", element_id=f"tc_{grid_id}-0-0"),
id=f"tsm_{grid_id}",
)]
assert matches(res, expected)
def test_i_can_press_enter_on_a_bool_editable_cell(dg2, grid_id):
dg2.get_grid_settings()[DG_READ_ONLY] = False
dg2.get_state().selected = (3, 0)
res = dg2.manage_key_pressed("Enter", None)
expected = [
Div(
Div(
NotStr('<svg name="CheckboxUnchecked'),
cls="icon-bool",
),
hx_swap_oob="innerHTML",
id=f"tc_{grid_id}-3-0"),
Div(
Div(selection_type="cell", element_id=f"tc_{grid_id}-3-1"),
id=f"tsm_{grid_id}",
)]
assert matches(res, expected)
# I can do it again
res = dg2.manage_key_pressed("Enter", None)
expected = [
Div(
Div(
NotStr('<svg name="CheckboxChecked'),
cls="icon-bool",
),
hx_swap_oob="innerHTML",
id=f"tc_{grid_id}-3-1"),
Div(
Div(selection_type="cell", element_id=f"tc_{grid_id}-3-2"),
id=f"tsm_{grid_id}",
)]
assert matches(res, expected)
def test_i_can_press_tab_when_not_readonly(dg, grid_id):
dg.get_grid_settings()[DG_READ_ONLY] = False
dg.manage_cell_click(0, 0) # select the top left
res = dg.manage_key_pressed("Tab", "Alice")
expected = [
Div(
Div("Alice"),
hx_swap_oob="innerHTML",
id=f"tc_{grid_id}-0-0"),
Div(
Div(Input()),
hx_swap_oob="innerHTML",
id=f"tc_{grid_id}-1-0"),
Div(
Div(selection_type="cell", element_id=f"tc_{grid_id}-1-0"),
id=f"tsm_{grid_id}")
]
assert matches(res, expected)
res = dg.manage_key_pressed("Tab", "20")
expected = [
Div(
Div("20"),
hx_swap_oob="innerHTML",
id=f"tc_{grid_id}-1-0",
),
Div(
Div(Input()),
hx_swap_oob="innerHTML",
id=f"tc_{grid_id}-0-1",
),
Div(
Div(selection_type="cell", element_id=f"tc_{grid_id}-0-1"),
id=f"tsm_{grid_id}")
]
assert matches(res, expected)
def test_i_can_escape_when_not_in_edition_nor_selection(dg):
dg.get_state().under_edition = None
result = dg.escape()
assert result is None
def test_i_can_manage_selection_on_escape_when_cell_selection_mode(dg, grid_id):
# The cell is selected, but no input
dg.get_grid_settings()[DG_READ_ONLY] = False
dg.get_state().selection_mode = DG_SELECTION_MODE_CELL
res = dg.manage_cell_click(0, 0) # entering edit mode
# sanity check that the input element is here, and it's selected
assert search_elements_by_name(res, "input") is not None
assert get_selected(res) == [("cell", 0, 0)]
res = dg.manage_key_pressed("Escape", None) # first escape : input is gone, but selection is still there
assert search_elements_by_name(res, "input") is None
assert get_selected(res) == [("cell", 0, 0)]
res = dg.manage_key_pressed("Escape", None) # second escape : input is gone, and no more selection
assert search_elements_by_name(res, "input") is None
assert get_selected(res) == []
def test_i_can_navigate_with_arrow_keys(dg, grid_id):
res = dg.manage_key_pressed("ArrowRight", None)
assert get_selected(res) == [("cell", 0, 0)]
# I cannot go left
res = dg.manage_key_pressed("ArrowLeft", None)
assert get_selected(res) == [("cell", 0, 0)]
# I cannot go up
res = dg.manage_key_pressed("ArrowUp", None)
assert get_selected(res) == [("cell", 0, 0)]
res = dg.manage_key_pressed("ArrowRight", None)
assert get_selected(res) == [("cell", 1, 0)]
# I cannot move right
res = dg.manage_key_pressed("ArrowRight", None)
assert get_selected(res) == [("cell", 1, 0)]
res = dg.manage_key_pressed("ArrowDown", None)
assert get_selected(res) == [("cell", 1, 1)]
# I cannot move down
res = dg.manage_key_pressed("ArrowDown", None)
assert get_selected(res) == [("cell", 1, 1)]
res = dg.manage_key_pressed("ArrowLeft", None)
assert get_selected(res) == [("cell", 0, 1)]
# I cannot move down
res = dg.manage_key_pressed("ArrowLeft", None)
assert get_selected(res) == [("cell", 0, 1)]
res = dg.manage_key_pressed("ArrowUp", None)
assert get_selected(res) == [("cell", 0, 0)]
def test_i_can_navigate_with_arrow_keys_when_the_grid_is_sorted(dg, grid_id):
dg.sort("name") # asc sort, so nothing is changed
dg.sort("name") #
res = dg.manage_key_pressed("ArrowRight", None)
assert get_selected(res) == [("cell", 0, 1)]
res = dg.manage_key_pressed("ArrowDown", None)
assert get_selected(res) == [("cell", 0, 0)]
# I cannot move down
res = dg.manage_key_pressed("ArrowDown", None)
assert get_selected(res) == [("cell", 0, 0)]
def test_i_can_navigate_with_arrow_keys_when_the_grid_is_filtered(dg, grid_id):
dg.filter(FILTER_INPUT_CID, 'Ali') # Apply filter to grid
dg.get_state().selected = (0, 0)
res = dg.manage_key_pressed("ArrowDow", None)
expected = [
Div(
Div(selection_type="cell", element_id=f"tc_{grid_id}-0-0"),
id=f"tsm_{grid_id}",
)]
assert matches(res, expected)
def test_i_can_navigate_with_arrow_keys_when_columns_are_hidden(dg2, grid_id):
dg2.manage_grid_state(DG_STATE_COLUMN_VISIBILITY, ["age", "city", "student"], "true", "false")
dg2.get_state().selected = dg2.navigate(None)
assert dg2.get_state().selected == (0, 0)
dg2.get_state().selected = dg2.navigate("ArrowRight")
assert dg2.get_state().selected == (4, 0)
# it's safe to continue in this direction
dg2.get_state().selected = dg2.navigate("ArrowRight")
assert dg2.get_state().selected == (4, 0)
# I can go back
dg2.get_state().selected = dg2.navigate("ArrowLeft")
assert dg2.get_state().selected == (0, 0)
def test_i_cannot_navigate_when_all_columns_are_hidden(dg2, grid_id):
dg2.manage_grid_state(DG_STATE_COLUMN_VISIBILITY, ["name", "age", "city", "student", "date"], "true", "false")
assert dg2.navigate(None) is None
def test_manage_grid_settings_i_can_manage_visible(dg, grid_id):
# sanity check
assert dg.get_grid_settings()[DG_COLUMNS] == {'age': {'index': 1,
'safe_index': 1,
'title': 'Age',
'type': 'number'},
'name': {'index': 0,
'safe_index': 0,
'title': 'Name',
'type': 'string'}}
# I can hide a column
dg.manage_grid_state(DG_STATE_COLUMN_VISIBILITY, ["name"], "true", "false")
new_state = [(c.col_id, c.visible) for c in dg.get_state().columns]
assert new_state == [("name", False), ('age', True)]
# I can put it back
dg.manage_grid_state(DG_STATE_COLUMN_VISIBILITY, ["name"], "false", "true")
new_state = [(c.col_id, c.visible) for c in dg.get_state().columns]
assert new_state == [("name", True), ('age', True)]
# I can remove multiple columns
dg.manage_grid_state(DG_STATE_COLUMN_VISIBILITY, ["name", "age"], "true", "false")
new_state = [(c.col_id, c.visible) for c in dg.get_state().columns]
assert new_state == [("name", False), ('age', False)]
def test_manage_grid_settings_extra_selected_is_reset_on_visible_change(dg, grid_id):
dg.get_state().extra_selected = [(DG_SELECTION_MODE_COLUMN, 0)]
dg.manage_grid_state(DG_STATE_COLUMN_VISIBILITY, ["name"], "something", "something")
assert dg.get_state().extra_selected == []
def test_selection_and_under_edition_is_reset_when_the_same_column_is_hidden(dg, grid_id):
dg.get_state().selected = (0, 0)
dg.get_state().under_edition = (0, 0)
dg.get_state().previous_under_edition = (0, 0)
dg.manage_grid_state(DG_STATE_COLUMN_VISIBILITY, ["name"], "true", "False")
assert dg.get_state().selected is None
assert dg.get_state().under_edition is None
assert dg.get_state().previous_under_edition is None
def test_selection_and_under_edition_is_not_reset_when_other_column_is_hidden(dg, grid_id):
dg.get_state().selected = (0, 0)
dg.get_state().under_edition = (0, 0)
dg.get_state().previous_under_edition = (0, 0)
dg.manage_grid_state(VISIBLE_KEY, ["age"], "true", "False")
assert dg.get_state().selected == (0, 0)
assert dg.get_state().under_edition == (0, 0)
assert dg.get_state().previous_under_edition == (0, 0)
def test_context_menu_i_can_hide_a_selected_column(dg, grid_id):
res = dg.manage_column_click(0, '')
context_menus = get_context_menu(res)
assert context_menus == [{
"hx-post": "/on_state_changed",
"data_tooltip": "Hide column 'Name'",
"attribute": DG_STATE_COLUMN_VISIBILITY,
"col_ids": "name",
"old_value": True,
"new_value": False,
}]
assert dg.get_state().selected is None
def test_context_menu_i_can_hide_selected_columns(dg, grid_id):
dg.manage_column_click(0, '')
res = dg.manage_column_click(1, 'ctrl')
context_menus = get_context_menu(res)
assert context_menus == [{
"hx-post": "/on_state_changed",
"data_tooltip": "Hide columns 'Name', 'Age'",
"attribute": DG_STATE_COLUMN_VISIBILITY,
"col_ids": "name,age",
"old_value": True,
"new_value": False,
}]
assert dg.get_state().selected is None
def test_context_menu_i_can_show_a_hidden_column(dg2, grid_id):
# This scenario is misnamed, you cannot have context menu visible by clicking a hidden column
dg2.manage_grid_state(DG_STATE_COLUMN_VISIBILITY, ["age"], "true", "false")
res = dg2.manage_column_click(1, '')
context_menus = get_context_menu(res)
assert context_menus == [{'hx-post': '/on_state_changed',
'data_tooltip': "Show column 'Age'",
'attribute': DG_STATE_COLUMN_VISIBILITY,
'col_ids': 'age',
'old_value': False,
'new_value': True}]
def test_context_menu_i_can_hide_and_show_columns(dg2, grid_id):
# More realistic scenario
dg2.manage_grid_state(DG_STATE_COLUMN_VISIBILITY, ["age", "city", "student"], "true", "false")
dg2.manage_column_click(0, '')
res = dg2.manage_column_click(4, 'shift') # select all the columns
context_menus = get_context_menu(res)
assert context_menus == [{'hx-post': '/on_state_changed',
'data_tooltip': "Show columns 'Age', 'City', 'Student'",
'attribute': DG_STATE_COLUMN_VISIBILITY,
'col_ids': 'age,city,student',
'old_value': False,
'new_value': True},
{'hx-post': '/on_state_changed',
'data_tooltip': "Hide columns 'Name', 'Date'",
'attribute': DG_STATE_COLUMN_VISIBILITY,
'col_ids': 'name,date',
'old_value': True,
'new_value': False}]
def test_i_an_undo_redo(dg):
dg.set_table_value(0, 0, "New name 1")
dg.set_table_value(0, 1, "New name 2")
dg.set_table_value(1, 0, 99)
assert to_array(dg._df) == [['New name 1', 99], ['New name 2', 25]]
dg.history_redo() # nothing happen
assert to_array(dg._df) == [['New name 1', 99], ['New name 2', 25]]
dg.history_undo()
assert to_array(dg._df) == [['New name 1', 20], ['New name 2', 25]]
dg.history_undo()
assert to_array(dg._df) == [['New name 1', 20], ['Bob', 25]]
dg.history_undo()
assert to_array(dg._df) == [['Alice', 20], ['Bob', 25]]
dg.history_undo() # nothing happen
assert to_array(dg._df) == [['Alice', 20], ['Bob', 25]]
dg.history_redo()
assert to_array(dg._df) == [['New name 1', 20], ['Bob', 25]]
dg.history_redo()
assert to_array(dg._df) == [['New name 1', 20], ['New name 2', 25]]
dg.history_redo()
assert to_array(dg._df) == [['New name 1', 99], ['New name 2', 25]]
def test_i_can_reset_the_history(dg):
dg.set_table_value(0, 0, "New name 1")
dg.set_table_value(0, 1, "New name 2")
dg.set_table_value(1, 0, 99)
dg.history_undo()
dg.history_undo()
assert to_array(dg._df) == [['New name 1', 20], ['Bob', 25]]
dg.set_table_value(1, 1, 10)
dg.history_redo() # nothing happen (history is reset with the new value)
assert to_array(dg._df) == [['New name 1', 20], ['Bob', 10]]
dg.history_undo()
assert to_array(dg._df) == [['New name 1', 20], ['Bob', 25]]
dg.history_redo()
assert to_array(dg._df) == [['New name 1', 20], ['Bob', 10]]
def test_i_can_compute_settings_when_no_agg_func():
grid_settings = {
DG_COLUMNS: {
'A': {'index': 0},
'B': {'index': 1},
}
}
result = DataGrid.get_computed_settings(grid_settings)
expected = {'max_agg_func': 1, 'agg_func_conf': {'A': [None], 'B': [None]}}
assert dataclasses.asdict(result) == expected
def test_i_can_compute_settings():
grid_settings = {
DG_COLUMNS: {
'C': {'agg_func': 'max', 'index': 2},
'D': {'agg_func_2': 'mean', 'index': 3},
'A': {'agg_func': 'sum', 'agg_func_2': 'max', 'index': 0},
'B': {'agg_func_1': 'min', 'agg_func_2': 'mean', 'index': 1},
}
}
result = DataGrid.get_computed_settings(grid_settings)
expected = {'max_agg_func': 2,
'agg_func_conf': {'A': ['sum', 'max'],
'B': ['min', 'mean'],
'C': ['max', None],
'D': [None, 'mean']}}
assert dataclasses.asdict(result) == expected
@pytest.mark.parametrize("agg_func,expected_value", [
(DG_AGGREGATE_MAX, 25),
(DG_AGGREGATE_MIN, 20),
(DG_AGGREGATE_COUNT, 2),
(DG_AGGREGATE_SUM, 45),
(DG_AGGREGATE_MEAN, 22.5),
])
def test_i_can_aggregate_function(agg_func, expected_value):
df = pd.DataFrame({
'Name': ['Alice', 'Bob'],
'Age': [20, 25]
})
grid_settings = {
DG_COLUMNS: {
"name": {
"index": 0,
"title": "Name",
},
"age": {
"index": 1,
"title": "Age",
"agg_func": agg_func,
}}, }
dg = DataGrid(df, id=TEST_GRID_ID, grid_settings=grid_settings)
dg_grid_id = dg.get_grid_id()
footer = dg.mk_table_footer()
expected = Div(
Div(
Div(
Div(None),
data_col="name",
# data_row="-1"
),
Div(
Div(expected_value),
data_col="age",
# data_row="-1"
),
cls="dt-row dt-footer"
),
id=f"tf_{dg_grid_id}",
)
assert matches(footer, expected)
@pytest.mark.parametrize("agg_func,expected_value", [
(DG_AGGREGATE_FILTERED_MAX, 30),
(DG_AGGREGATE_FILTERED_MIN, 20),
(DG_AGGREGATE_FILTERED_COUNT, 3),
(DG_AGGREGATE_FILTERED_SUM, 75),
(DG_AGGREGATE_FILTERED_MEAN, 25.0),
])
def test_i_can_test_filtered_aggregate(agg_func, expected_value):
df = pd.DataFrame({
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [20, 25, 30, 35],
})
grid_settings = {
DG_COLUMNS: {
"name": {
"index": 0,
"title": "Name",
},
"age": {
"index": 1,
"title": "Age",
"agg_func": agg_func,
}}, }
dg = DataGrid(df, id=TEST_GRID_ID, grid_settings=grid_settings)
dg.filter("name", ["Alice", "Bob", "Charlie"])
dg_grid_id = dg.get_grid_id()
footer = dg.mk_table_footer()
expected = Div(
Div(
Div(
Div(None),
data_col="name",
# data_row="-1"
),
Div(
Div(expected_value),
data_col="age",
# data_row="-1"
),
cls="dt-row dt-footer"
),
id=f"tf_{dg_grid_id}",
)
assert matches(footer, expected)
def test_i_can_move_columns(dg, grid_id):
dg.manage_grid_state(MOVE_KEY, ["name"], "0", "1")
res = dg.mk_table()
expected = Div(
Div(
Div(Div(Div("Age")), data_col="age"),
Div(Div(Div("Name")), data_col="name"),
cls="dt-row dt-header",
id=f"th_{grid_id}"),
Div(
Div(
Div(Div("20"), data_col="age"),
Div(Div("Alice"), data_col="name"),
),
Div(
Div(Div("25"), data_col="age"),
Div(Div("Bob"), data_col="name"),
),
id=f"tb_{grid_id}",
),
Div(
Div(
Div(Div(), data_col="age"),
Div(Div(), data_col="name"),
),
id=f"tf_{grid_id}")
)
table = search_elements_by_name(res, None, {"class": "dt-inner-table"})[0]
assert matches(table, expected)
def test_i_can_move_columns_multiple_times(dg2, grid_id):
dg2.manage_grid_state(MOVE_KEY, ["name"], "0", "1")
columns_ids = [c.col_id for c in dg2.get_state().columns]
assert columns_ids == ["age", "name", "city", "student", "date"]
dg2.manage_grid_state(MOVE_KEY, ["age"], "0", "1")
columns_ids = [c.col_id for c in dg2.get_state().columns]
assert columns_ids == ["name", "age", "city", "student", "date"]
dg2.manage_grid_state(MOVE_KEY, ["city"], "2", "4")
columns_ids = [c.col_id for c in dg2.get_state().columns]
assert columns_ids == ["name", "age", "student", "date", "city"]
def test_order_is_kept_when_column_is_hidden_or_shown(dg2, grid_id):
dg2.manage_grid_state(MOVE_KEY, ["name"], "0", "2")
dg2.manage_grid_state(VISIBLE_KEY, ["age"], "true", "false")
columns_ids = [c.col_id for c in dg2.get_state().columns]
assert columns_ids == ["age", "city", "name", "student", "date"]
dg2.manage_grid_state(VISIBLE_KEY, ["age"], "false", "true")
columns_ids = [c.col_id for c in dg2.get_state().columns]
assert columns_ids == ["age", "city", "name", "student", "date"]
def test_the_correct_column_is_select_when_column_order_is_changed(dg2, grid_id):
dg2.get_state().selection_mode = DG_SELECTION_MODE_COLUMN
dg2.manage_grid_state(MOVE_KEY, ["name"], "0", "1")
res = dg2.manage_cell_click(1, 0)
selected = get_selected(res)
assert selected == [('column', 'age'), ('cell', 1, 0)]
def test_filter_only_apply_to_visible_columns(dg, grid_id):
dg.manage_grid_state(DG_STATE_COLUMN_VISIBILITY, ["age"], "true", "false")
dg.filter("age", ["20"])
res = dg.mk_table_body()
values = extract_table_values(res, header=False)
expected = [
["Alice"],
] # since "age" is not visible, but the filter must be kept (as we do with the sort)
assert values == expected
# same if I use the filter all
dg.filter(FILTER_INPUT_CID, "20")
res = dg.mk_table_body()
values = extract_table_values(res, header=False)
expected = [] # since "age" is not visible there no match
assert values == expected
def test_i_can_render_rows_indexes(dg, grid_id):
dg.get_grid_settings()[DG_ROWS_INDEXES] = True
res = dg.mk_table()
table = search_elements_by_name(res, None, {"class": "dt-inner-table"})[0]
expected = Div(
Div(
Div(cls="dt-row-index-cell", data_col="-1"),
Div(Div(Div("Name")), data_col="name"),
Div(Div(Div("Age")), data_col="age"),
id=f"th_{grid_id}"),
Div(
Div(
Div(Div("0"), cls="dt-row-index-cell", data_col="-1"),
Div(Div("Alice"), data_col="name"),
Div(Div("20"), data_col="age"),
),
Div(
Div(Div("1"), data_col="-1"),
Div(Div("Bob"), data_col="name"),
Div(Div("25"), data_col="age"),
),
id=f"tb_{grid_id}",
),
Div(
Div(
Div(cls="dt-row-index-cell", data_col="-1"),
Div(Div(), data_col="name"),
Div(Div(), data_col="age"),
),
id=f"tf_{grid_id}")
)
assert matches(table, expected)
def test_i_can_hide_row(dg, grid_id):
dg.manage_grid_state(DG_STATE_ROW_VISIBILITY, ["0"], "true", "false")
res = dg.mk_table_body()
values = extract_table_values(res, header=False)
expected = [['Bob', '25']]
assert values == expected
def test_i_can_select_a_row(dg, grid_id):
res = dg.manage_row_click(0, '')
selected = get_selected(res)
assert selected == [('row', 0)]
context_menus = get_context_menu(res)
assert context_menus == [{
"hx-post": "/on_state_changed",
"data_tooltip": "Hide row 0",
"attribute": DG_STATE_ROW_VISIBILITY,
"col_ids": "0",
"old_value": True,
"new_value": False,
}]
def test_i_can_select_and_unselected_rows_using_control_key(dg, grid_id):
res = dg.manage_row_click(0, 'ctrl')
selected = get_selected(res)
assert selected == [('row', 0)]
context_menus = get_context_menu(res)
assert context_menus == [{
"hx-post": "/on_state_changed",
"data_tooltip": "Hide row 0",
"attribute": DG_STATE_ROW_VISIBILITY,
"col_ids": "0",
"old_value": True,
"new_value": False,
}]
# If I click again the row is no longer selected
res = dg.manage_row_click(0, 'ctrl-')
selected = get_selected(res)
assert selected == []
context_menus = get_context_menu(res)
assert context_menus == []
def test_i_can_select_multiple_rows_using_control_key(dg, grid_id):
dg.manage_row_click(1, '')
res = dg.manage_row_click(0, 'ctrl-')
selected = get_selected(res)
assert selected == [('row', 1), ('row', 0)]
context_menus = get_context_menu(res)
assert context_menus == [{
"hx-post": "/on_state_changed",
"data_tooltip": "Hide rows 0, 1", # the order is always ascending
"attribute": DG_STATE_ROW_VISIBILITY,
"col_ids": "0, 1",
"old_value": True,
"new_value": False,
}]
def test_i_can_select_multiple_rows_using_shift_key(dg2, grid_id):
res = dg2.manage_row_click(3, 'shift-')
selected = get_selected(res)
assert selected == [('row', 3)]
res = dg2.manage_row_click(0, 'shift-')
selected = get_selected(res)
assert selected == [('row', 0), ('row', 1), ('row', 2), ('row', 3)]
context_menus = get_context_menu(res)
assert context_menus == [{
"hx-post": "/on_state_changed",
"data_tooltip": "Hide rows 0, 1, 2, 3", # the order is always ascending
"attribute": DG_STATE_ROW_VISIBILITY,
"col_ids": "0, 1, 2, 3",
"old_value": True,
"new_value": False,
}]
def test_hidden_rows_can_be_made_visible_using_shift_key(dg2, grid_id):
dg2.manage_grid_state(DG_STATE_ROW_VISIBILITY, ["2"], "true", "false")
dg2.manage_row_click(0, '')
res = dg2.manage_row_click(3, 'shift-')
context_menus = get_context_menu(res)
assert context_menus == [
{
"hx-post": "/on_state_changed",
"data_tooltip": "Hide rows 0, 1, 3", # the order is always ascending
"attribute": DG_STATE_ROW_VISIBILITY,
"col_ids": "0, 1, 3",
"old_value": True,
"new_value": False
},
{
"hx-post": "/on_state_changed",
"data_tooltip": "Show row 2",
"attribute": DG_STATE_ROW_VISIBILITY,
"col_ids": "2",
"old_value": False,
"new_value": True
}]
Reference in New Issue View Git Blame Copy Permalink