#!/bin/sh
-run-standalone.sh python2.5 /opt/wifi-assistant/lib/wifi_assistant/daemon.py
\ No newline at end of file
+run-standalone.sh python2.5 /opt/wifi-assistant/lib/wifi_assistant/daemon/main.py
\ No newline at end of file
#!/bin/sh
-run-standalone.sh python2.5 /opt/wifi-assistant/lib/wifi_assistant/config-gui.py
\ No newline at end of file
+run-standalone.sh python2.5 /opt/wifi-assistant/lib/wifi_assistant/gui/main.py
\ No newline at end of file
+++ /dev/null
-#!/usr/bin/python2.5
-import gtk, hildon
-
-def _(str):
- return str
-
-class ConfigGui():
-
- def __init__(self, launcher, application_settings, network_settings, hildon_program, hildon_window, list_store):
- self._launcher = launcher
- self._application_settings = application_settings
- self._network_settings = network_settings
- self._program = hildon_program
- self._win = hildon_window
- self._model= list_store
-
-
- def main(self):
- self._win.set_title(_("Wifi Jail Breakout Assistant"))
- ssid_list = self._create_ssid_view(self._model)
- pannable_area= hildon.PannableArea()
- pannable_area.add(ssid_list)
- self._win.add(pannable_area)
- self._win.set_app_menu(self._create_menu())
- self._win.connect("destroy", gtk.main_quit, None)
- self._win.show_all()
-
-
- # FIXME: refactor out
- def _launch_browser(self, url):
- self._launcher.openUrl(url)
-
-
- def _show_about(self, x):
- from wifi_assistant.gui.about_dialog import AboutDialog
- AboutDialog(self._launcher, self._win).show()
-
-
- def _show_settings(self, x):
- from wifi_assistant.gui.application_settings_dialog import ApplicationSettingsDialog
- use_popup = self._application_settings.getUsePopup()
- url_to_open = self._network_settings.getDefaultSettings().getBrowserOptions()['url']
- ApplicationSettingsDialog(self._win, self._save_callback).show(use_popup, url_to_open)
-
-
- def _save_callback(self, popup, url):
- self._application_settings.setUsePopup(popup)
- settings = self._network_settings.getDefaultSettings()
- settings.getBrowserOptions()['url'] = url
- self._network_settings.save(settings)
-
-
- def _create_menu(self):
- menu = hildon.AppMenu()
-
- about = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- about.set_label(_("About"))
- about.connect("clicked", self._show_about)
- menu.append(about)
-
- settings = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- settings.set_label(_("Settings"))
- settings.connect("clicked",self._show_settings)
- menu.append(settings)
-
- add = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- add.set_label(_("Add network"))
- add.connect("clicked", self._add_ssid)
- menu.append(add)
-
- delete = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
- delete.set_label(_("Delete networks"))
- delete.connect("clicked", self._delete_ssid)
- menu.append(delete)
-
- menu.show_all()
- return menu
-
-
- def _edit_ssid(self, ssid, model, iter):
- dialog = gtk.Dialog(ssid, self._win)
- dialog.vbox.set_homogeneous(False)
-
- dialog.add_button(_('No'), gtk.RESPONSE_NO)
- dialog.add_button(_('Yes'), gtk.RESPONSE_YES)
-
- label = gtk.Label(_('After being connected to ' + ssid + ' do you wish to launch a browser?')) #FIXME: l10n
- label.set_line_wrap(True)
- label.set_justify(gtk.JUSTIFY_LEFT)
- label.set_alignment(0, 0.5)
- dialog.vbox.add(label)
-
- dialog.show_all()
- result = dialog.run()
- dialog.hide()
-
- launchBrowser = None
- if result == gtk.RESPONSE_YES:
- launchBrowser = True
- elif result == gtk.RESPONSE_NO:
- launchBrowser = False
-
- if launchBrowser is not None:
- self._settings.setLaunchSetting(ssid, launchBrowser)
- model.set(iter, 1, launchBrowser)
-
-
- def _add_ssid(self, x):
- from wifi_assistant.gui.add_network_dialog import AddNetworkDialog
- AddNetworkDialog(self._win, self._add_ssid_callback).show()
-
-
- def _add_ssid_callback(self, ssid, launch_browser):
- settings = self._network_settings.getDefaultSettings()
- settings.setNetworkName(ssid)
- settings.setLaunchingOfBrowserEnabled(launch_browser)
- self._network_settings.save(settings)
- self._model.append([ssid, launchBrowser])
-
-
- def _delete_ssid(self, x):
- window = hildon.StackableWindow()
- window.set_border_width(6)
- toolbar = hildon.EditToolbar(_("Choose network settings to delete"), _("Delete"))
- window.set_edit_toolbar(toolbar)
-
- area = hildon.PannableArea()
- tree_view = self._create_delete_view()
- area.add(tree_view)
- window.add(area)
-
- toolbar.connect("button-clicked", self._delete_button_clicked, tree_view)
- toolbar.connect_object("arrow-clicked", gtk.Window.destroy, window)
-
- window.show_all()
- window.fullscreen()
-
-
- def _delete_button_clicked(self, button, treeview):
- selection = treeview.get_selection()
-
- (model, selected_rows) = selection.get_selected_rows()
-
- # TODO: are you sure?
-
- row_references = []
- for path in selected_rows:
- ref = gtk.TreeRowReference(model, path)
- row_references.append(ref)
-
- for ref in row_references:
- path = ref.get_path()
- iter = model.get_iter(path)
- ssid, x = model.get(iter, 0, 1)
- self._settings.deleteLaunchSetting(ssid)
- model.remove(iter)
-
- # TODO: close delete window?
-
-
- def _create_delete_view(self):
- tv = hildon.GtkTreeView(gtk.HILDON_UI_MODE_EDIT)
- renderer = gtk.CellRendererText()
- col = gtk.TreeViewColumn("Title", renderer, text=0)
-
- tv.append_column(col)
-
- # Set multiple selection mode
- selection = tv.get_selection()
- selection.set_mode(gtk.SELECTION_MULTIPLE)
-
- tv.set_model(self._model)
-
- return tv
-
-
- def _create_ssid_view(self, model):
-# view = hildon.GtkTreeView(gtk.HILDON_UI_MODE_NORMAL, model)
-# view = hildon.GtkTreeView(gtk.HILDON_UI_MODE_NORMAL, model)
-
- if len(model) == 0:
- return gtk.Label(_('There are no launch settings saved for any network'))
-
- view = gtk.TreeView(model)
- view.set_border_width(5)
-
- def boolean_func(column, cell, model, iter):
- if model.get_value(iter, 1):
- stock_id = 'gtk-yes'
- else:
- stock_id = 'gtk-no'
- cell.set_property('stock-id', stock_id)
-
- launch_cell = gtk.CellRendererPixbuf()
- launch_cell.set_fixed_size(100, 50)
- view.insert_column_with_data_func(1, _('Launch'), launch_cell, boolean_func)
-# toggle_cell = gtk.CellRendererToggle()
-# toggle_cell.set_fixed_size(100, 50)
-# view.append_column( gtk.TreeViewColumn( '', toggle_cell, active=1))
-
- tvcolumn = gtk.TreeViewColumn(_('SSID'), gtk.CellRendererText(), text = 0)
- tvcolumn.set_expand(True)
- view.append_column(tvcolumn)
-
- view.connect('row-activated', self._row_activated)
- view.set_search_column(0)
- tvcolumn.set_sort_column_id(0)
-
- return view
-
-
- def _row_activated(self, treeview, path, view_column):
- model = treeview.get_model()
- iter = model.get_iter(path)
- ssid = model.get_value(iter, 0)
- self._edit_ssid(ssid, model, iter)
+++ /dev/null
-#!/usr/bin/python2.5
-import gtk, hildon
-import conic
-import gobject
-
-from launcher import Launcher
-
-def _(str):
- return str
-
-class Daemon():
-
- def __init__(self, launcher, application_settings, network_settings, parent_window):
- self._application_settings = application_settings
- self._network_settings = network_settings
- self._parent = parent_window
- self._launcher = launcher
- self._popup = self._application_settings.getUsePopup()
-
-
- def connectionEstablished(self, ssid):
- settings = self._network_settings.get(ssid)
- if settings is None:
- if self.showDecisionDialog(ssid):
- defaults = self._network_settings.getDefaultSettings()
- self.launchBrowser(defaults)
- return
-
- if settings.getLaunchingOfBrowserEnabled():
- self.launchBrowser(settings)
-
-
- def launchBrowser(self, settings):
- browser_name = settings.getNameOfBrowserToLaunch()
- browser_options = settings.getBrowserOptions()
- if 'url' in browser_options:
- self._launcher.launchBrowser(browser_name, browser_options)
- # the following line is the backwards compatible line
- else:
- settings = self._network_settings.getDefaultSettings()
- self.launchBrowser(settings)
-
- def showDecisionDialog(self, ssid):
- if not self._popup:
- return False
-
- dialog = self._createDialog(ssid)
-
- dialog.show_all()
- result = dialog.run()
- dialog.hide()
-
- launch_browser = (result == gtk.RESPONSE_YES)
- if checkbox.get_active():
- setting = NetworkSetting()
- setting.setNetworkName(ssid)
- setting.setLaunchingOfBrowserEnabled(launch_browser)
- self._network_settings.save(setting)
-
- return launch_browser
-
- def start(self):
- self._connection = conic.Connection()
- self._connection.connect("connection-event", self._connectionEventCallback)
- self._connection.set_property("automatic-connection-events", True)
- self._application_settings.addUsePopupListener(self._usePopupEventCallback)
- gtk.main()
-
-
- def stop(self):
- self._application_settings.removeUsePopupListener(self._usePopupEventCallback)
- self._connection.set_property("automatic-connection-events", False)
-
-
- def _createDialog(self, ssid):
- dialog = gtk.Dialog(ssid, self._parent)
- dialog.vbox.set_homogeneous(False)
-
- dialog.add_button(_('No'), gtk.RESPONSE_NO)
- dialog.add_button(_('Yes'), gtk.RESPONSE_YES)
-
- label = gtk.Label(_('New network connection established - do you wish to launch a browser?'))
- label.set_line_wrap(True)
- #label.set_justify(gtk.JUSTIFY_LEFT)
- #label.set_alignment(0, 0.5)
- dialog.vbox.add(label)
-
- checkbox = hildon.CheckButton(gtk.HILDON_SIZE_FINGER_HEIGHT)
- checkbox.set_label(_('Remember this decision'))
- checkbox.set_active(True)
- dialog.vbox.add(checkbox)
-
- return dialog
-
-
- def _connectionEventCallback(self, connection, event):
- status = event.get_status()
- if status == conic.STATUS_CONNECTED:
- # assemble id > name dict
- iap_id_to_name = {}
- iaps = connection.get_all_iaps()
- for iap in iaps:
- iap_id = iap.get_id()
- iap_name = iap.get_name()
- iap_id_to_name[iap_id] = iap_name
-
- # get name of network
- iap_id = event.get_iap_id()
- iap_name = None
- if (iap_id_to_name.has_key(iap_id)):
- iap_name = iap_id_to_name[iap_id]
- self.connectionEstablished(iap_name)
-
-
- def _usePopupEventCallback(self, gconfClient, id, gconfEntry, x):
- self._popup = gconfEntry.get_value().get_bool()
-
-
-if __name__ == "__main__":
- d = Daemon(Launcher(), ApplicationSettings(), NetworkSettings(), gtk.Window())
-
- d.start()
- d.stop()
--- /dev/null
+#!/usr/bin/python2.5
+import gtk, hildon
+import conic
+import gobject
+
+from launcher import Launcher
+
+def _(str):
+ return str
+
+class Daemon():
+
+ def __init__(self, launcher, application_settings, network_settings, parent_window):
+ self._application_settings = application_settings
+ self._network_settings = network_settings
+ self._parent = parent_window
+ self._launcher = launcher
+ self._popup = self._application_settings.getUsePopup()
+
+
+ def connectionEstablished(self, ssid):
+ settings = self._network_settings.get(ssid)
+ if settings is None:
+ if self.showDecisionDialog(ssid):
+ defaults = self._network_settings.getDefaultSettings()
+ self.launchBrowser(defaults)
+ return
+
+ if settings.getLaunchingOfBrowserEnabled():
+ self.launchBrowser(settings)
+
+
+ def launchBrowser(self, settings):
+ browser_name = settings.getNameOfBrowserToLaunch()
+ browser_options = settings.getBrowserOptions()
+ if 'url' in browser_options:
+ self._launcher.launchBrowser(browser_name, browser_options)
+ # the following line is the backwards compatible line
+ else:
+ settings = self._network_settings.getDefaultSettings()
+ self.launchBrowser(settings)
+
+ def showDecisionDialog(self, ssid):
+ if not self._popup:
+ return False
+
+ dialog = self._createDialog(ssid)
+
+ dialog.show_all()
+ result = dialog.run()
+ dialog.hide()
+
+ launch_browser = (result == gtk.RESPONSE_YES)
+ if checkbox.get_active():
+ setting = NetworkSetting()
+ setting.setNetworkName(ssid)
+ setting.setLaunchingOfBrowserEnabled(launch_browser)
+ self._network_settings.save(setting)
+
+ return launch_browser
+
+
+ def start(self):
+ self._connection = conic.Connection()
+ self._connection.connect("connection-event", self._connectionEventCallback)
+ self._connection.set_property("automatic-connection-events", True)
+ self._application_settings.registerUsePopupListener(self._usePopupEventCallback)
+ self._startLoop()
+
+
+ def stop(self):
+ self._application_settings.unregisterUsePopupListener(self._usePopupEventCallback)
+ self._connection.set_property("automatic-connection-events", False)
+
+
+ def _createDialog(self, ssid):
+ dialog = gtk.Dialog(ssid, self._parent)
+ dialog.vbox.set_homogeneous(False)
+
+ dialog.add_button(_('No'), gtk.RESPONSE_NO)
+ dialog.add_button(_('Yes'), gtk.RESPONSE_YES)
+
+ label = gtk.Label(_('New network connection established - do you wish to launch a browser?'))
+ label.set_line_wrap(True)
+ #label.set_justify(gtk.JUSTIFY_LEFT)
+ #label.set_alignment(0, 0.5)
+ dialog.vbox.add(label)
+
+ checkbox = hildon.CheckButton(gtk.HILDON_SIZE_FINGER_HEIGHT)
+ checkbox.set_label(_('Remember this decision'))
+ checkbox.set_active(True)
+ dialog.vbox.add(checkbox)
+
+ return dialog
+
+
+ def _connectionEventCallback(self, connection, event):
+ status = event.get_status()
+ if status == conic.STATUS_CONNECTED:
+ # assemble id > name dict
+ iap_id_to_name = {}
+ iaps = connection.get_all_iaps()
+ for iap in iaps:
+ iap_id = iap.get_id()
+ iap_name = iap.get_name()
+ iap_id_to_name[iap_id] = iap_name
+
+ # get name of network
+ iap_id = event.get_iap_id()
+ iap_name = None
+ if (iap_id_to_name.has_key(iap_id)):
+ iap_name = iap_id_to_name[iap_id]
+ self.connectionEstablished(iap_name)
+
+
+ def _usePopupEventCallback(self, gconfClient, id, gconfEntry, x):
+ self._popup = gconfEntry.get_value().get_bool()
+
+
+ def _startLoop(self):
+ gtk.main()
--- /dev/null
+#!/usr/bin/python2.5
+from gnome import gconf
+import osso
+
+class Launcher():
+
+ """Opens a URL in a browser."""
+
+ def __init__(self):
+ pass
+
+ # ---- public API __________________________________________________________
+
+ def launchBrowser(self, browser_name, browser_options):
+ """Uses the specified browser and makes the calls specified in the browser_options"""
+ # TODO:
+
+ url = browser_options['url']
+ self.openUrl(url)
+
+
+ def openUrl(self, url):
+ """Uses the default browser to open the specified url."""
+
+ osso_context = osso.Context("org.maemo.touchsearch", "1.1", False)
+ osso_rpc = osso.Rpc(osso_context)
+ osso_rpc.rpc_run_with_defaults("osso_browser", "open_new_window", (url,))
+
\ No newline at end of file
--- /dev/null
+#!/usr/bin/python2.5
+import conic
+import gtk, hildon
+import gobject
+from gnome import gconf
+
+from wifi_assistant.daemon.daemon import Daemon
+from wifi_assistant.daemon.launcher import Launcher
+from wifi_assistant.settings.application_settings import ApplicationSettings
+from wifi_assistant.settings.network_settings import NetworkSettings
+
+if __name__ == "__main__":
+ gconf_client = gconf.client_get_default()
+ gconf_root_dir = '/apps/maemo/wifi_assistant'
+ network_settings = NetworkSettings(gconf_client, gconf_root_dir)
+ application_settings = ApplicationSettings(gconf_client, gconf_root_dir)
+ launcher = Launcher()
+ gtk_window = gtk.Window()
+ d = Daemon(launcher, application_settings, network_settings, gtk_window)
+
+ d.start()
+ d.stop()
--- /dev/null
+#!/usr/bin/python2.5
+import gtk, hildon
+
+def _(str):
+ return str
+
+class ConfigGui():
+
+ def __init__(self, launcher, application_settings, network_settings, hildon_program, hildon_window, list_store):
+ self._launcher = launcher
+ self._application_settings = application_settings
+ self._network_settings = network_settings
+ self._program = hildon_program
+ self._win = hildon_window
+ self._model= list_store
+
+
+ def main(self):
+ self._win.set_title(_("Wifi Assistant"))
+ ssid_list = self._createNetworkSettingsView(self._model)
+ pannable_area= hildon.PannableArea()
+ pannable_area.add(ssid_list)
+ self._win.add(pannable_area)
+ self._win.set_app_menu(self._createMenu())
+ self._win.connect("destroy", gtk.main_quit, None)
+ self._win.show_all()
+
+
+ def _createMenu(self):
+ menu = hildon.AppMenu()
+
+ about = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
+ about.set_label(_("About"))
+ about.connect("clicked", self._showAboutDialog)
+ menu.append(about)
+
+ settings = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
+ settings.set_label(_("Settings"))
+ settings.connect("clicked",self._editApplicationSettings)
+ menu.append(settings)
+
+ add = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
+ add.set_label(_("Add network"))
+ add.connect("clicked", self._addNetworkSetting)
+ menu.append(add)
+
+ delete = hildon.GtkButton(gtk.HILDON_SIZE_AUTO)
+ delete.set_label(_("Delete networks"))
+ delete.connect("clicked", self._deleteNetworkSetting)
+ menu.append(delete)
+
+ menu.show_all()
+ return menu
+
+
+ def _showAboutDialog(self, x):
+ from wifi_assistant.gui.about_dialog import AboutDialog
+ AboutDialog(self._launcher, self._win).show()
+
+
+ def _editApplicationSettings(self, x):
+ from wifi_assistant.gui.application_settings_dialog import ApplicationSettingsDialog
+ use_popup = self._application_settings.getUsePopup()
+ url_to_open = self._network_settings.getDefaultSettings().getBrowserOptions()['url']
+ ApplicationSettingsDialog(self._win, self._editApplicationSettingsCallback).show(use_popup, url_to_open)
+
+ def _editApplicationSettingsCallback(self, popup, url):
+ self._application_settings.setUsePopup(popup)
+ settings = self._network_settings.getDefaultSettings()
+ settings.getBrowserOptions()['url'] = url
+ self._network_settings.save(settings)
+
+
+ def _editNetworkSetting(self, ssid, model, iter):
+ from wifi_assistant.gui.edit_network_dialog import EditNetworkDialog
+ network_name, x = model.get(iter, 0, 1)
+ EditNetworkDialog(self._win, self._editNetworkSettingCallback).show(iter, network_name)
+
+ def _editNetworkSettingCallback(self, iter, ssid, launch_browser):
+ # TODO: REMOVE ssid from arg list, extract like delete networks do?
+ #self._settings.setLaunchSetting(ssid, launch_browser)
+ settings = self._network_settings.get(ssid)
+ settings.setLaunchingOfBrowserEnabled(launch_browser)
+ self._network_settings.save(settings)
+ self._model.set(iter, 1, launch_browser)
+
+
+ def _addNetworkSetting(self, x):
+ from wifi_assistant.gui.add_network_dialog import AddNetworkDialog
+ AddNetworkDialog(self._win, self._addNetworkSettingCallback).show()
+
+ def _addNetworkSettingCallback(self, network_name, launch_browser):
+ settings = self._network_settings.getDefaultSettings()
+ settings.setNetworkName(network_name)
+ settings.setLaunchingOfBrowserEnabled(launch_browser)
+ self._network_settings.save(settings)
+ self._model.append([network_name, launch_browser])
+
+ # FIXME: on append, if len == 1, change main view from label to tree view
+ # but do this with the model
+
+
+ def _deleteNetworkSetting(self, x):
+ from wifi_assistant.gui.delete_networks_dialog import DeleteNetworksDialog
+ DeleteNetworksDialog(self._model, self._deleteNetworkSettingCallback).show()
+
+ def _deleteNetworkSettingCallback(self, model, row_references):
+ for ref in row_references:
+ path = ref.get_path()
+ iter = model.get_iter(path)
+ ssid, x = model.get(iter, 0, 1)
+ settings = self._network_settings.get(ssid)
+ self._network_settings.delete(settings)
+ model.remove(iter)
+
+
+ def _createNetworkSettingsView(self, model):
+# view = hildon.GtkTreeView(gtk.HILDON_UI_MODE_NORMAL, model)
+# view = hildon.GtkTreeView(gtk.HILDON_UI_MODE_NORMAL, model)
+
+ if len(model) == 0:
+ return gtk.Label(_('There are no launch settings saved for any network'))
+
+ view = gtk.TreeView(model)
+ view.set_border_width(5)
+
+ def boolean_func(column, cell, model, iter):
+ if model.get_value(iter, 1):
+ stock_id = 'gtk-yes'
+ else:
+ stock_id = 'gtk-no'
+ cell.set_property('stock-id', stock_id)
+
+ launch_cell = gtk.CellRendererPixbuf()
+ launch_cell.set_fixed_size(100, 50)
+ view.insert_column_with_data_func(1, _('Launch'), launch_cell, boolean_func)
+# toggle_cell = gtk.CellRendererToggle()
+# toggle_cell.set_fixed_size(100, 50)
+# view.append_column( gtk.TreeViewColumn( '', toggle_cell, active=1))
+
+ tvcolumn = gtk.TreeViewColumn(_('SSID'), gtk.CellRendererText(), text = 0)
+ tvcolumn.set_expand(True)
+ view.append_column(tvcolumn)
+
+ view.connect('row-activated', self._rowActivatedCallback)
+ view.set_search_column(0)
+ tvcolumn.set_sort_column_id(0)
+
+ return view
+
+
+ def _rowActivatedCallback(self, treeview, path, view_column):
+ model = treeview.get_model()
+ iter = model.get_iter(path)
+ ssid = model.get_value(iter, 0)
+ self._editNetworkSetting(ssid, model, iter)
--- /dev/null
+#!/usr/bin/python2.5
+import gtk, hildon
+
+def _(str):
+ return str
+
+class DeleteNetworksDialog():
+
+ TOOLBAR_DELETE_BUTTON_EVENT = "button-clicked"
+ TOOLBAR_BACK_BUTTON_EVENT = "arrow-clicked"
+
+ def __init__(self, model, deleteCallback):
+ """deleteCallback(model, [iter_path])"""
+
+ self._model = model
+ self._deleteCallback = deleteCallback
+
+
+ def show(self):
+ # TODO: if model is empty, show banner instead: "Nothing to remove"
+ self._window = hildon.StackableWindow()
+ self._window.set_border_width(6)
+
+ area = hildon.PannableArea()
+ tree_view = self._createDeleteView()
+ area.add(tree_view)
+ self._window.add(area)
+
+ self._toolbar = hildon.EditToolbar(_("Choose network settings to delete"), _("Delete"))
+ self._toolbar.connect(DeleteNetworksDialog.TOOLBAR_DELETE_BUTTON_EVENT, self._deleteButtonClicked, tree_view)
+ self._toolbar.connect(DeleteNetworksDialog.TOOLBAR_BACK_BUTTON_EVENT, self._backButtonClicked)
+ self._window.set_edit_toolbar(self._toolbar)
+
+ self._window.show_all()
+ self._window.fullscreen()
+
+ self._runDialog()
+
+
+ #self._toolbar.connect_object("arrow-clicked", gtk.Window.destroy, self._window)
+ def _backButtonClicked(self, button):
+ self._window.destroy()
+
+
+ def _deleteButtonClicked(self, button, treeview):
+ selection = treeview.get_selection()
+
+ (model, selected_rows) = selection.get_selected_rows()
+
+ # TODO: are you sure?
+
+ row_references = []
+ for path in selected_rows:
+ ref = gtk.TreeRowReference(model, path)
+ row_references.append(ref)
+
+ self._deleteCallback(model, row_references)
+
+ self._window.destroy()
+
+
+ def _createDeleteView(self):
+ tv = hildon.GtkTreeView(gtk.HILDON_UI_MODE_EDIT)
+ renderer = gtk.CellRendererText()
+ col = gtk.TreeViewColumn(_("Networks"), renderer, text=0)
+
+ tv.append_column(col)
+
+ # Set multiple selection mode
+ selection = tv.get_selection()
+ selection.set_mode(gtk.SELECTION_MULTIPLE)
+
+ tv.set_model(self._model)
+
+ return tv
+
+
+ def _runDialog(self):
+ pass
--- /dev/null
+#!/usr/bin/python2.5
+import gtk, hildon
+
+def _(str):
+ return str
+
+class EditNetworkDialog():
+
+ NO_BUTTON = 1
+ YES_BUTTON = 2
+
+ def __init__(self, parent_window, saveCallback):
+ """saveCallback(iter, ssid, launch_browser)"""
+
+ self._parent_window = parent_window
+ self._saveCallback = saveCallback
+
+
+ def show(self, iter, ssid):
+ dialog = gtk.Dialog(ssid, self._parent_window)
+ dialog.vbox.set_homogeneous(False)
+
+ dialog.add_button(_('No'), EditNetworkDialog.NO_BUTTON)
+ dialog.add_button(_('Yes'), EditNetworkDialog.YES_BUTTON)
+
+ label = gtk.Label(_('After being connected to ' + ssid + ' do you wish to launch a browser?')) #FIXME: l10n
+ label.set_line_wrap(True)
+ label.set_justify(gtk.JUSTIFY_LEFT)
+ label.set_alignment(0, 0.5)
+ dialog.vbox.add(label)
+
+ dialog.show_all()
+ result = self._runDialog(dialog)
+ dialog.hide()
+
+ launch_browser = None
+ if result == EditNetworkDialog.YES_BUTTON:
+ launch_browser = True
+ elif result == EditNetworkDialog.NO_BUTTON:
+ launch_browser = False
+
+ if launch_browser is not None:
+ self._saveCallback(iter, ssid, launch_browser)
+
+
+ def _runDialog(self, dialog):
+ result = dialog.run()
+ return result
--- /dev/null
+#!/usr/bin/python2.5
+
+import gtk, gobject
+from gnome import gconf
+import hildon
+
+from wifi_assistant.launcher import Launcher
+from wifi_assistant.settings.application_settings import ApplicationSettings
+from wifi_assistant.settings.network_settings import NetworkSettings
+from wifi_assistant.gui.config_gui import ConfigGui
+
+def _(str):
+ return str
+
+if __name__ == "__main__":
+ gconf_client = gconf.client_get_default()
+ gconf_root_dir = '/apps/maemo/wifi_assistant'
+ network_settings = NetworkSettings(gconf_client, gconf_root_dir)
+ application_settings = ApplicationSettings(gconf_client, gconf_root_dir)
+ launcher = Launcher()
+ list_store = network_settings.getListStore()
+ hildon_program = hildon.Program.get_instance()
+ hildon_window = hildon.StackableWindow()
+
+ # put it all together
+ gui = ConfigGui(launcher, application_settings, network_settings, hildon_program, hildon_window, list_store)
+ gui.main()
+ gtk.main()
+++ /dev/null
-#!/usr/bin/python2.5
-from gnome import gconf
-import osso
-
-class Launcher():
-
- """Opens a URL in a browser."""
-
- def __init__(self):
- pass
-
- # ---- public API __________________________________________________________
-
- def launchBrowser(self, browser_name, browser_options):
- """Uses the specified browser and makes the calls specified in the browser_options"""
- # TODO:
-
- url = browser_options['url']
- self.openUrl(url)
-
-
- def openUrl(self, url):
- """Uses the default browser to open the specified url."""
-
- osso_context = osso.Context("org.maemo.touchsearch", "1.1", False)
- osso_rpc = osso.Rpc(osso_context)
- osso_rpc.rpc_run_with_defaults("osso_browser", "open_new_window", (url,))
-
\ No newline at end of file
+++ /dev/null
-#!/usr/bin/python2.5
-
-import gtk, gobject
-from gnome import gconf
-import hildon
-
-from wifi_assistant.launcher import Launcher
-from wifi_assistant.settings.ApplicationSettings import ApplicationSettings
-from wifi_assistant.settings.NetworkSettings import NetworkSettings
-from wifi_assistant.config_gui import ConfigGui
-
-def _(str):
- return str
-
-if __name__ == "__main__":
- gconf_client = gconf.client_get_default()
- gconf_root_dir = '/apps/maemo/wifi_assistant'
- network_settings = NetworkSettings(gconf_client, gconf_root_dir)
- application_settings = ApplicationSettings(gconf_client, gconf_root_dir)
- launcher = Launcher()
- list_store = network_settings.getListStore()
- hildon_program = hildon.Program.get_instance()
- hildon_window = hildon.StackableWindow()
-
- # put it all together
- gui = ConfigGui(launcher, application_settings, network_settings, hildon_program, hildon_window, list_store)
- gui.main()
- gtk.main()
+++ /dev/null
-#!/usr/bin/python2.5
-from gnome import gconf
-import gtk, gobject
-
-class Settings():
-
- def __init__(self, gconf_root_dir='/apps/maemo/wifi-assistant'):
- self._gc = gconf.client_get_default()
- self._gconfRootDir = gconf_root_dir
- self._gconfLaunchDirectory = gconf_root_dir + '/launch'
- self._gconfPopupKey = gconf_root_dir + '/daemon'
- self._gconfUrlToOpen = gconf_root_dir + '/url-to-open'
- self._listeners = {}
-
- # ---- public API __________________________________________________________
-
- def getLaunchSetting(self, ssid):
- """Returns True or False to indicate that the user wants a browser
- launched or not, otherwise None (the ssid is not recognized)"""
-
- value = self._gc.get_without_default(self._get_launch_key(ssid))
- if value is None:
- return None
- return value.get_bool()
-
-
- def getLaunchSettings(self):
- """Returns a ListStore with one Row per SSID"""
-
- store = gtk.ListStore(str, gobject.TYPE_BOOLEAN)
- entries = self._gc.all_entries(self._gconfLaunchDirectory)
- directoryPathLength = len(self._gconfLaunchDirectory) + 1
- for entry in entries:
- ssidName = entry.get_key()[directoryPathLength:]
- launchBrowser = entry.get_value().get_bool()
- store.append([ssidName, launchBrowser])
-
- return store
-
-
- def setLaunchSetting(self, ssid, mode):
- """Saves the setting for the specified ssid. mode is True or False"""
-
- self._gc.set_bool(self._get_launch_key(ssid), mode)
-
-
- def deleteLaunchSetting(self, ssid):
- """Removes a setting for the specified ssid."""
-
- self._gc.unset(self._get_launch_key(ssid))
-
-
- def addUsePopupListener(self, callback):
- """Registers a listener/callback to changes on Use Daemon setting"""
-
- if len(self._listeners) == 0:
- self._gc.add_dir(self._gconfRootDir, gconf.CLIENT_PRELOAD_NONE)
- ref_id = self._gc.notify_add(self._gconfPopupKey, callback)
- self._listeners[callback] = ref_id
-
-
- def removeUsePopupListener(self, callback):
- """Unregisters the listener/callback"""
-
- if (self._listeners.has_key(callback)):
- ref_id = self._listeners.pop(callback)
- self._gc.notify_remove(ref_id)
-
- if len(self._listeners) == 0:
- self._gc.remove_dir(self._gconfRootDir)
-
-
- def getUsePopup(self):
- """Tells whether to use the daemon or not."""
-
- return self._gc.get_bool(self._gconfPopupKey) is True
-
-
- def setUsePopup(self, mode):
- """mode is either True or False."""
-
- self._gc.set_bool(self._gconfPopupKey, mode)
-
-
- def getUrlToOpen(self):
- """Returns the URL to open when launching a browser"""
-
- return self._gc.get_string(self._gconfUrlToOpen) or 'http://wifi-assistant.garage.maemo.org/ping/'
-
-
- def setUrlToOpen(self, url):
- """Sets the URL to open when launching a browser"""
-
- self._gc.set_string(self._gconfUrlToOpen, url)
-
-
- # ---- private _____________________________________________________________
-
- def _get_launch_key(self, ssid):
- return self._gconfLaunchDirectory + '/' + ssid
-
-
-if __name__ == "__main__":
- print Settings().getLaunchSetting('limbergwendt2')
+++ /dev/null
-#!/usr/bin/python2.5
-from gnome import gconf
-
-class ApplicationSettings():
-
- def __init__(self, gconf_client, gconf_root_dir='/apps/maemo/wifi-assistant'):
- self._gc = gconf_client
- self._gconfRootDir = gconf_root_dir
- self._gconfPopupKey = gconf_root_dir + '/daemon'
- self._listeners = {}
-
- # ---- public API __________________________________________________________
-
- def registerUsePopupListener(self, callback):
- """Registers a listener/callback to changes on Use Daemon setting"""
-
- if len(self._listeners) == 0:
- self._gc.add_dir(self._gconfRootDir, gconf.CLIENT_PRELOAD_NONE)
- ref_id = self._gc.notify_add(self._gconfPopupKey, callback)
- self._listeners[callback] = ref_id
-
-
- def unregisterUsePopupListener(self, callback):
- """Unregisters the listener/callback"""
-
- if (self._listeners.has_key(callback)):
- ref_id = self._listeners.pop(callback)
- self._gc.notify_remove(ref_id)
-
- if len(self._listeners) == 0:
- self._gc.remove_dir(self._gconfRootDir)
-
-
- def getUsePopup(self):
- """Tells whether to use the daemon or not."""
-
- return self._gc.get_bool(self._gconfPopupKey) is True
-
-
- def setUsePopup(self, mode):
- """mode is either True or False."""
-
- self._gc.set_bool(self._gconfPopupKey, mode)
+++ /dev/null
-
-class NetworkSetting(object):
- '''
- The settings specified for a network
- '''
-
- def __init__(self, settings=None):
- self._attributes = {}
- if (settings):
- for key in settings:
- self._attributes[key] = settings[key]
- if not self._attributes.has_key('launch'):
- self.setLaunchingOfBrowserEnabled(False)
-
- def getNetworkName(self):
- return self._attributes['name']
-
-
- def setNetworkName(self, name):
- self._attributes['name'] = name
-
-
- def getLaunchingOfBrowserEnabled(self):
- return self._attributes['launch'] is True
-
-
- def setLaunchingOfBrowserEnabled(self, value):
- self._attributes['launch'] = value
-
-
- def getNameOfBrowserToLaunch(self):
- if self._attributes.has_key('browser'):
- return self._attributes['browser']
- return "default"
-
-
- def setNameOfBrowserToLaunch(self, browser):
- self._attributes['browser'] = browser
-
-
- def getBrowserOptions(self):
- if self._attributes.has_key('options'):
- return self._attributes['options']
- return {}
-
-
- def setBrowserOptions(self, options):
- self._attributes['options'] = options
-
\ No newline at end of file
+++ /dev/null
-import gnome.gconf as gconf
-from NetworkSetting import NetworkSetting
-import gtk, gobject
-
-
-class NetworkSettings(object):
- '''
- Reads and Writes NetworkSettings from/to GConf.
- '''
-
- __DEFAULT_SETTINGS = 'default_settings'
-
- def __init__(self, gconf_client, root_path):
- self._gc = gconf_client
- self._root_path = root_path
-
-
- def delete(self, launch_setting):
- key = self._assembleRootKeyForSsid(launch_setting.getNetworkName())
- self._recursive_unset(key)
-
-
- def getDefaultSettings(self):
- settings = self.get(self.__DEFAULT_SETTINGS)
- if settings is None:
- settings = NetworkSetting()
- settings.setNetworkName(self.__DEFAULT_SETTINGS)
- settings.setLaunchingOfBrowserEnabled(True)
- settings.setBrowserOptions({'url':'http://wifi-assistant.garage.maemo.org/'})
- self.save(settings)
- return settings
-
-
- def getListStore(self):
- """Returns a ListStore with one Row per Network Setting"""
-
- store = gtk.ListStore(str, gobject.TYPE_BOOLEAN)
- settings = self._getAllNetworkSettings()
- for setting in settings:
- store.append([setting.getNetworkName(), setting.getLaunchingOfBrowserEnabled()])
- return store
-
-
- def get(self, ssid):
- key = self._assembleRootKeyForSsid(ssid)
- if self._gc.dir_exists(key):
- return NetworkSetting(self._loadValuesFromGConf(key))
- print "WARNING: No settings to return for network name", ssid
- return None
-
-
- def save(self, launch_setting):
- self._saveValuesToGConf(launch_setting)
-
-
- def _assembleRootKeyForSsid(self, ssid):
- safe = self._replaceForbiddenCharacters(ssid)
- return self._root_path + '/' + safe
-
-
- def _getAllNetworkSettings(self):
- dirs = self._gc.all_dirs(self._root_path)
- settings = []
- key_offset = len(self._root_path) + 1
- for dir in dirs:
- key = dir[key_offset:]
- if self.__DEFAULT_SETTINGS != key:
- settings.append(self.get(key))
- return settings
-
-
- def _loadValuesFromGConf(self, path):
- """Loads all values under a given path in gconf recursively into a dict"""
-
- values = {}
- path_length = len(path) + 1 # remove trailing / too
-
- dirs = self._gc.all_dirs(path)
- for sub_dir_path in dirs:
- key = sub_dir_path[path_length:]
- values[key] = self._loadValuesFromGConf(sub_dir_path)
-
- entries = self._gc.all_entries(path)
- for entry in entries:
- full_key = entry.get_key()
- key = full_key[path_length:]
- gvalue = entry.get_value()
- if gvalue.type == gconf.VALUE_BOOL:
- values[key] = gvalue.get_bool()
- elif gvalue.type == gconf.VALUE_STRING:
- values[key] = gvalue.get_string()
- else:
- print 'ga'
-
- return values
-
-
- def _recursive_unset(self, dir):
- # there's no recursive_unset available in gconf so we'll have to do it ourselves
- all_entries = self._gc.all_entries(dir)
- for entry in all_entries:
- self._gc.unset(entry.get_key())
- for sub_dir in self._gc.all_dirs(dir):
- self._recursive_unset(sub_dir)
- self._gc.suggest_sync()
-
-
- def _replaceForbiddenCharacters(self, str):
- allowed = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
- result = ''
- for c in str:
- if c in allowed:
- result = result + c
- else:
- result = result + '__'
- return result
-
-
- def _saveValuesToGConf(self, launch_setting):
- """Saves all values "recursively" from NetworkSetting"""
-
- network_name = launch_setting.getNetworkName()
- key = self._assembleRootKeyForSsid(network_name)
- browser = launch_setting.getNameOfBrowserToLaunch()
- launch = launch_setting.getLaunchingOfBrowserEnabled()
- options = launch_setting.getBrowserOptions()
-
- self._gc.set_string(key + "/name", network_name)
- self._gc.set_string(key + '/browser', browser)
- self._gc.set_bool(key + '/launch', launch)
- for option_key in options:
- self._gc.set_string(key + "/options/" + option_key, options[option_key])
-
\ No newline at end of file
--- /dev/null
+#!/usr/bin/python2.5
+from gnome import gconf
+
+class ApplicationSettings():
+
+ def __init__(self, gconf_client, gconf_root_dir='/apps/maemo/wifi-assistant'):
+ self._gc = gconf_client
+ self._gconfRootDir = gconf_root_dir
+ self._gconfPopupKey = gconf_root_dir + '/daemon'
+ self._listeners = {}
+
+ # ---- public API __________________________________________________________
+
+ def registerUsePopupListener(self, callback):
+ """Registers a listener/callback to changes on Use Daemon setting"""
+
+ if len(self._listeners) == 0:
+ self._gc.add_dir(self._gconfRootDir, gconf.CLIENT_PRELOAD_NONE)
+ ref_id = self._gc.notify_add(self._gconfPopupKey, callback)
+ self._listeners[callback] = ref_id
+
+
+ def unregisterUsePopupListener(self, callback):
+ """Unregisters the listener/callback"""
+
+ if (self._listeners.has_key(callback)):
+ ref_id = self._listeners.pop(callback)
+ self._gc.notify_remove(ref_id)
+
+ if len(self._listeners) == 0:
+ self._gc.remove_dir(self._gconfRootDir)
+
+
+ def getUsePopup(self):
+ """Tells whether to use the daemon or not."""
+
+ return self._gc.get_bool(self._gconfPopupKey) is True
+
+
+ def setUsePopup(self, mode):
+ """mode is either True or False."""
+
+ self._gc.set_bool(self._gconfPopupKey, mode)
--- /dev/null
+
+class NetworkSetting(object):
+ '''
+ The settings specified for a network
+ '''
+
+ def __init__(self, settings=None):
+ self._attributes = {}
+ if (settings):
+ for key in settings:
+ self._attributes[key] = settings[key]
+ if not self._attributes.has_key('launch'):
+ self.setLaunchingOfBrowserEnabled(False)
+
+ def getNetworkName(self):
+ return self._attributes['name']
+
+
+ def setNetworkName(self, name):
+ self._attributes['name'] = name
+
+
+ def getLaunchingOfBrowserEnabled(self):
+ return self._attributes['launch'] is True
+
+
+ def setLaunchingOfBrowserEnabled(self, value):
+ self._attributes['launch'] = value
+
+
+ def getNameOfBrowserToLaunch(self):
+ if self._attributes.has_key('browser'):
+ return self._attributes['browser']
+ return "default"
+
+
+ def setNameOfBrowserToLaunch(self, browser):
+ self._attributes['browser'] = browser
+
+
+ def getBrowserOptions(self):
+ if self._attributes.has_key('options'):
+ return self._attributes['options']
+ return {}
+
+
+ def setBrowserOptions(self, options):
+ self._attributes['options'] = options
+
\ No newline at end of file
--- /dev/null
+import gnome.gconf as gconf
+from NetworkSetting import NetworkSetting
+import gtk, gobject
+
+
+class NetworkSettings(object):
+ '''
+ Reads and Writes NetworkSettings from/to GConf.
+ '''
+
+ __DEFAULT_SETTINGS = 'default_settings'
+
+ def __init__(self, gconf_client, root_path):
+ self._gc = gconf_client
+ self._root_path = root_path
+
+
+ def delete(self, network_setting):
+ key = self._assembleRootKeyForSsid(network_setting.getNetworkName())
+ self._recursive_unset(key)
+
+
+ def getDefaultSettings(self):
+ settings = self.get(self.__DEFAULT_SETTINGS)
+ if settings is None:
+ settings = NetworkSetting()
+ settings.setNetworkName(self.__DEFAULT_SETTINGS)
+ settings.setLaunchingOfBrowserEnabled(True)
+ settings.setBrowserOptions({'url':'http://wifi-assistant.garage.maemo.org/'})
+ self.save(settings)
+ return settings
+
+
+ def getListStore(self):
+ """Returns a ListStore with one Row per Network Setting"""
+
+ store = gtk.ListStore(str, gobject.TYPE_BOOLEAN)
+ settings = self._getAllNetworkSettings()
+ for setting in settings:
+ store.append([setting.getNetworkName(), setting.getLaunchingOfBrowserEnabled()])
+ return store
+
+
+ def get(self, ssid):
+ key = self._assembleRootKeyForSsid(ssid)
+ if self._gc.dir_exists(key):
+ return NetworkSetting(self._loadValuesFromGConf(key))
+ print "WARNING: No settings to return for network name", ssid
+ return None
+
+
+ def save(self, network_setting):
+ self._saveValuesToGConf(network_setting)
+
+
+ def _assembleRootKeyForSsid(self, ssid):
+ safe = self._replaceForbiddenCharacters(ssid)
+ return self._root_path + '/' + safe
+
+
+ def _getAllNetworkSettings(self):
+ dirs = self._gc.all_dirs(self._root_path)
+ settings = []
+ key_offset = len(self._root_path) + 1
+ for dir in dirs:
+ key = dir[key_offset:]
+ if self.__DEFAULT_SETTINGS != key:
+ settings.append(self.get(key))
+ return settings
+
+
+ def _loadValuesFromGConf(self, path):
+ """Loads all values under a given path in gconf recursively into a dict"""
+
+ values = {}
+ path_length = len(path) + 1 # remove trailing / too
+
+ dirs = self._gc.all_dirs(path)
+ for sub_dir_path in dirs:
+ key = sub_dir_path[path_length:]
+ values[key] = self._loadValuesFromGConf(sub_dir_path)
+
+ entries = self._gc.all_entries(path)
+ for entry in entries:
+ full_key = entry.get_key()
+ key = full_key[path_length:]
+ gvalue = entry.get_value()
+ if gvalue.type == gconf.VALUE_BOOL:
+ values[key] = gvalue.get_bool()
+ elif gvalue.type == gconf.VALUE_STRING:
+ values[key] = gvalue.get_string()
+ else:
+ print 'ga'
+
+ return values
+
+
+ def _recursive_unset(self, dir):
+ # there's no recursive_unset available in gconf so we'll have to do it ourselves
+ all_entries = self._gc.all_entries(dir)
+ for entry in all_entries:
+ self._gc.unset(entry.get_key())
+ for sub_dir in self._gc.all_dirs(dir):
+ self._recursive_unset(sub_dir)
+ self._gc.suggest_sync()
+
+
+ def _replaceForbiddenCharacters(self, str):
+ allowed = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_'
+ result = ''
+ for c in str:
+ if c in allowed:
+ result = result + c
+ else:
+ result = result + '__'
+ return result
+
+
+ def _saveValuesToGConf(self, network_setting):
+ """Saves all values "recursively" from NetworkSetting"""
+
+ network_name = network_setting.getNetworkName()
+ key = self._assembleRootKeyForSsid(network_name)
+ browser = network_setting.getNameOfBrowserToLaunch()
+ launch = network_setting.getLaunchingOfBrowserEnabled()
+ options = network_setting.getBrowserOptions()
+
+ self._gc.set_string(key + "/name", network_name)
+ self._gc.set_string(key + '/browser', browser)
+ self._gc.set_bool(key + '/launch', launch)
+ for option_key in options:
+ self._gc.set_string(key + "/options/" + option_key, options[option_key])
+
\ No newline at end of file
--- /dev/null
+#!/usr/bin/python2.5
+
+import unittest
+import logging
+import sys
+
+logging.basicConfig(level=logging.DEBUG, stream=sys.__stdout__)
+
+from unit.pie_test import PieTest
+
+from unit.daemon.daemon_test import DaemonTest
+
+from unit.gui.about_dialog_test import AboutDialogTest
+from unit.gui.add_network_dialog_test import AddNetworkDialogTest
+from unit.gui.application_settings_dialog_test import ApplicationSettingsDialogTest
+from unit.gui.edit_network_dialog_test import EditNetworkDialogTest
+
+from unit.settings.application_settings_test import ApplicationSettingsTest
+from unit.settings.network_settings_test import NetworkSettingsTest
+
+
+if __name__ == '__main__':
+ unittest.main()
--- /dev/null
+from gnome import gconf
+from wifi_assistant.daemon.daemon import Daemon
+from wifi_assistant.settings.network_setting import NetworkSetting
+
+import unittest
+from unit.pie import *
+
+url_to_open = 'http://wifi-assistant.garage.maemo.org'
+default_browser_name = "default"
+default_browser_options = {'url':url_to_open}
+default_settings = NetworkSetting()
+default_settings.setNameOfBrowserToLaunch(default_browser_name)
+default_settings.setBrowserOptions(default_browser_options)
+ssid = 'A Network Name'
+settings_without_options = NetworkSetting()
+settings_without_options.setNetworkName(ssid)
+settings_without_options.setLaunchingOfBrowserEnabled(True)
+
+class DaemonTest(unittest.TestCase):
+
+ def setUp(self):
+ self.launcher = Mock()
+ self.application_settings = Mock()
+ self.network_settings = Mock()
+ self.parent_window = None
+
+
+ def test_withANewNetwork_whenUserClicksYes_browserIsLaunched(self):
+ # GIVEN
+ self._createTesteeWithPopupClickingYes()
+ given(self.network_settings).get(ssid).willReturn(None)
+ given(self.network_settings).getDefaultSettings().willReturn(default_settings)
+
+ # WHEN
+ self._replayMocks()
+ self.testee.connectionEstablished(ssid)
+
+ # THEN
+ verify(self.network_settings).getDefaultSettings()
+ verify(self.launcher).launchBrowser(default_browser_name, default_browser_options)
+
+
+ def test_withANewNetwork_whenUserClicksNo_browserIsNotLaunched(self):
+ self._createTesteeWithPopupClickingNo()
+ given(self.network_settings).get(ssid).willReturn(None)
+
+ # WHEN
+ self._replayMocks()
+ self.testee.connectionEstablished(ssid)
+
+ # THEN
+ verify(self.launcher, never()).launchBrowser(default_browser_name, default_browser_options)
+
+
+ def test_popupIsNotOpenedIfPopupIsDisabledInApplicationSettings(self):
+ given(self.application_settings).getUsePopup().willReturn(False)
+ self.testee = Daemon(self.launcher, self.application_settings, self.network_settings, self.parent_window)
+
+ self._replayMocks()
+ self.testee.connectionEstablished(ssid)
+
+ verify(self.launcher, never()).launchBrowser()
+ # TODO: refactor out gui part (popup) and test/mock that
+
+
+ def test_knownSsidWithLaunchSetToTrueUsesDefaultBrowserAndUrl(self):
+ given(self.network_settings).get(ssid).willReturn(settings_without_options)
+ given(self.network_settings).getDefaultSettings().willReturn(default_settings)
+ given(self.application_settings).getUsePopup().willReturn(True)
+ #self.testee = Daemon(self.launcher, self.application_settings, self.network_settings, self.parent_window)
+ self.testee = self._createTestee()
+
+ self._replayMocks()
+ self.testee.connectionEstablished(ssid)
+
+ verify(self.launcher, once()).launchBrowser(default_browser_name, default_browser_options)
+
+
+ def test_daemon_start_registersListenerWithApplicationSettings(self):
+ given(self.application_settings).getUsePopup().willReturn(True)
+ self.testee = self._createTestee()
+ given(self.application_settings).registerUsePopupListener(self.testee._usePopupEventCallback).willReturn(1234)
+
+ self._replayMocks()
+
+ verify(self.application_settings, never()).registerUsePopupListener()
+ self.testee.start()
+ verify(self.application_settings, once()).registerUsePopupListener(self.testee._usePopupEventCallback)
+
+ verify(self.application_settings, never()).unregisterUsePopupListener()
+ self.testee.stop()
+ verify(self.application_settings, once()).unregisterUsePopupListener(self.testee._usePopupEventCallback)
+
+
+ def _createTestee(self):
+ def _empty(*args, **kwargs):
+ pass
+ daemon = Daemon(self.launcher, self.application_settings, self.network_settings, self.parent_window)
+ daemon._startLoop = _empty
+ return daemon
+
+
+ def _createTesteeWithPopupClickingYes(self):
+ given(self.application_settings).getUsePopup().willReturn(True)
+ self.testee = self._createTestee()
+
+ def yes(*args, **kwargs):
+ return True
+ self.testee.showDecisionDialog = yes
+
+
+ def _createTesteeWithPopupClickingNo(self):
+ given(self.application_settings).getUsePopup().willReturn(True)
+ self.testee = self._createTestee()
+
+ def no(*args, **kwargs):
+ return False
+ self.testee.showDecisionDialog = no
+
+
+ def _replayMocks(self):
+ self.application_settings.replay()
+ self.launcher.replay()
+ self.network_settings.replay()
+
+
+if __name__ == '__main__':
+ unittest.main()
--- /dev/null
+from gnome import gconf
+from wifi_assistant.gui.about_dialog import AboutDialog
+
+import unittest
+from unit.pie import *
+
+class AboutDialogTest(unittest.TestCase):
+
+ def setUp(self):
+ self.launcher = Mock()
+ self.launcher.replay()
+ self.testee = AboutDialog(self.launcher, None)
+
+
+ def test_bugButtonCallsLauncher(self):
+ self._makeRunDialogReturn(AboutDialog.BUG_BUTTON)
+ self.testee.show()
+ verify(self.launcher).openUrl(AboutDialog.BUG_URL)
+
+
+ def test_closeButtonDoesntCallLauncher(self):
+ self._makeRunDialogReturn(AboutDialog.CLOSE_BUTTON)
+ self.testee.show()
+ verify(self.launcher, never()).openUrl()
+
+
+ def test_donateButtonCallsLauncher(self):
+ self._makeRunDialogReturn(AboutDialog.DONATE_BUTTON)
+ self.testee.show()
+ verify(self.launcher).openUrl(AboutDialog.DONATE_URL)
+
+
+ def _makeRunDialogReturn(self, value):
+ class method():
+ def __init__(self, value_to_return):
+ self._value_to_return = value_to_return
+ def __call__(self, x):
+ return self._value_to_return
+ self.testee._runDialog = method(value)
+
+
+if __name__ == '__main__':
+ unittest.main()
--- /dev/null
+import unittest
+from unit.pie import *
+
+from wifi_assistant.gui.add_network_dialog import AddNetworkDialog
+
+class AddNetworkDialogTest(unittest.TestCase):
+
+ def setUp(self):
+ self.parent_window = None
+ self.save_callback = Mock()
+
+ #given(self.save_callback).save().willReturn(None)
+ self.save_callback.replay()
+
+ self.testee = AddNetworkDialog(self.parent_window, self.save_callback.save)
+
+
+ def test_cancelButtonDoesntCallSaveCallback(self):
+ self._makeRunDialogReturn(AddNetworkDialog.CANCEL_BUTTON)
+ self.testee.show()
+ verify(self.save_callback, never()).save()
+
+
+ def test_saveButtonCallsSaveCallback(self):
+ self._makeRunDialogReturn(AddNetworkDialog.SAVE_BUTTON)
+ self.testee.show('A Network Name', True)
+ verify(self.save_callback).save('A Network Name', True)
+
+
+ def _makeRunDialogReturn(self, value):
+ class method():
+ def __init__(self, value_to_return):
+ self._value_to_return = value_to_return
+ def __call__(self, x):
+ return self._value_to_return
+ self.testee._runDialog = method(value)
+
+if __name__ == '__main__':
+ unittest.main()
+
--- /dev/null
+import unittest
+from unit.pie import *
+
+from wifi_assistant.gui.application_settings_dialog import ApplicationSettingsDialog
+
+class ApplicationSettingsDialogTest(unittest.TestCase):
+
+ def setUp(self):
+ self.parent_window = None
+ self.save_callback = Mock()
+
+ #given(self.save_callback).save().willReturn(None)
+ self.save_callback.replay()
+
+ self.testee = ApplicationSettingsDialog(self.parent_window, self.save_callback.save)
+
+
+ def test_cancelButtonDoesntCallSaveCallback(self):
+ self._makeRunDialogReturn(ApplicationSettingsDialog.CANCEL_BUTTON)
+ self.testee.show(False, '')
+ verify(self.save_callback, never()).save()
+
+
+ def test_saveButtonCallsSaveCallback(self):
+ self._makeRunDialogReturn(ApplicationSettingsDialog.SAVE_BUTTON)
+ self.testee.show(True, 'http://url')
+ verify(self.save_callback).save(True, 'http://url')
+
+
+ def _makeRunDialogReturn(self, value):
+ class method():
+ def __init__(self, value_to_return):
+ self._value_to_return = value_to_return
+ def __call__(self, x):
+ return self._value_to_return
+ self.testee._runDialog = method(value)
+
+if __name__ == '__main__':
+ unittest.main()
+
--- /dev/null
+from gnome import gconf
+from wifi_assistant.gui.edit_network_dialog import EditNetworkDialog
+
+import unittest
+from unit.pie import *
+
+ssid = 'Network Name'
+iter = 'Really a GTK TreeView iter'
+
+class EditNetworkDialogTest(unittest.TestCase):
+
+ def setUp(self):
+ self.parent_window = None
+ self.save_callback = Mock()
+
+ #given(self.save_callback).save().willReturn(None)
+ self.save_callback.replay()
+
+ self.testee = EditNetworkDialog(self.parent_window, self.save_callback.save)
+
+
+ def test_clickingYesButtonCallsCallback(self):
+ self._makeRunDialogReturn(EditNetworkDialog.YES_BUTTON)
+ self.testee.show(iter, ssid)
+ verify(self.save_callback).save(iter, ssid, True)
+
+
+ def test_clickingNoButtonCallsCallback(self):
+ self._makeRunDialogReturn(EditNetworkDialog.NO_BUTTON)
+ self.testee.show(iter, ssid)
+ verify(self.save_callback).save(iter, ssid, False)
+
+
+ def test_cancellingDialogDoesntCallCallback(self):
+ self._makeRunDialogReturn(-1)
+ self.testee.show(iter, ssid)
+ verify(self.save_callback, never()).save()
+
+
+ def _makeRunDialogReturn(self, value):
+ class method():
+ def __init__(self, value_to_return):
+ self._value_to_return = value_to_return
+ def __call__(self, x):
+ return self._value_to_return
+ self.testee._runDialog = method(value)
+
+
+if __name__ == '__main__':
+ unittest.main()
+++ /dev/null
-from gnome import gconf
-from wifi_assistant.daemon import Daemon
-from wifi_assistant.gui.about_dialog import AboutDialog
-
-import unittest
-from unit.pie import *
-
-
-
-class AboutDialogTest(unittest.TestCase):
-
- def setUp(self):
- self.launcher = Mock()
- self.launcher.replay()
- self.testee = AboutDialog(self.launcher, None)
-
-
- def test_bugButtonCallsLauncher(self):
- self._makeRunDialogReturn(AboutDialog.BUG_BUTTON)
- self.testee.show()
- verify(self.launcher).openUrl(AboutDialog.BUG_URL)
-
-
- def test_closeButtonDoesntCallLauncher(self):
- self._makeRunDialogReturn(AboutDialog.CLOSE_BUTTON)
- self.testee.show()
- verify(self.launcher, never()).openUrl()
-
-
- def test_donateButtonCallsLauncher(self):
- self._makeRunDialogReturn(AboutDialog.DONATE_BUTTON)
- self.testee.show()
- verify(self.launcher).openUrl(AboutDialog.DONATE_URL)
-
-
- def _makeRunDialogReturn(self, value):
- class method():
- def __init__(self, value_to_return):
- self._value_to_return = value_to_return
- def __call__(self, x):
- return self._value_to_return
- self.testee._runDialog = method(value)
-
-if __name__ == '__main__':
- unittest.main()
-
+++ /dev/null
-import unittest
-from unit.pie import *
-
-from wifi_assistant.gui.application_settings_dialog import ApplicationSettingsDialog
-
-class ApplicationSettingsDialogTest(unittest.TestCase):
-
- def setUp(self):
- self.parent_window = None
- self.save_callback = Mock()
-
- #given(self.save_callback).save().willReturn(None)
- self.save_callback.replay()
-
- self.testee = ApplicationSettingsDialog(self.parent_window, self.save_callback.save)
-
-
- def test_cancelButtonDoesntCallSaveCallback(self):
- self._makeRunDialogReturn(ApplicationSettingsDialog.CANCEL_BUTTON)
- self.testee.show(False, '')
- verify(self.save_callback, never()).save()
-
-
- def test_saveButtonCallsSaveCallback(self):
- self._makeRunDialogReturn(ApplicationSettingsDialog.SAVE_BUTTON)
- self.testee.show(True, 'http://url')
- verify(self.save_callback).save(True, 'http://url')
-
-
- def _makeRunDialogReturn(self, value):
- class method():
- def __init__(self, value_to_return):
- self._value_to_return = value_to_return
- def __call__(self, x):
- return self._value_to_return
- self.testee._runDialog = method(value)
-
-if __name__ == '__main__':
- unittest.main()
-
+++ /dev/null
-import unittest
-from unit.pie import *
-
-from wifi_assistant.gui.add_network_dialog import AddNetworkDialog
-
-class AddNetworkDialogTest(unittest.TestCase):
-
- def setUp(self):
- self.parent_window = None
- self.save_callback = Mock()
-
- #given(self.save_callback).save().willReturn(None)
- self.save_callback.replay()
-
- self.testee = AddNetworkDialog(self.parent_window, self.save_callback.save)
-
-
- def test_cancelButtonDoesntCallSaveCallback(self):
- self._makeRunDialogReturn(AddNetworkDialog.CANCEL_BUTTON)
- self.testee.show()
- verify(self.save_callback, never()).save()
-
-
- def test_saveButtonCallsSaveCallback(self):
- self._makeRunDialogReturn(AddNetworkDialog.SAVE_BUTTON)
- self.testee.show('A Network Name', True)
- verify(self.save_callback).save('A Network Name', True)
-
-
- def _makeRunDialogReturn(self, value):
- class method():
- def __init__(self, value_to_return):
- self._value_to_return = value_to_return
- def __call__(self, x):
- return self._value_to_return
- self.testee._runDialog = method(value)
-
-if __name__ == '__main__':
- unittest.main()
-
--- /dev/null
+import unittest
+from unit.pie import *
+
+class PieTest(unittest.TestCase):
+
+ def test_never(self):
+ mock = Mock()
+ mock.replay()
+ verify(mock, never()).fakeMethod()
+
+
+ def test_neverFail(self):
+ mock = Mock()
+ mock.replay()
+ mock.fakeMethod()
+ try:
+ verify(mock, never()).fakeMethod()
+ raise Exception("The fake method was called - the verify statement should fail")
+ except:
+ pass
+
+
+ def test_onceSuccess(self):
+ mock = Mock()
+ given(mock).method().willReturn(True)
+ mock.replay()
+ result = mock.method()
+ assert result is True
+ verify(mock, once()).method()
+
+
+ def test_onceFail(self):
+ mock = Mock()
+ given(mock).method().willReturn(True)
+ mock.replay()
+ try:
+ verify(mock, once()).method()
+ raise Exception("The method was never called - the verify step should fail")
+ except:
+ pass
+
+
+ def test_implicitOnce_undefinedReturn_WithArguments(self):
+ mock = Mock()
+ mock.replay()
+ url = 'http://sample.argument'
+ mock.openUrl(url)
+ verify(mock).openUrl(url)
+
+
+if __name__ == '__main__':
+ unittest.main()
--- /dev/null
+from gnome import gconf
+from wifi_assistant.settings.ApplicationSettings import ApplicationSettings
+
+import unittest
+
+class ApplicationSettingsTest(unittest.TestCase):
+
+ def setUp(self):
+ self.gc = gconf.client_get_default()
+ self.root = '/apps/maemo/wifi/unit_tests'
+ self._clearGConf(self.root)
+ self._setupDefaultValues(self.root)
+ self._firstCallbackCalled = None
+ self._secondCallbackCalled = None
+ self.testee = ApplicationSettings(self.gc, self.root)
+
+ def _setupDefaultValues(self, dir):
+ self.gc.set_bool(dir + '/daemon', True)
+
+ # FIXME: inherit
+ def _clearGConf(self, dir):
+ # there's no recursive_unset available
+ all_entries = self.gc.all_entries(dir)
+ for entry in all_entries:
+ self.gc.unset(entry.get_key())
+ for sub_dir in self.gc.all_dirs(dir):
+ self._clearGConf(sub_dir)
+ self.gc.suggest_sync()
+
+
+ def test_default_is_to_use_popup(self):
+ assert self.testee.getUsePopup() is True
+
+
+ def test_setting_use_popup_works(self):
+ assert self.testee.getUsePopup() is True
+
+ self.testee.setUsePopup(False)
+ assert self.testee.getUsePopup() is False
+
+ self.testee.setUsePopup(True)
+ assert self.testee.getUsePopup() is True
+
+
+ def dont_test_adding_two_listeners_removing_one_still_notifies_first_listener(self):
+ firstSignal = False
+ secondSignal = True
+
+ self.testee.registerUsePopupListener(self._firstCallback)
+ self.testee.registerUsePopupListener(self._secondCallback)
+
+ # TODO: start thread to have signalling work properly ...
+
+ self.testee.setUsePopup(firstSignal)
+
+ assert self._firstCallbackCalled == firstSignal
+ assert self._secondCallbackCalled == firstSignal
+
+ self.testee.unregisterUsePopupListener(self._secondCallback)
+ self.testee.setUsePopup(secondSignal)
+
+ assert self._firstCallbackCalled == secondSignal
+ assert self._secondCallbackCalled == firstSignal
+
+
+ def _firstCallback(self, value):
+ self._firstCallbackCalled = value
+
+ def _secondCallback(self, value):
+ self._secondCallbackCalled = value
+
+
+if __name__ == '__main__':
+ unittest.main()
+
--- /dev/null
+from gnome import gconf
+from wifi_assistant.settings.NetworkSettings import NetworkSettings
+from wifi_assistant.settings.NetworkSetting import NetworkSetting
+
+import unittest
+
+class NetworkSettingsTest(unittest.TestCase):
+
+ def setUp(self):
+ self.gc = gconf.client_get_default()
+ self.root = '/apps/maemo/wifi/unit_tests'
+ self._clearGConf(self.root)
+ self._setupDefaultValues(self.root)
+ self.testee = NetworkSettings(self.gc, self.root)
+
+
+ def _setupDefaultValues(self, dir):
+ #settings = NetworkSetting()
+ #settings.setBrowserOption("url", "http://wifi-assistant.wendt.se/")
+ #settings.setNameOfBrowserToLaunch("default")
+ #settings.setNetworkName("default_settings")
+ #self.testee.save(settings)
+ #self.gc.set_string(dir + '/default_settings/options/url', 'http://wifi-assistant.wendt.se/')
+ #self.gc.set_string(dir + '/default_settings/browser', 'default')
+ # moved this into code for now
+ return
+
+
+ def _clearGConf(self, dir):
+ # there's no recursive_unset available
+ all_entries = self.gc.all_entries(dir)
+ for entry in all_entries:
+ self.gc.unset(entry.get_key())
+ for sub_dir in self.gc.all_dirs(dir):
+ self._clearGConf(sub_dir)
+ self.gc.suggest_sync()
+
+
+
+ def _createSettings(self, ssid):
+ return NetworkSetting({'name':ssid})
+
+
+ def test_an_unkown_ssid_returns_None(self):
+ settings = self.testee.get('unknown')
+ assert settings is None
+
+
+ def test_saving_works(self):
+ ssid = 'test'
+ settings = self._createSettings(ssid)
+
+ # make sure it's empty first
+ assert self.testee.get(ssid) is None
+
+ self.testee.save(settings)
+ assert self.testee.get(ssid) is not None
+
+
+ def test_removing_network_setting_works(self):
+ ssid = 'test'
+ settings = self._createSettings(ssid)
+
+ # make sure it's empty first
+ assert self.testee.get(ssid) is None
+
+ self.testee.save(settings)
+ assert self.testee.get(ssid) is not None
+
+ self.testee.delete(settings)
+ value = self.testee.get(ssid)
+ assert value is None
+
+
+ def test_network_name_can_contain_space_dash_and_underscore(self):
+ ssid = 'This Is-My_Network'
+ settings = self._createSettings(ssid)
+
+ # make sure it's empty first
+ assert self.testee.get(ssid) is None
+
+ self.testee.save(settings)
+ value = self.testee.get(ssid)
+ assert value is not None
+ assert value.getNetworkName() == ssid
+
+
+ def test_default_settings(self):
+ defaults = self.testee.getDefaultSettings()
+ assert defaults.getNameOfBrowserToLaunch() == 'default'
+ browser_options = defaults.getBrowserOptions()
+ assert defaults.getLaunchingOfBrowserEnabled() is True
+ assert browser_options is not None
+ assert browser_options.has_key('url')
+ assert "http://" in browser_options['url']
+
+
+ def test_list(self):
+ ssid = 'This Is-My_Network'
+ settings = self._createSettings(ssid)
+ self.testee.save(settings)
+
+ store = self.testee.getListStore()
+ assert store is not None
+ store_len = len(store)
+ assert store_len == 1
+
+
+ def test_adding_same_network_twice_joins_and_overwrites_settings(self):
+ pass
+ # FIXME: the list store needs update instead of append etc
+
+
+if __name__ == '__main__':
+ unittest.main()
+
+++ /dev/null
-from gnome import gconf
-from wifi_assistant.settings.ApplicationSettings import ApplicationSettings
-
-import unittest
-
-class ApplicationSettingsTest(unittest.TestCase):
-
- def setUp(self):
- self.gc = gconf.client_get_default()
- self.root = '/apps/maemo/wifi/unit_tests'
- self._clearGConf(self.root)
- self._setupDefaultValues(self.root)
- self._firstCallbackCalled = None
- self._secondCallbackCalled = None
- self.testee = ApplicationSettings(self.gc, self.root)
-
- def _setupDefaultValues(self, dir):
- self.gc.set_bool(dir + '/daemon', True)
-
- # FIXME: inherit
- def _clearGConf(self, dir):
- # there's no recursive_unset available
- all_entries = self.gc.all_entries(dir)
- for entry in all_entries:
- self.gc.unset(entry.get_key())
- for sub_dir in self.gc.all_dirs(dir):
- self._clearGConf(sub_dir)
- self.gc.suggest_sync()
-
-
- def test_default_is_to_use_popup(self):
- assert self.testee.getUsePopup() is True
-
-
- def test_setting_use_popup_works(self):
- assert self.testee.getUsePopup() is True
-
- self.testee.setUsePopup(False)
- assert self.testee.getUsePopup() is False
-
- self.testee.setUsePopup(True)
- assert self.testee.getUsePopup() is True
-
-
- def dont_test_adding_two_listeners_removing_one_still_notifies_first_listener(self):
- firstSignal = False
- secondSignal = True
-
- self.testee.registerUsePopupListener(self._firstCallback)
- self.testee.registerUsePopupListener(self._secondCallback)
-
- # TODO: start thread to have signalling work properly ...
-
- self.testee.setUsePopup(firstSignal)
-
- assert self._firstCallbackCalled == firstSignal
- assert self._secondCallbackCalled == firstSignal
-
- self.testee.unregisterUsePopupListener(self._secondCallback)
- self.testee.setUsePopup(secondSignal)
-
- assert self._firstCallbackCalled == secondSignal
- assert self._secondCallbackCalled == firstSignal
-
-
- def _firstCallback(self, value):
- self._firstCallbackCalled = value
-
- def _secondCallback(self, value):
- self._secondCallbackCalled = value
-
-
-if __name__ == '__main__':
- unittest.main()
-
+++ /dev/null
-from gnome import gconf
-from wifi_assistant.settings.NetworkSettings import NetworkSettings
-from wifi_assistant.settings.NetworkSetting import NetworkSetting
-
-import unittest
-
-class NetworkSettingsTest(unittest.TestCase):
-
- def setUp(self):
- self.gc = gconf.client_get_default()
- self.root = '/apps/maemo/wifi/unit_tests'
- self._clearGConf(self.root)
- self._setupDefaultValues(self.root)
- self.testee = NetworkSettings(self.gc, self.root)
-
- def _setupDefaultValues(self, dir):
- #settings = NetworkSetting()
- #settings.setBrowserOption("url", "http://wifi-assistant.wendt.se/")
- #settings.setNameOfBrowserToLaunch("default")
- #settings.setNetworkName("default_settings")
- #self.testee.save(settings)
- #self.gc.set_string(dir + '/default_settings/options/url', 'http://wifi-assistant.wendt.se/')
- #self.gc.set_string(dir + '/default_settings/browser', 'default')
- # moved this into code for now
- return
-
- def _clearGConf(self, dir):
- # there's no recursive_unset available
- all_entries = self.gc.all_entries(dir)
- for entry in all_entries:
- self.gc.unset(entry.get_key())
- for sub_dir in self.gc.all_dirs(dir):
- self._clearGConf(sub_dir)
- self.gc.suggest_sync()
-
-
- def _createSettings(self, ssid):
- return NetworkSetting({'name':ssid})
-
-
- def test_an_unkown_ssid_returns_None(self):
- settings = self.testee.get('unknown')
- assert settings is None
-
-
- def test_saving_works(self):
- ssid = 'test'
- settings = self._createSettings(ssid)
-
- # make sure it's empty first
- assert self.testee.get(ssid) is None
-
- self.testee.save(settings)
- assert self.testee.get(ssid) is not None
-
-
- def test_removing_network_setting_works(self):
- ssid = 'test'
- settings = self._createSettings(ssid)
-
- # make sure it's empty first
- assert self.testee.get(ssid) is None
-
- self.testee.save(settings)
- assert self.testee.get(ssid) is not None
-
- self.testee.delete(settings)
- value = self.testee.get(ssid)
- assert value is None
-
-
- def test_network_name_can_contain_space_dash_and_underscore(self):
- ssid = 'This Is-My_Network'
- settings = self._createSettings(ssid)
-
- # make sure it's empty first
- assert self.testee.get(ssid) is None
-
- self.testee.save(settings)
- value = self.testee.get(ssid)
- assert value is not None
- assert value.getNetworkName() == ssid
-
-
- def test_default_settings(self):
- defaults = self.testee.getDefaultSettings()
- assert defaults.getNameOfBrowserToLaunch() == 'default'
- browser_options = defaults.getBrowserOptions()
- assert defaults.getLaunchingOfBrowserEnabled() is True
- assert browser_options is not None
- assert browser_options.has_key('url')
- assert "http://" in browser_options['url']
-
-
- def test_list(self):
- ssid = 'This Is-My_Network'
- settings = self._createSettings(ssid)
- self.testee.save(settings)
-
- store = self.testee.getListStore()
- assert store is not None
- store_len = len(store)
- assert store_len == 1
-
- # FIXME: assert that default_settings are not there
-
-
-if __name__ == '__main__':
- unittest.main()
-
+++ /dev/null
-from gnome import gconf
-from wifi_assistant.daemon import Daemon
-from wifi_assistant.settings.NetworkSetting import NetworkSetting
-
-import unittest
-from pie import *
-
-url_to_open = 'http://wifi-assistant.garage.maemo.org'
-default_browser_name = "default"
-default_browser_options = {'url':url_to_open}
-default_settings = NetworkSetting()
-default_settings.setNameOfBrowserToLaunch(default_browser_name)
-default_settings.setBrowserOptions(default_browser_options)
-ssid = 'A Network Name'
-settings_without_options = NetworkSetting()
-settings_without_options.setNetworkName(ssid)
-settings_without_options.setLaunchingOfBrowserEnabled(True)
-
-class DaemonTest(unittest.TestCase):
-
- def replayMocks(self):
- self.application_settings.replay()
- self.launcher.replay()
- self.network_settings.replay()
-
- def setUp(self):
- self.launcher = Mock()
- self.application_settings = Mock()
- self.network_settings = Mock()
- self.parent_window = None
-
- def createTesteeWithPopupClickingYes(self):
- given(self.application_settings).getUsePopup().willReturn(True)
- self.testee = Daemon(self.launcher, self.application_settings, self.network_settings, self.parent_window)
-
- def yes(*args, **kwargs):
- return True
- self.testee.showDecisionDialog = yes
-
- def createTesteeWithPopupClickingNo(self):
- given(self.application_settings).getUsePopup().willReturn(True)
- self.testee = Daemon(self.launcher, self.application_settings, self.network_settings, self.parent_window)
-
- def no(*args, **kwargs):
- return False
- self.testee.showDecisionDialog = no
-
- def test_withANewNetwork_whenUserClicksYes_browserIsLaunched(self):
- # GIVEN
- self.createTesteeWithPopupClickingYes()
- given(self.network_settings).get(ssid).willReturn(None)
- given(self.network_settings).getDefaultSettings().willReturn(default_settings)
-
- # WHEN
- self.replayMocks()
- self.testee.connectionEstablished(ssid)
-
- # THEN
- verify(self.network_settings).getDefaultSettings()
- verify(self.launcher).launchBrowser(default_browser_name, default_browser_options)
-
- def test_withANewNetwork_whenUserClicksNo_browserIsNotLaunched(self):
- self.createTesteeWithPopupClickingNo()
- given(self.network_settings).get(ssid).willReturn(None)
-
- # WHEN
- self.replayMocks()
- self.testee.connectionEstablished(ssid)
-
- # THEN
- verify(self.launcher, never()).launchBrowser(default_browser_name, default_browser_options)
-
- def test_popupIsNotOpenedIfPopupIsDisabledInApplicationSettings(self):
- given(self.application_settings).getUsePopup().willReturn(False)
- self.testee = Daemon(self.launcher, self.application_settings, self.network_settings, self.parent_window)
-
- self.replayMocks()
- self.testee.connectionEstablished(ssid)
-
- verify(self.launcher, never()).launchBrowser()
- verify(self.network_settings, never()).get(ssid)
-
- def test_knownSsidWithLaunchSetToTrueUsesDefaultBrowserAndUrl(self):
- given(self.network_settings).get(ssid).willReturn(settings_without_options)
- given(self.network_settings).getDefaultSettings().willReturn(default_settings)
- given(self.application_settings).getUsePopup().willReturn(True)
- self.testee = Daemon(self.launcher, self.application_settings, self.network_settings, self.parent_window)
-
- self.replayMocks()
- self.testee.connectionEstablished(ssid)
-
- verify(self.launcher, never()).launchBrowser(default_browser_name, default_browser_options)
-
-
-if __name__ == '__main__':
- unittest.main()
-
+++ /dev/null
-import unittest
-from pie import *
-
-
-class TestPie(unittest.TestCase):
-
- def test_never(self):
- mock = Mock()
- mock.replay()
- verify(mock, never()).fakeMethod()
-
- def test_neverFail(self):
- mock = Mock()
- mock.replay()
- mock.fakeMethod()
- try:
- verify(mock, never()).fakeMethod()
- raise Exception("The fake method was called - the verify statement should fail")
- except:
- pass
-
- def test_onceSuccess(self):
- mock = Mock()
- given(mock).method().willReturn(True)
- mock.replay()
- result = mock.method()
- assert result is True
- verify(mock, once()).method()
-
- def test_onceFail(self):
- mock = Mock()
- given(mock).method().willReturn(True)
- mock.replay()
- try:
- verify(mock, once()).method()
- raise Exception("The method was never called - the verify step should fail")
- except:
- pass
-
- def test_implicitOnce_undefinedReturn_WithArguments(self):
- mock = Mock()
- mock.replay()
- url = 'http://sample.argument'
- mock.openUrl(url)
- verify(mock).openUrl(url)
-
-if __name__ == '__main__':
- unittest.main()
+++ /dev/null
-from gnome import gconf
-from wifi_assistant.settings import Settings
-import unittest
-
-ssid = 'MyFoneraNetwork'
-
-callback_value = None
-
-class TestSettings(unittest.TestCase):
-
- def setUp(self):
- self.gconf_dir = "/apps/unit_tests"
- self.testee = Settings(self.gconf_dir)
- self.gc = gconf.client_get_default()
-
-
- # clear gconf
- all_entries = self.gc.all_entries(self.gconf_dir)
- for entry in all_entries:
- self.gc.unset(entry.get_key())
- self.gc.suggest_sync()
- all_entries = self.gc.all_entries(self.gconf_dir)
- # TODO: missing from python bindnings: self.gc.recursive_unset(self.gconf_dir)
- assert len(all_entries) == 0
-
-
- def test_normal_cycle(self):
- #empty to start with - ssid unknown
- assert self.testee.getLaunchSetting(ssid) == None
-
- # set to True - launch browser
- self.testee.setLaunchSetting(ssid, True)
- assert self.testee.getLaunchSetting(ssid) == True
-
- # changes to False
- self.testee.setLaunchSetting(ssid, False)
- assert self.testee.getLaunchSetting(ssid) == False
-
- # removes - neighbour with open WLAN moves out
- self.testee.deleteLaunchSetting(ssid)
- assert self.testee.getLaunchSetting(ssid) == None
-
-
- def test_auto_popup_cycle(self):
- self.testee.setUseDaemon(True)
- assert self.testee.getUseDaemon() == True
-
- self.testee.setUseDaemon(False)
- assert self.testee.getUseDaemon() == False
-
-
- def test_url_to_open_cycle(self):
- google = "http://www.google.com/"
- yahoo = "http://www.yahoo.com/"
-
- self.testee.setUrlToOpen(google)
- value = self.testee.getUrlToOpen()
- assert google == value
-
- self.testee.setUrlToOpen(yahoo)
- value = self.testee.getUrlToOpen()
- assert yahoo == value
-
- def test_default_url_points_to_maemo_org(self):
- self.gc.unset(self.testee._gconfUrlToOpen)
- value = self.testee.getUrlToOpen()
- assert "maemo.org" in value
-
-
-if __name__ == '__main__':
- unittest.main()
projects / wifi-assistant / commitdiff