commit 7719621a1e184e5e94fec94a06a70ded0d2171e0
Author: Damian Johnson <atagar(a)torproject.org>
Date: Sat Jun 25 12:34:24 2016 -0700
Test for drawing a blank subgraph
Not an overly useful test but first step in breaking these into functions and
adding test coverage.
---
nyx/panel/graph.py | 216 ++++++++++++++++++++++++++--------------------------
test/panel/graph.py | 30 ++++++++
2 files changed, 140 insertions(+), 106 deletions(-)
diff --git a/nyx/panel/graph.py b/nyx/panel/graph.py
index d3ed768..68c136a 100644
--- a/nyx/panel/graph.py
+++ b/nyx/panel/graph.py
@@ -556,152 +556,156 @@ class GraphPanel(nyx.panel.Panel):
subwindow.addstr(0, 0, attr.stat.title(subwindow.width), HIGHLIGHT)
- self._draw_subgraph(subwindow, attr, attr.stat.primary, 0, PRIMARY_COLOR)
- self._draw_subgraph(subwindow, attr, attr.stat.secondary, attr.subgraph_width, SECONDARY_COLOR)
+ _draw_subgraph(subwindow, attr, attr.stat.primary, 0, PRIMARY_COLOR)
+ _draw_subgraph(subwindow, attr, attr.stat.secondary, attr.subgraph_width, SECONDARY_COLOR)
if attr.stat.stat_type() == GraphStat.BANDWIDTH and accounting_stats:
_draw_accounting_stats(subwindow, DEFAULT_CONTENT_HEIGHT + attr.subgraph_height - 2, accounting_stats)
- def _draw_subgraph(self, subwindow, attr, data, x, color):
- # Concering our subgraph colums, the y-axis label can be at most six
- # characters, with two spaces of padding on either side of the graph.
- # Starting with the smallest size, then possibly raise it after determing
- # the y_axis_labels.
+ def _update_accounting(self, event):
+ if not CONFIG['features.graph.bw.accounting.show']:
+ self._accounting_stats = None
+ elif not self._accounting_stats or time.time() - self._accounting_stats.retrieved >= ACCOUNTING_RATE:
+ old_accounting_stats = self._accounting_stats
+ self._accounting_stats = tor_controller().get_accounting_stats(None)
- subgraph_columns = attr.subgraph_width - 8
- min_bound, max_bound = self._get_graph_bounds(attr, data, subgraph_columns)
+ if not self.is_paused():
+ # if we either added or removed accounting info then redraw the whole
+ # screen to account for resizing
- x_axis_labels = self._get_x_axis_labels(attr, subgraph_columns)
- y_axis_labels = self._get_y_axis_labels(attr, data, min_bound, max_bound)
- subgraph_columns = max(subgraph_columns, attr.subgraph_width - max([len(label) for label in y_axis_labels.values()]) - 2)
- axis_offset = max([len(label) for label in y_axis_labels.values()])
+ if bool(old_accounting_stats) != bool(self._accounting_stats):
+ nyx.controller.get_controller().redraw()
- subwindow.addstr(x, 1, data.header(attr.subgraph_width), color, BOLD)
+ def _update_stats(self, event):
+ for stat in self._stats.values():
+ stat.bandwidth_event(event)
- for x_offset, label in x_axis_labels.items():
- if attr.right_to_left:
- subwindow.addstr(x + attr.subgraph_width - x_offset, attr.subgraph_height, label, color)
- else:
- subwindow.addstr(x + x_offset + axis_offset, attr.subgraph_height, label, color)
+ if self.displayed_stat:
+ param = self._stats[self.displayed_stat]
+ update_rate = INTERVAL_SECONDS[self.update_interval]
- for y, label in y_axis_labels.items():
- subwindow.addstr(x, y, label, color)
+ if param.primary.tick % update_rate == 0:
+ self.redraw(True)
- for col in range(subgraph_columns):
- column_count = int(data.values[attr.interval][col]) - min_bound
- column_height = int(min(attr.subgraph_height - 2, (attr.subgraph_height - 2) * column_count / (max(1, max_bound) - min_bound)))
- for row in range(column_height):
- if attr.right_to_left:
- subwindow.addstr(x + attr.subgraph_width - col - 1, attr.subgraph_height - 1 - row, ' ', color, HIGHLIGHT)
- else:
- subwindow.addstr(x + col + axis_offset + 1, attr.subgraph_height - 1 - row, ' ', color, HIGHLIGHT)
+def _draw_subgraph(subwindow, attr, data, x, color):
+ # Concering our subgraph colums, the y-axis label can be at most six
+ # characters, with two spaces of padding on either side of the graph.
+ # Starting with the smallest size, then possibly raise it after determing
+ # the y_axis_labels.
- def _get_graph_bounds(self, attr, data, subgraph_columns):
- """
- Provides the range the graph shows (ie, its minimum and maximum value).
- """
+ subgraph_columns = attr.subgraph_width - 8
+ min_bound, max_bound = _get_graph_bounds(attr, data, subgraph_columns)
- min_bound, max_bound = 0, 0
- values = data.values[attr.interval][:subgraph_columns]
+ x_axis_labels = _x_axis_labels(attr.interval, subgraph_columns)
+ y_axis_labels = _y_axis_labels(attr.subgraph_height, data, min_bound, max_bound)
+ subgraph_columns = max(subgraph_columns, attr.subgraph_width - max([len(label) for label in y_axis_labels.values()]) - 2)
+ axis_offset = max([len(label) for label in y_axis_labels.values()])
- if attr.bounds_type == Bounds.GLOBAL_MAX:
- max_bound = data.max_value[attr.interval]
- elif subgraph_columns > 0:
- max_bound = max(values) # local maxima
+ subwindow.addstr(x, 1, data.header(attr.subgraph_width), color, BOLD)
- if attr.bounds_type == Bounds.TIGHT and subgraph_columns > 0:
- min_bound = min(values)
+ for x_offset, label in x_axis_labels.items():
+ if attr.right_to_left:
+ subwindow.addstr(x + attr.subgraph_width - x_offset, attr.subgraph_height, label, color)
+ else:
+ subwindow.addstr(x + x_offset + axis_offset, attr.subgraph_height, label, color)
- # if the max = min pick zero so we still display something
+ for y, label in y_axis_labels.items():
+ subwindow.addstr(x, y, label, color)
- if min_bound == max_bound:
- min_bound = 0
+ for col in range(subgraph_columns):
+ column_count = int(data.values[attr.interval][col]) - min_bound
+ column_height = int(min(attr.subgraph_height - 2, (attr.subgraph_height - 2) * column_count / (max(1, max_bound) - min_bound)))
- return min_bound, max_bound
+ for row in range(column_height):
+ if attr.right_to_left:
+ subwindow.addstr(x + attr.subgraph_width - col - 1, attr.subgraph_height - 1 - row, ' ', color, HIGHLIGHT)
+ else:
+ subwindow.addstr(x + col + axis_offset + 1, attr.subgraph_height - 1 - row, ' ', color, HIGHLIGHT)
- def _get_y_axis_labels(self, attr, data, min_bound, max_bound):
- """
- Provides the labels for the y-axis. This is a mapping of the position it
- should be drawn at to its text.
- """
- y_axis_labels = {
- 2: data.y_axis_label(max_bound),
- attr.subgraph_height - 1: data.y_axis_label(min_bound),
- }
+def _get_graph_bounds(attr, data, subgraph_columns):
+ """
+ Provides the range the graph shows (ie, its minimum and maximum value).
+ """
- ticks = (attr.subgraph_height - 5) / 2
+ min_bound, max_bound = 0, 0
+ values = data.values[attr.interval][:subgraph_columns]
- for i in range(ticks):
- row = attr.subgraph_height - (2 * i) - 5
+ if attr.bounds_type == Bounds.GLOBAL_MAX:
+ max_bound = data.max_value[attr.interval]
+ elif subgraph_columns > 0:
+ max_bound = max(values) # local maxima
- if attr.subgraph_height % 2 == 0 and i >= (ticks / 2):
- row -= 1 # make extra gap be in the middle when we're an even size
+ if attr.bounds_type == Bounds.TIGHT and subgraph_columns > 0:
+ min_bound = min(values)
- val = (max_bound - min_bound) * (attr.subgraph_height - row - 3) / (attr.subgraph_height - 3)
+ # if the max = min pick zero so we still display something
- if val not in (min_bound, max_bound):
- y_axis_labels[row + 2] = data.y_axis_label(val)
+ if min_bound == max_bound:
+ min_bound = 0
- return y_axis_labels
+ return min_bound, max_bound
- def _get_x_axis_labels(self, attr, subgraph_columns):
- """
- Provides the labels for the x-axis. We include the units for only its first
- value, then bump the precision for subsequent units. For example...
- 10s, 20, 30, 40, 50, 1m, 1.1, 1.3, 1.5
- """
+def _x_axis_labels(interval, subgraph_columns):
+ """
+ Provides the labels for the x-axis. We include the units for only its first
+ value, then bump the precision for subsequent units. For example...
- x_axis_labels = {}
+ 10s, 20, 30, 40, 50, 1m, 1.1, 1.3, 1.5
+ """
- interval_sec = INTERVAL_SECONDS[attr.interval]
- interval_spacing = 10 if subgraph_columns >= WIDE_LABELING_GRAPH_COL else 5
- units_label, decimal_precision = None, 0
+ x_axis_labels = {}
- for i in range((subgraph_columns - 4) / interval_spacing):
- x = (i + 1) * interval_spacing
- time_label = str_tools.time_label(x * interval_sec, decimal_precision)
+ interval_sec = INTERVAL_SECONDS[interval]
+ interval_spacing = 10 if subgraph_columns >= WIDE_LABELING_GRAPH_COL else 5
+ units_label, decimal_precision = None, 0
- if not units_label:
- units_label = time_label[-1]
- elif units_label != time_label[-1]:
- # upped scale so also up precision of future measurements
- units_label = time_label[-1]
- decimal_precision += 1
- else:
- # if constrained on space then strips labeling since already provided
- time_label = time_label[:-1]
+ for i in range((subgraph_columns - 4) / interval_spacing):
+ x = (i + 1) * interval_spacing
+ time_label = str_tools.time_label(x * interval_sec, decimal_precision)
- x_axis_labels[x] = time_label
+ if not units_label:
+ units_label = time_label[-1]
+ elif units_label != time_label[-1]:
+ # upped scale so also up precision of future measurements
+ units_label = time_label[-1]
+ decimal_precision += 1
+ else:
+ # if constrained on space then strips labeling since already provided
+ time_label = time_label[:-1]
- return x_axis_labels
+ x_axis_labels[x] = time_label
- def _update_accounting(self, event):
- if not CONFIG['features.graph.bw.accounting.show']:
- self._accounting_stats = None
- elif not self._accounting_stats or time.time() - self._accounting_stats.retrieved >= ACCOUNTING_RATE:
- old_accounting_stats = self._accounting_stats
- self._accounting_stats = tor_controller().get_accounting_stats(None)
+ return x_axis_labels
- if not self.is_paused():
- # if we either added or removed accounting info then redraw the whole
- # screen to account for resizing
- if bool(old_accounting_stats) != bool(self._accounting_stats):
- nyx.controller.get_controller().redraw()
+def _y_axis_labels(subgraph_height, data, min_bound, max_bound):
+ """
+ Provides the labels for the y-axis. This is a mapping of the position it
+ should be drawn at to its text.
+ """
- def _update_stats(self, event):
- for stat in self._stats.values():
- stat.bandwidth_event(event)
+ y_axis_labels = {
+ 2: data.y_axis_label(max_bound),
+ subgraph_height - 1: data.y_axis_label(min_bound),
+ }
- if self.displayed_stat:
- param = self._stats[self.displayed_stat]
- update_rate = INTERVAL_SECONDS[self.update_interval]
+ ticks = (subgraph_height - 5) / 2
- if param.primary.tick % update_rate == 0:
- self.redraw(True)
+ for i in range(ticks):
+ row = subgraph_height - (2 * i) - 5
+
+ if subgraph_height % 2 == 0 and i >= (ticks / 2):
+ row -= 1 # make extra gap be in the middle when we're an even size
+
+ val = (max_bound - min_bound) * (subgraph_height - row - 3) / (subgraph_height - 3)
+
+ if val not in (min_bound, max_bound):
+ y_axis_labels[row + 2] = data.y_axis_label(val)
+
+ return y_axis_labels
def _draw_accounting_stats(subwindow, y, accounting):
diff --git a/test/panel/graph.py b/test/panel/graph.py
index f2eca4b..26fd7da 100644
--- a/test/panel/graph.py
+++ b/test/panel/graph.py
@@ -7,12 +7,23 @@ import unittest
import stem.control
+import nyx.curses
import nyx.panel.graph
import test
from test import require_curses
from mock import patch
+EXPECTED_BLANK_GRAPH = """
+Download:
+0 b
+
+
+
+0 b
+ 5s 10 15
+""".rstrip()
+
EXPECTED_ACCOUNTING = """
Accounting (awake) Time to reset: 01:02
37.7 Kb / 842.0 Kb 16.0 Kb / 74.1 Kb
@@ -22,6 +33,25 @@ Accounting (awake) Time to reset: 01:02
class TestGraph(unittest.TestCase):
@require_curses
@patch('nyx.panel.graph.tor_controller')
+ def test_draw_subgraph_blank(self, tor_controller_mock):
+ tor_controller_mock().get_info.return_value = None
+
+ attr = nyx.panel.graph.DrawAttributes(
+ stat = None,
+ subgraph_height = 7,
+ subgraph_width = 30,
+ interval = nyx.panel.graph.Interval.EACH_SECOND,
+ bounds_type = nyx.panel.graph.Bounds.LOCAL_MAX,
+ right_to_left = False,
+ )
+
+ data = nyx.panel.graph.BandwidthStats()
+
+ rendered = test.render(nyx.panel.graph._draw_subgraph, attr, data.primary, 0, nyx.curses.Color.CYAN)
+ self.assertEqual(EXPECTED_BLANK_GRAPH, rendered.content)
+
+ @require_curses
+ @patch('nyx.panel.graph.tor_controller')
def test_draw_accounting_stats(self, tor_controller_mock):
tor_controller_mock().is_alive.return_value = True
