browsercms 3.3.4 → 3.4.0.rc1

data/test/unit/models/group_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+class GroupTest < ActiveSupport::TestCase
+
+  def setup
+    given_there_is_a_guest_group
+  end
+
+  def test_valid
+    assert Factory.build(:group).valid?
+  end
+
+  test "Find guest group via method" do
+    expected = Cms::Group.find_by_code(Cms::Group::GUEST_CODE)
+    assert_not_nil expected
+    assert_equal expected, Cms::Group.guest
+  end
+
+  test "has_permission?" do
+    p1 = Factory(:permission, :name=>"Edit Things")
+    p2 = Factory(:permission, :name=>"Delete things")
+
+    group = Factory.build(:group)
+    group.permissions << p1
+
+    assert group.has_permission?("Edit Things")
+    assert !group.has_permission?("Delete things")
+  end
+end

data/test/unit/models/html_block_test.rb

@@ -0,0 +1,121 @@
+require 'test_helper'
+
+class HtmlBlockTest < ActiveSupport::TestCase
+
+  test "template_path" do
+    assert_equal "cms/html_blocks/render", Cms::HtmlBlock.template_path
+  end
+
+  test "default table_name" do
+    assert_equal Cms::Namespacing.prefix("html_blocks"), Cms::HtmlBlock.table_name
+  end
+
+  test "form" do
+    type = Cms::ContentType.new(:name=>"Cms::HtmlBlock")
+    assert_equal "cms/html_blocks/form", type.form
+  end
+
+  test "save" do
+
+    @block = Cms::HtmlBlock.create!(:name=>"Test")
+  end
+
+  def test_create    
+    @page = Factory(:page)
+    @html_block = Factory(:html_block, :connect_to_page_id => @page.id, :connect_to_container => "test")
+    assert_equal 1, @page.reload.connectors.count
+    assert_equal @page, @html_block.connected_page
+    assert_equal @page.id, @html_block.connect_to_page_id
+    assert_equal "test", @html_block.connect_to_container
+  end
+  
+  def test_versioning
+    assert Cms::HtmlBlock.versioned?
+    
+    @html_block = Factory(:html_block, :name => "Original Value")
+    assert_equal @html_block, @html_block.versions.last.html_block
+
+    # Updates should make a new version
+    assert @html_block.update_attributes(:name => "Something Different")
+    assert_equal @html_block, @html_block.versions.last.html_block
+    assert_equal "Something Different", @html_block.versions.last.name
+    assert_equal "Something Different", @html_block.name
+    assert_equal "Original Value", @html_block.versions.first.name
+  
+    # Updating with no changes should not generate a new version
+    html_block_version_count = @html_block.versions.count
+    @html_block.update_attributes(:name => "Something Different")
+    assert_equal html_block_version_count, @html_block.versions.count
+    
+    # deleting should create a new version
+    html_block_count = Cms::HtmlBlock.count_with_deleted
+    html_block_version_count = @html_block.versions.count
+    assert !@html_block.deleted?
+    
+    @html_block.destroy    
+    
+    assert_equal html_block_count, Cms::HtmlBlock.count_with_deleted
+    assert_incremented html_block_version_count, @html_block.versions.count
+    assert @html_block.deleted?
+    
+  end
+  
+  def test_reverting
+    # We need a block with a version that was created in the past
+    @v1_created_at = Time.zone.now - 5.days
+    @html_block = Factory(:html_block, :name => "Version One", :created_at => @v1_created_at)
+    
+    # Make the version be created in the past as well
+    v1 = @html_block.versions.last
+    v1.created_at = @v1_created_at
+    v1.save
+
+    # Make a new version
+    @html_block.update_attributes(:name => "Version Two")
+    @v2_created_at = @html_block.versions.last.created_at
+
+    assert_equal "Version Two", @html_block.name
+    assert_equal @v1_created_at.to_i, @html_block.find_version(1).created_at.to_i
+    assert_equal @v2_created_at.to_i, @html_block.find_version(2).created_at.to_i
+    
+    @html_block.revert_to 1
+    @html_block.reload
+
+    assert_equal 3, @html_block.draft.version
+    assert_equal "Version One", @html_block.name
+    assert_equal @v1_created_at.to_i, @html_block.find_version(1).created_at.to_i
+    assert_equal @v2_created_at.to_i, @html_block.find_version(2).created_at.to_i
+    assert @html_block.find_version(3).created_at.to_i >= @v2_created_at.to_i
+    assert @v1_created_at.to_i, @html_block.created_at.to_i
+    
+    # version is required for revert_to
+    html_block_version_count = Cms::HtmlBlock::Version.count
+    assert_raise "Version parameter missing" do
+      @html_block.revert_to nil
+    end
+    assert_equal html_block_version_count, Cms::HtmlBlock::Version.count
+     
+    html_block_version_count = Cms::HtmlBlock::Version.count
+    assert_raise "Could not find version 42" do
+      @html_block.revert_to 42
+    end
+    assert_equal html_block_version_count, Cms::HtmlBlock::Version.count 
+  end
+  
+  def test_previous_version
+    @html_block = Factory(:html_block, :name => "V1")
+    @html_block.update_attributes(:name => "V2")
+    @version = @html_block.as_of_version 1
+    
+    assert_equal Cms::HtmlBlock, @version.class
+    assert_equal "V1", @version.name
+    assert_equal 1, @version.version
+    assert_equal @html_block.id, @version.id
+    
+    # We can't freeze the version because we need to be able to load assocations
+    assert !@version.frozen?
+    assert !@version.live?
+    assert !@html_block.live?
+  end
+  
+end

