radiant 0.5.0

data/test/unit/page_context_test.rb.rej

@@ -0,0 +1,26 @@
+***************
+*** 262,267 ****
+      assert_parse_output_match "undefined tag `missing'", '<r:missing />'
+    end
+    
+    protected
+      
+      def setup_for_page(page)
+--- 262,278 ----
+      assert_parse_output_match "undefined tag `missing'", '<r:missing />'
+    end
+    
++   def test_tag_tags_list
++     setup_for_page(:homepage)
++     expected = '<a href="/tags/lump">lump</a><a href="/tags/bar">bar</a><a href="/tags/test">test</a><a href="/tags/foo">foo</a>'
++     tags = '<r:tags url="/tags/"><r:link /></r:tags>'
++     assert_parse_output expected, tags
++   end
++   
++   def test_tag_tags_without_url
++     assert_parse_output_match "`tags' tag must include an 'url' attribute", %{<r:tags />}
++   end
++   
+    protected
+      
+      def setup_for_page(page)

data/test/unit/page_part_test.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class PagePartTest < Test::Unit::TestCase
+  fixtures :page_parts
+  test_helper :pages, :page_parts, :validations
+  
+  def setup
+    @part = @model = PagePart.new(VALID_PAGE_PART_PARAMS)
+  end
+  
+  def test_validates_length_of
+    {
+      :name => 100,
+      :filter_id => 25
+    }.each do |field, max|
+      assert_invalid field, ('%d-character limit' % max), 'x' * (max + 1)
+      assert_valid field, 'x' * max
+    end
+  end
+  
+  def test_validates_presence_of
+    [:name].each do |field|
+      assert_invalid field, 'required', '', ' ', nil
+    end
+  end
+  
+  def test_validates_numericality_of
+    [:id, :page_id].each do |field|
+      assert_valid field, '1', '2'
+      assert_invalid field, 'must be a number', 'abcd', '1,2', '1.3'
+    end
+  end
+
+  def test_filter
+    @part = page_parts(:textile_body)
+    original = @part.filter
+    assert_kind_of TextileFilter, original
+    
+    assert_same original, @part.filter
+    
+    @part.filter_id = 'Markdown'
+    assert_kind_of MarkdownFilter, @part.filter
+  end
+end

data/test/unit/page_test.rb

