browsercms 3.1.4 → 3.1.5

data/test/unit/lib/cms/sitemap_test.rb

@@ -0,0 +1,206 @@
+require "test_helper"
+
+class MoveSections < ActiveSupport::TestCase
+
+  def setup
+    @root = Factory(:root_section)
+    @parent = Factory(:section, :parent => @root, :name => "Parent")
+    @a = Factory(:section, :parent => @parent, :name => "A")
+    @a1 = Factory(:page, :section => @a, :name => "A1")
+    @a2 = Factory(:page, :section => @a, :name => "A2")
+    @a3 = Factory(:page, :section => @a, :name => "A3")
+    @b = Factory(:section, :parent => @parent, :name => "B")
+    @b1 = Factory(:page, :section => @b, :name => "B1")
+    @b2 = Factory(:page, :section => @b, :name => "B2")
+    @b3 = Factory(:page, :section => @b, :name => "B3")
+
+    @node_a = @a.node
+    @node_b = @b.node
+    @node_a1 = @a1.section_node
+    @node_a2 = @a2.section_node
+    @node_a3 = @a3.section_node
+    @node_b1 = @b1.section_node
+    @node_b2 = @b2.section_node
+    @node_b3 = @b3.section_node
+    reset(:node_a, :node_a1, :node_a2, :node_a3, :node_b, :node_b1, :node_b2, :node_b3)
+
+    # Use this to print out complete table data
+    # log_table_without_stamps(SectionNode)
+  end
+
+  def test_reorder_nodes_within_same_section
+    @node_a2.move_to(@a, 1)
+    reset(:node_a, :node_a1, :node_a2, :node_a3, :node_b, :node_b1, :node_b2, :node_b3)
+    assert_properties(@node_a, :ancestry=> ancestry_for(@parent), :node_type => "Section", :node_id => @a.id, :position => 1)
+    assert_properties(@node_b, :ancestry=> ancestry_for(@parent), :node_type => "Section", :node_id => @b.id, :position => 2)
+    assert_properties(@node_a1, :ancestry=> ancestry_for(@a), :node_type => "Page", :node_id => @a1.id, :position => 2)
+    assert_properties(@node_a2, :ancestry=>ancestry_for(@a), :node_type => "Page", :node_id => @a2.id, :position => 1)
+    assert_properties(@node_a3, :ancestry=> ancestry_for(@a), :node_type => "Page", :node_id => @a3.id, :position => 3)
+    assert_properties(@node_b1, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b1.id, :position => 1)
+    assert_properties(@node_b2, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b2.id, :position => 2)
+    assert_properties(@node_b3, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b3.id, :position => 3)
+  end
+
+  def test_move_nodes_to_different_section
+    @node_a2.move_to(@b, 2)
+    reset(:node_a, :node_a1, :node_a2, :node_a3, :node_b, :node_b1, :node_b2, :node_b3)
+    assert_properties(@node_a, :ancestry=> ancestry_for(@parent), :node_type => "Section", :node_id => @a.id, :position => 1)
+    assert_properties(@node_b, :ancestry=> ancestry_for(@parent), :node_type => "Section", :node_id => @b.id, :position => 2)
+    assert_properties(@node_a1, :ancestry=> ancestry_for(@a), :node_type => "Page", :node_id => @a1.id, :position => 1)
+    assert_properties(@node_a2, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @a2.id, :position => 2)
+    assert_properties(@node_a3, :ancestry=> ancestry_for(@a), :node_type => "Page", :node_id => @a3.id, :position => 2)
+    assert_properties(@node_b1, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b1.id, :position => 1)
+    assert_properties(@node_b2, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b2.id, :position => 3)
+    assert_properties(@node_b3, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b3.id, :position => 4)
+  end
+  def test_move_nodes_to_beginning_of_different_section
+    @node_a2.move_to(@b, 1)
+    reset(:node_a, :node_a1, :node_a2, :node_a3, :node_b, :node_b1, :node_b2, :node_b3)
+    assert_properties(@node_a, :ancestry=> ancestry_for(@parent), :node_type => "Section", :node_id => @a.id, :position => 1)
+    assert_properties(@node_b, :ancestry=> ancestry_for(@parent), :node_type => "Section", :node_id => @b.id, :position => 2)
+    assert_properties(@node_a1, :ancestry=> ancestry_for(@a), :node_type => "Page", :node_id => @a1.id, :position => 1)
+    assert_properties(@node_a2, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @a2.id, :position => 1)
+    assert_properties(@node_a3, :ancestry=> ancestry_for(@a), :node_type => "Page", :node_id => @a3.id, :position => 2)
+    assert_properties(@node_b1, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b1.id, :position => 2)
+    assert_properties(@node_b2, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b2.id, :position => 3)
+    assert_properties(@node_b3, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b3.id, :position => 4)
+  end
+  def test_move_nodes_to_end_of_different_section
+    @node_a2.move_to(@b, 99)
+    reset(:node_a, :node_a1, :node_a2, :node_a3, :node_b, :node_b1, :node_b2, :node_b3)
+    assert_properties(@node_a, :ancestry=> ancestry_for(@parent), :node_type => "Section", :node_id => @a.id, :position => 1)
+    assert_properties(@node_b, :ancestry=> ancestry_for(@parent), :node_type => "Section", :node_id => @b.id, :position => 2)
+    assert_properties(@node_a1, :ancestry=> ancestry_for(@a), :node_type => "Page", :node_id => @a1.id, :position => 1)
+    assert_properties(@node_a2, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @a2.id, :position => 4)
+    assert_properties(@node_a3, :ancestry=> ancestry_for(@a), :node_type => "Page", :node_id => @a3.id, :position => 2)
+    assert_properties(@node_b1, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b1.id, :position => 1)
+    assert_properties(@node_b2, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b2.id, :position => 2)
+    assert_properties(@node_b3, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b3.id, :position => 3)
+  end
+
+  def test_put_page_at_the_bottom_when_section_is_changed
+    @a2.update_attributes(:section=> @b)
+    reset(:node_a, :node_a1, :node_a2, :node_a3, :node_b, :node_b1, :node_b2, :node_b3)
+    assert_properties(@node_a, :ancestry=> ancestry_for(@parent), :node_type => "Section", :node_id => @a.id, :position => 1)
+    assert_properties(@node_b, :ancestry=> ancestry_for(@parent), :node_type => "Section", :node_id => @b.id, :position => 2)
+    assert_properties(@node_a1, :ancestry=> ancestry_for(@a), :node_type => "Page", :node_id => @a1.id, :position => 1)
+    assert_properties(@node_a2, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @a2.id, :position => 4)
+    assert_properties(@node_a3, :ancestry=> ancestry_for(@a), :node_type => "Page", :node_id => @a3.id, :position => 2)
+    assert_properties(@node_b1, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b1.id, :position => 1)
+    assert_properties(@node_b2, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b2.id, :position => 2)
+    assert_properties(@node_b3, :ancestry=> ancestry_for(@b), :node_type => "Page", :node_id => @b3.id, :position => 3)
+  end
+
+  def test_find_ancestors
+    assert @root.ancestors.empty?
+    assert_equal [@root], @parent.ancestors
+    assert_equal [@root, @parent], @a.ancestors
+    assert_equal [@root, @parent, @a], @a1.ancestors
+  end
+
+  def ancestry_for(section_or_page)
+    "#{section_or_page.ancestry}/#{section_or_page.node.id}"
+  end
+end
+
+class SitemapNavTest < ActiveSupport::TestCase
+
+  def setup
+    given_a_site_exists
+    @page = Factory(:public_page, :section=>root_section)
+    @link = Factory(:link, :section=>root_section)
+  end
+
+  test "access_status" do
+    assert_equal @page.section.status, @page.access_status
+    assert_equal @link.section.status, @link.access_status
+  end
+
+end
+class SitemapTest < ActiveSupport::TestCase
+
+  def setup
+
+  end
+
+  def teardown
+  end
+
+  test "ancestry_path" do
+    section = Factory(:public_section)
+    assert_equal "#{section.parent.node.id}/#{section.node.id}", section.node.ancestry_path
+  end
+  test "Build root section from factory" do
+    root = Factory(:root_section)
+    assert_not_nil root
+    assert root.root?
+  end
+
+  test "Build section with parent = root_section from factory" do
+    section = Factory(:public_section)
+    assert_not_nil section
+    assert_equal false, section.root?
+    assert_equal true, section.parent.root?
+  end
+
+  test "Section has parent based on ancestry" do
+    s = Section.create!(:name=>"A", :parent=>root, :path=>"/a")
+    assert_equal "#{root.node.id}", s.ancestry
+  end
+
+
+  test "Assign Parent sections" do
+    child_section = SectionNode.create!(:parent => root.node)
+    assert_equal "#{root.node.id}", child_section.ancestry
+    assert_equal root.node, child_section.parent
+  end
+
+  test "Each Section has a section node (even the root one)" do
+    r = root
+    assert_not_nil r.node
+    assert_nil r.node.ancestry
+  end
+
+  test "child_nodes" do
+    page = Factory(:page, :section=>root)
+    section = Factory :public_section, :parent=>root
+
+    assert_equal [page.section_node, section.node], root.child_nodes
+  end
+
+  test "pages" do
+    page1 = Factory(:page, :section=>root)
+    page2 = Factory(:page, :section=>root)
+    section = Factory :public_section, :parent=>root
+
+    assert_equal [page1, page2], root.pages
+  end
+
+  test "child_sections" do
+    page1 = Factory(:page, :section=>root)
+    page2 = Factory(:page, :section=>root)
+    section = Factory :public_section, :parent=>root
+
+    assert_equal [section], root.child_sections
+  end
+
+  test "Order of pages should be unique within each section" do
+    page = Factory(:page, :section=>root)
+    assert_equal 1, page.section_node.position
+
+    subsection = Factory(:section, :parent=>root)
+    page3 = Factory(:page, :section=>subsection)
+    log_table_without_stamps(SectionNode)
+    assert_equal 1, page3.section_node.position
+  end
+
+  test "The root section node has no parent section" do
+    assert_nil SectionNode.new.parent_section
+  end
+
+    private
+
+  def root
+    @root ||= Factory(:root_section)
+  end
+end

