linkedin-oauth2 0.1.1 → 1.0.0

data/spec/linked_in/api/search_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper"
+
+describe LinkedIn::Search, helpers: :api do
+  let(:access_token) {"dummy_access_token"}
+  let(:api) {LinkedIn::API.new(access_token)}
+
+  def stub(url)
+    url += "oauth2_access_token=#{access_token}"
+    stub_request(:get, url).to_return(body: '{}')
+  end
+
+  it "lets you search for all your contacts" do
+    stub("https://api.linkedin.com/v1/people-search?")
+    expect(api.search()).to be_kind_of LinkedIn::Mash
+  end
+
+  it "allows a keyword search with no hash" do
+    stub("https://api.linkedin.com/v1/people-search?keywords=Proximate%20Harvard&")
+    expect(api.search("Proximate Harvard")).to be_kind_of LinkedIn::Mash
+  end
+
+  it "allows a keyword search with the kewywords option" do
+    stub("https://api.linkedin.com/v1/people-search?keywords=Proximate%20Harvard&")
+    expect(api.search(keywords: "Proximate Harvard")).to be_kind_of LinkedIn::Mash
+  end
+
+  it "lets you search by an attribute" do
+    stub("https://api.linkedin.com/v1/people-search?school-name=Olin%20College%20of%20Engineering&")
+    expect(api.search(school_name: "Olin College of Engineering")).to be_kind_of LinkedIn::Mash
+  end
+
+  it "combines searches" do
+    stub("https://api.linkedin.com/v1/people-search?first-name=Evan&last-name=Morikawa&")
+    expect(api.search(first_name: "Evan", last_name: "Morikawa")).to be_kind_of LinkedIn::Mash
+  end
+
+  it "searches for specific fields" do
+    stub("https://api.linkedin.com/v1/people-search:(people:(id,first-name,last-name),num-results)?")
+    expect(api.search(fields: [{people: ["id", "first-name", "last-name"]}, "num-results"])).to be_kind_of LinkedIn::Mash
+  end
+
+  it "allows you to pass a sort parameter" do
+    stub("https://api.linkedin.com/v1/people-search?sort=connections&")
+    expect(api.search(sort: "connections")).to be_kind_of LinkedIn::Mash
+  end
+
+  it "it allows start and count parameters" do
+    stub("https://api.linkedin.com/v1/people-search?start=10&count=5&")
+    expect(api.search(start: 10, count: 5)).to be_kind_of LinkedIn::Mash
+  end
+
+  it "it lets you search by facets" do
+    stub("https://api.linkedin.com/v1/people-search:(facets:(code,buckets:(code,name)))?facets=location&")
+
+    fields = {facets: ["code", {buckets: ["code", "name"]}]}
+
+    expect(api.search(fields: fields,
+                      facets: "location")).to be_kind_of LinkedIn::Mash
+  end
+
+  it "lets you search for complex facets" do
+    stub("https://api.linkedin.com/v1/people-search:(facets:(code,buckets:(code,name,count)))?facets=location,network&facet=location,us:84&facet=network,F&")
+
+    fields = {facets: ["code", {buckets: ["code", "name", "count"]}]}
+
+    expect(api.search(fields: fields,
+                      facets: "location,network",
+                      facet: ["location,us:84", "network,F"])
+          ).to be_kind_of LinkedIn::Mash
+  end
+end

