Merge lp:~dobey/ubuntu-sso-client/update-stable-4-0 into lp:ubuntu-sso-client/stable-4-0

[dobey]

[Brian Curtin]

    Cleanup setup.py of lazr imports and lazr-specific features.

[György Balló.]

    Removed the lazr.restfulclient dependency by removing TimestampedAuthorizer class.

[Mike McCracken]

    Fixes "TypeError in got_state()" message and incorrect network detection on linux (LP: #1003692 )
    Implement internet connectivity detection in Mac OS X ("darwin") systems (LP: #984667 )
    Fix test scripts for linux and windows to avoid running darwin tests

[Diego Sarmentero]

    Setting the size property to expanding and adding a maximum width (LP: #999885).

[Eric Casteleijn (thisfred)]

review: Approve

[Mike McCracken (mikemc)]

review: Approve

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntu-sso-client/update-stable-4-0 into lp:ubuntu-sso-client/stable-4-0 failed. Below is the output from the failed tests.

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntu-sso-client/update-stable-4-0 into lp:ubuntu-sso-client/stable-4-0 failed. Below is the output from the failed tests.

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntu-sso-client/update-stable-4-0 into lp:ubuntu-sso-client/stable-4-0 failed. Below is the output from the failed tests.

*** Running GTK test suite for ubuntu_sso ***
/usr/bin/xvfb-run: 182: /usr/bin/xvfb-run: u1trial: not found

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntu-sso-client/update-stable-4-0 into lp:ubuntu-sso-client/stable-4-0 failed. Below is the output from the failed tests.

*** Running GTK test suite for ubuntu_sso ***
Traceback (most recent call last):
  File "/usr/bin/u1trial", line 337, in <module>
    main()
  File "/usr/bin/u1trial", line 317, in main
    suite = trial_runner.get_suite(config)
  File "/usr/bin/u1trial", line 196, in get_suite
    config['ignore-paths']))
  File "/usr/bin/u1trial", line 180, in _collect_tests
    module_suite = self._load_unittest(filepath)
  File "/usr/bin/u1trial", line 120, in _load_unittest
    module = __import__(modpath, None, None, [""])
  File "/mnt/tarmac/cache/ubuntu-sso-client/stable-3-0/ubuntu_sso/networkstate/tests/test_linux.py", line 34, in <module>
    from mocker import ARGS, KWARGS, ANY, MockerTestCase
ImportError: No module named mocker

[Ubuntu One Auto Pilot (otto-pilot)]

The attempt to merge lp:~dobey/ubuntu-sso-client/update-stable-4-0 into lp:ubuntu-sso-client/stable-4-0 failed. Below is the output from the failed tests.

*** Running GTK test suite for ubuntu_sso ***
ubuntu_sso.tests.test_account
  AccountTestCase
    test_generate_captcha ... [OK]
    test_is_not_validated ... [OK]
    test_is_not_validated_empty_result ... [OK]
    test_is_validated ... [OK]
    test_login_if_http_error ... [OK]
    test_login_if_no_error ... [OK]
    test_register_user_checks_valid_email ... [OK]
    test_register_user_checks_valid_password ... [OK]
    test_register_user_if_status_error ... [OK]
    test_register_user_if_status_error_with_string_message ... [OK]
    test_register_user_if_status_ok ... [OK]
    test_register_user_if_status_unknown ... [OK]
    test_request_password_reset_token_if_http_error ... [OK]
    test_request_password_reset_token_if_status_ok ... [OK]
    test_request_password_reset_token_if_status_unknown ... [OK]
    test_set_new_password_if_http_error ... [OK]
    test_set_new_password_if_status_ok ... [OK]
    test_set_new_password_if_status_unknown ... [OK]
    test_validate_email_if_status_error ... [OK]
    test_validate_email_if_status_error_with_string_message ... [OK]
    test_validate_email_if_status_ok ... [OK]
    test_validate_email_if_status_unknown ... [OK]
  EnvironOverridesTestCase
    test_no_override_service_url ... [OK]
    test_override_service_url ... [OK]
    test_service_url_as_parameter ... [OK]
twisted.trial.unittest
  TestCase
    runTest ... [OK]
ubuntu_sso.tests.test_credentials
  BasicTestCase
    runTest ... [OK]
  ClearCredentialsTestCase
    test_clear_credentials ... [OK]
    test_keyring_failure ... [OK]
  CredentialsCallbacksTestCase
    test_creation_parameters_are_stored ... [OK]
    test_help_text_defaults_to_empty_string ... [OK]
    test_ping_url_defaults_to_none ... [OK]
    test_policy_url_defaults_to_none ... [OK]
    test_tc_url_defaults_to_none ... [OK]
    test_ui_executable_defaults_to_gtk ... ...

=== modified file 'data/qt/reset_password.ui'
--- data/qt/reset_password.ui	2012-03-16 21:03:09 +0000
+++ data/qt/reset_password.ui	2012-06-05 14:23:23 +0000
@@ -202,7 +202,7 @@
      <item row="1" column="1" rowspan="2">
       <widget class="QLabel" name="password_assistance">
        <property name="sizePolicy">
-        <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+        <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
@@ -215,8 +215,8 @@
        </property>
        <property name="maximumSize">
         <size>
-         <width>185</width>
-         <height>95</height>
+         <width>300</width>
+         <height>16777215</height>
         </size>
        </property>
        <property name="text">

=== modified file 'run-tests'
--- run-tests	2012-04-20 19:28:22 +0000
+++ run-tests	2012-06-05 14:23:23 +0000
@@ -28,9 +28,13 @@
 # do not wish to do so, delete this exception statement from your
 # version.  If you delete this exception statement from all source
 # files in the program, then also delete it here.
+
 QT_TESTS_PATH="ubuntu_sso/qt/tests, ubuntu_sso/qt/main/tests"
+QT_TEST_FILES="test_qt.py,test_qtwisted.py"
+
 GTK_TESTS_PATH=ubuntu_sso/gtk/tests
-WINDOWS_TESTS=test_windows.py
+
+LINUX_IGNORE_FILES="test_darwin.py,test_windows.py,test_pykeyring.py"
 
 set -e
 
@@ -59,7 +63,7 @@
 fi
 
 echo "*** Running GTK test suite for ""$MODULE"" ***"
-$XVFB_CMDLINE u1trial --reactor=gi --gui -p "$QT_TESTS_PATH" -i "test_windows.py,test_qt.py,test_qtwisted.py,test_pykeyring.py" "$MODULE"
+$XVFB_CMDLINE u1trial --reactor=gi --gui -p "$QT_TESTS_PATH" -i "$QT_TEST_FILES,$LINUX_IGNORE_FILES" "$MODULE"
 rm -rf _trial_temp
 
 # hack to avoid:
@@ -69,7 +73,7 @@
 
 echo "*** Running QT test suite for ""$MODULE"" ***"
 ./setup.py build
-$XVFB_CMDLINE u1trial --reactor=qt4 --gui -p "$GTK_TESTS_PATH" -i "test_windows.py" "$MODULE"
+$XVFB_CMDLINE u1trial --reactor=qt4 --gui -p "$GTK_TESTS_PATH" -i $LINUX_IGNORE_FILES "$MODULE"
 rm -rf _trial_temp
 rm -rf build
 

=== modified file 'run-tests.bat'
--- run-tests.bat	2012-04-20 18:43:44 +0000
+++ run-tests.bat	2012-06-05 14:23:23 +0000
@@ -74,7 +74,7 @@
 "%PYTHONEXEPATH%" setup.py build
 ECHO Running tests
 :: execute the tests with a number of ignored linux only modules
-"%PYTHONEXEPATH%" "%TRIALPATH%" -i "test_linux.py, test_txsecrets.py, test_qt.py, test_glib.py" -p "ubuntu_sso\gtk" --reactor=qt4 --gui %PARAMS% ubuntu_sso
+"%PYTHONEXEPATH%" "%TRIALPATH%" -i "test_darwin.py, test_linux.py, test_txsecrets.py, test_qt.py, test_glib.py" -p "ubuntu_sso\gtk" --reactor=qt4 --gui %PARAMS% ubuntu_sso
 :: Clean the build from the setupt.py
 ECHO Cleaning the generated code before running the style checks...
 "%PYTHONEXEPATH%" setup.py clean

=== modified file 'setup.py'
--- setup.py	2012-04-09 17:38:24 +0000
+++ setup.py	2012-06-05 14:23:23 +0000
@@ -201,9 +201,8 @@
 
 def set_py2exe_paths():
     """Set the path so that py2exe finds the required modules."""
-    # Pylint does not understand same spaced imports which is what lazr uses
+    # Pylint does not understand same spaced imports
     # pylint: disable=F0401
-    import lazr
     import win32com
     # pylint: enable=F0401
     try:
@@ -226,55 +225,6 @@
         for module_path in module.__path__[1:]:
             modulefinder.AddPackagePath(extra_mod, module_path)
 
-    # lazr uses namespaces packages, which does add some problems to py2exe
-    # the following is a way to work arround the issue
-    for path in lazr.__path__:
-        modulefinder.AddPackagePath(__name__, path)
-
-
-def get_py2exe_extension():
-    """Return an extension class of py2exe."""
-    import glob
-    # pylint: disable=F0401
-    from py2exe.build_exe import py2exe as build_exe
-    # pylint: enable=F0401
-
-    # pylint: disable=E1101,W0232
-    class MediaCollector(build_exe):
-        """Extension that copies lazr missing data."""
-
-        def _add_module_data(self, module_name):
-            """Add the data from a given path."""
-            # Create the media subdir where the
-            # Python files are collected.
-            media = module_name.replace('.', os.path.sep)
-            full = os.path.join(self.collect_dir, media)
-            if not os.path.exists(full):
-                self.mkpath(full)
-
-            # Copy the media files to the collection dir.
-            # Also add the copied file to the list of compiled
-            # files so it will be included in zipfile.
-            module = __import__(module_name, None, None, [''])
-            for path in module.__path__:
-                for f in glob.glob(path + '/*'):  # does not like os.path.sep
-                    log.info('Copying file %s', f)
-                    name = os.path.basename(f)
-                    if not os.path.isdir(f):
-                        self.copy_file(f, os.path.join(full, name))
-                        self.compiled_files.append(os.path.join(media, name))
-                    else:
-                        self.copy_tree(f, os.path.join(full, name))
-
-        def copy_extensions(self, extensions):
-            """Copy the missing extensions."""
-            build_exe.copy_extensions(self, extensions)
-            for module in ['lazr.uri', 'lazr.restfulclient',
-                           'lazr.authentication', 'wadllib']:
-                self._add_module_data(module)
-    # pylint: enable=E1101
-
-    return MediaCollector
 
 # pylint: disable=C0103
 
@@ -316,7 +266,6 @@
     """Provide the required info to setup the project on windows."""
     set_py2exe_paths()
     _data_files = []
-    cmdclass['py2exe'] = get_py2exe_extension()
     # for PyQt, see http://www.py2exe.org/index.cgi/Py2exeAndPyQt
     _includes = ['sip', 'email', 'ubuntu_sso.qt.gui',
                  'ubuntu_sso.qt.controllers', 'PyQt4.QtNetwork', 'PIL']
@@ -347,7 +296,7 @@
 
 DistUtilsExtra.auto.setup(
     name='ubuntu-sso-client',
-    version='3.1',
+    version='3.99',
     license='GPL v3',
     author='Natalia Bidart',
     author_email='[e-mail]',

=== modified file 'ubuntu_sso/account.py'
--- ubuntu_sso/account.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/account.py	2012-06-05 14:23:23 +0000
@@ -38,8 +38,6 @@
 import os
 import re
 
-from lazr.restfulclient.authorize.oauth import OAuthAuthorizer
-from oauth import oauth
 from twisted.internet import defer
 
 from ubuntu_sso.logger import setup_logging
@@ -54,27 +52,6 @@
 SSO_STATUS_ERROR = 'error'
 
 
-class TimestampedAuthorizer(OAuthAuthorizer):
-    """Includes a custom timestamp on OAuth signatures."""
-
-    def __init__(self, get_timestamp, *args, **kwargs):
-        """Store the get_timestamp method, and move on."""
-        super(TimestampedAuthorizer, self).__init__(*args, **kwargs)
-        self.get_timestamp = get_timestamp
-
-    # pylint: disable=C0103
-    def authorizeRequest(self, absolute_uri, method, body, headers):
-        """Override authorizeRequest including the timestamp."""
-        parameters = {"oauth_timestamp": self.get_timestamp()}
-        oauth_request = oauth.OAuthRequest.from_consumer_and_token(
-            self.consumer, self.access_token, http_url=absolute_uri,
-            parameters=parameters)
-        oauth_request.sign_request(
-            oauth.OAuthSignatureMethod_PLAINTEXT(),
-            self.consumer, self.access_token)
-        headers.update(oauth_request.to_header(self.oauth_realm))
-
-
 class InvalidEmailError(Exception):
     """The email is not valid."""
 

=== modified file 'ubuntu_sso/networkstate/darwin.py'
--- ubuntu_sso/networkstate/darwin.py	2012-04-23 12:22:03 +0000
+++ ubuntu_sso/networkstate/darwin.py	2012-06-05 14:23:23 +0000
@@ -13,83 +13,291 @@
 #
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
-"""Implementation of network state detection."""
+"""Network state detection on OS X.
+
+is_machine_connected(): (deferred) returns connected state as bool
+NetworkManagerState: class with listening thread, calls back with state changes
+"""
 
 from twisted.internet import defer
 
+from threading import Thread
+
 from ubuntu_sso.networkstate import NetworkFailException
-from ubuntu_sso.networkstate.networkstates import (
-    ONLINE, OFFLINE, UNKNOWN,
-
-    NM_STATE_CONNECTING_LIST,
-    NM_STATE_CONNECTED_LIST,
-    NM_STATE_DISCONNECTED_LIST,
-    )
-from ubuntu_sso.networkstate.networkstates import NM_STATE_CONNECTED_GLOBAL
+from ubuntu_sso.networkstate.networkstates import (ONLINE, OFFLINE, UNKNOWN)
 from ubuntu_sso.logger import setup_logging
 logger = setup_logging("ubuntu_sso.networkstate")
 
+HOSTNAME_TO_CHECK = 'one.ubuntu.com'
+
+from ctypes import (
+    CDLL,
+    POINTER,
+    CFUNCTYPE,
+    Structure,
+    pointer,
+    c_bool,
+    c_long,
+    c_void_p,
+    c_uint32)
+
+from ctypes.util import find_library
+
+# pylint: disable=C0103
+
+# Functions and constants below are from
+# /System/Library/CoreFoundation.framework/
+CoreFoundationPath = find_library("CoreFoundation")
+CoreFoundation = CDLL(CoreFoundationPath)
+
+# CFRunLoopRef CFRunLoopGetCurrent()
+CFRunLoopGetCurrent = CoreFoundation.CFRunLoopGetCurrent
+CFRunLoopGetCurrent.restype = c_void_p
+CFRunLoopGetCurrent.argtypes = []
+
+# void CFRelease(CFTypeRef)
+CFRelease = CoreFoundation.CFRelease
+CFRelease.restype = None
+CFRelease.argtypes = [c_void_p]
+
+# void CFRunLoopRun()
+CFRunLoopRun = CoreFoundation.CFRunLoopRun
+
+# const CFStringRef kCFRunLoopDefaultMode
+# pylint: disable=E1101
+kCFRunLoopDefaultMode = c_void_p.in_dll(CoreFoundation,
+                                        "kCFRunLoopDefaultMode")
+
+
+# Functions and constants below are from
+# /System/Library/SystemConfiguration.framework/
+SystemConfigurationPath = find_library("SystemConfiguration")
+
+# SystemConfiguration abbreviated as "SC" below:
+SC = CDLL(SystemConfigurationPath)
+
+# "SCNetworkReachability" functions abbreviated to "SCNR*" here.
+
+# SCNetworkReachabilityRef
+# SCNetworkReachabilityCreateWithName(CFAllocatorRef, const char *)
+SCNRCreateWithName = SC.SCNetworkReachabilityCreateWithName
+SCNRCreateWithName.restype = c_void_p
+
+# Boolean SCNetworkReachabilityGetFlags(SCNetworkReachabilityRef,
+#                                       SCNetworkReachabilityFlags)
+SCNRGetFlags = SC.SCNetworkReachabilityGetFlags
+SCNRGetFlags.restype = c_bool
+SCNRGetFlags.argtypes = [c_void_p,
+                         POINTER(c_uint32)]
+
+SCNRScheduleWithRunLoop = SC.SCNetworkReachabilityScheduleWithRunLoop
+SCNRScheduleWithRunLoop.restype = c_bool
+SCNRScheduleWithRunLoop.argtypes = [c_void_p,
+                                    c_void_p,
+                                    c_void_p]
+
+# ctypes callback type to match SCNetworkReachabilityCallback
+# void (*SCNetworkReachabilityCallback) (SCNetworkReachabilityRef,
+#                                        SCNetworkReachabilityFlags,
+#                                        void *)
+SCNRCallbackType = CFUNCTYPE(None, c_void_p, c_uint32, c_void_p)
+# NOTE: need to keep this reference alive as long as a callback might occur.
+
+# Boolean SCNetworkReachabilitySetCallback(SCNetworkReachabilityRef,
+#                                          SCNetworkReachabilityCallback,
+#                                          SCNetworkReachabilityContext)
+SCNRSetCallback = SC.SCNetworkReachabilitySetCallback
+SCNRSetCallback.restype = c_bool
+SCNRSetCallback.argtypes = [c_void_p,
+                            SCNRCallbackType,
+                            c_void_p]
+# pylint: enable=E1101
+
+
+def check_connected_state():
+    """Calls Synchronous SCNR API, returns bool."""
+    target = SCNRCreateWithName(None, HOSTNAME_TO_CHECK)
+    if target is None:
+        logger.error("Error creating network reachability reference.")
+        raise NetworkFailException()
+
+    flags = c_uint32(0)
+    ok = SCNRGetFlags(target, pointer(flags))
+    CFRelease(target)
+
+    if not ok:
+        logger.error("Error getting reachability status of '%s'" % \
+                     HOSTNAME_TO_CHECK)
+        raise NetworkFailException()
+
+    return flags_say_reachable(flags.value)
+
+
+def flags_say_reachable(flags):
+    """Check flags returned from SCNetworkReachability API. Returns bool.
+
+    Requires some logic:
+    reachable_flag isn't enough on its own.
+
+    A down wifi will return flags = 7, or reachable_flag and
+    connection_required_flag, meaning that the host *would be*
+    reachable, but you need a connection first.  (And then you'd
+    presumably be best off checking again.)
+    """
+    # values from SCNetworkReachability.h
+    reachable_flag = 1 << 1
+    connection_required_flag = 1 << 2
+
+    if flags & connection_required_flag:
+        return False
+    elif flags & reachable_flag:
+        return True
+    else:
+        return False
+
+
+class SCNRContext(Structure):
+
+    """A struct to send as SCNetworkReachabilityContext to SCNRSetCallback.
+
+    We don't use the fields currently.
+    """
+
+    _fields_ = [("version", c_long),
+                ("info", c_void_p),
+                ("retain", c_void_p),           # func ptr
+                ("release", c_void_p),          # func ptr
+                ("copyDescription", c_void_p)]  # func ptr
+
 
 class NetworkManagerState(object):
-    """All likely to change very soon."""
+
+    """Probe Network State and receive callbacks on changes.
+
+    This class uses both synchronous and async API from the
+    SystemConfiguration framework.
+
+    To use: Initialize with a callback function, then call
+    find_online_state. The callback will be called once immediately
+    with the current state and then only on state changes.
+
+    Any exceptions in checking state will result in the callback being
+    called with UNKNOWN. At this point the listening thread is no
+    longer runing, and a new NetworkManagerState should be created.
+
+    NOTE: the callback will be called from the separate listening
+    thread, except for the first call.
+    """
 
     def __init__(self, result_cb):
-        """Initialize this instance with a result and error callbacks."""
+        """Initialize and save result callback function.
+
+        result_cb should take one argument, a networkstate object.
+
+        The callback will be called with one of ONLINE, OFFLINE, or
+        UNKNOWN, as defined in networkstates.py.
+        """
         self.result_cb = result_cb
-        self.state_signal = None
-
-    def call_result_cb(self, state):
-        """Return the state thru the result callback."""
-        self.result_cb(state)
-
-    def got_state(self, state):
-        """Not actually called by DBus when the state is retrieved from NM."""
-        if state in NM_STATE_CONNECTED_LIST:
-            self.call_result_cb(ONLINE)
-        elif state in NM_STATE_CONNECTING_LIST:
-            logger.debug("Currently connecting, waiting for signal")
-        else:
-            self.call_result_cb(OFFLINE)
-
-    def got_error(self, error):
-        """Not actually called by DBus when the state is retrieved from NM."""
-        logger.error("Error contacting NetworkManager: %s" % \
-                     str(error))
-        self.call_result_cb(UNKNOWN)
-
-    def state_changed(self, state):
-        """Called when a signal is emmited by Network Manager."""
-        if int(state) in NM_STATE_CONNECTED_LIST:
-            self.call_result_cb(ONLINE)
-        elif int(state) in NM_STATE_DISCONNECTED_LIST:
-            self.call_result_cb(OFFLINE)
-        else:
-            logger.debug("Not yet connected: continuing to wait")
+        self.listener_thread = None
+
+    def _state_changed(self, flags):
+        """Testable callback called by reachability_state_changed_cb.
+
+        Used because reachability_state_changed_cb has to have a
+        particular method signature.
+
+        Clients should not call this method.
+        """
+        if flags_say_reachable(flags):
+            self.result_cb(ONLINE)
+        else:
+            self.result_cb(OFFLINE)
+
+    def _listen_on_separate_thread(self):
+        """In separate thread, setup callback and listen for changes.
+
+        On error, calls result_cb(UNKNOWN) and returns.
+        """
+
+        def reachability_state_changed_cb(targetref, flags, info):
+            """Callback for SCNetworkReachability API
+
+            This callback is passed to the SCNetworkReachability API,
+            so its method signature has to be exactly this. Therefore,
+            we declare it here and just call _state_changed with
+            flags."""
+            self._state_changed(flags)
+
+        c_callback = SCNRCallbackType(reachability_state_changed_cb)
+        context = SCNRContext(0, None, None, None, None)
+
+        target = SCNRCreateWithName(None, HOSTNAME_TO_CHECK)
+        if target is None:
+            logger.error("Error creating SCNetworkReachability target")
+            self.result_cb(UNKNOWN)
+            return
+
+        ok = SCNRSetCallback(target, c_callback, pointer(context))
+        if not ok:
+            logger.error("error setting SCNetworkReachability callback")
+            CFRelease(target)
+            self.result_cb(UNKNOWN)
+            return
+
+        ok = SCNRScheduleWithRunLoop(target,
+                                     CFRunLoopGetCurrent(),
+                                     kCFRunLoopDefaultMode)
+        if not ok:
+            logger.error("error scheduling on runloop: SCNetworkReachability")
+            CFRelease(target)
+            self.result_cb(UNKNOWN)
+            return
+
+        CFRunLoopRun()
+
+        CFRelease(target)               # won't happen
+
+    def _start_listening_thread(self):
+        """Start the separate listener thread.
+
+        Currently will not start one more than once.
+        Should be OK because we don't expect errors the listen method.
+
+        To add more error handling support, you could either add a
+        call to join and re-start, or client could just create a new
+        NetworkManagerState.
+        """
+
+        if self.listener_thread is None:
+            self.listener_thread = Thread(
+                target=self._listen_on_separate_thread,
+                name="Ubuntu SSO Network Connection Monitor")
+            self.listener_thread.daemon = True
+            self.listener_thread.start()
 
     def find_online_state(self):
-        """Get the network state and return it thru the set callback."""
+        """Calls callback with current state. Starts listening thread."""
         try:
-            self.state_changed(NM_STATE_CONNECTED_GLOBAL)
-        except Exception, e:  # pylint: disable=W0703
-            self.got_error(e)
+            if check_connected_state():
+                self.result_cb(ONLINE)
+            else:
+                self.result_cb(OFFLINE)
+
+        except Exception:               # pylint: disable=W0703
+            logger.exception("Getting state from SCNetworkReachability")
+            self.result_cb(UNKNOWN)
+            return                      # don't start thread on error
+
+        self._start_listening_thread()
 
 
 def is_machine_connected():
-    """Return a deferred that when fired, returns if the machine is online."""
-    d = defer.Deferred()
-
-    def got_state(state):
-        """The state was retrieved from the Network Manager."""
-        result = int(state) in NM_STATE_CONNECTED_LIST
-        d.callback(result)
-
-    # pylint: disable=W0702, W0703
+    """Return a deferred that when fired, returns online state as a bool.
+
+    Raises NetworkFailException for errors.
+    """
     try:
-        network = NetworkManagerState(got_state)
-        network.find_online_state()
-    except Exception, e:
-        logger.exception('is_machine_connected failed with:')
-        d.errback(NetworkFailException(e))
-    # pylint: enable=W0702, W0703
-
-    return d
+        return defer.succeed(check_connected_state())
+    except Exception, e:                # pylint: disable=W0703
+        logger.exception("Exception calling check_connected_state:")
+        return defer.fail(NetworkFailException(e))

=== modified file 'ubuntu_sso/networkstate/linux.py'
--- ubuntu_sso/networkstate/linux.py	2012-04-23 12:22:03 +0000
+++ ubuntu_sso/networkstate/linux.py	2012-06-05 14:23:23 +0000
@@ -117,7 +117,10 @@
 
     def got_state(state):
         """The state was retrieved from the Network Manager."""
-        result = int(state) in NM_STATE_CONNECTED_LIST
+        if type(state) is not type(ONLINE):
+            logger.exception("bad callback argument in is_machine_connected")
+            raise NetworkFailException()
+        result = (state == ONLINE)
         d.callback(result)
 
     # pylint: disable=W0702, W0703

=== modified file 'ubuntu_sso/networkstate/networkstates.py'
--- ubuntu_sso/networkstate/networkstates.py	2012-04-23 12:22:03 +0000
+++ ubuntu_sso/networkstate/networkstates.py	2012-06-05 14:23:23 +0000
@@ -15,14 +15,20 @@
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 """Network states."""
 
+
+class NetworkState(object):
+    """ A simple class to add a label and make debugging easier. """
+
+    def __init__(self, label="unlabeled"):
+        self.label = label
+
+    def __repr__(self):
+        return "Network state (%s)" % self.label
+
 # Values returned by the callback
-ONLINE, OFFLINE, UNKNOWN = object(), object(), object()
-
-NM_STATE_NAMES = {
-    ONLINE: "online",
-    OFFLINE: "offline",
-    UNKNOWN: "unknown",
-}
+(ONLINE, OFFLINE, UNKNOWN) = (NetworkState("online"),
+                              NetworkState("offline"),
+                              NetworkState("unknown"))
 
 # Internal NetworkManager State constants
 NM_STATE_UNKNOWN = 0

=== added file 'ubuntu_sso/networkstate/tests/run_nwmgr_standalone.py'
--- ubuntu_sso/networkstate/tests/run_nwmgr_standalone.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/networkstate/tests/run_nwmgr_standalone.py	2012-06-05 14:23:23 +0000
@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+"""
+A test script to start a NetworkManagerState instance and print out
+the current actual state of the system.
+"""
+
+
+from ubuntu_sso.networkstate import (NetworkManagerState,
+                                     is_machine_connected)
+
+
+def my_cb(state):
+    """simple callback just prints state"""
+    print "one.ubuntu.com:", state
+
+if __name__ == '__main__':
+    # test once with direct call:
+    is_machine_connected().addCallback(my_cb)
+
+    NMS = NetworkManagerState(my_cb)
+
+    NMS.find_online_state()
+
+    import time
+    time.sleep(60)

=== added file 'ubuntu_sso/networkstate/tests/test_darwin.py'
--- ubuntu_sso/networkstate/tests/test_darwin.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/networkstate/tests/test_darwin.py	2012-06-05 14:23:23 +0000
@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2010-2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+"""Tests for the network state detection code."""
+
+from twisted.internet.defer import inlineCallbacks
+
+from ubuntu_sso.tests import TestCase
+from ubuntu_sso.networkstate import (
+    darwin,
+    NetworkFailException,
+    )
+
+from ubuntu_sso.networkstate.networkstates import (
+    ONLINE, OFFLINE, UNKNOWN,
+    )
+
+from ubuntu_sso.networkstate.darwin import (
+    is_machine_connected,
+    NetworkManagerState
+    )
+
+from ubuntu_sso.networkstate.darwin import flags_say_reachable
+
+
+REACHABLE_FLAG = 1 << 1
+CONNECTION_REQUIRED_FLAG = 1 << 2
+
+
+class TestSCNRFailingInDirect(TestCase):
+
+    """Test that we handle a problem getting status in a direct call
+    to check_connected_state (used by is_machine_connected) by
+    raising an exception.
+    """
+
+    def test_cant_create_target(self):
+        """SCNRCreateWithName returning None should cause an exception."""
+        self.patch(darwin, "SCNRCreateWithName",
+                   lambda _1, _2: None)
+        # pylint: disable=W0212
+        self.assertRaises(NetworkFailException,
+                          darwin.check_connected_state)
+
+    def test_cant_get_flags(self):
+        """SCNRGetFlags returning False should cause an exception."""
+        self.patch(darwin, "SCNRGetFlags",
+                   lambda _1, _2: False)
+        # pylint: disable=W0212
+        self.assertRaises(NetworkFailException,
+                          darwin.check_connected_state)
+
+
+class TestFailingSCNRInCallbacks(TestCase):
+
+    """Test that we handle a problem getting status in the separate
+    listening thread by updating the status to UNKNOWN.
+    """
+
+    def expect_unknown(self, state):
+        """A convenience callback that fails unless it sees UNKNOWN."""
+        self.assertEquals(state, UNKNOWN)
+
+    def test_exc_in_find_online_state(self):
+        """Expect UNKNOWN from find_online_state in case of exception."""
+        def fake_check_connected_state():
+            "fake a broken check_connected_state"
+            raise NetworkFailException()
+
+        self.patch(darwin, "check_connected_state",
+                   fake_check_connected_state)
+        NetworkManagerState(self.expect_unknown)
+
+    def test_cant_create_target(self):
+        """SCNRCreateWithName returning None -> callback gets UNKNOWN."""
+        self.patch(darwin, "SCNRCreateWithName", lambda _1, _2: None)
+        nms = NetworkManagerState(self.expect_unknown)
+        # pylint: disable=W0212
+        nms._listen_on_separate_thread()
+
+    def test_cant_set_callback(self):
+        """SCNRSetCallback returning false -> callback gets UNKNOWN."""
+        self.patch(darwin, "SCNRSetCallback", lambda _1, _2, _3: False)
+        nms = NetworkManagerState(self.expect_unknown)
+        # pylint: disable=W0212
+        nms._listen_on_separate_thread()
+
+    def test_cant_schedule_with_runloop(self):
+        """SCNRScheduleWithRunLoop returning false -> callback gets UNKNOWN."""
+        self.patch(darwin, "SCNRScheduleWithRunLoop",
+                   lambda _1, _2, _3: False)
+        nms = NetworkManagerState(self.expect_unknown)
+        # pylint: disable=W0212
+        nms._listen_on_separate_thread()
+
+
+class TestReadingFlags(TestCase):
+    """Test interpretation of flags returned from SCNR API"""
+
+    def test_flag_reachable(self):
+        """Reachable by itself is OK."""
+        flag = REACHABLE_FLAG
+        self.assertTrue(flags_say_reachable(flag))
+
+    def test_flag_reachable_and_flag_connection_required(self):
+        """Reachable and connection-required is NOT OK"""
+        flag = REACHABLE_FLAG | CONNECTION_REQUIRED_FLAG
+        self.assertFalse(flags_say_reachable(flag))
+
+    def test_other_flagvals(self):
+        """All other flag configurations are false for our purposes.
+
+        They either indicate an iOS device, which we won't run this
+        code on, or that the server we're testing for is on this
+        machine or wired directly to it. These cases won't happen.
+        """
+        for flag in range(0, 17) + [1 << 16, 1 << 17, 1 << 18]:
+            # only test cases without the reachable bit set:
+            flag = flag & ~ 2
+            self.assertEqual(False, flags_say_reachable(flag))
+
+
+class TestNMSListeningForNWStateChanges(TestCase):
+    """
+    Test that the NetworkManagerState class calls the callback with
+    ONLINE/OFFLINE when the state changes appropriately
+    """
+
+    @inlineCallbacks
+    def setUp(self):
+        """Setup array to hold state changes."""
+        yield super(TestNMSListeningForNWStateChanges, self).setUp()
+        self.network_changes = []
+
+    def _listen_network_changes(self, state):
+        """Fake callback function, records state changes."""
+        self.network_changes.append(state)
+
+    def test_network_state_change(self):
+        """Test the changes in the network connection."""
+        nms = NetworkManagerState(self._listen_network_changes)
+        # pylint: disable=W0212
+        nms._state_changed(2)
+        nms._state_changed(0)            # 0 or anything other than 2.
+        nms._state_changed(2)
+
+        self.assertEqual(self.network_changes,
+            [ONLINE, OFFLINE, ONLINE])
+
+
+class TestIsMachineConnectedFunc(TestCase):
+    """Simple test of is_machine_connected."""
+
+    @inlineCallbacks
+    def test_not_connected_returns_false(self):
+        """test that False comes back False"""
+        self.patch(darwin, "check_connected_state",
+                   lambda: False)
+        con = yield is_machine_connected()
+        self.assertEqual(con, False)
+
+    @inlineCallbacks
+    def test_connected_returns_true(self):
+        """check that True comes back True"""
+        self.patch(darwin, "check_connected_state",
+                   lambda: True)
+        con = yield is_machine_connected()
+        self.assertEqual(con, True)

=== modified file 'ubuntu_sso/networkstate/tests/test_linux.py'
--- ubuntu_sso/networkstate/tests/test_linux.py	2012-04-19 19:29:37 +0000
+++ ubuntu_sso/networkstate/tests/test_linux.py	2012-06-05 14:23:23 +0000
@@ -55,7 +55,7 @@
     NM_STATE_UNKNOWN,
 )
 
-from ubuntu_sso.networkstate.linux import  (is_machine_connected,
+from ubuntu_sso.networkstate.linux import (is_machine_connected,
     DBUS_UNKNOWN_SERVICE,
     NM_DBUS_INTERFACE,
     NM_DBUS_OBJECTPATH,
@@ -178,98 +178,38 @@
         self.assertFalse(nms.state_signal.removed)
 
     @inlineCallbacks
-    def test_is_machine_connected_nm_state_connected_old(self):
-        """Fake the NetworkManagerState with connected return."""
-        self.patch(FakeNetworkManagerState, "connection_state",
-            NM_STATE_CONNECTED_OLD)
-        d = yield is_machine_connected()
-        self.assertTrue(d)
-
-    @inlineCallbacks
-    def test_is_machine_connected_nm_state_connected_global(self):
-        """Fake the NetworkManagerState with connected return."""
-        self.patch(FakeNetworkManagerState, "connection_state",
-            NM_STATE_CONNECTED_GLOBAL)
-        d = yield is_machine_connected()
-        self.assertTrue(d)
-
-    @inlineCallbacks
-    def test_is_machine_disconnected_nm_state_nm_state_unknown(self):
-        """Fake the NetworkManagerState with disconnected return."""
-        self.patch(FakeNetworkManagerState, "connection_state",
-            NM_STATE_UNKNOWN)
-        d = yield is_machine_connected()
-        self.assertFalse(d)
-
-    @inlineCallbacks
-    def test_is_machine_disconnected_nm_state_asleep_old(self):
-        """Fake the NetworkManagerState with disconnected return."""
-        self.patch(FakeNetworkManagerState, "connection_state",
-            NM_STATE_ASLEEP_OLD)
-        d = yield is_machine_connected()
-        self.assertFalse(d)
-
-    @inlineCallbacks
-    def test_is_machine_disconnected_nm_state_asleep(self):
-        """Fake the NetworkManagerState with disconnected return."""
-        self.patch(FakeNetworkManagerState, "connection_state",
-            NM_STATE_ASLEEP)
-        d = yield is_machine_connected()
-        self.assertFalse(d)
-
-    @inlineCallbacks
-    def test_is_machine_disconnected_nm_state_connecting_old(self):
-        """Fake the NetworkManagerState with disconnected return."""
-        self.patch(FakeNetworkManagerState, "connection_state",
-            NM_STATE_CONNECTING_OLD)
-        d = yield is_machine_connected()
-        self.assertFalse(d)
-
-    @inlineCallbacks
-    def test_is_machine_disconnected_nm_state_connecting(self):
-        """Fake the NetworkManagerState with disconnected return."""
-        self.patch(FakeNetworkManagerState, "connection_state",
-            NM_STATE_CONNECTING)
-        d = yield is_machine_connected()
-        self.assertFalse(d)
-
-    @inlineCallbacks
-    def test_is_machine_disconnected_nm_state_connected_local(self):
-        """Fake the NetworkManagerState with disconnected return."""
-        self.patch(FakeNetworkManagerState, "connection_state",
-            NM_STATE_CONNECTED_LOCAL)
-        d = yield is_machine_connected()
-        self.assertFalse(d)
-
-    @inlineCallbacks
-    def test_is_machine_disconnected_nm_state_connected_site(self):
-        """Fake the NetworkManagerState with disconnected return."""
-        self.patch(FakeNetworkManagerState, "connection_state",
-            NM_STATE_CONNECTED_SITE)
-        d = yield is_machine_connected()
-        self.assertFalse(d)
-
-    @inlineCallbacks
-    def test_is_machine_disconnected_nm_state_disconnected_old(self):
-        """Fake the NetworkManagerState with disconnected return."""
-        self.patch(FakeNetworkManagerState, "connection_state",
-            NM_STATE_DISCONNECTED_OLD)
-        d = yield is_machine_connected()
-        self.assertFalse(d)
-
-    @inlineCallbacks
-    def test_is_machine_disconnected_nm_state_disconnected(self):
-        """Fake the NetworkManagerState with disconnected return."""
-        self.patch(FakeNetworkManagerState, "connection_state",
-            NM_STATE_DISCONNECTED)
-        d = yield is_machine_connected()
-        self.assertFalse(d)
-
-    @inlineCallbacks
-    def test_is_machine_defer_error(self):
-        """Fake the NetworkManagerState with disconnected return."""
-        self.patch(FakeNetworkManagerState, "connection_state",
-            'no-int')
+    def test_is_machine_connected_nm_state_online(self):
+        """Callback given ONLINE should mean we are online"""
+        self.patch(FakeNetworkManagerState, "connection_state",
+                   ONLINE)
+        d = yield is_machine_connected()
+        self.assertTrue(d)
+
+    @inlineCallbacks
+    def test_is_machine_connected_nm_state_offline(self):
+        """Callback given OFFLINE should mean we are offline"""
+        self.patch(FakeNetworkManagerState, "connection_state",
+                   OFFLINE)
+        d = yield is_machine_connected()
+        self.assertFalse(d)
+
+    @inlineCallbacks
+    def test_is_machine_connected_nm_state_unknown(self):
+        """Callback given ONLINE should mean we are not online"""
+        self.patch(FakeNetworkManagerState, "connection_state",
+                   UNKNOWN)
+        d = yield is_machine_connected()
+        self.assertFalse(d)
+
+    @inlineCallbacks
+    def test_is_machine_connected_callback_error(self):
+        """Test bad argument to is_machine_connected's internal callback.
+
+        Passing anything other than ONLINE/OFFLINE/UNKNOWN should
+        cause an exception.
+        """
+        self.patch(FakeNetworkManagerState, "connection_state",
+                   NM_STATE_CONNECTED_GLOBAL)
         yield self.assertFailure(is_machine_connected(), NetworkFailException)
 
 
@@ -361,6 +301,18 @@
         super(NetworkManagerStateTestCase, self).setUp()
         self.connect_proxy()
 
+    def test_nm_asleep(self):
+        """Asleep status should mean offline."""
+        self.check_nm_state(self.assertOffline, NM_STATE_ASLEEP)
+
+    def test_nm_asleep_old(self):
+        """Asleep, old status, should mean offline."""
+        self.check_nm_state(self.assertOffline, NM_STATE_ASLEEP_OLD)
+
+    def test_nm_unknown(self):
+        """Unknown status should be treated the same as OFFLINE."""
+        self.check_nm_state(self.assertOffline, NM_STATE_UNKNOWN)
+
     def test_nm_online_old(self):
         """Check the connected, old status, case."""
         self.check_nm_state(self.assertOnline, NM_STATE_CONNECTED_OLD)

=== modified file 'ubuntu_sso/tests/test_account.py'
--- ubuntu_sso/tests/test_account.py	2012-04-09 17:38:24 +0000
+++ ubuntu_sso/tests/test_account.py	2012-06-05 14:23:23 +0000
@@ -34,7 +34,6 @@
 import os
 import urllib2
 
-from oauth import oauth
 from twisted.trial.unittest import TestCase
 from twisted.internet import defer
 
@@ -51,7 +50,6 @@
     ResetPasswordTokenError,
     SSO_STATUS_OK,
     SSO_STATUS_ERROR,
-    TimestampedAuthorizer,
 )
 from ubuntu_sso.tests import (
     APP_NAME,
@@ -203,36 +201,6 @@
             return defer.fail(e)
 
 
-class TimestampedAuthorizerTestCase(TestCase):
-    """Test suite for the TimestampedAuthorizer."""
-
-    def test_authorize_request_includes_timestamp(self):
-        """The authorizeRequest method includes the timestamp."""
-        fromcandt_call = []
-        fake_uri = "http://protocultura.net"
-        fake_timestamp = 1234
-        get_fake_timestamp = lambda: fake_timestamp
-        original_oauthrequest = oauth.OAuthRequest
-
-        class FakeOAuthRequest(oauth.OAuthRequest):
-            """A Fake OAuthRequest class."""
-
-            @staticmethod
-            def from_consumer_and_token(*args, **kwargs):
-                """A fake from_consumer_and_token."""
-                fromcandt_call.append((args, kwargs))
-                builder = original_oauthrequest.from_consumer_and_token
-                return builder(*args, **kwargs)
-
-        self.patch(oauth, "OAuthRequest", FakeOAuthRequest)
-
-        authorizer = TimestampedAuthorizer(get_fake_timestamp, "ubuntuone")
-        authorizer.authorizeRequest(fake_uri, "POST", None, {})
-        call_kwargs = fromcandt_call[0][1]
-        parameters = call_kwargs["parameters"]
-        self.assertEqual(parameters["oauth_timestamp"], fake_timestamp)
-
-
 class AccountTestCase(TestCase):
     """Test suite for the SSO login processor."""