def test_fo_graphical_icon_disappears(self): o = get_mock_graphical_output() overlay = FunctionOverlay([lambda: True, lambda: False]) mu = Menu([], get_mock_input(), o, name=ui_name, config={}) mu.idle_loop = lambda *a, **k: True Canvas.fonts_dir = fonts_dir overlay.apply_to(mu) def activate(): mu.before_activate() mu.to_foreground() mu.idle_loop() img_1 = o.display_image.call_args[0] mu.idle_loop() mu.refresh() img_2 = o.display_image.call_args[0] assert(img_1 == img_2) for i in range(overlay.duration): mu.idle_loop() mu.refresh() img_2 = o.display_image.call_args[0] assert(img_1 != img_2) mu.deactivate() # KEY_LEFT with patch.object(mu, 'activate', side_effect=activate) as p: mu.activate()
def test_left_key_returns_none(self): num_elements = 3 contents = [["A" + str(i), "a" + str(i)] for i in range(num_elements)] mu = Menu(contents, get_mock_input(), get_mock_output(), name=mu_name, config={}) mu.refresh = lambda *args, **kwargs: None # Checking at the start of the list def scenario(): mu.deactivate() # KEY_LEFT assert not mu.in_foreground with patch.object(mu, 'idle_loop', side_effect=scenario) as p: return_value = mu.activate() assert return_value is None # Checking at the end of the list def scenario(): for i in range(num_elements): mu.move_down() # KEY_DOWN x3 mu.deactivate() # KEY_LEFT assert not mu.in_foreground with patch.object(mu, 'idle_loop', side_effect=scenario) as p: return_value = mu.activate() assert return_value is None
def wireless_status(): w_status = wpa_cli.connection_status() state = w_status['wpa_state'] status_menu_contents = [[["state:", state]]] #State is an element that's always there, let's see possible states if state == 'COMPLETED': #We have bssid, ssid and key_mgmt at least status_menu_contents.append(['SSID: '+w_status['ssid']]) status_menu_contents.append(['BSSID: '+w_status['bssid']]) key_mgmt = w_status['key_mgmt'] status_menu_contents.append([['Security:', key_mgmt]]) #If we have WPA in key_mgmt, we also have pairwise_cipher and group_cipher set to something other than NONE so we can show them if key_mgmt != 'NONE': try: #What if? group = w_status['group_cipher'] pairwise = w_status['pairwise_cipher'] status_menu_contents.append([['Group/Pairwise:', group+"/"+pairwise]]) except: pass elif state in ['AUTHENTICATING', 'SCANNING', 'ASSOCIATING']: pass #These states don't have much information #In any case, we might or might not have IP address info status_menu_contents.append([['IP address:',w_status['ip_address'] if 'ip_address' in w_status else 'None']]) #We also always have WiFi MAC address as 'address' status_menu_contents.append(['MAC: '+w_status['address']]) status_menu = Menu(status_menu_contents, i, o, "Wireless status menu", entry_height=2) status_menu.activate()
def test_contents_hook(self): """Tests whether menu contents hook is executed""" ev = Event() def gen_contents(): return [["True", ev.clear] if ev.isSet() else ["False", ev.set]] mu = Menu([], get_mock_input(), get_mock_output(), name=mu_name, contents_hook=gen_contents, config={}) def scenario(): assert mu.contents[0][0] == "False" mu.select_entry() assert mu.contents[0][0] == "True" mu.select_entry() assert mu.contents[0][0] == "False" mu.deactivate() assert not mu.in_foreground with patch.object(mu, 'idle_loop', side_effect=scenario) as p: mu.activate()
def show_scan_results(): network_menu_contents = [] networks = wpa_cli.get_scan_results() for network in networks: network_menu_contents.append([network['ssid'], lambda x=network: network_info_menu(x)]) network_menu = Menu(network_menu_contents, i, o, "Wireless network menu") network_menu.activate()
def launch(): try: current_interface = wpa_cli.get_current_interface() except OSError as e: if e.errno == 2: Printer(["Do you have", "wpa_cli?"], i, o, 3, skippable=True) return else: raise e except wpa_cli.WPAException: Printer([ "Do you have", "wireless cards?", "Is wpa_supplicant", "running?" ], i, o, 3, skippable=True) return else: main_menu_contents = [ [current_interface, change_interface], ["Scan", scan], ["Networks", show_networks], ["Status", wireless_status], ["Save changes", save_changes], #["Saved networks", manage_saved_networks], ["Exit", 'exit'] ] main_menu = Menu(main_menu_contents, i, o, "wpa_cli main menu") main_menu.activate()
def test_enter_on_last_returns_right(self): num_elements = 3 contents = [["A" + str(i), "a" + str(i)] for i in range(num_elements)] mu = Menu(contents, get_mock_input(), get_mock_output(), name=mu_name, config={}) mu.refresh = lambda *args, **kwargs: None # Checking at other elements - shouldn't return def scenario(): mu.select_entry() # KEY_ENTER assert mu.in_foreground # Should still be active mu.deactivate( ) # because is not deactivated yet and would idle loop otherwise with patch.object(mu, 'idle_loop', side_effect=scenario) as p: return_value = mu.activate() assert return_value is None # Scrolling to the end of the list and pressing Enter - should return a correct dict def scenario(): for i in range(num_elements): mu.move_down() # KEY_DOWN x3 mu.select_entry() # KEY_ENTER assert not mu.in_foreground with patch.object(mu, 'idle_loop', side_effect=scenario) as p: return_value = mu.activate() assert isinstance(return_value, dict) assert all( [isinstance(key, basestring) for key in return_value.keys()]) assert all( [isinstance(value, bool) for value in return_value.values()])
def show_scan_results(): network_menu_contents = [] networks = wpa_cli.get_scan_results() for network in networks: network_menu_contents.append( [network['ssid'], lambda x=network: network_info_menu(x)]) network_menu = Menu(network_menu_contents, i, o, "Wireless network menu") network_menu.activate()
def change_interface(): #This function builds a menu out of all the interface names, each having a callback to show_if_function with interface name as argument menu_contents = [] interfaces = wpa_cli.get_interfaces() for interface in interfaces: menu_contents.append([interface, lambda x=interface: change_current_interface(x)]) interface_menu = Menu(menu_contents, i, o, "Interface change menu") interface_menu.activate()
def network_info_menu(network_info): network_info_contents = [ ["Connect", lambda x=network_info: connect_to_network(x)], ["BSSID", lambda x=network_info['bssid']: Printer(x, i, o, 5, skippable=True)], ["Frequency", lambda x=network_info['frequency']: Printer(x, i, o, 5, skippable=True)], ["Open" if wpa_cli.is_open_network(network_info) else "Secured", lambda x=network_info['flags']: Printer(x, i, o, 5, skippable=True)]] network_info_menu = Menu(network_info_contents, i, o, "Wireless network info", catch_exit=False) network_info_menu.activate()
def manage_networks(): global saved_networks saved_networks = wpa_cli.list_configured_networks() network_menu_contents = [] #As of wpa_supplicant 2.3-1, header elements are ['network id', 'ssid', 'bssid', 'flags'] for num, network in enumerate(saved_networks): network_menu_contents.append(["{0[network id]}: {0[ssid]}".format(network), lambda x=num: saved_network_menu(saved_networks[x])]) network_menu = Menu(network_menu_contents, i, o, "Saved network menu", catch_exit=False) network_menu.activate()
def callback(): c = [["Update ZPUI", git_updater.update, git_updater.settings], ["Bugreport", bugreport_ui.main_menu], ["Logging settings", logging_ui.config_logging], ["About", about.about]] menu = Menu(c, i, o, "ZPUI settings menu") help_text = "Press RIGHT on \"Update ZPUI\" to change OTA update settings (branch or git URL to use)" HelpOverlay(help_text).apply_to(menu) menu.activate()
def show_ifc_data(ifc_name): ch = lambda x=ifc_name: get_ifc_menu_contents(x) ifd_menu = Menu([], i, o, "{} interface data menu".format(ifc_name), entry_height=2, contents_hook=ch) ifd_menu.activate()
def show_ifc_data(ifc_name, ifc_data): ifd_menu_contents = [ ["state: "+str(ifc_data['state'])], ["IP: "+str(ifc_data['addr'])], ["IP6: "+str(ifc_data['addr6'])], ["MAC: "+str(ifc_data['ph_addr'])] ] ifd_menu = Menu(ifd_menu_contents, i, o, "{} interface data menu".format(ifc_name), entry_height=2) ifd_menu.activate()
def show_scan_results(): network_menu_contents = [] networks = wpa_cli.get_scan_results() for network in networks: if network["ssid"] == '': ssid = '[Hidden]' elif network["ssid"]: ssid = network["ssid"] network_menu_contents.append([ssid, lambda x=network: network_info_menu(x)]) network_menu = Menu(network_menu_contents, i, o, "Wireless network menu") network_menu.activate()
def test_ho_text_redraw(self): overlay = HelpOverlay(lambda: True) mu = Menu([["Hello"]], get_mock_input(), get_mock_output(), name=ui_name, config={}) overlay.apply_to(mu) def scenario(): mu.deactivate() assert not mu.in_foreground with patch.object(mu, 'idle_loop', side_effect=scenario) as p: mu.activate() assert mu.o.display_data.called assert mu.o.display_data.call_count == 1 #One in to_foreground assert mu.o.display_data.call_args[0] == ('Hello', mu.exit_entry[0])
def launch(): try: systemctl.list_units() except OSError as e: if e.errno == 2: Printer(["Do you use", "systemctl?"], i, o, 3, skippable=True) return else: raise e main_menu_contents = [["Units (filtered)", filtered_units], ["All units", all_units], ["Change filters", change_filters]] main_menu = Menu(main_menu_contents, i, o, "systemctl main menu") main_menu.activate()
def show_ifc_data(ifc_name, ifc_data): ip, mask = str(ifc_data['addr']).rsplit('/', 1) ip_header = "IP: " mask_str = "/{}".format(mask) ip_header_str = ip_header + mask_str.rjust(o.cols-len(ip_header)) #Magic to make it beautiful print(ip_header_str) ifd_menu_contents = [ ["state: "+str(ifc_data['state'])], [[ip_header_str, ip]], ["IP6: "+str(ifc_data['addr6']), lambda: Printer(str(ifc_data['addr6']), i, o, 3)], ["MAC: "+str(ifc_data['ph_addr'])] ] ifd_menu = Menu(ifd_menu_contents, i, o, "{} interface data menu".format(ifc_name), entry_height=2) ifd_menu.activate()
def test_fo_graphical_redraw(self): o = get_mock_graphical_output() overlay = FunctionOverlay([lambda: True, lambda: False]) mu = Menu([], get_mock_input(), o, name=ui_name, config={}) Canvas.fonts_dir = fonts_dir overlay.apply_to(mu) # Exiting immediately, but we should get at least one redraw def scenario(): mu.deactivate() # KEY_LEFT assert not mu.in_foreground with patch.object(mu, 'idle_loop', side_effect=scenario) as p: mu.activate() assert o.display_image.called assert o.display_image.call_count == 1 #One in to_foreground
def launch(): try: systemctl.list_units() except OSError as e: if e.errno == 2: Printer(["Do you use", "systemctl?"], i, o, 3, skippable=True) return else: raise e main_menu_contents = [ ["Units (filtered)", filtered_units], ["All units", all_units], ["Change filters", change_filters]] main_menu = Menu(main_menu_contents, i, o, "systemctl main menu") main_menu.activate()
class MainMenu(ZeroApp): menu_name = "Main Menu" def on_start(self): self.m = Menu([], self.i, self.o) self.overlay = SpinnerOverlay() def test_func(x): self.overlay.set_state(self.m, not self.overlay.get_state(self.m)) menu_contents = [[str(i), lambda x=i: test_func(x)] for i in range(16)] self.overlay.apply_to(self.m) self.m.set_contents(menu_contents) self.m.activate()
def test_graphical_redraw_with_eh_2(self): """ Tests for a bug where a menu with one two-elements-high entry would fail to render """ num_elements = 3 o = get_mock_graphical_output() contents = [[["A" + str(i), "B" + str(i)], "a" + str(i)] for i in range(num_elements)] mu = Menu(contents, get_mock_input(), o, name=mu_name, entry_height=2, append_exit=False, config={}) Canvas.fonts_dir = fonts_dir # Exiting immediately, but we should get at least one redraw def scenario(): mu.deactivate() # KEY_LEFT assert not mu.in_foreground with patch.object(mu, 'idle_loop', side_effect=scenario) as p: return_value = mu.activate() assert o.display_image.called assert o.display_image.call_count == 1 #One in to_foreground
def launch(): try: status = tvservice.status() except OSError as e: if e.errno == 2: Printer(["Do you have", "tvservice?"], i, o, 3, skippable=True) return else: raise e else: main_menu_contents = [["Status", show_status], ["Choose HDMI mode", select_hdmi_mode], ["Display on", display_on], ["Display off", display_off]] main_menu = Menu(main_menu_contents, i, o, "tvservice main menu") main_menu.activate()
def shows_data_on_screen_wrapper(self, contents): i = get_mock_input() o = get_mock_output() mu = Menu(contents, i, o, name=mu_name, config={}) def scenario(): mu.deactivate() with patch.object(mu, 'idle_loop', side_effect=scenario) as p: mu.activate() #The scenario should only be called once assert mu.idle_loop.called assert mu.idle_loop.call_count == 1 assert o.display_data.called assert o.display_data.call_count == 1 #One in to_foreground assert o.display_data.call_args[0] == ('A0', 'A1', 'A2', 'Back')
def saved_network_menu(network_info): global saved_networks id = network_info['network id'] bssid = network_info['bssid'] network_status = network_info["flags"] if network_info["flags"] else "[ENABLED]" network_info_contents = [ [network_status], ["Select", lambda x=id: select_network(x)], ["Enable", lambda x=id: enable_network(x)], ["Disable", lambda x=id: disable_network(x)], ["Remove", lambda x=id: remove_network(x)], ["Set password", lambda x=id: set_password(x)], ["BSSID", lambda x=bssid: Printer(x, i, o, 5, skippable=True)]] network_info_menu = Menu(network_info_contents, i, o, "Wireless network info", catch_exit=False) network_info_menu.activate() #After menu exits, we'll request the status again and update the saved_networks = wpa_cli.list_configured_networks()
def saved_network_menu(network_info): global saved_networks id = network_info['network id'] bssid = network_info['bssid'] network_status = network_info["flags"] if network_info["flags"] else "[ENABLED]" network_info_contents = [ [network_status], ["Select", lambda x=id: select_network(x)], ["Enable", lambda x=id: enable_network(x)], ["Disable", lambda x=id: disable_network(x)], ["Remove", lambda x=id: remove_network(x)], ["Set password", lambda x=id: set_password(x)], ["BSSID", lambda x=bssid: Printer(x, i, o, 5, skippable=True)]] network_info_menu = Menu(network_info_contents, i, o, "Wireless network info", catch_exit=False) network_info_menu.activate() #After menu exits, we'll request the status again and update the network list saved_networks = wpa_cli.list_configured_networks()
def init_app(input, output): global if_menu, callback, i, o i = input o = output if_menu = Menu([], i, o, "Interface selection menu") if_menu.activate = activate_wrapper( if_menu.activate ) #Decorating around the menu.activate module so that every time menu is activated interface data is refreshed callback = if_menu.activate
def test_left_key_disabled_when_not_exitable(self): """Tests whether a menu does not exit on KEY_LEFT when exitable is set to False""" num_elements = 3 contents = [["A" + str(i), "a" + str(i)] for i in range(num_elements)] mu = Menu(contents, get_mock_input(), get_mock_output(), name=mu_name, exitable=False, config={}) mu.refresh = lambda *args, **kwargs: None def scenario(): assert "KEY_LEFT" not in mu.keymap # KEY_LEFT mu.deactivate() assert not mu.in_foreground with patch.object(mu, 'idle_loop', side_effect=scenario) as p: mu.activate()
def test_so_spins(self): Canvas.fonts_dir = fonts_dir o = get_mock_graphical_output() overlay = SpinnerOverlay() mu = Menu([], get_mock_input(), o, name=ui_name) mu.idle_loop = lambda *a, **k: True overlay.apply_to(mu) overlay.set_state(mu, False) def activate(): mu.before_activate() mu.to_foreground() mu.idle_loop() img_1 = o.display_image.call_args[0] mu.idle_loop() mu.refresh() img_2 = o.display_image.call_args[0] assert(img_1 == img_2) # enabling the spinner overlay.set_state(mu, True) # first iteration of the spinner mu.idle_loop() img_3 = o.display_image.call_args[0] assert(img_3 != img_1) # second iteration of the spinner mu.idle_loop() img_4 = o.display_image.call_args[0] assert(img_4 != img_1) assert(img_4 != img_3) # disabling the spinner overlay.set_state(mu, False) mu.idle_loop() # now idle_loop shouldn't contain a refresh img_5 = o.display_image.call_args[0] assert(img_5 == img_4) mu.refresh() # now, after an explicit refresh, there should be no spinner left img_6 = o.display_image.call_args[0] assert(img_6 == img_1) assert(img_6 != img_3) assert(img_6 != img_4) mu.deactivate() # KEY_LEFT with patch.object(mu, 'activate', side_effect=activate) as p: mu.activate()
def test_shows_data_on_screen(self): """Tests whether the Menu outputs data on screen when it's ran""" num_elements = 3 contents = [["A" + str(i), "a" + str(i)] for i in range(num_elements)] i = get_mock_input() o = get_mock_output() mu = Menu(contents, i, o, name=mu_name, config={}) def scenario(): mu.deactivate() with patch.object(mu, 'idle_loop', side_effect=scenario) as p: mu.activate() #The scenario should only be called once assert mu.idle_loop.called assert mu.idle_loop.call_count == 1 assert o.display_data.called assert o.display_data.call_count == 1 #One in to_foreground assert o.display_data.call_args[0] == ('A0', 'A1', 'A2', 'Back')
def callback(): if systemctl is None: PrettyPrinter( "python-gi not found! Please install it using 'apt-get install python-gi' ", i, o, 5) return try: systemctl.list_units() except OSError as e: if e.errno == 2: PrettyPrinter("Do you use systemctl?", i, o, 3, skippable=True) return else: raise e main_menu_contents = [["Pinned units", pinned_units], ["Units (filtered)", filtered_units], ["All units", all_units], ["Change filters", change_filters]] main_menu = Menu(main_menu_contents, i, o, "systemctl main menu") main_menu.activate()
def test_contents_hook_2(self): """ Tests whether menu contents hook is executed and whether on_contents_hook_fail works when it is supposed to work. """ self.test_contents_hook_2_counter = 0 contentss = [[["True"]], [["False"]], None] def gen_contents(): if len(contentss) <= self.test_contents_hook_2_counter: raise Exception contents = contentss[self.test_contents_hook_2_counter] self.test_contents_hook_2_counter += 1 return contents ochf = Mock() mu = Menu([], get_mock_input(), get_mock_output(), name=mu_name, contents_hook=gen_contents, on_contents_hook_fail=ochf, config={}) def scenario(): assert mu.contents[0][0] == "True" mu.select_entry() assert mu.contents[0][0] == "False" mu.select_entry() assert ochf.called assert ochf.call_count == 1 # first because contents_hook returned None mu.set_contents([]) mu.before_foreground() assert ochf.call_count == 2 # second because of the exception raised mu.deactivate() assert not mu.in_foreground with patch.object(mu, 'idle_loop', side_effect=scenario) as p: mu.activate()
def graphical_display_redraw_wrapper(self, contents): o = get_mock_graphical_output() mu = Menu(contents, get_mock_input(), o, name=mu_name, config={}) Canvas.fonts_dir = fonts_dir # Exiting immediately, but we should get at least one redraw def scenario(): mu.deactivate() # KEY_LEFT assert not mu.in_foreground with patch.object(mu, 'idle_loop', side_effect=scenario) as p: return_value = mu.activate() assert o.display_image.called assert o.display_image.call_count == 1 #One in to_foreground
def callback(): #Check if we have all the software necessary for the app to work #If not, show error messages and exit if nmap is None: PrettyPrinter("nmap Python module not found!", i, o, 3) return False try: nm = nmap.PortScanner() except nmap.nmap.PortScannerError: PrettyPrinter("nmap not installed!", i, o, 3) return False #Dump function support i.set_maskable_callback("KEY_F6", dump_current_scan_to_file) #Constructing and loading app main menu menu_contents = [["Smart scan", smart_scan], ["Scan a network", scan_network_menu], ["Scan arbitrary IP", scan_arbitrary_ip], ["Scan localhost", scan_localhost]] menu = Menu(menu_contents, i, o) help_text = "Press F6 in the scan results menu to save the scan results into a file" HelpOverlay(help_text).apply_to(menu) menu.activate() #Have to remove the dump function callback because once application exits it isn't removed automatically i.remove_maskable_callback("KEY_F6")
def init_app(input, output): global if_menu, callback, i, o i = input; o = output if_menu = Menu([], i, o, "Interface selection menu") if_menu.activate = activate_wrapper(if_menu.activate) #Decorating around the menu.activate module so that every time menu is activated interface data is refreshed callback = if_menu.activate