data/test/unit/models/attachment_test.rb

@@ -58,39 +58,59 @@ class AttachmentTest < ActiveSupport::TestCase
     assert_not_equal original_file_location, attachment.as_of_draft_version.file_location
     assert_equal "This is a new file", open(attachment.as_of_draft_version.full_file_location){|f| f.read}  
   end
-  
-  def test_find_live_by_file_path
-    file = ActionController::UploadedTempfile.new("foo.txt")
-    open(file.path, 'w') {|f| f << "This is a file"}
-    file.original_path = "bar.txt"
-    file.content_type = "text/plain"
-    attachment = Attachment.new(:temp_file => file, :file_path => "/foo.txt", :section => root_section)
-    attachment.save!
-    assert !attachment.published?, "Attachment should not be published"
+
+end
+
+class AttachmentRelations < ActiveSupport::TestCase
+
+  def setup
+    @file = ActionController::UploadedTempfile.new("foo.txt")
+    open(@file.path, 'w') {|f| f << "This is a file"}
+    @file.original_path = "bar.txt"
+    @file.content_type = "text/plain"
+    @attachment = Attachment.new(:temp_file => @file, :file_path => "/foo.txt", :section => root)
+    @attachment.save!
+  end
+
+  test "New Attachment" do
+    a = Attachment.new
+    a.section = root
+    assert_equal root, a.section
+  end
+
+  test "Attachments should be associated with a section" do
+    assert_not_nil @attachment.section_node
+    assert_not_nil @attachment.section_node.parent
+    assert_equal root, @attachment.section
+  end
+
+  test "Attachment should be unpublished and unfindable" do
+    assert !@attachment.published?, "Attachment should not be published"
     assert_nil Attachment.find_live_by_file_path("/foo.txt")
