Merge lp:~robru/friends/simplify-contacts into lp:friends

[Robert Bruce Park]

Vast simplification of contact logic.

Great simplification of our messy contacts implementation. Lots of big changes here, but here are some highlights:

* Stop creating VCards, serializing them into strings, and then parsing them back into EDS Contact objects. Just create the Contact directly.

* Stop iterating over all EDS address books, looking for the one with the right display name. Simply request the correct address book by ID the first time. Also cache this instance through the lifetime of the script, so it doesn't need to be polled for continuously.

* Streamline a lot of the _create_contact logic, which was highly reminiscent of the old Gwibber code, where json-ish data structures were being schlepped around and copied from one form into another, for no apparent reason.

[Robert Bruce Park (robru)]

Ok, I'm pretty happy with this at this point. A lot of mysterious methods are gone, test coverage is good, and the major inefficiencies have been streamlined. If you could review this on Monday, Ken, that'd be super.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:236
http://jenkins.qa.ubuntu.com/job/friends-ci/50/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/friends-saucy-amd64-ci/7

Click here to trigger a rebuild:
http://s-jenkins:8080/job/friends-ci/50/rebuild

review: Approve (continuous-integration)

[Ken VanDine (ken-vandine)]

Looks like it works well, thanks!

review: Approve

=== modified file 'friends/protocols/facebook.py'
--- friends/protocols/facebook.py	2013-07-17 22:15:56 +0000
+++ friends/protocols/facebook.py	2013-07-20 03:25:30 +0000
@@ -326,68 +326,35 @@
         else:
             raise FriendsError(str(response))
 
-    def _fetch_contacts(self):
-        """Retrieve a list of up to 1,000 Facebook friends."""
-        limit = 1000
-        access_token = self._get_access_token()
-        url = ME_URL + '/friends'
-        params = dict(
-            access_token=access_token,
-            limit=limit)
-        return self._follow_pagination(url, params, limit)
-
-    def _fetch_contact(self, contact_id):
-        """Fetch the full, individual contact info."""
-        access_token = self._get_access_token()
-        url = API_BASE.format(id=contact_id)
-        params = dict(access_token=access_token)
-        return Downloader(url, params).get_json()
-
-    def _create_contact(self, contact_json):
-        """Build a VCard based on a dict representation of a contact."""
-
-        user_id = contact_json.get('id')
-        user_fullname = contact_json.get('name')
-        user_nickname = contact_json.get('username')
-        user_link = contact_json.get('link')
-        gender = contact_json.get('gender')
-
-        attrs = {}
-        attrs['facebook-id'] = user_id
-        attrs['facebook-name'] = user_fullname
-        attrs['X-URIS'] = user_link
-        attrs['X-FOLKS-WEB-SERVICES-IDS'] = {
-            'jabber':'-{}@chat.facebook.com'.format(user_id),
-            'remote-full-name':user_fullname,
-            'facebook-id': user_id}
-        if gender is not None:
-            attrs['X-GENDER'] = gender
-
-        return super()._create_contact(user_fullname, user_nickname, attrs)
-
     @feature
     def contacts(self):
-        contacts = self._fetch_contacts()
-        log.debug('Size of the contacts returned {}'.format(len(contacts)))
-        source = self._get_eds_source()
+        contacts = self._follow_pagination(
+            url=ME_URL + '/friends',
+            params=dict(access_token=self._get_access_token(), limit=1000),
+            limit=1000)
+        log.debug('Found {} contacts'.format(len(contacts)))
 
         for contact in contacts:
-            if self._previously_stored_contact(
-                    source, 'facebook-id', contact['id']):
+            contact_id = contact.get('id')
+            if contact_id is None or self._previously_stored_contact(contact_id):
                 continue
-            log.debug(
-                'Fetch full contact info for {} and id {}'.format(
-                    contact['name'], contact['id']))
-            full_contact = self._fetch_contact(contact['id'])
-            eds_contact = self._create_contact(full_contact)
-            self._push_to_eds(eds_contact)
+            full_contact = Downloader(
+                url=API_BASE.format(id=contact_id),
+                params=dict(access_token=self._get_access_token())).get_json()
+            self._push_to_eds({
+                'facebook-id':   contact_id,
+                'facebook-name': full_contact.get('name'),
+                'facebook-nick': full_contact.get('username'),
+                'X-URIS':        full_contact.get('link'),
+                'X-GENDER':      full_contact.get('gender'),
+                'X-FOLKS-WEB-SERVICES-IDS': {
+                    'jabber': '-{}@chat.facebook.com'.format(contact_id),
+                    'remote-full-name': full_contact.get('name'),
+                    'facebook-id': contact_id,
+                }})
 
         return len(contacts)
 
-    def delete_contacts(self):
-        source = self._get_eds_source()
-        return self._delete_service_contacts(source)
-
 
 class PostIdCache(JsonCache):
     """Persist most-recent timestamps as JSON."""

=== modified file 'friends/protocols/identica.py'
--- friends/protocols/identica.py	2013-04-03 03:47:39 +0000
+++ friends/protocols/identica.py	2013-07-20 03:25:30 +0000
@@ -39,6 +39,7 @@
     _favorite = _api_base.format(endpoint='favorites/create/{}')
     _del_favorite = _api_base.format(endpoint='favorites/destroy/{}')
 
+    _user_home = 'https://identi.ca/{user_id}'
     _tweet_permalink = 'http://identi.ca/notice/{tweet_id}'
 
     def _whoami(self, authdata):

=== modified file 'friends/protocols/linkedin.py'
--- friends/protocols/linkedin.py	2013-07-17 22:25:42 +0000
+++ friends/protocols/linkedin.py	2013-07-20 03:25:30 +0000
@@ -26,12 +26,16 @@
 from friends.utils.base import Base, feature
 from friends.utils.http import Downloader
 from friends.utils.time import iso8601utc
-from friends.errors import FriendsError
 
 
 log = logging.getLogger(__name__)
 
 
+def make_fullname(firstName=None, lastName=None, **ignored):
+    """Converts dict(firstName='Bob', lastName='Loblaw') into 'Bob Loblaw'."""
+    return ' '.join(name for name in (firstName, lastName) if name)
+
+
 class LinkedIn(Base):
     _api_base = ('https://api.linkedin.com/v1/{endpoint}?format=json' +
                  '&secure-urls=true&oauth2_access_token={token}')
@@ -44,7 +48,7 @@
             token=self._get_access_token())
         result = Downloader(url).get_json()
         self._account.user_id = result.get('id')
-        self._account.user_name = '{firstName} {lastName}'.format(**result)
+        self._account.user_name = make_fullname(**result)
 
     def _publish_entry(self, entry, stream='messages'):
         """Publish a single update into the Dee.SharedModel."""
