http-cookie 1.0.0.pre6 → 1.0.0.pre7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 552b1f843786c58092655dff1e2587bafd65c995
-  data.tar.gz: ead56fc0cdda0ee554a8826eaab35e4b665c7e8a
+  metadata.gz: 36d302ade786727a1d6a34617d6f5fd5a0849ad5
+  data.tar.gz: 9f0f607f3f78427ec0f1737ce770e58aeb831110
 SHA512:
-  metadata.gz: ab0a84bce856ce0bde5b0200fe311c06875b9507a88c8829ff4e2a43db33a482ffc04ffbfb102caf30ca2af1528b2d1d42e6728ec2a4604aac7dc4107786da2d
-  data.tar.gz: 4747df38af92f497d315840aa706742d5ac8b3514247f3b85955b7d9f8df696689349c4d7cf8bdbd4f81de1b16e4bf16f671c13df0860b3513c56b7a94268b61
+  metadata.gz: 2288ba0ccc9dda414610bb4b87765492c480c1aa886c2b7b716c3d57a4373baa2de020cffb4cb93cfbb00f5dd7283a814c98573a3bbcc752f6f213a0dd8f290c
+  data.tar.gz: b08eb434043d9601cf743ba30a4c279356da12b4da8c243d37f9f8974ebbfe8d8b55fbeb28d2020e9f346aebcd545f5abedd8b8bb9ecb0eb76dc890576491688

data/lib/http/cookie.rb

@@ -170,7 +170,7 @@ class HTTP::Cookie
       raise ArgumentError, "wrong number of arguments (#{args.size} for 1-3)"
     end
     for_domain = false
