browsercms 3.4.2 → 3.5.0.rc1

data/test/unit/models/image_block_test.rb

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

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

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

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

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

data/test/unit/models/page_template_test.rb

@@ -1,50 +0,0 @@
-require 'test_helper'
-
-class PageTemplateTest < ActiveSupport::TestCase
-  def setup
-    @page_template = Factory.build(:page_template, :name => "test")
-    File.delete(@page_template.file_path) if File.exists?(@page_template.file_path)
-  end
-
-  def teardown
-    File.delete(@page_template.file_path) if File.exists?(@page_template.file_path)
-  end
-
-
-  test "Name used to build the form" do
-    assert_equal "page_template", Cms::PageTemplate.resource_collection_name
-  end
-
-  test "resource_name works for namespaced templates" do
-    assert_equal "page_templates", Cms::PageTemplate.resource_name
-
-  end
-
-  def test_create_and_destroy
-    assert !File.exists?(@page_template.file_path), "template file already exists"
-    assert_valid @page_template
-    assert @page_template.save
-    assert File.exists?(@page_template.file_path), "template file was not written to disk"
-    @page_template.destroy
-    assert !File.exists?(@page_template.file_path), "template file was not removed on destroy"
-  end
-
-  def test_for_valid_name
-    assert_not_valid Factory.build(:page_template, :name => "Fancy")
-    assert_not_valid Factory.build(:page_template, :name => "foo bar")
-    assert_valid Factory.build(:page_template, :name => "subpage_1_column")
-  end
-
-  def test_find_by_file_name
-    assert @page_template.save, "Could not save page template"
-    assert_equal @page_template, Cms::PageTemplate.find_by_file_name("test.html.erb")
-    assert_nil Cms::PageTemplate.find_by_file_name("fail.html.erb")
-    assert_nil Cms::PageTemplate.find_by_file_name("fail.erb")
-    assert_nil Cms::PageTemplate.find_by_file_name("fail")
-    assert_nil Cms::PageTemplate.find_by_file_name(nil)
-  end
-
-  def test_default_body
-    assert_not_nil Cms::PageTemplate.default_body
-  end
-end

data/test/unit/models/page_test.rb