@@ -52,7 +56,7 @@
 
         content = entry.get('updateContent', {})
         person = content.get('person', {})
-        name = '{firstName} {lastName}'.format(**person)
+        name = make_fullname(**person)
         person_id = person.get('id', '')
         status = person.get('currentStatus')
         picture = person.get('pictureUrl', '')
@@ -98,40 +102,28 @@
         """Gather and publish all incoming messages."""
         return self.home()
 
-    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 = { 'linkedin-id':   user_id,
-                  'linkedin-name': user_fullname,
-                  'X-URIS':        user_link }
-
-        return super()._create_contact(user_fullname, None, attrs)
-
     @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', [])
-        source = self._get_eds_source()
+        connections = Downloader(
+            url=self._api_base.format(
+                endpoint='people/~/connections',
+                token=self._get_access_token())
+        ).get_json().get('values', [])
 
         for connection in connections:
-            connection_id = connection.get('id')
-            if connection_id != 'private':
-                if not self._previously_stored_contact(
-                        source, 'linkedin-id', connection_id):
-                    self._push_to_eds(self._create_contact(connection))
+            connection_id = connection.get('id', 'private')
+            fullname = make_fullname(**connection)
+            if connection_id != 'private' and not self._previously_stored_contact(connection_id):
+                self._push_to_eds({
+                    'linkedin-id': connection_id,
+                    'linkedin-name': fullname,
+                    'X-URIS': connection.get(
+                        'siteStandardProfileRequest', {}).get('url'),
+                    'X-FOLKS-WEB-SERVICES-IDS': {
+                        'remote-full-name': fullname,
+                        'linkedin-id': connection_id,
+                    }})
 
         return len(connections)
-
-    def delete_contacts(self):
-        source = self._get_eds_source()
-        return self._delete_service_contacts(source)

=== modified file 'friends/protocols/twitter.py'
--- friends/protocols/twitter.py	2013-07-17 22:15:56 +0000
+++ friends/protocols/twitter.py	2013-07-20 03:25:30 +0000
@@ -61,7 +61,8 @@
     _favorite = _api_base.format(endpoint='favorites/create')
     _del_favorite = _api_base.format(endpoint='favorites/destroy')
 
-    _tweet_permalink = 'https://twitter.com/{user_id}/status/{tweet_id}'
+    _user_home = 'https://twitter.com/{user_id}'
+    _tweet_permalink = _user_home + '/status/{tweet_id}'
 
     def __init__(self, account):
         super().__init__(account)
@@ -347,68 +348,35 @@
             self._publish_tweet(tweet, stream='search/{}'.format(query))
         return self._get_n_rows()
 
-# https://dev.twitter.com/docs/api/1.1/get/friends/ids
-    def _getfriendsids(self):
-        """Get a list of the twitter id's of our twitter friends."""
-        url = self._api_base.format(endpoint="friends/ids")
-        response = self._get_url(url)
-
-        try:
-            # Twitter
-            return response["ids"]
-        except TypeError:
-            # Identica
-            return response
-
-# https://dev.twitter.com/docs/api/1.1/get/users/show
-    def _showuser(self, uid):
-        """Get all the information about a twitter user."""
-        url = self._api_base.format(
-            endpoint='users/show') + '?user_id={}'.format(uid)
-        return self._get_url(url)
-
-    def _create_contact(self, userdata):
-        """Build a VCard based on a dict representation of a contact."""
-
-        if userdata.get('error'):
-            raise FriendsError(userdata)
-
-        user_fullname = userdata['name']
-        user_nickname = userdata['screen_name']
-
-        attrs = {}
-        attrs['twitter-id'] = str(userdata['id'])
-        attrs['twitter-name'] = user_fullname
-        attrs['X-URIS'] = 'https://twitter.com/{}'.format(user_nickname)
-        attrs['X-FOLKS-WEB-SERVICES-IDS'] = {
-            'remote-full-name': user_fullname,
-            'twitter-id': str(userdata['id']),
-            }
-
-        return super()._create_contact(user_fullname, user_nickname, attrs)
-
     @feature
     def contacts(self):
-        contacts = self._getfriendsids()
-        log.debug('Size of the contacts returned {}'.format(len(contacts)))
-        source = self._get_eds_source()
-
-        for contact in contacts:
-            twitterid = str(contact)
-            if self._previously_stored_contact(source, 'twitter-id', twitterid):
-                continue
-            full_contact = self._showuser(twitterid)
-            try:
-                eds_contact = self._create_contact(full_contact)
-            except FriendsError:
-                continue
-            self._push_to_eds(eds_contact)
+        # https://dev.twitter.com/docs/api/1.1/get/friends/ids
+        contacts = self._get_url(self._api_base.format(endpoint='friends/ids'))
+        # Twitter uses a dict with 'ids' key, Identica returns the ids directly.
+        with ignored(TypeError):
+            contacts = contacts['ids']
+
+        log.debug('Found {} contacts'.format(len(contacts)))
+
+        for contact_id in contacts:
+            contact_id = str(contact_id)
+            if not self._previously_stored_contact(contact_id):
+                # https://dev.twitter.com/docs/api/1.1/get/users/show
+                full_contact = self._get_url(url=self._api_base.format(
+                    endpoint='users/show') + '?user_id=' + contact_id)
+                user_fullname = full_contact.get('name')
+                user_nickname = full_contact.get('screen_name')
+                self._push_to_eds({
+                    '{}-id'.format(self._name): contact_id,
+                    '{}-name'.format(self._name): user_fullname,
+                    '{}-nick'.format(self._name): user_nickname,
+                    'X-URIS': self._user_home.format(user_id=user_nickname),
+                    'X-FOLKS-WEB-SERVICES-IDS': {
+                        'remote-full-name': user_fullname,
+                        '{}-id'.format(self._name): contact_id,
+                    }})
         return len(contacts)
 
-    def delete_contacts(self):
-        source = self._get_eds_source()
-        return self._delete_service_contacts(source)
-
 
 class TweetIdCache(JsonCache):
     """Persist most-recent tweet_ids as JSON."""