-    max_age = origin = nil
+    domain = max_age = origin = nil
     attr_hash.each_pair { |key, val|
       skey = key.to_s.downcase
       if skey.sub!(/\?\z/, '')
@@ -179,6 +179,8 @@ class HTTP::Cookie
       case skey
       when 'for_domain'
         for_domain = !!val
+      when 'domain'
+        domain = val
       when 'origin'
         origin = val
       when 'max_age'
@@ -193,6 +195,7 @@ class HTTP::Cookie
       raise ArgumentError, "at least name and value must be specified"
     end
     @for_domain = for_domain
+    self.domain = domain if domain
     self.origin = origin if origin
     self.max_age = max_age if max_age
   end
@@ -283,8 +286,8 @@ class HTTP::Cookie
             begin
               case aname
               when 'domain'
-                cookie.domain = avalue
                 cookie.for_domain = true
+                cookie.domain = avalue # This may negate @for_domain
               when 'path'
                 cookie.path = avalue
               when 'expires'
@@ -376,6 +379,10 @@ class HTTP::Cookie
       end
       @domain_name = DomainName.new(domain)
     end
+    # RFC 6265 5.3 5.
+    if @domain_name.domain.nil? # a public suffix or IP address
+      @for_domain = false
+    end
     @domain = @domain_name.hostname
   end
 
@@ -388,7 +395,7 @@ class HTTP::Cookie
   # Returns the domain attribute value as a DomainName object.
   attr_reader :domain_name
 
-  # The domain flag.
+  # The domain flag. (the opposite of host-only-flag)
   #
   # If this flag is true, this cookie will be sent to any host in the
   # \#domain, including the host domain itself.  If it is false, this
@@ -419,20 +426,20 @@ class HTTP::Cookie
     @origin = origin
   end
 
-  # The secure flag.
+  # The secure flag. (secure-only-flag)
   #
   # A cookie with this flag on should only be sent via a secure
   # protocol like HTTPS.
   attr_accessor :secure
   alias secure? secure
 
-  # The HttpOnly flag.
+  # The HttpOnly flag. (http-only-flag)
   #
   # A cookie with this flag on should be hidden from a client script.
   attr_accessor :httponly
   alias httponly? httponly
 
-  # The session flag.
+  # The session flag. (the opposite of persistent-flag)
   #
   # A cookie with this flag on should be hidden from a client script.
   attr_reader :session
@@ -514,16 +521,12 @@ class HTTP::Cookie
     host = DomainName.new(uri.host)
 
     # RFC 6265 5.3
-    # When the user agent "receives a cookie":
-    return @domain.nil? || host.hostname == @domain unless @for_domain
+    return true if host.hostname == @domain
 
-    if host.cookie_domain?(@domain_name)
-      true
-    elsif host.hostname == @domain
-      @for_domain = false
-      true
+    if @for_domain  # !host-only-flag
+      host.cookie_domain?(@domain_name)
     else
-      false
+      @domain.nil?
     end
   end
 
@@ -534,6 +537,7 @@ class HTTP::Cookie
       raise "cannot tell if this cookie is valid because the domain is unknown"
     end
     uri = URI(uri)
+    # RFC 6265 5.4
     return false if secure? && !(URI::HTTPS === uri)
     acceptable_from_uri?(uri) && HTTP::Cookie.path_match?(@path, uri.path)
   end
@@ -556,7 +560,7 @@ class HTTP::Cookie
       raise "origin must be specified to produce a value for Set-Cookie"
 
     string = "#{@name}=#{Scanner.quote(@value)}"
-    if @for_domain || @domain != DomainName.new(origin.host).hostname
+    if @for_domain
       string << "; Domain=#{@domain}"
     end
     if (origin + './').path != @path

data/lib/http/cookie/version.rb

@@ -1,5 +1,5 @@
 module HTTP
   class Cookie
-    VERSION = "1.0.0.pre6"
+    VERSION = "1.0.0.pre7"
   end
 end

data/lib/http/cookie_jar/abstract_store.rb

@@ -1,4 +1,8 @@
+require 'monitor'
+
 class HTTP::CookieJar::AbstractStore
+  include MonitorMixin
+
   class << self
     @@class_map = {}
 
@@ -31,6 +35,7 @@ class HTTP::CookieJar::AbstractStore
   private :default_options
 
   def initialize(options = nil)
+    super() # MonitorMixin
     options ||= {}
     @logger = options[:logger]
     # Initializes each instance variable of the same name as option
@@ -50,6 +55,11 @@ class HTTP::CookieJar::AbstractStore
     self
   end
 
+  def delete(cookie)
+    raise
+    self
+  end
+
   # Iterates over all cookies that are not expired.
   #
   # An optional argument +uri+ specifies a URI object indicating the
@@ -60,7 +70,13 @@ class HTTP::CookieJar::AbstractStore
   # If (and only if) the +uri+ option is given, last access time of
   # each cookie is updated to the current time.
   def each(uri = nil, &block)
-    raise
+    if uri
+      raise
+    else
+      synchronize {
+        raise
+      }
+    end
     self
   end
   include Enumerable
@@ -80,7 +96,7 @@ class HTTP::CookieJar::AbstractStore
     else
       select(&:expired?)
     end.each { |cookie|
-      add(cookie.expire)
+      delete(cookie)
     }
     # subclasses can optionally remove over-the-limit cookies.
     self

data/lib/http/cookie_jar/hash_store.rb

@@ -10,6 +10,15 @@ end
 
 class HTTP::CookieJar
   # A store class that uses a hash-based cookie store.
+  #
+  # In this store, cookies that share the same name, domain and path
+  # will overwrite each other regardless of the `for_domain` flag
+  # value.  This store is built after the storage model described in
+  # RFC 6265 5.3 where there is no mention of how the host-only-flag
+  # affects in storing cookies.  On the other hand, in MozillaStore
+  # two cookies with the same name, domain and path coexist as long as
+  # they differ in the `for_domain` flag value, which means they need
+  # to be expired individually.
   class HashStore < AbstractStore
     def default_options
       {
@@ -57,7 +66,6 @@ class HTTP::CookieJar
       path_cookies.delete(cookie.name)
       self
     end
-    private :delete
 
     def each(uri = nil)
       now = Time.now
@@ -82,15 +90,17 @@ class HTTP::CookieJar
           }
         }
       else
