oauth-plugin 0.3.5

data/generators/oauth_provider/templates/controller_spec_helper.rb

@@ -0,0 +1,80 @@
+module OAuthControllerSpecHelper
+  def login
+    controller.stub!(:local_request?).and_return(true)
+    @user = mock_model(User)
+    controller.stub!(:current_user).and_return(@user)
+    @tokens = []
+    @tokens.stub!(:find).and_return(@tokens)
+    @user.stub!(:tokens).and_return(@tokens)
+    User.stub!(:find_by_id).and_return(@user)
+  end
+  
+  def login_as_application_owner
+    login
+    @client_application = mock_model(ClientApplication)
+    @client_applications = [@client_application]
+    
+    @user.stub!(:client_applications).and_return(@client_applications)
+    @client_applications.stub!(:find).and_return(@client_application)
+  end
+
+  def setup_oauth
+    controller.stub!(:local_request?).and_return(true)
+    @user||=mock_model(User)
+
+    User.stub!(:find_by_id).and_return(@user)
+
+    @server = OAuth::Server.new "http://test.host"
+    @consumer = OAuth::Consumer.new('key', 'secret',{:site => "http://test.host"})
+
+    @client_application = mock_model(ClientApplication)
+    controller.stub!(:current_client_application).and_return(@client_application)
+    ClientApplication.stub!(:find_by_key).and_return(@client_application)
+    @client_application.stub!(:key).and_return(@consumer.key)
+    @client_application.stub!(:secret).and_return(@consumer.secret)
+    @client_application.stub!(:name).and_return("Client Application name")
+    @client_application.stub!(:callback_url).and_return("http://application/callback")
+    @request_token = mock_model(RequestToken, :token => 'request_token', :client_application => @client_application, :secret => "request_secret", :user => @user)
+    @request_token.stub!(:invalidated?).and_return(false)
+    ClientApplication.stub!(:find_token).and_return(@request_token)
+
+    @request_token_string="oauth_token=request_token&oauth_token_secret=request_secret"
+    @request_token.stub!(:to_query).and_return(@request_token_string)
+    @request_token.stub!(:expired?).and_return(false)
+    @request_token.stub!(:callback_url).and_return(nil)
+    @request_token.stub!(:verifier).and_return("verifyme")
+    @request_token.stub!(:oauth10?).and_return(false)
+    @request_token.stub!(:oob?).and_return(true)
+
+    @access_token = mock_model(AccessToken, :token => 'access_token', :client_application => @client_application, :secret => "access_secret", :user => @user)
+    @access_token.stub!(:invalidated?).and_return(false)
+    @access_token.stub!(:authorized?).and_return(true)
+    @access_token.stub!(:expired?).and_return(false)
+    @access_token_string="oauth_token=access_token&oauth_token_secret=access_secret"
+    @access_token.stub!(:to_query).and_return(@access_token_string)
+
+    @client_application.stub!(:authorize_request?).and_return(true)
+#    @client_application.stub!(:sign_request_with_oauth_token).and_return(@request_token)
+    @client_application.stub!(:exchange_for_access_token).and_return(@access_token)
+  end
+
+  def setup_oauth_for_user
+    login
+    setup_oauth
+    @tokens = [@request_token]
+    @tokens.stub!(:find).and_return(@tokens)
+    @tokens.stub!(:find_by_token).and_return(@request_token)
+    @user.stub!(:tokens).and_return(@tokens)
+  end
+
+  def sign_request_with_oauth(token=nil,options={})
+    ActionController::TestRequest.use_oauth=true
+    @request.configure_oauth(@consumer,token,options)
+  end
+
+  def setup_to_authorize_request
+    setup_oauth
+    OauthToken.stub!(:find_by_token).with( @access_token.token).and_return(@access_token)
+    @access_token.stub!(:is_a?).and_return(true)
+  end
+end

data/generators/oauth_provider/templates/controller_test.rb

