browsercms 3.3.4 → 3.4.0.rc1

data/test/unit/lib/generators_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class GeneratorsTest < Test::Unit::TestCase
+
+  def test_patterns_substition_for_windows
+    pattern = /\b[A-Za-z]:\//
+
+    # Default
+    full_windows_path = "C:/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js"
+    assert_equal "/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js", full_windows_path.gsub(pattern, "/")
+    assert_equal "/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js", Cms.scrub_path(full_windows_path)
+
+    # D: drive
+    full_windows_path = "D:/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js"
+    assert_equal "/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js", full_windows_path.gsub(pattern, "/")
+    assert_equal "/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js", Cms.scrub_path(full_windows_path)
+
+    # F: Drive
+    full_windows_path = "F:/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js"
+    assert_equal "/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js", full_windows_path.gsub(pattern, "/")
+    assert_equal "/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js", Cms.scrub_path(full_windows_path)
+
+    # lower-case
+    full_windows_path = "c:/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js"
+    assert_equal "/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js", full_windows_path.gsub(pattern, "/")
+    assert_equal "/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js", Cms.scrub_path(full_windows_path)
+
+    # multiple
+    full_windows_path = "c:/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js c:/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/custom.js"
+    assert_equal "/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js /Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/custom.js", full_windows_path.gsub(pattern, "/")
+    assert_equal "/Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/jquery-ui.js /Ruby/lib/ruby/gems/1.8/gems/browsercms-3.0.0/public/javascripts/custom.js", Cms.scrub_path(full_windows_path)
+
+    # not scrub if in middle of string
+    full_windows_path = "c:/Ruby/lib/ruby/gems/1.8/gems:local/browsercms-3.0.0/public/javascripts/jquery-ui.js"
+    assert_equal "/Ruby/lib/ruby/gems/1.8/gems:local/browsercms-3.0.0/public/javascripts/jquery-ui.js", full_windows_path.gsub(pattern, "/")
+    assert_equal "/Ruby/lib/ruby/gems/1.8/gems:local/browsercms-3.0.0/public/javascripts/jquery-ui.js", Cms.scrub_path(full_windows_path)
+
+  end
+ 
+end

data/test/unit/lib/routes_test.rb

@@ -0,0 +1,98 @@
+require 'test_helper'
+
+class RouteBuilder
+  include Cms::RouteExtensions
+end
+
+class Bear < ActiveRecord::Base
+  acts_as_content_block
+end
+
+class Kindness < ActiveRecord::Base
+  acts_as_content_block
+end
+
+# This verifiest the behavior of how BrowserCMS creates new routes
+# for projects.
+class RoutesTest < ActiveSupport::TestCase
+
+  def setup
+    @routes = RouteBuilder.new
+  end
+
+  test "Verify behavior of classify, and how it works with already pluralized symbols" do
+    assert_equal "Kindness", :kindnesses.to_s.classify, "routes will pass 'plural' symbols to 'content_block', rather than single"    
+  end
+
+
+  # These tests could be better, but I'm not entirely sure how to mock test syntax that looks like:
+  #
+  # resources content_block_name do
+  #   member do
+  #     put :publish if content_block.publishable?
+  #     get :versions if content_block.versioned?
+  #     get :usages if content_block.connectable?
+  #   end
+  # end
+  #
+  # Which is what 'content_blocks' is currently doing.
+  test "behavior of 'content_blocks' route generator" do
+    rb = RouteBuilder.new
+
+    # Expect
+    rb.expects(:resources).with(:bears)
+    rb.expects(:get).with('/bears/:id/version/:version', {:to => 'bears#version', :as => :version_cms_bears})
+    rb.expects(:put)
+    rb.content_blocks :bears
+
+    # Verifies the exact messages being passed to the route generator
+  end
+
+  # Could be better. See previous method.
+  test "model names with s at the end behave identically (since content_blocks expects plural symbols)" do
+    rb = RouteBuilder.new
+    rb.expects(:resources).with(:kindnesses)
+    rb.expects(:get).with('/kindnesses/:id/version/:version', {:to => 'kindnesses#version', :as => :version_cms_kindnesses})
+    rb.expects(:put)
+
+    rb.content_blocks :kindnesses
+
+    # Verifies the exact messages being passed to the route generator
+  end
+
+end
+
+module BcmsZoo
+  class Engine < Rails::Engine
+    include Cms::Module
+  end
+  class Lion < ActiveRecord::Base
+    acts_as_content_block
+  end
+end
+
+class RoutingTest < ActiveSupport::TestCase
+  include Cms::RouteExtensions
+
+  def setup
+    stubs(:get)
+    stubs(:put)
+  end
+
+
+  test "Each CMS Engine stores the 'current' namespace" do
+    Cms::Module.expects(:current_namespace=).with("Cms")
+    Cms::Engine.routes
+  end
+
+  test "Other Engines store 'current_namespace'" do
+    Cms::Module.expects(:current_namespace=).with("BcmsZoo")
+    BcmsZoo::Engine.routes
+  end
+
+  test "handle models in modules with namespaces" do
+    expects(:resources).with(:lion)
+    Cms::Module.expects(:current_namespace).returns("BcmsZoo")
+    content_blocks :lion
+  end
+end