-    
-    attachment.publish
-    assert attachment.reload.published?, "Attachment should be published"
-    assert_equal attachment, Attachment.find_live_by_file_path("/foo.txt")
-    
-    attachment.update_attributes(:file_type => "text/html")
-    assert !attachment.live?, "Attachment should not be live"
-    assert_equal attachment.as_of_version(2), Attachment.find_live_by_file_path("/foo.txt")    
   end
-  
-  def test_update_attachment_section
-    file = ActionController::UploadedTempfile.new("foo.txt")
-    open(file.path, 'w') {|f| f << "This is a file"}
-    file.original_path = "bar.txt"
-    file.content_type = "text/plain"
-    attachment = Attachment.new(:temp_file => file, :file_path => "/foo.txt", :section => root_section)
-    attachment.save!
 
+  test "Publishing an attachment should make it findable" do
+    @attachment.publish
+    assert @attachment.reload.published?, "Attachment should be published"
+    assert_equal @attachment, Attachment.find_live_by_file_path("/foo.txt")
+  end
+
+  test "Changing but not republishing an attachment should keep old version live" do
+    @attachment.publish
+    assert_equal @root, @attachment.section
+    @attachment.update_attributes!(:file_type => "text/html")
+    assert !@attachment.live?, "Attachment should not be live"
+    assert_equal @attachment.as_of_version(2), Attachment.find_live_by_file_path("/foo.txt")
+  end
+
+  test "Updating the section" do
     new_section = Factory(:section, :name => "New")
