tfe-authlogic_openid 0.1.0

data/test/libs/open_id_authentication/lib/open_id_authentication/nonce.rb

@@ -0,0 +1,5 @@
+module OpenIdAuthentication
+  class Nonce < ActiveRecord::Base
+    set_table_name :open_id_authentication_nonces
+  end
+end

data/test/libs/open_id_authentication/lib/open_id_authentication/request.rb

@@ -0,0 +1,23 @@
+module OpenIdAuthentication
+  module Request
+    def self.included(base)
+      base.alias_method_chain :request_method, :openid
+    end
+
+    def request_method_with_openid
+      if !parameters[:_method].blank? && parameters[:open_id_complete] == '1'
+        parameters[:_method].to_sym
+      else
+        request_method_without_openid
+      end
+    end
+  end
+end
+
+# In Rails 2.3, the request object has been renamed
+# from AbstractRequest to Request
+if defined? ActionController::Request
+  ActionController::Request.send :include, OpenIdAuthentication::Request
+else
+  ActionController::AbstractRequest.send :include, OpenIdAuthentication::Request
+end

data/test/libs/open_id_authentication/lib/open_id_authentication/timeout_fixes.rb

@@ -0,0 +1,20 @@
+# http://trac.openidenabled.com/trac/ticket/156
+module OpenID
+  @@timeout_threshold = 20
+
+  def self.timeout_threshold
+    @@timeout_threshold
+  end
+
+  def self.timeout_threshold=(value)
+    @@timeout_threshold = value
+  end
+
+  class StandardFetcher
+    def make_http(uri)
+      http = @proxy.new(uri.host, uri.port)
+      http.read_timeout = http.open_timeout = OpenID.timeout_threshold
+      http
+    end
+  end
+end

data/test/libs/open_id_authentication/tasks/open_id_authentication_tasks.rake

@@ -0,0 +1,30 @@
+namespace :open_id_authentication do
+  namespace :db do
+    desc "Creates authentication tables for use with OpenIdAuthentication"
+    task :create => :environment do
+      generate_migration(["open_id_authentication_tables", "add_open_id_authentication_tables"])
+    end
+
+    desc "Upgrade authentication tables from ruby-openid 1.x.x to 2.x.x"
+    task :upgrade => :environment do
+      generate_migration(["upgrade_open_id_authentication_tables", "upgrade_open_id_authentication_tables"])
+    end
+
+    def generate_migration(args)
+      require 'rails_generator'
+      require 'rails_generator/scripts/generate'
+
+      if ActiveRecord::Base.connection.supports_migrations?
+        Rails::Generator::Scripts::Generate.new.run(args)
+      else
+        raise "Task unavailable to this database (no migration support)"
+      end
+    end
+
+    desc "Clear the authentication tables"
+    task :clear => :environment do
+      OpenIdAuthentication::DbStore.cleanup_nonces
+      OpenIdAuthentication::DbStore.cleanup_associations
+    end
+  end
+end

data/test/libs/open_id_authentication/test/mem_cache_store_test.rb

