omnicontacts 0.1.0

data/spec/omnicontacts/authorization/oauth2_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+require "omnicontacts/authorization/oauth2"
+
+describe OmniContacts::Authorization::OAuth2 do 
+
+  before(:all) do 
+    OAuth2TestClass= Struct.new(:auth_host, :authorize_path, :client_id, :client_secret, :scope, :redirect_uri,:auth_token_path)
+    class OAuth2TestClass 
+      include OmniContacts::Authorization::OAuth2
+    end
+  end
+
+  let(:test_target) do 
+    OAuth2TestClass.new("auth_host", "authorize_path", "client_id", "client_secret", "scope", "redirect_uri", "auth_token_path")
+  end
+
+  describe "authorization_url" do 
+
+    subject {test_target.authorization_url}
+
+    it {should include("https://#{test_target.auth_host}#{test_target.authorize_path}")}
+    it {should include("client_id=#{test_target.client_id}")}
+    it {should include("scope=#{test_target.scope}")}
+    it {should include("redirect_uri=#{test_target.redirect_uri}")}
+    it {should include("access_type=offline")}
+    it {should include("response_type=code")}
+  end
+
+  let(:access_token_response) {%[{"access_token": "access_token", "token_type":"token_type", "refresh_token":"refresh_token"}] }
+
+  describe "fetch_access_token" do
+
+    it "should provide all mandatory parameters in a https post request" do
+      code = "code"
+      test_target.should_receive(:https_post) do |host, path, params|
+        host.should eq(test_target.auth_host)
+        path.should eq(test_target.auth_token_path)
+        params[:code].should eq(code)
+        params[:client_id].should eq(test_target.client_id)
+        params[:client_secret].should eq(test_target.client_secret)
+        params[:redirect_uri].should eq(test_target.redirect_uri)
+        params[:grant_type].should eq("authorization_code")
+        access_token_response
+      end
+      test_target.fetch_access_token code
+    end
+
+    it "should successfully parse the token from the JSON response" do 
+      test_target.should_receive(:https_post).and_return(access_token_response)
+      (access_token, token_type, refresh_token) = test_target.fetch_access_token "code"
+      access_token.should eq("access_token")
+      token_type.should eq("token_type")
+      refresh_token.should eq("refresh_token")
+    end
+
+    it "should raise if the http request fails" do 
+      test_target.should_receive(:https_post).and_raise("Invalid code")
+      expect{test_target.fetch_access_token("code")}.should raise_error
+    end
+
+    it "should raise an error if the JSON response contains an error field" do
+      test_target.should_receive(:https_post).and_return(%[{"error": "error_message"}])
+      expect{test_target.fetch_access_token("code")}.should raise_error
+    end
+  end
+
+  describe "refresh_access_token" do 
+    it "should provide all mandatory fields in a https post request" do 
+      refresh_token = "refresh_token"
+      test_target.should_receive(:https_post) do |host, path, params|
+        host.should eq(test_target.auth_host)
+        path.should eq(test_target.auth_token_path)
+        params[:client_id].should eq(test_target.client_id)
+        params[:client_secret].should eq(test_target.client_secret)
+        params[:refresh_token].should eq(refresh_token)
+        params[:grant_type].should eq("refresh_token")
+        access_token_response
+      end
+      test_target.refresh_access_token refresh_token
+    end
+
+    it "should successfully parse the token from the JSON response" do 
+      test_target.should_receive(:https_post).and_return(access_token_response)
+      (access_token, token_type, refresh_token) = test_target.refresh_access_token "refresh_token"
+      access_token.should eq("access_token")
+      token_type.should eq("token_type")
+      refresh_token.should eq("refresh_token")
+    end
+
+  end
+
+end

data/spec/omnicontacts/http_utils_spec.rb