@@ -1,879 +0,0 @@
-require 'test_helper'
-
-module Cms
-  class CreatingPageTest < ActiveSupport::TestCase
-
-    test "Testing Database should be empty and have no pages" do
-      assert_nil Cms::Page.with_path("/").first
-    end
-
-    def test_creating_a_page_and_updating_the_attributes
-      @page = Cms::Page.new(
-          :name => "Test",
-          :path => "test",
-          :section => root_section,
-          :publish_on_save => true)
-
-      assert @page.save
-      assert_path_is_unique
-
-      @page.update_attributes(:name => "Test v2")
-      page = Cms::Page.find_live_by_path("/test")
-      assert_equal "Test", page.name
-
-      assert_equal 1, page.version
-
-    end
-
-    test "Creating a page builds a section node" do
-      @page = Page.create!(:name => "Hello", :path => "/hello", :section => Factory(:root_section))
-      assert_not_nil @page.section_node
-    end
-
-    test "page with no parent" do
-      @page = Page.new
-      assert_nil @page.parent
-    end
-
-    test "#section is alias for #parent" do
-      @page = Page.new
-      assert_nil @page.section
-    end
-
-
-    protected
-    def assert_path_is_unique
-      page = Factory.build(:page, :path => @page.path)
-      assert_not_valid page
-      assert_has_error_on page, :path
-    end
-
-  end
-
-  class VersionTest < ActiveSupport::TestCase
-
-    def setup
-      @page = Factory(:public_page)
-      @another_page = Factory(:public_page)
-    end
-
-    test "#latest_version set set when page is created" do
-      assert_equal 1, @page.version
-      assert_equal 1, @page.latest_version
-    end
-
-    test "#latest_version is incremented when page#update occurs" do
-      @page.name = "New"
-      @page.save!
-      @page.reload
-
-      assert_equal 1, @page.version
-      assert_equal 2, @page.latest_version
-
-      assert_equal 1, @another_page.reload.latest_version, "Should only update its own version, not other tables"
-    end
-
-    test "live? using latest version" do
-      assert @page.live?
-
-      @page.update_attributes(:name => "New")
-      @page.reload
-      refute @page.live?
-
-      @page.publish!
-      @page.reload
-      assert @page.live?
-    end
-
-    test "live? as_of_version" do
-      @page.update_attributes(:name => "New")
-      @page.publish!
-
-      v1 = @page.as_of_version(1)
-      assert v1.live?
-    end
-  end
-  class PageTest < ActiveSupport::TestCase
-
-    def test_creating_page_with_reserved_path
-      @page = Cms::Page.new(:name => "FAIL", :path => "/cms")
-      assert_not_valid @page
-      assert_has_error_on(@page, :path, "is invalid, '/cms' a reserved path")
-
-      @page = Cms::Page.new(:name => "FAIL", :path => "/cache")
-      assert_not_valid @page
-      assert_has_error_on(@page, :path, "is invalid, '/cache' a reserved path")
-
-      @page = Cms::Page.new(:name => "FTW", :path => "/whatever")
-
-      assert_valid @page
-    end
-
-    def test_creating_page_with_trailing_slash
-      @page = Factory.build(:page, :path => "/slashed/")
-      @page.save
-      assert_equal @page.path, "/slashed"
-
-      @page = Factory.build(:page, :path => "/slashed/loooong/path/")
-      @page.save
-      assert_equal @page.path, "/slashed/loooong/path"
-    end
-
-    def test_find_live_by_path
-      @page = Factory.build(:page, :path => '/foo')
-      assert_nil Cms::Page.find_live_by_path('/foo')
-
-      @page.publish!
-      reset(:page)
-      assert_equal @page, Cms::Page.find_live_by_path('/foo')
-
-      @page.update_attributes(:path => '/bar')
-      assert_equal @page, Cms::Page.find_live_by_path('/foo')
-      assert_nil Cms::Page.find_live_by_path('/bar')
-
-      @page.publish!
-      reset(:page)
-      assert_nil Cms::Page.find_live_by_path('/foo')
-      assert_equal @page, Cms::Page.find_live_by_path('/bar')
-    end
-
-    test "It should be possible to create a new page, using the same path as a previously deleted page" do
-      Cms::Page.delete_all
-      p = Time.now.to_f.to_s #use a unique, but consistent path
-
-      @page = Factory(:published_page, :path => "/#{p}")
-      @page.destroy
-
-      @page2 = Factory(:published_page, :path => "/#{p}")
-      assert_not_equal(@page, @page2)
-    end
-
-    test "Find by live path should not located deleted blocks, even if they share paths with live ones" do
-      @page = Factory.build(:page, :path => '/foo')
-      @page.publish!
-      reset(:page)
-
-      @page.mark_as_deleted!
-      assert_nil Cms::Page.find_live_by_path('/foo')
-
-      @new_page = Factory.build(:page, :path => '/foo')
-      assert_nil Cms::Page.find_live_by_path('/foo')
-
-      @new_page.publish!
-      reset(:new_page)
-      assert_equal @new_page, Cms::Page.find_live_by_path('/foo')
-      assert_not_equal @page, @new_page
-    end
-
-    def test_path_normalization
-      page = Factory.build(:page, :path => 'foo/bar')
-      assert_valid page
-      assert_equal "/foo/bar", page.path
-
-      page = Factory.build(:page, :path => '/foo/bar')
-      assert_valid page
-      assert_equal "/foo/bar", page.path
-    end
-
-    def test_template
-      page_template = Factory(:page_template, :name => 'test')
-      page = Factory.build(:page, :template_file_name => 'test.html.erb')
-      assert_equal 'test.html.erb', page.template_file_name
-      assert_equal 'Test (html/erb)', page.template_name
-      assert_equal page_template, page.template
-      assert_equal 'templates/test', page.layout
-
-      page = Factory.build(:page, :template_file_name => 'foo.html.erb')
-      assert_equal 'foo.html.erb', page.template_file_name
-      assert_equal 'Foo (html/erb)', page.template_name
-      assert_nil page.template
-      assert_equal 'templates/foo', page.layout
-    end
-
-    def test_revision_comments
-      page = Factory(:page, :section => root_section, :name => "V1")
-
-      assert_equal 'Created', page.live_version.version_comment
-
-      assert page.reload.save
-      assert_equal 'Created', page.reload.live_version.version_comment
-      assert_equal page.live_version.version_comment,
-                   page.as_of_version(page.version).live_version.version_comment
-
-      page.update_attributes(:name => "V2")
-      assert_equal 'Changed name', page.draft.version_comment
-      assert_equal 'Created', page.live_version.version_comment
-
-      block = Factory(:html_block, :name => "Hello, World!")
-      page.create_connector(block, "main")
-      assert_equal "Html Block 'Hello, World!' was added to the 'main' container",
-                   page.draft.version_comment
-      assert_equal 'Created', page.live_version.version_comment
-      assert_equal 3, page.reload.draft.version
-
-      page.create_connector(Factory(:html_block, :name => "Whatever"), "main")
-      assert_equal 4, page.reload.draft.version
-
-      page.move_connector_down(page.connectors.for_page_version(page.reload.draft.version).for_connectable(block).first)
-      assert_equal "Html Block 'Hello, World!' was moved down within the 'main' container",
-                   page.draft.version_comment
-      assert_equal 'Created', page.live_version.version_comment
-
-      page.move_connector_up(page.connectors.for_page_version(page.reload.draft.version).for_connectable(block).first)
-      assert_equal "Html Block 'Hello, World!' was moved up within the 'main' container",
-                   page.draft.version_comment
-      assert_equal 'Created', page.live_version.version_comment
-
-      page.remove_connector(page.connectors.for_page_version(page.reload.draft.version).for_connectable(block).first)
-      assert_equal "Html Block 'Hello, World!' was removed from the 'main' container",
-                   page.draft.version_comment
-      assert_equal 'Created', page.live_version.version_comment
-
-      page.revert_to(1)
-      assert_equal "Reverted to version 1",
-                   page.reload.draft.version_comment
-      assert_equal 'Created', page.live_version.version_comment
-
-      assert_equal "Created", page.as_of_version(1).current_version.version_comment
-      assert_equal "Changed name", page.as_of_version(2).current_version.version_comment
-      assert_equal "Reverted to version 1", page.draft.version_comment
-
-    end
-
-    def test_container_live
-      page = Factory(:page)
-      published = Factory(:html_block, :publish_on_save => true)
-      unpublished = Factory(:html_block)
-      page.create_connector(published, "main")
-      page.create_connector(unpublished, "main")
-      assert !page.container_published?("main")
-      assert unpublished.publish
-      assert page.container_published?("main")
-    end
-
-    def test_move_page_to_another_section
-      page = Factory(:public_page)
-      new_section = Factory(:public_section)
-
-      assert_not_equal new_section, page.section
-      page.section = new_section
-      assert page.save
-      assert_equal new_section, page.section
-    end
-
-    def test_deleting_page
-      page = Factory(:page)
-      page_count = Cms::Page.count_with_deleted
-
-      page_version_count = page.versions.count
-      assert !page.deleted?
-
-      page.destroy
-
-      assert_equal page_count, Cms::Page.count_with_deleted
-      assert_incremented page_version_count, page.versions.count
-      assert page.deleted?
-      assert_raise ActiveRecord::RecordNotFound do
-        Cms::Page.find(page.id)
-      end
-
-    end
-
-    def test_adding_a_block_to_a_page_puts_page_in_draft_mode
-      @page = Factory(:page, :section => root_section, :publish_on_save => true)
-      @block = Factory(:html_block, :publish_on_save => true)
-      reset(:page, :block)
-      assert @page.published?
-      assert @block.published?
-      @page.create_connector(@block, "main")
-      reset(:page, :block)
-      assert !@page.live?
-    end
-
-    def test_reverting_and_then_publishing_a_page
-      @page = Factory(:page, :section => root_section, :publish_on_save => true)
-
-      @block = Factory(:html_block,
-                       :connect_to_page_id => @page.id,
-                       :connect_to_container => "main")
-      @page.publish
-
-      reset(:page, :block)
-
-      assert_equal 2, @page.version
-      assert_equal 1, @page.connectors.for_page_version(@page.version).count
-
-      @block.update_attributes(:content => "Something else")
-      @page.publish!
-      reset(:page, :block)
-
-      assert_equal 1, @page.connectors.for_page_version(@page.version).count
-      assert_equal 2, @block.version
-      assert_equal 3, @page.version
-      assert @block.live?
-      assert @page.live?
-
-      @page.revert_to(2)
-      reset(:page, :block)
-
-      assert_equal 3, @page.version
-      assert_equal 4, @page.draft.version
-      assert_equal 2, @block.version
-      assert_equal 3, @block.draft.version
-      assert_equal 1, @page.connectors.for_page_version(@page.version).count
-      assert_equal 1, @page.connectors.for_page_version(@page.draft.version).count
-      assert !@page.live?
-      assert !@block.live?
-
-    end
-
-  end
-
-  class UserStampingTest < ActiveSupport::TestCase
-
-    def setup
-      @first_guy = Factory(:user, :login => "first_guy")
-      @next_guy = Factory(:user, :login => "next_guy")
-      Cms::User.current = @first_guy
-    end
-
-    def teardown
-      Cms::User.current = nil
-    end
-
-    def test_user_stamps_are_applied_to_versions
-      page = Factory(:page, :name => "Original Value")
-
-      assert_equal page, page.draft.page
-      assert_equal @first_guy, page.updated_by
-
-      Cms::User.current = @new_guy
-
-      page.update_attributes(:name => "Something Different")
-
-      assert_equal "Something Different", page.draft.name
-      assert_equal "Original Value", page.reload.name
-      assert_equal "Original Value", page.versions.first.name
-      assert_equal @first_guy, page.versions.first.updated_by
-      assert_equal @new_guy, page.versions.last.updated_by
-      assert_equal 2, page.versions.count
-    end
-
-  end
-
-  class PageInSectionTest < ActiveSupport::TestCase
-
-    def setup
-      @root = Factory(:root_section, :name => "First Section")
-      @football_section = Factory :public_section, :name => "Football", :parent => @root
-      @baseball_section = Factory :public_section, :name => "Baseball", :parent => @root
-
-      @football_page = Factory :public_page, :section => @football_section
-      @baseball_page = Factory :public_page, :section => @baseball_section
-    end
-
-    test "in_section if immediate parent section is included" do
-      assert @football_page.in_section?("Football")
-      assert !@baseball_page.in_section?("Football")
-    end
-
-    test "in_section if immediate parent's name is included" do
-      assert @football_page.in_section?("Football")
-      assert !@baseball_page.in_section?("Football")
-    end
-
-    test "in_section if any ancestor is included" do
-      assert @football_page.in_section?(@root)
-      assert @baseball_page.in_section?(@root)
-      assert @football_page.in_section?("First Section")
-      assert @baseball_page.in_section?("First Section")
-    end
-
-    test "#top_level_section" do
-      assert_equal @football_section, @football_page.top_level_section
-      assert_equal @baseball_section, @baseball_page.top_level_section
-
-      second_level_section = Factory(:public_section, :parent => @football_section)
-      second_level_page = Factory(:public_page, :section => second_level_section)
-      assert_equal @football_section, second_level_page.top_level_section
-    end
-
-    test "#top_level_section caches result to avoid repeated requests" do
-      top = @football_page.top_level_section
-      assert_equal top.object_id, @football_page.top_level_section.object_id
-    end
-  end
-
-  class PageWithAssociatedBlocksTest < ActiveSupport::TestCase
-    def setup
-      super
-      @page = Factory(:page, :section => root_section, :name => "Bar")
-      @block = Factory(:html_block)
-      @other_connector = Factory(:connector, :connectable => @block, :connectable_version => @block.version)
-      @page_connector = Factory(:connector, :page => @page, :page_version => @page.version, :connectable => @block, :connectable_version => @block.version)
-    end
-
-    # It should create a new page version and a new connector
-    def test_updating_the_page_with_changes
-      Cms::Page.delete_all
-      connector_count = Cms::Connector.count
-
-      page_version = @page.version
-      @page.update_attributes(:name => "Foo")
-
-      assert_incremented connector_count, Cms::Connector.count
-      assert_equal page_version, @page.version
-      assert_incremented page_version, @page.draft.version
-    end
-
-    # It should not create a new page version or a new connector
-    def test_updating_the_page_without_changes
-      connector_count = Cms::Connector.count
-      page_version = @page.version
-
-      @page.update_attributes(:name => @page.name)
-
-      assert_equal connector_count, Cms::Connector.count
-
-      assert_equal page_version, @page.version
-    end
-
-    # Verifies that 'after_destroy' callbacks happen on Page/SoftDeleting objects, such that
-    # a deleted page is disassociated with any blocks it was connected to.
-    test "Destroying a page with a block should remove its connectors from the database completely." do
-
-      connector_count = Cms::Connector.count
-      assert Cms::Connector.exists?(@page_connector.id)
-      assert Cms::Connector.exists?(@other_connector.id)
-
-      @page.destroy
-
-      assert_decremented connector_count, Cms::Connector.count
-      assert !Cms::Connector.exists?(@page_connector.id)
-      assert Cms::Connector.exists?(@other_connector.id)
-      assert Cms::HtmlBlock.exists?(@block.id)
-      assert !@block.deleted?
-    end
-
-
-  end
-
-  class AddingBlocksTest < ActiveSupport::TestCase
-
-    def setup
-      @page = Factory(:page)
-      @block = Factory(:html_block)
-      @original_versions_count = @page.versions.count
-      @connector_count = Cms::Connector.count
-
-      @connector = @page.create_connector(@block, "main")
-      reset(:page, :block)
-    end
-
-    test "Adding a block to a page without publishing" do
-      assert_equal 1, @page.version, "The unpublished page should still be version 1"
-      assert_equal 2, @connector.page_version, "The connector should point to version 2 of the page"
-      assert_equal 1, @connector.connectable_version, "Connector should point to version 1 of the block"
-      assert_incremented @original_versions_count, @page.versions.count # "There should be a new version of the page"
-      assert_equal 1, @page.connectors.for_page_version(@page.draft.version).count
-
-      assert_equal @connector_count + 1, Cms::Connector.count, "Adding the first block to a page should add exactly one connector"
-    end
-
-    test "Adding additional blocks to a page" do
-      block2 = Factory(:html_block)
-
-
-      conn = @page.create_connector(block2, "main")
-
-      assert_equal 1, @page.version
-      assert_equal 1, conn.connectable_version
-      assert_equal 3, @page.versions.count, "Should be three versions of the page now"
-      assert_equal 3, @page.draft.version, "Latest draft of a page should be 3"
-      assert_equal 2, @page.connectors.for_page_version(@page.draft.version).count
-      assert_equal @connector_count + 3, Cms::Connector.count, "Adding a second block to an existing page should add 3 total connectors."
-    end
-
-    test "Creating a new block to a page should update all existing connectors to the new page version." do
-      Rails.logger.warn "Creating a new connector"
-      @page.create_connector(Factory(:html_block), "main")
-      expected_version = 3
-      Rails.logger.warn "Done"
-      connectors = @page.connectors.for_page_version(expected_version)
-      assert_equal expected_version, connectors[0].page_version, "There should be two connectors with the same version as the page"
-      assert_equal expected_version, connectors[1].page_version
-      assert_equal 2, connectors.count, "There should be two connectors total for the page for this version (3) of the page."
-
-    end
-  end
-
-  class AddingBlocksToPageTest < ActiveSupport::TestCase
-
-
-    def test_that_it_works
-      @page = Factory(:page, :section => root_section)
-      @block = Factory(:html_block)
-      @block2 = Factory(:html_block)
-      @first_conn = @page.create_connector(@block, "testing")
-      @second_conn = @page.create_connector(@block2, "testing")
-
-      page_version_count = @page.versions.count
-      connector_count = Cms::Connector.count
-
-      @conn = @page.create_connector(@block2, "testing")
-
-      assert_equal 1, @page.reload.version
-      assert_equal 4, @conn.page_version
-      assert_equal 1, @conn.connectable_version
-      assert_incremented page_version_count, @page.versions.count
-      assert_equal 3, @page.connectors.for_page_version(@page.draft.version).count
-      assert_equal connector_count + 3, Cms::Connector.count
-
-
-      # should leave the previous connectors untouched
-      @conns = @page.connectors.all(:conditions => ["page_version < 4"], :order => "id")
-
-      assert_equal 3, @conns.size
-
-      assert_properties @conns[0], {
-          :connectable => @block,
-          :page => @page,
-          :page_version => 2,
-          :connectable_version => 1
-      }
-
-      assert_properties @conns[1], {
-          :connectable => @block,
-          :page => @page,
-          :page_version => 3,
-          :connectable_version => 1
-      }
-
-      assert_properties @conns[2], {
-          :connectable => @block2,
-          :page => @page,
-          :page_version => 3,
-          :connectable_version => 1
-      }
-
-      @conns = @page.connectors.for_page_version(4).all(:order => "id")
-      assert_equal 3, @conns.size
-
-      assert_properties @conns[0], {
-          :connectable => @block,
-          :page => @page,
-          :page_version => 4,
-          :connectable_version => 1
-      }
-
-      assert_properties @conns[1], {
-          :connectable => @block2,
-          :page => @page,
-          :page_version => 4,
-          :connectable_version => 1
-      }
-
-      assert_properties @conns[2], {
-          :connectable => @block2,
-          :page => @page,
-          :page_version => 4,
-          :connectable_version => 1
-      }
-
-    end
-  end
-
-  class PageWithTwoBlocksTest < ActiveSupport::TestCase
-    def setup
-      super
-      @page = Factory(:page, :section => root_section)
-      @foo_block = Factory(:html_block, :name => "Foo Block")
-      @bar_block = Factory(:html_block, :name => "Bar Block")
-      @page.create_connector(@foo_block, "whatever")
-      @page.reload
-      @page.create_connector(@bar_block, "whatever")
-      @page.reload
-    end
-
-    def test_editing_one_of_the_blocks_creates_a_new_version_of_the_page
-      page_version = @page.draft.version
-      @foo_block.update_attributes(:name => "Something Else")
-      assert_incremented page_version, @page.draft.version
-    end
-
-    # A page that had 2 blocks added to it and then had them removed,
-    # when reverting to the previous version,
-    # should restore the connectors from the version being reverted to
-    def test_removing_and_reverting_to_previous_version
-      remove_both_connectors!
-
-      connector_count = Cms::Connector.count
-
-      @page.revert
-
-      assert_incremented connector_count, Cms::Connector.count
-      assert_properties @page.reload.connectors.for_page_version(@page.draft.version).first, {
-          :page => @page,
-          :page_version => 6,
-          :connectable => @bar_block,
-          :connectable_version => 1,
-          :container => "whatever"}
-    end
-
-    # A page that had 2 blocks added to it and then had then removed,
-    # when reverting to the version that had both connectors,
-    # should restore the connectors that version
-    def test_removing_and_reverting_to_version_with_both_connectors
-      remove_both_connectors!
-
-      connector_count = Cms::Connector.count
-
-      @page.revert_to(3)
-
-      assert_equal connector_count + 2, Cms::Connector.count
-
-      foo, bar = @page.reload.connectors.for_page_version(@page.draft.version).find(:all, :order => "#{Cms::Connector.table_name}.position")
-
-      assert_properties foo, {
-          :page => @page,
-          :page_version => 6,
-          :connectable => @foo_block,
-          :connectable_version => 1,
-          :container => "whatever"}
-      assert_properties bar, {
-          :page => @page,
-          :page_version => 6,
-          :connectable => @bar_block,
-          :connectable_version => 1,
-          :container => "whatever"}
-
-    end
-
-    def test_updating_one_of_the_blocks_and_reverting_to_version_before_the_update
-      target_version = @page.draft.version
-      @foo_block.update_attributes!(:name => "Foo V2")
-      @page.reload
-
-      page_version = @page.draft.version
-      foo_block_version = @foo_block.draft.version
-
-      @page.revert_to(target_version)
-
-      assert_incremented page_version, @page.draft.version
-      assert_incremented foo_block_version, @foo_block.draft.version
-      assert_equal "Foo Block", @page.connectors.for_page_version(@page.draft.version).reload.first.connectable.name
-    end
-
-    protected
-    def remove_both_connectors!
-      @page.remove_connector(@page.connectors.for_page_version(@page.draft.version).first(:order => "#{Cms::Connector.table_name}.position"))
-      @page.remove_connector(@page.connectors.for_page_version(@page.draft.version).first(:order => "#{Cms::Connector.table_name}.position"))
-    end
-
-
-  end
-
-  class PageWithBlockTest < ActiveSupport::TestCase
-    def setup
-      @page = Factory(:page, :section => root_section)
-      @block = Factory(:html_block)
-      @conn = @page.create_connector(@block, "bar")
-      @page.publish!
-      @conn = @page.connectors.for_page_version(@page.version).for_connectable(@block).first
-    end
-
-    def test_removing_connector
-      page_version = @page.draft.version
-      page_version_count = Cms::Page::Version.count
-      assert @page.published?
-
-      @page.remove_connector(@conn)
-
-      assert_incremented page_version_count, Cms::Page::Version.count
-
-      assert_incremented page_version, @page.draft.version
-
-      conns = @page.connectors.for_page_version(@page.draft.version-1).all
-      assert_equal 1, conns.size
-
-      assert_properties conns.first, {
-          :page => @page,
-          :page_version => page_version,
-          :connectable => @block,
-          :connectable_version => @block.version
-      }
-
-      assert @page.reload.connectors.for_page_version(@page.draft.version).empty?
-      assert !@page.live?
-    end
-
-    def test_removing_multiple_connectors
-      @block2 = Factory(:html_block)
-      @conn2 = @page.create_connector(@block2, "bar")
-      @conn3 = @page.create_connector(@block2, "foo")
-      #Need to get the new connector that matches @conn2, otherwise you will delete an older version, not the latest connector
-      @conn2 = Cms::Connector.first(:conditions => {:page_id => @page.reload.id, :page_version => @page.draft.version, :connectable_id => @block2.id, :connectable_version => @block2.version, :container => "bar"})
-      @page.remove_connector(@conn2)
-
-      page_version_count = Cms::Page::Version.count
-      page_version = @page.draft.version
-      page_connector_count = @page.connectors.for_page_version(@page.draft.version).count
-
-      @conn = Cms::Connector.first(:conditions => {:page_id => @page.reload.id, :page_version => @page.draft.version, :connectable_id => @block2.id, :connectable_version => @block2.version, :container => "foo"})
-      @page.remove_connector(@conn)
-      @page.reload
-
-      assert_incremented page_version_count, Cms::Page::Version.count
-      assert_incremented page_version, @page.draft.version
-      assert_decremented page_connector_count, @page.connectors.for_page_version(@page.draft.version).count
-
-      conns = Cms::Connector.where("page_id = ?", @page.id).order("id")
-
-      assert_equal 9, conns.size
-
-      assert_properties conns[0], {:page => @page, :page_version => 2, :connectable => @block, :connectable_version => 1, :container => "bar", :position => 1}
-      assert_properties conns[1], {:page => @page, :page_version => 3, :connectable => @block, :connectable_version => 1, :container => "bar", :position => 1}
-      assert_properties conns[2], {:page => @page, :page_version => 3, :connectable => @block2, :connectable_version => 1, :container => "bar", :position => 2}
-      assert_properties conns[3], {:page => @page, :page_version => 4, :connectable => @block, :connectable_version => 1, :container => "bar", :position => 1}
-      assert_properties conns[4], {:page => @page, :page_version => 4, :connectable => @block2, :connectable_version => 1, :container => "bar", :position => 2}
-      assert_properties conns[5], {:page => @page, :page_version => 4, :connectable => @block2, :connectable_version => 1, :container => "foo", :position => 1}
-      assert_properties conns[6], {:page => @page, :page_version => 5, :connectable => @block, :connectable_version => 1, :container => "bar", :position => 1}
-      assert_properties conns[7], {:page => @page, :page_version => 5, :connectable => @block2, :connectable_version => 1, :container => "foo", :position => 1}
-      assert_properties conns[8], {:page => @page, :page_version => 6, :connectable => @block, :connectable_version => 1, :container => "bar", :position => 1}
-    end
-
-  end
-
-  class UnpublishedPageWithOnePublishedAndOneUnpublishedBlockTest < ActiveSupport::TestCase
-    def setup
-      @page = Factory(:page, :section => root_section)
-      @published_block = Factory(:html_block, :name => "Published")
-      @unpublished_block = Factory(:html_block, :name => "Unpublished")
-      @page.create_connector(@published_block, "main")
-      @page.create_connector(@unpublished_block, "main")
-      @published_block.publish!
-      @page.reload
-    end
-
-    def test_publishing_the_block
-      @unpublished_block.publish!
-      assert @unpublished_block.reload.published?
-      @page.reload
-      assert !@page.live?
-    end
-
-    def test_publishing_the_page
-      page_version_count = Cms::Page::Version.count
-      unpublished_block_version_count = @unpublished_block.versions.count
-      published_block_version_count = @published_block.versions.count
-
-      @page.publish!
-
-      assert_equal page_version_count, Cms::Page::Version.count
-      assert_equal unpublished_block_version_count, @unpublished_block.versions.count
-      assert_equal published_block_version_count, @published_block.versions.count
-      assert @page.live?
-      assert @unpublished_block.reload.live?
-      assert @published_block.reload.live?
-    end
-
-  end
-
-  class RevertingABlockThatIsOnMultiplePagesTest < ActiveSupport::TestCase
-    def test_that_it_reverts_both_pages
-      Cms::Page.delete_all
-
-      # 1. Create a new page (Page 1, v1)
-      @page1 = Factory(:page, :name => "Page 1")
-      assert_equal 1, @page1.version
-
-      # 2. Create a new page (Page 2, v1)
-      @page2 = Factory(:page, :name => "Page 2")
-
-      # 3. Add a new html block to Page 1. Save, don't publish. (Page 1, v2)
-      @block = Factory(:html_block, :name => "Block v1",
-                       :connect_to_page_id => @page1.id, :connect_to_container => "main")
-      reset(:page1, :page2, :block)
-      assert_equal 2, @page1.draft.version
-      assert_equal 1, @page2.draft.version
-
-      # 4. Goto page 2, and select that block. (Page 2, v2)
-      @page2.create_connector(@block, "main")
-      reset(:page1, :page2, :block)
-      assert_equal 2, @page1.draft.version
-      assert_equal 2, @page2.draft.version
-
-      # 5. Edit the block (Page 1, v3, Page 2, v3, Block v2)
-      @block.update_attributes!(:name => "Block v2")
-      reset(:page1, :page2, :block)
-      assert_equal 3, @page1.draft.version
-      assert_equal 3, @page2.draft.version
-      assert_equal 2, @block.draft.version
-
-      # 6. Revert page 1 to version 2. (Page 1, v4, Page 2, v4, Block v3)
-      @page1.revert_to(2)
-      reset(:page1, :page2, :block)
-      assert_equal 4, @page1.draft.version
-      assert_equal 3, @block.draft.version
-      assert_equal 4, @page2.draft.version
-
-      # Expected: Both page 1 and 2 will display the same version of the block (v1).
-      assert_equal "Block v1", @page1.connectors.first.connectable.name
-      assert_equal "Block v1", @page2.connectors.first.connectable.name
-
-    end
-
-  end
-
-  class ViewingAPreviousVersionOfAPageTest < ActiveSupport::TestCase
-
-    def test_that_it_shows_the_correct_version_of_the_blocks_it_is_connected_to
-      # 1. Create Page A (v1)
-      @page = Factory(:page, :section => root_section)
-
-      # 2. Add new Html Block A to Page A (Page A v2, Block A v1)
-      @block = Factory(:html_block, :name => "Block 1", :connect_to_page_id => @page.id, :connect_to_container => "main")
-      reset(:page, :block)
-      assert_equal 2, @page.draft.version
-      assert_equal 1, @block.draft.version
-
-      # 3. Publish Page A (Page A v3, Block A v2)
-      @page.publish!
-      reset(:page, :block)
-      assert_equal 2, @page.draft.version
-      assert_equal 1, @block.draft.version
-
-      # 4. Edit Block A (Page A v4, Block A v3)
-      @block.update_attributes!(:name => "Block 2")
-      reset(:page, :block)
-      assert_equal 2, @page.version
-      assert_equal 3, @page.draft.version
-      assert_equal 2, @block.draft.version
-
-      # Open Page A in a different browser (as guest)
-      @live_page = Cms::Page.find_live_by_path(@page.path)
-      assert_equal 2, @live_page.version
-      assert_equal "Block 1", @live_page.connectors.for_page_version(@live_page.version).first.connectable.live_version.name
-
-    end
-  end
-
-  class PortletsDontHaveDraftsTest < ActiveSupport::TestCase
-
-    def test_connectors_with_portlets_should_correctly_be_copied
-      @page = Factory(:page, :section => root_section)
-      @portlet = TagCloudPortlet.create(:name => "Portlet", :connect_to_page_id => @page.id, :connect_to_container => "main")
-
-      # Check some assumptions.
-      assert_equal 2, @page.draft.version, "Verifying that adding a portlet correctly increments page version."
-      connectors = Cms::Connector.for_connectable(@portlet)
-      assert_equal 1, connectors.size, "This portlet should have only 1 connector."
-
-      # Verifies that an exception is not thrown while removing connectors
-      @page.remove_connector(connectors[0])
-
-      assert_equal 3, @page.draft.version
-      assert @page.reload.connectors.for_page_version(@page.draft.version).empty?, "Verify that all connectors for the latest page are removed."
-    end
-  end
-end