atom-tools 1.0.0 → 2.0.0

data/test/test_constructs.rb

@@ -24,9 +24,9 @@ END
     xhtml = entry.content.xml
 
     # Hpricot is imperfect; for now I'll just test that it's parseable
-    assert_instance_of Array, xhtml
-    assert_instance_of REXML::Element, xhtml.first
- 
+    assert_instance_of REXML::Element, xhtml
+    assert_equal 'div', xhtml.name
+
 =begin
     assert_equal 2, xhtml.length
 
@@ -73,7 +73,7 @@ END
     assert_equal "html", entry.title["type"]
     assert_equal "<3", entry.title.to_s
     assert_equal "&lt;3", entry.title.html
-    
+
     title = entry.to_xml.root.children.first
     assert_equal "<3", title.text
 =end
@@ -89,9 +89,9 @@ END
     entry = Atom::Entry.new
 
     entry.title = "<3"
-    assert_raises(RuntimeError) { entry.title["type"] = "xhtml" }
-   
-    assert_raises(RuntimeError) do
+    assert_raises(Atom::ParseError) { entry.title["type"] = "xhtml" }
+
+    assert_raises(Atom::ParseError) do
       entry.title["type"] = "application/xhtml+xml"
     end
 
@@ -132,17 +132,30 @@ END
 
     assert_raises(ArgumentError) { entry.authors << "test" }
     assert_raises(ArgumentError) { entry.authors << link }
-    
+
     entry.links << link
 
     assert_equal 1, entry.links.length
   end
 
+  def test_nice_multiple
+    entry = Atom::Entry.new
+
+    entry.authors.new :name => 'Brendan Taylor', :email => 'fake@fake.com', :uri => 'http://necronomicorp.com/bct'
+    entry.authors.new :name => 'some jerk'
+
+    assert_equal 2, entry.authors.length
+
+    assert_equal 'Brendan Taylor', entry.authors.first.name
+  end
+
   require "date"
   def test_date_construct
+    entry = Atom::Entry.new
+
     today = Date.today
-    time = Atom::Time.new today
+    entry.updated = today
 
