Merge lp:~mikemc/ubuntu-sso-client/fix-networkstate-darwin into lp:ubuntu-sso-client

[Mike McCracken]

- Implement internet connectivity detection in Mac OS X ("darwin") systems ( LP #984667 )

- Implement internet connectivity detection in Mac OS X ("darwin") systems ( LP #984667 )

Implementation of network detection for darwin, including tests.

Uses a similar approach to the windows module, except instead of checking general internet connectivity, it specifically checks connectivity to one.ubuntu.com.
There's no general "connected" API in OS X, and I'm not sure there should be in Windows.

There are two API entry points:

1. The NetworkManagerState class spawns a separate python thread
for listening for callbacks from the system API, which then calls back
to user code with one of the states defined in
networkstate/networkstates.py.

2. The is_machine_connected() function, which returns a deferred that
calls the synchronous API to check the current connectivity once.

This branch includes two other changes:

1. run-nwmgr-standalone.py is a utility for testing this API live, but in
isolation. It should be platform-independent. Just run it and it will
report on connection status for 60 seconds.

2. networkstates.py now defines ONLINE, OFFLINE, and UNKNOWN as objects with meaningful __repr__s, so that test failure output makes sense.

This branch was marked as dependent on the no-darwin-in-linuxnwindows-tests branch because it introduces the test_darwin.py script that that branch guards against. Without that branch, this branch doesn't test well.

[Manuel de la Peña (mandel)]

When trying to run the tests on linux I get the following import error:

*** Running GTK test suite for ubuntu_sso ***
Traceback (most recent call last):
  File "/usr/local/bin/u1trial", line 325, in <module>
    main()
  File "/usr/local/bin/u1trial", line 305, in main
    suite = trial_runner.get_suite(config)
  File "/usr/local/bin/u1trial", line 184, in get_suite
    config['ignore-paths']))
  File "/usr/local/bin/u1trial", line 168, in _collect_tests
    module_suite = self._load_unittest(filepath)
  File "/usr/local/bin/u1trial", line 108, in _load_unittest
    module = __import__(modpath, None, None, [""])
  File "/home/mandel/Projects/Canonical/ubuntu-sso-client/fix-networkstate-darwin/ubuntu_sso/networkstate/tests/test_darwin.py", line 37, in <module>
    from ubuntu_sso.networkstate import (
  File "/home/mandel/Projects/Canonical/ubuntu-sso-client/fix-networkstate-darwin/ubuntu_sso/networkstate/darwin.py", line 55, in <module>
    CFRunLoopGetCurrent = CoreFoundation.CFRunLoopGetCurrent
  File "/usr/lib/python2.7/ctypes/__init__.py", line 378, in __getattr__
    func = self.__getitem__(name)
  File "/usr/lib/python2.7/ctypes/__init__.py", line 383, in __getitem__
    func = self._FuncPtr((name_or_ordinal, self))
AttributeError: /usr/bin/python: undefined symbol: CFRunLoopGetCurrent

Probably there is a missing module in the list of ingored modules

review: Needs Fixing

[lp:~mikemc/ubuntu-sso-client/fix-networkstate-darwin]

970. By Mike McCracken on 2012-05-16

merge with linux and windows test script branch so you can test this branch on linux and windows

[Mike McCracken (mikemc)]

> When trying to run the tests on linux I get the following import error:
>
> *** Running GTK test suite for ubuntu_sso ***

...snip...

> File "/home/mandel/Projects/Canonical/ubuntu-sso-client/fix-networkstate-
> darwin/ubuntu_sso/networkstate/darwin.py", line 55, in <module>
> CFRunLoopGetCurrent = CoreFoundation.CFRunLoopGetCurrent
> File "/usr/lib/python2.7/ctypes/__init__.py", line 378, in __getattr__
> func = self.__getitem__(name)
> File "/usr/lib/python2.7/ctypes/__init__.py", line 383, in __getitem__
> func = self._FuncPtr((name_or_ordinal, self))
> AttributeError: /usr/bin/python: undefined symbol: CFRunLoopGetCurrent
>
>
> Probably there is a missing module in the list of ingored modules

It's running the darwin tests. The prerequisite branch fixes this, and I've now merged with that branch with commit 970. Sorry for the inconvenience. I should've used the bzr pipeline plugin, I guess...

[Manuel de la Peña (mandel)]

> > When trying to run the tests on linux I get the following import error:
> >
> > *** Running GTK test suite for ubuntu_sso ***
>
> ...snip...
>
> > File "/home/mandel/Projects/Canonical/ubuntu-sso-client/fix-networkstate-
> > darwin/ubuntu_sso/networkstate/darwin.py", line 55, in <module>
> > CFRunLoopGetCurrent = CoreFoundation.CFRunLoopGetCurrent
> > File "/usr/lib/python2.7/ctypes/__init__.py", line 378, in __getattr__
> > func = self.__getitem__(name)
> > File "/usr/lib/python2.7/ctypes/__init__.py", line 383, in __getitem__
> > func = self._FuncPtr((name_or_ordinal, self))
> > AttributeError: /usr/bin/python: undefined symbol: CFRunLoopGetCurrent
> >
> >
> > Probably there is a missing module in the list of ingored modules
>
> It's running the darwin tests. The prerequisite branch fixes this, and I've
> now merged with that branch with commit 970. Sorry for the inconvenience. I
> should've used the bzr pipeline plugin, I guess...

No worries about that is a small details. After merging the other branch I get the following lint errors:

ubuntu_sso/networkstate/darwin.py:
    68: [C0301] Line too long (80/79)
    253: [C0301] Line too long (81/79)
    254: [C0301] Line too long (82/79)
    51: [C0103] Invalid name "CoreFoundationPath" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
    52: [C0103] Invalid name "CoreFoundation" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
    55: [C0103] Invalid name "CFRunLoopGetCurrent" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
    60: [C0103] Invalid name "CFRelease" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
    65: [C0103] Invalid name "CFRunLoopRun" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
    68: [C0103] Invalid name "kCFRunLoopDefaultMode" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
    68: [E1101] Class 'c_void_p' has no 'in_dll' member
    73: [C0103] Invalid name "SystemConfigurationPath" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
    82: [C0103] Invalid name "SCNRCreateWithName" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
    87: [C0103] Invalid name "SCNRGetFlags" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
    92: [C0103] Invalid name "SCNRScheduleWithRunLoop" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
    102: [C0103] Invalid name "SCNRCallbackType" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
    108: [C0103] Invalid name "SCNRSetCallback" (should match (([A-Z_][A-Z0-9_]*)|(__.*__))$)
    115: [C0111, _check_connected_state] Missing docstring
    145: [C0103, flags_say_reachable] Invalid name "kReachable" (should match [a-z_][a-z0-9_]{1,30}$)
    146: [C0103, flags_say_reachable] Invalid name "kConnectionRequired" (should match [a-z_][a-z0-9_]{1,30}$)
    270: [W0612, NetworkManagerState.find_online_state] Unused variable 'e'
    282: [W0703, is_machine_connected] Catching too general exception Exception
    23: [W0611] Unused import NM_STATE_DISCONNECTED_LIST
    30: [W0611] Unused import NM_STATE_CONNECTED_GLOBAL
    23: [W0611] Unused import NM_STATE_CONNECTED_LIST
    23: [W0611] Unused import NM_STATE_CONNECTING_LIST

ubuntu_sso/networkstate/networkstates.py:
    18: [C0111, NetworkState] Missing docstrin...

review: Needs Fixing

[lp:~mikemc/ubuntu-sso-client/fix-networkstate-darwin]

971. By Mike McCracken on 2012-05-17

fix dumb typo in tests that are only run on darwin

972. By Mike McCracken on 2012-05-18

Fix lint and pep8 complaints, improve some names and docstrings

973. By Mike McCracken on 2012-05-18

fix whitespace in blank lines that darwin lint didn't notice

974. By Mike McCracken on 2012-05-19

fixing yet another pep8 complaint missed by pep8 on darwin

[Manuel de la Peña (mandel)]

Can you fix the following details:

* if target == None: => if target is None
* if ok == False: => if not ok:
* if check_connected_state() == True => if check_connected_state():
* self.assertEqual(True, flags_say_reachable(flag)) => self.assertTrue(flags_say_reachable(flag))
* self.assertEqual(False, flags_say_reachable(flag)) => self.assertFalse(flags_say_reachable(flag))
* from ubuntu_sso.networkstate.darwin import flags_say_reachable => Can this be imported at the top of the file?

Tests and lint checks pass, please let me know when I can take another look.

review: Needs Fixing

[lp:~mikemc/ubuntu-sso-client/fix-networkstate-darwin]

975. By Mike McCracken on 2012-05-21

style fixes

[Manuel de la Peña (mandel)]

Looks good.

review: Approve

[Diego Sarmentero (diegosarmentero)]

+1

review: Approve

=== 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-05-21 14:51:18 +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/networkstates.py'
--- ubuntu_sso/networkstate/networkstates.py	2012-04-23 12:22:03 +0000
+++ ubuntu_sso/networkstate/networkstates.py	2012-05-21 14:51:18 +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-05-21 14:51:18 +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-05-21 14:51:18 +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)