Expanded tests slightly

git-svn-id: file:///svnroot/gc-dialer/trunk@338 c39d3808-3fe2-4d86-a59f-b7f623ee9f21

diff --git a/src/dc_glade.py b/src/dc_glade.py
index 520fb92..3b5f004 100755 (executable)
--- a/src/dc_glade.py
+++ b/src/dc_glade.py
@@ -169,147 +169,155 @@ class Dialcentral(object):
                """
                If something can be done after the UI loads, push it here so it's not blocking the UI
                """
-               # Barebones UI handlers
-               import null_backend
-               import null_views
-
-               self._phoneBackends = {self.NULL_BACKEND: null_backend.NullDialer()}
-               with gtk_toolbox.gtk_lock():
-                       self._dialpads = {self.NULL_BACKEND: null_views.Dialpad(self._widgetTree)}
-                       self._accountViews = {self.NULL_BACKEND: null_views.AccountInfo(self._widgetTree)}
-                       self._recentViews = {self.NULL_BACKEND: null_views.RecentCallsView(self._widgetTree)}
-                       self._messagesViews = {self.NULL_BACKEND: null_views.MessagesView(self._widgetTree)}
-                       self._contactsViews = {self.NULL_BACKEND: null_views.ContactsView(self._widgetTree)}
-
-                       self._dialpads[self._selectedBackendId].enable()
-                       self._accountViews[self._selectedBackendId].enable()
-                       self._recentViews[self._selectedBackendId].enable()
-                       self._messagesViews[self._selectedBackendId].enable()
-                       self._contactsViews[self._selectedBackendId].enable()
-
-               # Setup maemo specifics
                try:
-                       import osso
-               except ImportError:
-                       osso = None
-               self._osso = None
-               if osso is not None:
-                       self._osso = osso.Context(constants.__app_name__, constants.__version__, False)
-                       device = osso.DeviceState(self._osso)
-                       device.set_device_state_callback(self._on_device_state_change, 0)
-               else:
-                       pass # warnings.warn("No OSSO", UserWarning, 2)
-
-               # Setup maemo specifics
-               try:
-                       import conic
-               except ImportError:
-                       conic = None
-               self._connection = None
-               if conic is not None:
-                       self._connection = conic.Connection()
-                       self._connection.connect("connection-event", self._on_connection_change, constants.__app_magic__)
-                       self._connection.request_connection(conic.CONNECT_FLAG_NONE)
-               else:
-                       pass # warnings.warn("No Internet Connectivity API ", UserWarning)
+                       # Barebones UI handlers
+                       import null_backend
+                       import null_views
 
-               # Setup costly backends
-               import gv_backend
-               import gc_backend
-               import file_backend
-               import evo_backend
-               import gc_views
+                       self._phoneBackends = {self.NULL_BACKEND: null_backend.NullDialer()}
+                       with gtk_toolbox.gtk_lock():
+                               self._dialpads = {self.NULL_BACKEND: null_views.Dialpad(self._widgetTree)}
+                               self._accountViews = {self.NULL_BACKEND: null_views.AccountInfo(self._widgetTree)}
+                               self._recentViews = {self.NULL_BACKEND: null_views.RecentCallsView(self._widgetTree)}
+                               self._messagesViews = {self.NULL_BACKEND: null_views.MessagesView(self._widgetTree)}
+                               self._contactsViews = {self.NULL_BACKEND: null_views.ContactsView(self._widgetTree)}
+
+                               self._dialpads[self._selectedBackendId].enable()
+                               self._accountViews[self._selectedBackendId].enable()
+                               self._recentViews[self._selectedBackendId].enable()
+                               self._messagesViews[self._selectedBackendId].enable()
+                               self._contactsViews[self._selectedBackendId].enable()
+
+                       # Setup maemo specifics
+                       try:
+                               import osso
+                       except ImportError:
+                               osso = None
+                       self._osso = None
+                       if osso is not None:
+                               self._osso = osso.Context(constants.__app_name__, constants.__version__, False)
+                               device = osso.DeviceState(self._osso)
+                               device.set_device_state_callback(self._on_device_state_change, 0)
+                       else:
+                               pass # warnings.warn("No OSSO", UserWarning, 2)
 
