browsercms 3.1.5 → 3.3.0.beta

data/test/unit/lib/acts_as_content_page_test.rb

@@ -1,72 +0,0 @@
-require "test_helper"
-require "mocha"
-
-class CmsActsAsContentPageTest < ActiveSupport::TestCase
-  EXPECTED_SECTION = "/members"
-
-  class MyController < ActionController::Base
-    include Cms::Acts::ContentPage
-    requires_permission_for_section EXPECTED_SECTION
-  end
-
-  test "Arbitrary controller should have authentication methods" do
-    c = MyController.new
-
-    assert c.respond_to? :handle_access_denied_on_page
-    assert c.respond_to? :handle_not_found_on_page
-    assert c.respond_to? :handle_server_error_on_page
-    assert c.respond_to? :handle_error_with_cms_page, true
-
-    assert(c.respond_to?(:logged_in?), "Should include Cms::Authentication::Controller methods")
-    assert(c.respond_to?(:handle_server_error), "Should include Cms::ErrorHandling methods")
-
-    assert(MyController.respond_to?(:requires_permission_for_section), "Should add ClassMethods to the controller.")
-  end
-
-  test "check_access_to_section_filter" do
-    mock_user = mock()
-    mock_user.expects(:able_to_view?).with(EXPECTED_SECTION).returns(true)
-    mock_user.expects(:login).returns("mock_user_name")
-    c = MyController.new
-    c.expects(:current_user).returns(mock_user)
-
-
-    c.check_access_to_section
-
-
-  end
-
-  test "sets section in startup" do
-    class AController < ActionController::Base
-      include Cms::Acts::ContentPage
-      requires_permission_for_section EXPECTED_SECTION
-    end
-
-    assert_equal EXPECTED_SECTION, AController.in_section
-  end
-
-  class NewController < ActionController::Base
-      include Cms::Acts::ContentPage
-  end
-
-  test "placing in a section should create a before_filter for that section for all actions" do
-    NewController.expects(:before_filter).with(:check_access_to_section, {})
-
-    NewController.send :requires_permission_for_section, EXPECTED_SECTION
-
-  end
-
-  test "can put only conditions on filters" do
-    NewController.expects(:before_filter).with(:check_access_to_section, :only=>[:create])
-
-    NewController.send :requires_permission_for_section, EXPECTED_SECTION, :only=>[:create]
-  end
-
-  test "can put except conditions on filters" do
-    NewController.expects(:before_filter).with(:check_access_to_section, :except=>[:create])
-
-    NewController.send :requires_permission_for_section, EXPECTED_SECTION, :except=>[:create]
-  end
-
-
-end

data/test/unit/lib/cms/authentication/controller_test.rb

@@ -1,20 +0,0 @@
-require "test_helper"
-require 'mocha'
-
-class ProtectedController < ActionController::Base
-  include Cms::Authentication::Controller
-end
-
-class ControllerTest < ActiveSupport::TestCase
-
-  test "Sets current user in thread local" do
-    u = User.new()
-
-    c = ProtectedController.new
-    c.expects(:session).returns({})
-
-    c.send(:current_user=, u)
-
-    assert_equal u, User.current
-  end
-end

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

@@ -1,206 +0,0 @@
-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/lib/cms_domain_support_test.rb

@@ -1,43 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../test_helper')
-require 'mocha'
-
-class CmsDomainSupportTest < ActiveSupport::TestCase
-
-  def setup
-
-  end
-
-  def teardown
-
-  end
-
-  test "cms_site? determines if the first subdomain is 'cms'" do
-    c = Cms::ApplicationController.new
-    request = mock
-
-    c.expects(:request).returns(request)
-    request.expects(:subdomains).returns(["cms"])
-
-    assert c.send :cms_site?
-  end
-
-   test "A url that isn't a cms domain" do
-    c = Cms::ApplicationController.new
-    request = mock
-
-    c.expects(:request).returns(request)
-    request.expects(:subdomains).returns(["www"])
-
-    assert_equal false, c.send(:cms_site?)
-   end
-
-  test "default cms domain" do
-    c = Cms::ApplicationController.new
-
-    assert_equal "cms", c.send(:cms_domain_prefix)
-  end
-
-  test "prepare_for_rendererable" do
-        
-  end
-end

data/test/unit/lib/command_line_test.rb

