f1api 0.9.0

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+gem 'nokogiri'
+gem 'oauth', '=0.4.4'
+gem 'mocha'
+gem 'activeresource'

data/Gemfile.lock

@@ -0,0 +1,27 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activeresource (3.0.3)
+      activemodel (= 3.0.3)
+      activesupport (= 3.0.3)
+    activesupport (3.0.3)
+    builder (2.1.2)
+    i18n (0.4.2)
+    mocha (0.9.9)
+      rake
+    nokogiri (1.4.4)
+    oauth (0.4.4)
+    rake (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activeresource
+  mocha
+  nokogiri
+  oauth (= 0.4.4)

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Fellowship Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,24 @@
+Fellowship One REST API Ruby Client Library
+===========================================
+
+**NOTE**: This library is of alpha quality.  It is not meant for use in production apps.  It's definitely not feature complete and it may have bugs.
+
+Introduction
+------------
+This library is an implementation of the Fellowship One REST API.  Currently we are only fielding requests and handling the OAuth tokens.  The goal is to have a library that works like ActiveResource.
+
+Usage
+-----
+	require 'f1api'
+	
+	class Person < FellowshipOneAPI::Base
+	end
+	
+	client.authorize!
+	# If using creds in YAML file:
+	# client.authorize! "username", "password"
+	
+	Person.connect client
+	
+	Person.find(12345)
+	Person.find("search", {:searchFor => "Dearing", :include => "communications,addresses"})

data/Rakefile

@@ -0,0 +1,38 @@
+BASE_DIR = File.dirname(__FILE__)
+
+task :test do
+  require 'bundler/setup'
+  require 'test/unit'
+  require 'mocha'
+  require "#{BASE_DIR}/test/fixtures/request_token.rb"
+  require "#{BASE_DIR}/test/fixtures/access_token.rb"
+  require "#{BASE_DIR}/test/fixtures/http.rb"
+  require "#{BASE_DIR}/lib/f1api"
+  Dir["#{BASE_DIR}/test/unit/*.rb"].each do |test|
+    require test
+  end
+end
+
+task :rdoc do
+  `rdoc -x 'test/*'`
+end
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "f1api"
+  gem.homepage = "http://github.com/jessedearing/f1api"
+  gem.license = "MIT"
+  gem.summary = %Q{Consume the Fellowship One API in your apps using ActiveResource}
+  gem.description = %Q{Consumes the Fellowship One API in your apps using ActiveResource.  Implements 2nd party credentials-based authenticaion and full OAuth implementation. }
+  gem.email = "jdearing@fellowshiptech.com"
+  gem.authors = ["Jesse Dearing"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_runtime_dependency 'oauth', '= 0.4.4'
+  gem.add_development_dependency 'mocha'
+  gem.add_runtime_dependency 'activeresource'
+end
+Jeweler::RubygemsDotOrgTasks.new

data/VERSION

@@ -0,0 +1 @@
+0.9.0

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:major: 0
+:minor: 9
+:patch: 0
+:build: 

data/config/f1-oauth.yml

@@ -0,0 +1,48 @@
+development:
+  consumer_key: ""
+  consumer_secret: ""
+  site_url: "https://{church_code}.staging.fellowshiponeapi.com"
+  # Store the church code if you are writing a 2nd Party implementation
+  # Otherwise, you'll want to ask for the church code from the user
+  church_code: ""
+  authentication_type: "oauth" #oauth or credentials
+  request_token_path: "/v1/Tokens/RequestToken"
+  access_token_path: "/v1/Tokens/AccessToken" #OAuth only
+  # OAuth authentication vars
+  portal_authorize_path: "/v1/PortalUser/Login"
+  weblink_authorize_path: "/v1/WeblinkUser/Login"
+  # Use the following for credentials based authentication
+  portal_credential_token_path: "/v1/PortalUser/AccessToken"
+  weblink_credential_token_path: "/v1/WeblinkUser/AccessToken"
+test:
+  consumer_key: "123456789"
+  consumer_secret: "12345678-90ab-cdef-0123-4567890abcde"
+  site_url: "https://{church_code}.staging.fellowshiponeapi.com"
+  # Store the church code if you are writing a 2nd Party implementation
+  # Otherwise, you'll want to ask for the church code from the user
+  church_code: "test"
+  authentication_type: "oauth" #oauth or credentials
+  request_token_path: "/V1/Tokens/RequestToken"
+  access_token_path: "/V1/Tokens/AccessToken" #OAuth only
+  # OAuth authentication vars
+  portal_authorize_path: "/V1/PortalUser/Login"
+  weblink_authorize_path: "/V1/WeblinkUser/Login"
+  # Use the following for credentials based authentication
+  portal_credential_token_path: "/V1/PortalUser/AccessToken"
+  weblink_credential_token_path: "/V1/WeblinkUser/AccessToken"
+production:
+  consumer_key: ""
+  consumer_secret: ""
+  site_url: "https://{church_code}.fellowshiponeapi.com"
+  # Store the church code if you are writing a 2nd Party implementation
+  # Otherwise, you'll want to ask for the church code from the user
+  church_code: ""
+  authentication_type: "oauth" #oauth or credentials
+  request_token_path: "/v1/Tokens/RequestToken"
+  access_token_path: "/v1/Tokens/AccessToken" #OAuth only
+  # OAuth authentication vars
+  portal_authorize_path: "/v1/PortalUser/Login"
+  weblink_authorize_path: "/v1/WeblinkUser/Login"
+  # Use the following for credentials based authentication
+  portal_credential_token_path: "/v1/PortalUser/AccessToken"
+  weblink_credential_token_path: "/v1/WeblinkUser/AccessToken"

data/lib/f1api.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}"
+require 'bundler/setup'
+require 'yaml'
+require 'oauth'
+require 'base64'
+require 'uri'
+require 'active_resource'
+require "f1api/configuration"
+require "f1api/oauth"
+require "f1api/oauth/credentials_authentication"
+require "f1api/oauth/oauth_authentication"
+require "f1api/client"
+require "f1api/activeresource/connection"
+require "f1api/activeresource/base"

data/lib/f1api/activeresource/base.rb

@@ -0,0 +1,19 @@
+module FellowshipOneAPI # :nodoc:
+  # The Base class should be inherited by all model classes as it provides the facilities that the class will need
+  class Base < ActiveResource::Base
+    self.site = "#{Configuration.site_url}/v1"
+    # Creates a new connection
+    # 
+    # ==Examples
+    #   Person.connect(FellowshipOneAPI::Client.new)
+    # 
+    # If the connection needs to be forcibly refreshed then you can pass true
+    #   Person.connect(FellowshipOneAPI::Client.new, true)
+    def self.connect(client, refresh = false)
+      if(refresh or @connection.nil?)
+        @connection = Connection.new(client, client.consumer.site, format)
+      end
+    end
+    
+  end
+end

data/lib/f1api/activeresource/connection.rb

@@ -0,0 +1,39 @@
+require 'nokogiri'
+
+module FellowshipOneAPI
+  # Creating a wrapper for the ActiveResource::Connection class
+  class Connection < ActiveResource::Connection
+    # Pass in a new connection to the API
+    def initialize(f1api_connection, *args)
+      @f1api_connection = f1api_connection
+      super(*args)
+    end
+    
+    private
+    # The request method that is passes the request through to the F1 API client
+    def request(method, path, *args)
+      if @f1api_connection == nil
+        super(method, path, *args)
+      else
+        response = @f1api_connection.request(method, path, *args)
+        
+        if method == :get
+          response.body = transform_response response.body, path
+        end
+        handle_response(response)
+      end
+    end
+    
+    # 
+    def transform_response(response_body, path)
+      n = Nokogiri::XML(response_body)
+      res = (n/"results")
+      if not (res.empty?)
+        resource = ((path.split '/')[2]).downcase
+        res[0].name = resource
+      end
+      
+      n.to_s
+    end
+  end
+end

data/lib/f1api/client.rb

@@ -0,0 +1,62 @@
+module FellowshipOneAPI
+  # ==The Fellowship One API client class
+  # Takes an HTTP request and passes it through the OAuth library which added the approperiate headers and querystring
+  # parameters.
+  # ===Examples
+  # [Simple client using OAuth and default YAML config values]
+  #     client = FellowshipOneAPI::Client.new
+  #
+  #     client.authorize!
+  #
+  #     client.request(:get, '/v1/People/123.xml')
+  #
+  # [Using credentials based authentication (2nd party)]
+  #     client = FellowshipOneAPI::Client.new({:auth_type => :credentials})
+  #
+  #     client.authorize!("username", "password")
+  #
+  #     client.request(:get, '/v1/People/123.xml')
+  #
+  # [Authenticating against weblink passing credentials]
+  #     client = FellowshipOneAPI::Client.new({:auth_type => :credentials, :auth_against => :weblink})
+  #
+  #     client.authorize("weblinkuser", "weblinkpassword")
+  #
+  #     client.request(:get, '/v1/People/123.xml')
+  #
+  # [Loading a client with an existing access token]
+  #     client = FellowshipOneAPI::Client.new({:oauth_token => "123456", :oauth_token_secret => "987654"})
+  #
+  #     client.request(:get, '/v1/People/123.xml')
+  class Client
+    # Creates a new instance of a client used to connect with the Fellowship One API
+    # The client can be configured with the following symbols:
+    # [+:auth_type+] - Can be _:credentials_ or _:oauth_ (_:oauth_ is the default)
+    # [+:auth_against+] - Can be _:portal_ or _:weblink_ (_:portal_ is the default)
+    # [+:oauth_token+] - The access token
+    # [+:oauth_token_secret+] - The access token secret
+    def initialize(args = {})
+      args[:auth_type] ||= Configuration.authentication_type.to_sym
+      if args[:auth_type] == :credentials
+        extend OAuth::CredentialsAuthentication
+      else
+        extend OAuth::OAuthAuthentication
+      end
+      
+      if(args[:auth_against])
+        load_consumer_config args[:auth_against]
+      else
+        load_consumer_config
+      end
+      
+      if(args[:oauth_token] and args[:oauth_token_secret])
+        @oauth_access_token = ::OAuth::AccessToken.from_hash(@oauth_consumer, args[:oauth_token], args[:oauth_token_secret])
+      end
+    end
+    
+    # Passes through the request to the OAuth library to be signed and set out HTTP
+    def request(*args)
+      @oauth_access_token.request(*args)
+    end
+  end
+end

data/lib/f1api/configuration.rb

@@ -0,0 +1,63 @@
+module FellowshipOneAPI # :nodoc:
+  # This accesses the YAML-based F1 API config file
+  # 
+  # This class was written to take rails environment variables like +RAILS_ENV+ and +Rails.root+ into account
+  class Configuration
+    # Explictly defines where the configuration file is
+    def self.file_path=(path)
+      @file_path
+    end
+    
+    # Gets the specified key from the configuration file
+    # [Example]    FellowshipTechAPIClient.Configuration["consumer_key"] <i># "2"</i>
+    #
+    #              FellowshipTechAPIClient.Configuration["consumer_secret"] <i># "12345678-9abc-def0-1234-567890abcdef"</i>
+    def self.[](value)
+      load_yaml if @config_yaml.nil?
+      val = @config_yaml[self.environment][value]
+      # if we have the string has "{church_code}" then we'll substitute it
+      if val =~ /\{church_code\}/ and value != "church_code"
+        return val.gsub("{church_code}", self["church_code"]) 
+      end
+      return val
+    end
+    
+    # Gets the current environment
+    def self.environment
+      @environment ||= "development" 
+      @environment ||= ::Rails.env if defined? ::Rails
+      @environment
+    end
+    
+    # Set the current environment
+    def self.environment=(env_value)
+      @environment = env_value
+    end
+    
+    # Overridden method_missing to facilitate a more pleasing ruby-like syntax for accessing
+    # configuration values
+    def self.method_missing(name, *args, &block)
+      return self[name.to_s] unless self[name.to_s].nil?
+      super
+    end
+    
+    private
+    
+    # Loads the YAML file
+    #
+    # Starts by looking to see if file_path is defined then checks in current directory (.) and then your Rails.root and then the config 
+    # directory off of the base directory of the gem
+    def self.load_yaml
+      if not @file_path.nil?
+        @config_yaml = YAML.load_file(@file_path)
+      elsif File.exists? "./f1-oauth.yml"
+        @config_yaml = YAML.load_file("./f1-oauth.yml")
+      elsif defined? ::Rails
+        @config_yaml = YAML.load_file("#{::Rails.root}/config/f1-oauth.yml")
+      else
+        path = File.dirname(__FILE__) + "/../../config/f1-oauth.yml"
+        @config_yaml = YAML.load_file(path)
+      end
+    end
+  end
+end

data/lib/f1api/oauth.rb

@@ -0,0 +1,54 @@
+module FellowshipOneAPI # :nodoc:
+  # Wrapper around the OAuth v1.0 specification using the +oauth+ gem.
+  #
+  # The Fellowship One API has two methods of authentication:
+  # [OAuthAuthentication]       This is the default method if no method is declared.  This method allows Fellowship Tech to handle
+  #                             the authentication and we redirect back to your app.
+  # [CredentialsAuthentication]  The methods lets the consumer submit credentials and verify authentication.
+  module OAuth
+    # The OAuth consumer key.
+    # This will get set automatically from the YAML config file if not set explictly
+    attr_accessor :oauth_consumer_key
+    alias :consumer_key :oauth_consumer_key
+    alias :consumer_key= :oauth_consumer_key=
+    
+    # The OAuth consumer secret.
+    # This will get set automatically from the YAML config file if not set explictly
+    attr_accessor :oauth_consumer_secret
+    alias :consumer_secret :oauth_consumer_secret
+    alias :consumer_secret= :oauth_consumer_secret=
+     
+    # The OAuth access token object where all requests are made off of
+    attr_reader :oauth_access_token
+    alias :access_token :oauth_access_token
+    
+    # The OAuth consumer object
+    attr_reader :oauth_consumer
+    alias :consumer :oauth_consumer
+    
+    # The URI for the resource of the authenticated user
+    attr_reader :authenticated_user_uri
+    
+    # Creates the OAuth consumer object
+    def load_consumer_config(type = :portal)
+      case type
+      when :portal
+        authorize_path = FellowshipOneAPI::Configuration.portal_authorize_path
+      when :weblink
+        authorize_path = FellowshipOneAPI::Configuration.weblink_authorize_path
+      end
+      
+      @oauth_consumer_key ||= FellowshipOneAPI::Configuration.consumer_key
+      @oauth_consumer_secret ||= FellowshipOneAPI::Configuration.consumer_secret
+      
+      @oauth_consumer = ::OAuth::Consumer.new(@oauth_consumer_key, 
+                        @oauth_consumer_secret,
+                        {:site => FellowshipOneAPI::Configuration.site_url,
+                         :request_token_path => FellowshipOneAPI::Configuration.request_token_path,
+                         :access_token_path => FellowshipOneAPI::Configuration.access_token_path,
+                         :authorize_path => authorize_path })
+    end
+    
+ 
+  end
+end

data/lib/f1api/oauth/credentials_authentication.rb

@@ -0,0 +1,59 @@
+module FellowshipOneAPI # :nodoc:
+  module OAuth
+    # Implements the Credentials method of authentication.  You must manage the credentials.
+    module CredentialsAuthentication
+      include OAuth
+     # Authorizes a user 
+     # +username+::   The username of the user
+     # +password+::   The password of the user
+     # +type+::       Can be :portal or :weblink based on which credentials you want to authenticate against
+     # Returns the URI for the authenticated user
+     def authorize!(username, password, type = :portal)
+       load_consumer_config(type) if @oauth_consumer.nil?
+   
+       @oauth_request = @oauth_consumer.get_request_token
+       cred = URI.encode(Base64.encode64("#{username} #{password}"))
+   
+       case type
+       when :portal
+         auth_url = FellowshipOneAPI::Configuration.portal_credential_token_path
+       when :weblink
+         auth_url = FellowshipOneAPI::Configuration.weblink_credential_token_path
+       end
+   
+       response = @oauth_consumer.request(:post, auth_url, nil, {}, "ec=#{cred}", {'Content-Type' => 'application/x-www-form-urlencoded'})
+       
+       handle_response_code(response)
+       
+       # Gettting the URI of the authenticated user
+       @authenticated_user_uri = response["Content-Location"]
+     end
+ 
+     private
+     def handle_response_code(response)
+       case response.code.to_i
+       when (200..299)
+         @oauth_access_token = ::OAuth::AccessToken.from_hash(@oauth_consumer, parse_access_token(response.body))
+       when (300..399)
+         # redirect
+         # TODO: actually redirect instead of throwing error
+         response.error!
+       when (400..499)
+         raise OAuth::Unauthorized, response
+       else
+         response.error!
+       end
+     end
+     
+     # Parse returned OAuth access token key/secret pair
+     def parse_access_token(response)
+       oauth_hash = {}
+       response.split('&').each do |val|
+         kv = val.split('=')
+         oauth_hash.merge!({kv[0].to_sym => kv[1]})
+       end
+       oauth_hash
+     end
+    end
+  end
+end

data/lib/f1api/oauth/oauth_authentication.rb

@@ -0,0 +1,72 @@
+module FellowshipOneAPI # :nodoc:
+  module OAuth
+    # Implements the pure OAuth method of authentication.  This allows the Fellowship One API to 
+    # manage the authentication process.
+    module OAuthAuthentication
+      include OAuth
+      # The OAuth request object
+      attr_reader :oauth_request
+  
+      # The OAuth authorization URI
+      attr_reader :oauth_authorize_url
+      alias :authorize_url :oauth_authorize_url
+  
+      # Gets a new request token and return the authorize URI
+      # +type+:: Can be :portal or :weblink based on which credentials you want to authenticate against
+      def authorize!(type = :portal)
+        load_consumer_config(type) if oauth_consumer.nil?
+    
+        @oauth_request = oauth_consumer.get_request_token
+        @oauth_authorize_url = oauth_request.authorize_url
+
+        @oauth_consumer.instance_eval do
+          # The token request reponse is scoped only in the token_request method, but I need to get access to the response
+          # headers so that I can pull back the Content-Location header and get the authenticated user URI
+          def token_request(http_method, path, token = nil, request_options = {}, *arguments)
+            @tr_response = request(http_method, path, token, request_options, *arguments)
+            case @tr_response.code.to_i
+
+            when (200..299)
+              if block_given?
+                yield @tr_response.body
+              else
+                # symbolize keys
+                # TODO this could be considered unexpected behavior; symbols or not?
+                # TODO this also drops subsequent values from multi-valued keys
+                CGI.parse(@tr_response.body).inject({}) do |h,(k,v)|
+                  h[k.strip.to_sym] = v.first
+                  h[k.strip]        = v.first
+                  h
+                end
+              end
+            when (300..399)
+              # this is a redirect
+              @tr_response.error!
+            when (400..499)
+              raise OAuth::Unauthorized, @tr_response
+            else
+              @tr_response.error!
+            end
+          end
+          
+          # The HTTP response from token_request
+          def token_request_response
+            @tr_response
+          end
+        end
+    
+        oauth_authorize_url
+      end
+  
+      # After a the user has been authenticated then we use the access token to access protected resources in the API.
+      # Since the authentication has taken place, we now know about the user that authenticated and 
+      # have a URI to the record of that user.
+      #
+      # The URI for the authenticated user is returned.
+      def get_access_token
+        @oauth_access_token = oauth_request.get_access_token
+        @authenticated_user_uri = oauth_consumer.token_request_response["Content-Location"]
+      end
+    end
+  end
+end

data/test/fixtures/access_token.rb

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+require 'oauth'
+
+class AccessTokenFixture
+  def self.get(oauth_consumer)
+    @token = "access"
+    @secret = "token"
+    return ::OAuth::AccessToken.new(oauth_consumer, @token, @secret)
+  end
+end

data/test/fixtures/http.rb

@@ -0,0 +1,13 @@
+class HttpFixture
+  def body
+    "oauth_token=access&oauth_token_secret=token"
+  end
+  
+  def [](value)
+    {'Content-Location' => "#{FellowshipOneAPI::Configuration.site_url}/V1/People/123456"}[value]
+  end
+  
+  def code
+    "200"
+  end
+end

data/test/fixtures/request_token.rb

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+require 'oauth'
+
+class RequestTokenFixture
+  def self.get(oauth_consumer)
+    @token = "request"
+    @secret = "token"
+    return ::OAuth::RequestToken.new(oauth_consumer, @token, @secret)
+  end
+end

data/test/unit/configuration_test.rb

@@ -0,0 +1,60 @@
+class OAuthTest < Test::Unit::TestCase
+  include FellowshipOneAPI
+  
+  def setup
+    Configuration.environment = "test"
+    Configuration.file_path = "#{File.dirname(__FILE__)}/../../config/f1-oauth.yml"
+  end
+  
+  def test_method_missing
+    assert_raise NoMethodError do 
+      Configuration.asdf
+    end
+    
+    assert_nothing_raised do
+      Configuration.consumer_key
+    end
+    
+    assert_equal Configuration["consumer_key"], Configuration.consumer_key
+  end
+  
+  def test_consumer_key
+    assert_equal("123456789", Configuration.consumer_key)
+  end
+  
+  def test_consumer_secret
+    assert_equal("12345678-90ab-cdef-0123-4567890abcde", Configuration.consumer_secret)
+  end
+  
+  def test_site_url
+    assert_equal("https://test.staging.fellowshiponeapi.com", Configuration.site_url)
+  end
+  
+  def test_church_code
+    assert_equal("test", Configuration.church_code)
+  end
+  
+  def test_request_token_path
+    assert_equal("/V1/Tokens/RequestToken", Configuration.request_token_path)
+  end
+  
+  def test_access_token_path
+    assert_equal("/V1/Tokens/AccessToken", Configuration.access_token_path)
+  end
+  
+  def test_portal_authorize_path
+    assert_equal("/V1/PortalUser/Login", Configuration.portal_authorize_path)
+  end
+  
+  def test_weblink_authorize_path
+    assert_equal("/V1/WeblinkUser/Login", Configuration.weblink_authorize_path)
+  end
+  
+  def test_portal_credential_token_path
+    assert_equal("/V1/PortalUser/AccessToken", Configuration.portal_credential_token_path)
+  end
+  
+  def test_weblink_credential_token_path
+    assert_equal("/V1/WeblinkUser/AccessToken", Configuration.weblink_credential_token_path)
+  end
+end

data/test/unit/credentials_test.rb

@@ -0,0 +1,59 @@
+class CredentialsAuthenticationTest
+  include FellowshipOneAPI::OAuth::CredentialsAuthentication
+  attr_accessor :oauth_consumer
+end
+
+class CredentialsTest < Test::Unit::TestCase
+  include FellowshipOneAPI
+  def setup
+    Configuration.environment = "test"
+    Configuration.file_path = "#{File.dirname(__FILE__)}/../../config/f1-oauth.yml"
+    
+    @test_username = "testuser"
+    @test_password = "testpass"
+    
+    @cred_test = CredentialsAuthenticationTest.new
+    @cred_test.load_consumer_config
+    @mocked_access_token = AccessTokenFixture.get(@cred_test.oauth_consumer)
+    @mocked_request_token = RequestTokenFixture.get(@cred_test.oauth_consumer)
+    cred = URI.encode(Base64.encode64("#{@test_username} #{@test_password}"))
+    
+    @mocked_user_uri = "#{Configuration.site_url}/V1/People/123456"
+    
+    @cred_test.oauth_consumer.stubs(:get_request_token).returns(@mocked_request_token)
+    
+    @cred_test.oauth_consumer.stubs(:request).with(:post, ::FellowshipOneAPI::Configuration.portal_credential_token_path,
+                                                      nil, {}, "ec=#{cred}", {'Content-Type' => 'application/x-www-form-urlencoded'}).
+                                                      returns(HttpFixture.new)
+  end
+  
+  def test_portal_authorize!
+    actual = @cred_test.authorize! @test_username, @test_password
+    
+    assert_equal(@mocked_user_uri, actual)
+  end
+  
+  def test_weblink_authorize!
+    cred = URI.encode(Base64.encode64("#{@test_username} #{@test_password}"))
+    @cred_test.oauth_consumer = nil
+    @cred_test.load_consumer_config(:weblink)
+    @cred_test.oauth_consumer.expects(:get_request_token).returns(@mocked_request_token).at_least_once
+    @cred_test.oauth_consumer.expects(:request).with(:post, ::FellowshipOneAPI::Configuration.weblink_credential_token_path,
+                                                      nil, {}, "ec=#{cred}", {'Content-Type' => 'application/x-www-form-urlencoded'}).returns(
+                                                      HttpFixture.new).at_least_once
+    @cred_test.authorize! @test_username, @test_password, :weblink
+  end
+  
+  def test_get_access_token
+    @cred_test.authorize! @test_username, @test_password
+    
+    assert_equal("access", @cred_test.access_token.token)
+    assert_equal("token", @cred_test.access_token.secret)
+  end
+  
+  def test_authorized_user_uri
+    @cred_test.authorize! @test_username, @test_password
+    
+    assert_equal(@mocked_user_uri, @cred_test.authenticated_user_uri)
+  end
+end

data/test/unit/oauth_test.rb

@@ -0,0 +1,74 @@
+class OAuthAuthenticationTest
+  include FellowshipOneAPI::OAuth::OAuthAuthentication
+  attr_accessor :oauth_consumer
+end
+
+class OAuthTest < Test::Unit::TestCase
+  include FellowshipOneAPI
+  def setup
+    Configuration.environment = "test"
+    Configuration.file_path = "#{File.dirname(__FILE__)}/../../config/f1-oauth.yml"
+    
+    @oauth_test = OAuthAuthenticationTest.new
+    @oauth_test.load_consumer_config
+    @mocked_request_token = RequestTokenFixture.get(@oauth_test.oauth_consumer)
+    @mocked_access_token = AccessTokenFixture.get(@oauth_test.oauth_consumer)
+    @oauth_test.oauth_consumer.stubs(:get_request_token).returns(@mocked_request_token)
+  end
+  
+  def test_portal_authorize!
+    @oauth_test.oauth_consumer.expects(:get_request_token).returns(@mocked_request_token)
+    
+    assert_equal("#{Configuration.site_url}#{Configuration.portal_authorize_path}?oauth_token=request", @oauth_test.authorize!)
+    
+    assert_equal("request", @oauth_test.oauth_request.token)
+    assert_equal("token", @oauth_test.oauth_request.secret)
+    assert_equal("#{Configuration.site_url}#{Configuration.portal_authorize_path}?oauth_token=#{@oauth_test.oauth_request.token}", @oauth_test.authorize_url)
+  end
+  
+  def test_weblink_authorize!
+    @oauth_test.oauth_consumer = nil
+    @oauth_test.load_consumer_config(:weblink)
+    @mocked_request_token = RequestTokenFixture.get(@oauth_test.oauth_consumer)
+    @oauth_test.oauth_consumer.expects(:get_request_token).returns(@mocked_request_token)
+    
+    @oauth_test.authorize!(:weblink)
+    
+    assert_equal("request", @oauth_test.oauth_request.token)
+    assert_equal("token", @oauth_test.oauth_request.secret)
+    assert_equal("#{Configuration.site_url}#{Configuration.weblink_authorize_path}?oauth_token=#{@oauth_test.oauth_request.token}", @oauth_test.authorize_url)
+  end
+  
+  def test_get_access_token
+    @oauth_test.authorize!
+    
+    @oauth_test.oauth_request.expects(:get_access_token).returns(@mocked_access_token)
+    @oauth_test.oauth_consumer.expects(:token_request_response).returns({"Content-Location" => ""})
+    @oauth_test.get_access_token
+    
+    assert_equal("access", @oauth_test.access_token.token)
+    assert_equal("token", @oauth_test.access_token.secret)
+  end
+  
+  def test_authorized_user_uri
+    mocked_user_uri = "#{Configuration.site_url}/V1/People/123456"
+    
+    @oauth_test.authorize!
+    
+    @oauth_test.oauth_request.expects(:get_access_token).returns(@mocked_access_token)
+    @oauth_test.oauth_consumer.expects(:token_request_response).returns({"Content-Location" => mocked_user_uri})
+    @oauth_test.get_access_token
+    
+    assert_equal(mocked_user_uri, @oauth_test.authenticated_user_uri)
+  end
+  
+  def test_change_auth_types
+    @oauth_test.authorize!
+    assert_equal("#{Configuration.site_url}#{Configuration.portal_authorize_path}", @oauth_test.oauth_consumer.authorize_url)
+    @oauth_test.load_consumer_config(:weblink)
+    @oauth_test.oauth_consumer.stubs(:get_request_token).returns(@mocked_request_token)
+    @oauth_test.authorize!
+    assert_equal("#{Configuration.site_url}#{Configuration.weblink_authorize_path}", @oauth_test.oauth_consumer.authorize_url)
+  end
+  
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification 
+name: f1api
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 0
+  version: 0.9.0
+platform: ruby
+authors: 
+- Jesse Dearing
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-19 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: oauth
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 4
+        version: 0.4.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: oauth
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 4
+        version: 0.4.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id007
+description: "Consumes the Fellowship One API in your apps using ActiveResource.  Implements 2nd party credentials-based authenticaion and full OAuth implementation. "
+email: jdearing@fellowshiptech.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- VERSION.yml
+- config/f1-oauth.yml
+- lib/f1api.rb
+- lib/f1api/activeresource/base.rb
+- lib/f1api/activeresource/connection.rb
+- lib/f1api/client.rb
+- lib/f1api/configuration.rb
+- lib/f1api/oauth.rb
+- lib/f1api/oauth/credentials_authentication.rb
+- lib/f1api/oauth/oauth_authentication.rb
+- test/fixtures/access_token.rb
+- test/fixtures/http.rb
+- test/fixtures/request_token.rb
+- test/unit/configuration_test.rb
+- test/unit/credentials_test.rb
+- test/unit/oauth_test.rb
+has_rdoc: true
+homepage: http://github.com/jessedearing/f1api
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Consume the Fellowship One API in your apps using ActiveResource
+test_files: 
+- test/fixtures/access_token.rb
+- test/fixtures/http.rb
+- test/fixtures/request_token.rb
+- test/unit/configuration_test.rb
+- test/unit/credentials_test.rb
+- test/unit/oauth_test.rb