-    assert_equal root_section, attachment.section
-    
-    attachment.update_attributes!(:section => new_section)
-    assert_equal new_section, attachment.section
+    @attachment.update_attributes!(:section => new_section)
+    assert_equal new_section, @attachment.section
   end
-  
-end
+  private
+
+  def root
+    @root ||= Factory :root_section
+  end
+end

data/test/unit/models/file_block_test.rb

@@ -1,61 +1,63 @@
 require File.join(File.dirname(__FILE__), '/../../test_helper')
 
 class FileBlockTest < ActiveSupport::TestCase
+
   def setup
+    @root = Factory :root_section
     #@file is a mock of the object that Rails wraps file uploads in
     @file = file_upload_object(:original_filename => "foo.jpg",
-      :content_type => "image/jpeg", :rewind => true,
-      :size => "99", :read => "01010010101010101")
-    @file_block = Factory.build(:file_block, :attachment_file => @file, :attachment_section => root_section, :attachment_file_path => "/test.jpg", :publish_on_save => true)
+                               :content_type => "image/jpeg", :rewind => true,
+                               :size => "99", :read => "01010010101010101")
+    @file_block = Factory.build(:file_block, :attachment_file => @file, :attachment_section => @root, :attachment_file_path => "/test.jpg", :publish_on_save => true)
   end
-  
+
   def test_attachment_is_required
     @file_block.attachment_file = nil
     assert !@file_block.valid?
     assert_equal "You must upload a file", @file_block.errors.on(:attachment_file)
   end
-  
+
   def test_attachment_file_path_is_required
     @file_block.attachment_file_path = nil
     assert !@file_block.valid?
     assert_equal "File Name is required for attachment", @file_block.errors.on(:attachment_file_path)
   end
-  
+
   def test_no_leading_slash_in_file_path
     @file_block.attachment_file_path = "test.jpg"
     assert @file_block.save
     assert_equal "/test.jpg", @file_block.path
   end
-  
+
   def test_create_attachment
     assert @file_block.save
     assert !@file_block.attachment.nil?
     assert "image/jpeg", @file_block.attachment.file_type
     assert_equal "/test.jpg", @file_block.path
     assert_equal 1, @file_block.attachment_version
-    assert_equal root_section, @file_block.attachment.section
+    assert_equal @root, @file_block.attachment.section
   end
-  
+
   def test_reverting
     assert @file_block.save
     assert "/test.jpg", @file_block.attachment_file_path
     assert "01010010101010101", File.read(@file_block.attachment.full_file_location)
-    
+
     attachment_id = @file_block.attachment_id
     new_file = file_upload_object(:original_filename => "foo.jpg",
-      :content_type => "image/jpeg", :rewind => true,
-      :size => "99", :read => "10100101010101010")
-    
+                                  :content_type => "image/jpeg", :rewind => true,
+                                  :size => "99", :read => "10100101010101010")
+
     @file_block.update_attributes(:attachment_file => new_file, :publish_on_save => true)
     reset(:file_block)
-    
+
     assert @file_block.save
     assert 2, @file_block.version
     assert attachment_id, @file_block.attachment_id
