Upgrade to v2 API

* switch to use `r_liteprofile` (reduce number of fields)
* parse `profilePicture` response (use last picture in the array)

Email parsing comes next.

Author: pjg

lib/omniauth/strategies/linkedin.rb

@@ -14,34 +14,31 @@ class LinkedIn < OmniAuth::Strategies::OAuth2
         :token_url => 'https://www.linkedin.com/oauth/v2/accessToken'
       }
 
-      option :scope, 'r_basicprofile r_emailaddress'
-      option :fields, ['id', 'email-address', 'first-name', 'last-name', 'headline', 'location', 'industry', 'picture-url', 'public-profile-url']
+      option :scope, 'r_liteprofile r_emailaddress'
+      option :fields, ['id', 'firstName', 'lastName', 'profilePicture(displayImage~:playableStreams)']
 
       # These are called after authentication has succeeded. If
       # possible, you should try to set the UID without making
       # additional calls (if the user id is returned with the token
       # or as a URI parameter). This may not be possible with all
       # providers.
-      uid { raw_info['id'] }
+      uid do
+        raw_info['id']
+      end
 
       info do
         {
-          :name => user_name,
-          :email => raw_info['emailAddress'],
-          :nickname => user_name,
-          :first_name => raw_info['firstName'],
-          :last_name => raw_info['lastName'],
-          :location => raw_info['location'],
-          :description => raw_info['headline'],
-          :image => raw_info['pictureUrl'],
-          :urls => {
-            'public_profile' => raw_info['publicProfileUrl']
-          }
+          :email => nil,
+          :first_name => localized_field('firstName'),
+          :last_name => localized_field('lastName'),
+          :picture_url => picture_url
         }
       end
 
       extra do
-        { 'raw_info' => raw_info }
+        {
+          'raw_info' => raw_info
+        }
       end
 
       def callback_url
@@ -52,22 +49,50 @@ def callback_url
 
       def access_token
         ::OAuth2::AccessToken.new(client, oauth2_access_token.token, {
-          :mode => :query,
-          :param_name => 'oauth2_access_token',
           :expires_in => oauth2_access_token.expires_in,
           :expires_at => oauth2_access_token.expires_at
         })
       end
 
       def raw_info
-        @raw_info ||= access_token.get("/v1/people/~:(#{options.fields.join(',')})?format=json").parsed
+        @raw_info ||= access_token.get(profile_endpoint).parsed
       end
 
       private
 
-      def user_name
-        name = "#{raw_info['firstName']} #{raw_info['lastName']}".strip
-        name.empty? ? nil : name
+      def localized_field field_name
+        return unless localized_field_available? field_name
+
+        raw_info[field_name]['localized'][field_locale(field_name)]
+      end
+
+      def field_locale field_name
+        "#{ raw_info[field_name]['preferredLocale']['language'] }_" \
+          "#{ raw_info[field_name]['preferredLocale']['country'] }"
+      end
+
+      def localized_field_available? field_name
+        raw_info[field_name] && raw_info[field_name]['localized']
+      end
+
+      def picture_url
+        return unless picture_available?
+
+        picture_references.last['identifiers'].first['identifier']
+      end
+
+      def picture_available?
+        raw_info['profilePicture'] &&
+          raw_info['profilePicture']['displayImage~'] &&
+          picture_references
+      end
+
+      def picture_references
+        raw_info['profilePicture']['displayImage~']['elements']
+      end
+
+      def profile_endpoint
+        "/v2/me?projection=(#{ options.fields.join(',') })"
       end
     end
   end

spec/omniauth/strategies/linkedin_spec.rb

@@ -4,7 +4,7 @@
 describe OmniAuth::Strategies::LinkedIn do
   subject { OmniAuth::Strategies::LinkedIn.new(nil) }
 
-  it 'should add a camelization for itself' do
+  it 'adds camelization for itself' do
     expect(OmniAuth::Utils.camelize('linkedin')).to eq('LinkedIn')
   end
 
@@ -13,11 +13,11 @@
       expect(subject.client.site).to eq('https://api.linkedin.com')
     end
 
