browsercms 3.4.2 → 3.5.0.rc1

data/test/unit/behaviors/connectable_test.rb

@@ -1,32 +0,0 @@
-require "test_helper"
-
-module Cms
-
-  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
-end

data/test/unit/behaviors/connecting_test.rb

@@ -1,56 +0,0 @@
-require 'test_helper'
-
-module Cms
-  class Thing < ActiveRecord::Base
-    is_connectable
-  end
-end
-class ConnectingTest < 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
-
-  test "Class have display_names" do
-    assert_equal "Thing", Cms::Thing.display_name
-  end
-
-  test "Default Naming Strategy" do
-    assert_equal "String", Cms::Behaviors::Connecting.default_naming_for(String)
-
-    module Cms::SomeModule
-      class Thing ; end
-    end
-    assert_equal "Thing", Cms::Behaviors::Connecting.default_naming_for(Cms::SomeModule::Thing)
-  end
-  test "Update connected pages should return true if there is a valid version." do
-    block = Cms::HtmlBlock.new
-    mock_draft = mock()
-    mock_draft.expects(:version).returns(1)
-    block.expects(:draft).returns(mock_draft)
-
-    assert_equal true, block.update_connected_pages
-  end
-
-  test "Connected_to" do
-    assert_equal 1, @block.version
-    pages = Cms::Page.connected_to(:connectable => @block, :version => @block.version).all
-    assert_equal @page, pages.first
-  end
-
-  test "connected_pages should return all pages connected to a versioned block " do
-    @page.publish!
-    assert_equal [@page], @block.connected_pages
-  end
-
-
-  test "connected_pages should return all pages connected to a nonversioned block " do
-    @portlet = Factory(:portlet)
-    @page.create_connector(@portlet, "main")
-    @page.publish!
-    assert_equal [@page], @portlet.connected_pages
-  end
-end

data/test/unit/behaviors/dynamic_attributes_test.rb

@@ -1,74 +0,0 @@
-require '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 DynamicAttributesTest < ActiveSupport::TestCase
-
-  def setup
-    @thing = Thing.new
-  end
-
-  test "blocks should not have dynamic_attributes" do
-    assert !Cms::User.has_dynamic_attributes?
-
-  end
-
-  test "models should have dynamic_attributes if specified" do
-    assert Thing.has_dynamic_attributes?
-  end
-
-  test "can just call properties into existance" do
-    @thing.price = 1
-
-    assert_equal(1, @thing.price)
-  end
-
-  test "Can persist String properties" do
-    @thing.description = "A thing"
-    @thing.save!
-
-    reloaded_thing = Thing.find(@thing.id)
-    assert_equal("A thing", reloaded_thing.description)
-  end
-
-  test "non-string (like Integers) properties are persisted as Strings" do
-    @thing.price = 1
-    @thing.save!
-
-    reloaded_thing = Thing.find(@thing.id)
-    assert_equal("1", reloaded_thing.price)
-  end
-
-  test "undefined properties should be nil" do
-    assert_nil @thing.non_yet_set_property
-  end
-
-  test "can bulk set attributes=" do
-    @thing.attributes=({:price=>1, :description=>"Paper"})
-    assert_equal(1, @thing.price)
-    assert_equal("Paper", @thing.description)
-  end
-
-  test "can bulk set persistent properties during construction" do
-    mineral = Thing.new(:description=>"Rock")
-    mineral.save!
-
-    assert_equal("Rock", mineral.description)
-  end
-end

data/test/unit/behaviors/namespacing_test.rb

