SWAMPy

✎ CARVE FLESH

EDITING: test_http_cookie_jar.rb

require File.expand_path('helper', File.dirname(__FILE__))
require 'tmpdir'

module TestHTTPCookieJar
  class TestAutoloading < Test::Unit::TestCase
    def test_nonexistent_store
      assert_raises(NameError) {
        HTTP::CookieJar::NonexistentStore
      }
    end

def test_erroneous_store
      Dir.mktmpdir { |dir|
        Dir.mkdir(File.join(dir, 'http'))
        Dir.mkdir(File.join(dir, 'http', 'cookie_jar'))
        rb = File.join(dir, 'http', 'cookie_jar', 'erroneous_store.rb')
        File.open(rb, 'w').close
        $LOAD_PATH.unshift(dir)

assert_raises(NameError) {
          HTTP::CookieJar::ErroneousStore
        }
        assert($LOADED_FEATURES.any? { |file| FileTest.identical?(file, rb) })
      }
    end

def test_nonexistent_saver
      assert_raises(NameError) {
        HTTP::CookieJar::NonexistentSaver
      }
    end

def test_erroneous_saver
      Dir.mktmpdir { |dir|
        Dir.mkdir(File.join(dir, 'http'))
        Dir.mkdir(File.join(dir, 'http', 'cookie_jar'))
        rb = File.join(dir, 'http', 'cookie_jar', 'erroneous_saver.rb')
        File.open(rb, 'w').close
        $LOAD_PATH.unshift(dir)

assert_raises(NameError) {
          HTTP::CookieJar::ErroneousSaver
        }
        assert($LOADED_FEATURES.any? { |file| FileTest.identical?(file, rb) })
      }
    end
  end

module CommonTests
    def setup(options = nil, options2 = nil)
      default_options = {
        :store => :hash,
        :gc_threshold => 1500, # increased by 10 for shorter test time
      }
      new_options  = default_options.merge(options || {})
      new_options2 = new_options.merge(options2 || {})
      @store_type = new_options[:store]
      @gc_threshold = new_options[:gc_threshold]
      @jar  = HTTP::CookieJar.new(new_options)
      @jar2 = HTTP::CookieJar.new(new_options2)
    end

#def hash_store?
    #  @store_type == :hash
    #end

def mozilla_store?
      @store_type == :mozilla
    end

def cookie_values(options = {})
      {
        :name     => 'Foo',
        :value    => 'Bar',
        :path     => '/',
        :expires  => Time.at(Time.now.to_i + 10 * 86400), # to_i is important here
        :for_domain => true,
        :domain   => 'rubyforge.org',
        :origin   => 'http://rubyforge.org/'
      }.merge(options)
    end

def test_empty?
      assert_equal true, @jar.empty?
      cookie = HTTP::Cookie.new(cookie_values)
      @jar.add(cookie)
      assert_equal false, @jar.empty?
      assert_equal false, @jar.empty?('http://rubyforge.org/')
      assert_equal true, @jar.empty?('http://example.local/')
    end

def test_two_cookies_same_domain_and_name_different_paths
      url = URI 'http://rubyforge.org/'

cookie = HTTP::Cookie.new(cookie_values)
      @jar.add(cookie)
      @jar.add(HTTP::Cookie.new(cookie_values(:path => '/onetwo')))

assert_equal(1, @jar.cookies(url).length)
      assert_equal 2, @jar.cookies(URI('http://rubyforge.org/onetwo')).length
    end

def test_domain_case
      url = URI 'http://rubyforge.org/'

# Add one cookie with an expiration date in the future
      cookie = HTTP::Cookie.new(cookie_values)
      @jar.add(cookie)
      assert_equal(1, @jar.cookies(url).length)

@jar.add(HTTP::Cookie.new(cookie_values(:domain => 'RuByForge.Org', :name => 'aaron')))

assert_equal(2, @jar.cookies(url).length)

url2 = URI 'http://RuByFoRgE.oRg/'
      assert_equal(2, @jar.cookies(url2).length)
    end

