browsercms 3.3.4 → 3.4.0.rc1

data/test/unit/behaviors/searching_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+
+ActiveRecord::Base.connection.instance_eval do
+  drop_table(:searchable_content_block_parents) if table_exists?(:searchable_content_block_parents)  
+  create_table(:searchable_content_block_parents) {|t| t.string :name }
+  drop_table(:searchable_content_blocks) if table_exists?(:searchable_content_blocks)
+  drop_table(:searchable_content_block_versions) if table_exists?(:searchable_content_block_versions)
+  create_versioned_table(:searchable_content_blocks, :prefix=>false) do |t|
+    t.integer :parent_id
+    t.string :name 
+    t.boolean :deleted, :default => 0
+    t.integer :created_by
+    t.integer :updated_by
+    t.timestamps
+  end
+
+  # Verifies that blocks are created with a :name column if one is not specified.
+  drop_table(:searchable_block_without_names) if table_exists?(:searchable_block_without_names)
+  drop_table(:searchable_block_without_name_versions) if table_exists?(:searchable_block_without_name_versions)
+  create_versioned_table(:searchable_block_without_names, :prefix=>false) do |t|
+    t.string :title
+  end
+end
+
+class SearchableContentBlockParent < ActiveRecord::Base
+  has_many :children, :class_name => "SearchableContentBlock", :foreign_key => "parent_id" 
+end
+
+class SearchableContentBlock < ActiveRecord::Base
+  acts_as_content_block
+  belongs_to :parent, :class_name => "SearchableContentBlockParent"
+  scope :created_after, lambda{|time| {:conditions => ["created_at > ?", time]}}
+end
+
+class SearchableContentBlockTest < ActiveSupport::TestCase
+  def test_searchable
+    @parent = SearchableContentBlockParent.create!(:name => "Papa")
+    @a1 = @parent.children.create!(:name => "a1")
+    @a2 = @parent.children.create!(:name => "a2")
+    @b1 = @parent.children.create!(:name => "b1")
+    @b2 = @parent.children.create!(:name => "b2")
+
+    assert SearchableContentBlock.searchable?
+    assert_equal [@a1, @a2], SearchableContentBlock.search("a").all
+    assert_equal [@a2, @a1], SearchableContentBlock.search(:term => "a", :order => "id desc").all
+    assert_equal [@a2, @a1], SearchableContentBlock.created_after(1.hour.ago).search(:term => "a", :order => "id desc").all
+    assert_equal [@a2, @a1], @parent.children.created_after(1.hour.ago).search(:term => "a", :order => "id desc").all
+  end
+end
+
+class SearchableHtmlBlockTest < ActiveSupport::TestCase
+  def test_searchable
+    @a1 = Factory(:html_block, :name => "a1", :content => "a one")
+    @a2 = Factory(:html_block, :name => "a2", :content => "a two")
+    @b1 = Factory(:html_block, :name => "b1", :content => "b one")
+    @b2 = Factory(:html_block, :name => "b2", :content => "b two")
+
+    assert Cms::HtmlBlock.searchable?
+    assert_equal [@a2, @b2], Cms::HtmlBlock.search("2").all
+    assert Cms::HtmlBlock.search(:term => "one").all.empty?
+    assert_equal [@a1, @b1], Cms::HtmlBlock.search(:term => "one", :include_body => true).all
+    assert Cms::HtmlBlock.search(nil).include?(@b2)
+  end
+end
+
+
+class SearchableBlockWithoutName < ActiveRecord::Base
+  acts_as_content_block
+end
+
+class SearchableBlockWithoutNameTest < ActiveSupport::TestCase
+
+  test "Creating a test only ActiveRecord should work" do
+    block = SearchableBlockWithoutName.create!(:title => "TITLE")
+
+    assert_not_nil block
+    assert_equal block, SearchableBlockWithoutName.find(block.id)
+  end
+
+  test "Blocks should have a :name column by default" do
+    block = SearchableBlockWithoutName.create!(:name => "NAME")
+
+    assert_equal block, SearchableBlockWithoutName.find_by_name("NAME")
+    assert_equal "NAME", block.name
+  end
+  
+  test "Search method should not fail if block has no :name field" do
+    block = SearchableBlockWithoutName.create!(:name => ":implicitly specfied")
+
+    assert_equal SearchableBlockWithoutName.all.size, SearchableBlockWithoutName.search({}).size, "Should list all rows when no param is passed in."
+  end
+
+  test "Versions table for block should have 'name' attribute as well" do
+    name = ":implicitly specfied"
+    block = SearchableBlockWithoutName.create!(:name => name)
+    block.title = "Something New"
+    block.save!
+
+    v1 = block.find_version(1)
+    assert_equal name, v1.name
+  end
+end

