atom-tools 0.9.0 → 2.0.5

data/test/test_http.rb

@@ -1,7 +1,18 @@
+require "test/unit"
+
 require "atom/http"
 require "webrick"
 
-class AtomProtocolTest < Test::Unit::TestCase
+class AtomHTTPTest < Test::Unit::TestCase
+  REALM = "test authentication"
+  USER = "test_user"
+  PASS = "aoeuaoeu"
+
+  # for Google AuthSub authentication
+  TOKEN = "pq7266382__838"
+
+  SECRET_DATA = "I kissed a boy once"
+
   def setup
     @http = Atom::HTTP.new
     @port = rand(1024) + 1024
@@ -11,76 +22,279 @@ class AtomProtocolTest < Test::Unit::TestCase
   end
 
   def test_parse_wwwauth
-    header = 'Basic realm="SokEvo"'
-   
-    # parse_wwwauth is a private method
-    auth_type, auth_params = @http.send :parse_wwwauth, header
+    # a Basic WWW-Authenticate
+    header = 'realm="SokEvo"'
+
+    params = @http.send :parse_quoted_wwwauth, header
+    assert_equal "SokEvo", params[:realm]
+
+    # Digest is parsed a bit differently
+    header = 'opaque="07UrfUiCYac5BbWJ", algorithm=MD5-sess, qop="auth", stale=TRUE, nonce="MDAx0Mzk", realm="test authentication"'
+
+    params = @http.send :parse_wwwauth_digest, header
 
-    assert_equal "Basic", auth_type
-    assert_equal "SokEvo", auth_params["realm"]
+    assert_equal "test authentication", params[:realm]
+    assert_equal "MDAx0Mzk", params[:nonce]
+    assert_equal true, params[:stale]
+    assert_equal "auth", params[:qop]
+    assert_equal "MD5-sess", params[:algorithm]
+    assert_equal "07UrfUiCYac5BbWJ", params[:opaque]
   end
 
   def test_GET
-    @s.mount_proc("/") do |req,res|
+    mount_one_shot do |req,res|
       assert_equal("/", req.path)
 
       res.content_type = "text/plain"
-      res.body = "just junk"
-
-      @s.stop
+      res.body = "Success!"
     end
 
-    one_shot
-
-    res = get_root
+    get_root
     
-    assert_equal("200", res.code)
-    assert_equal("text/plain", res.content_type)
-    assert_equal("just junk", res.body)
+    assert_equal "200", @res.code 
+    assert_equal "text/plain", @res.content_type 
+    assert_equal "Success!", @res.body 
   end
 
   def test_GET_headers
-    @s.mount_proc("/") do |req,res|
+    mount_one_shot do |req,res|
       assert_equal("tester agent", req["User-Agent"])
+    end
+
+    get_root("User-Agent" => "tester agent")
+
+    assert_equal "200", @res.code 
+  end
+
+  def test_redirect
+    @s.mount_proc("/") do |req,res|
+      res.status = 302
+      res["Location"] = "http://localhost:#{@port}/redirected"
       
+      res.body = "ignore me."
+    end
+
+    @s.mount_proc("/redirected") do |req,res|
+      res.content_type = "text/plain"
+      res.body = "Success!"
+
       @s.stop
     end
 
+    one_shot; get_root
+
+    # the redirect should be transparent (to whatever extent it can be)
+    assert_equal "200", @res.code
+    assert_equal "Success!", @res.body
+  end
+
+  def test_redirect_loop
+    @s.mount_proc("/") do |req,res|
+      res.status = 302
+      res["Location"] = "http://localhost:#{@port}/redirected"
+    end
+
+    @s.mount_proc("/redirected") do |req,res|
+      res.status = 302
+      res["Location"] = "http://localhost:#{@port}/"
+    end
+
+    one_shot
+    
+    assert_raises(Atom::HTTPException) { get_root }
+
+    @s.stop
+  end
+
+  def test_redirect_non_GET_non_HEAD
+    @s.mount_proc("/") do |req,res|
+      assert_equal "POST", req.request_method
+      res.status = 302
+      res["Location"] = "http://localhost:#{@port}/redirected"
+    end
+
+    @s.mount_proc("/redirected") do |req,res|
+      assert_equal "POST", req.request_method
+      assert_equal "important message", req.body
+      res.content_type = "text/plain"
+      res.body = "Success!"
+    end
+
     one_shot
 