data/test/unit/models/image_block_test.rb

@@ -0,0 +1,35 @@
+require "test_helper"
+
+module Cms
+  class ImageBlockTest < ActiveSupport::TestCase
+
+    def setup
+
+    end
+
+    def teardown
+
+    end
+
+    test "#parent" do
+      image = Factory(:image_block)
+      assert_equal root_section, image.parent
+    end
+
+    test "default table_name" do
+      assert_equal Namespacing.prefix("file_blocks"), ImageBlock.table_name
+    end
+
+    test "non_versioned_columns should not include the version_foreign_ken" do
+      assert ImageBlock.non_versioned_columns.include?("original_record_id")
+    end
+
+    test "version_foreign_key" do
+      assert_equal :original_record_id, ImageBlock.version_foreign_key
+    end
+
+    test "create works" do
+      ImageBlock.create!(:name=>"test")
+    end
+  end
+end

data/test/unit/models/link_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+class LinkTest < ActiveSupport::TestCase
+
+  def setup
+    @link = Factory(:link)
+    @another_link = Factory(:link)
+  end
+
+  def test_create
+    assert Factory.build(:link).valid?
+    assert !Factory.build(:link, :name => "").valid?
+  end
+
+  test "draft_version is stored on pages" do
+    assert_equal 1, @link.version
+    assert_equal 1, @link.latest_version
+  end
+
+  test "#update increments the latest_version" do
+    @link.name = "New"
+    @link.save!
+    @link.reload
+
+    assert_equal 1, @link.version
+    assert_equal 2, @link.latest_version
+
+    assert_equal 1, @another_link.reload.latest_version, "Should only update its own version, not other tables"
+  end
+
+  test "live?" do
+    assert @link.live?
+  end
+
+  test "updating makes it not live" do
+    @link.update_attributes(:name => "New")
+    @link.reload
+    refute @link.live?
+
+    @link.publish!
+    @link.reload
+    assert @link.live?
+  end
+
+  test "live? as_of_version" do
+    @link.update_attributes(:name => "New")
+    @link.publish!
+
+    v1 = @link.as_of_version(1)
+    assert v1.live?
+  end
+end

data/test/unit/models/namespaces_test.rb

@@ -0,0 +1,57 @@
+
+# This test is to verify that for all of our namespaced objects that the named reflections are valid.  
+# Mostly to ensure that :class_name is set where needed.
+
+require 'test_helper'
+
+class NamespacesTest < ActiveSupport::TestCase
+  
+  
+  # Fetches all of the subclasses from a given module by grabbing the defined constants
+  # and seeing if they are a Class or something else.  Does not check to see if it is an 
+  # AR class or if it has a blueprint.
+  def self.subclasses_from_module(module_name)
+    subclasses = []
+    mod = module_name.constantize
+    if mod.class == Module
+      mod.constants.each do |module_const_name|
+        begin
+          klass_name = "#{module_name}::#{module_const_name}"
+          klass = klass_name.constantize
+          if klass.class == Class
+            subclasses << klass
+            subclasses += klass.send(:descendants).collect{|x| x.respond_to?(:constantize) ? x.constantize : x}
+          else
+            subclasses += subclasses_from_module(klass_name)
+          end
+        rescue NameError
+          raise $!
+          puts $!.inspect
+        end
+      end
+    end
+    return subclasses
+  end
+  
+  # If you want to test more namespaces add them here.
+  classes = []
+  classes += subclasses_from_module("Cms")
+  classes.uniq!
+  
+  classes.each do |klass|
+    test "ensure a #{klass.name} has valid reflections" do
+      if klass.kind_of? ActiveRecord::Base
+        @obj = klass.new
+        klass.reflections.each do |name, reflection|
+          assert_nothing_thrown("Error with #{name} reflection") do
+            @obj.send(name)
+            reflection.klass unless reflection.options[:polymorphic]
+          end
+        end
+      end
+    end
+  end
+  
+  
+end
+

