dwaite-cookiejar 0.1.0 → 0.1.1

data/lib/cookiejar/cookie.rb

@@ -1,64 +1,66 @@
 require 'time'
 require 'cookiejar/cookie_logic'
+
 module CookieJar
+  
+  # Defines the parsing logic and data model of a HTTP Cookie.
+  # Note that the data values within the cookie may be different from the
+  # values described in the literal cookie declaration.
+  # Specifically, the 'domain' and 'path' values may be set to defaults 
+  # based on the requested resource that resulted in the cookie being set.
   class Cookie
     include CookieLogic
-  
+    extend CookieLogic
+    
+    # The mandatory name and value of the cookie
     attr_reader :name, :value
-    attr_reader :created_at
-    attr_reader :expiry
+    # The domain and path of the cookie. These values will be set on all
+    # legal cookie objects, based on the requested URI if not set literally
     attr_reader :domain, :path
-    attr_reader :secure, :http_only
+    # The secure flag is set to indicate that the cookie should only be
+    # sent securely. Nearly all implementations assume this to mean over
+    # SSL/TLS
+    attr_reader :secure
+    # Popular browser extension to mark a cookie as invisible to code running
+    # within the browser, such as JavaScript
+    attr_reader :http_only
+    
+    #-- Attributes for RFC 2965 cookies
+    
+    # Version indicator - version is 0 for netscape cookies, 
+    # and 1 for RFC 2965 cookies
     attr_reader :version
-  # Currently unused attributes for RFC 2965 cookies
-  #  attr_reader :comment, :comment_url
-  #  attr_reader :discard
-  #  attr_reader :ports
+    # Comment (or location) describing cookie.
+    attr_reader :comment, :comment_url
+    # Discard
+    attr_reader :discard
+    attr_reader :ports
+    attr_reader :created_at
 
     def expires_at
-      if expiry.nil?
-        nil
-      elsif expiry.is_a? Time
-        expiry
+      if @expiry.nil? || @expiry.is_a?(Time)
+        @expiry
       else
-        Time.now + expiry
+        @created_at + @expiry
       end
     end
+    
     def max_age
-      if expiry.is_a? Integer
-        expiry
+      if @expiry.is_a? Time
+        @expiry - @created_at
       else
-        expiry - Time.now
-      end
-    end 
-    def port
-      nil
-    end   
-    def initialize(uri, *params)
-      case params.length
-      when 1
-        args = params[0]
-      when 2
-        args = {:name => args[0], :value => args[1]}
-      else
-        raise ArgumentError.new "wrong number of arguments (expected 1 or 2)"
+        @expiry
       end
+    end
     
-      @domain    = determine_cookie_domain(uri, args[:domain])
-      @expiry    = args[:max_age]   || args[:expires_at] || nil
-      @path      = determine_cookie_path(uri, args[:path])
-      @secure    = args[:secure]    || false
-      @http_only = args[:http_only] ||false
-      @name      = args[:name]
-      @value     = args[:value]
-      @version   = args[:version]
-      @created_at = DateTime.now
+    def expired?
+      expires_at != nil && (Time.now > expires_at)
     end