-    assert_match(/^#{today}T00:00:00/, time.to_s)
+    assert_match(/^#{today}T00:00:00/, entry.updated.to_s)
   end
 end

data/test/test_feed.rb

@@ -129,50 +129,6 @@ END
     assert_raises(Atom::HTTPException) { feed.update! }
   end
 
-  def test_conditional_get
-    @s.mount_proc("/") do |req,res|
-      assert_nil req["If-None-Match"]
-      assert_nil req["If-Modified-Since"]
-
-      res["Etag"] = '"xyzzy"'
-      res["Last-Modified"] = 'Wed, 15 Nov 1995 04:58:08 GMT'
-      res.content_type = "application/atom+xml"
-      res.body = @test_feed
-
-      @s.stop
-    end
-
-    feed = Atom::Feed.new "http://localhost:#{@port}/"
-
-    assert_equal 0, feed.entries.length
-    assert_equal nil, feed.etag
-    assert_equal nil, feed.last_modified
-
-    one_shot
-
-    feed.update!
-
-    assert_equal 1, feed.entries.length
-    assert_equal '"xyzzy"', feed.etag
-    assert_equal 'Wed, 15 Nov 1995 04:58:08 GMT', feed.last_modified
-
-    @s.mount_proc("/") do |req,res|
-      assert_equal '"xyzzy"', req["If-None-Match"]
-      assert_equal 'Wed, 15 Nov 1995 04:58:08 GMT', req["If-Modified-Since"]
-
-      res.status = 304
-      res.content_type = "application/atom+xml"
-      res.body = @test_feed
-      
-      @s.stop
-    end
-
-    one_shot
-    feed.update!
-
-    assert_equal 1, feed.entries.length
-  end
-
   # prepares the server for a single request
   def one_shot; Thread.new { @s.start }; end
 end

data/test/test_general.rb

@@ -2,9 +2,6 @@
 
 require "test/unit"
 
-require "atom/yaml"
-require "atom/xml"
-
 require "atom/feed"
 
 class AtomTest < Test::Unit::TestCase
@@ -46,43 +43,6 @@ class AtomTest < Test::Unit::TestCase
     assert_has_category(xml, "tags")
   end
 
-  def test_devour_yaml
-    time = Time.parse "2007-01-18T12:37:46Z"
-
-    yaml = <<END
-title: testing YAML
-draft: yes
-
-authors:
-- name: Mr. Safe
-  uri: http://example.com/
-
-links:
-- href: http://atomenabled.org/
-
-content: not much here
-
-updated: #{time.iso8601}
-END
-
-    entry = Atom::Entry.from_yaml(yaml)
-
-    assert_equal("testing YAML", entry.title.to_s)
-
-    assert entry.draft
-
-    assert_equal(1, entry.authors.length)
-    assert_equal("Mr. Safe", entry.authors.first.name)
-    assert_equal("http://example.com/", entry.authors.first.uri)
-
-    assert_equal(1, entry.links.length)
-    assert_equal("http://atomenabled.org/", entry.links.first["href"])
-
-    assert_equal("not much here", entry.content.to_s)
-
-    assert_equal(time, entry.updated)
-  end
-
   def assert_has_category xml, term
     assert_not_nil(REXML::XPath.match(xml, "/entry/category[@term = #{term}]"))
   end

data/test/test_http.rb

@@ -254,6 +254,24 @@ class AtomHTTPTest < Test::Unit::TestCase
     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
+
   def test_https
     require 'webrick/https'
 

data/test/test_protocol.rb

@@ -5,15 +5,21 @@ require "atom/service"
 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
@@ -35,30 +41,24 @@ class AtomProtocolTest < Test::Unit::TestCase
   </workspace>
 </service>
 END
-    
-    service = Atom::Service.new
-    service.parse doc
+
+    service = Atom::Service.parse doc
 
     ws = service.workspaces.first
-    assert_equal "My Blog", ws.title.to_s 
+    assert_equal "My Blog", ws.title.to_s
 
     coll = ws.collections.first
-    assert_equal URI.parse("http://example.org/myblog/entries"), coll.uri
+    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 = ws.collections.last
-    assert_equal URI.parse("http://example.org/myblog/fotes"), coll.uri
+    assert_equal "http://example.org/myblog/fotes", coll.href
     assert_equal "Photos", coll.title.to_s
     assert_equal ["image/*"], coll.accepts
 
     http = service.instance_variable_get(:@http)
     assert_instance_of Atom::HTTP, http
-
-    # collections should inherit the service's HTTP object
-    assert_equal http, coll.instance_variable_get(:@http)
-
-    # XXX write a test for relative hrefs
   end
 
   def test_write_introspection
@@ -83,10 +83,10 @@ END
 
     assert_equal "http://www.w3.org/2007/app", doc.root.namespace
 
-    ws = REXML::XPath.first( doc.root, 
-                              "/app:service/app:workspace", 
+    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
@@ -122,9 +122,47 @@ 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
+    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
+    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
+    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

data/test/test_xml.rb

@@ -1,18 +1,25 @@
+$:.unshift 'lib/', File.dirname(__FILE__) + '/../lib'
 require "test/unit"
-
-# for entry.edit_url
 require "atom/service"
 
 class AtomTest < Test::Unit::TestCase
   def test_text_type_text
     entry = get_entry
 
-    entry.title = "Atom-drunk pirates run amok!"
+    entry.title = "Let's talk about <html>"
     assert_equal("text", entry.title["type"])
 
-    xml = get_elements entry
+    assert_match('&lt;', entry.title.xml.to_s)
+
+    xml = entry.to_xml
+
+    b = Atom::Entry.parse(xml).to_s
 
-    assert_equal("Atom-drunk pirates run amok!", xml.elements["/entry/title"].text)
+    base_check xml
+
+    assert_equal("Let's talk about <html>", xml.elements["title"].text)
+
+    assert_match('&lt;', entry.to_s)
   end
 
   def test_text_type_html
@@ -23,8 +30,10 @@ class AtomTest < Test::Unit::TestCase
 
     xml = get_elements entry
 
-    assert_equal("Atom-drunk pirates<br>run amok!", xml.elements["/entry/title"].text)
-    assert_equal("html", xml.elements["/entry/title"].attributes["type"])
+    assert_equal("Atom-drunk pirates<br>run amok!", xml.elements["title"].text)
+    assert_equal("html", xml.elements["title"].attributes["type"])
+
+    assert_match('&lt;', entry.to_s)
   end
 
   def test_text_type_xhtml
@@ -35,10 +44,10 @@ class AtomTest < Test::Unit::TestCase
 
     xml = get_elements entry
 
-    base_check xml
+    assert_equal(XHTML::NS, xml.elements["title/div"].namespace)
+    assert_equal("run amok", xml.elements["title/div/em"].text)
 
-    assert_equal(XHTML::NS, xml.elements["/entry/title/div"].namespace)
-    assert_equal("run amok", xml.elements["/entry/title/div/em"].text)
+    assert_match('<em>', entry.to_s)
   end
 
   def test_html_text_with_entities
@@ -59,9 +68,9 @@ class AtomTest < Test::Unit::TestCase
 
     xml = get_elements entry
 
-    assert_equal("http://necronomicorp.com/blog/", xml.elements["/entry/author/uri"].text)
-    assert_equal("Brendan Taylor", xml.elements["/entry/author/name"].text)
-    assert_nil(xml.elements["/entry/author/email"])
+    assert_equal("http://necronomicorp.com/blog/", xml.elements["author/uri"].text)
+    assert_equal("Brendan Taylor", xml.elements["author/name"].text)
+    assert_nil(xml.elements["author/email"])
   end
 
   def test_tags
@@ -81,15 +90,36 @@ class AtomTest < Test::Unit::TestCase
 
     assert entry.updated.is_a?(Time)
 
-    xml = get_elements entry
+    xml = entry.to_xml
+
+    b = Atom::Entry.parse(xml).to_s
+
+    base_check xml
 
-    assert_match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/, xml.elements["//updated"].text, "atom:updated isn't in xsd:datetime format")
+    assert_match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/, xml.elements["updated"].text, "atom:updated isn't in xsd:datetime format")
 
     entry.updated!
 
     assert((Time.parse("1970-01-01") < entry.updated), "<updated/> is not updated")
   end
 
+  def test_edited
+    entry = get_entry
+
+    assert_nil entry.edited
+
+    entry.edited = "1990-04-07"
+    assert entry.edited.is_a?(Time)
+
+    xml = get_elements entry
+    assert_equal(Atom::PP_NS, xml.elements["app:edited"].namespace)
+    assert_match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/, xml.elements["app:edited"].text,
+      "atom:edited isn't in xsd:datetime format")
+
+    entry.edited!
+    assert((Time.parse("1990-04-07") < entry.edited), "<edited/> is not updated")
+  end
+
   def test_out_of_line
     entry = get_entry
 
