def test_should_set_tooltip(self):
# given
mapList4 = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
tabledisplay = TableDisplay(mapList4)
def config_tooltip(row, column, table):
return "The value is: " + str(table.values[row][column])
# when
tabledisplay.setToolTip(config_tooltip)
# then
tooltips = tabledisplay.chart.tooltips
self.assertEqual(tooltips[2][2], "The value is: 5")
def test_should_set_font_color_provider(self):
# given
mapList4 = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
tabledisplay = TableDisplay(mapList4)
colors = [[Color.LIGHT_GRAY, Color.GRAY, Color.RED],
[Color.DARK_GREEN, Color.ORANGE, Color.RED],
[Color.MAGENTA, Color.BLUE, Color.BLACK]]
def colorProvider(row, column, table):
return colors[row][column]
# when
tabledisplay.setFontColorProvider(colorProvider)
# then
self.assertEqual(tabledisplay.model["fontColor"][0][0],
Color.LIGHT_GRAY.hex())
def test_should_filter_all_rows(self):
# given
mapList4 = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
tabledisplay = TableDisplay(mapList4)
def filter_row(row, model):
return True
# when
tabledisplay.setRowFilter(filter_row)
# then
self.assertEqual(tabledisplay.model["filteredValues"][0], [1, 2, 3])
self.assertEqual(tabledisplay.model["filteredValues"][1], [4, 5, 6])
self.assertEqual(tabledisplay.model["filteredValues"][2], [7, 8, 5])
def test_should_set_string_format_humanFriendly_for_time(self):
# given
df = pd.read_csv(os.path.dirname(__file__) + "/resources/" + 'interest-rates.csv')
table = TableDisplay(df)
# when
table.setStringFormatForType(ColumnType.Time, TableDisplayStringFormat.getTimeFormat(TimeUnit.DAYS, True))
# then
time = table.model[STRING_FORMAT_FOR_TYPE]['time']
self.assertEqual(time['humanFriendly'], True)
def test_should_set_string_format_for_times(self):
# given
df = pd.read_csv(os.path.dirname(__file__) + "/resources/" + 'interest-rates.csv')
table = TableDisplay(df)
# when
table.setStringFormatForTimes(TimeUnit.DAYS)
# then
time = table.model[STRING_FORMAT_FOR_TYPE]['time']
self.assertEqual(time['type'], "time")
self.assertEqual(time['unit'], TimeUnit.DAYS.name)
def test_should_set_headers_vertical_to_true(self):
# given
mapList4 = [
{"a": 1, "b": 2, "c": 3},
{"a": 4, "b": 5, "c": 6},
{"a": 7, "b": 8, "c": 5}
]
tabledisplay = TableDisplay(mapList4)
# when
tabledisplay.setHeadersVertical(True)
# then
self.assertEqual(tabledisplay.model["headersVertical"], True)
def test_should_add_heatmap_highlighter(self):
# given
df = pd.read_csv(
os.path.dirname(__file__) + "/resources/" + 'interest-rates.csv')
table = TableDisplay(df)
# when
table.addCellHighlighter(
TableDisplayCellHighlighter.getHeatmapHighlighter("m3"))
# then
cellHighlighters = table.model['cellHighlighters'][0]
self.assertEqual(cellHighlighters["colName"], "m3")
self.assertEqual(cellHighlighters["style"],
HighlightStyle.FULL_ROW.value)
self.assertEqual(cellHighlighters["type"], HeatmapHighlighter.type)
def test_NaT_support(self):
# given
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f', 'h'], columns=['one', 'two', 'three'])
df['timestamp'] = pd.Timestamp('20120101')
df.loc[['a', 'c', 'h'], ['one', 'timestamp']] = np.nan
# when
display = TableDisplay(df)
# then
self.assertTrue(display.values[0][4] == Table.NAT_VALUE)
def test_date_format(self):
# given
df = pd.read_csv(
os.path.dirname(__file__) + "/resources/" + 'interest-rates.csv')
df['time'] = pd.to_datetime(df['time'], utc=True)
# when
table = TableDisplay(df)
# then
self.assertEqual(table.model['values'][0][7]['timestamp'],
633744000000.0)
def test_should_set_header_font_size(self):
# given
mapList4 = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
tabledisplay = TableDisplay(mapList4)
# when
tabledisplay.setHeaderFontSize(33)
# then
self.assertEqual(tabledisplay.model["headerFontSize"], 33)
def toWidget(self, item):
if item is None:
return self.createHTMLPre("None")
if isinstance(item, DataFrame):
return TableDisplay(item)
if isinstance(item, Widget):
return item
return self.createHTMLPre(item.__str__())
def test_default_headers_vertical_should_be_false(self):
# given
mapList4 = [
{"a": 1, "b": 2, "c": 3},
{"a": 4, "b": 5, "c": 6},
{"a": 7, "b": 8, "c": 5}
]
# when
tabledisplay = TableDisplay(mapList4)
# then
self.assertEqual(tabledisplay.model["headersVertical"], False)
def test_should_set_data_font_size(self):
# given
mapList4 = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
tabledisplay = TableDisplay(mapList4)
# when
tabledisplay.setDataFontSize(25)
# then
self.assertEqual(tabledisplay.model["dataFontSize"], 25)
def test_should_set_time_zone(self):
# given
timezone = "TZ1"
mapList4 = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
tabledisplay = TableDisplay(mapList4)
# when
tabledisplay.setTimeZone(timezone)
# then
self.assertEqual(tabledisplay.model["timeZone"], timezone)
def test_should_create_table_display_when_columns_equal_types(self):
# given
colNames = ["column1", "column2", "column3"]
row1 = [1, 2, 3]
row2 = [4, 5, 6]
# when
try:
TableDisplay(pd.DataFrame([row1, row2]), colNames, ['integer', 'integer'])
raise Exception("Test should not pass")
except Exception as e:
# then
self.assertTrue('The length of types should be same as number of columns.' in e.args)
def test_negate_when_context_menu_item_event(self):
# given
mapList4 = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
tabledisplay = TableDisplay(mapList4)
def negate(row, column, table):
table.values[row][column] = -1 * int(table.values[row][column])
tabledisplay.addContextMenuItem("negate", negate)
param = {
'event': 'CONTEXT_MENU_CLICK',
'itemKey': 'negate',
'row': 1,
'column': 1
}
# when
tabledisplay.handle_msg(tabledisplay, param, [])
# then
values = tabledisplay.chart.values
self.assertEqual(values[1][1], -5)
def test_sum_rows_when_double_click(self):
# given
mapList4 = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
tabledisplay = TableDisplay(mapList4)
def dclick(row, column, table):
table.values[row][column] = sum(map(int, table.values[row]))
tabledisplay.setDoubleClickAction(dclick)
param = {'event': 'DOUBLE_CLICK', 'row': 0, 'column': 0}
# when
tabledisplay.handle_msg(tabledisplay, param, [])
# then
values = tabledisplay.chart.values
self.assertEqual(values[0][0], 6)
def test_should_set_local_timezone(self):
#given
gtimezone = "GTZ1"
mapList4 = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
TableDisplay.timeZoneGlobal = gtimezone
#when
tabledisplay1 = TableDisplay(mapList4)
tabledisplay1.setTimeZone("TZ2")
# then
self.assertEqual(tabledisplay1.model["timeZone"], "TZ2")
def toWidget(self, item):
if item is None:
return self.createHTMLPre("None")
if isinstance(item, DataFrame):
if TableDisplay is not None:
return TableDisplay(item)
else:
return self.createHTMLPre("You need beakerx_tabledisplay to display this")
if isinstance(item, Widget):
return item
return self.createHTMLPre(item.__str__())
def test_support_discovering_types(self):
# given
colNames = ["xxx column", "integer column", "double column", "number column"]
row1 = [6.1, 6, 0.5, 6]
row2 = [3.1, 3, 2.0, 3]
row3 = [2.2, 2, 3.0, 2]
row4 = [0.1, 0, 6.0, 0]
# when
table = TableDisplay(pd.DataFrame([row1, row2, row3, row4], columns=colNames), colNames)
# then
self.assertTrue(table.model["types"][0] == "double")
self.assertTrue(table.model["types"][1] == "integer")
self.assertTrue(table.model["types"][2] == "double")
self.assertTrue(table.model["types"][3] == "integer")
def test_should_set_global_timezone(self):
#given
gtimezone = "GTZ1"
mapList4 = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
#when
TableDisplay.timeZoneGlobal = gtimezone
tabledisplay1 = TableDisplay(mapList4)
tabledisplay2 = TableDisplay(mapList4)
# then
self.assertEqual(tabledisplay1.model["timeZone"], gtimezone)
self.assertEqual(tabledisplay2.model["timeZone"], gtimezone)
def test_support_setting_types(self):
# given
colNames = ["xxx column", "integer column", "double column", "number column"]
row1 = [6, 6, 0.5, 6]
row2 = [3, 3, 2.0, 3]
row3 = [2, 2, 3.0, 2]
row4 = [0, 0, 6.0, 0]
# when
table = TableDisplay(pd.DataFrame([row1, row2, row3, row4], columns=colNames), colNames, ['xxx type', 'integer', 'double', 'number'])
# then
self.assertTrue(table.model["types"][0] == "xxx type")
self.assertTrue(table.model["types"][1] == "integer")
self.assertTrue(table.model["types"][2] == "double")
self.assertTrue(table.model["types"][3] == "number")
def test_should_set_alignment_provider_for_type(self):
# given
df = pd.read_csv(
os.path.dirname(__file__) + "/resources/" + 'interest-rates.csv')
table = TableDisplay(df)
# when
table.setAlignmentProviderForType(
ColumnType.Double, TableDisplayAlignmentProvider.RIGHT_ALIGNMENT)
table.setAlignmentProviderForType(
ColumnType.Integer, TableDisplayAlignmentProvider.LEFT_ALIGNMENT)
table.setAlignmentProviderForType(
ColumnType.Boolean, TableDisplayAlignmentProvider.CENTER_ALIGNMENT)
# then
alignment = table.model['alignmentForType']
self.assertEqual(alignment['double'], "R")
self.assertEqual(alignment['integer'], "L")
self.assertEqual(alignment['boolean'], "C")
def test_should_filter_last_row(self):
# given
mapList4 = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
tabledisplay = TableDisplay(mapList4)
def filter_row(row, model):
return model[row][1] == 8
# when
tabledisplay.setRowFilter(filter_row)
# then
self.assertEqual(tabledisplay.model["filteredValues"], [[7, 8, 5]])
def test_filtered_values(self):
# given
mapListFilter = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
display = TableDisplay(mapListFilter)
def filter_row(row, model):
return model[row][1] == 8
# when
display.setRowFilter(filter_row)
# then
self.assertEqual(display.model["filteredValues"], [[7, 8, 5]])
def test_no_filtered_values_when_no_setRowFilter(self):
# given
mapListFilter = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
# when
display = TableDisplay(mapListFilter)
# then
self.assertFalse('filteredValues' in display.model)
def test_default_time_zone(self):
# given
mapList4 = [{
"a": 1,
"b": 2,
"c": 3
}, {
"a": 4,
"b": 5,
"c": 6
}, {
"a": 7,
"b": 8,
"c": 5
}]
# when
tabledisplay = TableDisplay(mapList4)
# then
self.assertTrue("timeZone" not in tabledisplay.model)
def f():
display_html(TableDisplay(model_instance))