-               try:
-                       os.makedirs(self._data_path)
-               except OSError, e:
-                       if e.errno != 17:
-                               raise
-               gcCookiePath = os.path.join(self._data_path, "gc_cookies.txt")
-               gvCookiePath = os.path.join(self._data_path, "gv_cookies.txt")
-               self._defaultBackendId = self._guess_preferred_backend((
-                       (self.GC_BACKEND, gcCookiePath),
-                       (self.GV_BACKEND, gvCookiePath),
-               ))
-
-               self._phoneBackends.update({
-                       self.GC_BACKEND: gc_backend.GCDialer(gcCookiePath),
-                       self.GV_BACKEND: gv_backend.GVDialer(gvCookiePath),
-               })
-               with gtk_toolbox.gtk_lock():
-                       unifiedDialpad = gc_views.Dialpad(self._widgetTree, self._errorDisplay)
-                       unifiedDialpad.set_number("")
-                       self._dialpads.update({
-                               self.GC_BACKEND: unifiedDialpad,
-                               self.GV_BACKEND: unifiedDialpad,
-                       })
-                       self._accountViews.update({
-                               self.GC_BACKEND: gc_views.AccountInfo(
-                                       self._widgetTree, self._phoneBackends[self.GC_BACKEND], self._errorDisplay
-                               ),
-                               self.GV_BACKEND: gc_views.AccountInfo(
-                                       self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._errorDisplay
-                               ),
-                       })
-                       self._recentViews.update({
-                               self.GC_BACKEND: gc_views.RecentCallsView(
-                                       self._widgetTree, self._phoneBackends[self.GC_BACKEND], self._errorDisplay
-                               ),
-                               self.GV_BACKEND: gc_views.RecentCallsView(
-                                       self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._errorDisplay
-                               ),
-                       })
-                       self._messagesViews.update({
-                               self.GC_BACKEND: null_views.MessagesView(self._widgetTree),
-                               self.GV_BACKEND: gc_views.MessagesView(
-                                       self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._errorDisplay
-                               ),
-                       })
-                       self._contactsViews.update({
-                               self.GC_BACKEND: gc_views.ContactsView(
-                                       self._widgetTree, self._phoneBackends[self.GC_BACKEND], self._errorDisplay
-                               ),
-                               self.GV_BACKEND: gc_views.ContactsView(
-                                       self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._errorDisplay
-                               ),
-                       })
+                       # Setup maemo specifics
+                       try:
+                               import conic
+                       except ImportError:
+                               conic = None
+                       self._connection = None
+                       if conic is not None:
+                               self._connection = conic.Connection()
+                               self._connection.connect("connection-event", self._on_connection_change, constants.__app_magic__)
+                               self._connection.request_connection(conic.CONNECT_FLAG_NONE)
+                       else:
+                               pass # warnings.warn("No Internet Connectivity API ", UserWarning)
 
-               evoBackend = evo_backend.EvolutionAddressBook()
-               fsContactsPath = os.path.join(self._data_path, "contacts")
-               fileBackend = file_backend.FilesystemAddressBookFactory(fsContactsPath)
-               for backendId in (self.GV_BACKEND, self.GC_BACKEND):
-                       self._dialpads[backendId].number_selected = self._select_action
-                       self._recentViews[backendId].number_selected = self._select_action
-                       self._messagesViews[backendId].number_selected = self._select_action
-                       self._contactsViews[backendId].number_selected = self._select_action
-
-                       addressBooks = [
-                               self._phoneBackends[backendId],
-                               evoBackend,
-                               fileBackend,
-                       ]
-                       mergedBook = gc_views.MergedAddressBook(addressBooks, gc_views.MergedAddressBook.advanced_lastname_sorter)
-                       self._contactsViews[backendId].append(mergedBook)
-                       self._contactsViews[backendId].extend(addressBooks)
-                       self._contactsViews[backendId].open_addressbook(*self._contactsViews[backendId].get_addressbooks().next()[0][0:2])
+                       # Setup costly backends
+                       import gv_backend
+                       import gc_backend
+                       import file_backend
+                       import evo_backend
+                       import gc_views
 
