mechanize 2.0.1 → 2.1.pre.1

data/test/test_mechanize_cookie.rb

@@ -1,4 +1,4 @@
-require "helper"
+require 'mechanize/test_case'
 
 module Enumerable
   def combine
@@ -17,7 +17,7 @@ module Enumerable
   end
 end
 
-class TestMechanizeCookie < MiniTest::Unit::TestCase
+class TestMechanizeCookie < Mechanize::TestCase
   def silently
     warn_level = $VERBOSE
     $VERBOSE = false
@@ -70,6 +70,31 @@ class TestMechanizeCookie < MiniTest::Unit::TestCase
     end
   end
 
+  def test_parse_no_space
+    cookie_str = "foo=bar;Expires=Sun, 06 Nov 2011 00:28:06 GMT;Path=/"
+
+    uri = URI.parse 'http://example'
+
+    Mechanize::Cookie.parse uri, cookie_str do |cookie|
+      assert_equal 'foo',               cookie.name
+      assert_equal 'bar',               cookie.value
+      assert_equal '/',                 cookie.path
+      assert_equal Time.at(1320539286), cookie.expires
+    end
+  end
+
+  def test_parse_quoted
+    cookie_str =
+      "quoted=\"value\"; Expires=Sun, 06 Nov 2011 00:11:18 GMT; Path=/"
+
+    uri = URI.parse 'http://example'
+
+    Mechanize::Cookie.parse uri, cookie_str do |cookie|
+      assert_equal 'quoted', cookie.name
+      assert_equal '"value"', cookie.value
+    end
+  end
+
   def test_parse_weird_cookie
     cookie = 'n/a, ASPSESSIONIDCSRRQDQR=FBLDGHPBNDJCPCGNCPAENELB; path=/'
     url = URI.parse('http://www.searchinnovation.com/')
@@ -128,7 +153,8 @@ class TestMechanizeCookie < MiniTest::Unit::TestCase
 
     cookie = Mechanize::Cookie.parse(url, cookie_str).first
 
-    assert_equal '.example.com', cookie.domain
+    assert_equal 'example.com', cookie.domain
+    assert cookie.for_domain?
   end
 
   def test_parse_domain_no_dot
@@ -138,7 +164,8 @@ class TestMechanizeCookie < MiniTest::Unit::TestCase
 
     cookie = Mechanize::Cookie.parse(url, cookie_str).first
 
-    assert_equal '.example.com', cookie.domain
+    assert_equal 'example.com', cookie.domain
+    assert cookie.for_domain?
   end
 
   def test_parse_domain_none
@@ -149,6 +176,7 @@ class TestMechanizeCookie < MiniTest::Unit::TestCase
     cookie = Mechanize::Cookie.parse(url, cookie_str).first
 
     assert_equal 'example.com', cookie.domain
+    assert !cookie.for_domain?
   end
 
   def test_parse_expires_session
@@ -161,6 +189,43 @@ class TestMechanizeCookie < MiniTest::Unit::TestCase
     assert cookie.session
   end
 