@@ -0,0 +1,310 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/../oauth_controller_test_helper'
+require 'oauth/client/action_controller_request'
+
+class OauthController; def rescue_action(e) raise e end; end
+
+class OauthControllerRequestTokenTest < ActionController::TestCase
+  include OAuthControllerTestHelper
+  tests OauthController
+  
+  def setup
+    @controller = OauthController.new
+    setup_oauth
+    sign_request_with_oauth
+    @client_application.stubs(:create_request_token).returns(@request_token)
+  end
+  
+  def do_get
+    get :request_token
+  end
+  
+  def test_should_be_successful
+    do_get
+    assert @response.success?
+  end
+  
+  def test_should_query_for_client_application
+    ClientApplication.expects(:find_by_key).with('key').returns(@client_application)
+    do_get
+  end
+  
+  def test_should_request_token_from_client_application
+    @client_application.expects(:create_request_token).returns(@request_token)
+    do_get
+  end
+  
+  def test_should_return_token_string
+    do_get
+    assert_equal @request_token_string, @response.body
+  end
+end
+
+class OauthControllerTokenAuthorizationTest < ActionController::TestCase
+   include OAuthControllerTestHelper
+   tests OauthController
+   
+  def setup
+    @controller = OauthController.new
+    login
+    setup_oauth
+    RequestToken.stubs(:find_by_token).returns(@request_token)
+  end
+  
+  def do_get
+    get :authorize, :oauth_token => @request_token.token
+  end
+
+  def do_post
+    @request_token.expects(:authorize!).with(@user)
+    post :authorize,:oauth_token=>@request_token.token,:authorize=>"1"
+  end
+
+  def do_post_without_user_authorization
+    @request_token.expects(:invalidate!)
+    post :authorize,:oauth_token=>@request_token.token,:authorize=>"0"
+  end
+
+  def do_post_with_callback
+    @request_token.expects(:authorize!).with(@user)
+    post :authorize,:oauth_token=>@request_token.token,:oauth_callback=>"http://application/alternative",:authorize=>"1"
+  end
+
+  def do_post_with_no_application_callback
+    @request_token.expects(:authorize!).with(@user)
+    @client_application.stubs(:callback_url).returns(nil)
+    post :authorize, :oauth_token => @request_token.token, :authorize=>"1"
+  end
+  
+  def test_should_be_successful
+    do_get
+    assert @response.success?
+  end
+  
+  def test_should_query_for_client_application
+    RequestToken.expects(:find_by_token).returns(@request_token)
+    do_get
+  end
+  
+  def test_should_assign_token
+    do_get
+    assert_equal @request_token, assigns(:token)
+  end
+  
+  def test_should_render_authorize_template
+    do_get
+    assert_template('authorize')
+  end
+  
+  def test_should_redirect_to_default_callback
+    do_post
+    assert_response :redirect
+    assert_redirected_to("http://application/callback?oauth_token=#{@request_token.token}")
+  end
+
+  def test_should_redirect_to_callback_in_query
+    do_post_with_callback
+    assert_response :redirect
+    assert_redirected_to("http://application/alternative?oauth_token=#{@request_token.token}")
+  end
+
+  def test_should_be_successful_on_authorize_without_any_application_callback
+    do_post_with_no_application_callback
+    assert @response.success?
+    assert_template('authorize_success')
+  end
+  
+  def test_should_render_failure_screen_on_user_invalidation
+    do_post_without_user_authorization
+    assert_template('authorize_failure')
+  end
+
+  def test_should_render_failure_screen_if_token_is_invalidated
+    @request_token.expects(:invalidated?).returns(true)
+    do_get
+    assert_template('authorize_failure')
+  end
+  
+
+end
+
+class OauthControllerGetAccessTokenTest < ActionController::TestCase
+  include OAuthControllerTestHelper
+  tests OauthController
+  
+  def setup
+    @controller = OauthController.new
+    setup_oauth
+    sign_request_with_oauth @request_token
+    @request_token.stubs(:exchange!).returns(@access_token)
+  end
+  
+  def do_get
+    get :access_token
+  end
+  
+  def test_should_be_successful
+    do_get
+    assert @response.success?
+  end
+  
+  def test_should_query_for_client_application
+    ClientApplication.expects(:find_token).with(@request_token.token).returns(@request_token)
+    do_get
+  end
+  
+  def test_should_request_token_from_client_application
+    @request_token.expects(:exchange!).returns(@access_token)
+    do_get
+  end
+  
+  def test_should__return_token_string
+    do_get
+    assert_equal @access_token_string, @response.body
+  end
+end
+
+class OauthorizedController < ApplicationController
+  before_filter :login_or_oauth_required,:only=>:both
+  before_filter :login_required,:only=>:interactive
+  before_filter :oauth_required,:only=>:token_only
+    
+  def interactive
+    render :text => "interactive"
+  end
+  
+  def token_only
+    render :text => "token"
+  end
+  
+  def both
+    render :text => "both"
+  end
+end
+ 
+
+class OauthControllerAccessControlTest < ActionController::TestCase
+  include OAuthControllerTestHelper
+  tests OauthorizedController
+  
+  def setup
+    @controller = OauthorizedController.new
+  end
+  
+  def test_should__have_access_token_set_up_correctly
+    setup_to_authorize_request
+    assert @access_token.is_a?(AccessToken)
+    assert @access_token.authorized?
+    assert !@access_token.invalidated?
+    assert_equal @user, @access_token.user
+    assert_equal @client_application, @access_token.client_application
+  end
+  
+  def test_should_return_false_for_oauth_by_default
+    assert_equal false, @controller.send(:oauth?)
+  end
+
+  def test_should_return_nil_for_current_token_by_default
+    assert_nil @controller.send(:current_token)
+  end
+  
+  def test_should_allow_oauth_when_using_login_or_oauth_required
+    setup_to_authorize_request
+    sign_request_with_oauth(@access_token)
+    ClientApplication.expects(:find_token).with(@access_token.token).returns(@access_token)
+    get :both
+    assert_equal @access_token, @controller.send(:current_token)
+    assert @controller.send(:current_token).is_a?(AccessToken)
+    assert_equal @user, @controller.send(:current_user)
+    assert_equal @client_application, @controller.send(:current_client_application)
+    assert_equal '200', @response.code
+    assert @response.success?
+  end
+
+  def test_should_allow_interactive_when_using_login_or_oauth_required
+    login
+    get :both
+    assert @response.success?
+    assert_equal @user, @controller.send(:current_user)
+    assert_nil @controller.send(:current_token)
+  end
+  
+  def test_should_allow_oauth_when_using_oauth_required
+    setup_to_authorize_request
+    sign_request_with_oauth(@access_token)
+    ClientApplication.expects(:find_token).with(@access_token.token).returns(@access_token)
+    get :token_only
+    assert_equal @access_token, @controller.send(:current_token)
+    assert_equal @client_application, @controller.send(:current_client_application)
+    assert_equal @user, @controller.send(:current_user)
+    assert_equal '200', @response.code
+    assert @response.success? 
+  end
+
+  def test_should_disallow_oauth_using_request_token_when_using_oauth_required
+    setup_to_authorize_request
+    ClientApplication.expects(:find_token).with(@request_token.token).returns(@request_token)
+    sign_request_with_oauth(@request_token)
+    get :token_only
+    assert_equal '401', @response.code
+  end
+
+  def test_should_disallow_interactive_when_using_oauth_required
+    login
+    get :token_only
+    assert_equal '401', @response.code
+    
+    assert_equal @user, @controller.send(:current_user)
+    assert_nil @controller.send(:current_token)
+  end
+
+  def test_should_disallow_oauth_when_using_login_required
+    setup_to_authorize_request
+    sign_request_with_oauth(@access_token)
+    get :interactive
+    assert_equal "302",@response.code
+    assert_nil @controller.send(:current_user)
+    assert_nil @controller.send(:current_token)
+  end
+
+  def test_should_allow_interactive_when_using_login_required
+    login
+    get :interactive
+    assert @response.success?
+    assert_equal @user, @controller.send(:current_user)
+    assert_nil @controller.send(:current_token)
+  end
+
+end
+
+class OauthControllerRevokeTest < ActionController::TestCase
+  include OAuthControllerTestHelper
+  tests OauthController
+  
+  def setup
+    @controller = OauthController.new
+    setup_oauth_for_user
+    @request_token.stubs(:invalidate!)
+  end
+  
+  def do_post
+    post :revoke, :token => "TOKEN STRING"
+  end
+  
+  def test_should_redirect_to_index
+    do_post
+    assert_response :redirect
+    assert_redirected_to('http://test.host/oauth_clients')
+  end
+  
+  def test_should_query_current_users_tokens
+    @tokens.expects(:find_by_token).returns(@request_token)
+    do_post
+  end
+  
+  def test_should_call_invalidate_on_token
+    @request_token.expects(:invalidate!)
+    do_post
+  end
+  
+end