-    assert 2, @file_block.attachment_version    
+    assert 2, @file_block.attachment_version
     assert "/test.jpg", @file_block.attachment_file_path
     assert "10100101010101010", File.read(@file_block.attachment.full_file_location)
-    
+
     @file_block.revert_to(1)
     reset(:file_block)
 
@@ -67,38 +69,38 @@ class FileBlockTest < ActiveSupport::TestCase
     assert "/test.jpg", @file_block.attachment_file_path
     assert "01010010101010101", File.read(@file_block.attachment.full_file_location)
     assert "10100101010101010", File.read(@file_block.as_of_draft_version.attachment.full_file_location)
-    
+
   end
-  
+
 end
 
 class UpdatingFileBlockTest < ActiveSupport::TestCase
   def setup
     @file_block = Factory(:file_block,
-      :attachment_section => root_section,
-      :attachment_file_path => "/test.jpg",
-      :attachment_file => mock_file(:read => "original"),
-      :name => "Test",
-      :publish_on_save => true)
+                          :attachment_section => root_section,
+                          :attachment_file_path => "/test.jpg",
+                          :attachment_file => mock_file(:read => "original"),
+                          :name => "Test",
+                          :publish_on_save => true)
     reset(:file_block)
     @attachment = @file_block.attachment
   end
-  
+
   def test_change_attachment_file_name
     attachment_version = @attachment.version
     file_attachment_version = @file_block.attachment_version
     attachment_version_count = Attachment::Version.count
-    
+
     assert @file_block.update_attributes(
-      :attachment_file_path => "test_new.jpg",
-      :attachment_file => nil,
-      :publish_on_save => true)
-    
+               :attachment_file_path => "test_new.jpg",
+               :attachment_file => nil,
+               :publish_on_save => true)
+
     assert_incremented attachment_version, @attachment.reload.version
     assert_incremented file_attachment_version, @file_block.attachment_version
     assert_incremented attachment_version_count, Attachment::Version.count
-  end  
-  
+  end
+
   def test_change_attachment_section
     attachment_version_count = Attachment::Version.count
     file_block_version = @file_block.version
@@ -106,13 +108,13 @@ class UpdatingFileBlockTest < ActiveSupport::TestCase
     @section = Factory(:section, :parent => root_section, :name => "New")
     @file_block.update_attributes!(:attachment_section => @section, :publish_on_save => true)
 
-    assert_incremented attachment_version_count, Attachment::Version.count
     assert_incremented file_block_version, @file_block.reload.version
+    assert_incremented attachment_version_count, Attachment::Version.count
     assert_equal @section, @file_block.attachment_section
     assert_equal "/test.jpg", @file_block.attachment.file_path
     assert_equal "test.jpg", @file_block.attachment.file_name
-  end  
-  
+  end
+
   def test_change_attachment_data_with_save
     attachment_count = Attachment.count
     attachment_version_count = Attachment::Version.count
@@ -120,15 +122,15 @@ class UpdatingFileBlockTest < ActiveSupport::TestCase
 
     @section = Factory(:section, :parent => root_section, :name => "New")
     @file_block.update_attributes!(:attachment_file => mock_file(:read => "new"))
-    
+
     assert_equal attachment_count, Attachment.count
     assert_incremented attachment_version_count, Attachment::Version.count
     assert_incremented file_block_version, @file_block.draft.version
-    assert_equal "new", open(@file_block.as_of_draft_version.attachment.full_file_location){|f| f.read}
+    assert_equal "new", open(@file_block.as_of_draft_version.attachment.full_file_location) { |f| f.read }
     assert !@file_block.live?
     assert !@file_block.attachment.live?
   end
-  
+
   def test_change_attachment_data_with_save_and_publish
     attachment_count = Attachment.count
     attachment_version_count = Attachment::Version.count
@@ -136,76 +138,93 @@ class UpdatingFileBlockTest < ActiveSupport::TestCase
 
     @section = Factory(:section, :parent => root_section, :name => "New")
     @file_block.update_attributes!(:attachment_file => mock_file(:read => "new"), :publish_on_save => true)
-    
+
     assert_equal attachment_count, Attachment.count
     assert_incremented attachment_version_count, Attachment::Version.count
     assert_incremented file_block_version, @file_block.reload.version