data/test/unit/mock_file_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class MockFileTest < ActiveSupport::TestCase
+
+  def setup
+
+  end
+
+  def teardown
+
+  end
+
+
+  test "mock files can have data read from them" do
+    file = mock_file()
+    assert_not_nil file.path
+    assert_equal "", open(file.path) { |f| f.read }
+  end
+end

data/test/unit/models/attachment_test.rb

@@ -0,0 +1,160 @@
+require 'test_helper'
+
+module Cms
+  class AttachmentTest < ActiveSupport::TestCase
+
+    def setup
+      @file = file_upload_object({:original_filename => "sample_upload.txt", :content_type => "text/plain"})
+
+    end
+
+    def test_creating_an_attachment_with_no_file
+      attachment = Cms::Attachment.new
+      assert_not_valid attachment
+      assert_has_error_on attachment, :temp_file, "You must upload a file"
+    end
+
+    def test_creating_an_attachment_with_a_StringIO_file
+      file = @file
+      attachment = Cms::Attachment.new(:temp_file => file, :file_path => "/sample_upload.txt", :section => root_section)
+
+      attachment.save!
+      assert_equal "sample_upload.txt", attachment.file_name
+      assert_equal "text/plain", attachment.file_type
+      assert_equal "txt", attachment.file_extension
+      assert_file_exists attachment.full_file_location
+      assert_equal "This is a file.", open(attachment.full_file_location) { |f| f.read }
+    end
+
+    def test_creating_an_attachment_with_a_Tempfile_file
+      attachment = Cms::Attachment.new(:temp_file => @file, :file_path => "/foo.txt", :section => root_section)
+      attachment.save!
+
+      assert_equal "foo.txt", attachment.file_name
+      assert_file_exists attachment.full_file_location
+      assert_equal "This is a file.", open(attachment.full_file_location) { |f| f.read }
+
+      # If you change the attributes of the attachment, but don't change the file
+      # the file_location should not change
+      original_file_location = attachment.file_location
+      attachment = Cms::Attachment.find(attachment.id)
+      attachment.update_attributes(:file_path => "bar.txt")
+      assert_equal 2, attachment.draft.version
+      assert_equal "/bar.txt", attachment.file_path
+      assert_equal "bar.txt", attachment.file_name
+      assert_equal original_file_location, attachment.file_location
+    end
+
+    def test_updating_a_new_file_should_change_the_file_location
+      attachment = Cms::Attachment.create!(:temp_file => @file, :file_path => "/foo.txt", :section => root_section)
+
+      reloaded_attachment = Cms::Attachment.find(attachment.id)
+      original_file_location = attachment.file_location
+      file = file_upload_object(:original_filename => "second_upload.txt", :content_type => "text/plain")
+      reloaded_attachment.update_attributes(:temp_file => file)
+      assert_equal 2, reloaded_attachment.draft.version
+      assert_equal "/foo.txt", reloaded_attachment.as_of_draft_version.file_path, "Updating the file itself should also update the name of the file. (Note:This might just be an invalid test)"
+      assert_equal "foo.txt", reloaded_attachment.as_of_draft_version.file_name
+      assert_not_equal original_file_location, reloaded_attachment.as_of_draft_version.file_location
+      assert_equal "This is a second file.", open(reloaded_attachment.as_of_draft_version.full_file_location) { |f| f.read }
+    end
+
+    def test_find_live_by_file_path
+      file = @file
+      attachment = Cms::Attachment.new(:temp_file => file, :file_path => "/foo.txt", :section => root_section)
+      attachment.save!
+      assert !attachment.published?, "Attachment should not be published"
+      assert_nil Cms::Attachment.find_live_by_file_path("/foo.txt")
+
+      attachment.publish
+      assert attachment.reload.published?, "Attachment should be published"
+      assert_equal attachment, Cms::Attachment.find_live_by_file_path("/foo.txt")
+
+      attachment.update_attributes(:file_type => "text/html")
+      assert !attachment.live?, "Attachment should not be live"
+      assert_equal attachment.as_of_version(2), Cms::Attachment.find_live_by_file_path("/foo.txt")
+    end
+
+
+    test "If an uploaded file has no detectable content type (i.e. markdown) then assign it the 'unknown' type" do
+      mock_file = mock()
+      mock_file.expects(:content_type).returns(nil)
+      atk = Cms::Attachment.new(:temp_file => mock_file)
+      atk.extract_file_type_from_temp_file
+
+      assert_equal Cms::Attachment::UNKNOWN_MIME_TYPE, atk.file_type
+    end
+  end
+
+  class Cms::Attachment::SectionTest < ActiveSupport::TestCase
+
+    def setup
+      @file = file_upload_object({:original_filename => "sample_upload.txt", :content_type => "text/plain"})
+      @attachment = Cms::Attachment.create!(:temp_file => @file, :file_path => "/foo.txt", :section => root_section)
+      @attachment = Cms::Attachment.find(@attachment.id) # Force reload
+    end
+
+    test "Setting the section on an attachment persists that section" do
+      assert_equal root_section, @attachment.section, "Should be associated with the root section"
+    end
+
+    test "Replacing an existing section should update it" do
+      new_section = Factory(:section)
+      @attachment.section = new_section
+      @attachment.save!
+      @attachment = Cms::Attachment.find(@attachment.id) # Force reload
+      assert_equal new_section, @attachment.section
+    end
+  end
+
+  class AttachmentRelations < ActiveSupport::TestCase
+
+    def setup
+      @file = file_upload_object({:original_filename => "sample_upload.txt", :content_type => "text/plain"})
+      @attachment = Attachment.new(:temp_file => @file, :file_path => "/bar.txt", :section => root)
+      @attachment.save!
+    end
+
+    test "#section= assigns a parent to a given attachment" do
+      a = Attachment.new
+      a.section = root
+      assert_equal root, a.section
+    end
+
+    test "Attachments should be associated with a section" do
+      assert_not_nil @attachment.section_node
+      assert_not_nil @attachment.section_node.parent
+      assert_equal root, @attachment.section
+    end
+
+    test "Attachment should be unpublished and unfindable" do
+      assert !@attachment.published?, "Attachment should not be published"
+      assert_nil Attachment.find_live_by_file_path("/foo.txt")
+    end
+
+    test "Publishing an attachment should make it findable" do
+      @attachment.publish
+      assert @attachment.reload.published?, "Attachment should be published"
+      assert_equal @attachment, Attachment.find_live_by_file_path("/bar.txt")
+    end
+
+    test "Changing but not republishing an attachment should keep old version live" do
+      @attachment.publish
+      assert_equal @root, @attachment.section
+      @attachment.update_attributes!(:file_type => "text/html")
+      assert !@attachment.live?, "Attachment should not be live"
+      assert_equal @attachment.as_of_version(2), Attachment.find_live_by_file_path("/bar.txt")
+    end
+
+    test "Updating the section" do
+      new_section = Factory(:section, :name => "New")
+      @attachment.update_attributes!(:section => new_section)
+      assert_equal new_section, @attachment.section
+    end
+    private
+
+    def root
+      @root ||= Factory :root_section
+    end
+  end
+end

