browsercms 3.4.2 → 3.5.0.rc1

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 = Cms::User.new()
-
-    c = ProtectedController.new
-    c.expects(:session).returns({})
-
-    c.send(:current_user=, u)
-
-    assert_equal u, Cms::User.current
-  end
-end

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

@@ -1,119 +0,0 @@
-require "test_helper"
-
-module Cms
-  class CoreContentBlock
-    include EngineHelper
-  end
-end
-
-class MainAppThing
-  include Cms::EngineHelper
-end
-
-class NewThing
-
-end
-
-module BcmsWidgets
-  class Engine < Rails::Engine
-  end
-  class ContentBlock
-    include Cms::EngineHelper
-  end
-end
-
-class BcmsParts
-  class ContentThing
-    include Cms::EngineHelper
-  end
-end
-module Cms
-  class EngineHelperTest < ActiveSupport::TestCase
-
-    def setup
-      @cms_block = Cms::CoreContentBlock.new
-      @main_app_block = MainAppThing.new
-    end
-
-    test "main_app?" do
-      assert_equal true, @main_app_block.main_app_model?
-      assert_equal false, @cms_block.main_app_model?
-      assert_equal false, BcmsWidgets::ContentBlock.new.main_app_model?
-    end
-
-    test "If there is no Engine, engine_name should be the main app." do
-      assert_equal "main_app", BcmsParts::ContentThing.new.engine_name
-    end
-
-    test "Module Name" do
-      assert_equal "Cms", EngineHelper.module_name(Cms::CoreContentBlock)
-      assert_nil EngineHelper.module_name(NewThing)
-      assert_equal "BcmsWidgets", EngineHelper.module_name(BcmsWidgets::ContentBlock)
-    end
-
-    test "path_for_widget" do
-      name = BcmsWidgets::ContentBlock.new.engine_name
-      assert_not_nil name
-      assert_equal BcmsWidgets::Engine.engine_name, name
-    end
-
-    test "Decorate" do
-      n = NewThing.new
-      EngineHelper.decorate(n)
-      assert_equal true, n.respond_to?(:engine_name)
-    end
-
-    test "Decorate class" do
-      EngineHelper.decorate(NewThing)
-      assert_equal true, NewThing.respond_to?(:engine_name)
-    end
-
-    test "Don't decorate twice'" do
-      class DecorateOnce
-        include EngineHelper
-
-        def engine_name
-          "Original"
-        end
-      end
-      subject = DecorateOnce.new
-      EngineHelper.decorate(subject)
-      assert_equal "Original", subject.engine_name
-
-    end
-    test "Engine Name" do
-      assert_equal "cms", Cms::Engine.engine_name
-    end
-
-    test "calculate engine_name" do
-      assert_equal "cms", Cms::CoreContentBlock.new.engine_name
-    end
-
-    test "Blocks without namespace should be in main app" do
-      assert_equal "main_app", MainAppThing.new.engine_name
-    end
-
-    test "path_elements for an instance of a class in an application" do
-      assert_equal ["cms", @main_app_block], @main_app_block.path_elements
-    end
-
-    test "path_elements for a class in an application" do
-      MainAppThing.extend EngineHelper
-      assert_equal ["cms", MainAppThing], MainAppThing.path_elements
-    end
-
-    test "path_elements for an instance of in Cms namespace" do
-      assert_equal [@cms_block], @cms_block.path_elements
-    end
-
-    test "path_elements for a class in Cms namespace" do
-      Cms::CoreContentBlock.extend EngineHelper
-      assert_equal [Cms::CoreContentBlock], Cms::CoreContentBlock.path_elements
-    end
-
-    test "path_elements for a class in a module" do
-      BcmsWidgets::ContentBlock.extend EngineHelper
-      assert_equal [BcmsWidgets::ContentBlock], BcmsWidgets::ContentBlock.path_elements
-    end
-  end
-end

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