@@ -0,0 +1,224 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class PageTest < Test::Unit::TestCase
+  fixtures :users, :pages, :page_parts, :layouts
+  test_helper :pages, :page_parts, :validations
+
+  def setup
+    @page_title = 'Page Title'
+    destroy_test_page
+    
+    @part_name = 'test-part'
+    destroy_test_part
+    
+    @page = @model = Page.new(VALID_PAGE_PARAMS)
+  end
+  
+  def test_validates_length_of
+    {
+      :title => 255,
+      :slug => 100,
+      :breadcrumb => 160,
+      :behavior_id => 25
+    }.each do |field, max|
+      assert_invalid field, ('%d-character limit' % max), 'x' * (max + 1)
+      assert_valid field, 'x' * max
+    end
+  end
+  
+  def test_validates_presence_of
+    [:title, :slug, :breadcrumb].each do |field|
+      assert_invalid field, 'required', '', ' ', nil
+    end 
+  end
+  
+  def test_validates_format_of
+    @page.parent = pages(:homepage)
+    assert_valid :slug, 'abc', 'abcd-efg', 'abcd_efg', 'abc.html', '/', '123'
+    assert_invalid :slug, 'invalid format', 'abcd efg', ' abcd', 'abcd/efg'
+  end
+  
+  def test_validates_numericality_of
+    assert_invalid :status_id, 'required', '', nil
+    [:id, :status_id, :parent_id].each do |field|
+      assert_valid field, '1', '2'
+      assert_invalid field, 'must be a number', 'abcd', '1,2', '1.3'
+    end
+  end
+
+  def test_validates_uniqueness_of
+    @page.parent = pages(:radius)
+    assert_invalid :slug, 'slug already in use for child of parent', 'child-1', 'child-2', 'child-3'
+    assert_valid :slug, 'child-4'
+  end
+
+  def test_parts
+    @homepage = pages(:homepage)
+    assert_equal(4, @homepage.parts.count)
+    
+    @documentation = pages(:documentation)
+    assert_equal(1, @documentation.parts.count)
+  end
+  
+  def test_destroy__parts_dependant
+    @page = create_test_page
+    @page.parts.create(part_params(:name => @part_name, :page_id => nil))
+    assert_kind_of PagePart, @page.parts.find_by_name(@part_name)
+    
+    id = @page.id
+    @page.destroy
+    assert_nil PagePart.find_by_page_id_and_name(id, @part_name)
+  end
+  
+  def test_part
+    part = radius_page.part('body')
+    assert_equal 'body', part.name
+  end
+  def test_part__lookup_by_symbol
+    part = radius_page.part(:body)
+    assert_equal 'body', part.name
+  end
+  
+  def test_child_url
+    @page = pages(:parent)
+    @child = pages(:child)
+    assert_equal '/parent/child/', @page.child_url(@child)
+  end
+  
+  def test_url
+    page = pages(:parent)
+    assert_equal '/parent/', page.url
+    assert_equal '/parent/child/', page.children.first.url
+  end
+  
+  def test_layout
+    page = pages(:page_with_layout)
+    assert_equal 1, page.layout_id
+    assert_kind_of Layout, page.layout
+  end
+  
+  def test_published_at
+    @page = create_test_page(:status_id => '1')
+    assert_nil @page.published_at
+    
+    @page.status_id = status(:published).id
+    @page.save
+    assert_not_nil @page.published_at
+    assert_equal Time.now.day, @page.published_at.day
+  end
+  
+  def test_published_at__not_updated_on_save_because_already_published
+    @page = create_test_page(:status_id => status(:published).id)
+    assert_kind_of Time, @page.published_at
+    
+    expected = @page.published_at
+    @page.save
+    assert_equal expected, @page.published_at
+  end
+  
+  def test_published
+    @page.status = status(:published)
+    assert_equal true, @page.published?
+  end
+  
+  def test_published__not_published
+    @page.status = status(:draft)
+    assert_equal false, @page.published?
+  end
+  
+  def test_find_by_url
+    @page = pages(:homepage)
+    assert_equal pages(:article), @page.find_by_url('/archive/2000/05/01/article/')
+  end
+  
+  def test_find_by_url__raises_exception_when_root_missing
+    pages(:homepage).destroy
+    
+    # This shouldn't raise an error when there's no root...
+    assert_nil Page.find_by_parent_id(nil)
+    
+    # ...but this should
+    e = assert_raises(Page::MissingRootPageError) { Page.find_by_url "/" }
+    assert_equal 'Database missing root page', e.message
+  end
+  
+  def test_find_by_url_class_method
+    @root = pages(:homepage)
+    assert_equal @root, Page.find_by_url('/')
+    
+    @page = pages(:books)
+    assert_equal @page, Page.find_by_url('/documentation/books/')
+    
+    @root = pages(:homepage)
+    assert_equal 'File Not Found', Page.find_by_url('/gallery/gallery_draft/').title
+    assert_equal 'Gallery Draft', Page.find_by_url('/gallery/gallery_draft/', false).title
+  end
+  
+  def test_render
+    @page = pages(:small_test)
+    assert_equal 'test', @page.render
+  end
+  
+  def test_process
+    @page = create_test_page
+    @request = ActionController::TestRequest.new :url => '/page/'
+    @response = ActionController::TestResponse.new
+    @page.process(@request, @response)
+    assert_equal 'test', @response.body
+  end
+
+  def test_status
+    @page = pages(:homepage)
+    assert_equal Status[:published], @page.status
+  end
+  
+  def test_set_status
+    @page = pages(:homepage)
+    draft = Status[:draft]
+    @page.status = draft
+    assert_equal draft, @page.status
+    assert_equal draft.id, @page.status_id
+  end
+  
+  def test_cache
+    assert_equal true, @page.cache?
+  end
+  
+  def test_layout__inherited
+    @page = pages(:child_of_page_with_layout)
+    assert_equal nil, @page.layout_id
+    assert_equal @page.parent.layout, @page.layout
+  end
+  
+  def test_virtual?
+    assert_equal false, @page.virtual?
+  end
+  
+  def test_before_save
+    @page = create_test_page(:behavior_id => 'Archive Month Index')
+    assert_equal true, @page.virtual?
+    assert_equal true, @page.virtual
+  end
+  
+  def test_behavior
+    @page = pages(:homepage)
+    original = @page.behavior
+    
+    assert_kind_of Behavior::Base, original
+    
+    assert_same original, @page.behavior
+    
+    @page.behavior_id = 'Archive'
+    assert_kind_of ArchiveBehavior, @page.behavior
+  end
+  
+  private
+  
+    def radius_page
+      pages(:radius)
+    end
+    
+    def status(name)
+      Status[name]
+    end
+end