+  def test_parse_many
+    url = URI 'http://example/'
+    cookie_str =
+      "name=Aaron; Domain=localhost; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/, " \
+      "name=Aaron; Domain=localhost; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/, " \
+      "name=Aaron; Domain=localhost; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/, " \
+      "name=Aaron; Domain=localhost; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/; HttpOnly, " \
+      "expired=doh; Expires=Fri, 04 Nov 2011 00:29:51 GMT; Path=/, " \
+      "a_path=some_path; Expires=Sun, 06 Nov 2011 00:29:51 GMT; Path=/some_path, " \
+      "no_path=no_path; Expires=Sun, 06 Nov 2011 00:29:51 GMT, no_expires=nope; Path=/"
+
+    cookies = Mechanize::Cookie.parse url, cookie_str
+    assert_equal 8, cookies.length
+
+    name = cookies.find { |c| c.name == 'name' }
+    assert_equal "Aaron",             name.value
+    assert_equal "/",                 name.path
+    assert_equal Time.at(1320539391), name.expires
+
+    a_path = cookies.find { |c| c.name == 'a_path' }
+    assert_equal "some_path",         a_path.value
+    assert_equal "/some_path",        a_path.path
+    assert_equal Time.at(1320539391), a_path.expires
+
+    no_expires = cookies.find { |c| c.name == 'no_expires' }
+    assert_equal "nope", no_expires.value
+    assert_equal "/",    no_expires.path
+    assert_nil           no_expires.expires
+
+    no_path = cookies.find { |c| c.name == 'no_path' }
+    assert_equal "no_path",           no_path.value
+    assert_equal "/",                 no_path.path
+    assert_equal Time.at(1320539391), no_path.expires
+
+    assert cookies.find { |c| c.name == 'expired' }
+  end
+
   def test_parse_valid_cookie
     url = URI.parse('http://rubyforge.org/')
     cookie_params = {}

data/test/test_mechanize_cookie_jar.rb

@@ -1,19 +1,11 @@
-require 'helper'
-require 'tmpdir'
+require 'mechanize/test_case'
 
-class TestMechanizeCookieJar < MiniTest::Unit::TestCase
+class TestMechanizeCookieJar < Mechanize::TestCase
 
   def setup
-    @jar = Mechanize::CookieJar.new
-    @tmpdir = Dir.mktmpdir
-
-    @orig_dir = Dir.pwd
-    Dir.chdir @tmpdir
-  end
+    super
 
-  def teardown
-    Dir.chdir @orig_dir
-    FileUtils.remove_entry_secure @tmpdir
+    @jar = Mechanize::CookieJar.new
   end
 
   def cookie_values(options = {})
@@ -22,185 +14,242 @@ class TestMechanizeCookieJar < MiniTest::Unit::TestCase
       :value    => 'Bar',
       :path     => '/',
       :expires  => Time.now + (10 * 86400),
+      :for_domain => true,
       :domain   => 'rubyforge.org'
    }.merge(options)
   end
 
-  def cookie_from_hash(hash)
-    c = Mechanize::Cookie.new(hash[:name], hash[:value])
-    hash.each { |k,v|
-      next if k == :name || k == :value
-      c.send("#{k}=", v)
-    }
-    c
-  end
-
   def test_two_cookies_same_domain_and_name_different_paths
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
-    cookie = cookie_from_hash(cookie_values)
+    cookie = Mechanize::Cookie.new(cookie_values)
     @jar.add(url, cookie)
-    @jar.add(url, cookie_from_hash(cookie_values(:path => '/onetwo')))
+    @jar.add(url, Mechanize::Cookie.new(cookie_values(:path => '/onetwo')))
 
     assert_equal(1, @jar.cookies(url).length)
-    assert_equal 2, @jar.cookies(URI.parse('http://rubyforge.org/onetwo')).length
+    assert_equal 2, @jar.cookies(URI('http://rubyforge.org/onetwo')).length
   end
 
   def test_domain_case
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
     # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
+    cookie = Mechanize::Cookie.new(cookie_values)
     @jar.add(url, cookie)
     assert_equal(1, @jar.cookies(url).length)
 