=== modified file 'friends/tests/test_dispatcher.py'
--- friends/tests/test_dispatcher.py	2013-04-03 04:04:56 +0000
+++ friends/tests/test_dispatcher.py	2013-07-20 03:25:30 +0000
@@ -184,23 +184,26 @@
 
     def test_get_features(self):
         self.assertEqual(json.loads(self.dispatcher.GetFeatures('facebook')),
-                         ['contacts', 'delete', 'home', 'like', 'receive',
-                          'search', 'send', 'send_thread', 'unlike', 'upload',
-                          'wall'])
+                         ['contacts', 'delete', 'delete_contacts',
+                          'home', 'like', 'receive', 'search', 'send',
+                          'send_thread', 'unlike', 'upload', 'wall'])
         self.assertEqual(json.loads(self.dispatcher.GetFeatures('twitter')),
-                         ['contacts', 'delete', 'follow', 'home', 'like',
-                          'list', 'lists', 'mentions', 'private', 'receive',
-                          'retweet', 'search', 'send', 'send_private',
-                          'send_thread', 'tag', 'unfollow', 'unlike', 'user'])
+                         ['contacts', 'delete', 'delete_contacts',
+                          'follow', 'home', 'like', 'list', 'lists',
+                          'mentions', 'private', 'receive', 'retweet',
+                          'search', 'send', 'send_private',
+                          'send_thread', 'tag', 'unfollow', 'unlike',
+                          'user'])
         self.assertEqual(json.loads(self.dispatcher.GetFeatures('identica')),
-                         ['contacts', 'delete', 'follow', 'home', 'like', 
-                          'mentions', 'private', 'receive', 'retweet',
-                          'search', 'send', 'send_private', 'send_thread',
+                         ['contacts', 'delete', 'delete_contacts',
+                          'follow', 'home', 'like', 'mentions',
+                          'private', 'receive', 'retweet', 'search',
+                          'send', 'send_private', 'send_thread',
                           'unfollow', 'unlike', 'user'])
         self.assertEqual(json.loads(self.dispatcher.GetFeatures('flickr')),
-                         ['receive', 'upload'])
+                         ['delete_contacts', 'receive', 'upload'])
         self.assertEqual(json.loads(self.dispatcher.GetFeatures('foursquare')),
-                         ['receive'])
+                         ['delete_contacts', 'receive'])
 
     @mock.patch('friends.service.dispatcher.logging')
     def test_urlshorten_already_shortened(self, logging_mock):

=== modified file 'friends/tests/test_facebook.py'
--- friends/tests/test_facebook.py	2013-07-17 22:15:56 +0000
+++ friends/tests/test_facebook.py	2013-07-20 03:25:30 +0000
@@ -26,13 +26,13 @@
 import unittest
 import shutil
 
-from gi.repository import GLib
+from gi.repository import GLib, EDataServer
 from pkg_resources import resource_filename
 
 from friends.protocols.facebook import Facebook
 from friends.tests.mocks import FakeAccount, FakeSoupMessage, LogMock
 from friends.tests.mocks import TestModel, mock
-from friends.tests.mocks import EDSBookClientMock, EDSSource, EDSRegistry
+from friends.tests.mocks import EDSBookClientMock, EDSRegistry
 from friends.errors import ContactsError, FriendsError, AuthorizationError
 from friends.utils.cache import JsonCache
 
@@ -57,8 +57,9 @@
     def test_features(self):
         # The set of public features.
         self.assertEqual(Facebook.get_features(),
-            ['contacts', 'delete', 'home', 'like', 'receive', 'search', 'send',
-             'send_thread', 'unlike', 'upload', 'wall'])
+                         ['contacts', 'delete', 'delete_contacts', 'home',
+                          'like', 'receive', 'search', 'send', 'send_thread',
+                          'unlike', 'upload', 'wall'])
 
     @mock.patch('friends.utils.authentication.manager')
     @mock.patch('friends.utils.authentication.Accounts')
@@ -474,23 +475,66 @@
             params=dict(access_token='face'))
         unpublish.assert_called_once_with('post_id')
 
-    @mock.patch('friends.utils.http.Soup.Message',
-                FakeSoupMessage('friends.tests.data', 'facebook-contacts.dat'))
-    @mock.patch('friends.protocols.facebook.Facebook._login',
-                return_value=True)
-    def test_fetch_contacts(self, *mocks):
-        # Receive the users friends.
-        results = self.protocol._fetch_contacts()
-        self.assertEqual(len(results), 8)
-        self.assertEqual(results[7]['name'], 'John Smith')
-        self.assertEqual(results[7]['id'], '444444')
+    @mock.patch('friends.protocols.facebook.Downloader')
+    def test_contacts(self, downloader):
+        downloader().get_json.return_value = dict(
+            name='Joe Blow', username='jblow', link='example.com', gender='male')
+        downloader.reset_mock()
+        self.protocol._get_access_token = mock.Mock(return_value='broken')
+        follow = self.protocol._follow_pagination = mock.Mock(
+            return_value=[dict(id='contact1'), dict(id='contact2')])
+        prev = self.protocol._previously_stored_contact = mock.Mock(return_value=False)
+        push = self.protocol._push_to_eds = mock.Mock()
+        self.assertEqual(self.protocol.contacts(), 2)
+        follow.assert_called_once_with(
+            params={'access_token': 'broken', 'limit': 1000},
+            url='https://graph.facebook.com/me/friends',
+            limit=1000)
+        self.assertEqual(
+            prev.call_args_list,
+            [mock.call('contact1'), mock.call('contact2')])
+        self.assertEqual(
+            downloader.call_args_list,
+            [mock.call(url='https://graph.facebook.com/contact1',
+                       params={'access_token': 'broken'}),
+             mock.call(url='https://graph.facebook.com/contact2',
+                       params={'access_token': 'broken'})])
+        self.assertEqual(
+            push.call_args_list,
+            [mock.call({
+                'X-FOLKS-WEB-SERVICES-IDS': {
+                    'jabber': '[e-mail]',
+                    'facebook-id': 'contact1',
+                    'remote-full-name': 'Joe Blow'},
+                'X-GENDER': 'male',
+                'facebook-name': 'Joe Blow',
+                'facebook-id': 'contact1',
+                'X-URIS': 'example.com',
+                'facebook-nick': 'jblow'}),
+             mock.call({
+                 'X-FOLKS-WEB-SERVICES-IDS': {
+                     'jabber': '[e-mail]',
+                     'facebook-id': 'contact2',
+                     'remote-full-name': 'Joe Blow'},
+                 'X-GENDER': 'male',
+                 'facebook-name': 'Joe Blow',
+                 'facebook-id': 'contact2',
+                 'X-URIS': 'example.com',
+                 'facebook-nick': 'jblow'})])
 
     def test_create_contact(self, *mocks):
         # Receive the users friends.