data/test/unit/radiant/config_test.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'radiant/config'
+
+class Radiant::ConfigTest < Test::Unit::TestCase
+  def setup
+    @conf = Radiant::Config
+    set('test', 'cool')
+    set('foo', 'bar')
+  end
+  
+  def test_brackets
+    assert_equal 'cool', @conf['test']
+  end
+  
+  def test_brackets_with_non_existant_key
+    assert_equal nil, @conf['non-existant-key']
+  end
+  
+  def test_assign_to_brackets
+    v = @conf['bar'] = 'baz'
+    assert_equal 'baz', @conf['bar']
+    assert_equal 'baz', v
+  end
+  
+  def test_assign_to_brackets_existing_key
+    @conf['foo'] = 'normal'
+    v = @conf['foo'] = 'replaced'
+    assert_equal 'replaced', @conf['foo']
+    assert_equal 'replaced', v
+  end
+
+  def test_to_hash
+    h = @conf.to_hash
+    assert_instance_of Hash, h
+    assert_equal 'cool', h['test']
+    assert h.size > 1
+  end
+  
+  private
+    def set(key, value)
+      setting = Radiant::Config.find_by_key(key)
+      setting.destroy if setting
+      Radiant::Config.new(:key => key, :value => value).save
+    end
+
+end

data/test/unit/radiant/exporter_test.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../../test_helper'
+require 'radiant/exporter'
+
+class Radiant::ExporterTest < Test::Unit::TestCase
+  fixtures :users, :pages, :page_parts, :snippets, :layouts
+  
+  def setup
+    @exporter = Radiant::Exporter
+    @output   = @exporter.export
+    @hash     = YAML::load(@output)
+    @classes  = ['Radiant::Configs', 'Users', 'Pages', 'PageParts', 'Snippets', 'Layouts']
+  end
+  
+  def test_export_is_string
+    assert_kind_of String, @output
+  end
+  def test_export_classes
+    @classes.each do |expected|
+      assert @hash.keys.include?(expected), "expected hash to contain <#{expected.inspect}> but it did not"
+    end
+  end
+  def test_export_homepage
+    assert_equal 'Ruby Home Page', @hash['Pages'][1]['title']
+    assert_equal 'Admin User',  @hash['Users'][3]['name']
+  end
+end

data/test/unit/registerable_test.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RegisterableTest < Test::Unit::TestCase
+  
+  module TestModule
+    include Registerable
+    
+    class TestClass < Base
+      register 'test'
+    end
+    
+    class Unregistered < Base
+    end
+  end
+  
+  def test_registered
+    assert_kind_of Hash, TestModule.registered
+  end
+  
+  def test_registered_id
+    assert_equal nil, TestModule::Unregistered.registered_id
+    assert_equal 'test', TestModule::TestClass.registered_id
+    assert_equal 'test', TestModule::TestClass.new.registered_id
+  end
+  
+  def test_brackets
+    assert_equal TestModule::TestClass, TestModule['test']
+  end
+  def test_brackets__symbol
+    assert_equal TestModule::TestClass, TestModule[:test]
+  end
+  def test_brackets__with_padding
+    assert_equal TestModule::TestClass, TestModule['  test  ']
+  end
+  def test_brackets__nil_value
+    assert_equal TestModule::Base, TestModule[nil]
+  end
+  def test_brackets__empty_value
+    assert_equal TestModule::Base, TestModule['  ']
+  end
+  def test_brackets__unknown_value
+    assert_equal TestModule::Base, TestModule['Unknown']
+  end
+  def test_brackets__return_same_instance_every_time
+    assert_same TestModule['test'], TestModule['test']
+    assert_same TestModule[nil], TestModule[nil]
+    assert_same TestModule[' '], TestModule[' ']
+  end
+
+  def test_create
+    assert_instance_of TestModule::TestClass, TestModule.create('test')
+  end
+
+  def test_register
+    assert_equal TestModule::TestClass, TestModule['test']
+    assert_equal 'test', TestModule::TestClass.registered_id
+  end
+
+  def test_register__already_registered
+    e = assert_raises(RuntimeError) { TestModule::Base.register 'test' }
+    assert_equal "ID `test' already registered. Choose another ID.", e.message
+  end
+
+  def test_find_all
+    expected = [TestModule::TestClass]
+    assert_equal expected, TestModule.find_all
+  end
+end