-        @jar.each { |domain, paths|
-          paths.each { |path, hash|
-            hash.delete_if { |name, cookie|
-              if cookie.expired?(now)
-                true
-              else
-                yield cookie
-                false
-              end
+        synchronize {
+          @jar.each { |domain, paths|
+            paths.each { |path, hash|
+              hash.delete_if { |name, cookie|
+                if cookie.expired?(now)
+                  true
+                else
+                  yield cookie
+                  false
+                end
+              }
             }
           }
         }
@@ -110,45 +120,51 @@ class HTTP::CookieJar
     def cleanup(session = false)
       now = Time.now
       all_cookies = []
-      @jar.each { |domain, paths|
-        domain_cookies = []
-
-        paths.each { |path, hash|
-          hash.delete_if { |name, cookie|
-            if cookie.expired?(now) || (session && cookie.session?)
-              true
-            else
-              domain_cookies << cookie
-              false
-            end
+
+      synchronize {
+        break if @gc_index == 0
+
+        @jar.each { |domain, paths|
+          domain_cookies = []
+
+          paths.each { |path, hash|
+            hash.delete_if { |name, cookie|
+              if cookie.expired?(now) || (session && cookie.session?)
+                true
+              else
+                domain_cookies << cookie
+                false
+              end
+            }
           }
+
+          if (debt = domain_cookies.size - HTTP::Cookie::MAX_COOKIES_PER_DOMAIN) > 0
+            domain_cookies.sort_by!(&:created_at)
+            domain_cookies.slice!(0, debt).each { |cookie|
+              delete(cookie)
+            }
+          end
+
+          all_cookies.concat(domain_cookies)
         }
 
-        if (debt = domain_cookies.size - HTTP::Cookie::MAX_COOKIES_PER_DOMAIN) > 0
-          domain_cookies.sort_by!(&:created_at)
-          domain_cookies.slice!(0, debt).each { |cookie|
+        if (debt = all_cookies.size - HTTP::Cookie::MAX_COOKIES_TOTAL) > 0
+          all_cookies.sort_by!(&:created_at)
+          all_cookies.slice!(0, debt).each { |cookie|
             delete(cookie)
           }
         end
 
-        all_cookies.concat(domain_cookies)
-      }
-
-      if (debt = all_cookies.size - HTTP::Cookie::MAX_COOKIES_TOTAL) > 0
-        all_cookies.sort_by!(&:created_at)
-        all_cookies.slice!(0, debt).each { |cookie|
-          delete(cookie)
+        @jar.delete_if { |domain, paths|
+          paths.delete_if { |path, hash|
+            hash.empty?
+          }
+          paths.empty?
         }
-      end
 
-      @jar.delete_if { |domain, paths|
-        paths.delete_if { |path, hash|
-          hash.empty?
-        }
-        paths.empty?
+        @gc_index = 0
       }
-
-      @gc_index = 0
+      self
     end
   end
 end

data/lib/http/cookie_jar/mozilla_store.rb

@@ -5,6 +5,9 @@ require 'sqlite3'
 class HTTP::CookieJar
   # A store class that uses Mozilla compatible SQLite3 database as
   # backing store.
+  #
+  # Session cookies are stored separately on memory and will not be
+  # stored persistently in the SQLite3 database.
   class MozillaStore < AbstractStore
     SCHEMA_VERSION = 5
 
@@ -55,6 +58,7 @@ class HTTP::CookieJar
 
       @filename = options[:filename] or raise ArgumentError, ':filename option is missing'
 
+      @sjar = HashStore.new
       @db = SQLite3::Database.new(@filename)
       @db.results_as_hash = true
 
@@ -137,7 +141,8 @@ class HTTP::CookieJar
           st_update = @db.prepare("UPDATE moz_cookies SET baseDomain = :baseDomain WHERE id = :id")
 
           @db.execute("SELECT id, host FROM moz_cookies") { |row|
-            domain = DomainName.new(row[:host]).domain
+            domain_name = DomainName.new(row[:host])
+            domain = domain_name.domain || domain_name.hostname
             st_update.execute(:baseDomain => domain, :id => row[:id])
           }
 
@@ -187,9 +192,7 @@ class HTTP::CookieJar
       end
     end
 
-    public
-
-    def add(cookie)
+    def db_add(cookie)
       @st_add ||=
         @db.prepare('INSERT OR REPLACE INTO moz_cookies (%s) VALUES (%s)' % [
           ALL_COLUMNS.join(', '),
@@ -197,7 +200,7 @@ class HTTP::CookieJar
         ])
 
       @st_add.execute({
-          :baseDomain => cookie.domain_name.domain,
+          :baseDomain => cookie.domain_name.domain || cookie.domain,
           :appId => @app_id,
           :inBrowserElement => @in_browser_element ? 1 : 0,
           :name => cookie.name, :value => cookie.value,
@@ -214,6 +217,44 @@ class HTTP::CookieJar
       self
     end
 
+    def db_delete(cookie)
+      @st_delete ||=
+        @db.prepare(<<-'SQL')
+                     DELETE FROM moz_cookies
+                       WHERE appId = :appId AND
+                             inBrowserElement = :inBrowserElement AND
+                             name = :name AND
+                             host = :host AND
+                             path = :path
+                    SQL
+
+      @st_delete.execute({
+          :appId => @app_id,
+          :inBrowserElement => @in_browser_element ? 1 : 0,
+          :name => cookie.name,
+          :host => cookie.dot_domain,
+          :path => cookie.path,
+        })
+      self
+    end
+
+    public
+
+    def add(cookie)
+      if cookie.session?
+        @sjar.add(cookie)
+        db_delete(cookie)
+      else
+        @sjar.delete(cookie)
+        db_add(cookie)
+      end
+    end
+
+    def delete(cookie)
+      @sjar.delete(cookie)
+      db_delete(cookie)
+    end
+
     def each(uri = nil)
       now = Time.now
       if uri
@@ -230,10 +271,10 @@ class HTTP::CookieJar
             @db.prepare("UPDATE moz_cookies SET lastAccessed = :lastAccessed where id = :id")
 
         thost = DomainName.new(uri.host)
-        tpath = HTTP::Cookie.normalize_path(uri.path)
+        tpath = uri.path
 
         @st_cookies_for_domain.execute({
-            :baseDomain => thost.domain_name.domain,
+            :baseDomain => thost.domain || thost.hostname,
             :appId => @app_id,
             :inBrowserElement => @in_browser_element ? 1 : 0,
             :expiry => now.to_i,
@@ -263,6 +304,7 @@ class HTTP::CookieJar
             yield cookie
           end
         }
+        @sjar.each(uri, &proc)
       else
         @st_all_cookies ||=
           @db.prepare(<<-'SQL')
@@ -291,12 +333,14 @@ class HTTP::CookieJar
 
           yield cookie
         }
+        @sjar.each(&proc)
       end
       self
     end
 
     def clear
       @db.execute("DELETE FROM moz_cookies")
+      @sjar.clear
       self
     end
 
@@ -309,13 +353,10 @@ class HTTP::CookieJar
     protected :count
 
     def empty?
-      count == 0
+      @sjar.empty? && count == 0
     end
 
     def cleanup(session = false)
-      now = Time.now
-      all_cookies = []
-
       @st_delete_expired ||=
         @db.prepare("DELETE FROM moz_cookies WHERE expiry < :expiry")
 
@@ -342,26 +383,31 @@ class HTTP::CookieJar
                      )
         SQL
 
-      @st_delete_expired.execute({ 'expiry' => now.to_i })
+      synchronize {
+        break if @gc_index == 0
 
-      @st_overusing_domains.execute({
-          'count' => HTTP::Cookie::MAX_COOKIES_PER_DOMAIN
-        }).each { |row|
-        domain, count = row['domain'], row['count']
+        @st_delete_expired.execute({ 'expiry' => Time.now.to_i })
 
-        @st_delete_per_domain_overuse.execute({
-            'domain' => domain,
-            'limit' => count - HTTP::Cookie::MAX_COOKIES_PER_DOMAIN,
-          })
-      }
+        @st_overusing_domains.execute({
+            'count' => HTTP::Cookie::MAX_COOKIES_PER_DOMAIN
+          }).each { |row|
+          domain, count = row['domain'], row['count']
 
-      overrun = count - HTTP::Cookie::MAX_COOKIES_TOTAL
+          @st_delete_per_domain_overuse.execute({
+              'domain' => domain,
+              'limit' => count - HTTP::Cookie::MAX_COOKIES_PER_DOMAIN,
+            })
+        }
 
-      if overrun > 0
-        @st_delete_total_overuse.execute({ 'limit' => overrun })
-      end
+        overrun = count - HTTP::Cookie::MAX_COOKIES_TOTAL
 
-      @gc_index = 0
+        if overrun > 0
+          @st_delete_total_overuse.execute({ 'limit' => overrun })
+        end
+
+        @gc_index = 0
+      }
+      self
     end
   end
 end

data/test/test_http_cookie.rb

@@ -177,6 +177,22 @@ class TestHTTPCookie < Test::Unit::TestCase
     assert_equal '.example.com', cookie.dot_domain
   end
 
+  def test_parse_public_suffix
+    cookie_str = 'a=b; domain=com'
+
+    cookie = HTTP::Cookie.parse(cookie_str).first
+    assert_equal('com', cookie.domain)
+    assert_equal(false, cookie.for_domain?)
+
+    cookie.origin = 'http://com/'
+    assert_equal('com', cookie.domain)
+    assert_equal(false, cookie.for_domain?)
+
+    assert_raises(ArgumentError) {
+      cookie.origin = 'http://example.com/'
+    }
+  end
+
   def test_parse_domain_none
     url = URI.parse('http://example.com/')
 
@@ -439,6 +455,19 @@ class TestHTTPCookie < Test::Unit::TestCase
     assert_equal 'key', cookie.name
     assert_equal 'value', cookie.value
     assert_equal expires, cookie.expires
+    assert_equal false, cookie.for_domain?
+
+    cookie = HTTP::Cookie.new(:value => 'value', :name => 'key', :expires => expires.dup, :domain => '.example.com')
+    assert_equal 'key', cookie.name
+    assert_equal 'value', cookie.value
+    assert_equal expires, cookie.expires
+    assert_equal true, cookie.for_domain?
+
+    cookie = HTTP::Cookie.new(:value => 'value', :name => 'key', :expires => expires.dup, :domain => 'example.com', :for_domain => false)
+    assert_equal 'key', cookie.name
+    assert_equal 'value', cookie.value
+    assert_equal expires, cookie.expires
+    assert_equal false, cookie.for_domain?
 
     cookie = HTTP::Cookie.new(:value => 'value', :name => 'key', :expires => expires.dup, :domain => 'example.org', :for_domain? => true)
     assert_equal 'key', cookie.name
@@ -664,6 +693,16 @@ class TestHTTPCookie < Test::Unit::TestCase
     }
   end
 
+  def test_acceptable_from_uri?
+    cookie = HTTP::Cookie.new(cookie_values(
+        :domain => 'uk',
+        :for_domain => true,
+        :origin => nil))
+    assert_equal false, cookie.for_domain?
+    assert_equal true, cookie.acceptable_from_uri?('http://uk/')
+    assert_equal false, cookie.acceptable_from_uri?('http://foo.uk/')
+  end
+
   def test_valid_for_uri?
     {
       HTTP::Cookie.parse('a1=b',

data/test/test_http_cookie_jar.rb

@@ -1,9 +1,28 @@
 require File.expand_path('helper', File.dirname(__FILE__))
 require 'tmpdir'
 
-class TestHTTPCookieJar < Test::Unit::TestCase
-  def setup
-    @jar = HTTP::CookieJar.new
+module TestHTTPCookieJar; end
+
+module TestHTTPCookieJar::Tests
+  def setup(options = nil, options2 = nil)
+    default_options = {
+      :store => :hash,
+      :gc_threshold => 150,
+    }
+    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_options)
+  end
+
+  def hash_store?
+    @store_type == :hash
+  end
+
+  def mozilla_store?
+    @store_type == :mozilla
   end
 
   def cookie_values(options = {})
@@ -307,9 +326,8 @@ class TestHTTPCookieJar < Test::Unit::TestCase
       value = @jar.save(File.join(dir, "cookies.yml"))
       assert_same @jar, value
 
-      jar = HTTP::CookieJar.new
-      jar.load(File.join(dir, "cookies.yml"))
-      cookies = jar.cookies(url).sort_by { |cookie| cookie.name }
+      @jar2.load(File.join(dir, "cookies.yml"))
+      cookies = @jar2.cookies(url).sort_by { |cookie| cookie.name }
       assert_equal(2, cookies.length)
       assert_equal('Baz', cookies[0].name)
       assert_equal(false, cookies[0].for_domain)
@@ -338,9 +356,8 @@ class TestHTTPCookieJar < Test::Unit::TestCase
     Dir.mktmpdir do |dir|
       @jar.save(File.join(dir, "cookies.yml"), :format => :yaml, :session => true)
 
-      jar = HTTP::CookieJar.new
-      jar.load(File.join(dir, "cookies.yml"))
-      assert_equal(3, jar.cookies(url).length)
+      @jar2.load(File.join(dir, "cookies.yml"))
+      assert_equal(3, @jar2.cookies(url).length)
     end
 
     assert_equal(3, @jar.cookies(url).length)
@@ -384,9 +401,8 @@ class TestHTTPCookieJar < Test::Unit::TestCase
       assert_match(/^rubyforge\.org\t.*\tBaz\t/, content)
       assert_match(/^#HttpOnly_\.rubyforge\.org\t/, content)
 
-      jar = HTTP::CookieJar.new
-      jar.load(filename, :cookiestxt) # HACK test the format
-      cookies = jar.cookies(url)
+      @jar2.load(filename, :cookiestxt) # HACK test the format
+      cookies = @jar2.cookies(url)
       assert_equal(4, cookies.length)
       cookies.each { |cookie|
         case cookie.name
@@ -541,12 +557,27 @@ class TestHTTPCookieJar < Test::Unit::TestCase
     assert_equal('Foo1 Foo2', @jar.cookies(surl).map { |c| c.name }.sort.join(' ') )
   end
 
-  def h_test_max_cookies(jar, slimit)
+  def _test_delete
+    nurl = URI 'http://rubyforge.org/login'
+    surl = URI 'https://rubyforge.org/login'
+
+    cookie1 = HTTP::Cookie.new(cookie_values(:name => 'Foo1', :origin => nurl))
+    cookie2 = HTTP::Cookie.new(cookie_values(:name => 'Foo1', :origin => surl))
+
+    @jar.add(nncookie)
+    @jar.add(sncookie)
+    @jar.add(nscookie)
+    @jar.add(sscookie)
+  end
+
+  def test_max_cookies
+    slimit = HTTP::Cookie::MAX_COOKIES_TOTAL + @gc_threshold
+
     limit_per_domain = HTTP::Cookie::MAX_COOKIES_PER_DOMAIN
     uri = URI('http://www.example.org/')
     date = Time.at(Time.now.to_i + 86400)
     (1..(limit_per_domain + 1)).each { |i|
-      jar << HTTP::Cookie.new(cookie_values(
+      @jar << HTTP::Cookie.new(cookie_values(
           :name => 'Foo%d' % i,
           :value => 'Bar%d' % i,
           :domain => uri.host,
@@ -557,11 +588,11 @@ class TestHTTPCookieJar < Test::Unit::TestCase
         cookie.created_at = i == 42 ? date - i : date
       }
     }
-    assert_equal limit_per_domain + 1, jar.to_a.size
-    jar.cleanup
-    count = jar.to_a.size
+    assert_equal limit_per_domain + 1, @jar.to_a.size
+    @jar.cleanup
+    count = @jar.to_a.size
     assert_equal limit_per_domain, count
-    assert_equal [*1..41] + [*43..(limit_per_domain + 1)], jar.map { |cookie|
+    assert_equal [*1..41] + [*43..(limit_per_domain + 1)], @jar.map { |cookie|
       cookie.name[/(\d+)$/].to_i
     }.sort
 
@@ -572,7 +603,7 @@ class TestHTTPCookieJar < Test::Unit::TestCase
     (1..n).each { |i|
       (1..(limit_per_domain + 1)).each { |j|
         uri = URI('http://www%d.example.jp/' % i)
-        jar << HTTP::Cookie.new(cookie_values(
+        @jar << HTTP::Cookie.new(cookie_values(
             :name => 'Baz%d' % j,
             :value => 'www%d.example.jp' % j,
             :domain => uri.host,
@@ -587,40 +618,33 @@ class TestHTTPCookieJar < Test::Unit::TestCase
     }
 
     assert_equal true, count > slimit
-    assert_equal true, jar.to_a.size <= slimit
-    jar.cleanup
-    assert_equal hlimit, jar.to_a.size
-    assert_equal false, jar.any? { |cookie|
+    assert_equal true, @jar.to_a.size <= slimit
+    @jar.cleanup
+    assert_equal hlimit, @jar.to_a.size
+    assert_equal false, @jar.any? { |cookie|
       cookie.domain == cookie.value
     }
   end
+end
+
+module TestHTTPCookieJar
+  class WithHashStore < Test::Unit::TestCase
+    include Tests
+  end
 
-  def test_max_cookies_hashstore
-    gc_threshold = 150
-    h_test_max_cookies(
-      HTTP::CookieJar.new(
-        :store => :hash,
-        :gc_threshold => gc_threshold),
-      HTTP::Cookie::MAX_COOKIES_TOTAL + gc_threshold)
-  end
-
-  def test_max_cookies_mozillastore
-    gc_threshold = 150
-    h_test_max_cookies(
-      HTTP::CookieJar.new(
-        :store => :mozilla,
-        :gc_threshold => gc_threshold,
-        :filename => ":memory:"),
-      HTTP::Cookie::MAX_COOKIES_TOTAL + gc_threshold)
-    #Dir.mktmpdir { |dir|
-    #  h_test_max_cookies(
-    #    HTTP::CookieJar.new(
-    #      :store => :mozilla,
-    #      :gc_threshold => gc_threshold,
-    #      :filename => File.join(dir, "cookies.sqlite")),
-    #    HTTP::Cookie::MAX_COOKIES_TOTAL + gc_threshold)
-    #}
-  rescue IndexError
+  class WithMozillaStore < Test::Unit::TestCase
+    include Tests
+
+    def setup
+      super(
+        { :store => :mozilla, :filename => ":memory:" },
+        { :store => :mozilla, :filename => ":memory:" })
+    end
+  end if begin
+    require 'sqlite3'
+    true
+  rescue LoadError
     STDERR.puts 'sqlite3 missing?'
+    false
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: http-cookie
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre6
+  version: 1.0.0.pre7
 platform: ruby
 authors:
 - Akinori MUSHA
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-27 00:00:00.000000000 Z
+date: 2013-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: domain_name