data/generators/oauth_provider/templates/controller_test_helper.rb

@@ -0,0 +1,115 @@
+require "mocha"
+module OAuthControllerTestHelper
+  
+  # Some custom stuff since we're using Mocha
+  def mock_model(model_class, options_and_stubs = {})
+    id = rand(10000)
+    options_and_stubs.reverse_merge! :id => id,
+      :to_param => id.to_s,
+      :new_record? => false,
+      :errors => stub("errors", :count => 0)
+      
+    m = stub("#{model_class.name}_#{options_and_stubs[:id]}", options_and_stubs)
+    m.instance_eval <<-CODE
+      def is_a?(other)
+        #{model_class}.ancestors.include?(other)
+      end
+      def kind_of?(other)
+        #{model_class}.ancestors.include?(other)
+      end
+      def instance_of?(other)
+        other == #{model_class}
+      end
+      def class
+        #{model_class}
+      end
+    CODE
+    yield m if block_given?
+    m
+  end
+    
+  def mock_full_client_application
+    mock_model(ClientApplication, 
+                :name => "App1", 
+                :url => "http://app.com", 
+                :callback_url => "http://app.com/callback",
+                :support_url => "http://app.com/support",
+                :key => "asd23423yy",
+                :secret => "secret",
+                :oauth_server => OAuth::Server.new("http://kowabunga.com")
+              )
+  end
+  
+  def login
+    @controller.stubs(:local_request?).returns(true)
+    @user = mock_model(User, :login => "ron")
+    @controller.stubs(:current_user).returns(@user)
+    @tokens=[]
+    @tokens.stubs(:find).returns(@tokens)
+    @user.stubs(:tokens).returns(@tokens)
+    User.stubs(:find_by_id).returns(@user)
+  end
+  
+  def login_as_application_owner
+    login
+    @client_application = mock_full_client_application
+    @client_applications = [@client_application]
+    
+    @user.stubs(:client_applications).returns(@client_applications)
+    @client_applications.stubs(:find).returns(@client_application)
+  end
+  
+  def setup_oauth
+    @controller.stubs(:local_request?).returns(true)
+    @user||=mock_model(User)
+    
+    User.stubs(:find_by_id).returns(@user)
+    
+    @server=OAuth::Server.new "http://test.host"
+    @consumer=OAuth::Consumer.new('key','secret',{:site=>"http://test.host"})
+
+    @client_application = mock_full_client_application
+    @controller.stubs(:current_client_application).returns(@client_application)
+    ClientApplication.stubs(:find_by_key).returns(@client_application)
+    @client_application.stubs(:key).returns(@consumer.key)
+    @client_application.stubs(:secret).returns(@consumer.secret)
+    @client_application.stubs(:name).returns("Client Application name")
+    @client_application.stubs(:callback_url).returns("http://application/callback")
+    @request_token=mock_model(RequestToken,:token=>'request_token',:client_application=>@client_application,:secret=>"request_secret",:user=>@user)
+    @request_token.stubs(:invalidated?).returns(false)
+    ClientApplication.stubs(:find_token).returns(@request_token)
+    
+    @request_token_string="oauth_token=request_token&oauth_token_secret=request_secret"
+    @request_token.stubs(:to_query).returns(@request_token_string)
+
+    @access_token=mock_model(AccessToken,:token=>'access_token',:client_application=>@client_application,:secret=>"access_secret",:user=>@user)
+    @access_token.stubs(:invalidated?).returns(false)
+    @access_token.stubs(:authorized?).returns(true)
+    @access_token_string="oauth_token=access_token&oauth_token_secret=access_secret"
+    @access_token.stubs(:to_query).returns(@access_token_string)
+
+    @client_application.stubs(:authorize_request?).returns(true)
+#    @client_application.stubs(:sign_request_with_oauth_token).returns(@request_token)
+    @client_application.stubs(:exchange_for_access_token).returns(@access_token)
+  end
+  
+  def setup_oauth_for_user
+    login
+    setup_oauth
+    @tokens=[@request_token]
+    @tokens.stubs(:find).returns(@tokens)
+    @tokens.stubs(:find_by_token).returns(@request_token)
+    @user.stubs(:tokens).returns(@tokens)
+  end
+  
+  def sign_request_with_oauth(token=nil)
+    ActionController::TestRequest.use_oauth=true
+    @request.configure_oauth(@consumer, token)
+  end
+    
+  def setup_to_authorize_request
+    setup_oauth
+    OauthToken.stubs(:find_by_token).with( @access_token.token).returns(@access_token)
+    @access_token.stubs(:is_a?).returns(true)
+  end
+end