@@ -0,0 +1,151 @@
+require File.dirname(__FILE__) + '/test_helper'
+require File.dirname(__FILE__) + '/../lib/open_id_authentication/mem_cache_store'
+
+# Mock MemCacheStore with MemoryStore for testing
+class OpenIdAuthentication::MemCacheStore < OpenID::Store::Interface
+  def initialize(*addresses)
+    @connection = ActiveSupport::Cache::MemoryStore.new
+  end
+end
+
+class MemCacheStoreTest < Test::Unit::TestCase
+  ALLOWED_HANDLE = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
+
+  def setup
+    @store = OpenIdAuthentication::MemCacheStore.new
+  end
+
+  def test_store
+    server_url = "http://www.myopenid.com/openid"
+    assoc = gen_assoc(0)
+
+    # Make sure that a missing association returns no result
+    assert_retrieve(server_url)
+
+    # Check that after storage, getting returns the same result
+    @store.store_association(server_url, assoc)
+    assert_retrieve(server_url, nil, assoc)
+
+    # more than once
+    assert_retrieve(server_url, nil, assoc)
+
+    # Storing more than once has no ill effect
+    @store.store_association(server_url, assoc)
+    assert_retrieve(server_url, nil, assoc)
+
+    # Removing an association that does not exist returns not present
+    assert_remove(server_url, assoc.handle + 'x', false)
+
+    # Removing an association that does not exist returns not present
+    assert_remove(server_url + 'x', assoc.handle, false)
+
+    # Removing an association that is present returns present
+    assert_remove(server_url, assoc.handle, true)
+
+    # but not present on subsequent calls
+    assert_remove(server_url, assoc.handle, false)
+
+    # Put assoc back in the store
+    @store.store_association(server_url, assoc)
+
+    # More recent and expires after assoc
+    assoc2 = gen_assoc(1)
+    @store.store_association(server_url, assoc2)
+
+    # After storing an association with a different handle, but the
+    # same server_url, the handle with the later expiration is returned.
+    assert_retrieve(server_url, nil, assoc2)
+
+    # We can still retrieve the older association
+    assert_retrieve(server_url, assoc.handle, assoc)
+
+    # Plus we can retrieve the association with the later expiration
+    # explicitly
+    assert_retrieve(server_url, assoc2.handle, assoc2)
+
+    # More recent, and expires earlier than assoc2 or assoc. Make sure
+    # that we're picking the one with the latest issued date and not
+    # taking into account the expiration.
+    assoc3 = gen_assoc(2, 100)
+    @store.store_association(server_url, assoc3)
+
+    assert_retrieve(server_url, nil, assoc3)
+    assert_retrieve(server_url, assoc.handle, assoc)
+    assert_retrieve(server_url, assoc2.handle, assoc2)
+    assert_retrieve(server_url, assoc3.handle, assoc3)
+
+    assert_remove(server_url, assoc2.handle, true)
+
+    assert_retrieve(server_url, nil, assoc3)
+    assert_retrieve(server_url, assoc.handle, assoc)
+    assert_retrieve(server_url, assoc2.handle, nil)
+    assert_retrieve(server_url, assoc3.handle, assoc3)
+
+    assert_remove(server_url, assoc2.handle, false)
+    assert_remove(server_url, assoc3.handle, true)
+
+    assert_retrieve(server_url, nil, assoc)
+    assert_retrieve(server_url, assoc.handle, assoc)
+    assert_retrieve(server_url, assoc2.handle, nil)
+    assert_retrieve(server_url, assoc3.handle, nil)
+
+    assert_remove(server_url, assoc2.handle, false)
+    assert_remove(server_url, assoc.handle, true)
+    assert_remove(server_url, assoc3.handle, false)
+
+    assert_retrieve(server_url, nil, nil)
+    assert_retrieve(server_url, assoc.handle, nil)
+    assert_retrieve(server_url, assoc2.handle, nil)
+    assert_retrieve(server_url, assoc3.handle, nil)
+
+    assert_remove(server_url, assoc2.handle, false)
+    assert_remove(server_url, assoc.handle, false)
+    assert_remove(server_url, assoc3.handle, false)
+  end
+
+  def test_nonce
+    server_url = "http://www.myopenid.com/openid"
+
+    [server_url, ''].each do |url|
+      nonce1 = OpenID::Nonce::mk_nonce
+
+      assert_nonce(nonce1, true, url, "#{url}: nonce allowed by default")
+      assert_nonce(nonce1, false, url, "#{url}: nonce not allowed twice")
+      assert_nonce(nonce1, false, url, "#{url}: nonce not allowed third time")
+
+      # old nonces shouldn't pass
+      old_nonce = OpenID::Nonce::mk_nonce(3600)
+      assert_nonce(old_nonce, false, url, "Old nonce #{old_nonce.inspect} passed")
+    end
+  end
+
+  private
+    def gen_assoc(issued, lifetime = 600)
+      secret = OpenID::CryptUtil.random_string(20, nil)
+      handle = OpenID::CryptUtil.random_string(128, ALLOWED_HANDLE)
+      OpenID::Association.new(handle, secret, Time.now + issued, lifetime, 'HMAC-SHA1')
+    end
+
+    def assert_retrieve(url, handle = nil, expected = nil)
+      assoc = @store.get_association(url, handle)
+
+      if expected.nil?
+        assert_nil(assoc)
+      else
+        assert_equal(expected, assoc)
+        assert_equal(expected.handle, assoc.handle)
+        assert_equal(expected.secret, assoc.secret)
+      end
+    end
+
+    def assert_remove(url, handle, expected)
+      present = @store.remove_association(url, handle)
+      assert_equal(expected, present)
+    end
+
+    def assert_nonce(nonce, expected, server_url, msg = "")
+      stamp, salt = OpenID::Nonce::split_nonce(nonce)
+      actual = @store.use_nonce(server_url, stamp, salt)
+      assert_equal(expected, actual, msg)
+    end
+end