@@ -1,210 +0,0 @@
-require "test_helper"
-
-module Cms
-  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 => "Cms::Section", :node_id => @a.id, :position => 1)
-      assert_properties(@node_b, :ancestry => ancestry_for(@parent), :node_type => "Cms::Section", :node_id => @b.id, :position => 2)
-      assert_properties(@node_a1, :ancestry => ancestry_for(@a), :node_type => "Cms::Page", :node_id => @a1.id, :position => 2)
-      assert_properties(@node_a2, :ancestry => ancestry_for(@a), :node_type => "Cms::Page", :node_id => @a2.id, :position => 1)
-      assert_properties(@node_a3, :ancestry => ancestry_for(@a), :node_type => "Cms::Page", :node_id => @a3.id, :position => 3)
-      assert_properties(@node_b1, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @b1.id, :position => 1)
-      assert_properties(@node_b2, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @b2.id, :position => 2)
-      assert_properties(@node_b3, :ancestry => ancestry_for(@b), :node_type => "Cms::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 => "Cms::Section", :node_id => @a.id, :position => 1)
-      assert_properties(@node_b, :ancestry => ancestry_for(@parent), :node_type => "Cms::Section", :node_id => @b.id, :position => 2)
-      assert_properties(@node_a1, :ancestry => ancestry_for(@a), :node_type => "Cms::Page", :node_id => @a1.id, :position => 1)
-      assert_properties(@node_a2, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @a2.id, :position => 2)
-      assert_properties(@node_a3, :ancestry => ancestry_for(@a), :node_type => "Cms::Page", :node_id => @a3.id, :position => 2)
-      assert_properties(@node_b1, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @b1.id, :position => 1)
-      assert_properties(@node_b2, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @b2.id, :position => 3)
-      assert_properties(@node_b3, :ancestry => ancestry_for(@b), :node_type => "Cms::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 => "Cms::Section", :node_id => @a.id, :position => 1)
-      assert_properties(@node_b, :ancestry => ancestry_for(@parent), :node_type => "Cms::Section", :node_id => @b.id, :position => 2)
-      assert_properties(@node_a1, :ancestry => ancestry_for(@a), :node_type => "Cms::Page", :node_id => @a1.id, :position => 1)
-      assert_properties(@node_a2, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @a2.id, :position => 1)
-      assert_properties(@node_a3, :ancestry => ancestry_for(@a), :node_type => "Cms::Page", :node_id => @a3.id, :position => 2)
-      assert_properties(@node_b1, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @b1.id, :position => 2)
-      assert_properties(@node_b2, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @b2.id, :position => 3)
-      assert_properties(@node_b3, :ancestry => ancestry_for(@b), :node_type => "Cms::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 => "Cms::Section", :node_id => @a.id, :position => 1)
-      assert_properties(@node_b, :ancestry => ancestry_for(@parent), :node_type => "Cms::Section", :node_id => @b.id, :position => 2)
-      assert_properties(@node_a1, :ancestry => ancestry_for(@a), :node_type => "Cms::Page", :node_id => @a1.id, :position => 1)
-      assert_properties(@node_a2, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @a2.id, :position => 4)
-      assert_properties(@node_a3, :ancestry => ancestry_for(@a), :node_type => "Cms::Page", :node_id => @a3.id, :position => 2)
-      assert_properties(@node_b1, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @b1.id, :position => 1)
-      assert_properties(@node_b2, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @b2.id, :position => 2)
-      assert_properties(@node_b3, :ancestry => ancestry_for(@b), :node_type => "Cms::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 => "Cms::Section", :node_id => @a.id, :position => 1)
-      assert_properties(@node_b, :ancestry => ancestry_for(@parent), :node_type => "Cms::Section", :node_id => @b.id, :position => 2)
-      assert_properties(@node_a1, :ancestry => ancestry_for(@a), :node_type => "Cms::Page", :node_id => @a1.id, :position => 1)
-      assert_properties(@node_a2, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @a2.id, :position => 4)
-      assert_properties(@node_a3, :ancestry => ancestry_for(@a), :node_type => "Cms::Page", :node_id => @a3.id, :position => 2)
-      assert_properties(@node_b1, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @b1.id, :position => 1)
-      assert_properties(@node_b2, :ancestry => ancestry_for(@b), :node_type => "Cms::Page", :node_id => @b2.id, :position => 2)
-      assert_properties(@node_b3, :ancestry => ancestry_for(@b), :node_type => "Cms::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
-end

data/test/unit/lib/cms_domain_support_test.rb

@@ -1,44 +0,0 @@
-require '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