-        bare_contact = {'name': 'Lucy Baron',
-                        'id': '555555555',
-                        'username': 'lucy.baron5',
-                        'link': 'http:www.facebook.com/lucy.baron5'}
+        bare_contact = {
+            'facebook-id':   '555555555',
+            'facebook-name': 'Lucy Baron',
+            'facebook-nick': 'lucy.baron5',
+            'X-URIS':        'http:www.facebook.com/lucy.baron5',
+            'X-GENDER':      'female',
+            'X-FOLKS-WEB-SERVICES-IDS': {
+                'jabber': '[e-mail]',
+                'remote-full-name': 'Lucy Baron',
+                'facebook-id': '555555555',
+            }}
         eds_contact = self.protocol._create_contact(bare_contact)
         facebook_id_attr = eds_contact.get_attribute('facebook-id')
         self.assertEqual(facebook_id_attr.get_value(), '555555555')
@@ -521,7 +565,7 @@
         # Finally test to ensure all key value pairs were tested
         self.assertTrue(test_jabber and test_remote_name and test_facebook_id)
 
-    @mock.patch('friends.utils.base.Base._get_eds_source',
+    @mock.patch('friends.utils.base.Base._prepare_eds_connections',
                 return_value=True)
     @mock.patch('gi.repository.EBook.BookClient.new',
                 return_value=EDSBookClientMock())
@@ -530,54 +574,100 @@
                         'id': '555555555',
                         'username': 'lucy.baron5',
                         'link': 'http:www.facebook.com/lucy.baron5'}
-        eds_contact = self.protocol._create_contact(bare_contact)
         self.protocol._address_book = 'test-address-book'
+        client = self.protocol._book_client = mock.Mock()
+        client.add_contact_sync.return_value = True
         # Implicitely fail test if the following raises any exceptions
-        self.protocol._push_to_eds(eds_contact)
+        self.protocol._push_to_eds(bare_contact)
 