@@ -99,25 +129,27 @@ class AtomTest < Test::Unit::TestCase
 
     xml = get_elements(entry)
 
-    assert_nil(xml.elements["/entry/content"].text)
-    assert_equal("http://example.org/test.png", xml.elements["/entry/content"].attributes["src"])
-    assert_equal("image/png", xml.elements["/entry/content"].attributes["type"])
+    assert_nil xml.elements["content"].text
+    assert_equal("http://example.org/test.png", xml.elements["content"].attributes["src"])
+    assert_equal("image/png", xml.elements["content"].attributes["type"])
   end
 
   def test_extensions
     entry = get_entry
 
-    assert(entry.extensions.children.empty?)
+    assert(entry.extensions.empty?)
 
     element = REXML::Element.new("test")
     element.add_namespace "http://purl.org/"
 
     entry.extensions << element
 
+    assert entry.extensions.member?(element)
+
     xml = get_elements entry
 
-    assert_equal(REXML::Element, xml.elements["/entry/test"].class)
-    assert_equal("http://purl.org/", xml.elements["/entry/test"].namespace)
+    assert_equal(REXML::Element, xml.elements["test"].class)
+    assert_equal("http://purl.org/", xml.elements["test"].namespace)
   end
 
   def test_roundtrip_extension
@@ -131,15 +163,15 @@ class AtomTest < Test::Unit::TestCase
 
     assert !entry.draft
 