@@ -0,0 +1,68 @@
+require "spec_helper"
+require "omnicontacts/http_utils"
+
+describe OmniContacts::HTTPUtils do
+
+  describe "to_query_string" do
+    it "should create a query string from a map" do
+      OmniContacts::HTTPUtils.to_query_string(:name => "john", :surname => "doe").should eq("name=john&surname=doe")
+    end 
+  end
+
+  describe "encode" do
+    it "should encode the space" do
+      OmniContacts::HTTPUtils.encode("name=\"john\"").should eq("name%3D%22john%22")
+    end 
+  end
+
+  describe "query_string_to_map" do
+    it "should split a query string into a map" do
+      query_string = "name=john&surname=doe"
+      result = OmniContacts::HTTPUtils.query_string_to_map(query_string)
+      result["name"].should eq("john")
+      result["surname"].should eq("doe")
+    end
+  end
+
+  describe "host_url_from_rack_env" do
+    it "should calculate the host url using the HTTP_HOST variable" do
+      env = {"rack.url_scheme" => "http", "HTTP_HOST" => "localhost:8080","SERVER_NAME" => "localhost", "SERVER_PORT" => 8080}
+      OmniContacts::HTTPUtils.host_url_from_rack_env(env).should eq("http://localhost:8080")
+    end
+
+    it "should calculate the host url using SERVER_NAME and SERVER_PORT variables" do
+      env = {"rack.url_scheme" => "http", "SERVER_NAME" => "localhost", "SERVER_PORT" => 8080}
+      OmniContacts::HTTPUtils.host_url_from_rack_env(env).should eq("http://localhost:8080")
+    end
+  end
+
+  describe "https_post" do
+
+    before(:each) do 
+      @connection = double
+      Net::HTTP.should_receive(:new).and_return(@connection)
+      @connection.should_receive(:use_ssl=).with(true)
+      @test_target = Object.new
+      @test_target.extend OmniContacts::HTTPUtils
+      @response = double
+    end
+
+    it "should execute a request with success" do
+      @test_target.should_receive(:ssl_ca_file).and_return(nil)
+      @connection.should_receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+      @connection.should_receive(:request_post).and_return(@response)
+      @response.should_receive(:code).and_return("200")
+      @response.should_receive(:body).and_return("some content")
+      @test_target.send(:https_post, "host", "path", {})
+    end
+
+    it "should raise an exception with response code != 200" do
+      @test_target.should_receive(:ssl_ca_file).and_return(nil)
+      @connection.should_receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
+      @connection.should_receive(:request_get).and_return(@response)
+      @response.should_receive(:code).and_return("500")
+      @response.should_receive(:body).and_return("some error message")
+      expect {@test_target.send(:https_get, "host", "path", {})}.should raise_error
+    end
+  end
+end

data/spec/omnicontacts/importer/gmail_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "omnicontacts/importer/gmail"
+
+describe OmniContacts::Importer::Gmail do 
+
+  let(:gmail) { OmniContacts::Importer::Gmail.new( {}, "client_id", "client_secret") }
+
+  let(:contacts_as_xml) {
+    "<entry xmlns:gd='http://schemas.google.com/g/2005'>
+       <gd:name>
+         <gd:fullName>Edward Bennet</gd:fullName>
+       </gd:name>
+       <gd:email rel='http://schemas.google.com/g/2005#work' primary='true' address='bennet@gmail.com'/>
+     </entry>"
+  }
+
+  describe  "fetch_contacts_using_access_token" do 
+
+    let(:token) { "token"}
+    let(:token_type) { "token_type" }
+
+    it "should request the contacts by specifying version and code in the http headers" do 
+      gmail.should_receive(:https_get) do |host, path, params, headers|
+        headers["GData-Version"].should eq("3.0")
+        headers["Authorization"].should eq("#{token_type} #{token}")
+        contacts_as_xml
+      end
+      gmail.fetch_contacts_using_access_token token, token_type
+    end
+
+    it "should correctly parse name and email" do 
+      gmail.should_receive(:https_get).and_return(contacts_as_xml)
+      result = gmail.fetch_contacts_using_access_token token, token_type
+      result.size.should be(1)
+      result.first[:name].should eq("Edward Bennet")
+      result.first[:email].should eq("bennet@gmail.com")
+    end
+
+  end
+end

data/spec/omnicontacts/importer/hotmail_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+require "omnicontacts/importer/hotmail"
+
+describe OmniContacts::Importer::Hotmail do 
+
+  let(:hotmail) {OmniContacts::Importer::Hotmail.new({}, "client_id", "client_secret") }
+
+  let(:contacts_as_json) {
+    "{
+       \"data\":
+       [{
+       \"id\": \"contact.b4466224b2ca42798c3d4ea90c75aa56\", 
+       \"first_name\": null, 
+       \"last_name\": null, 
+       \"name\": \"henrik@hotmail.com\", 
+       \"gender\": null, 
+       \"is_friend\": false,
+       \"is_favorite\": false,  
+       \"user_id\": null, 
+       \"birth_day\": 29, 
+       \"birth_month\": 3 
+       }]
+    }"}
+
+    describe "fetch_contacts_using_access_token" do 
+
+      let(:token) { "token"}
+      let(:token_type) { "token_type" }
+
+      it "should request the contacts by providing the token in the url" do
+        hotmail.should_receive(:https_get) do |host, path, params, headers|
+          params[:access_token].should eq(token)
+          contacts_as_json
+        end
+        hotmail.fetch_contacts_using_access_token token, token_type
+      end
+
+      it "should correctly parse the contacts" do 
+        hotmail.should_receive(:https_get).and_return(contacts_as_json)
+        result = hotmail.fetch_contacts_using_access_token token, token_type
+        result.size.should be(1)
+        result.first[:name].should be_nil
+        result.first[:email].should eq("henrik@hotmail.com")
+      end
+    end
+
+end