-    @mock.patch('friends.utils.base.Base._get_eds_source',
-                return_value=None)
-    @mock.patch('friends.utils.base.Base._create_eds_source',
+    @mock.patch('friends.utils.base.Base._prepare_eds_connections',
                 return_value=None)
     def test_unsuccessfull_push_to_eds(self, *mocks):
         bare_contact = {'name': 'Lucy Baron',
                         'id': '555555555',
                         'username': 'lucy.baron5',
                         'link': 'http:www.facebook.com/lucy.baron5'}
-        eds_contact = self.protocol._create_contact(bare_contact)
         self.protocol._address_book = 'test-address-book'
+        client = self.protocol._book_client = mock.Mock()
+        client.add_contact_sync.return_value = False
         self.assertRaises(
             ContactsError,
             self.protocol._push_to_eds,
-            eds_contact,
+            bare_contact,
             )
 
-    @mock.patch('gi.repository.EDataServer.Source.new',
-                return_value=EDSSource('foo', 'bar'))
-    def test_create_eds_source(self, *mocks):
-        regmock = self.protocol._source_registry = mock.Mock()
-        regmock.ref_source = lambda x: x
-
-        result = self.protocol._create_eds_source()
-        self.assertEqual(result, 'test-source-uid')
-
-    @mock.patch('gi.repository.EBook.BookClient.new',
+    @mock.patch('gi.repository.EBook.BookClient.connect_sync',
                 return_value=EDSBookClientMock())
     def test_successful_previously_stored_contact(self, *mocks):
-        result = self.protocol._previously_stored_contact(
-            True, 'facebook-id', '11111')
+        result = self.protocol._previously_stored_contact('11111')
         self.assertEqual(result, True)
 
-    def test_successful_get_eds_source(self, *mocks):
-        class FakeSource:
-            def get_display_name(self):
-                return 'test-facebook-contacts'
-            def get_uid(self):
-                return 1345245
-
-        reg_mock = self.protocol._source_registry = mock.Mock()
-        reg_mock.list_sources.return_value = [FakeSource()]
-        reg_mock.ref_source = lambda x: x
-        self.protocol._address_book = 'test-facebook-contacts'
-        result = self.protocol._get_eds_source()
-        self.assertEqual(result, 1345245)
+    def test_first_run_prepare_eds_connections(self):
+        self.protocol._name = 'testsuite'
+        self.assertIsNone(self.protocol._address_book_name)
+        self.assertIsNone(self.protocol._eds_source_registry)
+        self.assertIsNone(self.protocol._eds_source)
+        self.assertIsNone(self.protocol._book_client)
+        self.protocol._prepare_eds_connections()
+        self.assertEqual(self.protocol._address_book_name,
+                         'friends-testsuite-contacts')
+        self.assertEqual(self.protocol._eds_source.get_display_name(),
+                         'friends-testsuite-contacts')
+        self.assertEqual(self.protocol._eds_source.get_uid(),
+                         'friends-testsuite-contacts')
+        self.protocol.delete_contacts()
+
+    @mock.patch('gi.repository.EDataServer.SourceRegistry')
+    @mock.patch('gi.repository.EDataServer.Source')
+    @mock.patch('gi.repository.EBook.BookClient')
+    def test_mocked_prepare_eds_connections(self, client, source, registry):
+        self.protocol._name = 'testsuite'
+        self.assertIsNone(self.protocol._address_book_name)
+        self.protocol._prepare_eds_connections()
+        self.protocol._prepare_eds_connections() # Second time harmlessly ignored
+        self.assertEqual(self.protocol._address_book_name,
+                         'friends-testsuite-contacts')
+        registry.new_sync.assert_called_once_with(None)
+        self.assertEqual(self.protocol._eds_source_registry,
+                         registry.new_sync())
+        registry.new_sync().ref_source.assert_called_once_with(
+            'friends-testsuite-contacts')
+        self.assertEqual(self.protocol._eds_source,
+                         registry.new_sync().ref_source())
+        client.connect_sync.assert_called_once_with(
+            registry.new_sync().ref_source(), None)
+        self.assertEqual(self.protocol._book_client,
+                         client.connect_sync())
+
+    @mock.patch('gi.repository.EDataServer.SourceRegistry')
+    @mock.patch('gi.repository.EDataServer.Source')
+    @mock.patch('gi.repository.EBook.BookClient')
+    def test_create_new_eds_book(self, client, source, registry):
+        self.protocol._name = 'testsuite'
+        self.assertIsNone(self.protocol._address_book_name)
+        registry.new_sync().ref_source.return_value = None
+        registry.reset_mock()
+        self.protocol._prepare_eds_connections()
+        self.protocol._prepare_eds_connections() # Second time harmlessly ignored
+        self.assertEqual(self.protocol._address_book_name,
+                         'friends-testsuite-contacts')
+        registry.new_sync.assert_called_once_with(None)
+        self.assertEqual(self.protocol._eds_source_registry,
+                         registry.new_sync())
+        registry.new_sync().ref_source.assert_called_once_with(
+            'friends-testsuite-contacts')
+        source.new_with_uid.assert_called_once_with(
+            'friends-testsuite-contacts', None)
+        self.assertEqual(self.protocol._eds_source,
+                         source.new_with_uid())
+        source.new_with_uid().set_display_name.assert_called_once_with(
+            'friends-testsuite-contacts')
+        source.new_with_uid().set_parent.assert_called_once_with('local-stub')
+        source.new_with_uid().get_extension.assert_called_once_with(
+            EDataServer.SOURCE_EXTENSION_ADDRESS_BOOK)
+        registry.new_sync().commit_source_sync.assert_called_once_with(
+            source.new_with_uid(), None)
+        client.connect_sync.assert_called_once_with(
+            source.new_with_uid(), None)
+        self.assertEqual(self.protocol._book_client,
+                         client.connect_sync())

=== modified file 'friends/tests/test_flickr.py'
--- friends/tests/test_flickr.py	2013-06-18 22:00:44 +0000
+++ friends/tests/test_flickr.py	2013-07-20 03:25:30 +0000
@@ -49,7 +49,8 @@
 
     def test_features(self):
         # The set of public features.
-        self.assertEqual(Flickr.get_features(), ['receive', 'upload'])
+        self.assertEqual(Flickr.get_features(),
+                         ['delete_contacts', 'receive', 'upload'])
 
     @mock.patch('friends.utils.http.Soup.Message',
                 FakeSoupMessage('friends.tests.data', 'flickr-nophotos.dat'))

=== modified file 'friends/tests/test_foursquare.py'
--- friends/tests/test_foursquare.py	2013-06-18 22:00:44 +0000
+++ friends/tests/test_foursquare.py	2013-07-20 03:25:30 +0000
@@ -48,7 +48,8 @@
 
     def test_features(self):
         # The set of public features.
-        self.assertEqual(FourSquare.get_features(), ['receive'])
+        self.assertEqual(FourSquare.get_features(),
+                         ['delete_contacts', 'receive'])
 
     @mock.patch('friends.utils.authentication.manager')
     @mock.patch('friends.utils.authentication.Accounts')

=== modified file 'friends/tests/test_identica.py'
--- friends/tests/test_identica.py	2013-04-17 06:13:49 +0000
+++ friends/tests/test_identica.py	2013-07-20 03:25:30 +0000
@@ -221,24 +221,6 @@
         get_url.assert_called_with(
             'http://identi.ca/api/search.json?q=hello')
 
-    def test_getfriendsids(self):
-        get_url = self.protocol._get_url = mock.Mock(return_value=[1,2,3])
-        ids = self.protocol._getfriendsids()
-
-        get_url.assert_called_with(
-            'http://identi.ca/api/friends/ids.json'
-            )
-        self.assertEqual(ids, [1,2,3])
-
-    def test_showuser(self):
-        get_url = self.protocol._get_url = mock.Mock(return_value={"name":"Alice"})
-        userdata = self.protocol._showuser(1)
-
-        get_url.assert_called_with(
-            'http://identi.ca/api/users/show.json?user_id=1'
-            )
-        self.assertEqual(userdata, {"name":"Alice"})
-
     def test_like(self):
         get_url = self.protocol._get_url = mock.Mock()
         inc_cell = self.protocol._inc_cell = mock.Mock()
@@ -265,32 +247,33 @@
             'http://identi.ca/api/favorites/destroy/1234.json',
             dict(id='1234'))
 
-    def test_create_contact(self, *mocks):
-        # Receive the users friends.
-        bare_contact = {'name': 'Alice Bob',
-                        'screen_name': 'alice_bob',
-                        'id': 13579}
-
-        eds_contact = self.protocol._create_contact(bare_contact)
-        twitter_id_attr = eds_contact.get_attribute('twitter-id')
-        self.assertEqual(twitter_id_attr.get_value(), '13579')
-        twitter_name_attr = eds_contact.get_attribute('twitter-name')
-        self.assertEqual(twitter_name_attr.get_value(), 'Alice Bob')
-        web_service_addrs = eds_contact.get_attribute('X-FOLKS-WEB-SERVICES-IDS')
-        params= web_service_addrs.get_params()
-        self.assertEqual(len(params), 2)
-
-        test_remote_name = False
-        test_twitter_id = False
-
-        for p in params:
-            if p.get_name() == 'remote-full-name':
-                self.assertEqual(len(p.get_values()), 1)
-                self.assertEqual(p.get_values()[0], 'Alice Bob')
-                test_remote_name = True
-            if p.get_name() == 'twitter-id':
-                self.assertEqual(len(p.get_values()), 1)
-                self.assertEqual(p.get_values()[0], '13579')
-                test_twitter_id = True
-
-        self.assertTrue(test_remote_name and test_twitter_id)
+    def test_contacts(self):
+        get = self.protocol._get_url = mock.Mock(
+            return_value=dict(ids=[1,2],name='Bob',screen_name='bobby'))
+        prev = self.protocol._previously_stored_contact = mock.Mock(return_value=False)
+        push = self.protocol._push_to_eds = mock.Mock()
+        self.assertEqual(self.protocol.contacts(), 2)
+        self.assertEqual(
+            get.call_args_list,
+            [mock.call('http://identi.ca/api/friends/ids.json'),
+             mock.call(url='http://identi.ca/api/users/show.json?user_id=1'),
+             mock.call(url='http://identi.ca/api/users/show.json?user_id=2')])
+        self.assertEqual(
+            prev.call_args_list,
+            [mock.call('1'), mock.call('2')])
+        self.assertEqual(
+            push.call_args_list,
+            [mock.call({'identica-id': '1',
+                        'X-FOLKS-WEB-SERVICES-IDS': {
+                            'identica-id': '1',
+                            'remote-full-name': 'Bob'},
+                        'X-URIS': 'https://identi.ca/bobby',
+                        'identica-name': 'Bob',
+                        'identica-nick': 'bobby'}),
+             mock.call({'identica-id': '2',
+                        'X-FOLKS-WEB-SERVICES-IDS': {
+                            'identica-id': '2',
+                            'remote-full-name': 'Bob'},
+                        'X-URIS': 'https://identi.ca/bobby',
+                        'identica-name': 'Bob',
+                        'identica-nick': 'bobby'})])

=== modified file 'friends/tests/test_instagram.py'
--- friends/tests/test_instagram.py	2013-07-08 20:54:34 +0000
+++ friends/tests/test_instagram.py	2013-07-20 03:25:30 +0000
@@ -54,7 +54,8 @@
     def test_features(self):
         # The set of public features.
         self.assertEqual(Instagram.get_features(),
-            ['home', 'like', 'receive', 'send_thread', 'unlike'])
+                         ['delete_contacts', 'home', 'like', 'receive',
+                          'send_thread', 'unlike'])
 
     @mock.patch('friends.utils.authentication.manager')
     @mock.patch('friends.utils.authentication.Accounts')