data/spec/linked_in/api/share_and_social_stream_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+
+describe LinkedIn::ShareAndSocialStream do
+  let(:access_token) {"dummy_access_token"}
+  let(:api) {LinkedIn::API.new(access_token)}
+
+  def stub(url)
+    url += "oauth2_access_token=#{access_token}"
+    stub_request(:get, url).to_return(body: '{}')
+  end
+
+  it "should be able to view network_updates" do
+    stub("https://api.linkedin.com/v1/people/~/network/updates?")
+    expect(api.network_updates).to be_an_instance_of(LinkedIn::Mash)
+  end
+
+  it "should be able to view network_update's comments" do
+    stub("https://api.linkedin.com/v1/people/~/network/updates/key=network_update_key/update-comments?")
+    expect(api.share_comments("network_update_key")).to be_an_instance_of(LinkedIn::Mash)
+  end
+
+  it "should be able to view network_update's likes" do
+    stub("https://api.linkedin.com/v1/people/~/network/updates/key=network_update_key/likes?")
+    expect(api.share_likes("network_update_key")).to be_an_instance_of(LinkedIn::Mash)
+  end
+
+  it "should be able to share a new status" do
+    stub_request(:post, "https://api.linkedin.com/v1/people/~/shares?oauth2_access_token=#{access_token}").to_return(body: "", status: 201)
+    response = api.add_share(:comment => "Testing, 1, 2, 3")
+    expect(response.body).to eq ""
+    expect(response.status).to eq 201
+  end
+
+  it "returns the shares for a person" do
+    stub("https://api.linkedin.com/v1/people/~/network/updates?type=SHAR&scope=self&after=1234&count=35&")
+    api.shares(:after => 1234, :count => 35)
+  end
+
+  it "should be able to comment on network update" do
+    stub_request(:post, "https://api.linkedin.com/v1/people/~/network/updates/key=SOMEKEY/update-comments?oauth2_access_token=#{access_token}").to_return(body: "", status: 201)
+    response = api.update_comment('SOMEKEY', "Testing, 1, 2, 3")
+    expect(response.body).to eq ""
+    expect(response.status).to eq 201
+  end
+
+  it "should be able to like a network update" do
+    stub_request(:put, "https://api.linkedin.com/v1/people/~/network/updates/key=SOMEKEY/is-liked?oauth2_access_token=#{access_token}").
+      with(:body => "true").to_return(body: "", status: 201)
+    response = api.like_share('SOMEKEY')
+    expect(response.body).to eq ""
+    expect(response.status).to eq 201
+  end
+
+  it "should be able to unlike a network update" do
+    stub_request(:put, "https://api.linkedin.com/v1/people/~/network/updates/key=SOMEKEY/is-liked?oauth2_access_token=#{access_token}").to_return(body: "", status: 201)
+    response = api.unlike_share('SOMEKEY')
+    expect(response.body).to eq ""
+    expect(response.status).to eq 201
+  end
+end

data/spec/linked_in/configuration_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe "LinkedIn configuration" do
+  let(:config_value) { "Foo Bar" }
+
+  let(:site)          { "https://www.linkedin.com"  }
+  let(:token_url)     { "/uas/oauth2/accessToken"   }
+  let(:authorize_url) { "/uas/oauth2/authorization" }
+
+  subject { LinkedIn.config }
+
+  before(:example) do
+    LinkedIn.configure do |config|
+      config.client_id = config_value
+      config.client_secret = config_value
+    end
+  end
+
+  it("has a client_id") do
+    expect(subject.client_id).to eq config_value
+  end
+
+  it("has a client_secret") do
+    expect(subject.client_secret).to eq config_value
+  end
+
+  it("has an aliased api_key") do
+    expect(subject.api_key).to eq config_value
+  end
+
+  it("has an aliased secret_key") do
+    expect(subject.secret_key).to eq config_value
+  end
+
+  it("has the correct default site") do
+    expect(subject.site).to eq site
+  end
+
+  it("has the correct default token_url") do
+    expect(subject.token_url).to eq token_url
+  end
+
+  it("has the correct default authorize_url") do
+    expect(subject.authorize_url).to eq authorize_url
+  end
+end

data/spec/linked_in/connection_spec.rb

@@ -0,0 +1,10 @@
+describe LinkedIn::Connection do
+  it "inherits from Faraday::Connection" do
+    expect(subject).to be_kind_of Faraday::Connection
+  end
+
+  it "has the correct default url" do
+    url = LinkedIn.config.api + LinkedIn.config.api_version
+    expect(subject.url_prefix.to_s).to eq url
+  end
+end

data/spec/linked_in/module_loading_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe LinkedIn do
+  it "is a module" do
+    expect(LinkedIn).to be_a Module
+  end
+
+  it "is independently loadable" do
+    expect { require 'linkedin-oauth2' }.not_to raise_error
+  end
+
+  describe LinkedIn::OAuth2 do
+    it "is a class" do
+      expect(LinkedIn::OAuth2).to be_a Class
+    end
+  end
+
+  describe LinkedIn::API do
+    it "is a class" do
+      expect(LinkedIn::API).to be_a Class
+    end
+  end
+end

data/spec/linked_in/oauth/access_token_spec.rb

@@ -0,0 +1,27 @@
+describe "LinkedIn::AccessToken" do
+  let(:tok) {:dummy_access_token}
+  let(:expires_in) { 64000 }
+  let(:expires_at) { Time.utc(2014,1,1) }
+
+  context "When just token is set" do
+    subject {LinkedIn::AccessToken.new(tok)}
+    it("has the token value") { expect(subject.token).to eq tok }
+  end
+
+  context "When only expires_in is set" do
+    subject {LinkedIn::AccessToken.new(tok, expires_in)}
+    it("set expires_in") {expect(subject.expires_in).to eq expires_in}
+    it("calculated expires_at") do
+      calc_time = Time.now + expires_in
+      diff = subject.expires_at - calc_time
+      expect(diff).to be < 1
+    end
+  end
+
+  context "When everything is set" do
+    subject {LinkedIn::AccessToken.new(tok, expires_in, expires_at)}
+    it("set token") { expect(subject.token).to eq tok }
+    it("set expires_in") {expect(subject.expires_in).to eq expires_in}
+    it("set expires_at") {expect(subject.expires_at).to eq expires_at}
+  end
+end

