warden_oauth 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/CHANGELOG

@@ -0,0 +1,6 @@
+* 0.0.2 (Oct 1, 2009) Keep the manager out of the business of strategies
+* Removing the access_token_user_finder from Warden::Manager and adding it to
+the Warden::StrategyBuilder module
+
+* 0.0.1 (Sep 16, 2009) The beginning of easy OAuth for Warden
+* Adding the initial implementation of the warden_oauth gem

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Roman Gonzalez
+
+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.rdoc

@@ -0,0 +1,60 @@
+= warden_oauth
+
+warden_oauth enhances the Warden authentication framework, offering a simple interface for creating 
+oauth strategies.
+
+== Getting Started
+
+To get started you just have to require the warden_oauth libraries, and setup the 
+oauth services you would like to have on the <tt>Warden::Manager</tt> middleware declaration:
+
+  Warden::Manager do |manager|
+    manager.failure_app = FailureApp
+    manager.oauth(:twitter) do |twitter|
+      twitter.consumer_secret = <YOUR CONSUMER SECRET>
+      twitter.consumer_key  = <YOUR CONSUMER KEY>
+      twitter.options :site => 'http://twitter.com'
+    end
+    manager.default_strategies(:twitter_oauth, :password, :other)
+  end
+
+== Giving an Access Token fetcher
+
+Users get identified on a system via an access_token and an access_secret, when a valid access_token is 
+recevied, warden_oauth calls a fetcher declared on <tt>Warden::Manager.access_token_user_finder</tt>. 
+
+  Warden::Manager.access_token_user_finder(:twitter) do |access_token|
+    User.find_by_access_token_and_access_secret(access_token.token, access_token.secret)
+  end
+
+If a user is returned, then this is the user that is going to be authenticated in the session, otherwise the 
+<tt>FailureApp</tt> will be called, you may check the <tt>env['warden.options'][:oauth][:access_token]</tt> to check
+the original access_token and <em>create a new user</em> from there if desired. 
+
+== Strategy Class info
+
+When you declare an oauth strategy on the <tt>Warden::Manager</tt> initialization, (e.g. manager.oauth(:service_name))
+a <tt>Warden::OAuth::Strategy::ServiceName</tt> will be declared, at the same time this class will be registered as
+<tt>:service_name_oauth</tt> on the <tt>Warden::Strategies</tt>.
+
+So if we have a declaration like the one of the Getting Started section, we will have an Strategy class 
+called <tt>Warden::OAuth::Strategy::Twitter</tt>, and this will be registered as <tt>:twitter_oauth</tt>.
+
+== Running the Strategy
+
+In order to get the strategy running in the app, you have to specify a parameter called warden_oauth_provider
+with the name of the oauth service you want to start. So for example, if you would like to boot the twitter
+oauth example given on the "Getting Started" section you just have to specify the parameter on a protected
+url.
+
+In Rails:
+  
+  link_to 'Twitter Authentication', url_for(login_path(:warden_oauth_provider => 'twitter'))
+
+== Note on Patches/Pull Requests
+
+For any error send an email to: romanandreg [at] gmail [dot] com
+
+== Copyright
+
+Copyright (c) 2009 Roman Gonzalez. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "warden_oauth"
+    gem.summary = %Q{OAuth Strategy generator for Warden Authentication Framework}
+    gem.description = %Q{ 
+      warden_oauth will help you create oauth authentication strategies using the oauth
+      helper method on the Warden::Manager config setup
+    }
+    gem.email = "romanandreg@gmail.com"
+    gem.homepage = "http://github.com/roman/warden_oauth"
+    gem.authors = ["Roman Gonzalez"]
+    gem.rubyforge_project = "warden_oauth"
+    gem.add_dependency('warden')
+    gem.add_dependency('oauth')
+    gem.add_development_dependency("rack-test")
+    gem.add_development_dependency("fakeweb")
+    gem.add_development_dependency("rspec")
+    gem.add_development_dependency("yard")
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/warden_oauth.rb

