Merge lp:~jpds/friends/linkedin-protocol into lp:friends

[Jonathan Davies]

Implemented a base LinkedIn protocol for friends.

Implemented a base LinkedIn protocol for friends.

[Robert Bruce Park (robru)]

MP into wrong branch ;-)

review: Needs Resubmitting

[lp:~jpds/friends/linkedin-protocol]

197. By Jonathan Davies on 2013-04-29

Gave url .get() a default value for robustness.

198. By Jonathan Davies on 2013-04-29

Save LinkedIn connections to EDS with _push_to_eds().

Unmerged revisions

=== modified file 'Makefile'
--- Makefile	2013-02-05 01:11:35 +0000
+++ Makefile	2013-03-25 10:33:12 +0000
@@ -14,7 +14,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 check:
-	python3 -m unittest discover -vv
+	python3 -m unittest discover
 
 install:
 	python3 setup.py install
 
=== modified file 'debian/changelog'
--- debian/changelog	2013-03-22 05:02:25 +0000
+++ debian/changelog	2013-03-25 10:33:12 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 friends (0.1.3daily13.03.22-0ubuntu1) raring; urgency=low
 
   * Automatic snapshot from revision 168
@@ -14,18 +15,30 @@
 
  -- Ubuntu daily release <[e-mail]>  Thu, 21 Mar 2013 05:02:17 +0000
 
+=======
+friends (0.2.0-0ubuntu2) UNRELEASED; urgency=low
+
+  [ Robert Bruce Park ]
+  * Version bump for the next development series.
+
+  [ Jonathan Davies ]
+  * Added friends-linkedin.
+
+ -- Jonathan Davies <[e-mail]>  Thu, 21 Mar 2013 22:52:07 +0000
+
+>>>>>>> MERGE-SOURCE
 friends (0.1.3daily13.03.20-0ubuntu1) raring; urgency=low
 
   [ Robert Bruce Park ]
   * Keep the Dispatcher alive for 30s beyond the return of the final
     method invocation.