-    assert_equal "new", open(@file_block.attachment.full_file_location){|f| f.read}
+    assert_equal "new", open(@file_block.attachment.full_file_location) { |f| f.read }
     assert @file_block.published?
     assert @file_block.attachment.published?
   end
-  
+
   def test_no_changes_to_the_attachment
     attachment_count = Attachment.count
     attachment_version_count = Attachment::Version.count
     file_block_version = @file_block.version
-    
+
     @file_block.update_attributes!(:name => "Test 2", :publish_on_save => true)
-    
+
     assert_equal attachment_count, Attachment.count
     assert_equal attachment_version_count, Attachment::Version.count
     assert_incremented file_block_version, @file_block.reload.version
     assert_equal "Test 2", @file_block.name
   end
-  
+
 end
 
 class ViewingOlderVersionOfFileTest < ActiveSupport::TestCase
-  
+
   def test_that_it_shows_the_correct_content
-    @file1 = mock_file(:content_type => "text/plain", :read => "v1")      
+    @file1 = mock_file(:content_type => "text/plain", :read => "v1")
     @file2 = mock_file(:content_type => "text/plain", :read => "v2")
     @file_block = Factory(:file_block, :attachment_file => @file1, :attachment_file_path => "/test.txt", :attachment_section => root_section)
     @file_block.update_attributes(:attachment_file => @file2)
     #reset(:file_block)            
-    assert_equal "v1", open(@file_block.as_of_version(1).attachment.full_file_location){|f| f.read}
+    assert_equal "v1", open(@file_block.as_of_version(1).attachment.full_file_location) { |f| f.read }
   end
-  
+
 end
 
 class ExistingFileBlockTest < ActiveSupport::TestCase
   def setup
-    @file_block = Factory(:file_block, :attachment_file => mock_file, :attachment_file_path => "/test.txt", :attachment_section => root_section)
+    @file_block = Factory(:file_block, :attachment_file => mock_file, :attachment_file_path => "/test.txt", :attachment_section => Factory(:root_section))
   end
-  
+
   def test_archiving
-    assert @file_block.update_attributes(:archived => true)
+    assert @file_block.update_attributes!(:archived => true)
     assert @file_block.attachment.archived?
   end
-  
+
   def test_destroy
-    @file_block.destroy      
+    @file_block.destroy
     assert_nil Attachment.find_live_by_file_path("/test.txt")
   end
 end
 
 class ExistingFileBlocksTest < ActiveSupport::TestCase
   def setup
-    @one = Factory(:file_block, :attachment_file => mock_file, :attachment_file_path => "/one.txt", :attachment_section => root_section)
+    @one = Factory(:file_block, :attachment_file => mock_file, :attachment_file_path => "/one.txt", :attachment_section => root_section, :name=>"One")
     @two = Factory(:file_block, :attachment_file => mock_file, :attachment_file_path => "/two.txt", :attachment_section => root_section)
     @section = Factory(:section, :name => "A")
     @a1 = Factory(:file_block, :attachment_file => mock_file, :attachment_file_path => "/a/1.txt", :attachment_section => @section)
     @a2 = Factory(:file_block, :attachment_file => mock_file, :attachment_file_path => "/2.txt", :attachment_section => @section)
     #reset(:one, :two, :a1, :a2)
   end
-  
+
   def test_find_blocks_in_root_section
     assert_equal [@one, @two], FileBlock.by_section(root_section).all(:order => "file_blocks.id")
   end
-  
+
   def test_find_blocks_in_sub_section
     assert_equal [@a1, @a2], FileBlock.by_section(@section).all(:order => "file_blocks.id")
   end
+
+   test "searchable?" do
+    assert FileBlock.searchable?
+  end
+
+  test "search by name" do
+    assert_equal [@one], FileBlock.search("one")
+  end
+
+  test "search by section" do
+    options = {}
+    options[:page] = 1
+    options[:include] = { :attachment =>  :section_node }
+    options[:conditions] = ["section_nodes.ancestry = ?", root_section.ancestry_path]
+
+    assert_equal [@one, @two], FileBlock.search("").paginate(options)
+  end
 end