data/spec/linked_in/oauth/auth_code_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+require "uri"
+require "cgi"
+
+describe "OAuth2 Auth Code" do
+  before(:example) do
+    LinkedIn.configure do |config|
+      config.client_id     = "dummy_client_id"
+      config.client_secret = "dummy_client_secret"
+    end
+  end
+  subject { LinkedIn::OAuth2.new }
+
+  def params(key, opts=nil)
+    CGI.parse(URI.parse(subject.auth_code_url(opts)).query)[key][0]
+  end
+
+  context "When no redirect_uri is given" do
+    before(:example) do
+      LinkedIn.configure { |config| config.redirect_uri = nil }
+    end
+
+    let(:err_msg) { LinkedIn::ErrorMessages.redirect_uri }
+
+    it "Throws an error" do
+      expect {subject.auth_code_url}.to raise_error(LinkedIn::InvalidRequest, err_msg)
+    end
+  end
+
+  context "When an auth code url is requested with no options" do
+    let(:redirect_uri) { "http://lvh.me:5000" }
+    let(:scope) { "r_fullprofile r_emailaddress r_network" }
+
+    before(:example) do
+      LinkedIn.configure do |config|
+        config.redirect_uri = redirect_uri
+        config.scope = scope
+      end
+    end
+
+    it "Returns the client id in the uri" do
+      expect(params("client_id")).to eq LinkedIn.config.client_id
+    end
+
+    it "Includes the configured redirect_uri" do
+      expect(params("redirect_uri")).to eq redirect_uri
+    end
+
+    it "Includes the configured scope" do
+      expect(params("scope")).to eq scope
+    end
+
+    it "Includes an autogenerated state" do
+      expect(params("state")).to_not be_nil
+    end
+  end
+
+  context "When an auth code url is requested with options" do
+    let(:state) { "foobarbaz" }
+    let(:scope) { "r_basicprofile rw_nus" }
+    let(:redirect_uri) { "https://example.com" }
+
+    let(:opts) do
+      {state: state,
+       scope: scope,
+       redirect_uri: redirect_uri}
+    end
+
+    it "Returns the client id in the uri" do
+      expect(params("client_id", opts)).to eq LinkedIn.config.client_id
+    end
+
+    it "Includes the custom redirect_uri" do
+      expect(params("redirect_uri", opts)).to eq redirect_uri
+    end
+
+    it "Includes the custom scope" do
+      expect(params("scope", opts)).to eq scope
+    end
+
+    it "Includes the custom state" do
+      expect(params("state", opts)).to eq state
+    end
+  end
+
+end

data/spec/linked_in/oauth/credentials_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+
+describe LinkedIn::OAuth2 do
+  let(:site)          { LinkedIn.config.site }
+  let(:token_url)     { LinkedIn.config.token_url }
+  let(:authorize_url) { LinkedIn.config.authorize_url }
+
+  let(:client_id)     { "dummy_client_id" }
+  let(:client_secret) { "dummy_client_secret" }
+
+  shared_examples "verify client" do
+    it "creates a valid oauth object" do
+      expect(subject).to be_kind_of(LinkedIn::OAuth2)
+    end
+    it "is a subclass of OAuth2::Client" do
+      expect(subject).to be_kind_of(OAuth2::Client)
+    end
+    it "assigned the client_id to id" do
+      expect(subject.id).to eq client_id
+    end
+    it "assigned the client_secret to secret" do
+      expect(subject.secret).to eq client_secret
+    end
+    it "assigned the site to site" do
+      expect(subject.site).to eq site
+    end
+    it "assigned the authorize_url option" do
+      expect(subject.options[:authorize_url]).to eq authorize_url
+    end
+    it "assigned the token_url option" do
+      expect(subject.options[:token_url]).to eq token_url
+    end
+  end
+
+  shared_examples "options take" do
+    it "overrides default options" do
+      expect(subject.options[:raise_errors]).to eq false
+    end
+    it "sets new options" do
+      expect(subject.options[:new_opt]).to eq "custom option"
+    end
+  end
+
+  context "When client credentials exist" do
+    before(:example) do
+      LinkedIn.configure do |config|
+        config.client_id     = client_id
+        config.client_secret = client_secret
+      end
+    end
+
+    include_examples "verify client"
+
+    let(:options) do
+      return {raise_errors: false,
+              new_opt: "custom option"}
+    end
+
+    context "When custom options are passed in as first arg" do
+      subject do
+        LinkedIn::OAuth2.new(options)
+      end
+      include_examples "options take"
+    end
+
+    context "When custom options are passed in" do
+      subject do
+        LinkedIn::OAuth2.new(client_id, client_secret, options)
+      end
+      include_examples "options take"
+    end
+
+  end
+
+  context "When client credentials do not exist" do
+    let(:err_msg) { LinkedIn::ErrorMessages.credentials_missing }
+
+    before(:example) do
+      LinkedIn.configure do |config|
+        config.client_id     = nil
+        config.client_secret = nil
+      end
+    end
+
+    it "raises an error" do
+      expect { LinkedIn::OAuth2.new }.to raise_error(LinkedIn::InvalidRequest, err_msg)
+    end
+  end
+
+  context "When client credentials are passed in" do
+    subject { LinkedIn::OAuth2.new(client_id, client_secret) }
+
+    include_examples "verify client"
+  end
+
+end