data/spec/omnicontacts/importer/yahoo_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "omnicontacts/importer/yahoo"
+
+describe OmniContacts::Importer::Yahoo do
+
+  describe "fetch_contacts_from_token_and_verifier" do
+    let(:contacts_as_json) {
+      '{"contacts": 
+      {"start":1, "count":1, 
+      "contact":[{"id":10, "fields":[{"id":819, "type":"email", "value":"john@yahoo.com"},
+       {"type":"name", "value": { "givenName":"John", "familyName":"Doe"} }] }] 
+    } }'}
+
+    let(:yahoo) { OmniContacts::Importer::Yahoo.new( {}, "consumer_key", "consumer_secret" ) }
+
+    it "should request the contacts by specifying all required parameters" do
+      yahoo.should_receive(:fetch_access_token).and_return(["access_token", "access_token_secret", "guid"])
+      yahoo.should_receive(:http_get) do |host, path, params|
+        params[:format].should eq("json")
+        params[:oauth_consumer_key].should eq("consumer_key")
+        params[:oauth_nonce].should_not be_nil
+        params[:oauth_signature_method].should eq("HMAC-SHA1")
+        params[:oauth_timestamp].should_not be_nil
+        params[:oauth_token].should eq("access_token")
+        params[:oauth_version].should eq("1.0")
+        params[:view].should eq("compact")
+        contacts_as_json
+      end
+      yahoo.fetch_contacts_from_token_and_verifier "auth_token", "auth_token_secret", "oauth_verifier"
+    end
+
+    it "should parse the contacts correctly" do
+      yahoo.should_receive(:fetch_access_token).and_return(["access_token", "access_token_secret", "guid"])
+      yahoo.should_receive(:http_get).and_return(contacts_as_json)
+      result = yahoo.fetch_contacts_from_token_and_verifier "auth_token", "auth_token_secret", "oauth_verifier"
+      result.size.should be(1)
+      result.first[:name].should eq("John Doe")
+      result.first[:email].should eq("john@yahoo.com")
+    end
+
+  end
+end

data/spec/omnicontacts/middleware/oauth1_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper"
+require "omnicontacts/middleware/oauth1"
+
+describe OmniContacts::Middleware::OAuth1 do
+
+  before(:all) do
+    class OAuth1Middleware < OmniContacts::Middleware::OAuth1
+      def self.mock_auth_token_resp
+        @mock_auth_token_resp ||= Object.new
+      end
+
+      def fetch_authorization_token
+        OAuth1Middleware.mock_auth_token_resp.body
+      end
+
+      def authorization_url auth_token
+        "http://www.example.com"
+      end
+
+     def fetch_contacts_from_token_and_verifier oauth_token, ouath_token_secret, oauth_verifier
+        [{:name => "John Doe", :email => "john@example.com"}]
+      end
+
+      def self.mock_session
+        @mock_session ||= {}
+      end
+      def session
+        OAuth1Middleware.mock_session
+      end
+    end
+  end
+
+  let(:app) {
+    Rack::Builder.new do |b|
+    b.use OAuth1Middleware, "consumer_id", "consumer_secret"
+    b.run lambda{ |env| [200, {"Content-Type" => "text/html"}, ["Hello World"]] }
+    end.to_app
+  }
+
+  context "visiting the listening path" do
+    it "should save the authorization token and redirect to the authorization url" do
+      OAuth1Middleware.mock_auth_token_resp.should_receive(:body).and_return(["auth_token", "auth_token_secret"])
+      get "/contacts/oauth1middleware"
+      last_response.should be_redirect
+      last_response.headers['location'].should eq("http://www.example.com")
+    end
+
+    it "should redirect to failure url if fetching the request token does not succeed" do
+      OAuth1Middleware.mock_auth_token_resp.should_receive(:body).and_raise("Request failed")
+      get "contacts/oauth1middleware"
+      last_response.should be_redirect
+      last_response.headers["location"].should eq("/contacts/failure?error_message=internal_error")
+    end
+  end
+
+  context "visiting the callback url after authorization" do
+    it "should return the list of contacts" do
+      OAuth1Middleware.mock_session.should_receive(:[]).and_return("oauth_token_secret")
+      get "/contacts/oauth1middleware/callback?oauth_token=token&oauth_verifier=verifier"
+      last_response.should be_ok
+      last_request.env["omnicontacts.contacts"].size.should be(1)
+    end
+
+    it "should redirect to failure url if oauth_token_secret is not found in the session" do 
+      OAuth1Middleware.mock_session.should_receive(:[]).and_return(nil)
+      get "/contacts/oauth1middleware/callback?oauth_token=token&oauth_verifier=verifier"
+      last_response.should be_redirect
+      last_response.headers["location"].should eq("/contacts/failure?error_message=not_authorized") 
+    end
+  end
+end