=== modified file 'friends/tests/test_linkedin.py'
--- friends/tests/test_linkedin.py	2013-07-18 03:35:03 +0000
+++ friends/tests/test_linkedin.py	2013-07-20 03:25:30 +0000
@@ -23,7 +23,7 @@
 
 import unittest
 
-from friends.protocols.linkedin import LinkedIn
+from friends.protocols.linkedin import LinkedIn, make_fullname
 from friends.tests.mocks import FakeAccount, FakeSoupMessage, LogMock
 from friends.tests.mocks import TestModel, mock
 from friends.errors import AuthorizationError
@@ -46,6 +46,19 @@
         # as to isolate out test logger from other tests.
         self.log_mock.stop()
 
+    def test_name_logic(self):
+        self.assertEqual('', make_fullname())
+        self.assertEqual('', make_fullname(irrelevant_key='foo'))
+        self.assertEqual('Bob', make_fullname(**dict(firstName='Bob')))
+        self.assertEqual('LastOnly', make_fullname(**dict(lastName='LastOnly')))
+        self.assertEqual(
+            'Bob Loblaw',
+            make_fullname(**dict(firstName='Bob', lastName='Loblaw')))
+        self.assertEqual(
+            'Bob Loblaw',
+            make_fullname(**dict(firstName='Bob', lastName='Loblaw',
+                                 extra='ignored')))
+
     @mock.patch('friends.utils.authentication.manager')
     @mock.patch('friends.utils.authentication.Accounts')
     @mock.patch.dict('friends.utils.authentication.__dict__', LOGIN_TIMEOUT=1)
@@ -97,14 +110,6 @@
              '&authToken=-LNy&trk=api*a26127*s26893*',
              1, False, '', '', '', '', '', '', '', 0.0, 0.0])
 
-    @mock.patch('friends.utils.base.Base._create_contact')
-    def test_create_contact(self, base_mock):
-        self.protocol._create_contact(
-            dict(id='jb89', firstName='Joe', lastName='Blow'))
-        base_mock.assert_called_once_with(
-            'Joe Blow', None,
-            {'X-URIS': '', 'linkedin-id': 'jb89', 'linkedin-name': 'Joe Blow'})
-
     @mock.patch('friends.utils.http.Soup.Message',
                 FakeSoupMessage('friends.tests.data', 'linkedin_contacts.json'))
     @mock.patch('friends.protocols.linkedin.LinkedIn._login',
@@ -118,65 +123,30 @@
         self.assertEqual(
             push.mock_calls,
             [mock.call(
-                {'siteStandardProfileRequest':
-                 {'url': 'https://www.linkedin.com'},
-                 'pictureUrl': 'http://m.c.lnkd.licdn.com',
-                 'apiStandardProfileRequest':
-                 {'url': 'http://api.linkedin.com',
-                  'headers': {'_total': 1, 'values':
-                              [{'value': 'name:', 'name': 'x-li-auth-token'}]}},
-                 'industry': 'Computer Network Security',
-                 'lastName': 'A',
-                 'firstName': 'H',
-                 'headline': 'Unix Administrator at NVIDIA',
-                 'location': {'name': 'Pune Area, India',
-                              'country': {'code': 'in'}},
-                 'id': 'IFDI'}),
-
-             mock.call(
-                 {'siteStandardProfileRequest':
-                  {'url': 'https://www.linkedin.com'},
-                  'pictureUrl': 'http://m.c.lnkd.licdn.com',
-                  'apiStandardProfileRequest':
-                  {'url': 'http://api.linkedin.com',
-                   'headers': {'_total': 1, 'values':
-                               [{'value': 'name:', 'name': 'x-li-auth-token'}]}},
-                  'industry': 'Food Production',
-                  'lastName': 'A',
-                  'firstName': 'C',
-                  'headline': 'Recent Graduate, Simon Fraser University',
-                  'location': {'name': 'Vancouver, Canada Area',
-                               'country': {'code': 'ca'}},
-                  'id': 'AefF'}),
-
-             mock.call(
-                 {'siteStandardProfileRequest':
-                  {'url': 'https://www.linkedin.com'},
-                  'pictureUrl': 'http://m.c.lnkd.licdn.com',
-                  'apiStandardProfileRequest':
-                  {'url': 'http://api.linkedin.com',
-                   'headers': {'_total': 1, 'values':
-                               [{'value': 'name:', 'name': 'x-li-auth-token'}]}},
-                  'industry': 'Computer Software',
-                  'lastName': 'A',
-                  'firstName': 'R',
-                  'headline': 'Technical Lead at Canonical Ltd.',
-                  'location': {'name': 'Auckland, New Zealand',
-                               'country': {'code': 'nz'}},
-                  'id': 'DFdV'}),
-
-             mock.call(
-                 {'siteStandardProfileRequest':
-                  {'url': 'https://www.linkedin.com'},
-                  'pictureUrl': 'http://m.c.lnkd.licdn.com',
-                  'apiStandardProfileRequest':
-                  {'url': 'http://api.linkedin.com',
-                   'headers': {'_total': 1, 'values':
-                               [{'value': 'name:', 'name': 'x-li-auth-token'}]}},
-                  'industry': 'Photography',
-                  'lastName': 'Z',
-                  'firstName': 'A',
-                  'headline': 'Sales manager at McBain Camera',
-                  'location': {'name': 'Edmonton, Canada Area',
-                               'country': {'code': 'ca'}},
-                  'id': 'xkBU'})])
+                {'X-URIS': 'https://www.linkedin.com',
+                 'X-FOLKS-WEB-SERVICES-IDS': {
+                     'linkedin-id': 'IFDI',
+                     'remote-full-name': 'H A'},
+                 'linkedin-name': 'H A',
+                 'linkedin-id': 'IFDI'}),
+             mock.call(
+                 {'X-URIS': 'https://www.linkedin.com',
+                  'X-FOLKS-WEB-SERVICES-IDS': {
+                      'linkedin-id': 'AefF',
+                      'remote-full-name': 'C A'},
+                  'linkedin-name': 'C A',
+                  'linkedin-id': 'AefF'}),
+             mock.call(
+                 {'X-URIS': 'https://www.linkedin.com',
+                  'X-FOLKS-WEB-SERVICES-IDS': {
+                      'linkedin-id': 'DFdV',
+                      'remote-full-name': 'R A'},
+                  'linkedin-name': 'R A',
+                  'linkedin-id': 'DFdV'}),
+             mock.call(
+                 {'X-URIS': 'https://www.linkedin.com',
+                  'X-FOLKS-WEB-SERVICES-IDS': {
+                      'linkedin-id': 'xkBU',
+                      'remote-full-name': 'A Z'},
+                  'linkedin-name': 'A Z',
+                  'linkedin-id': 'xkBU'})])