data/test/libs/open_id_authentication/test/normalize_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class NormalizeTest < Test::Unit::TestCase
+  include OpenIdAuthentication
+
+  NORMALIZATIONS = {
+    "openid.aol.com/nextangler"             => "http://openid.aol.com/nextangler",
+    "http://openid.aol.com/nextangler"      => "http://openid.aol.com/nextangler",
+    "https://openid.aol.com/nextangler"     => "https://openid.aol.com/nextangler",
+    "HTTP://OPENID.AOL.COM/NEXTANGLER"      => "http://openid.aol.com/NEXTANGLER",
+    "HTTPS://OPENID.AOL.COM/NEXTANGLER"     => "https://openid.aol.com/NEXTANGLER",
+    "loudthinking.com"                      => "http://loudthinking.com/",
+    "http://loudthinking.com"               => "http://loudthinking.com/",
+    "http://loudthinking.com:80"            => "http://loudthinking.com/",
+    "https://loudthinking.com:443"          => "https://loudthinking.com/",
+    "http://loudthinking.com:8080"          => "http://loudthinking.com:8080/",
+    "techno-weenie.net"                     => "http://techno-weenie.net/",
+    "http://techno-weenie.net"              => "http://techno-weenie.net/",
+    "http://techno-weenie.net  "            => "http://techno-weenie.net/",
+    "=name"                                 => "=name"
+  }
+
+  def test_normalizations
+    NORMALIZATIONS.each do |from, to|
+      assert_equal to, normalize_identifier(from)
+    end
+  end
+
+  def test_broken_open_id
+    assert_raises(InvalidOpenId) { normalize_identifier(nil) }
+  end
+end

data/test/libs/open_id_authentication/test/open_id_authentication_test.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class OpenIdAuthenticationTest < Test::Unit::TestCase
+  def setup
+    @controller = Class.new do
+      include OpenIdAuthentication
+      def params() {} end
+    end.new
+  end
+
+  def test_authentication_should_fail_when_the_identity_server_is_missing
+    open_id_consumer = mock()
+    open_id_consumer.expects(:begin).raises(OpenID::OpenIDError)
+    @controller.expects(:open_id_consumer).returns(open_id_consumer)
+    @controller.expects(:logger).returns(mock(:error => true))
+
+    @controller.send(:authenticate_with_open_id, "http://someone.example.com") do |result, identity_url|
+      assert result.missing?
+      assert_equal "Sorry, the OpenID server couldn't be found", result.message
+    end
+  end
+
+  def test_authentication_should_be_invalid_when_the_identity_url_is_invalid
+    @controller.send(:authenticate_with_open_id, "!") do |result, identity_url|
+      assert result.invalid?, "Result expected to be invalid but was not"
+      assert_equal "Sorry, but this does not appear to be a valid OpenID", result.message
+    end
+  end
+
+  def test_authentication_should_fail_when_the_identity_server_times_out
+    open_id_consumer = mock()
+    open_id_consumer.expects(:begin).raises(Timeout::Error, "Identity Server took too long.")
+    @controller.expects(:open_id_consumer).returns(open_id_consumer)
+    @controller.expects(:logger).returns(mock(:error => true))
+
+    @controller.send(:authenticate_with_open_id, "http://someone.example.com") do |result, identity_url|
+      assert result.missing?
+      assert_equal "Sorry, the OpenID server couldn't be found", result.message
+    end
+  end
+
+  def test_authentication_should_begin_when_the_identity_server_is_present
+    @controller.expects(:begin_open_id_authentication)
+    @controller.send(:authenticate_with_open_id, "http://someone.example.com")
+  end
+end

data/test/libs/open_id_authentication/test/status_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class StatusTest < Test::Unit::TestCase
+  include OpenIdAuthentication
+
+  def test_state_conditional
+    assert Result[:missing].missing?
+    assert Result[:missing].unsuccessful?
+    assert !Result[:missing].successful?
+
+    assert Result[:successful].successful?
+    assert !Result[:successful].unsuccessful?
+  end
+end

data/test/libs/open_id_authentication/test/test_helper.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+require 'rubygems'
+
+gem 'activesupport'
+require 'active_support'
+
+gem 'actionpack'
+require 'action_controller'
+
+gem 'mocha'
+require 'mocha'
+
+gem 'ruby-openid'
+require 'openid'
+
+RAILS_ROOT = File.dirname(__FILE__) unless defined? RAILS_ROOT
+require File.dirname(__FILE__) + "/../lib/open_id_authentication"

data/test/libs/rails_trickery.rb