data/spec/omnicontacts/middleware/oauth2_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+require "omnicontacts/middleware/oauth2"
+
+describe OmniContacts::Middleware::OAuth2 do 
+
+  before(:all) do 
+    class OAuth2Middleware < OmniContacts::Middleware::OAuth2
+      def authorization_url
+        "http://www.example.com"
+      end
+
+      def redirect_path
+        "/redirect_path"
+      end
+
+      def self.mock_session
+        @mock_session ||= {}
+      end
+
+      def session
+        OAuth2Middleware.mock_session  
+      end
+
+      def fetch_access_token code
+        ["access_token", "token_type", "token_refresh"]  
+      end
+
+      def fetch_contacts_using_access_token token, token_type
+        [{:name => "John Doe", :email => "john@example.com"}]
+      end
+    end
+  end
+
+  let(:app) {
+    Rack::Builder.new do |b|
+    b.use OAuth2Middleware, "client_id", "client_secret"
+    b.run lambda{ |env| [200, {"Content-Type" => "text/html"}, ["Hello World"]] }
+    end.to_app
+  }
+
+  context "visiting the listening path" do
+    it "should redirect to authorization site when visiting the listening path" do
+      get "/contacts/oauth2middleware"
+      last_response.should be_redirect
+      last_response.headers['location'].should eq("http://www.example.com")
+    end
+  end
+
+  context "visiting the callback url after authorization" do
+    it "should fetch the contacts" do
+      get '/redirect_path?code=ABC'
+      last_response.should be_ok
+      last_request.env["omnicontacts.contacts"].size.should be(1)
+    end
+
+    it "should redirect to failure page because user did not allow access to contacts list" do
+      get '/redirect_path?error=not_authorized'
+      last_response.should be_redirect
+      last_response.headers["location"].should eq("/contacts/failure?error_message=not_authorized")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require "simplecov"
+SimpleCov.start do
+  add_filter "spec/"
+end
+
+require "rspec"
+require "rack/test"
+RSpec.configure do |config|
+  config.include Rack::Test::Methods
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: omnicontacts
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Diego Castorina
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &1458910 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *1458910
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &1453940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *1453940
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &1452760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *1452760
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &1451690 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *1451690
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &1450620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *1450620
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &1449560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *1449560
+description: A generalized Rack middleware for importing contacts from major email
+  providers.
+email:
+- diegocastorina@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/omnicontacts.rb
+- lib/omnicontacts/authorization/oauth1.rb
+- lib/omnicontacts/authorization/oauth2.rb
+- lib/omnicontacts/builder.rb
+- lib/omnicontacts/http_utils.rb
+- lib/omnicontacts/importer.rb
+- lib/omnicontacts/importer/gmail.rb
+- lib/omnicontacts/importer/hotmail.rb
+- lib/omnicontacts/importer/yahoo.rb
+- lib/omnicontacts/middleware/base_oauth.rb
+- lib/omnicontacts/middleware/oauth1.rb
+- lib/omnicontacts/middleware/oauth2.rb
+- omnicontacts.gemspec
+- spec/omnicontacts/authorization/oauth1_spec.rb
+- spec/omnicontacts/authorization/oauth2_spec.rb
+- spec/omnicontacts/http_utils_spec.rb
+- spec/omnicontacts/importer/gmail_spec.rb
+- spec/omnicontacts/importer/hotmail_spec.rb
+- spec/omnicontacts/importer/yahoo_spec.rb
+- spec/omnicontacts/middleware/oauth1_spec.rb
+- spec/omnicontacts/middleware/oauth2_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/Diego81/omnicontacts
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: A generalized Rack middleware for importing contacts from major email providers.
+test_files: []