casablanca 0.0.2 → 0.0.3

data/History.txt

@@ -1,4 +1,11 @@
-=== 1.0.0 / 2009-01-07
+=== 0.0.2 / 2009-01-07
+
+* 1 major enhancement
+
+  * Implmented renew
+  * Added logger
+
+=== 0.0.2 / 2009-01-07
 
 * 1 major enhancement
 

data/Manifest.txt

@@ -1,6 +1,6 @@
 History.txt
 Manifest.txt
-README.textile
+README.txt
 Rakefile
 init.rb
 bin/casablanca

data/{README.textile → README.txt}

@@ -1,18 +1,29 @@
-h1. Casablanca
+= Casablanca
 
-h2. Description
+* http://rubyforge.org/projects/casablanca/
+
+== DESCRIPTION:
 
 Casablanca is a single sign-on client for the CAS 2.0 protocol.
-It can be run from the commandline and as a filter for Rails.
 
-  sudo gem install p8-casablanca
+== FEATURES:
+
+* Includes a commandline Client to test getting service tickets from a CAS server
+* It can be run as a Rails plugin.
+* Gatewaying (permitting the user to continue without authentication).
+
+== TODO:
 
+* Add extra attributes returned from the server
+* Implement proxing
+* Check for single signout
+* Check for endless redirects
 
-h2. Usage
+== SYNOPSIS:
 
 Commandline:
 
-  casablanca
+  % casablanca
 
 In IRB:
 
@@ -31,6 +42,8 @@ In a Rails project:
   Casablanca::RailsFilter.config do |config|
      config[:cas_server_url]  = "http://localhost:4567"
      config[:service_url]     = "http://localhost:3000"
+     # Always require new credentials for authentication
+     config[:renew]           = true
   end
   
 - Add the following to application.rb:
@@ -52,16 +65,17 @@ In a Rails project:
 - Add the following to you logout action
 
   Casablanca::RailsFilter.logout(self)
+  
+== REQUIREMENTS:
 
-h2. TODO
+== INSTALL:
 
-* Add logging
-* Add extra attributes returned from the server
-* Implement gateway and proxy
-* Check for single signout
-* Check for endless redirects
+Stable version
+* sudo gem install casablanca
+Development version
+* gem sources -a http://gems.github.com; sudo gem install p8-casablanca
 
-h2. LICENSE:
+== LICENSE:
 
 (The MIT License)
 

data/Rakefile

@@ -6,10 +6,11 @@ require 'lib/casablanca.rb'
 
 Hoe.new('casablanca', Casablanca::VERSION) do |p|
   p.developer('FIX', 'FIX@example.com')
+  p.remote_rdoc_dir = '' # Release to root  
 end
 
-# require 'metric_fu'
-# 
-# MetricFu::Configuration.run do |config|
-#   config.coverage = { :test_files => ['test/**/test_*.rb'] }
-# end
+require 'metric_fu'
+
+MetricFu::Configuration.run do |config|
+  config.coverage = { :test_files => ['test/**/test_*.rb'] }
+end

data/bin/casablanca

@@ -3,7 +3,8 @@ irb = RUBY_PLATFORM =~ /mswin32/ ? 'irb.bat' : 'irb'
 options = { :sandbox => false, :irb => irb }
 
 libs =  " -r irb/completion"
-libs << " -r #{File.dirname(__FILE__)}/../lib/casablanca.rb"
-libs << " -r #{File.dirname(__FILE__)}/../lib/casablanca/cli.rb"
+libs << " -r #{File.expand_path(File.dirname(__FILE__))}/../lib/casablanca.rb"
+libs << " -r #{File.expand_path(File.dirname(__FILE__))}/../lib/casablanca/client.rb"
+libs << " -r #{File.expand_path(File.dirname(__FILE__))}/../lib/casablanca/cli.rb"
 
 exec "#{options[:irb]} #{libs} --simple-prompt"

data/lib/casablanca.rb

@@ -1,5 +1,5 @@
 module Casablanca
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end
 require 'casablanca/client'
 require 'casablanca/response_parsers'

data/lib/casablanca/cli.rb