-    res = get_root("User-Agent" => "tester agent")
+    @res = @http.post "http://localhost:#{@port}/", "important message"
 
-    assert_equal("200", res.code)
+    assert_equal "302", @res.code
+
+    @http.allow_all_redirects = true
+
+    one_shot
+
+    @res = @http.post "http://localhost:#{@port}/", "important message"
+
+    assert_equal "200", @res.code
+    assert_equal "Success!", @res.body
+
+    @s.stop
   end
 
   def test_basic_auth
-    @s.mount_proc("/") do |req,res|
-      WEBrick::HTTPAuth.basic_auth(req, res, "test authentication") do |u,p|
-        u == "test" and p == "pass"
+    mount_one_shot do |req,res|
+      WEBrick::HTTPAuth.basic_auth(req, res, REALM) do |u,p|
+        u == USER and p == PASS
       end
 
-      res.body = "sooper-secret!"
-      @s.stop
+      res.body = SECRET_DATA
     end
 
+    # no credentials
+    assert_raises(Atom::Unauthorized) { get_root }
+
+    # incorrect credentials
+    @http.user = USER
+    @http.pass = "incorrect_password"
+
     one_shot
-    
+
+    assert_raises(Atom::Unauthorized) { get_root }
+
+    # no credentials, fancy block
+    @http.when_auth do nil end
+
+    one_shot
+
     assert_raises(Atom::Unauthorized) { get_root }
 
+    # correct credentials, fancy block
     @http.when_auth do |abs_url,realm|
       assert_equal "http://localhost:#{@port}/", abs_url 
-      assert_equal "test authentication", realm
+      assert_equal REALM, realm
 
-      ["test", "pass"]
+      [USER, PASS]
     end
-    
+
     one_shot
-  
-    res = get_root
-    assert_equal("200", res.code)
-    assert_equal("sooper-secret!", res.body)
+
+    assert_authenticates
+  end
+
+  def test_digest_auth
+    # a dummy userdb (saves me creating a file)
+    userdb = {}
+    # with a single entry
+    userdb[USER] = PASS
+
+    # HTTPAuth::DigestAuth#authenticate uses this
+    def userdb.get_passwd(realm, user, reload)
+      Digest::MD5::hexdigest([user, realm, self[user]].join(":"))
+    end
+      
+    authenticator = WEBrick::HTTPAuth::DigestAuth.new(
+      :UserDB => userdb,
+      :Realm => REALM,
+      :Algorithm => "MD5"
+    )
+
+    @s.mount_proc("/") do |req,res|
+      authenticator.authenticate(req, res)
+      res.body = SECRET_DATA
+    end
+   
+    one_shot
+
+    # no credentials
+    assert_raises(Atom::Unauthorized) { get_root }
+
+    @http.user = USER
+    @http.pass = PASS
+
+    # correct credentials
+    assert_authenticates
+
+    @s.stop
+  end
+
+  def test_wsse_auth
+    mount_one_shot do |req,res|
+      assert_equal 'WSSE profile="UsernameToken"', req["Authorization"]
+
+      xwsse = req["X-WSSE"]
+
+      p = @http.send :parse_quoted_wwwauth, xwsse
+
+      assert_equal USER, p[:Username]
+      assert_match /^UsernameToken /, xwsse
+
+      # Base64( SHA1( Nonce + CreationTimestamp + Password ) )
+      pd_string = p[:Nonce].unpack("m").first + p[:Created] + PASS
+      password_digest = [Digest::SHA1.digest(pd_string)].pack("m").chomp
+
+      assert_equal password_digest, p[:PasswordDigest]
+
+      res.body = SECRET_DATA
+    end
+
+    @http.always_auth = :wsse
+    @http.user = USER
+    @http.pass = PASS
+
+    assert_authenticates
+  end
+
+  def test_authsub_auth
+    mount_one_shot do |req,res|
+      assert_equal %{AuthSub token="#{TOKEN}"}, req["Authorization"]
+
+      res.body = SECRET_DATA
+    end
+
+    @http.always_auth = :authsub
+    @http.token = TOKEN
+
+    assert_authenticates
+  end
+
+  def test_multiple_auth
+    mount_one_shot do |req,res|
+      # WEBrick doesn't seem to support sending multiple headers, so this is the best we can do
+      res["WWW-Authenticate"] = %{NonexistantAuth parameter="yes", qop="auth", Basic realm="#{REALM}", something="true"}
+
+      if req["Authorization"]
+        res.body = SECRET_DATA
+      else
+        res.status = 401
+      end
+    end
+
+    @http.user = USER
+    @http.pass = PASS
+
+    assert_authenticates
+  end
+
+  # mount a block on the test server, shutting the server down after a
+  # single request
+  def mount_one_shot &block
+    @s.mount_proc("/") do |req,res|
+      block.call req, res
+      @s.stop
+    end
+
+    one_shot
+  end
+
+  # test that we authenticated properly
+  def assert_authenticates
+    get_root
+    assert_equal "200", @res.code
+    assert_equal SECRET_DATA, @res.body
+  end
+
+  # performs a GET on the test server
+  def get_root(*args)
+    @res = @http.get("http://localhost:#{@port}/", *args)
   end
 