-               callbackMapping = {
-                       "on_paste": self._on_paste,
-                       "on_refresh": self._on_refresh,
-                       "on_clearcookies_clicked": self._on_clearcookies_clicked,
-                       "on_notebook_switch_page": self._on_notebook_switch_page,
-                       "on_about_activate": self._on_about_activate,
-               }
-               self._widgetTree.signal_autoconnect(callbackMapping)
+                       try:
+                               os.makedirs(self._data_path)
+                       except OSError, e:
+                               if e.errno != 17:
+                                       raise
+                       gcCookiePath = os.path.join(self._data_path, "gc_cookies.txt")
+                       gvCookiePath = os.path.join(self._data_path, "gv_cookies.txt")
+                       self._defaultBackendId = self._guess_preferred_backend((
+                               (self.GC_BACKEND, gcCookiePath),
+                               (self.GV_BACKEND, gvCookiePath),
+                       ))
+
+                       self._phoneBackends.update({
+                               self.GC_BACKEND: gc_backend.GCDialer(gcCookiePath),
+                               self.GV_BACKEND: gv_backend.GVDialer(gvCookiePath),
+                       })
+                       with gtk_toolbox.gtk_lock():
+                               unifiedDialpad = gc_views.Dialpad(self._widgetTree, self._errorDisplay)
+                               unifiedDialpad.set_number("")
+                               self._dialpads.update({
+                                       self.GC_BACKEND: unifiedDialpad,
+                                       self.GV_BACKEND: unifiedDialpad,
+                               })
+                               self._accountViews.update({
+                                       self.GC_BACKEND: gc_views.AccountInfo(
+                                               self._widgetTree, self._phoneBackends[self.GC_BACKEND], self._errorDisplay
+                                       ),
+                                       self.GV_BACKEND: gc_views.AccountInfo(
+                                               self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._errorDisplay
+                                       ),
+                               })
+                               self._recentViews.update({
+                                       self.GC_BACKEND: gc_views.RecentCallsView(
+                                               self._widgetTree, self._phoneBackends[self.GC_BACKEND], self._errorDisplay
+                                       ),
+                                       self.GV_BACKEND: gc_views.RecentCallsView(
+                                               self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._errorDisplay
+                                       ),
+                               })
+                               self._messagesViews.update({
+                                       self.GC_BACKEND: null_views.MessagesView(self._widgetTree),
+                                       self.GV_BACKEND: gc_views.MessagesView(
+                                               self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._errorDisplay
+                                       ),
+                               })
+                               self._contactsViews.update({
+                                       self.GC_BACKEND: gc_views.ContactsView(
+                                               self._widgetTree, self._phoneBackends[self.GC_BACKEND], self._errorDisplay
+                                       ),
+                                       self.GV_BACKEND: gc_views.ContactsView(
+                                               self._widgetTree, self._phoneBackends[self.GV_BACKEND], self._errorDisplay
+                                       ),
+                               })
+
+                       evoBackend = evo_backend.EvolutionAddressBook()
+                       fsContactsPath = os.path.join(self._data_path, "contacts")
+                       fileBackend = file_backend.FilesystemAddressBookFactory(fsContactsPath)
+                       for backendId in (self.GV_BACKEND, self.GC_BACKEND):
+                               self._dialpads[backendId].number_selected = self._select_action
+                               self._recentViews[backendId].number_selected = self._select_action
+                               self._messagesViews[backendId].number_selected = self._select_action
+                               self._contactsViews[backendId].number_selected = self._select_action
+
+                               addressBooks = [
+                                       self._phoneBackends[backendId],
+                                       evoBackend,
+                                       fileBackend,
+                               ]
+                               mergedBook = gc_views.MergedAddressBook(addressBooks, gc_views.MergedAddressBook.advanced_lastname_sorter)
+                               self._contactsViews[backendId].append(mergedBook)
+                               self._contactsViews[backendId].extend(addressBooks)
+                               self._contactsViews[backendId].open_addressbook(*self._contactsViews[backendId].get_addressbooks().next()[0][0:2])
+
+                       callbackMapping = {
+                               "on_paste": self._on_paste,
+                               "on_refresh": self._on_refresh,
+                               "on_clearcookies_clicked": self._on_clearcookies_clicked,
+                               "on_notebook_switch_page": self._on_notebook_switch_page,
+                               "on_about_activate": self._on_about_activate,
+                       }
+                       self._widgetTree.signal_autoconnect(callbackMapping)
 
-               self._initDone = True
+                       self._initDone = True
 
-               config = ConfigParser.SafeConfigParser()
-               config.read(self._user_settings)
-               with gtk_toolbox.gtk_lock():
-                       self.load_settings(config)
+                       config = ConfigParser.SafeConfigParser()
+                       config.read(self._user_settings)
+                       with gtk_toolbox.gtk_lock():
+                               self.load_settings(config)
 