-    @jar.add(url, cookie_from_hash(
+    @jar.add(url, Mechanize::Cookie.new(
         cookie_values(:domain => 'RuByForge.Org', :name   => 'aaron')))
 
     assert_equal(2, @jar.cookies(url).length)
 
-    url2 = URI.parse('http://RuByFoRgE.oRg/')
+    url2 = URI 'http://RuByFoRgE.oRg/'
     assert_equal(2, @jar.cookies(url2).length)
   end
 
+  def test_no_domain_case
+    url = URI.parse('http://www.rubyforge.org/')
+
+    @jar.add(url, Mechanize::Cookie.new(
+        cookie_values(:domain => 'rubyforge.org', :for_domain => false)))
+
+    assert_equal(0, @jar.cookies(url).length)
+  end
+
   def test_empty_value
     values = cookie_values(:value => "")
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
     # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(values)
+    cookie = Mechanize::Cookie.new(values)
     @jar.add(url, cookie)
     assert_equal(1, @jar.cookies(url).length)
 
-    @jar.add(url, cookie_from_hash( values.merge(  :domain => 'RuByForge.Org',
-                                                  :name   => 'aaron'
-                                               ) ) )
+    @jar.add url, Mechanize::Cookie.new(values.merge(:domain => 'RuByForge.Org',
+                                                     :name   => 'aaron'))
 
     assert_equal(2, @jar.cookies(url).length)
 
-    url2 = URI.parse('http://RuByFoRgE.oRg/')
+    url2 = URI 'http://RuByFoRgE.oRg/'
     assert_equal(2, @jar.cookies(url2).length)
   end
 
   def test_add_future_cookies
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
     # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
+    cookie = Mechanize::Cookie.new(cookie_values)
     @jar.add(url, cookie)
     assert_equal(1, @jar.cookies(url).length)
 
     # Add the same cookie, and we should still only have one
-    @jar.add(url, cookie_from_hash(cookie_values))
+    @jar.add(url, Mechanize::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.parse('http://rubyforge.org/login')).length)
+    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.parse('http://google.com/')).length)
+    assert_equal(0, @jar.cookies(URI('http://google.com/')).length)
   end
 
   def test_add_multiple_cookies
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
     # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
+    cookie = Mechanize::Cookie.new(cookie_values)
     @jar.add(url, cookie)
     assert_equal(1, @jar.cookies(url).length)
 
     # Add the same cookie, and we should still only have one
-    @jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
+    @jar.add(url, Mechanize::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.parse('http://rubyforge.org/login')).length)
+    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.parse('http://google.com/')).length)
+    assert_equal(0, @jar.cookies(URI('http://google.com/')).length)
   end
 
   def test_add_rejects_cookies_that_do_not_contain_an_embedded_dot
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
-    tld_cookie = cookie_from_hash(cookie_values(:domain => '.org'))
+    tld_cookie = Mechanize::Cookie.new(cookie_values(:domain => '.org'))
     @jar.add(url, tld_cookie)
-    single_dot_cookie = cookie_from_hash(cookie_values(:domain => '.'))
+    single_dot_cookie = Mechanize::Cookie.new(cookie_values(:domain => '.'))
     @jar.add(url, single_dot_cookie)
 
     assert_equal(0, @jar.cookies(url).length)
   end
 
-  def test_add_makes_exception_for_local_tld
-    url = URI.parse('http://example.local')
+  def test_fall_back_rules_for_local_domains
+    url = URI 'http://www.example.local'
 
-    tld_cookie = cookie_from_hash(cookie_values(:domain => '.local'))
+    tld_cookie = Mechanize::Cookie.new(cookie_values(:domain => '.local'))
     @jar.add(url, tld_cookie)
 
+    assert_equal(0, @jar.cookies(url).length)
+
+    sld_cookie = Mechanize::Cookie.new(cookie_values(:domain => '.example.local'))
+    @jar.add(url, sld_cookie)
+
     assert_equal(1, @jar.cookies(url).length)
   end
 
   def test_add_makes_exception_for_localhost
-    url = URI.parse('http://localhost')
+    url = URI 'http://localhost'
 
-    tld_cookie = cookie_from_hash(cookie_values(:domain => 'localhost'))
+    tld_cookie = Mechanize::Cookie.new(cookie_values(:domain => 'localhost'))
     @jar.add(url, tld_cookie)
 
     assert_equal(1, @jar.cookies(url).length)
   end
 
   def test_add_cookie_for_the_parent_domain
-    url = URI.parse('http://x.foo.com')
+    url = URI 'http://x.foo.com'
 