data/test/unit/behaviors/taggable_test.rb

@@ -0,0 +1,110 @@
+require 'test_helper'
+
+ActiveRecord::Base.connection.instance_eval do
+  drop_table(:taggable_articles) if table_exists?(:taggable_articles)
+  create_table(:taggable_articles) {|t| t.string :name }
+
+  drop_table(:versioned_taggable_articles) if table_exists?(:versioned_taggable_articles)
+  drop_table(:versioned_taggable_article_versions) if table_exists?(:versioned_taggable_article_versions)
+  create_versioned_table(:versioned_taggable_articles, :prefix=>false) do |t|
+    t.string :name
+  end
+end
+
+class TaggableArticle < ActiveRecord::Base
+  is_taggable
+end
+
+class VersionedTaggableArticle < ActiveRecord::Base
+  acts_as_content_block :taggable => true
+end
+
+class TaggableBlockTest < ActiveSupport::TestCase
+  def test_tagging
+    article = TaggableArticle.create!(:name => "foo")
+    assert_equal 0, article.taggings.count
+    assert_equal 0, article.tags.count
+    assert_equal 0, Cms::Tag.count
+    assert_equal 0, Cms::Tagging.count
+
+    article.tag_list = "foo bar"
+    assert article.save
+    assert_equal 2, article.taggings.count
+    assert_equal 2, article.tags.count
+    assert_equal 2, Cms::Tag.count
+    assert_equal 2, Cms::Tagging.count
+    
+    assert_equal [article], TaggableArticle.tagged_with("foo").all
+    assert_equal [article], TaggableArticle.tagged_with("bar").all
+    assert TaggableArticle.tagged_with("bang").all.empty?
+        
+    article.tag_list = "foo bang"
+    assert article.save
+    assert_equal 2, article.taggings.count
+    assert_equal 2, article.tags.count
+    assert_equal 3, Cms::Tag.count
+    assert_equal 2, Cms::Tagging.count
+
+    assert_equal [article], TaggableArticle.tagged_with("foo").all
+    assert_equal [article], TaggableArticle.tagged_with("bang").all
+    assert TaggableArticle.tagged_with("bar").all.empty?
+    
+    assert_equal "bang foo", article.tag_list
+  end
+  
+  def test_tag_cloud
+    25.times do |n|
+      tag_list = ["article"]
+      tag_list << "first" if n == 0
+      tag_list << "even" if n.even?
+      tag_list << "five" if n % 5 == 0
+      tag_list << "last" if n == 24
+      TaggableArticle.create!(:name => "Article ##{n}", :tag_list => tag_list.join(" ") )
+    end
+    
+    tag_counts = Cms::Tag.counts(:limit => 4)
+    assert_equal 4, tag_counts.size
+    assert_equal Cms::Tag.find_by_name("article"), tag_counts[0]
+    assert_equal 25, tag_counts[0].count.to_i
+    assert_equal Cms::Tag.find_by_name("even"), tag_counts[1]
+    assert_equal 13, tag_counts[1].count.to_i
+    assert_equal Cms::Tag.find_by_name("five"), tag_counts[2]
+    assert_equal 5, tag_counts[2].count.to_i
+    assert_equal Cms::Tag.find_by_name("first"), tag_counts[3]
+    assert_equal 1, tag_counts[3].count.to_i
+
+    
+    tag_cloud = Cms::Tag.cloud(:sizes => 9)
+    assert_equal 5, tag_cloud.size
+    assert_equal Cms::Tag.find_by_name("article"), tag_cloud[0]
+    assert_equal 6, tag_cloud[0].size
+    assert_equal Cms::Tag.find_by_name("even"), tag_cloud[1]
+    assert_equal 3, tag_cloud[1].size
+    assert_equal Cms::Tag.find_by_name("five"), tag_cloud[2]
+    assert_equal 1, tag_cloud[2].size
+    assert_equal Cms::Tag.find_by_name("first"), tag_cloud[3]
+    assert_equal 0, tag_cloud[3].size
+    assert_equal Cms::Tag.find_by_name("last"), tag_cloud[4]
+    assert_equal 0, tag_cloud[4].size
+  end
+  
+end
+
+class VersionedTaggableBlockTest < ActiveSupport::TestCase
+  def test_tagging
+    article = VersionedTaggableArticle.create!(:name => "foo")
+    assert_equal 0, article.taggings.count
+    assert_equal 0, article.tags.count
+    assert_equal 0, Cms::Tag.count
+    assert_equal 0, Cms::Tagging.count
+
+    article.tag_list = "foo bar"
+    assert article.save
+    assert_equal 2, article.taggings.count
+    assert_equal 2, article.tags.count
+    assert_equal 2, Cms::Tag.count
+    assert_equal 2, Cms::Tagging.count
+  end
+
+  
+end

