typo 3.99.0

data/test/unit/metafragment_test.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class MetaFragmentTest < Test::Unit::TestCase
+  include MetaFragmentCache
+  include ActionController::Caching::Fragments
+
+  def self.benchmark(foo)
+    yield
+  end
+
+  def perform_caching
+    true
+  end
+
+  def setup
+  end
+
+  def test_read_write
+    data = "BLAHBLAHBLAH"
+    meta = {:foo => :bar}
+    write_meta_fragment("TESTFRAGMENT", meta, data)
+    newmeta, newdata = read_meta_fragment("TESTFRAGMENT")
+
+    assert_equal newdata, data
+    assert_equal newmeta, meta
+
+    expire_meta_fragment("TESTFRAGMENT")
+  end
+
+  def test_expre_string
+    write_meta_fragment("TEST_EXPIRE", {:foo => :bar}, "foo")
+    expire_meta_fragment("TEST_EXPIRE")
+    meta, data = read_meta_fragment("TEST_EXPIRE")
+
+    assert_equal nil, data
+    assert_equal Hash.new, meta
+  end
+
+  def test_expire_regex
+    write_meta_fragment("TEST_EXPIRE_1", {:a => :b}, "foo")
+    write_meta_fragment("TEST_EXPIRE_2", {:c => :d}, "bar")
+    write_meta_fragment("TEST_3", {:e => :f}, "zzz")
+
+    expire_meta_fragment(/TEST_EXPIRE.*/)
+    assert_equal [Hash.new, nil], read_meta_fragment("TEST_EXPIRE_1")
+    assert_equal [Hash.new, nil], read_meta_fragment("TEST_EXPIRE_2")
+    assert_equal [{:e => :f},'zzz'], read_meta_fragment("TEST_3")
+  end
+
+  def test_read_expires
+    key = "TEST_READ_EXPIRES"
+    data = "blahblah"
+    meta = {:foo => 'bar', :expires => Time.now + 120} # Expire in 2 minutes
+    write_meta_fragment(key,meta,data)
+    assert_equal [meta, data], read_meta_fragment_expire(key)
+    assert_equal [meta, data], read_meta_fragment(key) # It wasn't expired
+
+    meta[:expires] = Time.now - 1
+    write_meta_fragment(key,meta,data)
+    assert_equal [Hash.new, nil], read_meta_fragment_expire(key)
+    assert_equal [Hash.new, nil], read_meta_fragment(key) # It *was* expired
+  end
+end

data/test/unit/notification_mailer_test.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'notification_mailer'
+
+class NotificationMailerTest < Test::Unit::TestCase
+  FIXTURES_PATH = File.dirname(__FILE__) + '/../fixtures'
+  CHARSET = "utf-8"
+
+  include ActionMailer::Quoting
+
+  def setup
+    ActionMailer::Base.delivery_method = :test
+    ActionMailer::Base.perform_deliveries = true
+    ActionMailer::Base.deliveries = []
+
+    @controller = nil
+    @article = Article.find(1)
+    @user = User.find(1)
+
+    @expected = TMail::Mail.new
+    @expected.set_content_type "text", "plain", { "charset" => CHARSET }
+  end
+
+  def test_article
+    @expected.subject = 'NotificationMailer#article'
+    @expected.body    = read_fixture('article')
+    @expected.date    = Time.now
+
+#    assert_equal @expected.encoded, NotificationMailer.create_article(@controller, @article, @user).encoded
+  end
+
+  def test_comment
+    @expected.subject = 'NotificationMailer#comment'
+    @expected.body    = read_fixture('comment')
+    @expected.date    = Time.now
+
+#    assert_equal @expected.encoded, NotificationMailer.create_comment(@controller, @article, @user).encoded
+  end
+
+  def test_trackback
+    @expected.subject = 'NotificationMailer#trackback'
+    @expected.body    = read_fixture('trackback')
+    @expected.date    = Time.now
+
+#    assert_equal @expected.encoded, NotificationMailer.create_trackback(@controller, @article, @user).encoded
+  end
+
+  private
+    def read_fixture(action)
+      IO.readlines("#{FIXTURES_PATH}/notification_mailer/#{action}")
+    end
+
+    def encode(subject)
+      quoted_printable(subject, CHARSET)
+    end
+end

