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

[Robert Bruce Park]

Add LinkedIn support.

So close to landing this! Just need to write a test or two for the contacts implementation.

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

204. By Robert Bruce Park on 2013-07-17

Safer default value for result.get().

205. By Robert Bruce Park on 2013-07-18

Scrubbed demo data and test coverage for LinkedIn contacts.

[Robert Bruce Park (robru)]

review: Approve

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'debian/control'
--- debian/control	2013-07-08 15:17:44 +0000
+++ debian/control	2013-07-18 03:36:30 +0000
@@ -78,7 +78,7 @@
 
 Package: friends-facebook
 Architecture: all
-Depends: friends, 
+Depends: friends,
          ${misc:Depends},
          ${python3:Depends},
          account-plugin-facebook,
@@ -87,7 +87,7 @@
 
 Package: friends-twitter
 Architecture: all
-Depends: friends, 
+Depends: friends,
          ${misc:Depends},
          ${python3:Depends},
          account-plugin-twitter,
@@ -96,7 +96,7 @@
 
 Package: friends-identica
 Architecture: all
-Depends: friends, 
+Depends: friends,
          ${misc:Depends},
          ${python3:Depends},
          account-plugin-identica,
@@ -105,7 +105,7 @@
 
 Package: friends-foursquare
 Architecture: all
-Depends: friends, 
+Depends: friends,
          ${misc:Depends},
          ${python3:Depends},
          account-plugin-foursquare,
@@ -114,7 +114,7 @@
 
 Package: friends-flickr
 Architecture: all
-Depends: friends, 
+Depends: friends,
          ${misc:Depends},
          ${python3:Depends},
          account-plugin-flickr,
@@ -123,9 +123,18 @@
 
 Package: friends-instagram
 Architecture: all
-Depends: friends,
+Depends: account-plugin-instagram,
+         friends,
          ${misc:Depends},
          ${python3:Depends},
-         account-plugin-instagram,
 Description: Social integration with the desktop - Instagram
  Provides social networking integration with the desktop
+
+Package: friends-linkedin
+Architecture: all
+Depends: account-plugin-linkedin,
+         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-07-18 03:36:30 +0000
@@ -0,0 +1,1 @@
+usr/lib/python3/dist-packages/friends/protocols/linkedin*

=== modified file 'friends/protocols/facebook.py'
--- friends/protocols/facebook.py	2013-06-18 22:00:44 +0000
+++ friends/protocols/facebook.py	2013-07-18 03:36:30 +0000
@@ -37,7 +37,6 @@
 PERMALINK = URL_BASE.format(subdomain='www') + '{id}'
 API_BASE = URL_BASE.format(subdomain='graph') + '{id}'
 ME_URL = API_BASE.format(id='me')
-FACEBOOK_ADDRESS_BOOK = 'friends-facebook-contacts'
 STORY_PERMALINK = PERMALINK + '/posts/{post_id}'
 
 
@@ -364,18 +363,13 @@
         if gender is not None:
             attrs['X-GENDER'] = gender
 
-        contact = Base._create_contact(
-            self, user_fullname, user_nickname, attrs)
-
-        return contact
+        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(FACEBOOK_ADDRESS_BOOK)
-        if source is None:
-            source = self._create_eds_source(FACEBOOK_ADDRESS_BOOK)
+        source = self._get_eds_source()
 
         for contact in contacts:
             if self._previously_stored_contact(
@@ -386,12 +380,12 @@
                     contact['name'], contact['id']))
             full_contact = self._fetch_contact(contact['id'])
             eds_contact = self._create_contact(full_contact)
-            self._push_to_eds(FACEBOOK_ADDRESS_BOOK, eds_contact)
+            self._push_to_eds(eds_contact)
 
         return len(contacts)
 
     def delete_contacts(self):
-        source = self._get_eds_source(FACEBOOK_ADDRESS_BOOK)
+        source = self._get_eds_source()
         return self._delete_service_contacts(source)
 
 