@@ -0,0 +1,19 @@
+require "rack"
+require "warden"
+require "oauth"
+
+module Warden
+  module OAuth
+
+    base_path = File.dirname(__FILE__) + "/warden_oauth"
+    
+    require base_path + "/errors"
+    autoload :Utils,           base_path + '/utils'
+    autoload :StrategyBuilder, base_path + '/strategy_builder'
+    autoload :Strategy,        base_path + '/strategy'
+    autoload :Config,          base_path + "/config"
+    require base_path + "/manager"
+    
+
+  end
+end

data/lib/warden_oauth/config.rb

@@ -0,0 +1,43 @@
+module Warden
+  module OAuth
+  
+    #
+    # Holds all the information of the OAuth service.
+    #
+    class Config
+      attr_accessor :provider_name
+      
+      def consumer_key(key = nil)
+        unless key.nil?
+          @consumer_key = key
+        end
+        @consumer_key
+      end
+      alias_method :consumer_key=, :consumer_key
+
+      def consumer_secret(secret = nil)
+        unless secret.nil?
+          @consumer_secret = secret
+        end
+        @consumer_secret
+      end
+      alias_method :consumer_secret=, :consumer_secret
+
+      def options(options = nil) 
+        unless options.nil?
+          @options = options
+        end
+        @options
+      end
+      alias_method :options=, :options
+
+      def check_requirements
+        if @consumer_key.nil? || @consumer_secret.nil?
+          raise Warden::OAuth::ConfigError.new("You need to specify the consumer key and the consumer secret")
+        end
+      end
+
+    end
+
+  end
+end

data/lib/warden_oauth/errors.rb

@@ -0,0 +1,9 @@
+module Warden
+  module OAuth
+
+    class ConfigError < ArgumentError; end
+    class ServiceAlreadyRegistered < StandardError; end
+    class AccessTokenFinderMissing < StandardError; end
+
+  end
+end

data/lib/warden_oauth/manager.rb

@@ -0,0 +1,43 @@
+module Warden
+  module OAuth
+
+    #
+    # Holds all the extensions made to Warden::Manager in order to create OAuth
+    # consumers.
+    #
+    module Manager
+
+      #
+      # Helps to setup a new OAuth client authentication, to get started you need to define
+      # a service name, and then on the block assign the different values required in order
+      # to boot the OAuth process.
+      # @param [Symbol] service An identifier of the OAuth service
+      # 
+      # @example
+      #
+      #   Warden::Manager.oauth(:twitter) do
+      #     consumer_key "<YOUR CONSUMER KEY>"
+      #     consumer_secret "<YOUR CONSUMER SECRET>"
+      #     options :site => 'http://twitter.com'
+      #   end
+      #
+      def oauth(service, &block)
+        config = Warden::OAuth::Config.new
+        if block_given?
+          if block.arity == 1 
+            yield config 
+          else
+            config.instance_eval(&block)
+          end
+        end
+        config.check_requirements
+        config.provider_name = service
+        Warden::OAuth::Strategy.build(service, config)
+      end
+    
+    end
+
+  end
+end
+
+Warden::Manager.send(:include, Warden::OAuth::Manager)

data/lib/warden_oauth/strategy.rb

