atom-tools 0.9.0

data/test/test_general.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/ruby
+
+require "test/unit"
+
+require "atom/yaml"
+require "atom/xml"
+
+require "atom/feed"
+
+class AtomTest < Test::Unit::TestCase
+  def test_feed_duplicate_id
+    feed = Atom::Feed.new
+
+    entry1 = get_entry
+    entry1.id = "http://example.org/test"
+    entry1.content = "an original entry"
+    entry1.updated!
+
+    feed << entry1
+
+    assert_equal(1, feed.entries.length)
+    assert_equal("an original entry", feed.entries.first.content.to_s)
+
+    feed << entry1.dup
+
+    assert_equal(1, feed.entries.length)
+    assert_equal("an original entry", feed.entries.first.content.to_s)
+
+    entry2 = entry1.dup
+    entry2.content = "a changed entry"
+    entry2.updated!
+
+    feed << entry2
+
+    assert_equal(1, feed.entries.length)
+    assert_equal("a changed entry", feed.entries.last.content.to_s)
+  end
+
+  def test_tags
+    entry = get_entry
+    entry.tag_with "test tags"
+
+    xml = get_elements entry
+
+    assert_has_category(xml, "test")
+    assert_has_category(xml, "tags")
+  end
+
+  def test_snarf_yaml
+    yaml = """title: testing YAML
+authors:
+- name: Mr. Safe
+  uri: http://example.com/
+links:
+- href: http://atomenabled.org/
+content: not much here\
+"""
+
+    entry = Atom::Entry.from_yaml(yaml)
+
+    assert_equal("testing YAML", entry.title.to_s)
+
+    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)
+  end
+ 
+  def assert_has_category xml, term
+    assert_not_nil(REXML::XPath.match(xml, "/entry/category[@term = #{term}]"))
+  end
+
+  def assert_has_content_type xml, type
+    assert_equal(type, xml.elements["/entry/content"].attributes["type"])
+  end
+
+  def get_entry
+    Atom::Entry.new
+  end
+
+  def get_elements entry
+    xml = entry.to_xml
+
+    assert_equal(entry.to_s, Atom::Entry.parse(xml).to_s) 
+    
+    base_check xml
+    
+    xml
+  end
+
+  def base_check xml
+    assert_equal("entry", xml.root.name)
+    assert_equal("http://www.w3.org/2005/Atom", xml.root.namespace)
+  end
+end

data/test/test_http.rb

@@ -0,0 +1,86 @@
+require "atom/http"
+require "webrick"
+
+class AtomProtocolTest < Test::Unit::TestCase
+  def setup
+    @http = Atom::HTTP.new
+    @port = rand(1024) + 1024
+    @s = WEBrick::HTTPServer.new :Port => @port, 
+               :Logger => WEBrick::Log.new($stderr, WEBrick::Log::FATAL), 
+               :AccessLog => []
+  end
+
+  def test_parse_wwwauth
+    header = 'Basic realm="SokEvo"'
+   
+    # parse_wwwauth is a private method
+    auth_type, auth_params = @http.send :parse_wwwauth, header
+
+    assert_equal "Basic", auth_type
+    assert_equal "SokEvo", auth_params["realm"]
+  end
+
+  def test_GET
+    @s.mount_proc("/") do |req,res|
+      assert_equal("/", req.path)
+
+      res.content_type = "text/plain"
+      res.body = "just junk"
+
+      @s.stop
+    end
+
+    one_shot
+
+    res = get_root
+    
+    assert_equal("200", res.code)
+    assert_equal("text/plain", res.content_type)
+    assert_equal("just junk", res.body)
+  end
+
+  def test_GET_headers
+    @s.mount_proc("/") do |req,res|
+      assert_equal("tester agent", req["User-Agent"])
+      
+      @s.stop
+    end
+
+    one_shot
+
+    res = get_root("User-Agent" => "tester agent")
+
+    assert_equal("200", res.code)
+  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"
+      end
+
+      res.body = "sooper-secret!"
+      @s.stop
+    end
+
+    one_shot
+    
+    assert_raises(Atom::Unauthorized) { get_root }
+
+    @http.when_auth do |abs_url,realm|
+      assert_equal "http://localhost:#{@port}/", abs_url 
+      assert_equal "test authentication", realm
+
+      ["test", "pass"]
+    end
+    
+    one_shot
+  
+    res = get_root
+    assert_equal("200", res.code)
+    assert_equal("sooper-secret!", res.body)
+  end
+
+  def get_root(*args); @http.get("http://localhost:#{@port}/", *args); end
+  def one_shot; Thread.new { @s.start }; end
+end