@@ -1,76 +0,0 @@
-require "test_helper"
-
-
-create_testing_table :cms_namespaced_blocks
-class Cms::NamespacedBlock < ActiveRecord::Base
-  acts_as_content_block
-end
-
-
-class Cms::NonNamespacedBlock < ActiveRecord::Base
-
-  # Avoids need to create another table
-  set_table_name "cms_namespaced_blocks"
-
-  acts_as_content_block namespace_table: false
-end
-
-
-class Cms::NamespacingCoreRailsTest < ActiveSupport::TestCase
-
-  module ::Foo
-    def self.table_name_prefix
-      "foobar_"
-    end
-  end
-
-  class ::Foo::TestBlock < ActiveRecord::Base;
-  end
-
-  test "table_name should be automatically prefixed" do
-    assert_equal "foobar_test_blocks", Foo::TestBlock.table_name
-  end
-
-
-  test "model tables are not automatically prefixed" do
-    create_testing_table :test_blocks
-    assert_equal false, ActiveRecord::Base.connection.table_exists?("foobar_test_blocks")
-  end
-end
-
-class Cms::Behaviors::NamespacingTest < ActiveSupport::TestCase
-  create_testing_table :cms_my_blocks
-  class ::Cms::MyBlock < ActiveRecord::Base
-  end
-
-  def setup
-
-  end
-
-  test "Default for new projects is blank." do
-    Cms.expects("table_prefix").returns(nil)
-    assert_equal "", Cms.table_name_prefix
-  end
-
-  test "All blocks automatically get namespacing" do
-    Cms::MyBlock.respond_to?(:namespaced_table?)
-  end
-
-  test "default table namespace " do
-    assert_equal Cms::Namespacing.prefix("my_blocks"), Cms::MyBlock.table_name
-  end
-
-  test "set a table namespace" do
-    Cms.expects(:table_prefix).returns('abc_').at_least_once
-    class ::Cms::CustomBlock < ActiveRecord::Base
-    end
-    create_testing_table :abc_custom_blocks
-    assert_equal "abc_custom_blocks", ::Cms::CustomBlock.table_name
-  end
-
-  test "Get prefixed name" do
-    Cms.expects(:table_prefix).returns('abc_')
-    assert_equal "abc_name", Cms::Namespacing.prefixed_table_name("name")
-  end
-
-end

data/test/unit/behaviors/publishable_test.rb

@@ -1,83 +0,0 @@
-require '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, :prefix=>false) 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 Cms::HtmlBlock.new(:connect_to_page_id => "").publishable?
-  end
-
-end

data/test/unit/behaviors/rendering_test.rb

@@ -1,68 +0,0 @@
-require 'test_helper'
-
-class Parent
-  def render
-    "I'm the 'wrong' render method to call."
-  end
-end
-
-class SelfRenderingBlock < Parent
-  include Cms::Behaviors::Rendering
-  is_renderable
-
-  def render
-    "I can do it myself"
-  end
-end
-
-class NonSelfRenderingBlock < Parent
-  include Cms::Behaviors::Rendering
-  is_renderable
-end
-
-class RenderingTest < ActiveSupport::TestCase
-
-  test "an object should not self render if it doesn't define a 'render' method on the class itself." do
-    obj = NonSelfRenderingBlock.new
-    assert_equal false, obj.should_render_self?
-  end
-
-  test "an object should self render if it defines a 'render' method." do
-    obj = SelfRenderingBlock.new
-    assert_equal true, obj.should_render_self?
-  end
-
-  test "The proper render method should be called" do
-    assert_equal false, Cms::HtmlBlock.new.should_render_self?, "HtmlBlocks should not be considered 'self renderable'"
-  end
-
-  test "Blocks which define their own render method should have that one called" do
-    assert_equal "I can do it myself", SelfRenderingBlock.new.render
-  end
-
-  test "prepare_to_render should not call 'render' when blocks are non-self rendering" do
-    non_rendering = NonSelfRenderingBlock.new
-    non_rendering.expects(:should_render_self?).returns(false)
-    non_rendering.expects(:render).never
-    non_rendering.prepare_to_render(stub())
-
-  end
-
-  test "prepare to render" do
-    self_rendering = SelfRenderingBlock.new
-    self_rendering.expects(:render)
-    self_rendering.prepare_to_render(stub())
-  end
-
-  test "perform render doesn't throw missing methods errors" do
-    controller = ActionController::Base.new
-    controller.expects(:view_paths).returns([])
-
-    block = Cms::HtmlBlock.new
-
-    # This isn't really what should happen, but its at least testing that render isn't using missing methods
-    assert_raise ActionView::MissingTemplate do
-      block.perform_render(controller)
-    end
-  end
-end

data/test/unit/behaviors/searching_test.rb

@@ -1,102 +0,0 @@
-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