@@ -0,0 +1,140 @@
+module Warden
+  module OAuth
+
+    #
+    # Holds all the main logic of the OAuth authentication, all the generated
+    # OAuth classes will extend from this class
+    #
+    class Strategy < Warden::Strategies::Base
+      extend StrategyBuilder
+
+      ######################
+      ### Strategy Logic ###
+      ######################
+
+      #
+      # An OAuth strategy will be valid to execute if:
+      # * A 'warden_oauth_provider' parameter is given, with the name of the OAuth service
+      # * A 'oauth_token' is being receive on the request (response from an OAuth provider)
+      #
+      def valid?
+        (params.include?('warden_oauth_provider') &&  params['warden_oauth_provider'] == config.provider_name.to_s) ||
+          params.include?('oauth_token') 
+      end
+
+
+      #
+      # Manages the OAuth authentication process, there can be 3 outcomes from this Strategy:
+      # 1. The OAuth credentials are invalid and the FailureApp is called
+      # 2. The OAuth credentials are valid, but there is no user associated to them. In this case
+      #    the FailureApp is called, but the env['warden.options'][:oauth][:access_token] will be 
+      #    available.
+      # 3. The OAuth credentials are valid, and the user is authenticated successfuly
+      #
+      # @note
+      # If you want to signup users with the twitter credentials, you can manage the creation of a new 
+      # user in the FailureApp with the given access_token
+      #
+      def authenticate!
+        if params.include?('warden_oauth_provider')
+          store_request_token_on_session
+          redirect!(request_token.authorize_url)
+
+        elsif params.include?('oauth_token')
+          load_request_token_from_session
+          if missing_stored_token?
+            fail!("There is no OAuth authentication in progress")
+          elsif !stored_token_match_recieved_token?
+            fail!("Received OAuth token didn't match stored OAuth token")
+          else
+            user = find_user_by_access_token(access_token)
+            if user.nil?
+              fail!("User with access token not found")
+              throw_error_with_oauth_info
+            else
+              success!(user)
+            end
+          end
+        end
+
+      end
+
+      def fail!(msg) #:nodoc:
+        self.errors.add(service_param_name.to_sym, msg)
+        super
+      end
+      
+      ###################
+      ### OAuth Logic ###
+      ###################
+
+      def consumer
+        @consumer ||= ::OAuth::Consumer.new(config.consumer_key, config.consumer_secret, config.options)
+      end
+
+      def request_token
+        host_with_port = Warden::OAuth::Utils.host_with_port(request)
+        @request_token ||= consumer.get_request_token(:oauth_callback => host_with_port)
+      end
+
+      def access_token
+        @access_token ||= request_token.get_access_token(:oauth_verifier => params['oauth_verifier'])
+      end
+
+      protected
+
+      def find_user_by_access_token(access_token)
+        raise RuntimeError.new(<<-ERROR_MESSAGE) unless self.respond_to?(:_find_user_by_access_token)
+        
+You need to define a finder by access_token for this strategy.
+Write on the warden initializer the following code:
+Warden::Strategies[:#{config.provider_name}_oauth].access_token_user_finder do |access_token|
+  # Logic to get your user from an access_token
+end
+
+ERROR_MESSAGE
+        self._find_user_by_access_token(access_token)
+      end
+
+      def throw_error_with_oauth_info
+        throw(:warden, :oauth => { 
+          self.config.provider_name => {
+            :provider => config.provider_name,
+            :access_token => access_token,
+            :consumer_key => config.consumer_key,
+            :consumer_secret => config.consumer_secret
+          }
+        })
+      end
+
+      def store_request_token_on_session
+        session[:request_token]  = request_token.token
+        session[:request_secret] = request_token.secret
+      end
+
+      def load_request_token_from_session
+        token  = session.delete(:request_token)
+        secret = session.delete(:request_secret)
+        @request_token = ::OAuth::RequestToken.new(consumer, token, secret)
+      end
+
+      def missing_stored_token? 
+        !request_token
+      end
+
+      def stored_token_match_recieved_token?
+        request_token.token == params['oauth_token']
+      end
+
+      def service_param_name
+        '%s_oauth' % config.provider_name
+      end
+
+      def config
+        self.class::CONFIG
+      end
+
+    end
+
+  end
+end

data/lib/warden_oauth/strategy_builder.rb

@@ -0,0 +1,92 @@
+module Warden
+  module OAuth
+
+    #
+    # Handles the creation an registration of OAuth strategies based on configuration parameters
+    # via the Warden::Manager.oauth method
+    #
+    module StrategyBuilder
+      extend self
+
+
+      #
+      # Defines the user finder from the access_token for the strategy, receives a block
+      # that will be invoked each time you want to find an user via an access_token in your
+      # system.
+      #
+      # @param blk Block that recieves the access_token as a parameter and will return a user or nil
+      # 
+      def access_token_user_finder(&blk)
+        define_method(:_find_user_by_access_token, &blk)
+      end
+
+      #
+      # Manages the creation and registration of the OAuth strategy specified
+      # on the keyword
+      #
+      # @param [Symbol] name of the oauth service
+      # @param [Walruz::Config] configuration specified on the declaration of the oauth service
+      #
+      def build(keyword, config)
+        strategy_class = self.create_oauth_strategy_class(keyword)
+        self.register_oauth_strategy_class(keyword, strategy_class)
+        self.set_oauth_service_info(strategy_class, config)
+      end
+
+      #
+      # Creates the OAuth Strategy class from the keyword specified on the declaration of the 
+      # oauth service. This class will be namespaced inside Warden::OAuth::Strategy
+      #
+      # @param [Symbol] name of the OAuth service 
+      # @return [Class] The class representing the Warden strategy
+      #
+      # @example
+      # 
+      #   self.create_oauth_strategy_class(:twitter) #=> Warden::OAuth::Strategy::Twitter
+      #   # will create a class Warden::OAuth::Strategy::Twitter that extends from 
+      #   # Warden::OAuth::Strategy
+      #
+      def create_oauth_strategy_class(keyword)
+        class_name = Warden::OAuth::Utils.camelize(keyword.to_s) 
+        if self.const_defined?(class_name)
+          self.const_get(class_name) 
+        else
+          self.const_set(class_name, Class.new(self))
+        end
+      end
+
+      #
+      # Registers the generated OAuth Strategy in the Warden::Strategies collection, the label
+      # of the strategy will be the given oauth service name plus an '_oauth' postfix
+      #
+      # @param [Symbol] name of the OAuth service
+      #
+      # @example
+      #   manager.oauth(:twitter) { |twitter| ... } # will register a strategy :twitter_oauth
+      #
+      def register_oauth_strategy_class(keyword, strategy_class)
+        keyword_name = "%s_oauth" % keyword.to_s
+        if Warden::Strategies[keyword_name.to_sym].nil?
+          Warden::Strategies.add(keyword_name.to_sym, strategy_class) 
+        end
+      end
+
+      #
+      # Defines a CONFIG constant in the generated class that will hold the configuration information 
+      # (consumer_key, consumer_secret and options) of the oauth service.
+      #
+      # @param [Class] strategy class that will hold the configuration info
+      # @param [Warden::OAuth::Config] configuration info of the oauth service
+      #
+      def set_oauth_service_info(strategy_class, config)
+        strategy_class.const_set("CONFIG", config) unless strategy_class.const_defined?("CONFIG")
+      end
+
+      protected :create_oauth_strategy_class,
+                :register_oauth_strategy_class,
+                :set_oauth_service_info
+
+    end
+
+  end
+end

data/lib/warden_oauth/utils.rb

@@ -0,0 +1,40 @@
+module Warden
+  module OAuth
+
+    #
+    # Contains methods from Rails to avoid unnecessary dependencies
+    #
+    module Utils
+
+      #
+      # Fetched from ActiveSupport::Inflector.camelize to avoid dependencies
+      #
+      def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+        if first_letter_in_uppercase
+          lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+        else
+          lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+        end
+      end
+
+      #
+      # Fetched from ActionController::Request to avoid dependencies
+      #
+      def host_with_port(request)
+        url = request.scheme + "://"
+        url << request.host
+
+        if request.scheme == "https" && request.port != 443 ||
+            request.scheme == "http" && request.port != 80
+          url << ":#{request.port}"
+        end
+        
+        url
+      end
+
+      module_function :camelize, :host_with_port
+      
+    end
+
+  end
+end

data/spec/application_runner.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'warden_oauth'
+require File.dirname(__FILE__) + "/application_scenario"
+
+Warden::Manager.access_token_user_finder do |access_token|
+  nil
+end
+
+Rack::Handler::Mongrel.run $app, :Port => '4567'

data/spec/application_scenario.rb

@@ -0,0 +1,36 @@
+class ClientApp
+
+  def self.call(env)
+    env['warden'].authenticate!
+    [200, {"Content-Type" => 'text/plain'}, "Welcome"]
+  end
+
+end
+
+class ErrorApp
+  
+  def self.call(env)
+    if env['warden.options'][:oauth].nil?
+      [401, {'Content-Type' => 'text/plain'}, "You are not authenticated"]
+    else
+      access_token = env['warden.options'][:oauth][:access_token]
+      [401, {'Content-Type' => 'text/plain'}, "No user with the given access token"]
+    end
+  end
+
+end
+
+$app = Rack::Builder.new do
+  use Rack::Session::Cookie
+  use Warden::Manager do |manager|
+    manager.oauth(:example) do |example|
+      example.consumer_key "aCOTnTeKniyifcwwF3Mo"
+      example.consumer_secret  "dEu91qxWfO0Z4Be1tHGuZ63FzHoUm9mk4Z8rzKa8"
+      example.options :site => 'http://localhost:3000'
+    end
+    manager.default_strategies :example_oauth
+    manager.failure_app = ErrorApp
+  end
+  run ClientApp
+end if $app.nil?
+

data/spec/fixtures/authorize_request_token.txt

@@ -0,0 +1 @@
+oauth_token=SylltB94pocC6hex8kr9&oauth_verifier=omPxEkKnnx9ygnu7dd6f

data/spec/fixtures/unauthorized_request_token.txt

@@ -0,0 +1 @@
+oauth_token=SylltB94pocC6hex8kr9&oauth_token_secret=WkU0NDgdOlKeB7arFWJyAQjlaVZEEcH0lhdy1kFs&oauth_callback_confirmed=true

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'warden_oauth'
+require 'spec'
+require 'fakeweb'
+require 'spec/autorun'
+
+require File.dirname(__FILE__) + "/application_scenario"
+
+Spec::Runner.configure do |config|
+  config.before(:all) do
+    FakeWeb.allow_net_connect = false
+  end
+end

data/spec/warden_oauth/manager_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Warden::Manager do 
+
+  before(:each) do
+    failure_app = lambda { |env| "Failure" }
+    @manager = Warden::Manager.new(nil, :failure_app => failure_app)
+  end
+  
+  it "should respond to an `oauth` message" do
+    @manager.should respond_to(:oauth)
+  end
+
+  describe "#oauth" do
+
+    describe "when initialize" do
+
+      it "should require setting the consumer_key" do
+        lambda do
+          @manager.oauth(:service) do |service|
+            service.consumer_secret "ABC"
+          end
+        end.should raise_error(Warden::OAuth::ConfigError,  "You need to specify the consumer key and the consumer secret")
+      end
+
+      it "should require setting the consumer_secret" do
+        lambda do 
+          @manager.oauth(:service) do |service|
+            service.consumer_key "ABC"
+          end
+        end.should raise_error(Warden::OAuth::ConfigError, "You need to specify the consumer key and the consumer secret")
+      end
+
+      it "should create a new instance of strategy" do
+        @manager.oauth(:service) do |service|
+          service.consumer_key "ABC"
+          service.consumer_secret "123"
+        end
+        lambda do
+          Warden::OAuth::Strategy::Service
+        end.should_not raise_error(NameError)
+      end
+
+    end
+
+  end
+
+end

data/spec/warden_oauth/strategy_spec.rb

@@ -0,0 +1,144 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+require "rack/test"
+
+describe Warden::OAuth::Strategy do
+  
+  def fixture_response(name)
+    filename = File.dirname(__FILE__) + "/../fixtures/%s.txt" % name
+  end
+
+  describe '.build' do
+    before(:each) do
+      @config = Warden::OAuth::Config.new
+      @config.consumer_key "ABC"
+      @config.consumer_secret "123"
+      @config.options :site => 'http://service.com'
+      Warden::OAuth::Strategy.send(:remove_const, "Service") if Warden::OAuth::Strategy.const_defined?("Service")
+      Warden::Strategies.clear!
+      Warden::OAuth::Strategy.build(:service, @config)
+    end
+
+    it "should create a new instance that extends from Warden::OAuth::Strategy" do
+      Warden::OAuth::Strategy.const_defined?("Service").should be_true
+      (Warden::OAuth::Strategy::Service < Warden::OAuth::Strategy).should be_true
+    end
+
+    it "should register the oauth service key on the Warden strategies with `_oauth` appended" do
+      Warden::Strategies[:service_oauth].should_not be_nil
+      Warden::OAuth::Strategy::Service.should_not be_nil
+      Warden::Strategies[:service_oauth].should == Warden::OAuth::Strategy::Service
+    end
+
+    it "should assign the oauth_service config as a constant" do
+      Warden::OAuth::Strategy::Service::CONFIG.should_not be_nil
+      Warden::OAuth::Strategy::Service::CONFIG.should == @config 
+    end
+
+  end
+
+  describe "when invoking the strategy" do
+    
+    before(:each) do
+      @request  = Rack::MockRequest.new($app)
+    end
+
+
+    describe "without warden_oauth_service nor oauth_token parameter" do
+      
+      before(:each) do
+        @response = @request.get("/")
+      end
+
+      it "should render the failure app response" do
+        @response.body.should == "You are not authenticated"
+      end
+
+    end
+
+    describe "with a warden_oauth_provider parameter" do
+
+      before(:each) do
+        FakeWeb.register_uri(:post, 'http://localhost:3000/oauth/request_token', 
+                             :body => fixture_response("unauthorized_request_token"))
+        @response = @request.get("/", :input => 'warden_oauth_provider=example')
+      end
+
+      it "should redirect to the authorize url" do
+        @response.headers['Location'].should =~ %r"http://localhost:3000/oauth/authorize"
+      end
+
+    end
+
+    describe "when receiving a valid oauth response" do
+      include Rack::Test::Methods
+      
+      def app
+        $app
+      end
+
+      describe "and the access_token_finder hasn't been declared" do
+
+        before(:each) do
+          FakeWeb.register_uri(:post, 'http://localhost:3000/oauth/request_token', 
+                               :body => fixture_response("unauthorized_request_token"))
+        end
+
+        it "should raise an exception saying that the access_token_finder is not declared" do
+          get "/", 'warden_oauth_provider' => 'example'
+          FakeWeb.register_uri(:post, 'http://localhost:3000/oauth/access_token', 
+                               :body => 'oauth_token=ABC&oauth_token_secret=123')
+          lambda do
+            get "/", 'oauth_token' => "SylltB94pocC6hex8kr9",
+                     'oauth_verifier' => "omPxEkKnnx9ygnu7dd6f"
+          end.should raise_error(RuntimeError, /strategy/)
+        end
+
+      end
+      
+      describe "and the access_token_finder has been declared" do
+
+        before(:each) do
+          Warden::Strategies[:example_oauth].access_token_user_finder do |access_token|
+            Object.new if access_token.token == 'ABC' && access_token.secret == '123' 
+          end
+          FakeWeb.register_uri(:post, 'http://localhost:3000/oauth/request_token', 
+                               :body => fixture_response("unauthorized_request_token"))
+          get "/", 'warden_oauth_provider' => 'example'
+        end
+
+        describe "and the user is not found" do
+
+          before(:each) do
+            FakeWeb.register_uri(:post, 'http://localhost:3000/oauth/access_token', 
+                                 :body => 'oauth_token=ABD&oauth_token_secret=122')
+            get "/", 'oauth_token' => "SylltB94pocC6hex8kr9",
+                   'oauth_verifier' => "omPxEkKnnx9ygnu7dd6f"
+          end
+
+          it "should invoke the fail app" do
+            last_response.body.should ==  "No user with the given access token"
+          end
+
+        end
+
+        describe "and the user is found" do
+
+          before(:each) do
+            FakeWeb.register_uri(:post, 'http://localhost:3000/oauth/access_token', 
+                                 :body => 'oauth_token=ABC&oauth_token_secret=123')
+            get "/", 'oauth_token' => "SylltB94pocC6hex8kr9",
+                   'oauth_verifier' => "omPxEkKnnx9ygnu7dd6f"
+          end
+
+          it "should go to the desired app" do
+            last_response.body.should == "Welcome" 
+          end
+
+        end
+      end
+
+    end
+
+  end
+
+end

data/warden_oauth.gemspec

@@ -0,0 +1,87 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{warden_oauth}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Roman Gonzalez"]
+  s.date = %q{2009-11-02}
+  s.description = %q{ 
+      warden_oauth will help you create oauth authentication strategies using the oauth
+      helper method on the Warden::Manager config setup
+    }
+  s.email = %q{romanandreg@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "CHANGELOG",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/warden_oauth.rb",
+     "lib/warden_oauth/config.rb",
+     "lib/warden_oauth/errors.rb",
+     "lib/warden_oauth/manager.rb",
+     "lib/warden_oauth/strategy.rb",
+     "lib/warden_oauth/strategy_builder.rb",
+     "lib/warden_oauth/utils.rb",
+     "spec/application_runner.rb",
+     "spec/application_scenario.rb",
+     "spec/fixtures/authorize_request_token.txt",
+     "spec/fixtures/unauthorized_request_token.txt",
+     "spec/spec_helper.rb",
+     "spec/warden_oauth/manager_spec.rb",
+     "spec/warden_oauth/strategy_spec.rb",
+     "warden_oauth.gemspec"
+  ]
+  s.homepage = %q{http://github.com/roman/warden_oauth}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{warden_oauth}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{OAuth Strategy generator for Warden Authentication Framework}
+  s.test_files = [
+    "spec/application_runner.rb",
+     "spec/application_scenario.rb",
+     "spec/spec_helper.rb",
+     "spec/warden_oauth/manager_spec.rb",
+     "spec/warden_oauth/strategy_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<warden>, [">= 0"])
+      s.add_runtime_dependency(%q<oauth>, [">= 0"])
+      s.add_development_dependency(%q<rack-test>, [">= 0"])
+      s.add_development_dependency(%q<fakeweb>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+    else
+      s.add_dependency(%q<warden>, [">= 0"])
+      s.add_dependency(%q<oauth>, [">= 0"])
+      s.add_dependency(%q<rack-test>, [">= 0"])
+      s.add_dependency(%q<fakeweb>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<warden>, [">= 0"])
+    s.add_dependency(%q<oauth>, [">= 0"])
+    s.add_dependency(%q<rack-test>, [">= 0"])
+    s.add_dependency(%q<fakeweb>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification 
+name: warden_oauth
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Roman Gonzalez
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-02 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: warden
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: oauth
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: " \n      warden_oauth will help you create oauth authentication strategies using the oauth\n      helper method on the Warden::Manager config setup\n    "
+email: romanandreg@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- CHANGELOG
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/warden_oauth.rb
+- lib/warden_oauth/config.rb
+- lib/warden_oauth/errors.rb
+- lib/warden_oauth/manager.rb
+- lib/warden_oauth/strategy.rb
+- lib/warden_oauth/strategy_builder.rb
+- lib/warden_oauth/utils.rb
+- spec/application_runner.rb
+- spec/application_scenario.rb
+- spec/fixtures/authorize_request_token.txt
+- spec/fixtures/unauthorized_request_token.txt
+- spec/spec_helper.rb
+- spec/warden_oauth/manager_spec.rb
+- spec/warden_oauth/strategy_spec.rb
+- warden_oauth.gemspec
+has_rdoc: true
+homepage: http://github.com/roman/warden_oauth
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: warden_oauth
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: OAuth Strategy generator for Warden Authentication Framework
+test_files: 
+- spec/application_runner.rb
+- spec/application_scenario.rb
+- spec/spec_helper.rb
+- spec/warden_oauth/manager_spec.rb
+- spec/warden_oauth/strategy_spec.rb