data/test/unit/behaviors/userstamping_test.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+
+class UserStampingTest < ActiveSupport::TestCase
+
+  def setup
+
+  end
+
+  def teardown
+
+  end
+
+  test "if no current user, then timestamp should be nil" do
+    Cms::User.expects(:current).returns(nil).at_least_once
+    block = Cms::HtmlBlock.create!(:name=>"A")
+
+    assert_nil block.created_by
+    assert_nil block.updated_by
+  end
+
+  test "if no current user is false, then timestamp should be nil" do
+    Cms::User.expects(:current).returns(false).twice
+    block = Cms::HtmlBlock.create!(:name=>"A")
+    assert_nil block.created_by
+    assert_nil block.updated_by
+  end
+end

data/test/unit/behaviors/versioning_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+
+module Cms
+  class VersioningTest < ActiveSupport::TestCase
+
+    test "version_foriegn_key is always the same" do
+      assert_equal :original_record_id, Cms::HtmlBlock.version_foreign_key
+    end
+
+    test "Non-versioned columns include 'original_record_id'" do
+      assert_equal true, Cms::HtmlBlock.non_versioned_columns.include?("original_record_id")
+    end
+
+    test "non_versioned_columns should be made into string" do
+      class ::Cms::SpecialBlock < ActiveRecord::Base
+        is_versioned
+      end
+
+      Cms::SpecialBlock.non_versioned_columns.each do |c|
+        assert_equal String, c.class, "Expected #{c} to be a String, but wasn't."
+      end
+
+    end
+    test "Saving a new record should create two rows, one in html_blocks, one in html_block_versions" do
+      block = Cms::HtmlBlock.new(:name => "Name is required.")
+      assert_equal true, block.save!
+      assert_equal 1, block.versions.size
+    end
+
+    test "Saving a new Versioned block should allow after_save callbacks to work" do
+      block = Cms::HtmlBlock.new(:name => "Testing")
+      assert block.save
+      assert_equal false, block.skip_callbacks
+    end
+
+    test "Saving a block without changing any attributes should skip after_save callbacks" do
+      block = Cms::HtmlBlock.new(:name => "Testing")
+      block.save
+
+      block.name = "Testing"
+      assert block.save
+
+      assert_equal true, block.skip_callbacks
+    end
+
+    test "Updating a block should increment the version on the new draft" do
+      block = Factory(:html_block)
+      assert_equal 1, block.version
+      block.name = "New Name"
+      assert block.save
+
+      assert_equal 2, block.versions.size
+      assert_equal 1, block.versions[0].version
+      assert_equal 2, block.versions[1].version
+    end
+
+    test "Build new version should create a new version with an incremented version from the primary object" do
+      block = Cms::HtmlBlock.new(:name => "ABC")
+      assert block.save
+      assert_equal 2, block.build_new_version_and_add_to_versions_list_for_saving.version
+    end
+
+    test "Updating an object should perform after_save callbacks" do
+      block = Factory(:html_block)
+      block.name = "New THing"
+      block.expects(:update_connected_pages).returns(true)
+
+      block.save
+    end
+  end
+
+  class VersionsTest < ActiveSupport::TestCase
+
+    def setup
+      @published_block = Factory(:html_block, :name => "Version 1", :publish_on_save => true)
+      @published_block.update_attributes(:name => "Version 2")
+      @published_block.reload
+    end
+
+    test "#name matches original version's attributes'" do
+      assert_equal "Version 1", @published_block.name
+    end
+
+    test "#as_of_draft_version" do
+      v2 = @published_block.as_of_draft_version
+      assert_equal "Version 2", v2.name
+      assert_equal HtmlBlock, v2.class
+    end
+
+    test "#draft returns the latest Version Object for a block" do
+      v2 = @published_block.draft
+      assert_equal "Version 2", v2.name
+      assert_equal HtmlBlock::Version, v2.class
+    end
+
+    test "#as_of_version" do
+      v1 = @published_block.as_of_version(1)
+      assert_equal "Version 1", v1.name
+      assert_equal @published_block.id, v1.id
+    end
+  end
+end