@@ -6,15 +6,19 @@ CASABLANCA CLIENT CONSOLE (#{Casablanca::VERSION})
 Use C for a configured client (#{config.inspect})
 Example:
 
-t = C.get_service_ticket('admin', 'admin')
-C.authenticate_ticket(t)
+  t = C.login('admin', 'admin')
+  C.authenticate_ticket(t)
+
+  C.logout
 
 The configuration can be changed:
-C.cas_server_url = "http://example.com/cas_server"
-C.service_url = "http://example.com/application"
+
+  C.cas_server_url = "http://example.com/cas_server"
+  C.service_url = "http://example.com/application"
 
 )
 
-C = @client = Casablanca::CommandLineClient.new(config)
+C = Casablanca::CommandLineClient.new(config)
+C.logger.level = Logger::DEBUG
 
 puts INFO

data/lib/casablanca/client.rb

@@ -2,9 +2,10 @@ require 'uri'
 require 'cgi'
 require 'net/https'
 require 'rexml/document'
+require 'logger'
 
 module Casablanca
-
+  
   class Client
     attr_accessor :cas_server_url, :service_url
 
@@ -14,23 +15,60 @@ module Casablanca
       @service_url = config[:service_url]
     end
 
+    ##
+    # Validates a Ticket to the validation url of the CAS Server
+    # and checks if the ticket is authenticated
     def authenticate_ticket(ticket)
-      response = request_validation(ticket)
-      ticket.authenticate(response)
+      request_validation(ticket)
+      ticket.authenticate
     end
 
-    def login_url
-      url = "#{@cas_server_url}/login?service=#{@service_url}" 
+    ##
+    # The login url of the Cas server. This page has the login form.
+    def login_url(params={})
+      uri = URI.parse("#{@cas_server_url}/login")
+      query = {:service => @service_url}
+      query[:renew] = 'true' if params[:renew]
+      uri.merge_query(query)
+      uri.to_s
     end
 
-    def logout_url
-      "#{@cas_server_url}/logout"
+    ##
+    # The logout url of the Cas server
+    def logout_url(params={})
+      uri = URI.parse("#{@cas_server_url}/logout")
+      query = {}
+      query[:url] = params[:url] if params[:url]
+      uri.merge_query(query)
+      uri.to_s
     end
 
+    ##
+    # The proxy validation url of the Cas server.
     def validate_url
       "#{@cas_server_url}/proxyValidate"
     end
 
+    def logger
+      self.class.logger
+    end
+
+    def logger=logger
+      self.class.logger = logger
+    end
+
+    def self.logger=logger
+      @logger = logger
+    end
+
+    def self.logger
+      unless @logger
+        @logger = ::Logger.new($stderr)
+        @logger.level = Logger::WARN
+      end
+      @logger
+    end
+    
     private
 
     def request_validation(ticket)
@@ -38,95 +76,134 @@ module Casablanca
       uri = URI.parse(validate_url)
       uri.merge_query(ticket.to_request_params)
       response = get(uri)
-      puts "#{@cas_server_url} #{response.inspect}:\n#{response.body}"
       unless response.kind_of?(Net::HTTPSuccess)
         raise ResponseError, "#{response.code}, #{response.body}"
       end
-      response.body
+      ticket.body = response.body
     end
     
     def get(uri)
       https(uri) do |h|
-        h.get("#{uri.path}?#{uri.query}")
-      end   
+        h.get("#{uri.path}?#{uri.query}", headers)
+      end
     end 
 
     def https(uri)
       https = Net::HTTP.new(uri.host, uri.port)
       https.use_ssl = (uri.scheme == 'https')
       begin
-        https.start do |h|
+        response = https.start do |h|
           yield(h)
         end
       rescue Errno::ECONNREFUSED => error
         raise CasServerException
       end
+      logger.debug(response_log(response))
+      response     
+    end
+    
+    def headers
+      {'cookie' => @ticket_granting_ticket || ''}
+    end
+
+    def response_log(response)
+      msg = "################\n"
+      msg << "  #{@cas_server_url} #{response.inspect}:\n"
+      msg << "  body: #{response.body}\n"
+      msg << "  headers:\n"
+      response.each_key do |k|
+        msg << "    - #{k}: #{response[k]}\n"
+      end
+      msg
     end
 
   end
 
   class CommandLineClient < Client
-
+    attr_reader :ticket_granting_ticket
+    ##
+    # Logs in to the CAS server and returns the response
     def login(username, password)
-      post(URI.parse(login_url), {:username => username, :password => password, :service => service_url})
+      @ticket_granting_ticket = nil
+      response = post(URI.parse(login_url), {:username => username, :password => password, :service => service_url})
+      set_ticket_granting_ticket(response)
+      get_service_ticket(response)
     end
 
-    def get_service_ticket(username, password)
-      location = login(username, password)['location']
-      query = {}
-      URI.parse(location).query.collect{|q| k,v = q.split('='); query[k] = v }
-      Ticket.new(query['ticket'], @service_url)
+    def logout(follow_url=nil)
+      @ticket_granting_ticket = nil
+      uri = URI.parse(logout_url)
+      uri.merge_query(:url => follow_url) if follow_url
+      get(uri)
     end
-    
+
     private
-    
+
     def post(uri, form_data)
       req = Net::HTTP::Post.new(uri.path)
       req.set_form_data(form_data, ';')
       https(uri) do |h|
         h.request(req)
       end
-    end  
+    end
+    
+    def get_service_ticket(response)
+      if (location = response['location'])
+        query = {}
+        URI.parse(location).query.collect{|q| k,v = q.split('='); query[k] = v }
+        Ticket.new(query['ticket'], @service_url)
+      end
+    end
+
+    def set_ticket_granting_ticket(response)
+      @ticket_granting_ticket = (response['set-cookie'] || '').split(/;/)[0] # tgt=TGC-1232569033r763536CC6753E6F357
+    end    
   end
 
   class Ticket
     attr_accessor :user, :failure_code, :failure_message
     attr_reader :service_url, :ticket
-    
+    attr_writer :body
     def initialize(ticket, service_url, renew = false)      
       @service_url = service_url
       @ticket  = ticket
-      @renew   = renew
+      @renew = renew
     end
 
+    ##
+    # Create a Ticket from a Hash. Useful for unserializing
     def self.from_hash(hash)
-      ticket = Ticket.new(hash[:ticket], hash[:service_url], hash[:renew])
+      ticket = Ticket.new(hash[:ticket], hash[:service_url])
       ticket.user = hash[:user]
       ticket
     end
 
-    def to_request_params
-      params = {:service =>  @service_url,
-        :ticket => @ticket }
-      params[:renew] = 1 if @renew
-      params
-    end
-
+    ##
+    # Convert a Ticket to a Hash. Useful for serializing    
     def to_hash
       props = {}
       props[:user] = @user if authenticated?
-      props[:renew] = @renew if @renew
       props[:service_url] = @service_url
       props[:ticket] = @ticket
       props
     end
+
+    ##
+    # Convert the ticket to a Hash for a request
+    def to_request_params
+      params = {}
+      params[:service] = @service_url
+      params[:ticket] = @ticket if @ticket
+      params[:renew] = 'true' if @renew      
+      params
+    end
     
     def authenticated?
       !!@user
     end
 
-    def authenticate(body)
-      response = CasResponseParser.parse(self, body)
+    def authenticate
+      response = CasResponseParser.parse(self, @body)
       authenticated?
     end
   end
@@ -141,12 +218,19 @@ module Casablanca
   end
 end
 
+##
+# Monkey patches for URI::HTTP
 class URI::HTTP
+  
+  ##
+  # Adds the hash to query
   def merge_query(hash)
     q = query ? query + '&' : ''
     self.query = "#{q}#{hash_to_uri_array(hash)}"
   end
   
+  private
+  
   def hash_to_uri_array(hash)
     hash.collect do |name, value|
       if value.kind_of? Array

data/lib/casablanca/filters/rails.rb

@@ -1,55 +1,85 @@
 module Casablanca
   class RailsFilter
-    @@client = nil
 
     class << self
-      
-      def client=client
-        @@client = client
-      end
-      
-      def client
-        @@client
-      end
-            
+
+      ##
+      # Configure the client
+      #
+      #   Casablanca::RailsFilter.config do |config|
+      #     config[:cas_server_url]  = "http://localhost:4567"
+      #     config[:service_url]     = "http://localhost:3000"
+      #   end
       def config
         config = {}
         yield config
-        @@client = Client.new(config)
+        @cas_server_url = config[:cas_server_url]
+        @service_url = config[:service_url]
+        @renew = config[:renew] # always renew the session
+        # set logger to rails logger
+        Client.logger = ::ActionController::Base.logger        
       end
       
       def filter(controller)
-        return true if previous_ticket(controller) && !controller.params[:renew]     
-        ticket = Ticket.new(controller.params[:ticket], @@client.service_url, controller.params[:renew])
-        if @@client.authenticate_ticket(ticket)
-          puts "Ticket authenticated"
+        
+        client = Client.new(:cas_server_url => @cas_server_url, :service_url => @service_url)
+        if !controller.session[:cas_user] && !controller.params[:ticket]
+          if renew?
+            logger.debug "Always require credentials for authentication"
+          else
+            logger.debug "Not authenticated yet. Ticket parameter required"
+          end
+          redirect_to_cas_login(controller, renew?)
+          return false
+        end
+        ticket = Ticket.new(controller.params[:ticket], client.service_url, controller.session[:cas_renew])
+        if client.authenticate_ticket(ticket)
+          logger.debug "Ticket authenticated"
           controller.session[:cas_user] = ticket.user
-          controller.session[:cas_ticket] = ticket.to_hash
+          controller.session[:cas_renew] = nil
           return true
-        else
-          puts "Ticket authentication failed: #{ticket.failure_message}"          
-          controller.session[:cas_user] = nil
-          controller.session[:cas_ticket] = nil
-          controller.send(:redirect_to, login_url)
+        else          
+          logger.warn "Ticket authentication failed: #{ticket.failure_message}"
+          logout(controller)
+          logger.debug "Renew login credentials"
+          redirect_to_cas_login(controller, true)
           return false
         end
       end
 
-      def login_url
-        @@client.login_url
+      ##
+      # The login url of the Cas server. This page has the login form.
+      def login_url(params={})
+        client = Client.new(:cas_server_url => @cas_server_url, :service_url => @service_url)
+        client.login_url(params)
       end
 
+      ##
+      # The logout url of the Cas server.
+      def logout_url(params={})
+        client = Client.new(:cas_server_url => @cas_server_url, :service_url => @service_url)
+        client.logout_url(params)
+      end
+      
+      ##
+      # Logs out of the Cas server.      
       def logout(controller)
-        controller.send(:reset_session)
-        controller.send(:redirect_to, @@client.logout_url)
+        controller.session[:cas_user] = nil
+      end
+      
+      def logger
+        Client.logger
       end
       
       private
       
-      def previous_ticket(controller)
-        hash = controller.session[:cas_ticket]
-        return nil unless hash
-        Ticket.from_hash(hash)
+      def redirect_to_cas_login(controller, renew)
+        controller.session[:cas_renew] = renew
+        controller.send(:redirect_to, login_url(:renew => renew))
+      end
+      
+      def renew?
+        @renew
       end
       
     end

data/test/test_client.rb

@@ -18,7 +18,7 @@ class TestClient < Test::Unit::TestCase
   def test_authenticate_ticket
     service_ticket = get_service_ticket
     @client = Client.new(:cas_server_url => "http://localhost:4567", :service_url => "http://localhost:3000")    
-    mock_authenticate_ticket(VALID_REQUEST)    
+    mock_authenticate_ticket(VALID_REQUEST)
     @client.authenticate_ticket(service_ticket)
     assert_equal 'admin', service_ticket.user
   end
@@ -26,7 +26,7 @@ class TestClient < Test::Unit::TestCase
   def test_validate_expired_ticket
     mock_authenticate_ticket(INVALID_TICKET)
     ticket = 'ST-1231341579r871C5757B79767C21E'
-    service_ticket = Ticket.new(ticket, 'http://localhost:3000', true)
+    service_ticket = Ticket.new(ticket, 'http://localhost:3000')
     @client.authenticate_ticket(service_ticket)
     assert_equal 'INVALID_TICKET', service_ticket.failure_code
     #assert_equal "Ticket 'ST-1231341579r871C5757B79767C21E' has already been used up.", ticket.failure_message
@@ -35,7 +35,7 @@ class TestClient < Test::Unit::TestCase
   def test_validate_invalid_ticket
     mock_authenticate_ticket(INVALID_TICKET)
     ticket = 'ST-1231242314r72465638160B31E8D1'
-    service_ticket =  Ticket.new(ticket, 'http://localhost:3000', true)
+    service_ticket =  Ticket.new(ticket, 'http://localhost:3000')
     @client.authenticate_ticket(service_ticket)
     assert_equal 'INVALID_TICKET', service_ticket.failure_code
     assert_equal "Ticket ST-1231242314r72465638160B31E8D1 not recognized.", service_ticket.failure_message
@@ -49,13 +49,24 @@ class TestClient < Test::Unit::TestCase
   end
 
   def test_login_url
-    assert_equal 'http://localhost:4567/login?service=http://localhost:3000', @client.login_url
+    assert_equal 'http://localhost:4567/login?service=http%3A%2F%2Flocalhost%3A3000', @client.login_url
   end
   
+  def test_login_url_with_extra_params
+    url = @client.login_url(:renew => true)    
+    assert_equal true, (url =~ /service\=http%3A%2F%2Flocalhost%3A3000/) > 0
+    assert_equal true, (url =~ /renew\=true/) > 0
+  end
+
   def test_logout_url
-    assert_equal 'http://localhost:4567/logout', @client.logout_url
+    assert_equal 'http://localhost:4567/logout?', @client.logout_url
   end
  
+  def test_logout_url_with_extra_params
+    url = @client.logout_url(:url => 'http://localhost:3000')
+    assert_equal true, (url =~ /url\=http%3A%2F%2Flocalhost%3A3000/) > 0
+  end 
+ 
   def test_validate_url
     assert_equal 'http://localhost:4567/proxyValidate', @client.validate_url
   end
@@ -68,17 +79,41 @@ class TestCommandLineClient < Test::Unit::TestCase
   end
 
   def test_login
-    mock_get_service_ticket
-    res = @client.login('admin', 'admin')
-    assert_equal '', res.body
-    assert_equal '303', res.code
-    assert_equal 0, res['location'] =~ /^http:\/\/localhost:3000\?ticket=ST-/
-    assert_equal 61, res['location'].size
+    mock_get_service_ticket(@client)
+    service_ticket = @client.login('admin', 'admin')
+    #assert_equal '', res.body
+    #assert_equal '303', res.code
+    #assert_equal 0, res['location'] =~ /^http:\/\/localhost:3000\?ticket=ST-/
+    assert_equal 32, service_ticket.ticket.size
+    assert_equal 37, @client.ticket_granting_ticket.size
   end
 
+  def test_logout
+    mock_get_service_ticket(@client)
+    service_ticket = @client.login('admin', 'admin')
+    assert_equal 37, @client.ticket_granting_ticket.size    
+    # if MOCK_REQUESTS
+      # @client.expects(:get).returns(MockResponse.new(body, '200', :location => 'http://localhost:3000?ticket=ST-1231341579r871C5757B79767C21E'))
+    # end
+    service_ticket = @client.logout
+    assert_equal nil, @client.ticket_granting_ticket
+  end
+
+  def test_logout_with_follow_url
+    mock_get_service_ticket(@client)
+    service_ticket = @client.login('admin', 'admin')
+    assert_equal 37, @client.ticket_granting_ticket.size    
+    # if MOCK_REQUESTS
+      # @client.expects(:get).returns(MockResponse.new(body, '200', :location => 'http://localhost:3000?ticket=ST-1231341579r871C5757B79767C21E'))
+    # end
+    service_ticket = @client.logout('follow_url')
+    assert_equal nil, @client.ticket_granting_ticket
+    # TODO check for follow_url
+  end
+  
   def test_get_service_ticket
-    mock_get_service_ticket
-    ticket = @client.get_service_ticket('admin', 'admin')
+    mock_get_service_ticket(@client)
+    ticket = @client.login('admin', 'admin')
     assert_equal 0, ticket.ticket =~ /^ST-/
     assert_equal 32, ticket.ticket.size    
   end

data/test/test_helper.rb

@@ -12,22 +12,22 @@ class Test::Unit::TestCase
   
   def mock_authenticate_ticket(body)
     if MOCK_REQUESTS
-      @client.expects(:get).returns(MockResponse.new(body, '200', :location => 'http://localhost:3000?ticket=ST-1231341579r871C5757B79767C21E'))
+      Client.any_instance.expects(:get).returns(MockResponse.new(body, '200', :location => 'http://localhost:3000?ticket=ST-1231341579r871C5757B79767C21E'))
     end
   end
   
-  def mock_get_service_ticket
+  def mock_get_service_ticket(client=Client.any_instance)
     if MOCK_REQUESTS
-      @client.expects(:post).returns(MockResponse.new('', '303', :location => 'http://localhost:3000?ticket=ST-1231341579r871C5757B79767C21E'))
+      client.expects(:post).returns(MockResponse.new('', '303', :location => 'http://localhost:3000?ticket=ST-1231341579r871C5757B79767C21E', :'set-cookie' => 'tgt=TGC-1232569033r763536CC6753E6F357'))
     end
   end
 
   def get_service_ticket
     cli = CommandLineClient.new(:cas_server_url => "http://localhost:4567", :service_url => "http://localhost:3000")
     if MOCK_REQUESTS
-      cli.expects(:post).returns(MockResponse.new('', '303', :location => 'http://localhost:3000?ticket=ST-1231341579r871C5757B79767C21E'))
+      cli.expects(:post).returns(MockResponse.new('', '303', {:location => 'http://localhost:3000?ticket=ST-1231341579r871C5757B79767C21E', :'set-cookie' => 'tgt=TGC-1232569033r763536CC6753E6F357'}))
     end
-    cli.get_service_ticket('admin', 'admin')
+    cli.login('admin', 'admin')
   end 
 end
 

data/test/test_rails_filter.rb

@@ -1,73 +1,80 @@
 require File.join(File.dirname(__FILE__), 'test_helper.rb')
-require 'action_pack'
+
 class TestRailsFilter < Test::Unit::TestCase
   def setup
-    @client = Client.new(:cas_server_url => "http://localhost:4567", :service_url => "http://localhost:3000")
-    RailsFilter.client = @client
+    Casablanca::RailsFilter.config do |config|
+       config[:cas_server_url]  = "http://localhost:4567"
+       config[:service_url]     = "http://localhost:3000"
+    end
     @controller = Controller.new    
     @controller.params = {}       
   end
   
   def test_login_url
-    assert_equal 'http://localhost:4567/login?service=http://localhost:3000', RailsFilter.login_url
+    assert_equal 'http://localhost:4567/login?service=http%3A%2F%2Flocalhost%3A3000', RailsFilter.login_url
+  end
+
+  def test_login_url_with_params
+    url = RailsFilter.login_url(:renew => true)
+    assert_equal true, (url =~ /service\=http%3A%2F%2Flocalhost%3A3000/) > 0
+    assert_equal true, (url =~ /renew\=true/) > 0
+  end
+
+  def test_logout_url
+    assert_equal 'http://localhost:4567/logout?', RailsFilter.logout_url
   end  
   
+  def test_logout
+    @controller.session = { :cas_user => 'admin' }
+    RailsFilter.logout(@controller)
+    assert_equal({:cas_user=>nil }, @controller.session)
+  end
+  
   def test_config
     Casablanca::RailsFilter.config do |config|
        config[:cas_server_url]  = "http://example.com/cas_server"
        config[:service_url]     = "http://example.com/application"
     end
-    assert_equal "http://example.com/cas_server", RailsFilter.client.cas_server_url
-    assert_equal "http://example.com/application", RailsFilter.client.service_url    
-  end
-  # def test_filter_requires_config
-  #   RailsFilter.config = nil
-  #   assert_raises(RuntimeError) do
-  #     RailsFilter.filter(Controller.new)
-  #   end
-  # end
-
-  def test_logout
-    RailsFilter.logout(@controller)
-    assert_equal({}, @controller.session)
+    # assert_equal "http://example.com/cas_server", RailsFilter.client.cas_server_url
+    # assert_equal "http://example.com/application", RailsFilter.client.service_url
+    assert_equal 'http://example.com/cas_server/login?service=http%3A%2F%2Fexample.com%2Fapplication', RailsFilter.login_url       
   end
 
   def test_filter_invalid_attempt
-    mock_authenticate_ticket(INVALID_TICKET)
-    @controller.session = {}    
+    service_ticket = get_service_ticket    
+    params = {:ticket => 'service_ticket.ticket'}
+    mock_authenticate_ticket(INVALID_REQUEST)
+    @controller.params = params 
     assert_equal false, RailsFilter.filter(@controller)
   end
 
-  def test_filter_authenticated
+  def test_filter_authenticated_with_valid_ticket_from_request
     service_ticket = get_service_ticket    
     params = {:ticket => service_ticket.ticket}
     mock_authenticate_ticket(VALID_REQUEST)
     @controller.params = params
     assert_equal true, RailsFilter.filter(@controller)
-    assert_session('admin', { :ticket => service_ticket.ticket, :user => 'admin', :service_url => 'http://localhost:3000' })
+    assert_equal 'admin', @controller.session[:cas_user]
   end
 
-  def test_filter_same_ticket
-    params = {:ticket => 'a'}
-    @controller.session = { :cas_ticket => params, :cas_user => 'admin' }
-    @controller.params = params
+  def test_filter_already_authenticated_with_valid_ticket_from_session
+    service_ticket = get_service_ticket    
+    @controller.session = {:cas_user => 'admin'}
+    mock_authenticate_ticket(VALID_REQUEST)
     assert_equal true, RailsFilter.filter(@controller)
-    assert_session('admin', params)
+    assert_equal 'admin', @controller.session[:cas_user]    
   end
 
-  def test_filter_resets_sessions_for_renew
-    mock_authenticate_ticket(INVALID_TICKET)
-    @controller.session[:cas_ticket] = { :ticket => 'a', :service_url => 'b'   }
-    @controller.params = {:renew => true }    
-    assert_equal false, RailsFilter.filter(@controller)
-    assert_session(nil, nil)
-  end
+end
 
-  def assert_session(user, ticket)
-    assert_equal ticket, @controller.session[:cas_ticket]
-    assert_equal user, @controller.session[:cas_user]
+module ActionController
+  module Base
+    def self.logger
+      @logger = ::Logger.new($stderr)
+      @logger.level = ::Logger::ERROR
+      @logger
+    end
   end
-
 end
 
 class Controller # < ActionController::Base

data/test/test_ticket.rb

@@ -23,7 +23,6 @@ class TestTicket < Test::Unit::TestCase
   def test_from_hash
     props = {:ticket => 'ticket',
                   :service_url => "http://localhost:3000",
-                  :renew    => 1,
                   :user     => 'admin' }
     ticket = Ticket.from_hash(props)
     assert_equal props, ticket.to_hash
@@ -36,34 +35,31 @@ class TestTicket < Test::Unit::TestCase
     assert_equal(expected, ticket.to_request_params)
   end
 
-  def test_to_request_params_with_renew
-    ticket = Ticket.new('ticket', 'http://localhost:3000', true)
-    expected = {:ticket => 'ticket',
-                  :service  => "http://localhost:3000",
-                  :renew    => 1 }
-    assert_equal(expected, ticket.to_request_params)
-  end
-  
   def test_authenticate_valid_ticket
-    @ticket.authenticate(VALID_REQUEST)
+    @ticket.body = VALID_REQUEST
+    @ticket.authenticate
     assert_equal 'admin', @ticket.user
   end
 
   def test_authenticate_invalid_request_resets_ticket_to_unauthenticated
-    @ticket.authenticate(VALID_REQUEST)
+    @ticket.body = VALID_REQUEST
+    @ticket.authenticate
     assert_equal true, @ticket.authenticated?
-    @ticket.authenticate(INVALID_REQUEST)
+    @ticket.body = INVALID_REQUEST
+    @ticket.authenticate
     assert_equal false, @ticket.authenticated?
   end
     
   def test_authenticate_invalid_request
-    @ticket.authenticate(INVALID_REQUEST)
+    @ticket.body = INVALID_REQUEST
+    @ticket.authenticate
     assert_equal 'INVALID_REQUEST', @ticket.failure_code    
     assert_equal 'Ticket or service parameter was missing in the request.', @ticket.failure_message
   end
   
   def test_authenticate_invalid_ticket
-    @ticket.authenticate(INVALID_TICKET)
+    @ticket.body = INVALID_TICKET
+    @ticket.authenticate
     assert_equal 'INVALID_TICKET', @ticket.failure_code    
     assert_equal 'Ticket ST-1231242314r72465638160B31E8D1 not recognized.', @ticket.failure_message
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: casablanca
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - FIX
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-19 00:00:00 +01:00
+date: 2009-01-24 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,9 +20,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.8.2
+        version: 1.8.3
     version: 
-description: A single sign-on client for the CAS 2.0 protocol
+description: Casablanca is a single sign-on client for the CAS 2.0 protocol.
 email: 
 - FIX@example.com
 executables: 
@@ -32,10 +32,11 @@ extensions: []
 extra_rdoc_files: 
 - History.txt
 - Manifest.txt
+- README.txt
 files: 
 - History.txt
 - Manifest.txt
-- README.textile
+- README.txt
 - Rakefile
 - init.rb
 - bin/casablanca
@@ -75,7 +76,7 @@ rubyforge_project: casablanca
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: A single sign-on client for the CAS 2.0 protocol
+summary: Casablanca is a single sign-on client for the CAS 2.0 protocol.
 test_files: 
 - test/test_client.rb
 - test/test_helper.rb