@@ -1,70 +0,0 @@
-require "test_helper"
-require "mocha"
-
-class CommandLineTest < ActiveSupport::TestCase
-
-  test "Use the correct demo template with '-m demo'" do
-    CommandLine.expects(:template).with("demo.rb").returns("./templates/demo.rb")
-    args = ["-m", "demo"]
-
-    CommandLine.set_template(args)
-
-    assert_equal ["-m", "./templates/demo.rb"], args
-  end
-
-  test "template_file looks up files based on the current directory" do
-    CommandLine.expects(:template_dir).returns("./templates")
-
-    assert_equal "./templates/bar.rb", CommandLine.template("bar.rb")
-  end
-
-  test "ARGV gets replaced" do
-    CommandLine.expects(:template).with("demo.rb").returns("./templates/demo.rb")
-    ARGV = ["-m", "demo"]
-
-    CommandLine.set_template(ARGV)
-
-    assert_equal ["-m", "./templates/demo.rb"], ARGV
-  end
-
-  test "Sets blank template if empty" do
-    CommandLine.expects(:template).with("blank.rb").returns("./templates/blank.rb")
-    args = []
-
-    CommandLine.set_template(args)
-
-    assert_equal ["-m", "./templates/blank.rb"], args
-  end
-
-  test "Sets module template with -m" do
-    CommandLine.expects(:template).with("module.rb").returns("./templates/module.rb")
-    args = ["-m", "module"]
-
-    CommandLine.set_template(args)
-
-    assert_equal ["-m", "./templates/module.rb"], args
-  end
-
-  test "Sets the module template with --template" do
-    CommandLine.expects(:template).with("module.rb").returns("./templates/module.rb")
-    args = ["--template", "module"]
-
-    CommandLine.set_template(args)
-
-    assert_equal ["--template", "./templates/module.rb"], args 
-  end
-
-  test "Sets the demo template with --template" do
-    CommandLine.expects(:template).with("demo.rb").returns("./templates/demo.rb")
-    args = ["--template", "demo"]
-
-    CommandLine.set_template(args)
-
-    assert_equal ["--template", "./templates/demo.rb"], args
-  end
-
-  test "Set usage" do
-    
-  end
-
-end

data/test/unit/lib/content_block_test.rb