-  * Stop deduplicating messages across protocols, simplifying model 
+  * Stop deduplicating messages across protocols, simplifying model
     schema (LP: #1156941)
   * Add schema columns for latitude, longitude, and location name.
   * Fix 'likes' column from gdouble to guint64.
   * Add geotagging support from foursquare, facebook, flickr.
   * Implement since= for Facebook, reducing bandwidth usage.
-  * Automatically prepend the required @mention to Twitter 
+  * Automatically prepend the required @mention to Twitter
     replies (LP: #1156829)
   * Automatically linkify URLs that get published to the model.
   * Fix the publishing of Facebook Stories (LP: #1155785)
 
=== modified file 'debian/control'
--- debian/control	2013-02-22 00:06:42 +0000
+++ debian/control	2013-03-25 10:33:12 +0000
@@ -103,3 +103,9 @@
 Depends: friends, ${misc:Depends}, ${python3:Depends}
 Description: Social integration with the desktop - Flickr
  Provides social networking integration with the desktop
+
+Package: friends-linkedin
+Architecture: all
+Depends: friends, ${misc:Depends}, ${python3:Depends}
+Description: Social integration with the desktop - LinkedIn
+ Provides social networking integration with the desktop
 
=== added file 'debian/friends-linkedin.install'
--- debian/friends-linkedin.install	1970-01-01 00:00:00 +0000
+++ debian/friends-linkedin.install	2013-03-25 10:33:12 +0000
@@ -0,0 +1,1 @@
+usr/lib/python3/dist-packages/friends/protocols/linkedin*
 
=== modified file 'friends/protocols/flickr.py'
--- friends/protocols/flickr.py	2013-03-12 21:08:21 +0000
+++ friends/protocols/flickr.py	2013-03-25 10:33:12 +0000
@@ -82,7 +82,7 @@
 # http://www.flickr.com/services/api/flickr.people.getInfo.html
     def _get_avatar(self, nsid):
         args = dict(
-            api_key=self._account.auth.parameters.get('ConsumerKey'),
+            api_key=self._account.consumer_key,
             method='flickr.people.getInfo',
             format='json',
             nojsoncallback='1',
@@ -109,7 +109,7 @@
         self._get_access_token()
 
         args = dict(
-            api_key=self._account.auth.parameters.get('ConsumerKey'),
+            api_key=self._account.consumer_key,
             method='flickr.photos.getContactsPhotos',
             format='json',
             nojsoncallback='1',
@@ -179,7 +179,7 @@
         self._get_access_token()
 
         args = dict(
-            api_key=self._account.auth.parameters.get('ConsumerKey'),
+            api_key=self._account.consumer_key,
             title=title,
             )
 
 
=== added file 'friends/protocols/linkedin.py'
--- friends/protocols/linkedin.py	1970-01-01 00:00:00 +0000
+++ friends/protocols/linkedin.py	2013-03-25 10:33:12 +0000
@@ -0,0 +1,133 @@
+# friends-dispatcher -- send & receive messages from any social network
+# Copyright (C) 2013  Canonical Ltd
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY 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/>.
+
+"""The LinkedIn protocol plugin."""
+
+
+__all__ = [
+    'LinkedIn',
+    ]
+
+import time
+import logging
+
+from friends.utils.avatar import Avatar
+from friends.utils.base import Base, feature
+from friends.utils.cache import JsonCache
+from friends.utils.http import Downloader, Uploader
+from friends.utils.time import parsetime, iso8601utc
+from friends.errors import FriendsError
+
+log = logging.getLogger(__name__)
+
+class LinkedIn(Base):
+    _api_base = 'https://api.linkedin.com/v1/{endpoint}?format=json&secure-urls=true&oauth2_access_token={token}'
+
+    def _whoami(self, authdata):
+        """Identify the authenticating user."""
+        # http://developer.linkedin.com/documents/profile-fields
+        url = self._api_base.format(
+            endpoint='people/~:(id,first-name,last-name)',
+            token=self._get_access_token())
+        result = Downloader(url).get_json()
+        self._account.user_id = result.get('id')
+        self._account.user_full_name = '{firstName} {lastName}'.format(**result)
+        
+    def _publish_entry(self, entry, stream='messages'):
+        """Publish a single update into the Dee.SharedModel."""
+        message_id = entry.get('updateKey')
+
+        if message_id is None:
+            # We can't do much with this entry.
+            return
+           
+        content = entry.get('updateContent')
+        person = content.get('person')
+        name = '{firstName} {lastName}'.format(**person)
+        person_id = person.get('id')
+        status = person.get('currentStatus')
+        picture = person.get('pictureUrl', '')
+        url = person.get('siteStandardProfileRequest').get('url')
+        timestamp = entry.get('timestamp')
+        # We need to divide by 1000 here, as LinkedIn's timestamps have
+        # milliseconds.
+        iso_time = iso8601utc(int(timestamp/1000))
+        
+        # Posts gives us a likes dict, while replies give us an int.
+        likes = entry.get('numLikes', 0)
+        
+        args = dict(
+             message_id=message_id,
+             stream=stream,
+             message=status,
+             likes=likes,
+             sender_id=person_id,
+             sender=name,
+             icon_uri=picture,
+             link_url=url,
+             timestamp=iso_time
+             )
+             
+        self._publish(**args)
+
+    @feature    
+    def home(self):
+        """Gather and publish public timeline messages."""
+        url = self._api_base.format(
+            endpoint='people/~/network/updates',
+            token=self._get_access_token()) + '&type=STAT'
+        result = Downloader(url).get_json()
+        values = result.get('values')
+        for update in values:
+            self._publish_entry(update)
+    
+    @feature
+    def receive(self):
+        """Gather and publish all incoming messages."""
+        self.home()
+        return self._get_n_rows()
+        
+    def _create_contact(self, connection_json):
+        """Build a VCard based on a dict representation of a contact."""
+        user_id = connection_json.get('id')
+            
+        user_fullname = '{firstName} {lastName}'.format(**connection_json)
+        user_link = connection_json.get('siteStandardProfileRequest').get('url')
+        
+        attrs = {}
+        attrs['linkined-id'] = user_id
+        attrs['linkedin-name'] = user_fullname
+        attrs['X-URIS'] = user_link
+        
+        contact = Base._create_contact(
+            self, user_fullname, None, attrs)
+        
+        return contact
+    
+    @feature
+    def contacts(self):
+        """Retrieve a list of up to 500 LinkedIn connections."""
+        # http://developer.linkedin.com/documents/connections-api
+        url = self._api_base.format(
+            endpoint='people/~/connections',
+            token=self._get_access_token())
+        result = Downloader(url).get_json()
+        connections = result.get('values')
+        
+        for connection in connections:
+            if connection.get('id') != 'private':
+                # We cannot access information on profiles that are set to
+                # private.
+                self._create_contact(connection)
 
=== modified file 'friends/service/dispatcher.py'
--- friends/service/dispatcher.py	2013-03-20 01:19:39 +0000
+++ friends/service/dispatcher.py	2013-03-25 10:33:12 +0000
@@ -31,7 +31,7 @@
 from contextlib import ContextDecorator
 
 from friends.utils.avatar import Avatar
-from friends.utils.account import AccountManager
+from friends.utils.account import find_accounts
 from friends.utils.manager import protocol_manager
 from friends.utils.menus import MenuManager
 from friends.utils.model import Model, persist_model
@@ -96,7 +96,8 @@
         bus_name = dbus.service.BusName(DBUS_INTERFACE, bus=self.bus)
         super().__init__(bus_name, self.__dbus_object_path__)
         self.mainloop = mainloop
-        self.account_manager = AccountManager()
+
+        self.accounts = find_accounts()
 
         self._unread_count = 0
         self.menu_manager = MenuManager(self.Refresh, self.mainloop.quit)
@@ -119,7 +120,7 @@
         # account.protocol() starts a new thread and then returns
         # immediately, so there is no delay or blocking during the
         # execution of this method.
-        for account in self.account_manager.get_all():
+        for account in self.accounts.values():
             try:
                 account.protocol('receive')
             except NotImplementedError:
@@ -163,14 +164,14 @@
             service.Do('list', '6', 'list_id') # Fetch a single list.
         """
         if account_id:
-            accounts = [self.account_manager.get(account_id)]
+            accounts = [self.accounts.get(int(account_id))]
             if None in accounts:
                 message = 'Could not find account: {}'.format(account_id)
                 failure(message)
                 log.error(message)
                 return
         else:
-            accounts = list(self.account_manager.get_all())
+            accounts = list(self.accounts.values())
 
         called = False
         for account in accounts:
@@ -205,7 +206,7 @@
             service.SendMessage('Your message')
         """
         sent = False
-        for account in self.account_manager.get_all():
+        for account in self.accounts.values():
             if account.send_enabled:
                 sent = True
                 log.debug(
@@ -240,7 +241,7 @@
             service.SendReply('6', '34245645347345626', 'Your reply')
         """
         log.debug('Replying to {}, {}'.format(account_id, message_id))
-        account = self.account_manager.get(account_id)
+        account = self.accounts.get(int(account_id))
         if account is not None:
             account.protocol(
                 'send_thread',
@@ -298,7 +299,7 @@
         free to ignore error conditions at your peril.
         """
         log.debug('Uploading {} to {}'.format(uri, account_id))
-        account = self.account_manager.get(account_id)
+        account = self.accounts.get(int(account_id))
         if account is not None:
             account.protocol(
                 'upload',
 
=== modified file 'friends/tests/mocks.py'
--- friends/tests/mocks.py	2013-03-14 19:44:13 +0000
+++ friends/tests/mocks.py	2013-03-25 10:33:12 +0000
@@ -100,16 +100,21 @@
 
 
 class FakeAuth:
-    id = 'fakeauth id'
-    method = 'fakeauth method'
-    parameters = {'ConsumerKey': 'fake', 'ConsumerSecret': 'alsofake'}
-    mechanism = 'fakeauth mechanism'
+    get_credentials_id = lambda *ignore: 'fakeauth id'
+    get_method = lambda *ignore: 'fakeauth method'
+    get_mechanism = lambda *ignore: 'fakeauth mechanism'
+    get_parameters = lambda *ignore: {
+        'ConsumerKey': 'fake',
+        'ConsumerSecret': 'alsofake',
+        }
 
 
 class FakeAccount:
     """A fake account object for testing purposes."""
 
     def __init__(self, service=None, account_id=88):
+        self.consumer_secret = 'secret'
+        self.consumer_key = 'consume'
         self.access_token = None
         self.secret_token = None
         self.user_full_name = None
 
=== modified file 'friends/tests/test_account.py'
--- friends/tests/test_account.py	2013-03-14 19:14:03 +0000
+++ friends/tests/test_account.py	2013-03-25 10:33:12 +0000
@@ -17,7 +17,6 @@
 
 __all__ = [
     'TestAccount',
-    'TestAccountManager',
     ]
 
 
@@ -26,14 +25,15 @@
 from friends.errors import UnsupportedProtocolError
 from friends.protocols.flickr import Flickr
 from friends.tests.mocks import FakeAccount, LogMock, SettingsIterMock
-from friends.tests.mocks import TestModel, mock
-from friends.utils.account import Account, AccountManager
+from friends.tests.mocks import TestModel, LogMock, mock
+from friends.utils.account import Account, _find_accounts_uoa
 
 
 class TestAccount(unittest.TestCase):
     """Test Account class."""
 
     def setUp(self):
+        self.log_mock = LogMock('friends.utils.account')
         def connect_side_effect(signal, callback, account):
             # The account service provides a .connect method that connects a
             # signal to a callback.  We have to mock a side effect into the
@@ -49,7 +49,9 @@
                 'get_credentials_id.return_value': 'fake credentials',
                 'get_method.return_value': 'fake method',
                 'get_mechanism.return_value': 'fake mechanism',
-                'get_parameters.return_value': 'fake parameters',
+                'get_parameters.return_value': {
+                            'ConsumerKey': 'fake_key',
+                            'ConsumerSecret': 'fake_secret'},
                 }),
             'get_account.return_value': mock.Mock(**{
                 'get_settings_iter.return_value': SettingsIterMock(),
@@ -63,17 +65,21 @@
             })
         self.account = Account(self.account_service)
 
+    def tearDown(self):
+        self.log_mock.stop()
+
     def test_account_auth(self):
         # Test that the constructor initializes the 'auth' attribute.
         auth = self.account.auth
-        self.assertEqual(auth.id, 'fake credentials')
-        self.assertEqual(auth.method, 'fake method')
-        self.assertEqual(auth.mechanism, 'fake mechanism')
-        self.assertEqual(auth.parameters, 'fake parameters')
+        self.assertEqual(auth.get_credentials_id(), 'fake credentials')
+        self.assertEqual(auth.get_method(), 'fake method')
+        self.assertEqual(auth.get_mechanism(), 'fake mechanism')
+        self.assertEqual(auth.get_parameters(),
+                         dict(ConsumerKey='fake_key',
+                              ConsumerSecret='fake_secret'))
 
     def test_account_id(self):
         self.assertEqual(self.account.id, 'fake_id')
-        self.assertEqual(self.account.protocol_name, 'flickr')
 
     def test_account_service(self):
         # The protocol attribute refers directly to the protocol used.
@@ -122,102 +128,18 @@
         self.assertFalse(hasattr(self.account, 'bee'))
         self.assertFalse(hasattr(self.account, 'cat'))
 
-    def test_enabled(self):
-        # .enabled() just passes through from the account service.
-        self.account_service.get_enabled.return_value = True
-        self.assertTrue(self.account.enabled)
-        self.account_service.get_enabled.return_value = False
-        self.assertFalse(self.account.enabled)
-
-    def test_equal(self):
-        # Two accounts are equal if their account services are equal.
-        other = Account(self.account_service)
-        self.assertEqual(self.account, other)
-        assert not self.account == None
-
-    def test_unequal(self):
-        # Two accounts are unequal if their account services are unequal.  The
-        # other mock service has to at least support the basic required API.
-        other = Account(mock.Mock(**{
-            'get_account.return_value': mock.Mock(**{
-                'get_settings_iter.return_value': SettingsIterMock(),
-                    # It's okay if the provider names are the same; the test
-                    # is for whether the account services are the same or not,
-                    # and in this test, they'll be different mock instances.
-                    'get_provider_name.return_value': 'flickr',
-                }),
-            }))
-        self.assertNotEqual(self.account, other)
-        assert self.account != None
-
-
-accounts_manager = mock.Mock()
-accounts_manager.new_for_service_type(
-    'microblogging').get_enabled_account_services.return_value = []
-
-
[e-mail]('gi.repository.Accounts.Manager', accounts_manager)
[e-mail]('friends.utils.account.Account', FakeAccount)
-class TestAccountManager(unittest.TestCase):
-    """Test the AccountManager API."""
-
-    def setUp(self):
-        TestModel.clear()
-        self.account_service = mock.Mock()
-
+    @mock.patch('friends.utils.account.manager')
+    @mock.patch('friends.utils.account.Account')
     @mock.patch('friends.utils.account.Accounts')
-    def test_get_service(self, accounts_mock):
-        manager = AccountManager()
-        manager_mock = mock.Mock()
-        account_mock = mock.Mock()
-        service_mock = mock.Mock()
-        manager_mock.get_account.return_value = account_mock
-        account_mock.list_services.return_value = [service_mock]
-        account_service_mock = accounts_mock.AccountService.new(account_mock,
-                                                                service_mock)
-        account_service_mock.get_service(
-            ).get_display_name().lower.return_value = 'protocol'
-
-        service = manager._get_service(manager_mock, 10)
-
-        manager_mock.get_account.assert_called_once_with(10)
-        account_mock.list_services.assert_called_once_with()
-        accounts_mock.AccountService.new.assert_called_with(account_mock,
-                                                            service_mock)
-
-    def test_account_manager_add_new_account(self):
-        # Explicitly adding a new account puts the account's global_id into
-        # the account manager's mapping.
-        manager = AccountManager()
-        manager._add_new_account(self.account_service)
-        self.assertIn(88, manager._accounts)
-
-    def test_account_manager_enabled_event(self):
-        manager = AccountManager()
-        manager._get_service = mock.Mock()
-        manager._get_service.return_value = mock.Mock()
-        manager._add_new_account = mock.Mock()
-        manager._add_new_account.return_value = account = mock.Mock()
-        manager._on_enabled_event(accounts_manager, 2)
-        account.protocol.assert_called_once_with('receive')
-
-
[e-mail]('gi.repository.Accounts.Manager', accounts_manager)
-class TestAccountManagerRealAccount(unittest.TestCase):
-    """Test of the AccountManager API requiring the real Account class.
-
-    You'll need to guarantee other mocks are in place such that the real
-    accounts are not touched.
-    """
-    def setUp(self):
-        self.account_service = mock.Mock()
-
-    def test_account_manager_add_new_account_unsupported(self):
-        fake_account = self.account_service.get_account()
-        fake_account.get_provider_name.return_value = 'no service'
-        manager = AccountManager()
-        with LogMock('friends.utils.account') as log_mock:
-            manager._add_new_account(self.account_service)
-            log_contents = log_mock.empty(trim=False)
-        self.assertNotIn('no service', manager._accounts)
-        self.assertEqual(log_contents, 'Unsupported protocol: no service\n')
+    def test_find_accounts(self, accts, acct, manager):
+        service = mock.Mock()
+        get_enabled = manager.get_enabled_account_services
+        get_enabled.return_value = [service]
+        manager.reset_mock()
+        accounts = _find_accounts_uoa()
+        get_enabled.assert_called_once_with()
+        acct.assert_called_once_with(service)
+        self.assertEqual(accounts, {acct().id: acct()})
+        self.assertEqual(self.log_mock.empty(),
+                         'Flickr (fake_id) got send_enabled: True\n'
+                         'Accounts found: 1\n')
 
=== modified file 'friends/tests/test_authentication.py'
--- friends/tests/test_authentication.py	2013-02-05 01:11:35 +0000
+++ friends/tests/test_authentication.py	2013-03-25 10:33:12 +0000
@@ -27,7 +27,7 @@
 import unittest
 
 from friends.utils.authentication import Authentication
-from friends.tests.mocks import FakeAccount, mock
+from friends.tests.mocks import FakeAccount, LogMock, mock
 from friends.errors import AuthorizationError
 
 
@@ -43,7 +43,11 @@
         # error, and user_data arguments.  We'll use the parameters
         # argument as a way to specify whether an error occurred during
         # authentication or not.
-        callback(None, self.results, parameters, None)
+        callback(
+            None,
+            self.results,
+            parameters if hasattr(parameters, 'message') else None,
+            None)
 
 
 class FakeSignon:
@@ -56,59 +60,49 @@
         results = dict(NoAccessToken='fail')
 
 
-class Logger:
-    def __init__(self):
-        self.debug_messages = []
-        self.error_messages = []
-
-    def debug(self, message, *args):
-        self.debug_messages.append(message.format(*args))
-
-    def error(self, message, *args):
-        self.error_messages.append(message.format(*args))
-
-    reset = __init__
-
-
-logger = Logger()
-
-
 class TestAuthentication(unittest.TestCase):
     """Test authentication."""
 
     def setUp(self):
+        self.log_mock = LogMock('friends.utils.authentication')
         self.account = FakeAccount()
-        self.account.auth.id = 'my id'
-        self.account.auth.method = 'some method'
-        self.account.auth.parameters = 'change me'
-        self.account.auth.mechanism = ['whatever']
-        logger.reset()
-
-    @mock.patch('friends.utils.authentication.log', logger)
+        self.account.auth.get_credentials_id = lambda *ignore: 'my id'
+        self.account.auth.get_method = lambda *ignore: 'some method'
+        self.account.auth.get_parameters = lambda *ignore: 'change me'
+        self.account.auth.get_mechanism = lambda *ignore: 'whatever'
+
+    def tearDown(self):
+        self.log_mock.stop()
+
+    @mock.patch('friends.utils.authentication.manager')
     @mock.patch('friends.utils.authentication.Signon', FakeSignon)
-    def test_successful_login(self):
+    @mock.patch('friends.utils.authentication.Accounts')
+    def test_successful_login(self, accounts, *mocks):
         # Prevent an error in the callback.
-        self.account.auth.parameters = False
-        authenticator = Authentication(self.account)
+        accounts.AccountService.new().get_auth_data(
+            ).get_parameters.return_value = False
+        authenticator = Authentication(self.account.id)
         reply = authenticator.login()
         self.assertEqual(reply, dict(AccessToken='auth reply'))
-        self.assertEqual(logger.debug_messages, ['Login completed'])
-        self.assertEqual(logger.error_messages, [])
+        self.assertEqual(self.log_mock.empty(), 'Login completed\n')
 
-    @mock.patch('friends.utils.authentication.log', logger)
+    @mock.patch('friends.utils.authentication.manager')
+    @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch('friends.utils.authentication.Signon', FailingSignon)
-    def test_missing_access_token(self):
+    def test_missing_access_token(self, *mocks):
         # Prevent an error in the callback.
-        self.account.auth.parameters = False
-        authenticator = Authentication(self.account)
+        self.account.auth.get_parameters = lambda *ignore: False
+        authenticator = Authentication(self.account.id)
         self.assertRaises(AuthorizationError, authenticator.login)
 
-    @mock.patch('friends.utils.authentication.log', logger)
+    @mock.patch('friends.utils.authentication.manager')
     @mock.patch('friends.utils.authentication.Signon', FakeSignon)
-    def test_failed_login(self):
+    @mock.patch('friends.utils.authentication.Accounts')
+    def test_failed_login(self, accounts, *mocks):
         # Trigger an error in the callback.
         class Error:
             message = 'who are you?'
-        self.account.auth.parameters = Error
-        authenticator = Authentication(self.account)
+        accounts.AccountService.new(
+            ).get_auth_data().get_parameters.return_value = Error
+        authenticator = Authentication(self.account.id)
         self.assertRaises(AuthorizationError, authenticator.login)
 
=== modified file 'friends/tests/test_dispatcher.py'
--- friends/tests/test_dispatcher.py	2013-03-20 01:19:39 +0000
+++ friends/tests/test_dispatcher.py	2013-03-25 10:33:12 +0000
@@ -38,13 +38,13 @@
     """Test the dispatcher's ability to dispatch."""
 
     @mock.patch('dbus.service.BusName')
-    @mock.patch('friends.service.dispatcher.AccountManager')
-    @mock.patch('friends.service.dispatcher.Dispatcher.Refresh')
+    @mock.patch('friends.service.dispatcher.find_accounts')
     @mock.patch('dbus.service.Object.__init__')
     def setUp(self, *mocks):
         self.log_mock = LogMock('friends.service.dispatcher',
                                 'friends.utils.account')
         self.dispatcher = Dispatcher(mock.Mock(), mock.Mock())
+        self.dispatcher.accounts = {}
 
     def tearDown(self):
         self.log_mock.stop()
@@ -53,12 +53,12 @@
     def test_refresh(self, threading_mock):
         account = mock.Mock()
         threading_mock.activeCount.return_value = 1
-        self.dispatcher.account_manager = mock.Mock()
-        self.dispatcher.account_manager.get_all.return_value = [account]
+        self.dispatcher.accounts = mock.Mock()
+        self.dispatcher.accounts.values.return_value = [account]
 
         self.assertIsNone(self.dispatcher.Refresh())
 
-        self.dispatcher.account_manager.get_all.assert_called_once_with()
+        self.dispatcher.accounts.values.assert_called_once_with()
         account.protocol.assert_called_once_with('receive')
 
         self.assertEqual(self.log_mock.empty(),
@@ -75,12 +75,11 @@
     def test_do(self):
         account = mock.Mock()
         account.id = '345'
-        self.dispatcher.account_manager = mock.Mock()
-        self.dispatcher.account_manager.get.return_value = account
+        self.dispatcher.accounts = mock.Mock()
+        self.dispatcher.accounts.get.return_value = account
 
         self.dispatcher.Do('like', '345', '23346356767354626')
-        self.dispatcher.account_manager.get.assert_called_once_with(
-            '345')
+        self.dispatcher.accounts.get.assert_called_once_with(345)
         account.protocol.assert_called_once_with(
             'like', '23346356767354626', success=STUB, failure=STUB)
 
@@ -92,11 +91,11 @@
 
     def test_failing_do(self):
         account = mock.Mock()
-        self.dispatcher.account_manager = mock.Mock()
-        self.dispatcher.account_manager.get.return_value = None
+        self.dispatcher.accounts = mock.Mock()
+        self.dispatcher.accounts.get.return_value = None
 
         self.dispatcher.Do('unlike', '6', '23346356767354626')
-        self.dispatcher.account_manager.get.assert_called_once_with('6')
+        self.dispatcher.accounts.get.assert_called_once_with(6)
         self.assertEqual(account.protocol.call_count, 0)
 
         self.assertEqual(self.log_mock.empty(),
@@ -111,15 +110,15 @@
         account3 = mock.Mock()
         account2.send_enabled = False
 
-        self.dispatcher.account_manager = mock.Mock()
-        self.dispatcher.account_manager.get_all.return_value = [
+        self.dispatcher.accounts = mock.Mock()
+        self.dispatcher.accounts.values.return_value = [
             account1,
             account2,
             account3,
             ]
 
         self.dispatcher.SendMessage('Howdy friends!')
-        self.dispatcher.account_manager.get_all.assert_called_once_with()
+        self.dispatcher.accounts.values.assert_called_once_with()
         account1.protocol.assert_called_once_with(
             'send', 'Howdy friends!', success=STUB, failure=STUB)
         account3.protocol.assert_called_once_with(
@@ -128,11 +127,11 @@
 
     def test_send_reply(self):
         account = mock.Mock()
-        self.dispatcher.account_manager = mock.Mock()
-        self.dispatcher.account_manager.get.return_value = account
+        self.dispatcher.accounts = mock.Mock()
+        self.dispatcher.accounts.get.return_value = account
 
         self.dispatcher.SendReply('2', 'objid', '[Hilarious Response]')
-        self.dispatcher.account_manager.get.assert_called_once_with('2')
+        self.dispatcher.accounts.get.assert_called_once_with(2)
         account.protocol.assert_called_once_with(
             'send_thread', 'objid', '[Hilarious Response]',
             success=STUB, failure=STUB)
@@ -145,11 +144,11 @@
 
     def test_send_reply_failed(self):
         account = mock.Mock()
-        self.dispatcher.account_manager = mock.Mock()
-        self.dispatcher.account_manager.get.return_value = None
+        self.dispatcher.accounts = mock.Mock()
+        self.dispatcher.accounts.get.return_value = None
 
         self.dispatcher.SendReply('2', 'objid', '[Hilarious Response]')
-        self.dispatcher.account_manager.get.assert_called_once_with('2')
+        self.dispatcher.accounts.get.assert_called_once_with(2)
         self.assertEqual(account.protocol.call_count, 0)
 
         self.assertEqual(self.log_mock.empty(),
@@ -161,8 +160,8 @@
 
     def test_upload_async(self):
         account = mock.Mock()
-        self.dispatcher.account_manager = mock.Mock()
-        self.dispatcher.account_manager.get.return_value = account
+        self.dispatcher.accounts = mock.Mock()
+        self.dispatcher.accounts.get.return_value = account
 
         success = mock.Mock()
         failure = mock.Mock()
@@ -172,7 +171,7 @@
                                'A thousand words',
                                success=success,
                                failure=failure)
-        self.dispatcher.account_manager.get.assert_called_once_with('2')
+        self.dispatcher.accounts.get.assert_called_once_with(2)
         account.protocol.assert_called_once_with(
             'upload',
             'file://path/to/image.png',
 
=== modified file 'friends/tests/test_facebook.py'
--- friends/tests/test_facebook.py	2013-03-16 00:54:45 +0000
+++ friends/tests/test_facebook.py	2013-03-25 10:33:12 +0000
@@ -60,11 +60,13 @@
             ['contacts', 'delete', 'home', 'like', 'receive', 'search', 'send',
              'send_thread', 'unlike', 'upload', 'wall'])
 
+    @mock.patch('friends.utils.authentication.manager')
+    @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch('friends.utils.authentication.Authentication.login',
                 return_value=dict(AccessToken='abc'))
     @mock.patch('friends.utils.http.Soup.Message',
                 FakeSoupMessage('friends.tests.data', 'facebook-login.dat'))
-    def test_successful_login(self, mock):
+    def test_successful_login(self, *mocks):
         # Test that a successful response from graph.facebook.com returning
         # the user's data, sets up the account dict correctly.
         self.protocol._login()
@@ -72,14 +74,18 @@
         self.assertEqual(self.account.user_name, 'Bart Person')
         self.assertEqual(self.account.user_id, '801')
 
+    @mock.patch('friends.utils.authentication.manager')
+    @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch.dict('friends.utils.authentication.__dict__', LOGIN_TIMEOUT=1)
     @mock.patch('friends.utils.authentication.Signon.AuthSession.new')
-    def test_login_unsuccessful_authentication(self, mock):
+    def test_login_unsuccessful_authentication(self, *mocks):
         # The user is not already logged in, but the act of logging in fails.
         self.assertRaises(AuthorizationError, self.protocol._login)
         self.assertIsNone(self.account.access_token)
         self.assertIsNone(self.account.user_name)
 
+    @mock.patch('friends.utils.authentication.manager')
+    @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch('friends.utils.authentication.Authentication.login',
                 return_value=dict(AccessToken='abc'))
     @mock.patch('friends.protocols.facebook.Downloader.get_json',
@@ -237,9 +243,6 @@
     def test_home_since_id(self, *mocks):
         self.account.access_token = 'access'
         self.account.secret_token = 'secret'
-        self.account.auth.parameters = dict(
-            ConsumerKey='key',
-            ConsumerSecret='secret')
         self.assertEqual(self.protocol.home(), 12)
 
         with open(self._root.format('facebook_ids'), 'r') as fd:
 
=== modified file 'friends/tests/test_flickr.py'
--- friends/tests/test_flickr.py	2013-03-20 23:57:40 +0000
+++ friends/tests/test_flickr.py	2013-03-25 10:33:12 +0000
@@ -86,6 +86,8 @@
         # But also no photos.
         self.assertEqual(TestModel.get_n_rows(), 0)
 
+    @mock.patch('friends.utils.authentication.manager')
+    @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch.dict('friends.utils.authentication.__dict__', LOGIN_TIMEOUT=1)
     @mock.patch('friends.utils.authentication.Signon.AuthSession.new')
     @mock.patch('friends.utils.http.Soup.Message',
@@ -95,6 +97,8 @@
         # AccessToken, but this fails.
         self.assertRaises(AuthorizationError, self.protocol.receive)
 
+    @mock.patch('friends.utils.authentication.manager')
+    @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch('friends.utils.http.Soup.Message',
                 FakeSoupMessage('friends.tests.data', 'flickr-nophotos.dat'))
     @mock.patch('friends.utils.authentication.Authentication.login',
@@ -102,7 +106,7 @@
                                   user_nsid='bob',
                                   AccessToken='123',
                                   TokenSecret='abc'))
-    def test_login_successful_authentication(self, mock):
+    def test_login_successful_authentication(self, *mocks):
         # Logging in required communication with the account service to get an
         # AccessToken, but this fails.
         self.protocol.receive()
@@ -131,7 +135,7 @@
                 extras='date_upload,owner_name,icon_server,geo',
                 format='json',
                 nojsoncallback='1',
-                api_key='fake',
+                api_key='consume',
                 method='flickr.photos.getContactsPhotos',
                 ),
             headers={})
 
=== modified file 'friends/tests/test_foursquare.py'
--- friends/tests/test_foursquare.py	2013-03-14 19:14:03 +0000
+++ friends/tests/test_foursquare.py	2013-03-25 10:33:12 +0000
@@ -50,6 +50,8 @@
         # The set of public features.
         self.assertEqual(FourSquare.get_features(), ['receive'])
 
+    @mock.patch('friends.utils.authentication.manager')
+    @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch.dict('friends.utils.authentication.__dict__', LOGIN_TIMEOUT=1)
     @mock.patch('friends.utils.authentication.Signon.AuthSession.new')
     @mock.patch('friends.utils.http.Downloader.get_json',
@@ -59,6 +61,8 @@
         self.assertIsNone(self.account.user_name)
         self.assertIsNone(self.account.user_id)
 
+    @mock.patch('friends.utils.authentication.manager')
+    @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch('friends.utils.authentication.Authentication.login',
                 return_value=dict(AccessToken='tokeny goodness'))
     @mock.patch('friends.protocols.foursquare.Downloader.get_json',
 
=== modified file 'friends/tests/test_identica.py'
--- friends/tests/test_identica.py	2013-03-14 19:14:03 +0000
+++ friends/tests/test_identica.py	2013-03-25 10:33:12 +0000
@@ -53,6 +53,8 @@
         self.log_mock.stop()
         shutil.rmtree(self._temp_cache)
 
+    @mock.patch('friends.utils.authentication.manager')
+    @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch.dict('friends.utils.authentication.__dict__', LOGIN_TIMEOUT=1)
     @mock.patch('friends.utils.authentication.Signon.AuthSession.new')
     @mock.patch('friends.utils.http.Downloader.get_json',
@@ -62,6 +64,8 @@
         self.assertIsNone(self.account.user_name)
         self.assertIsNone(self.account.user_id)
 
+    @mock.patch('friends.utils.authentication.manager')
+    @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch('friends.utils.authentication.Authentication.login',
                 return_value=dict(AccessToken='some clever fake data',
                                   TokenSecret='sssssshhh!'))
 
=== modified file 'friends/tests/test_twitter.py'
--- friends/tests/test_twitter.py	2013-03-19 04:17:58 +0000
+++ friends/tests/test_twitter.py	2013-03-25 10:33:12 +0000
@@ -57,15 +57,19 @@
         self.log_mock.stop()
         shutil.rmtree(self._temp_cache)
 
+    @mock.patch('friends.utils.authentication.manager')
+    @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch.dict('friends.utils.authentication.__dict__', LOGIN_TIMEOUT=1)
     @mock.patch('friends.utils.authentication.Signon.AuthSession.new')
     @mock.patch('friends.protocols.twitter.Downloader.get_json',
                 return_value=None)
-    def test_unsuccessful_authentication(self, dload, login):
+    def test_unsuccessful_authentication(self, dload, login, *mocks):
         self.assertRaises(AuthorizationError, self.protocol._login)
         self.assertIsNone(self.account.user_name)
         self.assertIsNone(self.account.user_id)
 
+    @mock.patch('friends.utils.authentication.manager')
+    @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch('friends.utils.authentication.Authentication.login',
                 return_value=dict(AccessToken='some clever fake data',
                                   TokenSecret='sssssshhh!',
@@ -86,11 +90,12 @@
     def test_signatures(self, dload):
         self.account.secret_token = 'alpha'
         self.account.access_token = 'omega'
-        self.account.auth.id = 6
-        self.account.auth.method = 'oauth2'
-        self.account.auth.mechanism = 'HMAC-SHA1'
-        self.account.auth.parameters = dict(ConsumerKey='consume',
-                                            ConsumerSecret='obey')
+        self.account.consumer_secret = 'obey'
+        self.account.consumer_key = 'consume'
+        self.account.auth.get_credentials_id = lambda *ignore: 6
+        self.account.auth.get_method = lambda *ignore: 'oauth2'
+        self.account.auth.get_mechanism = lambda *ignore: 'HMAC-SHA1'
+
         result = '''\
 OAuth oauth_nonce="once%20upon%20a%20nonce", \
 oauth_timestamp="1348690628", \
@@ -122,9 +127,6 @@
     def test_home(self, *mocks):
         self.account.access_token = 'access'
         self.account.secret_token = 'secret'
-        self.account.auth.parameters = dict(
-            ConsumerKey='key',
-            ConsumerSecret='secret')
         self.assertEqual(0, TestModel.get_n_rows())
         self.assertEqual(self.protocol.home(), 3)
         self.assertEqual(3, TestModel.get_n_rows())
@@ -171,9 +173,6 @@
     def test_home_since_id(self, *mocks):
         self.account.access_token = 'access'
         self.account.secret_token = 'secret'
-        self.account.auth.parameters = dict(
-            ConsumerKey='key',
-            ConsumerSecret='secret')
         self.assertEqual(self.protocol.home(), 3)
 
         with open(self._root.format('twitter_ids'), 'r') as fd:
@@ -196,9 +195,6 @@
         self.account.access_token = 'access'
         self.account.secret_token = 'secret'
         self.account.user_name = 'oauth_dancer'
-        self.account.auth.parameters = dict(
-            ConsumerKey='key',
-            ConsumerSecret='secret')
         self.assertEqual(0, TestModel.get_n_rows())
         self.assertEqual(
             self.protocol.send('some message'),
@@ -399,9 +395,6 @@
     def test_send_thread_prepend_nick(self, *mocks):
         self.account.access_token = 'access'
         self.account.secret_token = 'secret'
-        self.account.auth.parameters = dict(
-            ConsumerKey='key',
-            ConsumerSecret='secret')
         self.assertEqual(0, TestModel.get_n_rows())
         self.assertEqual(self.protocol.home(), 3)
         self.assertEqual(3, TestModel.get_n_rows())
@@ -703,9 +696,6 @@
     def test_protocol_rate_limiting(self, time, sleep, login):
         self.account.access_token = 'access'
         self.account.secret_token = 'secret'
-        self.account.auth.parameters = dict(
-            ConsumerKey='key',
-            ConsumerSecret='secret')
         # Test rate limiting via the Twitter plugin API.
         #
         # The first call doesn't get rate limited.
 
=== modified file 'friends/utils/account.py'
--- friends/utils/account.py	2013-03-13 02:03:12 +0000
+++ friends/utils/account.py	2013-03-25 10:33:12 +0000
@@ -17,7 +17,7 @@
 
 __all__ = [
     'Account',
-    'AccountManager',
+    'find_accounts',
     ]
 
 
@@ -28,65 +28,30 @@
 
 from friends.errors import UnsupportedProtocolError
 from friends.utils.manager import protocol_manager
+from friends.utils.authentication import manager
 
 
 log = logging.getLogger(__name__)
 
 
-class AccountManager:
-    """Manage the accounts that we know about."""
-
-    def __init__(self):
-        self._accounts = {}
-        # Ask libaccounts for a manager of the microblogging services.
-        # Connect callbacks to the manager so that we can react when accounts
-        # are added or deleted.
-        manager = Accounts.Manager.new_for_service_type('microblogging')
-        manager.connect('enabled-event', self._on_enabled_event)
-        # Add all the currently known accounts.
-        for account_service in manager.get_enabled_account_services():
-            self._add_new_account(account_service)
-        log.info('Accounts found: {}'.format(len(self._accounts)))
-
-    def _get_service(self, manager, account_id):
-        """Instantiate an AccountService and identify it."""
-        account = manager.get_account(account_id)
-        for service in account.list_services():
-            return Accounts.AccountService.new(account, service)
-
-    def _on_enabled_event(self, manager, account_id):
-        """React to new microblogging accounts being enabled or disabled."""
-        account_service = self._get_service(manager, account_id)
-        if account_service is not None and account_service.get_enabled():
-            log.debug('Adding account {}'.format(account_id))
-            account = self._add_new_account(account_service)
-            if account is not None:
-                account.protocol('receive')
-
-    def _add_new_account(self, account_service):
+def _find_accounts_uoa():
+    """Consult Ubuntu Online Accounts for the accounts we have."""
+    accounts = {}
+    for service in manager.get_enabled_account_services():
         try:
-            new_account = Account(account_service)
+            account = Account(service)
         except UnsupportedProtocolError as error:
             log.info(error)
         else:
-            self._accounts[new_account.id] = new_account
-            return new_account
-
-    def get_all(self):
-        return self._accounts.values()
-
-    def get(self, account_id, default=None):
-        return self._accounts.get(int(account_id), default)
-
-
-class AuthData:
-    """This class serves as a sub-namespace for Account instances."""
-
-    def __init__(self, auth_data):
-        self.id = auth_data.get_credentials_id()
-        self.method = auth_data.get_method()
-        self.mechanism = auth_data.get_mechanism()
-        self.parameters = auth_data.get_parameters()
+            accounts[account.id] = account
+    log.info('Accounts found: {}'.format(len(accounts)))
+    return accounts
+
+
+def find_accounts():
+    # TODO: Implement GOA support, then fill out this method with some
+    # logic for determining whether to use UOA or GOA.
+    return _find_accounts_uoa()
 
 
 class Account:
@@ -99,6 +64,8 @@
         )
 
     # Defaults for the known and useful attributes.
+    consumer_secret = None
+    consumer_key = None
     access_token = None
     secret_token = None
     send_enabled = None
@@ -108,15 +75,22 @@
     id = None
 
     def __init__(self, account_service):
-        self.account_service = account_service
-        self.auth = AuthData(account_service.get_auth_data())
+        self.auth = account_service.get_auth_data()
+        if self.auth is not None:
+            auth_params = self.auth.get_parameters()
+            self.consumer_key = auth_params.get('ConsumerKey')
+            self.consumer_secret = auth_params.get('ConsumerSecret')
+        else:
+            raise UnsupportedProtocolError(
+                'This AgAccountService is missing AgAuthData!')
+
         # The provider in libaccounts should match the name of our protocol.
         account = account_service.get_account()
         self.id = account.id
-        self.protocol_name = account.get_provider_name()
-        protocol_class = protocol_manager.protocols.get(self.protocol_name)
+        protocol_name = account.get_provider_name()
+        protocol_class = protocol_manager.protocols.get(protocol_name)
         if protocol_class is None:
-            raise UnsupportedProtocolError(self.protocol_name)
+            raise UnsupportedProtocolError(protocol_name)
         self.protocol = protocol_class(self)
         # Connect responders to changes in the account information.
         account_service.connect('changed', self._on_account_changed, account)
@@ -152,24 +126,11 @@
         while True:
             success, key, value = settings.next()
             if success:
-                log.debug('{} got {}: {}'.format(self.id, key, value))
+                log.debug('{} ({}) got {}: {}'.format(
+                        self.protocol._Name, self.id, key, value))
                 # Testing for tuple membership makes this easy to expand
                 # later, if necessary.
                 if key in Account._LIBACCOUNTS_PROPERTIES:
                     setattr(self, key, value)
             else:
                 break
-
-    @property
-    def enabled(self):
-        return self.account_service.get_enabled()
-
-    def __eq__(self, other):
-        if other is None:
-            return False
-        return self.account_service == other.account_service
-
-    def __ne__(self, other):
-        if other is None:
-            return True
-        return self.account_service != other.account_service
 
=== modified file 'friends/utils/authentication.py'
--- friends/utils/authentication.py	2013-03-13 17:34:26 +0000
+++ friends/utils/authentication.py	2013-03-25 10:33:12 +0000
@@ -23,7 +23,7 @@
 import logging
 import time
 
-from gi.repository import GObject, Signon
+from gi.repository import GObject, Accounts, Signon
 
 from friends.errors import AuthorizationError
 
@@ -37,17 +37,30 @@
 LOGIN_TIMEOUT = 30 # Currently this is measured in half-seconds.
 
 
+# Yes, this is not the most logical place to instantiate this, but I
+# couldn't do it in account.py due to cyclical import dependencies.
+manager = Accounts.Manager.new_for_service_type('microblogging')
+
+
 class Authentication:
-    def __init__(self, account):
-        self.account = account
+    def __init__(self, account_id):
+        self.account_id = account_id
+        account = manager.get_account(account_id)
+        service = account.list_services()[0]
+        self.auth = Accounts.AccountService.new(
+            account, service).get_auth_data()
         self._reply = None
 
     def login(self):
-        auth = self.account.auth
-        self.auth_session = Signon.AuthSession.new(auth.id, auth.method)
+        auth = self.auth
+        self.auth_session = Signon.AuthSession.new(
+            auth.get_credentials_id(),
+            auth.get_method())
         self.auth_session.process(
-            auth.parameters, auth.mechanism,
-            self._login_cb, None)
+            auth.get_parameters(),
+            auth.get_mechanism(),
+            self._login_cb,
+            None)
         timeout = LOGIN_TIMEOUT
         while self._reply is None and timeout > 0:
             # We're building a synchronous API on top of an inherently
@@ -56,17 +69,17 @@
             time.sleep(0.5)
             timeout -= 1
         if self._reply is None:
-            raise AuthorizationError(self.account.id, 'Login timed out.')
+            raise AuthorizationError(self.account_id, 'Login timed out.')
         if 'AccessToken' not in self._reply:
             raise AuthorizationError(
-                self.account.id,
+                self.account_id,
                 'No AccessToken found: {!r}'.format(self._reply))
         return self._reply
 
     def _login_cb(self, session, reply, error, user_data):
         self._reply = reply
         if error:
-            exception = AuthorizationError(self.account.id, error.message)
+            exception = AuthorizationError(self.account_id, error.message)
             # Mardy says this error can happen during normal operation.
             if error.message.endswith('userActionFinished error: 10'):
                 log.error(str(exception))
 
=== modified file 'friends/utils/base.py'
--- friends/utils/base.py	2013-03-20 01:19:39 +0000
+++ friends/utils/base.py	2013-03-25 10:33:12 +0000
@@ -460,7 +460,7 @@
         log.debug('{} to {}'.format(
                 'Re-authenticating' if old_token else 'Logging in', self._Name))
 
-        result = Authentication(self._account).login()
+        result = Authentication(self._account.id).login()
 
         self._account.access_token = result.get('AccessToken')
         self._whoami(result)
@@ -469,8 +469,8 @@
     def _get_oauth_headers(self, method, url, data=None, headers=None):
         """Basic wrapper around oauthlib that we use for Twitter and Flickr."""
         # "Client" == "Consumer" in oauthlib parlance.
-        client_key = self._account.auth.parameters['ConsumerKey']
-        client_secret = self._account.auth.parameters['ConsumerSecret']
+        client_key = self._account.consumer_key
+        client_secret = self._account.consumer_secret
 
         # "resource_owner" == secret and token.
         resource_owner_key = self._get_access_token()
 
=== modified file 'tools/debug_live.py'
--- tools/debug_live.py	2013-03-13 18:05:13 +0000
+++ tools/debug_live.py	2013-03-25 10:33:12 +0000
@@ -30,7 +30,7 @@
 # Print all logs for debugging purposes
 initialize(debug=True, console=True)
 
-from friends.utils.account import AccountManager
+from friends.utils.account import find_accounts
 from friends.utils.base import initialize_caches, _OperationThread
 from friends.utils.model import Model
 
@@ -53,12 +53,10 @@
 
     initialize_caches()
 
+    Model.connect('row-added', row_added)
+
     found = False
-    a = AccountManager()
-
-    Model.connect('row-added', row_added)
-
-    for account in a._accounts.values():
+    for account in find_accounts().values():
         if account.protocol._name == protocol.lower():
             found = True
             account.protocol(*args)