data/test/unit/observer_test.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+require 'http_mock'
+
+class ObserverTest < Test::Unit::TestCase
+  fixtures :contents, :blogs, :articles_tags, :tags,
+           :resources, :categories, :articles_categories
+
+  def reset_observer
+    @informant = nil
+    @symbol    = nil
+  end
+
+  def setup
+    reset_observer
+  end
+
+  def update(informant, symbol)
+    @informant = informant
+    @symbol = symbol
+  end
+
+  def test_simple_observation
+    art = Article.find(contents(:article1).id)
+    assert art.add_observer(self)
+    art.changed
+    art.notify_observers(art, :test)
+
+    assert_equal art.id, @informant.id
+    assert_equal :test, @symbol
+  end
+
+  def test_content_observation
+    contents(:article1).add_observer(self)
+    contents(:article1).body = 'A new body'
+
+    assert_equal contents(:article1), @informant
+    assert_equal :body, @symbol
+  end
+end

data/test/unit/page_cache_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require 'page_cache'
+
+class PageCache
+
+  cattr_accessor :deleted_pages
+
+  def delete_file(path)
+    PageCache.deleted_pages << path
+  end
+end
+
+class CacheTest < Test::Unit::TestCase
+  fixtures :page_caches
+
+  def setup
+    PageCache.deleted_pages = []
+    PageCache.public_path = ''
+  end
+
+  # Replace this with your real tests.
+  def test_sweep_all
+    PageCache.sweep_all
+
+    assert_equal ['/index.html', '/articles/2005/05/05/title'].sort, PageCache.deleted_pages.sort
+  end
+
+  def test_sweep_by_pattern
+    PageCache.sweep('articles%')
+
+    assert_equal ['/articles/2005/05/05/title'], PageCache.deleted_pages
+  end
+
+end

data/test/unit/page_test.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class PageTest < Test::Unit::TestCase
+  fixtures :contents
+
+  def setup
+    @page = Page.find(9)
+  end
+
+  def test_validate
+    a = Page.new
+    a.name = 'a-new-name'
+    a.title = 'A Fabulous Page yo!'
+    a.body = 'x'
+
+    assert a.save
+
+    b = Page.new
+    b.name = a.name
+    b.body = a.body
+    b.title = a.title
+
+    assert !b.save
+  end
+end