data/test/unit/models/page_partial_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class PagePartialTest < ActiveSupport::TestCase
+  def setup
+    @page_partial = Factory.build(:page_partial, :name => "_test")
+    File.delete(@page_partial.file_path) if File.exists?(@page_partial.file_path)
+  end
+
+  def teardown
+    File.delete(@page_partial.file_path) if File.exists?(@page_partial.file_path)
+  end
+
+  test "Name used to build the form" do
+    assert_equal "page_partial", Cms::PagePartial.resource_collection_name
+  end
+
+  test "resource_name works for namespaced templates" do
+    assert_equal "page_partials", Cms::PagePartial.resource_name
+  end
+
+  def test_create
+    assert !File.exists?(@page_partial.file_path), "partial file already exists"
+    assert_valid @page_partial
+    assert @page_partial.save
+    assert File.exists?(@page_partial.file_path), "partial file was not written to disk"
+  end
+
+  def test_for_valid_name
+    assert_not_valid Factory.build(:page_partial, :name => "Fancy")
+    assert_not_valid Factory.build(:page_partial, :name => "foo bar")
+    partial = Factory.build(:page_partial, :name => "subpage_1_column")
+    assert_valid partial
+    assert_equal "_subpage_1_column", partial.name
+    assert_valid Factory.build(:page_partial, :name => "_sidebar")
+  end
+
+end

data/test/unit/models/page_route_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+class PageRouteTest < ActiveSupport::TestCase
+  def setup
+    @route = Cms::PageRoute.new(:pattern=>"/:some/:pattern", :name=>"My Name")
+  end
+
+
+  def test_create
+    page = Factory(:page, :path => "/things/overview")
+    route = page.page_routes.build(:pattern => "/things/:year/:month/:day")
+    route.add_requirement(:year, "\\d{4,}")
+    route.add_requirement(:month, "\\d{2,}")
+    route.add_requirement(:day, "\\d{2,}")
+    route.add_condition(:method, "get")
+
+    assert route.save!
+    assert_equal "/things/:year/:month/:day", route.pattern
+    assert_equal({
+                     :controller => "cms/content",
+                     :action => "show_page_route",
+                     :_page_route_id => route.id.to_s,
+                     :requirements => {
+                         :year => /\d{4,}/,
+                         :month => /\d{2,}/,
+                         :day => /\d{2,}/
+                     }, :conditions => {
+            :method => :get
+        }
+                 }, route.options_map)
+
+
+  end
+
+  # Rails 3 Routing
+  test "match :to" do
+    assert_equal "cms/content#show_page_route", @route.to
+  end
+
+  test "match :as" do
+    assert_equal "my_name", @route.route_name
+    assert_equal "my_name", @route.as
+  end
+
+  test "default method conditions" do
+    assert_equal [:get, :post], @route.via
+  end
+  test "setting method conditions" do
+    @route.add_condition(:method, "post")
+    assert_equal([:post], @route.via)
+
+  end
+
+  test "Using :via to constraint the callable methods" do
+    @route.via = :get
+    assert_equal [:get], @route.via
+  end
+
+  test "Specify multiple methods using :via to constraint the callable methods" do
+    @route.via = [:get, :propfind]
+    assert_equal [:get, :propfind], @route.via
+  end
+
+  test "constraints converts string key to symbol since routes requires it" do
+    @route.add_requirement("year", 'd{4}')
+    assert_equal(true, @route.constraints.include?(:year))
+
+  end
+  test "constraints allows for regular expressions to be set for pattern elements in a route" do
+    @route.add_requirement(:year, '\d{4,}')
+    assert_equal({:year => /\d{4,}/}, @route.constraints)
+  end
+
+  test "add_constraint is replacement method for add_requirement " do
+    @route.add_requirement(:year, 'd{4}')
+    assert_equal({:year => /d{4}/}, @route.constraints)
+  end
+
+  test "constraints handles more than one pattern" do
+    @route.add_requirement(:month, '\d{2,}')
+    @route.add_requirement(:day, '\d{2,}')
+    @route.add_requirement(:year, '\d{4,}')
+    assert_equal({:month => /\d{2,}/, :day => /\d{2,}/, :year => /\d{4,}/}, @route.constraints)
+  end
+end
+
+
+class LoadingPageRoutesTest < ActiveSupport::TestCase
+
+  def setup
+
+  end
+
+  test "can_be_loaded?" do
+    Cms::PageRoute.expects(:database_exists?).returns(true)
+    Cms::PageRoute.expects(:table_exists?).returns(true)
+
+    assert_equal true, Cms::PageRoute.can_be_loaded?
+  end
+
+  test "Routes cannot be loaded if the table doesn't exist" do
+    Cms::PageRoute.expects(:database_exists?).returns(true)
+    Cms::PageRoute.expects(:table_exists?).returns(false)
+
+    assert_equal false, Cms::PageRoute.can_be_loaded?
+  end
+
+  test "Routes cannot be loaded if the database doesn't exist" do
+    Cms::PageRoute.expects(:database_exists?).returns(false)
+
+    assert_equal false, Cms::PageRoute.can_be_loaded?
+  end
+end