data/test/unit/extensions/active_record/base_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class ActiveRecord::BaseTest < ActiveSupport::TestCase
+  def test_updated_on_string
+    base = Cms::HtmlBlock.new
+    assert_nil base.updated_on_string
+    base.updated_at = Time.zone.parse("1978-07-06")
+    assert_equal "Jul 6, 1978", base.updated_on_string
+  end
+end
+
+# Must use vanilla TestCase to avoid ActiveRecord setup conflicts
+class TestExtensions < Test::Unit::TestCase
+
+  #"If a connection throws an error when established, then we consider the database to not exist."
+  def test_throws_error
+    ActiveRecord::Base.expects(:connection).raises(StandardError)
+    assert_equal false, ActiveRecord::Base.database_exists?
+  end
+
+  # "If we can establish a connection, the database exists"
+  def test_exists
+    assert_equal true, ActiveRecord::Base.database_exists?
+  end
+end

data/test/unit/extensions/hash_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class HashTest < ActiveSupport::TestCase
+  def test_except
+    x = {:a => 1, :b => 2}
+    assert_equal({:b => 2}, x.except(:a))
+    assert_equal({:a => 1, :b => 2}, x)
+  end
+
+  # Test the behavior of out extract_only! method
+  def test_extract_only!
+    x = {:a => 1, :b => 2}
+    y = x.extract_only!(:b, :c)
+    assert_equal({:a => 1}, x)
+    assert_equal({:b => 2}, y)
+  end
+
+  # This exists only to confirm the behavior of extract! (from ActiveSupport) is different then our extract_only!.
+  # If this ever changes, we can remove extract_only!
+  test "ActiveSupport Hash#extract! will add nil keys if they don't exist" do
+    x = {:a => 1, :b => 2}
+    y = x.extract!(:b, :c)
+    assert_equal({:b => 2, :c=>nil}, y, "Even though :c didn't exist in the original hash, ActiveSupport 3.0.0 adds it as a side effect.")     
+  end
+  
+end

data/test/unit/extensions/integer_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class IntegerTest < ActiveSupport::TestCase
+  def test_round_bytes
+    assert_equal "99.44 MB", (99.megabytes + 450.kilobytes).round_bytes
+    assert_equal "12.04 KB", (12.kilobytes + 45).round_bytes
+    assert_equal "999 bytes", 999.round_bytes
+    assert_equal "0 bytes", nil.round_bytes
+  end
+end

data/test/unit/extensions/string_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+# Tests the BrowserCMS extentions to the String class
+class StringTest < ActiveSupport::TestCase
+
+  test "string should be pluralizes unless there is one" do
+    assert_equal "posts", "post".pluralize_unless_one(0)
+    assert_equal "posts", "post".pluralize_unless_one(2)
+  end
+
+  test "string shouldn't be pluralized if there is one" do
+    assert_equal "post", "post".pluralize_unless_one(1)
+  end
+end

data/test/unit/factories_test.rb

@@ -0,0 +1,50 @@
+require "test_helper"
+
+class FactoriesTest < ActiveSupport::TestCase
+
+  def setup
+
+  end
+
+  def teardown
+
+  end
+
+  # Write tests to verify the basic Factories are being used correctly.
+  # Make :task work, such that a valid task is created with assignee/assigner that can edit.
+  # Use in tasks_controller rather than massive setup code.
+  #
+  # Bonus points...
+  # Refactor test_helper to get rid of adhoc setup code.
+  # Split factories into 'sharable' cms factories (that can be used in testing BrowserCMS projects).
+  #   as well as 'core' CMS factories (needed only for core)
+  test "content_editor_group" do
+    group = Factory(:content_editor_group)
+    assert_equal Cms::Group, group.class
+  end
+
+  test ":content_editor factory has edit_permission" do
+    editor = Factory(:content_editor)
+    assert editor.able_to?(:edit_content)
+    assert editor.able_to?(:publish_content)
+  end
+
+  test "section" do
+    section = Factory(:section)
+    assert_equal "Test", section.name
+    assert_equal "/test", section.path
+    assert_not_nil section.parent
+  end
+
+  test "cms_admin_user" do
+    user = Factory(:cms_admin)
+    assert_equal 1, user.groups.size
+    assert_equal true, user.able_to?(:edit_content)
+    assert_equal true, user.able_to?(:administrate)
+    assert_equal true, user.able_to?(:publish_content)
+  end
+
+  test ":public_page is also published" do
+    assert_equal true, Factory(:public_page).published?
+  end
+end