data/test/unit/ping_test.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+require 'http_mock'
+require 'xmlrpc_mock'
+
+class PingTest < Test::Unit::TestCase
+  fixtures :contents, :blogs
+
+  def setup
+    @pingback_header = nil
+    @body = ''
+  end
+
+  def teardown
+    Net::HTTP.next_response = nil
+  end
+
+  def test_send_pingback_found_in_pingback_header
+
+    # We've linked to http://anotherblog.org/a-post from
+    # http://myblog.net/referring-post and discovered a pingback
+    # listener at http://anotherblog.org/xml-rpc
+    # Set up the mocking
+
+
+    @pingback_header = "http://anotherblog.org/xml-rpc"
+    assert_pingback_sent
+  end
+
+  def test_send_pingback_found_in_body
+    @body = %{<link rel="pingback" href="http://anotherblog.org/xml-rpc" />}
+
+    assert_pingback_sent
+  end
+
+  def assert_pingback_sent
+    Net::HTTP.next_response = self
+    ping = contents(:article1).pings.build("url" =>
+                                           "http://anotherblog.org/a-post")
+
+    ping.send_pingback_or_trackback("http://myblog.net/referring-post")
+
+    sent_ping = XMLRPC::Client.pings.last
+    assert_equal "http://anotherblog.org/xml-rpc", sent_ping.uri
+    assert_equal "pingback.ping", sent_ping.method_name
+    assert_equal "http://myblog.net/referring-post", sent_ping.args[0]
+    assert_equal "http://anotherblog.org/a-post", sent_ping.args[1]
+  end
+
+  def test_send_trackback
+
+    # We've linked to http://anotherblog.org/a-post from
+    # http://myblog.net/referring-post and discovered the trackback
+    # URL http://anotherblog.org/a-post/trackback
+    Net::HTTP.next_response = self
+
+    @body = <<-eobody
+    <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+           xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/"
+           xmlns:dc="http://purl.org/dc/elements/1.1/">
+    <rdf:Description
+        rdf:about=""
+        trackback:ping="http://anotherblog.org/a-post/trackback"
+        dc:title="Track me, track me!"
+        dc:identifier="http://anotherblog.org/a-post"
+        dc:description="Track me 'til I fart!'"
+        dc:creator="pdcawley"
+        dc:date="2006-03-01T04:31:00-05:00" />
+    </rdf:RDF>
+    eobody
+
+    ping = contents(:article1).pings.build("url" =>
+                                           "http://anotherblog.org/a-post")
+    ping.send_pingback_or_trackback("http://myblog.net/referring-post")
+
+    ping = Net::HTTP.pings.last
+    assert_equal "anotherblog.org", ping.host
+    assert_equal 80, ping.port
+    assert_equal "/a-post/trackback", ping.query
+    assert_equal "title=Article%201!&excerpt=body&url=http://myblog.net/referring-post&blog_name=test%20blog", ping.post_data
+  end
+
+  def test_send_weblogupdatesping
+
+    # Our blog, named this_blog.blog_name at http://myblog.net/ has
+    # changed through us posting http://myblog.net/new-post. This,
+    # we'd like to tell to http://rpc.technorati.com/rpc/ping.
+
+    ping = contents(:article1).pings.build("url" =>
+                                           "http://rpc.technorati.com/rpc/ping")
+    ping.send_weblogupdatesping("http://myblog.net/",
+                                "http://myblog.net/new-post")
+
+    ping = XMLRPC::Client.pings.last
+    assert_equal "http://rpc.technorati.com/rpc/ping", ping.uri
+    assert_equal "weblogUpdates.ping", ping.method_name
+    assert_equal this_blog.blog_name, ping.args[0]
+    assert_equal "http://myblog.net/", ping.args[1]
+    assert_equal "http://myblog.net/new-post", ping.args[2]
+  end
+
+  # Mock stuff
+
+  def [](key)
+    @pingback_header
+  end
+
+  def body
+    @body
+  end
+end

data/test/unit/redirect_test.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RedirectTest < Test::Unit::TestCase
+  fixtures :redirects
+
+  # Replace this with your real tests.
+  def test_exists
+    assert_kind_of Redirect, redirects(:foo_redirect)
+    assert_kind_of Redirect, redirects(:archive1_redirect)
+  end
+
+  def test_uniqueness
+    assert_equal redirects(:foo_redirect), Redirect.find_by_from_path('foo/bar')
+    redir = Redirect.new
+    redir.from_path = 'foo/bar'
+    redir.to_path = '/'
+    assert !redir.save
+  end
+end