-    it 'has correct authorize url' do
+    it 'has correct `authorize_url`' do
       expect(subject.client.options[:authorize_url]).to eq('https://www.linkedin.com/oauth/v2/authorization?response_type=code')
     end
 
-    it 'has correct token url' do
+    it 'has correct `token_url`' do
       expect(subject.client.options[:token_url]).to eq('https://www.linkedin.com/oauth/v2/accessToken')
     end
   end
@@ -30,7 +30,7 @@
 
   describe '#uid' do
     before :each do
-      allow(subject).to receive(:raw_info) { { 'id' => 'uid' } }
+      allow(subject).to receive(:raw_info) { Hash['id' => 'uid'] }
     end
 
     it 'returns the id from raw_info' do
@@ -44,47 +44,55 @@
     end
 
     context 'and therefore has all the necessary fields' do
-      it { expect(subject.info).to have_key :name }
-      it { expect(subject.info).to have_key :email }
-      it { expect(subject.info).to have_key :nickname }
-      it { expect(subject.info).to have_key :first_name }
-      it { expect(subject.info).to have_key :last_name }
-      it { expect(subject.info).to have_key :location }
-      it { expect(subject.info).to have_key :description }
-      it { expect(subject.info).to have_key :image }
-      it { expect(subject.info).to have_key :urls }
+      specify { expect(subject.info).to have_key :email }
+      specify { expect(subject.info).to have_key :first_name }
+      specify { expect(subject.info).to have_key :last_name }
+      specify { expect(subject.info).to have_key :picture_url }
     end
   end
 
   describe '#extra' do
+    let(:raw_info) { Hash[:foo => 'bar'] }
+
     before :each do
-      allow(subject).to receive(:raw_info) { { :foo => 'bar' } }
+      allow(subject).to receive(:raw_info).and_return raw_info
     end
 
-    it { expect(subject.extra['raw_info']).to eq({ :foo => 'bar' }) }
+    specify { expect(subject.extra['raw_info']).to eq raw_info }
   end
 
   describe '#access_token' do
+    let(:expires_in) { 3600 }
+    let(:expires_at) { 946688400 }
+    let(:token) { 'token' }
+    let(:access_token) do
+      instance_double OAuth2::AccessToken, :expires_in => expires_in,
+        :expires_at => expires_at, :token => token
+    end
+
     before :each do
-      allow(subject).to receive(:oauth2_access_token) { double('oauth2 access token', :expires_in => 3600, :expires_at => 946688400).as_null_object }
+      allow(subject).to receive(:oauth2_access_token).and_return access_token
     end
 
-    it { expect(subject.access_token.expires_in).to eq(3600) }
-    it { expect(subject.access_token.expires_at).to eq(946688400) }
+    specify { expect(subject.access_token.expires_in).to eq expires_in }
+    specify { expect(subject.access_token.expires_at).to eq expires_at }
   end
 
   describe '#raw_info' do
+    let(:access_token) { instance_double OAuth2::AccessToken }
+    let(:parsed_response) { Hash[:foo => 'bar'] }
+    let(:response) { instance_double OAuth2::Response, parsed: parsed_response }
+    let(:profile_endpoint) { '/v2/me?projection=(id,firstName,lastName,profilePicture(displayImage~:playableStreams))' }
+
     before :each do
-      access_token = double('access token')
-      response = double('response', :parsed => { :foo => 'bar' })
+      allow(subject).to receive(:access_token).and_return access_token
+
       expect(access_token).to receive(:get)
-        .with("/v1/people/~:(id,email-address,first-name,last-name,headline,location,industry,picture-url,public-profile-url)?format=json")
+        .with(profile_endpoint)
         .and_return(response)
-
-      allow(subject).to receive(:access_token) { access_token }
     end
 
-    it 'returns parsed response from access token' do
+    it 'returns parsed response from the access token' do
       expect(subject.raw_info).to eq({ :foo => 'bar' })
     end
   end
@@ -96,7 +104,7 @@
       end
 
       it 'sets default scope' do
-        expect(subject.authorize_params['scope']).to eq('r_basicprofile r_emailaddress')
+        expect(subject.authorize_params['scope']).to eq('r_liteprofile r_emailaddress')
       end
     end
   end