-    cookie = cookie_from_hash(cookie_values(:domain => '.foo.com'))
+    cookie = Mechanize::Cookie.new(cookie_values(:domain => '.foo.com'))
     @jar.add(url, cookie)
 
     assert_equal(1, @jar.cookies(url).length)
   end
 
-  def test_add_rejects_cookies_from_a_nested_subdomain
-    url = URI.parse('http://y.x.foo.com')
+  def test_add_does_not_reject_cookies_from_a_nested_subdomain
+    url = URI 'http://y.x.foo.com'
 
-    cookie = cookie_from_hash(cookie_values(:domain => '.foo.com'))
+    cookie = Mechanize::Cookie.new(cookie_values(:domain => '.foo.com'))
     @jar.add(url, cookie)
 
-    assert_equal(0, @jar.cookies(url).length)
+    assert_equal(1, @jar.cookies(url).length)
   end
 
-  def test_cookie_without_leading_dot_does_not_match_subdomains
-    url = URI.parse('http://admin.rubyforge.org/')
+  def test_cookie_without_leading_dot_does_not_cause_substring_match
+    url = URI 'http://arubyforge.org/'
 
-    cookie = cookie_from_hash(cookie_values(:domain => 'rubyforge.org'))
+    cookie = Mechanize::Cookie.new(cookie_values(:domain => 'rubyforge.org'))
     @jar.add(url, cookie)
 
     assert_equal(0, @jar.cookies(url).length)
   end
 
+  def test_cookie_without_leading_dot_matches_subdomains
+    url = URI 'http://admin.rubyforge.org/'
+
+    cookie = Mechanize::Cookie.new(cookie_values(:domain => 'rubyforge.org'))
+    @jar.add(url, cookie)
+
+    assert_equal(1, @jar.cookies(url).length)
+  end
+
   def test_cookies_with_leading_dot_match_subdomains
-    url = URI.parse('http://admin.rubyforge.org/')
+    url = URI 'http://admin.rubyforge.org/'
+
+    @jar.add(url, Mechanize::Cookie.new(cookie_values(:domain => '.rubyforge.org')))
+
+    assert_equal(1, @jar.cookies(url).length)
+  end
+
+  def test_cookies_with_leading_dot_match_parent_domains
+    url = URI 'http://rubyforge.org/'
+
+    @jar.add(url, Mechanize::Cookie.new(cookie_values(:domain => '.rubyforge.org')))
+
+    assert_equal(1, @jar.cookies(url).length)
+  end
+
+  def test_cookies_with_leading_dot_match_parent_domains_exactly
+    url = URI 'http://arubyforge.org/'
+
+    @jar.add(url, Mechanize::Cookie.new(cookie_values(:domain => '.rubyforge.org')))
+
+    assert_equal(0, @jar.cookies(url).length)
+  end
+
+  def test_cookie_for_ipv4_address_matches_the_exact_ipaddress
+    url = URI 'http://192.168.0.1/'
+
+    cookie = Mechanize::Cookie.new(cookie_values(:domain => '192.168.0.1'))
+    @jar.add(url, cookie)
+
+    assert_equal(1, @jar.cookies(url).length)
+  end
+
+  def test_cookie_for_ipv4_address_does_not_cause_subdomain_match
+    url = URI 'http://192.168.0.1/'
+
+    cookie = Mechanize::Cookie.new(cookie_values(:domain => '.0.1'))
+    @jar.add(url, cookie)
 
-    @jar.add(url, cookie_from_hash(cookie_values(:domain => '.rubyforge.org')))
+    assert_equal(0, @jar.cookies(url).length)
+  end
+
+  def test_cookie_for_ipv6_address_matches_the_exact_ipaddress
+    url = URI 'http://[fe80::0123:4567:89ab:cdef]/'
+
+    cookie = Mechanize::Cookie.new(cookie_values(:domain => '[fe80::0123:4567:89ab:cdef]'))
+    @jar.add(url, cookie)
 
     assert_equal(1, @jar.cookies(url).length)
   end
 
   def test_cookies_dot