data/test/test_protocol.rb

@@ -0,0 +1,69 @@
+require "test/unit"
+
+require "atom/app"
+
+class FakeHTTP
+  Response = Struct.new(:body, :code, :content_type)
+
+  def initialize table, mime_type
+    @table = table
+    @mime_type = mime_type
+  end
+  def get url
+    res = Response.new
+    res.body = @table[url.to_s]
+    res.code = 200.to_s
+    res.content_type = @mime_type
+    res
+  end
+end
+
+class AtomProtocolTest < Test::Unit::TestCase
+  def test_introspection
+
+    service = <<END
+<service xmlns="http://purl.org/atom/app#"
+  xmlns:atom="http://www.w3.org/2005/Atom">
+  <workspace>
+    <atom:title>My Blog</atom:title>
+    <collection href="http://example.org/myblog/entries">
+      <atom:title>Entries</atom:title>
+    </collection>
+    <collection href="http://example.org/myblog/fotes">
+      <atom:title>Photos</atom:title>
+      <accept>image/*</accept>
+    </collection>
+  </workspace>
+</service>
+END
+    
+    http = FakeHTTP.new({ "http://example.com/service.xml" => service }, "application/atomserv+xml")
+
+
+    server = Atom::App.new "http://example.com/service.xml", http
+
+    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 = 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)
+
+    # XXX write a test for relative hrefs
+  end
+
+  def test_dont_specify_http_object
+    collection = Atom::Collection.new("http://necronomicorp.com/testatom?atom")
+
+    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")
+
+    assert_equal [], collection.links
+  end
+end

data/test/test_xml.rb

@@ -0,0 +1,353 @@
+require "test/unit"
+
+# for entry.edit_url
+require "atom/app"
+
+class AtomTest < Test::Unit::TestCase
+  def test_text_type_text
+    entry = get_entry
+    
+    entry.title = "Atom-drunk pirates run amok!"
+    assert_equal("text", entry.title["type"])
+
+    xml = get_elements entry
+    
+    assert_equal("Atom-drunk pirates run amok!", xml.elements["/entry/title"].text)
+  end
+
+  def test_text_type_html
+    entry = get_entry
+
+    entry.title = "Atom-drunk pirates<br>run amok!"
+    entry.title["type"] = "html"
+
+    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"])
+  end
+
+  def test_text_type_xhtml
+    entry = get_entry
+
+    entry.title = "Atom-drunk pirates <em>run amok</em>!"
+    entry.title["type"] = "xhtml"
+
+    xml = get_elements entry
+    
+    base_check xml
+
+    assert_equal(XHTML::NS, xml.elements["/entry/title/div"].namespace)
+    assert_equal("run amok", xml.elements["/entry/title/div/em"].text)
+  end
+
+  def test_author
+    entry = get_entry
+    a = entry.authors.new
+    
+    a.name= "Brendan Taylor"
+    a.uri = "http://necronomicorp.com/blog/"
+
+    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"])
+  end
+
+  def test_tags
+    entry = get_entry
+    entry.tag_with "test tags"
+
+    xml = get_elements entry
+
+    assert_has_category(xml, "test")
+    assert_has_category(xml, "tags")
+  end
+
+  def test_updated
+    entry = get_entry
+    entry.updated = "1970-01-01"
+    entry.content = "blah"
+
+    assert_instance_of(Time, entry.updated)
+
+    xml = get_elements entry
+
+    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_out_of_line
+    entry = get_entry
+
+    entry.content = "this shouldn't appear"
+    entry.content["src"] = 'http://example.org/test.png'
+    entry.content["type"] = "image/png"
+
+    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"])
+  end
+
+  def test_extensions
+    entry = get_entry
+
+    assert(entry.extensions.children.empty?)
+
+    element = REXML::Element.new("test")
+    element.add_namespace "http://purl.org/"
+
+    entry.extensions << element
+
+    xml = get_elements entry
+
+    assert_equal(REXML::Element, xml.elements["/entry/test"].class)
+    assert_equal("http://purl.org/", xml.elements["/entry/test"].namespace)
+  end
+
+  def test_extensive_enty_parsing
+str = '<entry xmlns="http://www.w3.org/2005/Atom">
+  <title>Atom draft-07 snapshot</title>
+  <link rel="alternate" type="text/html"
+    href="http://example.org/2005/04/02/atom"/>
+  <link rel="enclosure" type="audio/mpeg" length="1337"
+    href="http://example.org/audio/ph34r_my_podcast.mp3"/>
+  <id>tag:example.org,2003:3.2397</id>
+  <updated>2005-07-31T12:29:29Z</updated>
+  <published>2003-12-13T08:29:29-04:00</published>
+  <author>
+    <name>Mark Pilgrim</name>
+    <uri>http://example.org/</uri>
+    <email>f8dy@example.com</email>
+  </author>
+  <contributor>
+    <name>Sam Ruby</name>
+  </contributor>
+  <contributor>
+    <name>Joe Gregorio</name>
+  </contributor>
+  <content type="xhtml" xml:lang="en"
+    xml:base="http://diveintomark.org/">
+    <div xmlns="http://www.w3.org/1999/xhtml">
+      <p><i>[Update: The Atom draft is finished.]</i></p>
+    </div>
+  </content>
+</entry>'
+
+    entry = Atom::Entry.parse(str)
+  
+    assert_equal("Atom draft-07 snapshot", entry.title.to_s)
+    assert_equal("tag:example.org,2003:3.2397", entry.id)
+  
+    assert_equal(Time.parse("2005-07-31T12:29:29Z"), entry.updated)
+    assert_equal(Time.parse("2003-12-13T08:29:29-04:00"), entry.published)
+
+    assert_equal(2, entry.links.length)
+    assert_equal("alternate", entry.links.first["rel"])
+    assert_equal("text/html", entry.links.first["type"])
+    assert_equal("http://example.org/2005/04/02/atom", entry.links.first["href"])
+
+    assert_equal("enclosure", entry.links.last["rel"])
+    assert_equal("audio/mpeg", entry.links.last["type"])
+    assert_equal("1337", entry.links.last["length"])
+    assert_equal("http://example.org/audio/ph34r_my_podcast.mp3", entry.links.last["href"])
+
+    assert_equal(1, entry.authors.length)
+    assert_equal("Mark Pilgrim", entry.authors.first.name)
+    assert_equal("http://example.org/", entry.authors.first.uri)
+    assert_equal("f8dy@example.com", entry.authors.first.email)
+    
+    assert_equal(2, entry.contributors.length)
+    assert_equal("Sam Ruby", entry.contributors.first.name)
+    assert_equal("Joe Gregorio", entry.contributors.last.name)
+  
+    assert_equal("xhtml", entry.content["type"])
+   
+    assert_match("<p><i>[Update: The Atom draft is finished.]</i></p>", 
+                 entry.content.to_s)
+    
+    assert_equal("http://diveintomark.org/", entry.content.base)
+    # XXX unimplemented
+#    assert_equal("en", entry.content.lang)
+  end
+
+  def test_extensive_feed_parsing
+feed = <<END
+<?xml version="1.0" encoding="utf-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title type="text">dive into mark</title>
+  <subtitle type="html">
+    A &lt;em&gt;lot&lt;/em&gt; of effort
+    went into making this effortless
+  </subtitle>
+  <updated>2005-07-31T12:29:29Z</updated>
+  <id>tag:example.org,2003:3</id>
+  <link rel="alternate" type="text/html"
+   hreflang="en" href="http://example.org/"/>
+  <link rel="self" type="application/atom+xml"
+   href="http://example.org/feed.atom"/>
+  <rights>Copyright (c) 2003, Mark Pilgrim</rights>
+  <generator uri="http://www.example.com/" version="1.0">
+    Example Toolkit
+  </generator>
+  <entry>
+    <title>Atom draft-07 snapshot</title>
+    <author>
+      <name>Mark Pilgrim</name>
+      <uri>http://example.org/</uri>
+      <email>f8dy@example.com</email>
+    </author>
+    <link rel="alternate" type="text/html"
+     href="http://example.org/2005/04/02/atom"/>
+    <id>tag:example.org,2003:3.2397</id>
+    <updated>2005-07-31T12:29:29Z</updated>
+  </entry>
+</feed>
+END
+
+    feed = Atom::Feed.parse(feed)
+
+    assert_equal("", feed.base)
+
+    assert_equal("text", feed.title["type"])
+    assert_equal("dive into mark", feed.title.to_s)
+
+    assert_equal("html", feed.subtitle["type"])
+    assert_equal("\n    A <em>lot</em> of effort\n    went into making this effortless\n  ", feed.subtitle.to_s)
+
+    assert_equal(Time.parse("2005-07-31T12:29:29Z"), feed.updated)
+    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"])
+    assert_equal("en", alt["hreflang"])
+    assert_equal("http://example.org/", alt["href"])
+
+    assert_equal("text", feed.rights["type"])
+    assert_equal("Copyright (c) 2003, Mark Pilgrim", feed.rights.to_s)
+
+    assert_equal("\n    Example Toolkit\n  ", feed.generator)
+    # XXX unimplemented
+    # assert_equal("http://www.example.com/", feed.generator["uri"])
+    # assert_equal("1.0", feed.generator["version"])
+   
+    assert_equal(1, feed.entries.length)
+    assert_equal "Atom draft-07 snapshot", feed.entries.first.title.to_s
+  end
+
+  def test_parse_html_content
+    xml = <<END
+<entry xmlns="http://www.w3.org/2005/Atom">
+  <summary type="html">
+    &lt;p>...&amp;amp; as a result of this, I submit that &lt;var>pi&lt;/var> &amp;lt; 4
+  </summary>
+</entry>
+END
+
+    entry = Atom::Entry.parse(xml)
+
+    assert_equal "html", entry.summary["type"]
+    assert_equal "<p>...&amp; as a result of this, I submit that <var>pi</var> &lt; 4", entry.summary.html.strip
+  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>
+</entry>
+END
+
+    entry = Atom::Entry.parse xml
+
+    assert_equal "http://necronomicorp.com/nil", entry.content["src"]
+    assert_equal "", entry.content.to_s
+  end
+
+  def test_relative_base
+    base_url = "http://www.tbray.org/ongoing/ongoing.atom"
+    doc = "<entry xmlns='http://www.w3.org/2005/Atom' xml:base='When/200x/2006/10/11/'/>"
+    
+    entry = Atom::Entry.parse(doc, base_url)
+    assert_equal("http://www.tbray.org/ongoing/When/200x/2006/10/11/", entry.base)
+  end
+  
+  def test_edit_url
+    doc = <<END
+<entry xmlns="http://www.w3.org/2005/Atom"><link rel="edit"/></entry>
+END
+    entry = Atom::Entry.parse(doc)
+
+    assert_nil(entry.edit_url)
+
+    doc = <<END
+<entry xmlns="http://www.w3.org/2005/Atom"><link rel="edit"/></entry>
+END
+
+    entry = Atom::Entry.parse(doc)
+
+    assert_nil(entry.edit_url)
+    
+    doc = <<END
+<entry xmlns="http://www.w3.org/2005/Atom">
+  <link rel="edit" href="http://necronomicorp.com/nil"/>
+</entry>
+END
+
+    entry = Atom::Entry.parse(doc)
+
+    assert_equal("http://necronomicorp.com/nil", entry.edit_url)
+  end
+
+
+  def assert_has_category xml, term
+    assert_not_nil(REXML::XPath.match(xml, "/entry/category[@term = #{term}]"))
+  end
+
+  def assert_has_content_type xml, type
+    assert_equal(type, xml.elements["/entry/content"].attributes["type"])
+  end
+
+  def get_entry
+    Atom::Entry.new
+  end
+
+  # round-trips it to make sure things stay the same
+  def get_elements entry
+    xml = entry.to_xml
+
+    assert_equal(entry.to_s, Atom::Entry.parse(xml).to_s) 
+    
+    base_check xml
+    
+    xml
+  end
+
+  def base_check xml
+    assert_equal("entry", xml.root.name)
+    assert_equal("http://www.w3.org/2005/Atom", xml.root.namespace)
+  end
+end