-    assert_nil get_elements(entry).elements["/entry/control"]
+    assert_nil get_elements(entry).elements["control"]
 
     entry.draft = true
 
     xml = get_elements entry
 
-    assert_equal Atom::PP_NS, xml.elements["/entry/control"].namespace
-    assert_equal Atom::PP_NS, xml.elements["/entry/control/draft"].namespace
-    assert_equal "yes", xml.elements["/entry/control/draft"].text
+    assert_equal Atom::PP_NS, xml.elements["app:control"].namespace
+    assert_equal Atom::PP_NS, xml.elements["app:control/app:draft"].namespace
+    assert_equal "yes", xml.elements["app:control/app:draft"].text
 
     entry2 = Atom::Entry.parse xml
 
@@ -260,7 +292,7 @@ END
     assert_equal("tag:example.org,2003:3", feed.id)
 
     assert_equal([], feed.authors)
-    
+
     alt = feed.links.find { |l| l["rel"] == "alternate" }
     assert_equal("alternate", alt["rel"])
     assert_equal("text/html", alt["type"])
@@ -309,19 +341,6 @@ END
   def test_parse_outofline_content
     xml = <<END
 <entry xmlns="http://www.w3.org/2005/Atom">
-  <summary src="http://necronomicorp.com/nil">
-Summary doesn't have src.
-  </summary>
-</entry>
-END
-
-    entry = Atom::Entry.parse xml
-
-    assert_raises(RuntimeError) { entry.summary["src"] }
-    assert_equal "Summary doesn't have src.", entry.summary.to_s.strip
-
-    xml = <<END
-<entry xmlns="http://www.w3.org/2005/Atom">
   <content src="http://necronomicorp.com/nil">
 src means empty content.
   </content>
@@ -356,6 +375,14 @@ END
     assert_equal("http://www.tbray.org/ongoing/When/200x/2006/10/11/", entry.base)
   end
 
+  def test_relative_src
+    base_url = "http://example.org/foo/"
+    doc = "<entry xmlns='http://www.w3.org/2005/Atom'><content src='./bar'/></entry>"
+
+    entry = Atom::Entry.parse(doc, base_url)
+    assert_equal("http://example.org/foo/bar", entry.content['src'])
+  end
+
   def test_edit_url
     doc = <<END
 <entry xmlns="http://www.w3.org/2005/Atom"><link rel="edit"/></entry>
@@ -381,6 +408,9 @@ END
     entry = Atom::Entry.parse(doc)
 
     assert_equal("http://necronomicorp.com/nil", entry.edit_url)
+
+    entry.edit_url = "http://necronomicorp.com/foo"
+    assert_equal "http://necronomicorp.com/foo", entry.edit_url
   end
 
   def assert_has_category xml, term
@@ -388,7 +418,7 @@ END
   end
 
   def assert_has_content_type xml, type
-    assert_equal(type, xml.elements["/entry/content"].attributes["type"])
+    assert_equal(type, xml.elements["content"].attributes["type"])
   end
 
   def get_entry
@@ -399,7 +429,9 @@ END
   def get_elements entry
     xml = entry.to_xml
 
-    assert_equal(entry.to_s, Atom::Entry.parse(xml).to_s)
+    b = Atom::Entry.parse(xml)
+
+    assert_equal(xml.to_s, b.to_s)
 
     base_check xml