-               gtk_toolbox.asynchronous_gtk_message(self._spawn_attempt_login)(2)
+                       gtk_toolbox.asynchronous_gtk_message(self._spawn_attempt_login)(2)
+               except StandardError, e:
+                       warnings.warn(e.message, UserWarning, 2)
+               except BaseException, e:
+                       try:
+                               warnings.warn(e.message, UserWarning, 2)
+                       finally:
+                               raise
 
        def attempt_login(self, numOfAttempts = 10, force = False):
                """

diff --git a/tests/dummy_hildon/hildon.py b/tests/dummy_hildon/hildon.py
new file mode 100644 (file)
index 0000000..2111a67
--- /dev/null
+++ b/tests/dummy_hildon/hildon.py
@@ -0,0 +1,12 @@
+import gtk
+
+class Program(object):
+
+       def add_window(self, window):
+               pass
+
+
+Window = gtk.Window
+
+def hildon_helper_set_thumb_scrollbar(widget, value):
+       pass

diff --git a/tests/test_startup.py b/tests/test_startup.py
index 88d8807..a469626 100644 (file)
--- a/tests/test_startup.py
+++ b/tests/test_startup.py
@@ -11,28 +11,45 @@ sys.path.append("../src")
 import dc_glade
 
 
-def test_startup_with_no_data_dir():
+def startup(factory):
+       handle = factory()
+       with test_utils.expected(AssertionError("Attempting login before app is fully loaded")):
+               handle.refresh_session()
+
+       for i in xrange(10):
+               if handle._initDone:
+                       print "Completed init on iteration %d" % i
+                       break
+               time.sleep(1)
+       assert handle._initDone
+
+       with test_utils.expected(RuntimeError("Login Failed")):
+               handle.refresh_session()
+
+       handle._save_settings()
+
+       del handle
+
+
+def test_startup_with_no_data_dir_with_dummy_hildon():
        dc_glade.Dialcentral._data_path = os.path.join(os.path.dirname(__file__), "notexistent_data")
        dc_glade.Dialcentral._user_settings = "%s/settings.ini" % dc_glade.Dialcentral._data_path
 
        try:
-               handle = dc_glade.Dialcentral()
-               with test_utils.expected(AssertionError("Attempting login before app is fully loaded")):
-                       handle.refresh_session()
-
-               for i in xrange(10):
-                       if handle._initDone:
-                               print "Completed init on iteration %d" % i
-                               break
-                       time.sleep(1)
-               assert handle._initDone
+               sys.path.insert(0, "dummy_hildon")
+               startup(dc_glade.Dialcentral)
+               sys.path.remove("dummy_hildon")
+       finally:
+               os.remove(dc_glade.Dialcentral._user_settings)
+               os.removedirs(dc_glade.Dialcentral._data_path)
 
-               with test_utils.expected(RuntimeError("Login Failed")):
-                       handle.refresh_session()
 
-               handle._save_settings()
+def test_startup_with_no_data_dir():
+       dc_glade.Dialcentral._data_path = os.path.join(os.path.dirname(__file__), "notexistent_data")
+       dc_glade.Dialcentral._user_settings = "%s/settings.ini" % dc_glade.Dialcentral._data_path
 
-               del handle
+       try:
+               startup(dc_glade.Dialcentral)
        finally:
                os.remove(dc_glade.Dialcentral._user_settings)
                os.removedirs(dc_glade.Dialcentral._data_path)
@@ -43,25 +60,7 @@ def test_startup_with_empty_data_dir():
        dc_glade.Dialcentral._user_settings = "%s/settings.ini" % dc_glade.Dialcentral._data_path
 
        try:
-               os.makedirs(dc_glade.Dialcentral._data_path)
-
-               handle = dc_glade.Dialcentral()
-               with test_utils.expected(AssertionError("Attempting login before app is fully loaded")):
-                       handle.refresh_session()
-
-               for i in xrange(10):
-                       if handle._initDone:
-                               print "Completed init on iteration %d" % i
-                               break
-                       time.sleep(1)
-               assert handle._initDone
-
-               with test_utils.expected(RuntimeError("Login Failed")):
-                       handle.refresh_session()
-
-               handle._save_settings()
-
-               del handle
+               startup(dc_glade.Dialcentral)
        finally:
                os.remove(dc_glade.Dialcentral._user_settings)
                os.removedirs(dc_glade.Dialcentral._data_path)
@@ -71,20 +70,4 @@ def test_startup_with_basic_data_dir():
        dc_glade.Dialcentral._data_path = os.path.join(os.path.dirname(__file__), "basic_data")
        dc_glade.Dialcentral._user_settings = "%s/settings.ini" % dc_glade.Dialcentral._data_path
 
-       handle = dc_glade.Dialcentral()
-       with test_utils.expected(AssertionError("Attempting login before app is fully loaded")):
-               handle.refresh_session()
-
-       for i in xrange(10):
-               if handle._initDone:
-                       print "Completed init on iteration %d" % i
-                       break
-               time.sleep(1)
-       assert handle._initDone
-
-       with test_utils.expected(RuntimeError("Login Failed")):
-               handle.refresh_session()
-
-       handle._save_settings()
-
-       del handle
+       startup(dc_glade.Dialcentral)