-  def get_root(*args); @http.get("http://localhost:#{@port}/", *args); end
+  # sets up the server for a single request
   def one_shot; Thread.new { @s.start }; end
 end

data/test/test_protocol.rb

@@ -1,28 +1,47 @@
 require "test/unit"
 
-require "atom/app"
+require "atom/service"
+
+# needed for hpricot
+require "rubygems"
 
 class FakeHTTP
   Response = Struct.new(:body, :code, :content_type)
 
-  def initialize table, mime_type
+  def initialize table
     @table = table
-    @mime_type = mime_type
   end
-  def get url
+
+  def get url, headers = {}
     res = Response.new
-    res.body = @table[url.to_s]
+
+    data = @table[url.to_s]
+
+    res.body = data[1]
     res.code = 200.to_s
-    res.content_type = @mime_type
+    res.content_type = data[0]
+
+    def res.validate_content_type valid; valid.member? content_type; end
+
     res
   end
 end
 
 class AtomProtocolTest < Test::Unit::TestCase
-  def test_introspection
+  attr_reader :have_hpricot
+
+  def initialize *args
+    super
+
+    require "hpricot"
+    @have_hpricot = true
+  rescue LoadError
+    puts "skipping hpricot tests"
+  end
 
-    service = <<END
-<service xmlns="http://purl.org/atom/app#"
+  def test_introspection
+    doc = <<END
+<service xmlns="http://www.w3.org/2007/app"
   xmlns:atom="http://www.w3.org/2005/Atom">
   <workspace>
     <atom:title>My Blog</atom:title>
@@ -36,23 +55,79 @@ class AtomProtocolTest < Test::Unit::TestCase
   </workspace>
 </service>
 END
-    
-    http = FakeHTTP.new({ "http://example.com/service.xml" => service }, "application/atomserv+xml")
 
+    service = Atom::Service.parse doc
 
-    server = Atom::App.new "http://example.com/service.xml", http
+    ws = service.workspaces.first
+    assert_equal "My Blog", ws.title.to_s
 
-    coll = server.collections.first
-    assert_equal(URI.parse("http://example.org/myblog/entries"), coll.uri)
-    assert_equal("Entries", coll.title.to_s)
-    assert_equal("entry", coll.accepts)
+    coll = ws.collections.first
+    assert_equal "http://example.org/myblog/entries", coll.href
+    assert_equal "Entries", coll.title.to_s
+    assert_equal ["application/atom+xml;type=entry"], coll.accepts
 
-    coll = server.collections.last
-    assert_equal(URI.parse("http://example.org/myblog/fotes"), coll.uri)
-    assert_equal("Photos", coll.title.to_s)
-    assert_equal("image/*", coll.accepts)
+    coll = ws.collections.last
+    assert_equal "http://example.org/myblog/fotes", coll.href
+    assert_equal "Photos", coll.title.to_s
+    assert_equal ["image/*"], coll.accepts
 