=== modified file 'friends/tests/test_protocols.py'
--- friends/tests/test_protocols.py	2013-06-21 20:17:07 +0000
+++ friends/tests/test_protocols.py	2013-07-20 03:25:30 +0000
@@ -440,7 +440,8 @@
     # with-statement in Base._login().
 
     def test_features(self):
-        self.assertEqual(MyProtocol.get_features(), ['feature_1', 'feature_2'])
+        self.assertEqual(MyProtocol.get_features(),
+                         ['delete_contacts', 'feature_1', 'feature_2'])
 
     def test_linkify_string(self):
         # String with no URL is unchanged.

=== modified file 'friends/tests/test_twitter.py'
--- friends/tests/test_twitter.py	2013-06-18 22:00:44 +0000
+++ friends/tests/test_twitter.py	2013-07-20 03:25:30 +0000
@@ -552,56 +552,6 @@
         get_url.assert_called_with(
             'https://api.twitter.com/1.1/search/tweets.json?q=hello')
 
-    def test_getfriendsids(self):
-        get_url = self.protocol._get_url = mock.Mock(
-            return_value={"ids":[1,2,3]})
-        ids = self.protocol._getfriendsids()
-
-        get_url.assert_called_with(
-            'https://api.twitter.com/1.1/friends/ids.json'
-            )
-        self.assertEqual(ids, [1,2,3])
-
-    def test_showuser(self):
-        get_url = self.protocol._get_url = mock.Mock(
-            return_value={"name":"Alice"})
-        userdata = self.protocol._showuser(1)
-
-        get_url.assert_called_with(
-            'https://api.twitter.com/1.1/users/show.json?user_id=1'
-            )
-        self.assertEqual(userdata, {"name":"Alice"})
-
-    def test_create_contact(self, *mocks):
-        # Receive the users friends.
-        bare_contact = {'name': 'Alice Bob',
-                        'screen_name': 'alice_bob',
-                        'id': 13579}
-
-        eds_contact = self.protocol._create_contact(bare_contact)
-        twitter_id_attr = eds_contact.get_attribute('twitter-id')
-        self.assertEqual(twitter_id_attr.get_value(), '13579')
-        twitter_name_attr = eds_contact.get_attribute('twitter-name')
-        self.assertEqual(twitter_name_attr.get_value(), 'Alice Bob')
-        web_service_addrs = eds_contact.get_attribute('X-FOLKS-WEB-SERVICES-IDS')
-        params= web_service_addrs.get_params()
-        self.assertEqual(len(params), 2)
-
-        test_remote_name = False
-        test_twitter_id = False
-
-        for p in params:
-            if p.get_name() == 'remote-full-name':
-                self.assertEqual(len(p.get_values()), 1)
-                self.assertEqual(p.get_values()[0], 'Alice Bob')
-                test_remote_name = True
-            if p.get_name() == 'twitter-id':
-                self.assertEqual(len(p.get_values()), 1)
-                self.assertEqual(p.get_values()[0], '13579')
-                test_twitter_id = True
-
-        self.assertTrue(test_remote_name and test_twitter_id)
-
     @mock.patch('friends.protocols.twitter.time.sleep')
     def test_rate_limiter_first_time(self, sleep):
         # The first time we see a URL, there is no rate limiting.
@@ -747,3 +697,34 @@
         # sleep 100 seconds between each call.
         self.protocol.home()
         sleep.assert_called_with(100.0)
+
+    def test_contacts(self):
+        get = self.protocol._get_url = mock.Mock(
+            return_value=dict(ids=[1,2],name='Bob',screen_name='bobby'))
+        prev = self.protocol._previously_stored_contact = mock.Mock(return_value=False)
+        push = self.protocol._push_to_eds = mock.Mock()
+        self.assertEqual(self.protocol.contacts(), 2)
+        self.assertEqual(
+            get.call_args_list,
+            [mock.call('https://api.twitter.com/1.1/friends/ids.json'),
+             mock.call(url='https://api.twitter.com/1.1/users/show.json?user_id=1'),
+             mock.call(url='https://api.twitter.com/1.1/users/show.json?user_id=2')])
+        self.assertEqual(
+            prev.call_args_list,
+            [mock.call('1'), mock.call('2')])
+        self.assertEqual(
+            push.call_args_list,
+            [mock.call({'twitter-id': '1',
+                        'X-FOLKS-WEB-SERVICES-IDS': {
+                            'twitter-id': '1',
+                            'remote-full-name': 'Bob'},
+                        'X-URIS': 'https://twitter.com/bobby',
+                        'twitter-name': 'Bob',
+                        'twitter-nick': 'bobby'}),
+             mock.call({'twitter-id': '2',
+                        'X-FOLKS-WEB-SERVICES-IDS': {
+                            'twitter-id': '2',
+                            'remote-full-name': 'Bob'},
+                        'X-URIS': 'https://twitter.com/bobby',
+                        'twitter-name': 'Bob',
+                        'twitter-nick': 'bobby'})])

=== modified file 'friends/utils/base.py'
--- friends/utils/base.py	2013-07-17 22:15:56 +0000
+++ friends/utils/base.py	2013-07-20 03:25:30 +0000
@@ -33,7 +33,7 @@
 
 from gi.repository import GLib, GObject, EDataServer, EBook, EBookContacts
 
-from friends.errors import FriendsError, ContactsError
+from friends.errors import FriendsError, ContactsError, ignored
 from friends.utils.authentication import Authentication
 from friends.utils.model import Schema, Model, persist_model
 from friends.utils.notify import notify
@@ -186,8 +186,11 @@
     The code in this class has been tested against Facebook, Twitter,
     Flickr, Identica, and Foursquare, and works well with all of them.
     """
-    # Used for EDS stuff.
-    _source_registry = None
+    # Lazily populated when needed for contact syncing.
+    _book_client = None
+    _address_book_name = None
+    _eds_source_registry = None
+    _eds_source = None
 
     # This number serves a guideline (not a hard limit) for the protocol
     # subclasses to download in each refresh.
@@ -201,7 +204,6 @@
         self._account = account
         self._Name = self.__class__.__name__
         self._name = self._Name.lower()
-        self._address_book = 'friends-{}-contacts'.format(self._name)
 
     def _whoami(self, result):
         """Use OAuth login results to identify the authenticating user.
