browsercms 3.1.5 → 3.3.0.beta

data/test/unit/behaviors/connectable_test.rb

@@ -1,29 +0,0 @@
-require "test_helper"
-
-class ConnectableTest < ActiveSupport::TestCase
-
-  def setup
-    given_a_site_exists
-    @block = Factory(:html_block)
-    @connected_page = Factory(:public_page, :parent=>root_section)
-    @connected_page_2 = Factory(:public_page, :parent=>root_section)
-    @unconnected_page = Factory(:public_page, :parent=>root_section)
-
-    @connected_page.create_connector(@block, "main")
-    @connected_page_2.create_connector(@block, "main")
-  end
-
-  def teardown
-  end
-
-  test "#connected_pages" do
-    assert_equal [@connected_page, @connected_page_2], @block.connected_pages
-  end
-
-  test "#connected_pages should return same list when called twice" do
-    expected = @block.connected_pages
-    assert_equal expected.object_id, @block.connected_pages.object_id
-  end
-
-
-end

data/test/unit/behaviors/dynamic_attributes_test.rb

@@ -1,38 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../test_helper')
-
-ActiveRecord::Base.connection.instance_eval do
-  drop_table(:things) if table_exists?(:things)
-  drop_table(:thing_attributes) if table_exists?(:thing_attributes)
-  create_table(:things) do |t| 
-    t.string :name
-    t.timestamps
-  end
-  create_table(:thing_attributes) do |t| 
-    t.integer :thing_id
-    t.string :name
-    t.text :value
-  end
-end
-
-class Thing < ActiveRecord::Base
-  has_dynamic_attributes
-end
-
-class ThingTest < ActiveSupport::TestCase
-  def test_dynamic_attributes
-    assert !User.has_dynamic_attributes?
-    assert Thing.has_dynamic_attributes?
-
-    thing = Thing.new(:foo => "bar")
-    assert_equal "bar", thing.foo
-
-    thing.foo = "Bang"
-    assert_equal "Bang", thing.foo
-
-    assert thing.save
-
-    thing = Thing.find(thing.id)
-    assert_equal "Bang", thing.foo
-    assert_nil thing.bar
-  end
-end

data/test/unit/behaviors/publishable_test.rb

@@ -1,84 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../test_helper')
-
-ActiveRecord::Base.connection.instance_eval do
-  drop_table(:publishables) if table_exists?(:publishables)
-  create_table(:publishables) do |t|
-    t.string :name
-    t.boolean :published, :default => false
-  end
-  drop_table(:unpublishables) if table_exists?(:unpublishables)
-  create_table(:unpublishables) do |t|
-    t.string :name
-  end
-
-  drop_table(:publishable_blocks) if table_exists?(:publishable_blocks)
-  drop_table(:publishable_block_versions) if table_exists?(:publishable_block_versions)
-  create_content_table(:publishable_blocks) do |t|
-    t.string :name
-  end
-end
-
-class Publishable < ActiveRecord::Base
-  is_publishable
-end
-
-class Unpublishable < ActiveRecord::Base
-end
-
-class PublishableBlock < ActiveRecord::Base
-  acts_as_content_block
-end
-
-class PublishableBlockTestCase < ActiveSupport::TestCase
-
-  def setup
-    @object = PublishableBlock.create!(:name=>"v1", :publish_on_save=>true)
-  end
-
-  test "#live?" do
-    assert @object.live?
-  end
-
-  test "#live? if there are draft versions" do
-    @object.name = "New Name"
-    @object.save!
-
-    assert_equal false, @object.live?
-    assert_equal :draft, @object.status
-  end
-end
-
-class PublishableTestCase < ActiveSupport::TestCase
-
-  def setup
-    @object = Publishable.new(:name => "New Record")
-  end
-
-  def test_publishable
-    assert @object.publishable?
-  end
-
-  def test_save
-    assert @object.save
-    assert !@object.published?
-  end
-
-  def test_publish_on_save
-    @object.publish_on_save = true
-    assert @object.save
-    assert @object.reload.published?
-  end
-
-  def test_unpublishable
-    @object = Unpublishable.new(:name => "New Record")
-    assert !@object.publishable?
-    assert @object.save
-    assert !@object.publishable?
-  end
-
-  def test_not_publishable_if_connect_to_page_id_is_blank
-    assert HtmlBlock.new(:connect_to_page_id => "").publishable?
-  end
-
-
-end

data/test/unit/behaviors/searching_test.rb

@@ -1,102 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../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) 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) 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"
-  named_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 HtmlBlock.searchable?
-    assert_equal [@a2, @b2], HtmlBlock.search("2").all
-    assert HtmlBlock.search(:term => "one").all.empty?
-    assert_equal [@a1, @b1], HtmlBlock.search(:term => "one", :include_body => true).all
-    assert 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

@@ -1,109 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../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) 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, Tag.count
-    assert_equal 0, 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, Tag.count
-    assert_equal 2, 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, Tag.count
-    assert_equal 2, 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 = Tag.counts(:limit => 4)
-    assert_equal 4, tag_counts.size
-    assert_equal Tag.find_by_name("article"), tag_counts[0]
-    assert_equal "25", tag_counts[0].count
-    assert_equal Tag.find_by_name("even"), tag_counts[1]
-    assert_equal "13", tag_counts[1].count
-    assert_equal Tag.find_by_name("five"), tag_counts[2]
-    assert_equal "5", tag_counts[2].count
-    assert_equal Tag.find_by_name("first"), tag_counts[3]
-    assert_equal "1", tag_counts[3].count
-    
-    tag_cloud = Tag.cloud(:sizes => 9)
-    assert_equal 5, tag_cloud.size
-    assert_equal Tag.find_by_name("article"), tag_cloud[0]
-    assert_equal 6, tag_cloud[0].size
-    assert_equal Tag.find_by_name("even"), tag_cloud[1]
-    assert_equal 3, tag_cloud[1].size
-    assert_equal Tag.find_by_name("five"), tag_cloud[2]
-    assert_equal 1, tag_cloud[2].size
-    assert_equal Tag.find_by_name("first"), tag_cloud[3]
-    assert_equal 0, tag_cloud[3].size
-    assert_equal 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, Tag.count
-    assert_equal 0, 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, Tag.count
-    assert_equal 2, Tagging.count
-  end
-
-  
-end

data/test/unit/behaviors/versioning_test.rb

@@ -1,36 +0,0 @@
-require "test_helper"
-
-class VersioningTest < 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
-
-  def teardown
-  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

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

@@ -1,10 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../../test_helper')
-
-class ActiveRecord::BaseTest < ActiveSupport::TestCase
-  def test_updated_on_string
-    base = 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

data/test/unit/extensions/hash_test.rb

@@ -1,17 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../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
-  
-  def test_extract!
-    x = {:a => 1, :b => 2}
-    y = x.extract!(:b, :c)
-    assert_equal({:a => 1}, x)
-    assert_equal({:b => 2}, y)
-  end
-  
-end

data/test/unit/extensions/integer_test.rb

@@ -1,10 +0,0 @@
-require File.join(File.dirname(__FILE__), '/../../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