-    url = URI.parse('http://www.host.example/')
+    url = URI 'http://www.host.example/'
 
     @jar.add(url,
-             cookie_from_hash(cookie_values(:domain => 'www.host.example')))
+             Mechanize::Cookie.new(cookie_values(:domain => 'www.host.example')))
 
-    url = URI.parse('http://wwwxhost.example/')
+    url = URI 'http://wwwxhost.example/'
     assert_equal(0, @jar.cookies(url).length)
   end
 
   def test_clear_bang
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
     # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
+    cookie = Mechanize::Cookie.new(cookie_values)
     @jar.add(url, cookie)
-    @jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
+    @jar.add(url, Mechanize::Cookie.new(cookie_values(:name => 'Baz')))
     assert_equal(2, @jar.cookies(url).length)
 
     @jar.clear!
@@ -209,177 +258,188 @@ class TestMechanizeCookieJar < MiniTest::Unit::TestCase
   end
 
   def test_save_cookies_yaml
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
     # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
-    s_cookie = cookie_from_hash(cookie_values(:name => 'Bar',
+    cookie = Mechanize::Cookie.new(cookie_values)
+    s_cookie = Mechanize::Cookie.new(cookie_values(:name => 'Bar',
                                               :expires => nil,
                                               :session => true))
 
     @jar.add(url, cookie)
     @jar.add(url, s_cookie)
-    @jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
+    @jar.add(url, Mechanize::Cookie.new(cookie_values(:name => 'Baz')))
 
     assert_equal(3, @jar.cookies(url).length)
 
-    @jar.save_as("cookies.yml")
+    in_tmpdir do
+      @jar.save_as("cookies.yml")
 
-    jar = Mechanize::CookieJar.new
-    jar.load("cookies.yml")
-    assert_equal(2, jar.cookies(url).length)
+      jar = Mechanize::CookieJar.new
+      jar.load("cookies.yml")
+      assert_equal(2, jar.cookies(url).length)
+    end
 
     assert_equal(3, @jar.cookies(url).length)
   end
 
   def test_save_cookies_cookiestxt
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
     # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
-    s_cookie = cookie_from_hash(cookie_values(:name => 'Bar',
+    cookie = Mechanize::Cookie.new(cookie_values)
+    s_cookie = Mechanize::Cookie.new(cookie_values(:name => 'Bar',
                                               :expires => nil,
                                               :session => true))
 
     @jar.add(url, cookie)
     @jar.add(url, s_cookie)
-    @jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
+    @jar.add(url, Mechanize::Cookie.new(cookie_values(:name => 'Baz')))
 
     assert_equal(3, @jar.cookies(url).length)
 
-    @jar.save_as("cookies.txt", :cookiestxt)
+    in_tmpdir do
+      @jar.save_as("cookies.txt", :cookiestxt)
 
-    jar = Mechanize::CookieJar.new
-    jar.load("cookies.txt", :cookiestxt) # HACK test the format
-    assert_equal(2, jar.cookies(url).length)
+      jar = Mechanize::CookieJar.new
+      jar.load("cookies.txt", :cookiestxt) # HACK test the format
+      assert_equal(2, jar.cookies(url).length)
+    end
 
     assert_equal(3, @jar.cookies(url).length)
   end
 
   def test_expire_cookies
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
     # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
+    cookie = Mechanize::Cookie.new(cookie_values)
     @jar.add(url, cookie)
     assert_equal(1, @jar.cookies(url).length)
 
     # Add a second cookie
-    @jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
+    @jar.add(url, Mechanize::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.parse('http://rubyforge.org/login')).length)
+    assert_equal(2, @jar.cookies(URI('http://rubyforge.org/login')).length)
 
     # Expire the first cookie
-    @jar.add(url, cookie_from_hash(
+    @jar.add(url, Mechanize::Cookie.new(
         cookie_values(:expires => Time.now - (10 * 86400))))
     assert_equal(1, @jar.cookies(url).length)
 
     # Expire the second cookie
-    @jar.add(url, cookie_from_hash(
+    @jar.add(url, Mechanize::Cookie.new(
         cookie_values( :name => 'Baz', :expires => Time.now - (10 * 86400))))
     assert_equal(0, @jar.cookies(url).length)
   end
 
   def test_session_cookies
     values = cookie_values(:expires => nil)
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
     # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(values)
+    cookie = Mechanize::Cookie.new(values)
     @jar.add(url, cookie)
     assert_equal(1, @jar.cookies(url).length)
 
     # Add a second cookie
-    @jar.add(url, cookie_from_hash(values.merge(:name => 'Baz')))
+    @jar.add(url, Mechanize::Cookie.new(values.merge(: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.parse('http://rubyforge.org/login')).length)
+    assert_equal(2, @jar.cookies(URI('http://rubyforge.org/login')).length)
 
     # Expire the first cookie
-    @jar.add(url, cookie_from_hash(values.merge(:expires => Time.now - (10 * 86400))))
+    @jar.add(url, Mechanize::Cookie.new(values.merge(:expires => Time.now - (10 * 86400))))
     assert_equal(1, @jar.cookies(url).length)
 
     # Expire the second cookie
-    @jar.add(url, cookie_from_hash(
+    @jar.add(url, Mechanize::Cookie.new(
         values.merge(:name => 'Baz', :expires => Time.now - (10 * 86400))))
     assert_equal(0, @jar.cookies(url).length)
 
     # When given a URI with a blank path, CookieJar#cookies should return
     # cookies with the path '/':
-    url = URI.parse('http://rubyforge.org')
+    url = URI 'http://rubyforge.org'
     assert_equal '', url.path
     assert_equal(0, @jar.cookies(url).length)
     # Now add a cookie with the path set to '/':
-    @jar.add(url, cookie_from_hash(values.merge( :name => 'has_root_path',
+    @jar.add(url, Mechanize::Cookie.new(values.merge( :name => 'has_root_path',
                                           :path => '/')))
     assert_equal(1, @jar.cookies(url).length)
   end
 
   def test_paths
     values = cookie_values(:path => "/login", :expires => nil)
-    url = URI.parse('http://rubyforge.org/login')
+    url = URI 'http://rubyforge.org/login'
 
     # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(values)
+    cookie = Mechanize::Cookie.new(values)
     @jar.add(url, cookie)
     assert_equal(1, @jar.cookies(url).length)
 
     # Add a second cookie
-    @jar.add(url, cookie_from_hash(values.merge( :name => 'Baz' )))
+    @jar.add(url, Mechanize::Cookie.new(values.merge( :name => 'Baz' )))
     assert_equal(2, @jar.cookies(url).length)
 
     # Make sure we don't get the cookie in a different path
-    assert_equal(0, @jar.cookies(URI.parse('http://rubyforge.org/hello')).length)
-    assert_equal(0, @jar.cookies(URI.parse('http://rubyforge.org/')).length)
+    assert_equal(0, @jar.cookies(URI('http://rubyforge.org/hello')).length)
+    assert_equal(0, @jar.cookies(URI('http://rubyforge.org/')).length)
 
     # Expire the first cookie
-    @jar.add(url, cookie_from_hash(values.merge( :expires => Time.now - (10 * 86400))))
+    @jar.add(url, Mechanize::Cookie.new(values.merge( :expires => Time.now - (10 * 86400))))
     assert_equal(1, @jar.cookies(url).length)
 
     # Expire the second cookie
-    @jar.add(url, cookie_from_hash(values.merge( :name => 'Baz',
+    @jar.add(url, Mechanize::Cookie.new(values.merge( :name => 'Baz',
                                           :expires => Time.now - (10 * 86400))))
     assert_equal(0, @jar.cookies(url).length)
   end
 
   def test_save_and_read_cookiestxt
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
     # Add one cookie with an expiration date in the future
-    cookie = cookie_from_hash(cookie_values)
+    cookie = Mechanize::Cookie.new(cookie_values)
     @jar.add(url, cookie)
-    @jar.add(url, cookie_from_hash(cookie_values(:name => 'Baz')))
+    @jar.add(url, Mechanize::Cookie.new(cookie_values(:name => 'Baz')))
     assert_equal(2, @jar.cookies(url).length)
 
-    @jar.save_as("cookies.txt", :cookiestxt)
-    @jar.clear!
+    in_tmpdir do
+      @jar.save_as("cookies.txt", :cookiestxt)
+      @jar.clear!
+
+      @jar.load("cookies.txt", :cookiestxt)
+    end
 
-    @jar.load("cookies.txt", :cookiestxt)
     assert_equal(2, @jar.cookies(url).length)
   end
 
   def test_save_and_read_cookiestxt_with_session_cookies
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
-    @jar.add(url, cookie_from_hash(cookie_values(:expires => nil)))
-    @jar.save_as("cookies.txt", :cookiestxt)
-    @jar.clear!
+    @jar.add(url, Mechanize::Cookie.new(cookie_values(:expires => nil)))
+
+    in_tmpdir do
+      @jar.save_as("cookies.txt", :cookiestxt)
+      @jar.clear!
+
+      @jar.load("cookies.txt", :cookiestxt)
+    end
 
-    @jar.load("cookies.txt", :cookiestxt)
     assert_equal(1, @jar.cookies(url).length)
     assert_nil @jar.cookies(url).first.expires
   end
 
   def test_save_and_read_expired_cookies
-    url = URI.parse('http://rubyforge.org/')
+    url = URI 'http://rubyforge.org/'
 
     @jar.jar['rubyforge.org'] = {}
 
 
-    @jar.add url, cookie_from_hash(cookie_values)
+    @jar.add url, Mechanize::Cookie.new(cookie_values)
 
     # HACK no asertion
   end
@@ -387,15 +447,31 @@ class TestMechanizeCookieJar < MiniTest::Unit::TestCase
   def test_ssl_cookies
     # thanks to michal "ocher" ochman for reporting the bug responsible for this test.
     values = cookie_values(:expires => nil)
-    values_ssl = values.merge(:domain => "#{values[:domain]}:443")
-    url = URI.parse('https://rubyforge.org/login')
+    values_ssl = values.merge(:name => 'Baz', :domain => "#{values[:domain]}:443")
+    url = URI 'https://rubyforge.org/login'
 
-    cookie = cookie_from_hash(values)
+    cookie = Mechanize::Cookie.new(values)
     @jar.add(url, cookie)
     assert_equal(1, @jar.cookies(url).length, "did not handle SSL cookie")
 
-    cookie = cookie_from_hash(values_ssl)
+    cookie = Mechanize::Cookie.new(values_ssl)
     @jar.add(url, cookie)
     assert_equal(2, @jar.cookies(url).length, "did not handle SSL cookie with :443")
   end
+
+  def test_secure_cookie
+    nurl = URI 'http://rubyforge.org/login'
+    surl = URI 'https://rubyforge.org/login'
+
+    ncookie = Mechanize::Cookie.new(cookie_values(:name => 'Foo1'))
+    scookie = Mechanize::Cookie.new(cookie_values(:name => 'Foo2', :secure => true))
+
+    @jar.add(nurl, ncookie)
+    @jar.add(nurl, scookie)
+    @jar.add(surl, ncookie)
+    @jar.add(surl, scookie)
+
+    assert_equal('Foo1',      @jar.cookies(nurl).map { |c| c.name }.sort.join(' ') )
+    assert_equal('Foo1 Foo2', @jar.cookies(surl).map { |c| c.name }.sort.join(' ') )
+  end
 end