data/spec/linked_in/oauth/get_access_token_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+describe "Get OAuth2 Access Token" do
+  code = "dummy_code"
+  client_id = "dummy_client_id"
+  client_secret = "dummy_client_secret"
+  redirect_uri = "http://lvh.me:5000"
+
+  before(:example) do
+    LinkedIn.configure do |config|
+      config.client_id     = client_id
+      config.client_secret = client_secret
+      config.redirect_uri  = redirect_uri
+    end
+  end
+  subject { LinkedIn::OAuth2.new }
+
+  shared_examples "Success Access Token Fetch" do |*args|
+    it "Returns an access token object" do
+      VCR.use_cassette("access token success") do
+        expect(subject.get_access_token(*args)).to be_kind_of LinkedIn::AccessToken
+      end
+    end
+
+    it "Sets the AcessToken object" do
+      VCR.use_cassette("access token success") do
+        subject.get_access_token(*args)
+        expect(subject.access_token).to be_kind_of LinkedIn::AccessToken
+      end
+    end
+
+    it "Generated an access token string" do
+      VCR.use_cassette("access token success") do
+        subject.get_access_token(*args)
+        expect(subject.access_token.token).to be_kind_of String
+      end
+    end
+  end
+
+  shared_examples "Raises InvalidRequest" do |*args|
+    it "Raises InvalidRequest" do
+      expect{subject.get_access_token(*args)}.to raise_error(LinkedIn::InvalidRequest, msg)
+    end
+
+    it "Has no AccessToken object set" do
+      expect(subject.access_token).to be_nil
+    end
+  end
+
+  context "When a auth_code is provided" do
+    include_examples "Success Access Token Fetch", code
+  end
+
+  context "When no code is given" do
+    let(:msg) {LinkedIn::ErrorMessages.no_auth_code}
+    include_examples "Raises InvalidRequest"
+  end
+
+  context "When redirect_uri is not configured and not passed in" do
+    before(:example) do
+      LinkedIn.configure { |config| config.redirect_uri = nil }
+    end
+    let(:msg) {LinkedIn::ErrorMessages.redirect_uri}
+    include_examples "Raises InvalidRequest", code
+  end
+
+  context "When redirect_uri is configured and not passed in" do
+    before(:example) do
+      LinkedIn.configure { |config| config.redirect_uri = redirect_uri }
+    end
+    include_examples "Success Access Token Fetch", code
+  end
+
+  context "When redirect_uri is passed in" do
+    include_examples "Success Access Token Fetch", code, {redirect_uri: redirect_uri}
+  end
+
+  context "When redirect_uri was previously set by auth_code_url" do
+    before(:example) do
+      LinkedIn.configure { |config| config.redirect_uri = nil }
+      subject.auth_code_url(redirect_uri: redirect_uri)
+    end
+    include_examples "Success Access Token Fetch", code
+  end
+
+  context "When redirect_uri does not match previous setting" do
+    let(:msg) {LinkedIn::ErrorMessages.redirect_uri_mismatch}
+    include_examples "Raises InvalidRequest", code, {redirect_uri: "different"}
+  end
+
+  context "When the service is unavailable" do
+    let(:msg) { /temporarily_unavailable/ }
+    it "raises an OAuthError" do
+      VCR.use_cassette("unavailable") do
+        expect {subject.get_access_token(code)}.to raise_error(LinkedIn::OAuthError, msg)
+      end
+    end
+  end
+
+  context "When the request is invalid" do
+    let(:msg) { /invalid_request/ }
+    it "raises an OAuthError" do
+      VCR.use_cassette("bad code") do
+        expect {subject.get_access_token(code)}.to raise_error(LinkedIn::OAuthError, msg)
+      end
+    end
+  end
+end