=== added file 'friends/protocols/linkedin.py'
--- friends/protocols/linkedin.py	1970-01-01 00:00:00 +0000
+++ friends/protocols/linkedin.py	2013-07-18 03:36:30 +0000
@@ -0,0 +1,137 @@
+# 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 logging
+
+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__)
+
+
+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_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')
+
+        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', 0)
+        # We need to divide by 1000 here, as LinkedIn's timestamps have
+        # milliseconds.
+        iso_time = iso8601utc(int(timestamp/1000))
+
+        likes = entry.get('numLikes', 0)
+
+        if None in (message_id, status):
+            # Something went wrong; just ignore this malformed message.
+            return
+
+        args = dict(
+             message_id=message_id,
+             stream=stream,
+             message=status,
+             likes=likes,
+             sender_id=person_id,
+             sender=name,
+             icon_uri=picture,
+             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()
+        for update in result.get('values', []):
+            self._publish_entry(update)
+        return self._get_n_rows()
+
+    @feature
+    def receive(self):
+        """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()
+
+        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))
+
+        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-06-18 22:00:44 +0000
+++ friends/protocols/twitter.py	2013-07-18 03:36:30 +0000
@@ -34,9 +34,6 @@
 from friends.errors import FriendsError, ignored
 
 
-TWITTER_ADDRESS_BOOK = 'friends-twitter-contacts'
-
-
 log = logging.getLogger(__name__)
 
 
@@ -388,18 +385,13 @@
             'twitter-id': str(userdata['id']),
             }
 
-        contact = Base._create_contact(
-            self, user_fullname, user_nickname, attrs)
-
-        return contact
+        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(TWITTER_ADDRESS_BOOK)
-        if source is None:
-            source = self._create_eds_source(TWITTER_ADDRESS_BOOK)
+        source = self._get_eds_source()
 
         for contact in contacts:
             twitterid = str(contact)
@@ -410,11 +402,11 @@
                 eds_contact = self._create_contact(full_contact)
             except FriendsError:
                 continue
-            self._push_to_eds(TWITTER_ADDRESS_BOOK, eds_contact)
+            self._push_to_eds(eds_contact)
         return len(contacts)
 
     def delete_contacts(self):
-        source = self._get_eds_source(TWITTER_ADDRESS_BOOK)
+        source = self._get_eds_source()
         return self._delete_service_contacts(source)
 
 

=== added file 'friends/tests/data/linkedin_contacts.json'
--- friends/tests/data/linkedin_contacts.json	1970-01-01 00:00:00 +0000
+++ friends/tests/data/linkedin_contacts.json	2013-07-18 03:36:30 +0000
@@ -0,0 +1,53 @@
+{"_total": 4,
+ "values": [{"apiStandardProfileRequest": {"headers": {"_total": 1,
+                                                       "values": [{"name": "x-li-auth-token",
+                                                                   "value": "name:"}]},
+                                           "url": "http://api.linkedin.com"},
+             "firstName": "H",
+             "headline": "Unix Administrator at NVIDIA",
+             "id": "IFDI",
+             "industry": "Computer Network Security",
+             "lastName": "A",
+             "location": {"country": {"code": "in"},
+                          "name": "Pune Area, India"},
+             "pictureUrl": "http://m.c.lnkd.licdn.com",
+             "siteStandardProfileRequest": {"url": "https://www.linkedin.com"}},
+            {"apiStandardProfileRequest": {"headers": {"_total": 1,
+                                                       "values": [{"name": "x-li-auth-token",
+                                                                   "value": "name:"}]},
+                                           "url": "http://api.linkedin.com"},
+             "firstName": "C",
+             "headline": "Recent Graduate, Simon Fraser University",
+             "id": "AefF",
+             "industry": "Food Production",
+             "lastName": "A",
+             "location": {"country": {"code": "ca"},
+                          "name": "Vancouver, Canada Area"},
+             "pictureUrl": "http://m.c.lnkd.licdn.com",
+             "siteStandardProfileRequest": {"url": "https://www.linkedin.com"}},
+            {"apiStandardProfileRequest": {"headers": {"_total": 1,
+                                                       "values": [{"name": "x-li-auth-token",
+                                                                   "value": "name:"}]},
+                                           "url": "http://api.linkedin.com"},
+             "firstName": "R",
+             "headline": "Technical Lead at Canonical Ltd.",
+             "id": "DFdV",
+             "industry": "Computer Software",
+             "lastName": "A",
+             "location": {"country": {"code": "nz"},
+                          "name": "Auckland, New Zealand"},
+             "pictureUrl": "http://m.c.lnkd.licdn.com",
+             "siteStandardProfileRequest": {"url": "https://www.linkedin.com"}},
+            {"apiStandardProfileRequest": {"headers": {"_total": 1,
+                                                       "values": [{"name": "x-li-auth-token",
+                                                                   "value": "name:"}]},
+                                           "url": "http://api.linkedin.com"},
+             "firstName": "A",
+             "headline": "Sales manager at McBain Camera",
+             "id": "xkBU",
+             "industry": "Photography",
+             "lastName": "Z",
+             "location": {"country": {"code": "ca"},
+                          "name": "Edmonton, Canada Area"},
+             "pictureUrl": "http://m.c.lnkd.licdn.com",
+             "siteStandardProfileRequest": {"url": "https://www.linkedin.com"}}]}

=== added file 'friends/tests/data/linkedin_receive.json'
--- friends/tests/data/linkedin_receive.json	1970-01-01 00:00:00 +0000
+++ friends/tests/data/linkedin_receive.json	2013-07-18 03:36:30 +0000
@@ -0,0 +1,177 @@
+{"_count": 10,
+ "_start": 0,
+ "_total": 23,
+ "values": [{"isCommentable": true,
+             "isLikable": true,
+             "isLiked": false,
+             "likes": {"_total": 1,
+                       "values": [{"person": {"firstName": "Tigran",
+                                              "headline": "Software Engineer at Cornerstone OnDemand",
+                                              "id": "6f7TDUv",
+                                              "lastName": "K",
+                                              "pictureUrl": "http://m.c.lnkd.licdn.com/mpr/mprx/0_zR-8KkCNtotClCYzyiPKFr9rqDrlCYBM60KFPQftJhzvOMjGuObFeOSfTn_tq4rx8jhPrK"}}]},
+             "numLikes": 1,
+             "timestamp": 1373935626874,
+             "updateComments": {"_total": 0},
+             "updateContent": {"person": {"apiStandardProfileRequest": {"headers": {"_total": 1,
+                                                                                    "values": [{"name": "x-li-auth-token",
+                                                                                                "value": "name:-LNy"}]},
+                                                                        "url": "http://api.linkedin.com/v1/people/Pa0L6dU"},
+                                          "currentStatus": "I'm looking forward to the Udacity Global meetup event here in Portland: http://lnkd.in/dh5MQz\nGreat way to support the next big thing in c…",
+                                          "firstName": "Hobson",
+                                          "headline": "Developer at Building Energy, Inc",
+                                          "id": "ma0LLid",
+                                          "lastName": "L",
+                                          "pictureUrl": "http://m.c.lnkd.licdn.com/mpr/mprx/0_mVxsC0BnN52aqc24yWvoyA5haqc2ZwLCgzLv0EiBGp7n2jTwX-ls_dzgkSVIZu0",
+                                          "siteStandardProfileRequest": {"url": "https://www.linkedin.com/profile/view?id=7375&authType=name&authToken=-LNy&trk=api*a26127*s26893*"}}},
+             "updateKey": "UNIU-73705-576270369559388-SHARE",
+             "updateType": "STAT"},
+            {"isCommentable": true,
+             "isLikable": true,
+             "isLiked": false,
+             "numLikes": 0,
+             "timestamp": 1373900948273,
+             "updateComments": {"_total": 0},
+             "updateContent": {"person": {"firstName": "private",
+                                          "id": "private",
+                                          "lastName": "private"}},
+             "updateKey": "UNIU-1060864-576255824267264-SHARE",
+             "updateType": "STAT"},
+            {"isCommentable": true,
+             "isLikable": true,
+             "isLiked": false,
+             "numLikes": 0,
+             "timestamp": 1373899922654,
+             "updateComments": {"_total": 0},
+             "updateContent": {"person": {"firstName": "private",
+                                          "id": "private",
+                                          "lastName": "private"}},
+             "updateKey": "UNIU-106088-5769411789496-SHARE",
+             "updateType": "STAT"},
+            {"isCommentable": true,
+             "isLikable": true,
+             "isLiked": false,
+             "likes": {"_total": 3,
+                       "values": [{"person": {"firstName": "J. P.",
+                                              "headline": "Software Technologist",
+                                              "id": "GUUXiHdd40",
+                                              "lastName": "N",
+                                              "pictureUrl": "http://m.c.lnkd.licdn.com/mpr/mprx/0_3Y7iZs_hWCTi0d-ZxAJn8XpT_pU-ZxGoW6GSZxT90nXZSnShgSPB4rdoNQi"}},
+                                  {"person": {"firstName": "Tyler",
+                                              "headline": "Senior Associate at Toffler Associates",
+                                              "id": "RCYVRJ",
+                                              "lastName": "S",
+                                              "pictureUrl": "http://m.c.lnkd.licdn.com/mpr/mprx/0_i7W-Lvgud5pur7I-eBpecy7IlZe0yFr_zWdOUMNHHuhiLkRWj8ufDpQBz"}},
+                                  {"person": {"firstName": "Paweł",
+                                              "headline": "Senior programmer at EMG Systems",
+                                              "id": "FjbEJi",
+                                              "lastName": "S",
+                                              "pictureUrl": "http://m.c.lnkd.licdn.com/mpr/mprx/0_SEgTdwePXDoInf9XIm-XfHanGqqoLk3uoLT0aMWtuW4ch4ekYCqF"}}]},
+             "numLikes": 3,
+             "timestamp": 1373638523241,
+             "updateComments": {"_total": 0},
+             "updateContent": {"person": {"firstName": "private",
+                                          "id": "private",
+                                          "lastName": "private"}},
+             "updateKey": "UNIU-106764-5761479649536-SHARE",
+             "updateType": "STAT"},
+            {"isCommentable": true,
+             "isLikable": true,
+             "isLiked": false,
+             "likes": {"_total": 2,
+                       "values": [{"person": {"firstName": "João",
+                                              "headline": "System Engineer",
+                                              "id": "DXmxRB",
+                                              "lastName": "M",
+                                              "pictureUrl": "http://m.c.lnkd.licdn.com/mpr/mprx/0_Vu55rTWdTtWwT-xSwZiP4alVriEVYAwgNpq1vWY_xR7bU0kZ8mjE9"}},
+                                  {"person": {"firstName": "private",
+                                              "id": "private",
+                                              "lastName": "private"}}]},
+             "numLikes": 2,
+             "timestamp": 1373638247645,
+             "updateComments": {"_total": 1,
+                                "values": [{"comment": "Forgot to mention: Floor Drees wrote the article and was the workshop coach",
+                                            "id": 155125,
+                                            "person": {"firstName": "private",
+                                                       "id": "private",
+                                                       "lastName": "private"},
+                                            "sequenceNumber": 0,
+                                            "timestamp": 1373638357000}]},
+             "updateContent": {"person": {"firstName": "private",
+                                          "id": "private",
+                                          "lastName": "private"}},
+             "updateKey": "UNIU-10664-57614646232064-SHARE",
+             "updateType": "STAT"},
+            {"isCommentable": true,
+             "isLikable": true,
+             "isLiked": false,
+             "likes": {"_total": 2,
+                       "values": [{"person": {"firstName": "Tomáš",
+                                              "headline": "Invisible software writer, amateur storyteller and wannabe clown.",
+                                              "id": "37f-Kc",
+                                              "lastName": "J",
+                                              "pictureUrl": "http://m.c.lnkd.licdn.com/mpr/mprx/0_C9Sz75iM9tWx_54nX12tErnWLYY3-joGjcY6V85pwujCGB7"}},
+                                  {"person": {"firstName": "Miguel",
+                                              "headline": "Senior Consultant at Red Hat",
+                                              "id": "RsdH",
+                                              "lastName": "P",
+                                              "pictureUrl": "http://m.c.lnkd.licdn.com/mpr/mprx/0_9-9rsGcir_ciT05XHD8i2Asq4AM_oi4k1ly6SD"}}]},
+             "numLikes": 2,
+             "timestamp": 1373530350025,
+             "updateComments": {"_total": 1,
+                                "values": [{"comment": "Interesting read.....",
+                                            "id": 1369,
+                                            "person": {"firstName": "private",
+                                                       "id": "private",
+                                                       "lastName": "private"},
+                                            "sequenceNumber": 0,
+                                            "timestamp": 1373533027000}]},
+             "updateContent": {"person": {"firstName": "private",
+                                          "id": "private",
+                                          "lastName": "private"}},
+             "updateKey": "UNIU-1064-51227071488-SHARE",
+             "updateType": "STAT"},
+            {"isCommentable": true,
+             "isLikable": true,
+             "isLiked": false,
+             "numLikes": 0,
+             "timestamp": 1373465844294,
+             "updateComments": {"_total": 0},
+             "updateContent": {"person": {"firstName": "private",
+                                          "id": "private",
+                                          "lastName": "private"}},
+             "updateKey": "UNIU-10664-33284581519360-SHARE",
+             "updateType": "STAT"},
+            {"isCommentable": true,
+             "isLikable": true,
+             "isLiked": false,
+             "numLikes": 0,
+             "timestamp": 1373358138541,
+             "updateComments": {"_total": 0},
+             "updateContent": {"person": {"firstName": "private",
+                                          "id": "private",
+                                          "lastName": "private"}},
+             "updateKey": "UNIU-106088-3910880256-SHARE",
+             "updateType": "STAT"},
+            {"isCommentable": true,
+             "isLikable": true,
+             "isLiked": false,
+             "numLikes": 0,
+             "timestamp": 1373354287104,
+             "updateComments": {"_total": 0},
+             "updateContent": {"person": {"firstName": "private",
+                                          "id": "private",
+                                          "lastName": "private"}},
+             "updateKey": "UNIU-10607-13277696-SHARE",
+             "updateType": "STAT"},
+            {"isCommentable": true,
+             "isLikable": true,
+             "isLiked": false,
+             "numLikes": 0,
+             "timestamp": 1373273818071,
+             "updateComments": {"_total": 0},
+             "updateContent": {"person": {"firstName": "private",
+                                          "id": "private",
+                                          "lastName": "private"}},
+             "updateKey": "UNIU-1060884-868226281472-SHARE",
+             "updateType": "STAT"}]}

=== modified file 'friends/tests/test_facebook.py'
--- friends/tests/test_facebook.py	2013-06-18 22:00:44 +0000
+++ friends/tests/test_facebook.py	2013-07-18 03:36:30 +0000
@@ -531,8 +531,9 @@
                         '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'
         # Implicitely fail test if the following raises any exceptions
-        self.protocol._push_to_eds('test-address-book', eds_contact)
+        self.protocol._push_to_eds(eds_contact)
 
     @mock.patch('friends.utils.base.Base._get_eds_source',
                 return_value=None)
@@ -544,10 +545,10 @@
                         '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'
         self.assertRaises(
             ContactsError,
             self.protocol._push_to_eds,
-            'test-address-book',
             eds_contact,
             )
 
@@ -557,7 +558,7 @@
         regmock = self.protocol._source_registry = mock.Mock()
         regmock.ref_source = lambda x: x
 
-        result = self.protocol._create_eds_source('facebook-test-address')
+        result = self.protocol._create_eds_source()
         self.assertEqual(result, 'test-source-uid')
 
     @mock.patch('gi.repository.EBook.BookClient.new',
@@ -577,13 +578,6 @@
         reg_mock = self.protocol._source_registry = mock.Mock()
         reg_mock.list_sources.return_value = [FakeSource()]
         reg_mock.ref_source = lambda x: x
-        result = self.protocol._get_eds_source('test-facebook-contacts')
+        self.protocol._address_book = 'test-facebook-contacts'
+        result = self.protocol._get_eds_source()
         self.assertEqual(result, 1345245)
-
-    @mock.patch('friends.utils.base.Base._get_eds_source_registry',
-                mock.Mock())
-    @mock.patch('friends.utils.base.Base._source_registry',
-                mock.Mock(**{'list_sources.return_value': []}))
-    def test_unsuccessful_get_eds_source(self, *mocks):
-        result = self.protocol._get_eds_source('test-incorrect-contacts')
-        self.assertIsNone(result)

=== added file 'friends/tests/test_linkedin.py'
--- friends/tests/test_linkedin.py	1970-01-01 00:00:00 +0000
+++ friends/tests/test_linkedin.py	2013-07-18 03:36:30 +0000
@@ -0,0 +1,182 @@
+# friends-dispatcher -- send & receive messages from any social network
+# Copyright (C) 2012  Canonical Ltd
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License 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/>.
+
+"""Test the LinkedIn plugin."""
+
+
+__all__ = [
+    'TestLinkedIn',
+    ]
+
+
+import unittest
+
+from friends.protocols.linkedin import LinkedIn
+from friends.tests.mocks import FakeAccount, FakeSoupMessage, LogMock
+from friends.tests.mocks import TestModel, mock
+from friends.errors import AuthorizationError
+
+
[e-mail]('friends.utils.http._soup', mock.Mock())
[e-mail]('friends.utils.base.notify', mock.Mock())
+class TestLinkedIn(unittest.TestCase):
+    """Test the LinkedIn API."""
+
+    def setUp(self):
+        TestModel.clear()
+        self.account = FakeAccount()
+        self.protocol = LinkedIn(self.account)
+        self.log_mock = LogMock('friends.utils.base',
+                                'friends.protocols.linkedin')
+
+    def tearDown(self):
+        # Ensure that any log entries we haven't tested just get consumed so
+        # as to isolate out test logger from other tests.
+        self.log_mock.stop()
+
+    @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.linkedin.Downloader.get_json',
+                return_value=None)
+    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.__init__',
+                return_value=None)
+    @mock.patch('friends.utils.authentication.Authentication.login',
+                return_value=dict(AccessToken='some clever fake data'))
+    @mock.patch('friends.protocols.linkedin.Downloader.get_json',
+                return_value=dict(id='blerch', firstName='Bob', lastName='Loblaw'))
+    def test_successful_authentication(self, *mocks):
+        self.assertTrue(self.protocol._login())
+        self.assertEqual(self.account.user_name, 'Bob Loblaw')
+        self.assertEqual(self.account.user_id, 'blerch')
+        self.assertEqual(self.account.access_token, 'some clever fake data')
+
+    @mock.patch('friends.utils.base.Model', TestModel)
+    @mock.patch('friends.utils.http.Soup.Message',
+                FakeSoupMessage('friends.tests.data', 'linkedin_receive.json'))
+    @mock.patch('friends.protocols.linkedin.LinkedIn._login',
+                return_value=True)
+    @mock.patch('friends.utils.base._seen_ids', {})
+    def test_home(self, *mocks):
+        self.account.access_token = 'access'
+        self.assertEqual(0, TestModel.get_n_rows())
+        self.assertEqual(self.protocol.home(), 1)
+        self.assertEqual(1, TestModel.get_n_rows())
+        self.maxDiff = None
+
+        self.assertEqual(
+            list(TestModel.get_row(0)),
+            ['linkedin', 88, 'UNIU-73705-576270369559388-SHARE', 'messages',
+             'Hobson L', 'ma0LLid', '', False, '2013-07-16T00:47:06Z',
+             'I\'m looking forward to the Udacity Global meetup event here in '
+             'Portland: <a href="http://lnkd.in/dh5MQz">http://lnkd.in/dh5MQz'
+             '</a>\nGreat way to support the next big thing in c…',
+             'http://m.c.lnkd.licdn.com/mpr/mprx/0_mVxsC0BnN52aqc24yWvoyA5haqc2Z'
+             'wLCgzLv0EiBGp7n2jTwX-ls_dzgkSVIZu0',
+             'https://www.linkedin.com/profile/view?id=7375&authType=name'
+             '&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',
+                return_value=True)
+    def test_contacts(self, *mocks):
+        push = self.protocol._push_to_eds = mock.Mock()
+        prev = self.protocol._previously_stored_contact = mock.Mock(return_value=False)
+        token = self.protocol._get_access_token = mock.Mock(return_value='foo')
+        self.protocol._create_contact = lambda arg:arg
+        self.assertEqual(self.protocol.contacts(), 4)
+        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'})])

=== modified file 'friends/utils/base.py'
--- friends/utils/base.py	2013-06-21 20:17:07 +0000
+++ friends/utils/base.py	2013-07-18 03:36:30 +0000
@@ -201,6 +201,7 @@
         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.
@@ -347,7 +348,7 @@
                 account_id=self._account.id
                 )
             )
-# linkify the message
+        # linkify the message
         orig_message = kwargs.get('message', '')
         kwargs['message'] = linkify_string(orig_message)
         args = []
@@ -544,12 +545,12 @@
         client.open_sync(False, None)
         return client
 
-    def _push_to_eds(self, online_service, contact):
-        source_match = self._get_eds_source(online_service)
+    def _push_to_eds(self, contact):
+        source_match = self._get_eds_source()
         if source_match is None:
             raise ContactsError(
                 '{} does not have an address book.'.format(
-                    online_service))
+                    self._address_book))
         client = self._new_book_client(source_match)
         success = client.add_contact_sync(contact, None)
         if not success:
@@ -559,10 +560,10 @@
         if self._source_registry is None:
             self._source_registry = EDataServer.SourceRegistry.new_sync(None)
 
-    def _create_eds_source(self, online_service):
+    def _create_eds_source(self):
         self._get_eds_source_registry()
         source = EDataServer.Source.new(None, None)
-        source.set_display_name(online_service)
+        source.set_display_name(self._address_book)
         source.set_parent('local-stub')
         extension = source.get_extension(
             EDataServer.SOURCE_EXTENSION_ADDRESS_BOOK)
@@ -576,12 +577,14 @@
             time.sleep(2)
             return self._source_registry.ref_source(source.get_uid())
 
-    def _get_eds_source(self, online_service):
+    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() == online_service:
+            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)
@@ -612,15 +615,16 @@
         vcard = EBookContacts.VCard.new()
         info = social_network_attrs
 
-        for i in info:
-            attr = EBookContacts.VCardAttribute.new('social-networking-attributes', i)
-            if type(info[i]) == type(dict()):
-                for j in info[i]:
-                    param = EBookContacts.VCardAttributeParam.new(j)
-                    param.add_value(info[i][j])
+        for key, val 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);
             else:
-                attr.add_value(info[i])
+                attr.add_value(val)
             vcard.add_attribute(attr)
 
         contact = EBookContacts.Contact.new_from_vcard(