def test_host_only
      url = URI.parse('http://rubyforge.org/')

@jar.add(HTTP::Cookie.new(
          cookie_values(:domain => 'rubyforge.org', :for_domain => false)))

assert_equal(1, @jar.cookies(url).length)

assert_equal(1, @jar.cookies(URI('http://RubyForge.org/')).length)

assert_equal(1, @jar.cookies(URI('https://RubyForge.org/')).length)

assert_equal(0, @jar.cookies(URI('http://www.rubyforge.org/')).length)
    end

def test_host_only_with_unqualified_hostname
      @jar.add(HTTP::Cookie.new(cookie_values(
        :origin => 'http://localhost/', :domain => 'localhost', :for_domain => false)))

assert_equal(1, @jar.cookies(URI('http://localhost/')).length)

assert_equal(1, @jar.cookies(URI('http://Localhost/')).length)

assert_equal(1, @jar.cookies(URI('https://Localhost/')).length)
    end

def test_empty_value
      url = URI 'http://rubyforge.org/'
      values = cookie_values(:value => "")

# Add one cookie with an expiration date in the future
      cookie = HTTP::Cookie.new(values)
      @jar.add(cookie)
      assert_equal(1, @jar.cookies(url).length)

@jar.add HTTP::Cookie.new(values.merge(:domain => 'RuByForge.Org',
          :name   => 'aaron'))

assert_equal(2, @jar.cookies(url).length)

url2 = URI 'http://RuByFoRgE.oRg/'
      assert_equal(2, @jar.cookies(url2).length)
    end

def test_add_future_cookies
      url = URI 'http://rubyforge.org/'

# Add one cookie with an expiration date in the future
      cookie = HTTP::Cookie.new(cookie_values)
      @jar.add(cookie)
      assert_equal(1, @jar.cookies(url).length)

# Add the same cookie, and we should still only have one
      @jar.add(HTTP::Cookie.new(cookie_values))
      assert_equal(1, @jar.cookies(url).length)

# Make sure we can get the cookie from different paths
      assert_equal(1, @jar.cookies(URI('http://rubyforge.org/login')).length)

# Make sure we can't get the cookie from different domains
      assert_equal(0, @jar.cookies(URI('http://google.com/')).length)
    end

def test_add_multiple_cookies
      url = URI 'http://rubyforge.org/'

# Add one cookie with an expiration date in the future
      cookie = HTTP::Cookie.new(cookie_values)
      @jar.add(cookie)
      assert_equal(1, @jar.cookies(url).length)

# Add the same cookie, and we should still only have one
      @jar.add(HTTP::Cookie.new(cookie_values(:name => 'Baz')))
      assert_equal(2, @jar.cookies(url).length)

# Make sure we can get the cookie from different paths
      assert_equal(2, @jar.cookies(URI('http://rubyforge.org/login')).length)

# Make sure we can't get the cookie from different domains
      assert_equal(0, @jar.cookies(URI('http://google.com/')).length)
    end

def test_add_multiple_cookies_with_the_same_name
      now = Time.now

cookies = [
        { :value => 'a', :path => '/', },
        { :value => 'b', :path => '/abc/def/', :created_at => now - 1 },
        { :value => 'c', :path => '/abc/def/', :domain => 'www.rubyforge.org', :origin => 'http://www.rubyforge.org/abc/def/', :created_at => now },
        { :value => 'd', :path => '/abc/' },
      ].map { |attrs|
        HTTP::Cookie.new(cookie_values(attrs))
      }

url = URI 'http://www.rubyforge.org/abc/def/ghi'

cookies.permutation(cookies.size) { |shuffled|
        @jar.clear
        shuffled.each { |cookie| @jar.add(cookie) }
        assert_equal %w[b c d a], @jar.cookies(url).map { |cookie| cookie.value }
      }
    end

def test_fall_back_rules_for_local_domains
      url = URI 'http://www.example.local'

sld_cookie = HTTP::Cookie.new(cookie_values(:domain => '.example.local', :origin => url))
      @jar.add(sld_cookie)