-    # XXX write a test for relative hrefs
+    http = service.instance_variable_get(:@http)
+    assert_instance_of Atom::HTTP, http
+  end
+
+  def test_write_introspection
+    service = Atom::Service.new
+
+    ws = service.workspaces.new
+
+    ws.title = "Workspace 1"
+
+    coll = Atom::Collection.new "http://example.org/entries"
+    coll.title = "Entries"
+    ws.collections << coll
+
+    coll = Atom::Collection.new "http://example.org/audio"
+    coll.title = "Audio"
+    coll.accepts = ["audio/*"]
+    ws.collections << coll
+
+    nses = { "app" => Atom::PP_NS, "atom" => Atom::NS }
+
+    doc = REXML::Document.new(service.to_s)
+
+    assert_equal "http://www.w3.org/2007/app", doc.root.namespace
+
+    ws = REXML::XPath.first( doc.root,
+                              "/app:service/app:workspace",
+                              nses )
+
+    title = REXML::XPath.first( ws, "./atom:title", nses)
+
+    assert_equal "Workspace 1", title.text
+    assert_equal "http://www.w3.org/2005/Atom", title.namespace
+
+    colls = REXML::XPath.match( ws, "./app:collection", nses)
+    assert_equal(2, colls.length)
+
+    entries = colls.first
+
+    assert_equal "http://example.org/entries", entries.attributes["href"]
+
+    title = REXML::XPath.first(entries, "./atom:title", nses)
+    assert_equal "Entries", title.text
+
+    accepts = REXML::XPath.first(entries, "./app:accept", nses)
+    assert_nil accepts
+
+    audio = colls.last
+
+    assert_equal "http://example.org/audio", audio.attributes["href"]
+
+    title = REXML::XPath.first(audio, "./atom:title", nses)
+    assert_equal "Audio", title.text
+
+    accepts = REXML::XPath.first(audio, "./app:accept", nses)
+    assert_equal "audio/*", accepts.text
   end
 
   def test_dont_specify_http_object
@@ -61,9 +136,53 @@ END
     assert_instance_of Atom::HTTP, collection.instance_variable_get("@http")
   end
 
-  def test_collection_properly_inherits_feed
-    collection = Atom::Collection.new("http://necronomicorp.com/testatom?atom")
+  def test_autodiscover_service_link
+    return unless have_hpricot
+
+    http = FakeHTTP.new \
+      'http://example.org/' => [ 'text/html', '<html><link rel="service" href="svc">' ],
+      'http://example.org/xhtml' => [ 'text/html', '<html><head><link rel="service" href="svc"/></head></html>' ],
+      'http://example.org/svc' => [ 'application/atomsvc+xml', '<service xmlns="http://www.w3.org/2007/app"/>' ]
+
+    svc = Atom::Service.discover 'http://example.org/', http
+    assert_instance_of Atom::Service, svc
+
+    svc = Atom::Service.discover 'http://example.org/xhtml', http
+    assert_instance_of Atom::Service, svc
+  end
+
+  def test_autodiscover_rsd
+    return unless have_hpricot
+
+    http = FakeHTTP.new \
+      'http://example.org/' => [ 'text/html', '<html><link rel="EditURI" href="rsd">' ],
+      'http://example.org/svc' => [ 'application/atomsvc+xml', '<service xmlns="http://www.w3.org/2007/app"/>' ],
+      'http://example.org/rsd' => [ 'text/xml', '<rsd version="1.0" xmlns="http://archipelago.phrasewise.com/rsd"><service><apis><api name="Atom" apiLink="svc" /></apis></service></rsd>' ]
+
+    svc = Atom::Service.discover 'http://example.org/', http
+    assert_instance_of Atom::Service, svc
+  end
+
+  def test_autodiscover_conneg
+    http = FakeHTTP.new \
+      'http://example.org/svc' => [ 'application/atomsvc+xml', '<service xmlns="http://www.w3.org/2007/app"/>' ]
+
+    svc = Atom::Service.discover 'http://example.org/svc', http
+    assert_instance_of Atom::Service, svc
+  end
+
+  def test_cant_autodiscover
+    return unless have_hpricot
+
+    http = FakeHTTP.new 'http://example.org/h' => [ 'text/html', '<html>' ],
+                       'http://example.org/t' => [ 'text/plain', 'no joy.' ]
+
+    assert_raises Atom::AutodiscoveryFailure do
+      Atom::Service.discover 'http://example.org/h', http
+    end
 
-    assert_equal [], collection.links
+    assert_raises Atom::AutodiscoveryFailure do
+      Atom::Service.discover 'http://example.org/t', http
+    end
   end
 end