data/test/unit/models/category_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class CategoryTest < ActiveSupport::TestCase
+  def test_creating_categories
+    @a_type = Factory(:category_type, :name => "A")
+    @b_type = Factory(:category_type, :name => "B")
+    
+    @a = Factory(:category, :name => "A", :category_type => @a_type)
+    @a1 = Factory(:category, :name => "A1", :category_type => @a_type, :parent => @a)
+    @a1a = Factory(:category, :name => "A1a", :category_type => @a_type, :parent => @a1)
+    @a2 = Factory(:category, :name => "A2", :category_type => @a_type, :parent => @a)
+    @b = Factory(:category, :name => "B", :category_type => @b_type)
+    @b1 = Factory(:category, :name => "B1", :category_type => @b_type, :parent => @b)
+    @b2 = Factory(:category, :name => "B2", :category_type => @b_type, :parent => @b)
+    
+    assert @a.parent.blank?
+    assert_equal [@a1, @a2], @a.children
+    
+    assert_equal @a, @a1.parent
+    assert_equal [@a1a], @a1.children
+    
+    assert_equal @a, @a2.parent
+    assert @a2.children.blank?
+    
+    assert @a.ancestors.blank?
+    assert_equal [@a], @a1.ancestors
+    assert_equal [@a, @a1], @a1a.ancestors
+    
+    assert_equal "#{@a.name}", @a.path
+    assert_equal "#{@a.name} > #{@a1.name}", @a1.path
+    assert_equal "#{@a.name} > #{@a1.name} > #{@a1a.name}", @a1a.path
+    
+    assert_equal [
+      "#{@a.name}",
+      "#{@a.name} > #{@a1.name}",
+      "#{@a.name} > #{@a1.name} > #{@a1a.name}",
+      "#{@a.name} > #{@a2.name}"
+    ], Cms::Category.of_type("A").all.map(&:path)
+  end
+end