@@ -1,203 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../test_helper')
-
-class ContentBlockTest < ActiveSupport::TestCase
-  def setup
-    @block = Factory(:html_block, :name => "Test")   
-  end
-  
-  def test_publishing
-    assert_equal "Draft", @block.status_name
-    assert !@block.published?
-
-    @block.publish
-    assert @block.published?
-
-    @block.publish_on_save = true
-    @block.save
-    
-    assert @block.published?
-
-    assert @block.update_attributes(:name => "Whatever")
-    
-    assert !@block.live?
-    
-  end
-
-  def test_revision_comment_on_create
-    assert_equal 'Created', @block.draft.version_comment
-  end
-
-  def test_revision_comment_on_update
-    assert @block.update_attributes(:name => "Something Else", :content => "Whatever")
-    assert_equal 'Changed content, name', @block.draft.version_comment
-  end
-
-  def test_revision_comment_without_changes
-    assert @block.update_attributes(:name => @block.name)
-    assert_equal 'Created', @block.draft.version_comment
-  end
-
-  def test_custom_revision_comment
-    assert @block.update_attributes(:name => "Something Else", :version_comment => "Something Changed")
-    assert_equal "Something Changed", @block.draft.version_comment
-  end
-  
-  def test_destroy
-    html_block_count = HtmlBlock.count
-    assert_equal 1, @block.versions.size
-    assert !@block.deleted?
-    
-    @block.destroy
-
-    assert !HtmlBlock.exists?(@block.id)
-    assert !HtmlBlock.exists?(["name = ?", @block.name])
-    assert_decremented html_block_count, HtmlBlock.count
-    assert_raise(ActiveRecord::RecordNotFound) { HtmlBlock.find(@b) }
-    assert_nil HtmlBlock.find_by_name(@block.name)
-
-    deleted_block = HtmlBlock.find_with_deleted(@block.id)
-    assert_equal 2, deleted_block.versions.size
-    assert_equal 2, deleted_block.version
-    assert_equal 1, deleted_block.versions.first.version
-    assert_equal 2, HtmlBlock::Version.count(:conditions => {:html_block_id => @block.id})
-  end  
-  
-  def test_delete_all
-    HtmlBlock.delete_all(["name = ?", @block.name])
-    assert_raise(ActiveRecord::RecordNotFound) { HtmlBlock.find(@block.id) }
-    assert HtmlBlock.find_with_deleted(@block.id).deleted?
-  end
-  
-end
-
-class VersionedContentBlock < ActiveSupport::TestCase
-  def setup
-    @block = Factory(:html_block, :name => "Versioned Content Block")
-  end  
-
-  def test_edit
-    old_name = "Versioned Content Block"
-    new_name  = "New version of content block"
-    @block.publish!
-    @block.reload
-    assert_equal @block.draft.name, old_name
-    @block.name = new_name
-    @block.save
-    @block.reload
-    assert_equal @block.draft.name, new_name
-    @block.name = old_name
-    @block.save
-    @block.reload
-    assert_equal @block.draft.name, old_name    
-  end
-
-  def test_revert
-    old_name = "Versioned Content Block"
-    new_name  = "New version of content block"
-    @block.publish!
-    @block.reload
-    assert_equal @block.draft.name, old_name
-    version = @block.version
-    @block.name = new_name
-    @block.save
-    @block.reload
-    assert_equal @block.draft.name, new_name
-    @block.revert_to(version)
-    @block.reload
-    assert_equal @block.draft.name, old_name
-  end
-
-end
-
-class VersionedContentBlockConnectedToAPageTest < ActiveSupport::TestCase
-  def setup
-    @page = Factory(:page, :section => root_section)
-    @block = Factory(:html_block, :name => "Versioned Content Block")
-    @page.create_connector(@block, "main")
-    reset(:page, :block)    
-  end  
-  
-  def test_editing_connected_to_an_unpublished_page
-    page_version_count = Page::Version.count
-    assert !@page.published?
-    
-    assert @block.update_attributes(:name => "something different")
-    reset(:page)
-    
-    assert !@page.published?
-    assert_equal 3, @page.draft.version
-    assert_incremented page_version_count, Page::Version.count
-    assert_match /^HtmlBlock #\d+ was Edited/, @page.draft.version_comment
-
-    conns = @block.connectors.all(:order => 'id')
-    assert_equal 2, conns.size
-    assert_properties conns[0], :page => @page, :page_version => 2, :connectable => @block, :connectable_version => 1, :container => "main"
-    assert_properties conns[1], :page => @page, :page_version => 3, :connectable => @block, :connectable_version => 2, :container => "main"
-  end
-  
-  def test_editing_connected_to_a_published_page
-    @page.publish!
-    reset(:page, :block)
-    
-    assert @page.published?
-    assert @block.update_attributes(:name => "something different", :publish_on_save => true)
-    reset(:page)
-    
-    assert @page.published?
-  end  
-  
-  def test_deleting_when_connected_to_page
-    @page.publish!
-    reset(:page, :block)
-
-    page_connector_count = @page.connectors.for_page_version(@page.draft.version).count
-    page_version = @page.draft.version
-
-    @block.destroy
-
-    reset(:page)
-
-    assert_decremented page_connector_count, @page.connectors.for_page_version(@page.draft.version).count
-    assert_incremented page_version, @page.draft.version
-    assert_match /^HtmlBlock #\d+ was Deleted/, @page.draft.version_comment
-  end  
-  
-end
-
-class NonVersionedContentBlockConnectedToAPageTest < ActiveSupport::TestCase
-  def setup
-    @page = Factory(:page, :section => root_section)
-    @block = DynamicPortlet.create!(:name => "Non-Versioned Content Block")
-    @page.create_connector(@block, "main")
-    reset(:page, :block)    
-  end
-
-  def test_editing_connected_to_an_unpublished_page
-    page_version_count = Page::Version.count
-
-    assert_equal "Dynamic Portlet 'Non-Versioned Content Block' was added to the 'main' container", @page.draft.version_comment
-    assert !@page.published?
-
-    assert @block.update_attributes(:name => "something different", :publish_on_save => true)
-    reset(:page)
-    
-    assert 2, @page.version
-    assert_equal page_version_count, Page::Version.count
-    assert !@page.published?
-    
-    conns = Connector.for_connectable(@block).all(:order => 'id')
-    assert_equal 1, conns.size
-    assert_properties conns[0], :page => @page, :page_version => 2, :connectable => @block, :connectable_version => nil, :container => "main"
-  end
-    
-  def test_editing_connected_to_a_published_page
-    @page.publish!
-    reset(:page)
-    
-    assert @page.published?
-    assert @block.update_attributes(:name => "something different", :publish_on_save => true)
-    reset(:page)
-    
-    assert @page.published?
-  end  
-end