-  
-    PARAM1 = /\A(#{PATTERN::TOKEN})(?:=#{PATTERN::VALUE1})?\Z/
-    # PARAM2 = /\A(#{PATTERN::TOKEN})(?:=#{PATTERN::VALUE2})?\Z/
 
+    # Create a cookie based on an absolute URI and the string value of a
+    # 'Set-Cookie' header.
     def self.from_set_cookie(request_uri, set_cookie_value)
+      include CookieLogic
       args = {}
       params=set_cookie_value.split(/;\s*/)
       params.each do |param|
@@ -66,14 +68,14 @@ module CookieJar
         if (!result) 
           raise InvalidCookieError.new("Invalid cookie parameter in cookie '#{set_cookie_value}'")
         end
-        key = result[1].upcase
-        keyvalue = result[2] || result[3]
+        key = result[1].downcase.to_sym
+        keyvalue = result[2]
         case key
-        when 'EXPIRES'
-          args[:expires_at] = DateTime.parse(keyvalue)
-        when 'DOMAIN'
-          args[:domain] = keyvalue.downcase
-        when 'PATH'
+        when :expires
+          args[:expires_at] = Time.parse(keyvalue)
+        when :domain
+          args[:domain] = keyvalue
+        when :path
           args[:path] = keyvalue
         when 'SECURE'
           args[:secure] = true
@@ -84,12 +86,124 @@ module CookieJar
           args[:value] = keyvalue
         end
       end
+      args[:domain] = determine_cookie_domain request_uri, args[:domain]
+      args[:path] = determine_cookie_path request_uri, args[:path]
       args[:version] = 0
-      Cookie.new(request_uri, args)
+      cookie = Cookie.new args
+      validate_cookie request_uri, cookie
+      cookie
     end
-  
+
     def to_s
-      %Q^#{name}=#{value}#{if(domain) then "; domain=#{domain}" end}#{if (expiry) then "; expiry=#{expiry}" end}#{if (path) then "; path=#{path}" end}#{if (secure) then "; secure" end }#{if (http_only) then "; HTTPOnly" end}^
-    end  
+      %^"#{name}=#{value}#{if(domain) then "; domain=#{domain}" end}#{if (expiry) then "; expiry=#{expiry}" end}#{if (path) then "; path=#{path}" end}#{if (secure) then "; secure" end }#{if (http_only) then "; HTTPOnly" end}^
+    end
+
+    # Check whether a cookie meets all of the rules to be created, based on 
+    # its internal settings and the URI it came from.
+    #
+    # returns true on success, but will raise an InvalidCookieError on failure
+    # with an appropriate error message
+    def self.validate_cookie request_uri, cookie
+      uri = request_uri.is_a?(URI) ? request_uri : URI.parse(request_uri)
+    
+      request_host = effective_host uri.host
+      request_path = uri.path
+      request_secure = (uri.scheme == 'https')
+      cookie_host = cookie.domain
+      cookie_path = cookie.path
+      
+      errors = []
+    
+      # From RFC 2965, Section 3.3.2 Rejecting Cookies
+    
+      # A user agent rejects (SHALL NOT store its information) if the 
+      # Version attribute is missing. Note that the legacy Set-Cookie
+      # directive will result in an implicit version 0.
+      unless cookie.version
+        errors << "Version missing"
+      end
+
+      # The value for the Path attribute is not a prefix of the request-URI
+      unless request_path.start_with? cookie_path 
+        errors << "Path is not a prefix of the request uri path"
+      end
+
+      unless cookie_host =~ IPADDR || #is an IPv4 or IPv6 address
+        cookie_host =~ /.\../ || #contains an embedded dot
+        cookie_host == '.local' #is the domain cookie for local addresses
+        errors << "Domain format is illegal"
+      end
+    
+      # The effective host name that derives from the request-host does
+      # not domain-match the Domain attribute.
+      #
+      # The request-host is a HDN (not IP address) and has the form HD,
+      # where D is the value of the Domain attribute, and H is a string
+      # that contains one or more dots.
+      effective_host = effective_host uri
+      unless domains_match effective_host, cookie_host
+        errors << "Domain is inappropriate based on request URI hostname"
+      end
+    
+      # The Port attribute has a "port-list", and the request-port was
+      # not in the list.
+      unless cookie.ports.nil? || cookie.ports.length != 0
+        unless cookie.ports.find_index uri.port
+          errors << "Ports list does not contain request URI port"
+        end
+      end
+
+      raise InvalidCookieError.new(errors) unless errors.empty?
+
+      # Note: 'secure' is not explicitly defined as an SSL channel, and no
+      # test is defined around validity and the 'secure' attribute
+      true
+    end
+    # Return true if (given a URI, a cookie object and other options) a cookie
+    # should be sent to a host. Note that this currently ignores domain.
+    #
+    # The third option, 'script', indicates that cookies with the 'http only'
+    # extension should be ignored
+    def should_send? uri, script
+      # cookie path must start with the uri, it must not be a secure cookie being sent over http,
+      # and it must not be a http_only cookie sent to a script
+      path_match   = uri.path.start_with? @path
+      secure_match = !(@secure && uri.scheme == 'http') 
+      script_match = !(script && @http_only)
+      expiry_match = !expired?
+      path_match && secure_match && script_match && expiry_match
+    end
+  protected
+    PARAM1 = /\A(#{PATTERN::TOKEN})(?:=#{PATTERN::VALUE1})?\Z/
+    # PARAM2 = /\A(#{PATTERN::TOKEN})(?:=#{PATTERN::VALUE2})?\Z/
+
+    def initialize(*params)
+      case params.length
+      when 1
+        args = params[0]
+      when 2
+        args = {:name => params[0], :value => params[1], :version => 0}
+      else
+        raise ArgumentError.new "wrong number of arguments (expected 1 or 2)"
+      end
+
+      @created_at = Time.now    
+      @domain       = args[:domain]
+      @expiry       = args[:max_age]   || args[:expires_at] || nil
+      @path         = args[:path]
+      @secure       = args[:secure]    || false
+      @http_only    = args[:http_only] || false
+      @name         = args[:name]
+      @value        = args[:value]
+      @version      = args[:version]
+      @comment      = args[:comment]
+      @comment_url  = args[:comment_url]
+      @discard      = args[:discard]
+      @ports        = args[:ports]
+      
+      if @ports.is_a? Integer
+        @ports = [@ports]
+      end      
+    end
   end
-end
+end

data/lib/cookiejar/cookie_common.rb

@@ -1,4 +1,14 @@
 module CookieJar
   class CookieError < StandardError; end
-  class InvalidCookieError < CookieError; end
+  # Represents all cookie validation errors
+  class InvalidCookieError < CookieError; 
+    attr_reader :messages
+    def initialize message
+     if message.is_a? Array
+       @messages = message
+       message = message.join ', '
+     end
+     super(message)
+    end
+  end
 end

data/lib/cookiejar/cookie_logic.rb

@@ -108,64 +108,6 @@ module CookieJar
       rhs = effective_host base_domain
       lhs == rhs || ".#{lhs}" == rhs || hostname_reach(lhs) == rhs || ".#{hostname_reach lhs}" == rhs
     end
-
-    # Check whether a cookie meets all of the rules to be created, based on 
-    # its internal settings and the URI it came from.
-    #
-    # returns true on success, but will raise an InvalidCookieError on failure
-    # with an appropriate error message
-    def validate_cookie request_uri, cookie
-      uri = request_uri.is_a?(URI) ? request_uri : URI.parse(request_uri)
-    
-      request_host = effective_host uri.host
-      request_path = uri.path
-      request_secure = (uri.scheme == 'https')
-      cookie_host = cookie.domain
-      cookie_path = cookie.path
-    
-      # From RFC 2965, Section 3.3.2 Rejecting Cookies
-    
-      # A user agent rejects (SHALL NOT store its information) if the 
-      # Version attribute is missing. Note that the legacy Set-Cookie
-      # directive will result in an implicit version 0.
-      unless cookie.version
-        raise InvalidCookieError, "Cookie version not supplied (or implicit with Set-Cookie)"
-      end
-
-      # The value for the Path attribute is not a prefix of the request-URI
-      unless request_path.start_with? cookie_path 
-        raise InvalidCookieError, "Cookie path should match or be a subset of the request path"
-      end
-
-      # The value for the Domain attribute contains no embedded dots, and the value is not .local
-      # Note: we also allow IPv4 and IPv6 addresses
-      unless cookie_host =~ IPADDR || cookie_host =~ /.\../ || cookie_host == '.local'
-        raise InvalidCookieError, "Cookie domain format is not legal"
-      end
-    
-      # The effective host name that derives from the request-host does
-      # not domain-match the Domain attribute.
-      #
-      # The request-host is a HDN (not IP address) and has the form HD,
-      # where D is the value of the Domain attribute, and H is a string
-      # that contains one or more dots.
-      effective_host = effective_host uri
-      unless domains_match effective_host, cookie_host
-        raise InvalidCookieError, "Cookie domain is inappropriate based on request hostname"
-      end
-    
-      # The Port attribute has a "port-list", and the request-port was
-      # not in the list.
-      if cookie.port.to_a.length != 0
-        unless cookie.port.to_a.find_index uri.port
-          raise InvalidCookieError, "incoming request port does not match cookie port(s)"
-        end
-      end
-    
-      # Note: 'secure' is not explicitly defined as an SSL channel, and no
-      # test is defined around validity and the 'secure' attribute
-      true
-    end
   
     # Given a URI, compute the relevant search domains for pre-existing
     # cookies. This includes all the valid dotted forms for a named or IP
@@ -183,20 +125,5 @@ module CookieJar
       end
       result
     end
-    
-    # Return true if (given a URI, a cookie object and other options) a cookie
-    # should be sent to a host. Note that this currently ignores domain.
-    #
-    # The third option, 'script', indicates that cookies with the 'http only'
-    # extension should be ignored
-    def send_cookie? uri, cookie, script
-      # cookie path must start with the uri, it must not be a secure cookie being sent over http,
-      # and it must not be a http_only cookie sent to a script
-      path_match   = uri.path.start_with? cookie.path
-      secure_match = !(cookie.secure && uri.scheme == 'http') 
-      script_match = !(script && cookie.http_only)
-      expiry_match = cookie.expires_at.nil? || cookie.expires_at > Time.now
-      path_match && secure_match && script_match && expiry_match
-    end
   end
 end

data/lib/cookiejar/jar.rb

@@ -56,11 +56,9 @@ module CookieJar
     	uri = request_uri.is_a?(URI) ? request_uri : URI.parse(request_uri)
     	host = effective_host uri
     	cookie = Cookie.from_set_cookie(uri, cookie_header_value)
-    	if (validate_cookie uri, cookie)
-    	  domain_paths = find_or_add_domain_for_cookie(cookie.domain)
-    	  add_cookie_to_path(domain_paths,cookie)
-    	  cookie
-    	end
+  	  domain_paths = find_or_add_domain_for_cookie(cookie.domain)
+  	  add_cookie_to_path(domain_paths,cookie)
+  	  cookie
     end
     
     # Given a request URI, return a sorted list of Cookie objects. Cookies
@@ -79,7 +77,7 @@ module CookieJar
     	  domain.each do |path, cookies|
     		  if uri.path.start_with? path
       		  results += cookies.select do |name, cookie|
-        			send_cookie? uri, cookie, args[:script]
+        			cookie.should_send? uri, args[:script]
         		end.collect do |name, cookie|
         			cookie
         		end            

data/test/cookie_logic_test.rb

@@ -136,85 +136,6 @@ describe CookieLogic do
       domains_match('foo.com.', 'foo.com').should be_false
     end
   end
-  describe '.validate_cookie' do
-    localaddr = 'http://localhost/foo/bar/'
-    it "should fail if version unset" do
-      unversioned = Cookie.new localaddr, :name => 'foo', :value => 'bar', :version => nil
-      lambda do
-        validate_cookie localaddr, unversioned
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail if the path is more specific" do
-      subdirred = Cookie.new localaddr, :name => 'foo', :value => 'bar', :version => 0, :path => '/foo/bar/baz'
-      lambda do
-        validate_cookie localaddr, subdirred
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail if the path is different than the request" do
-      difdirred = Cookie.new localaddr, :name => 'foo', :value => 'bar', :version => 0, :path => '/baz/'
-      lambda do
-        validate_cookie localaddr, difdirred
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail if the domain has no dots" do
-      nodot = Cookie.new 'http://zero/', :name => 'foo', :value => 'bar', :version => 0, :domain => 'zero'
-      lambda do
-        validate_cookie 'http://zero/', nodot
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail for explicit localhost" do
-      localhost = Cookie.new localaddr, :name => 'foo', :value => 'bar', :version => 0, :domain => 'localhost'
-      lambda do
-        validate_cookie localaddr, localhost
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail for mismatched domains" do
-      foobar = Cookie.new 'http://www.foo.com/', :name => 'foo', :value => 'bar', :version => 0, :domain => 'bar.com'
-      lambda do
-        validate_cookie 'http://www.foo.com/', foobar
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail for domains more than one level up" do
-      xyz = Cookie.new 'http://x.y.z.com/', :name => 'foo', :value => 'bar', :version => 0, :domain => 'z.com'
-      lambda do
-        validate_cookie 'http://x.y.z.com/', xyz
-      end.should raise_error InvalidCookieError
-    end
-    it "should fail for setting subdomain cookies" do
-      subdomain = Cookie.new 'http://foo.com/', :name => 'foo', :value => 'bar', :version => 0, :domain => 'auth.foo.com'
-      lambda do
-        validate_cookie 'http://foo.com/', subdomain
-      end.should raise_error InvalidCookieError
-    end
-    it "should handle a normal implicit internet cookie" do
-      normal = Cookie.new 'http://foo.com/', :name => 'foo', :value => 'bar', :version => 0
-      validate_cookie('http://foo.com/', normal).should be_true
-    end
-    it "should handle a normal implicit localhost cookie" do
-      localhost = Cookie.new 'http://localhost/', :name => 'foo', :value => 'bar', :version => 0
-      validate_cookie('http://localhost/', localhost).should be_true
-    end
-    it "should handle an implicit IP address cookie" do
-      ipaddr =  Cookie.new 'http://127.0.0.1/', :name => 'foo', :value => 'bar', :version => 0
-      validate_cookie('http://127.0.0.1/', ipaddr).should be_true
-    end
-    it "should handle an explicit domain on an internet site" do
-      explicit = Cookie.new 'http://foo.com/', :name => 'foo', :value => 'bar', :version => 0, :domain => '.foo.com'
-      validate_cookie('http://foo.com/', explicit).should be_true
-    end
-    it "should handle setting a cookie explicitly on a superdomain" do
-      superdomain = Cookie.new 'http://auth.foo.com/', :name => 'foo', :value => 'bar', :version => 0, :domain => '.foo.com'
-      validate_cookie('http://foo.com/', superdomain).should be_true
-    end
-    it "should handle explicitly setting a cookie" do
-      explicit = Cookie.new 'http://foo.com/bar/', :name => 'foo', :value => 'bar', :version => 0, :path => '/bar/'
-      validate_cookie('http://foo.com/bar/', explicit)
-    end
-    it "should handle setting a cookie on a higher path" do
-      higher = Cookie.new 'http://foo.com/bar/baz/', :name => 'foo', :value => 'bar', :version => 0, :path => '/bar/'
-      validate_cookie('http://foo.com/bar/baz/', higher)
-    end
-  end
   describe '.compute_search_domains' do
     it "should handle subdomains" do
       compute_search_domains('http://www.auth.foo.com/').should ==

data/test/cookie_test.rb

@@ -1,18 +1,29 @@
 require 'cookiejar'
+require 'cookiejar/cookie_logic'
+
 include CookieJar
+include CookieLogic
 
+FOO_URL = 'http://localhost/foo'
+AMMO_URL = 'http://localhost/ammo'
 NETSCAPE_SPEC_SET_COOKIE_HEADERS =
-['CUSTOMER=WILE_E_COYOTE; path=/; expires=Wednesday, 09-Nov-99 23:12:40 GMT',
- 'PART_NUMBER=ROCKET_LAUNCHER_0001; path=/',
- 'SHIPPING=FEDEX; path=/foo',
- 'PART_NUMBER=ROCKET_LAUNCHER_0001; path=/',
- 'PART_NUMBER=RIDING_ROCKET_0023; path=/ammo']
+[['CUSTOMER=WILE_E_COYOTE; path=/; expires=Wednesday, 09-Nov-99 23:12:40 GMT',
+    FOO_URL],
+  ['PART_NUMBER=ROCKET_LAUNCHER_0001; path=/',
+    FOO_URL],
+  ['SHIPPING=FEDEX; path=/foo',
+    FOO_URL],
+  ['PART_NUMBER=ROCKET_LAUNCHER_0001; path=/',
+    FOO_URL],
+  ['PART_NUMBER=RIDING_ROCKET_0023; path=/ammo',
+    AMMO_URL]]
  
 describe Cookie do
   describe "#from_set_cookie" do
     it "should handle cookies from the netscape spec" do
-      NETSCAPE_SPEC_SET_COOKIE_HEADERS.each do |header|
-        cookie = Cookie.from_set_cookie 'http://localhost', header
+      NETSCAPE_SPEC_SET_COOKIE_HEADERS.each do |value|
+        header, url = *value
+        cookie = Cookie.from_set_cookie url, header
       end
     end
     it "should give back the input names and values" do
@@ -21,4 +32,84 @@ describe Cookie do
       cookie.value.should == 'bar'
     end
   end
+  describe '.validate_cookie' do
+    localaddr = 'http://localhost/foo/bar/'
+    it "should fail if version unset" do
+      lambda do
+        unversioned = Cookie.from_set_cookie localaddr, 'foo=bar'
+        unversioned.instance_variable_set :@version, nil
+        Cookie.validate_cookie localaddr, unversioned
+      end.should raise_error InvalidCookieError
+    end
+    it "should fail if the path is more specific" do
+      lambda do
+        subdirred = Cookie.from_set_cookie localaddr, 'foo=bar;path=/foo/bar/baz'
+        # validate_cookie localaddr, subdirred
+      end.should raise_error InvalidCookieError
+    end
+    it "should fail if the path is different than the request" do
+      lambda do
+        difdirred = Cookie.from_set_cookie localaddr, 'foo=bar;path=/baz/'
+        # validate_cookie localaddr, difdirred
+      end.should raise_error InvalidCookieError
+    end
+    it "should fail if the domain has no dots" do
+      lambda do
+        nodot = Cookie.from_set_cookie 'http://zero/', 'foo=bar;domain=zero'
+        # validate_cookie 'http://zero/', nodot
+      end.should raise_error InvalidCookieError
+    end
+    it "should fail for explicit localhost" do
+      lambda do
+        localhost = Cookie.from_set_cookie localaddr, 'foo=bar;domain=localhost'
+        # validate_cookie localaddr, localhost
+      end.should raise_error InvalidCookieError
+    end
+    it "should fail for mismatched domains" do
+      lambda do
+        foobar = Cookie.from_set_cookie 'http://www.foo.com/', 'foo=bar;domain=bar.com'
+        # validate_cookie 'http://www.foo.com/', foobar
+      end.should raise_error InvalidCookieError
+    end
+    it "should fail for domains more than one level up" do
+      lambda do
+        xyz = Cookie.from_set_cookie 'http://x.y.z.com/', 'foo=bar;domain=z.com'
+        # validate_cookie 'http://x.y.z.com/', xyz
+      end.should raise_error InvalidCookieError
+    end
+    it "should fail for setting subdomain cookies" do
+      lambda do
+        subdomain = Cookie.from_set_cookie 'http://foo.com/', 'foo=bar;domain=auth.foo.com'
+        # validate_cookie 'http://foo.com/', subdomain
+      end.should raise_error InvalidCookieError
+    end
+    it "should handle a normal implicit internet cookie" do
+      normal = Cookie.from_set_cookie 'http://foo.com/', 'foo=bar'
+      Cookie.validate_cookie('http://foo.com/', normal).should be_true
+    end
+    it "should handle a normal implicit localhost cookie" do
+      localhost = Cookie.from_set_cookie 'http://localhost/', 'foo=bar'
+      Cookie.validate_cookie('http://localhost/', localhost).should be_true
+    end
+    it "should handle an implicit IP address cookie" do
+      ipaddr =  Cookie.from_set_cookie 'http://127.0.0.1/', 'foo=bar'
+      Cookie.validate_cookie('http://127.0.0.1/', ipaddr).should be_true
+    end
+    it "should handle an explicit domain on an internet site" do
+      explicit = Cookie.from_set_cookie 'http://foo.com/', 'foo=bar;domain=.foo.com'
+      Cookie.validate_cookie('http://foo.com/', explicit).should be_true
+    end
+    it "should handle setting a cookie explicitly on a superdomain" do
+      superdomain = Cookie.from_set_cookie 'http://auth.foo.com/', 'foo=bar;domain=.foo.com'
+      Cookie.validate_cookie('http://foo.com/', superdomain).should be_true
+    end
+    it "should handle explicitly setting a cookie" do
+      explicit = Cookie.from_set_cookie 'http://foo.com/bar/', 'foo=bar;path=/bar/'
+      Cookie.validate_cookie('http://foo.com/bar/', explicit)
+    end
+    it "should handle setting a cookie on a higher path" do
+      higher = Cookie.from_set_cookie 'http://foo.com/bar/baz/', 'foo=bar;path=/bar/'
+      Cookie.validate_cookie('http://foo.com/bar/baz/', higher)
+    end
+  end
 end

data/test/jar_test.rb

@@ -39,6 +39,13 @@ describe Jar do
       cookies[2].name.should == 'c'
       cookies[3].name.should == 'd'
     end
+    it "should not return expired cookies" do
+      jar = Jar.new
+      uri = 'http://localhost/'
+      jar.set_cookie uri, 'foo=bar;expires=Wednesday, 09-Nov-99 23:12:40 GMT'
+      cookies = jar.get_cookies(uri)
+      cookies.should have(0).items
+    end
   end
   describe '.get_cookie_headers' do
     it "should return cookie headers" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dwaite-cookiejar
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - David Waite
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-07 00:00:00 -07:00
+date: 2009-09-10 00:00:00 -07:00
 default_executable: 
 dependencies: []