@@ -0,0 +1,41 @@
+# The only reason I am doing all of this non sense is becuase the openid_authentication requires that
+# these constants be present. The only other alternative is to use an entire rails application for testing
+# which is a little too overboard for this, I think.
+
+RAILS_ROOT = ''
+
+class ActionController < Authlogic::TestCase::MockController
+  class Request < Authlogic::TestCase::MockRequest
+    def request_method
+      ""
+    end
+  end
+  
+  def root_url
+    ''
+  end
+  
+  def request
+    return @request if defined?(@request)
+    super
+    # Rails does some crazy s#!t with the "method" method. If I don't do this I get a "wrong arguments (0 for 1) error"
+    @request.class.class_eval do
+      def method
+        nil
+      end
+    end
+    @request
+  end
+  
+  def url_for(*args)
+    ''
+  end
+  
+  def redirecting_to
+    @redirect_to
+  end
+  
+  def redirect_to(*args)
+    @redirect_to = args
+  end
+end

data/test/libs/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+  acts_as_authentic
+end

data/test/libs/user_session.rb

@@ -0,0 +1,2 @@
+class UserSession < Authlogic::Session::Base
+end

data/test/session_test.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class SessionTest < ActiveSupport::TestCase
+  def test_openid_identifier
+    session = UserSession.new
+    assert session.respond_to?(:openid_identifier)
+    session.openid_identifier = "test"
+    assert_equal "http://test/", session.openid_identifier
+  end
+  
+  def test_validate_openid_error
+    session = UserSession.new
+    session.openid_identifier = "yes"
+    session.openid_identifier = "%"
+    assert_nil session.openid_identifier
+    assert !session.save
+    assert session.errors.on(:openid_identifier)
+  end
+  
+  def test_validate_by_nil_openid_identifier
+    session = UserSession.new
+    assert !session.save
+    assert !redirecting_to_yahoo?
+  end
+  
+  def test_validate_by_correct_openid_identifier
+    session = UserSession.new
+    session.openid_identifier = "https://me.yahoo.com/a/9W0FJjRj0o981TMSs0vqVxPdmMUVOQ--"
+    assert !session.save
+    assert redirecting_to_yahoo?
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,78 @@
+require "test/unit"
+require "rubygems"
+require "ruby-debug"
+require "active_record"
+
+ActiveRecord::Schema.verbose = false
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+ActiveRecord::Base.configurations = true
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :open_id_authentication_associations, :force => true do |t|
+    t.integer :issued, :lifetime
+    t.string :handle, :assoc_type
+    t.binary :server_url, :secret
+  end
+
+  create_table :open_id_authentication_nonces, :force => true do |t|
+    t.integer :timestamp, :null => false
+    t.string :server_url, :null => true
+    t.string :salt, :null => false
+  end
+  
+  create_table :users do |t|
+    t.datetime  :created_at
+    t.datetime  :updated_at
+    t.integer   :lock_version, :default => 0
+    t.string    :login
+    t.string    :crypted_password
+    t.string    :password_salt
+    t.string    :persistence_token
+    t.string    :single_access_token
+    t.string    :perishable_token
+    t.string    :openid_identifier
+    t.string    :email
+    t.string    :first_name
+    t.string    :last_name
+    t.integer   :login_count, :default => 0, :null => false
+    t.integer   :failed_login_count, :default => 0, :null => false
+    t.datetime  :last_request_at
+    t.datetime  :current_login_at
+    t.datetime  :last_login_at
+    t.string    :current_login_ip
+    t.string    :last_login_ip
+  end
+end
+
+require "active_record/fixtures"
+require "openid"
+Rails = true # to trick authlogic into loading the rails adapter
+require File.dirname(__FILE__) + "/../../authlogic/lib/authlogic"
+require File.dirname(__FILE__) + "/../../authlogic/lib/authlogic/test_case"
+#require File.dirname(__FILE__) + "/libs/rails_trickery"
+require File.dirname(__FILE__) + '/libs/open_id_authentication/lib/open_id_authentication'
+require File.dirname(__FILE__) + '/../lib/authlogic_openid'  unless defined?(AuthlogicOpenid)
+require File.dirname(__FILE__) + '/libs/user'
+require File.dirname(__FILE__) + '/libs/user_session'
+
+class ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+  self.fixture_path = File.dirname(__FILE__) + "/fixtures"
+  self.use_transactional_fixtures = false
+  self.use_instantiated_fixtures  = false
+  self.pre_loaded_fixtures = false
+  fixtures :all
+  setup :activate_authlogic
+  
+  private
+    def activate_authlogic
+      Authlogic::Session::Base.controller = controller
+    end
+    
+    def controller
+      @controller ||= Authlogic::ControllerAdapters::RailsAdapter.new(ActionController.new)
+    end
+    
+    def redirecting_to_yahoo?
+      controller.redirecting_to.to_s =~ /^https:\/\/open.login.yahooapis.com\/openid\/op\/auth/
+    end
+end