data/test/unit/models/category_type_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class CategoryTypeTest < ActiveSupport::TestCase
+  def test_create
+    category_type = Cms::CategoryType.new(:name => "Test")
+    assert category_type.save
+  end
+end

data/test/unit/models/connector_test.rb

@@ -0,0 +1,152 @@
+require 'test_helper'
+
+class ConnectorTest < ActiveSupport::TestCase
+  
+  def test_container_is_required
+    connector = Factory.build(:connector, :container => nil)
+    assert_not_valid connector
+    assert_has_error_on connector, :container
+  end
+  
+  def test_find_by_block
+    foo = Factory(:html_block, :name => "foo")
+    bar = Factory(:html_block, :name => "bar")
+    Factory(:connector, :connectable => foo, :connectable_version => foo.version)
+    blocks = Cms::Connector.for_connectable(foo).map(&:connectable)
+    assert blocks.include?(foo)
+    assert !blocks.include?(bar)
+  end
+  
+  def test_only_find_connectors_for_a_block_that_match_the_current_version
+    @foo = Factory(:html_block, :name => "foo")
+    @foo.update_attribute(:name, "foo v2")
+    @bar = Factory(:html_block, :name => "bar")
+    @con = Factory(:connector, :connectable => @foo)
+    @con.update_attribute(:connectable_version, 99)
+    reset(:con)
+    assert_raise(ActiveRecord::RecordNotFound) { @con.current_connectable }
+  end
+  
+  def test_only_find_connectors_for_the_current_version_of_the_page
+    @page = Factory(:page, :section => root_section)
+    @connector = Factory(:connector, :page => @page)
+    @page.update_attributes(:name => "Updated")
+    assert_equal 1, @page.reload.connectors.for_page_version(@page.version).count
+  end
+  
+  def test_blocks_not_deleted_when_connector_is_not_deleted
+    b = Factory(:html_block)
+    c = Factory(:connector, :connectable => b)
+    connector_count = Cms::Connector.count
+    c.destroy
+    assert_decremented connector_count, Cms::Connector.count
+    assert !Cms::HtmlBlock.find_by_id(b.id).nil?
+  end
+  
+  def test_re_order_blocks_within_a_container
+    page = Factory(:page)
+    one = Factory(:connector, :page => page, :container => "foo")
+    two = Factory(:connector, :page => page, :container => "foo")
+    three = Factory(:connector, :page => page, :container => "foo")
+    
+    two.reload.move_up
+    assert_equal [two, one, three].map(&:id),
+      page.reload.connectors.for_page_version(page.version).in_container("foo").all.map(&:id)
+    
+    two.reload.move_down
+    assert_equal [one, two, three],
+      page.reload.connectors.for_page_version(page.version).in_container("foo").all
+    
+    three.reload.move_to_top
+    assert_equal [three, one, two],
+      page.reload.connectors.for_page_version(page.version).in_container("foo").all
+    
+    one.reload.move_to_bottom
+    assert_equal [three, two, one],
+      page.reload.connectors.for_page_version(page.version).in_container("foo").all
+  end
+  
+  def test_connectable_with_deleted
+    @page = Factory(:page)
+    @block = Factory(:html_block, :name => "Deleted", 
+      :connect_to_page_id => @page.id,
+      :connect_to_container => "main",
+      :publish_on_save => "true")
+    
+    reset(:page, :block)
+    @block.destroy
+    
+    reset(:page)
+
+    log_table_without_stamps Cms::Connector
+    
+    assert_nil @page.connectors.for_page_version(2).first.connectable
+    
+    c = @page.connectors.for_page_version(2).first.connectable_with_deleted
+    assert !c.nil?
+    assert_equal @block.id, c.id
+    assert_equal @block.name, c.name
+    assert_equal 1, c.version
+  end
+
+  def test_connector_should_be_copied_when_it_has_a_connectable
+    @page = Factory(:page)
+    @block = Factory(:html_block, :connect_to_page_id => @page.id, :connect_to_container => "main")
+
+    conn = Cms::Connector.new
+    conn.connectable = @block
+    assert(conn.connectable, "Check the assumption there is connectable.")
+    assert_equal(false, conn.connectable.draft.deleted?, "Check the assumption that the draft is not-deleted.")
+
+    assert(conn.should_be_copied?, "Verifes that normally a connector should be copied.")
+  end
+
+  def test_connector_shouldnt_copy_when_its_connectable_is_nil
+    conn = Cms::Connector.new
+    assert_nil(conn.connectable, "Check assumption that connectable is nil.")
+
+    assert_equal false, conn.should_be_copied?, "Shouldn't copy when a connector isn't connected to anything."
+  end
+
+  def test_connector_should_copy_when_its_latest_draft_is_deleted
+    @page = Factory(:page)
+    @block = Factory(:html_block, :connect_to_page_id => @page.id, :connect_to_container => "main")
+
+    @block.destroy
+
+    conn = Cms::Connector.new
+    conn.connectable = @block
+
+    assert_equal true, @block.draft.deleted?, "Check assumption that latest draft of this block is 'deleted'."
+    assert_equal false, conn.should_be_copied?, "Should not copy when latest draft is deleted."
+
+  end
+
+  def test_connector_should_copy_even_if_connectable_doesnt_have_drafts
+    @page = Factory(:page)
+    @block = Cms::Portlet.create!(:name => "Stuff")
+
+    conn = Cms::Connector.new
+    conn.connectable = @block
+
+    assert_equal false, @block.respond_to?(:draft), "Check assumption that portlets do not respond to draft method."
+    assert_equal true, conn.should_be_copied?, "Should not copy when latest draft is deleted."
+
+  end
+  
+  def test_connector_with_file_block_status
+    @page = Factory(:page)
+    @file = Factory(:image_block, :connect_to_page_id => @page.id, :connect_to_container => "main", :publish_on_save => true)
+    @page.reload
+    
+    assert @file.live?
+    assert @page.connectors.last.live?
+    
+    @file.update_attributes(:name => "Something Else")
+    @page.reload
+
+    assert !@file.live?
+    assert !@page.connectors.last.live?    
+  end  
+  
+end