@@ -540,102 +542,83 @@
         Model.get_row(row_id)[col_idx] -= 1
         persist_model()
 
-    def _new_book_client(self, source):
-        client = EBook.BookClient.new(source)
-        client.open_sync(False, None)
-        return client
+    def _prepare_eds_connections(self, allow_creation=True):
+        """Lazily establish a connection to EDS."""
+        if None not in (self._address_book_name, self._eds_source_registry,
+                        self._eds_source, self._book_client):
+            return
+
+        self._address_book_name = 'friends-{}-contacts'.format(self._name)
+        self._eds_source_registry = EDataServer.SourceRegistry.new_sync(None)
+
+        self._eds_source = self._eds_source_registry.ref_source(
+            self._address_book_name)
+
+        # First run? Might need to create the EDS source!
+        if allow_creation and self._eds_source is None:
+            self._eds_source = EDataServer.Source.new_with_uid(
+                self._address_book_name, None)
+            self._eds_source.set_display_name(self._address_book_name)
+            self._eds_source.set_parent('local-stub')
+            self._eds_source.get_extension(
+                EDataServer.SOURCE_EXTENSION_ADDRESS_BOOK
+            ).set_backend_name('local')
+            self._eds_source_registry.commit_source_sync(self._eds_source, None)
+
+        if self._eds_source is not None:
+            self._book_client = EBook.BookClient.connect_sync(self._eds_source, None)
 
     def _push_to_eds(self, contact):
-        source_match = self._get_eds_source()
-        if source_match is None:
+        self._prepare_eds_connections()
+        contact = self._create_contact(contact)
+        if not self._book_client.add_contact_sync(contact, None):
+            raise ContactsError('Failed to save contact {!r}'.format(contact))
+
+    def _previously_stored_contact(self, search_term):
+        self._prepare_eds_connections()
+        query = EBookContacts.BookQuery.vcard_field_test(
+            '{}-id'.format(self._name), EBookContacts.BookQueryTest.IS, search_term)
+        success, result = self._book_client.get_contacts_sync(query.to_string(), None)
+        if not success:
             raise ContactsError(
-                '{} does not have an address book.'.format(
-                    self._address_book))
-        client = self._new_book_client(source_match)
-        success = client.add_contact_sync(contact, None)
-        if not success:
-            raise ContactsError('Failed to save contact {!r}', contact)
-
-    def _get_eds_source_registry(self):
-        if self._source_registry is None:
-            self._source_registry = EDataServer.SourceRegistry.new_sync(None)
-
-    def _create_eds_source(self):
-        self._get_eds_source_registry()
-        source = EDataServer.Source.new(None, None)
-        source.set_display_name(self._address_book)
-        source.set_parent('local-stub')
-        extension = source.get_extension(
-            EDataServer.SOURCE_EXTENSION_ADDRESS_BOOK)
-        extension.set_backend_name('local')
-        if self._source_registry.commit_source_sync(source, None):
-            # https://bugzilla.gnome.org/show_bug.cgi?id=685986
-            # Potential race condition - need to sleep for a
-            # couple of cycles to ensure the registry will return
-            # a valid source object after commiting. Evolution fix
-            # on the way but for now we need this.
-            time.sleep(2)
-            return self._source_registry.ref_source(source.get_uid())
-
-    def _get_eds_source(self):
-        self._get_eds_source_registry()
-        for previous_source in self._source_registry.list_sources(None):
-            if previous_source.get_display_name() == self._address_book:
-                return self._source_registry.ref_source(
-                    previous_source.get_uid())
-        # if we got this far, then the source doesn't exist; create it
-        return self._create_eds_source()
-
-    def _previously_stored_contact(self, source, field, search_term):
-        client = self._new_book_client(source)
-        query = EBookContacts.BookQuery.vcard_field_test(
-            field, EBookContacts.BookQueryTest.IS, search_term)
-        success, result = client.get_contacts_sync(query.to_string(), None)
-        if not success:
-            raise ContactsError('Search failed on field {}'.format(field))
+                'Id field is missing in {} address book.'.format(self._Name))
         return len(result) > 0
 
-    def _delete_service_contacts(self, source):
-        client = self._new_book_client(source)
-        query = EBook.book_query_any_field_contains('')
-        success, results = client.get_contacts_sync(query.to_string(), None)
-        if not success:
-            raise ContactsError('Search for delete all contacts failed')
-        log.debug('Found {} contacts to delete'.format(len(results)))
-        for contact in results:
-            log.debug(
-                'Deleting contact {}'.format(
-                    contact.get_property('full-name')))
-            client.remove_contact_sync(contact, None)
-        return True
-
-    def _create_contact(self, user_fullname, user_nickname,
-                        social_network_attrs):
+    def _create_contact(self, info):
         """Build a VCard based on a dict representation of a contact."""
-        vcard = EBookContacts.VCard.new()
-        info = social_network_attrs
+        contact = EBookContacts.Contact.new()
 
-        for key, val in info.items():
+        for key, value in info.items():
             attr = EBookContacts.VCardAttribute.new(
                 'social-networking-attributes', key)
-            if isinstance(val, dict):
-                for subkey, subval in val.items():
-                    param = EBookContacts.VCardAttributeParam.new(subkey)
-                    param.add_value(subval)
-                    attr.add_param(param);
+            if hasattr(value, 'items'):
+                for subkey, subval in value.items():
+                    if subval is not None:
+                        param = EBookContacts.VCardAttributeParam.new(subkey)
+                        param.add_value(subval)
+                        attr.add_param(param);
+            elif value is not None:
+                attr.add_value(value)
             else:
-                attr.add_value(val)
-            vcard.add_attribute(attr)
-
-        contact = EBookContacts.Contact.new_from_vcard(
-            vcard.to_string(EBookContacts.VCardFormat(1)))
-        contact.set_property('full-name', user_fullname)
-        if user_nickname is not None:
-            contact.set_property('nickname', user_nickname)
-
-        log.debug('Creating new contact for {}'.format(user_fullname))
+                continue
+            contact.add_attribute(attr)
+
+        properties = (('full-name', '{}-name'),
+                      ('nickname', '{}-nick'))
+        for prop, key in properties:
+            value = info.get(key.format(self._name))
+            if value is not None:
+                contact.set_property(prop, value)
+                log.debug('New contact got {}: {}'.format(prop, value))
         return contact
 
+    @feature
+    def delete_contacts(self):
+        """Remove all synced contacts from this social network."""
+        self._prepare_eds_connections(allow_creation=False)
+        with ignored(GLib.GError, AttributeError):
+            return self._eds_source.remove_sync(None)
+
     @classmethod
     def get_features(cls):
         """Report what public operations we expose over DBus."""