data/test/unit/resource_test.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ResourceTest < Test::Unit::TestCase
+  fixtures :resources
+
+  def setup
+    # put the files on disk as if it were uploaded
+    FileUtils.mkpath("#{RAILS_ROOT}/public/files")
+    [ resources(:resource1), resources(:resource2) ].each { |f| FileUtils.touch(f.fullpath) }
+  end
+
+  def teardown
+    # remove the files on disk
+    [ resources(:resource1), resources(:resource2) ].each { |f|
+      File.unlink(f.fullpath) if File.exist?(f.fullpath)
+    }
+  end
+
+  def test_fullpath
+    assert_equal resources(:resource1).fullpath, "#{RAILS_ROOT}/public/files/#{resources(:resource1).filename}"
+  end
+
+  def test_create
+    assert_not_nil resources(:resource1)
+    assert_not_nil resources(:resource2)
+
+    f1 = Resource.create(:filename => resources(:resource1).filename,
+                            :mime => resources(:resource1).mime,
+                            :created_at => Time.now)
+    assert_not_nil f1
+    f2 = Resource.create(:filename => resources(:resource2).filename,
+                            :mime => resources(:resource2).mime,
+                            :created_at => Time.now)
+    assert_not_nil f2
+
+    assert resources(:resource1).filename != f1.filename
+    assert resources(:resource2).filename != f2.filename
+    f1.destroy
+    f2.destroy
+  end
+
+  def test_read
+    assert_not_nil resources(:resource1)
+    f = Resource.find_by_filename(resources(:resource1).filename)
+    assert_not_nil f
+    assert_equal f, resources(:resource1)
+  end
+
+  def test_update
+    assert_not_nil resources(:resource1)
+    assert_not_nil resources(:resource2)
+
+    f = resources(:resource2)
+    assert resources(:resource2).save
+    assert_equal f.filename, resources(:resource2).filename
+
+    resources(:resource1).filename = f.filename
+    assert !resources(:resource1).save
+
+    resources(:resource1).filename = Resource.find(1).filename
+    assert resources(:resource1).save
+  end
+
+  def test_destroy
+    assert_not_nil resources(:resource1)
+    # blow it away, ensure that the file is removed from the public/files dir
+    assert resources(:resource1).destroy
+    assert !File.exist?(resources(:resource1).fullpath)
+    assert_raise(ActiveRecord::RecordNotFound) { Resource.find(resources(:resource1).id) }
+  end
+end

data/test/unit/sidebar_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class SidebarTest < Test::Unit::TestCase
+  fixtures :sidebars
+
+  def setup
+    @sidebar = Sidebar.find(1)
+  end
+
+  # Replace this with your real tests.
+  def test_truth
+    assert_kind_of Sidebar,  @sidebar
+  end
+end

data/test/unit/tag_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TagTest < Test::Unit::TestCase
+  fixtures :tags, :contents, :articles_tags
+
+  def setup
+    @tag = Tag.find(1)
+  end
+
+  # Replace this with your real tests.
+  def test_truth
+    assert_kind_of Tag,  @tag
+  end
+
+  def test_get
+    tag=Tag.get('foo')
+    assert_equal tags(:foo_tag), tag
+
+    tag2=Tag.get('zzz')
+    assert_kind_of Tag, tag2
+    #assert_equal 3, tag2.id # this conflicts with MySQL's auto_increment
+    assert_equal 'zzz', tag2.name
+  end
+
+  def test_uniqueness
+    tag1 = Tag.create(:name => 'test')
+    assert_kind_of Tag, tag1
+    assert_equal 'test', tag1.name
+
+    tag2 = Tag.new(:name => 'test')
+    assert_kind_of Tag, tag2
+    assert_equal 'test', tag2.name
+
+    assert_not_equal tag1, tag2
+
+    assert ! tag2.save, "Duplicate tag save did not fail"
+    assert tag2.errors.invalid?('name'), "name field did not have error"
+
+    tag3 = Tag.create(:name => 'Monty Python')
+    assert_kind_of Tag, tag3
+    assert_equal 'montypython', tag3.name
+    assert_equal 'Monty Python', tag3.display_name
+  end
+
+  def test_article
+    a1=Article.create(:title => 'Article 1')
+    assert_kind_of Article, a1
+    a1.tags << tags(:foo_tag)
+    a1.tags << tags(:bar_tag)
+
+    assert_equal 2, a1.tags.size
+    assert_equal [tags(:foo_tag),tags(:bar_tag)].sort_by {|i| i.id}, a1.tags.sort_by {|i| i.id}
+  end
+
+  def test_find_all_with_article_counters
+    tags=Tag.find_all_with_article_counters(10)
+
+    assert_equal 2, tags.size
+
+    assert_equal "foo", tags.first.name
+    assert_equal 1, tags.last.article_counter
+
+    assert_equal "bar", tags.last.name
+    assert_equal 2, tags.first.article_counter
+  end
+end