data/test/unit/response_cache_test.rb

@@ -0,0 +1,133 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ResponseCacheTest < Test::Unit::TestCase
+  class SilentLogger
+    def method_missing(*args); end
+  end
+  
+  class TestResponse
+    attr_accessor :headers, :body
+    def initialize(body = '', headers = {})
+      @body, @headers = body, headers
+    end
+  end
+  
+  def setup
+    @dir = "#{RAILS_ROOT}/test/cache"
+    @cache = ResponseCache.new(
+      :directory => @dir,
+      :perform_caching => true
+    )
+    @cache.clear
+  end
+  
+  def teardown
+    FileUtils.rm_rf @dir if File.exists? @dir
+  end
+  
+  def test_initialize__defaults
+    @cache = ResponseCache.new
+    assert_equal   "#{RAILS_ROOT}/cache", @cache.directory
+    assert_equal   5.minutes,             @cache.expire_time
+    assert_equal   '.yml',                @cache.default_extension
+    assert_equal   false,                 @cache.perform_caching
+    assert_kind_of Logger,                @cache.logger
+  end
+  
+  def test_initialize__with_options
+    @cache = ResponseCache.new(
+      :directory         => "test",
+      :expire_time       => 5,
+      :default_extension => ".xhtml",
+      :perform_caching   => false,
+      :logger            => SilentLogger.new
+    )
+    assert_equal   "test",       @cache.directory
+    assert_equal   5,            @cache.expire_time
+    assert_equal   ".xhtml",     @cache.default_extension
+    assert_equal   false,        @cache.perform_caching
+    assert_kind_of SilentLogger, @cache.logger
+  end
+  
+  def test_cache_response
+    ['test/me', '/test/me', 'test/me/', '/test/me/', 'test//me'].each do |url|
+      @cache.clear
+      @cache.cache_response(url, response('content'))
+      name = "#{@dir}/test/me.html"
+      assert File.exists?(name), "url: #{url}"
+      assert_equal "--- \nbody: content\nheaders: {}", file(name), "url: #{url}"
+    end
+  end
+  def test_cache_response_without_caching
+    @cache.perform_caching = false
+    @cache.cache_response('test', response('content'))
+    assert !File.exists?("#{@dir}/test.yml")
+  end
+  
+  def test_cache_response
+    @cache.cache_response('/test/me', response('content'))
+    ['test/me', '/test/me', 'test/me/', '/test/me/', 'test//me'].each do |url|
+      assert_equal 'content', @cache.update_response(url, response).body, "url: #{url}"
+    end
+  end
+  def test_update_response__nonexistant
+    assert_equal '', @cache.update_response('nothing/here', response).body
+  end
+  def test_update_response_without_caching
+    @cache.cache_response('/test/me', response('content'))
+    @cache.perform_caching = false
+    assert_equal '', @cache.update_response('/test/me', response).body
+  end
+  
+  def test_cache
+    result = @cache.cache_response('test', response('content', 'Content-Type' => 'text/plain'))
+    cached = @cache.update_response('test', response)
+    assert_equal 'content', cached.body
+    assert_equal 'text/plain', cached.headers['Content-Type']
+    assert_kind_of TestResponse, result
+  end
+  
+  def test_expire_response
+    @cache.cache_response('test', response('content'))
+    @cache.expire_response('test')
+    assert_equal '', @cache.update_response('test', response).body
+  end
+  
+  def test_clear
+    @cache.cache_response('test1', response('content'))
+    @cache.cache_response('test2', response('content'))
+    assert_equal 2, Dir["#{@dir}/*"].size
+    
+    @cache.clear
+    assert_equal 0, Dir["#{@dir}/*"].size
+  end
+  
+  def test_response_cached
+    assert_equal false, @cache.response_cached?('test')
+    result = @cache.cache_response('test', response('content'))
+    assert_equal true, @cache.response_cached?('test')
+  end
+  def test_response_cached_timed_out
+    @cache.expire_time = 1
+    result = @cache.cache_response('test', response('content'))
+    sleep 1.5
+    assert_equal false, @cache.response_cached?('test')
+  end
+  
+  # Class Methods
+  
+  def test_instance
+    assert_same ResponseCache.instance, ResponseCache.instance
+  end
+  
+  private
+  
+    def file(filename)
+      open(filename) { |f| f.read } rescue ''
+    end
+    
+    def response(*args)
+      TestResponse.new(*args)
+    end
+  
+end