comfortable_mexican_sofa 1.11.2 → 1.12.0

data/test/models/page_test.rb

@@ -5,49 +5,49 @@ require_relative '../test_helper'
 class CmsPageTest < ActiveSupport::TestCase
   
   def test_fixtures_validity
-    Cms::Page.all.each do |page|
+    Comfy::Cms::Page.all.each do |page|
       assert page.valid?, page.errors.full_messages.to_s
-      assert_equal page.content, page.render
+      assert_equal page.content_cache, page.render
     end
   end
   
   def test_validations
-    page = Cms::Page.new
+    page = Comfy::Cms::Page.new
     page.save
     assert page.invalid?
     assert_has_errors_on page, :site_id, :layout, :slug, :label
   end
   
   def test_validation_of_parent_presence
-    page = cms_sites(:default).pages.new(new_params)
+    page = comfy_cms_sites(:default).pages.new(new_params)
     assert !page.parent
     assert page.valid?, page.errors.full_messages.to_s
-    assert_equal cms_pages(:default), page.parent
+    assert_equal comfy_cms_pages(:default), page.parent
   end
   
   def test_validation_of_parent_relationship
-    page = cms_pages(:default)
+    page = comfy_cms_pages(:default)
     assert !page.parent
     page.parent = page
     assert page.invalid?
     assert_has_errors_on page, :parent_id
-    page.parent = cms_pages(:child)
+    page.parent = comfy_cms_pages(:child)
     assert page.invalid?
     assert_has_errors_on page, :parent_id
   end
   
   def test_validation_of_target_page
-    page = cms_pages(:child)
-    page.target_page = cms_pages(:default)
+    page = comfy_cms_pages(:child)
+    page.target_page = comfy_cms_pages(:default)
     page.save!
-    assert_equal cms_pages(:default), page.target_page
+    assert_equal comfy_cms_pages(:default), page.target_page
     page.target_page = page
     assert page.invalid?
     assert_has_errors_on page, :target_page_id
   end
   
   def test_validation_of_slug
-    page = cms_pages(:child)
+    page = comfy_cms_pages(:child)
     page.slug = 'slug.with.d0ts-and_things'
     assert page.valid?
     
@@ -59,7 +59,7 @@ class CmsPageTest < ActiveSupport::TestCase
   end
 
   def test_validation_of_slug_allows_unicode_accent_characters
-    page = cms_pages(:child)
+    page = comfy_cms_pages(:child)
     thai_character_ko_kai = "\u0e01"
     thai_character_mai_tho = "\u0E49"
     page.slug = thai_character_ko_kai + thai_character_mai_tho
@@ -67,22 +67,22 @@ class CmsPageTest < ActiveSupport::TestCase
   end
 
   def test_label_assignment
-    page = cms_sites(:default).pages.new(
+    page = comfy_cms_sites(:default).pages.new(
       :slug   => 'test',
-      :parent => cms_pages(:default),
-      :layout => cms_layouts(:default)
+      :parent => comfy_cms_pages(:default),
+      :layout => comfy_cms_layouts(:default)
     )
     assert page.valid?
     assert_equal 'Test', page.label
   end
   
   def test_creation
-    assert_difference ['Cms::Page.count', 'Cms::Block.count'] do
-      page = cms_sites(:default).pages.create!(
+    assert_difference ['Comfy::Cms::Page.count', 'Comfy::Cms::Block.count'] do
+      page = comfy_cms_sites(:default).pages.create!(
         :label  => 'test',
         :slug   => 'test',
-        :parent => cms_pages(:default),
-        :layout => cms_layouts(:default),
+        :parent => comfy_cms_pages(:default),
+        :layout => comfy_cms_layouts(:default),
         :blocks_attributes => [
           { :identifier => 'default_page_text',
             :content    => 'test' }
@@ -94,33 +94,33 @@ class CmsPageTest < ActiveSupport::TestCase
   end
   
   def test_initialization_of_full_path
-    page = Cms::Page.new
+    page = Comfy::Cms::Page.new
     assert_equal '/', page.full_path
     
-    page = Cms::Page.new(new_params)
+    page = Comfy::Cms::Page.new(new_params)
     assert page.invalid?
     assert_has_errors_on page, :site_id
     
-    page = cms_sites(:default).pages.new(new_params(:parent => cms_pages(:default)))
+    page = comfy_cms_sites(:default).pages.new(new_params(:parent => comfy_cms_pages(:default)))
     assert page.valid?
     assert_equal '/test-page', page.full_path
     
-    page = cms_sites(:default).pages.new(new_params(:parent => cms_pages(:child)))
+    page = comfy_cms_sites(:default).pages.new(new_params(:parent => comfy_cms_pages(:child)))
     assert page.valid?
     assert_equal '/child-page/test-page', page.full_path
     
-    Cms::Page.destroy_all
-    page = cms_sites(:default).pages.new(new_params)
+    Comfy::Cms::Page.destroy_all
+    page = comfy_cms_sites(:default).pages.new(new_params)
     assert page.valid?
     assert_equal '/', page.full_path
   end
   
   def test_sync_child_pages
-    page = cms_pages(:child)
-    page_1 = cms_sites(:default).pages.create!(new_params(:parent => page, :slug => 'test-page-1'))
-    page_2 = cms_sites(:default).pages.create!(new_params(:parent => page, :slug => 'test-page-2'))
-    page_3 = cms_sites(:default).pages.create!(new_params(:parent => page_2, :slug => 'test-page-3'))
-    page_4 = cms_sites(:default).pages.create!(new_params(:parent => page_1, :slug => 'test-page-4'))
+    page = comfy_cms_pages(:child)
+    page_1 = comfy_cms_sites(:default).pages.create!(new_params(:parent => page, :slug => 'test-page-1'))
+    page_2 = comfy_cms_sites(:default).pages.create!(new_params(:parent => page, :slug => 'test-page-2'))
+    page_3 = comfy_cms_sites(:default).pages.create!(new_params(:parent => page_2, :slug => 'test-page-3'))
+    page_4 = comfy_cms_sites(:default).pages.create!(new_params(:parent => page_1, :slug => 'test-page-4'))
     assert_equal '/child-page/test-page-1', page_1.full_path
     assert_equal '/child-page/test-page-2', page_2.full_path
     assert_equal '/child-page/test-page-2/test-page-3', page_3.full_path
@@ -143,12 +143,12 @@ class CmsPageTest < ActiveSupport::TestCase
   end
   
   def test_children_count_updating
-    page_1 = cms_pages(:default)
-    page_2 = cms_pages(:child)
+    page_1 = comfy_cms_pages(:default)
+    page_2 = comfy_cms_pages(:child)
     assert_equal 1, page_1.children_count
     assert_equal 0, page_2.children_count
     
-    page_3 = cms_sites(:default).pages.create!(new_params(:parent => page_2))
+    page_3 = comfy_cms_sites(:default).pages.create!(new_params(:parent => page_2))
     page_1.reload; page_2.reload
     assert_equal 1, page_1.children_count
     assert_equal 1, page_2.children_count
@@ -166,90 +166,120 @@ class CmsPageTest < ActiveSupport::TestCase
   end
   
   def test_cascading_destroy
-    assert_difference 'Cms::Page.count', -2 do
-      assert_difference 'Cms::Block.count', -2 do
-        cms_pages(:default).destroy
+    assert_difference 'Comfy::Cms::Page.count', -2 do
+      assert_difference 'Comfy::Cms::Block.count', -2 do
+        comfy_cms_pages(:default).destroy
       end
     end
   end
   
   def test_options_for_select
     assert_equal ['Default Page', '. . Child Page'], 
-      Cms::Page.options_for_select(cms_sites(:default)).collect{|t| t.first }
+      Comfy::Cms::Page.options_for_select(comfy_cms_sites(:default)).collect{|t| t.first }
     assert_equal ['Default Page'], 
-      Cms::Page.options_for_select(cms_sites(:default), cms_pages(:child)).collect{|t| t.first }
+      Comfy::Cms::Page.options_for_select(comfy_cms_sites(:default), comfy_cms_pages(:child)).collect{|t| t.first }
     assert_equal [], 
-      Cms::Page.options_for_select(cms_sites(:default), cms_pages(:default))
+      Comfy::Cms::Page.options_for_select(comfy_cms_sites(:default), comfy_cms_pages(:default))
     
-    page = Cms::Page.new(new_params(:parent => cms_pages(:default)))
+    page = Comfy::Cms::Page.new(new_params(:parent => comfy_cms_pages(:default)))
     assert_equal ['Default Page', '. . Child Page'],
-      Cms::Page.options_for_select(cms_sites(:default), page).collect{|t| t.first }
+      Comfy::Cms::Page.options_for_select(comfy_cms_sites(:default), page).collect{|t| t.first }
   end
   
-  def test_cms_blocks_attributes_accessor
-    page = cms_pages(:default)
+  def test_comfy_cms_blocks_attributes_accessor
+    page = comfy_cms_pages(:default)
     assert_equal page.blocks.count, page.blocks_attributes.size
     assert_equal 'default_field_text', page.blocks_attributes.first[:identifier]
     assert_equal 'default_field_text_content', page.blocks_attributes.first[:content]
   end
   
   def test_content_caching
-    page = cms_pages(:default)
-    assert_equal page.content, page.render
+    page = comfy_cms_pages(:default)
+    assert_equal page.content_cache, page.render
     
-    page.update_columns(:content => 'Old Content')
-    refute_equal page.content, page.render
+    page.update_columns(:content_cache => 'Old Content')
+    refute_equal page.content_cache, page.render
     
-    page.clear_cached_content!
-    assert_equal page.content, page.render
+    page.clear_content_cache!
+    assert_equal page.content_cache, page.render
+  end
+  
+  def test_content_cache_clear_on_save
+    page = comfy_cms_pages(:default)
+    old_content = 'Old Content'
+    page.update_columns(:content_cache => old_content)
+    
+    page.save!
+    refute_equal old_content, page.content_cache
   end
   
   def test_scope_published
-    assert_equal 2, Cms::Page.published.count
-    cms_pages(:child).update_columns(:is_published => false)
-    assert_equal 1, Cms::Page.published.count
+    assert_equal 2, Comfy::Cms::Page.published.count
+    comfy_cms_pages(:child).update_columns(:is_published => false)
+    assert_equal 1, Comfy::Cms::Page.published.count
   end
   
   def test_root?
-    assert cms_pages(:default).root?
-    assert !cms_pages(:child).root?
+    assert comfy_cms_pages(:default).root?
+    assert !comfy_cms_pages(:child).root?
   end
   
   def test_url
-    site = cms_sites(:default)
+    site = comfy_cms_sites(:default)
     
-    assert_equal '//test.host/', cms_pages(:default).url
-    assert_equal '//test.host/child-page', cms_pages(:child).url
+    assert_equal '//test.host/', comfy_cms_pages(:default).url
+    assert_equal '//test.host/child-page', comfy_cms_pages(:child).url
     
     site.update_columns(:path => '/en/site')
-    cms_pages(:default).reload
-    cms_pages(:child).reload
+    comfy_cms_pages(:default).reload
+    comfy_cms_pages(:child).reload
     
-    assert_equal '//test.host/en/site/', cms_pages(:default).url
-    assert_equal '//test.host/en/site/child-page', cms_pages(:child).url
+    assert_equal '//test.host/en/site/', comfy_cms_pages(:default).url
+    assert_equal '//test.host/en/site/child-page', comfy_cms_pages(:child).url
   end
 
   def test_unicode_slug_escaping
-    page = cms_pages(:child)
-    page_1 = cms_sites(:default).pages.create!(new_params(:parent => page, :slug => 'tést-ünicode-slug'))
+    page = comfy_cms_pages(:child)
+    page_1 = comfy_cms_sites(:default).pages.create!(new_params(:parent => page, :slug => 'tést-ünicode-slug'))
     assert_equal CGI::escape('tést-ünicode-slug'), page_1.slug
     assert_equal CGI::escape('/child-page/tést-ünicode-slug').gsub('%2F', '/'), page_1.full_path
   end
 
   def test_unicode_slug_unescaping
-    page = cms_pages(:child)
-    page_1 = cms_sites(:default).pages.create!(new_params(:parent => page, :slug => 'tést-ünicode-slug'))
-    found_page = cms_sites(:default).pages.where(:slug => CGI::escape('tést-ünicode-slug')).first
+    page = comfy_cms_pages(:child)
+    page_1 = comfy_cms_sites(:default).pages.create!(new_params(:parent => page, :slug => 'tést-ünicode-slug'))
+    found_page = comfy_cms_sites(:default).pages.where(:slug => CGI::escape('tést-ünicode-slug')).first
     assert_equal 'tést-ünicode-slug', found_page.slug
     assert_equal '/child-page/tést-ünicode-slug', found_page.full_path
   end
   
   def test_identifier
-    assert_equal 'index',       cms_pages(:default).identifier
-    assert_equal 'child-page',  cms_pages(:child).identifier
+    assert_equal 'index',       comfy_cms_pages(:default).identifier
+    assert_equal 'child-page',  comfy_cms_pages(:child).identifier
     
-    cms_pages(:default).update_column(:slug, 'index')
-    assert_equal 'index', cms_pages(:default).identifier
+    comfy_cms_pages(:default).update_column(:slug, 'index')
+    assert_equal 'index', comfy_cms_pages(:default).identifier
+  end
+  
+  def test_children_count_updating_on_move
+    page_1 = comfy_cms_pages(:default)
+    page_2 = comfy_cms_pages(:child)
+    page_3 = comfy_cms_sites(:default).pages.create!(new_params(:parent => page_2))
+
+    page_2.reload
+
+    assert_equal 1, page_1.children_count
+    assert_equal 1, page_2.children_count
+    assert_equal 0, page_3.children_count
+
+    page_3.parent_id = page_1.id
+    page_3.save!
+
+    page_1.reload; page_2.reload; page_3.reload
+
+    assert_equal 2, page_1.children_count
+    assert_equal 0, page_2.children_count
+    assert_equal 0, page_3.children_count
   end
   
 protected
@@ -258,7 +288,7 @@ protected
     {
       :label  => 'Test Page',
       :slug   => 'test-page',
-      :layout => cms_layouts(:default)
+      :layout => comfy_cms_layouts(:default)
     }.merge(options)
   end
 end

data/test/models/site_test.rb

@@ -3,34 +3,34 @@ require_relative '../test_helper'
 class CmsSiteTest < ActiveSupport::TestCase
   
   def test_fixtures_validity
-    Cms::Site.all.each do |site|
+    Comfy::Cms::Site.all.each do |site|
       assert site.valid?, site.errors.inspect
     end
   end
   
   def test_validation
-    site = Cms::Site.new
+    site = Comfy::Cms::Site.new
     assert site.invalid?
     assert_has_errors_on site, [:identifier, :label, :hostname]
     
-    site = Cms::Site.new(:identifier => 'test', :hostname => 'http://site.host')
+    site = Comfy::Cms::Site.new(:identifier => 'test', :hostname => 'http://site.host')
     assert site.invalid?
     assert_has_errors_on site, :hostname
     
-    site = Cms::Site.new(:identifier => cms_sites(:default).identifier, :hostname => 'site.host')
+    site = Comfy::Cms::Site.new(:identifier => comfy_cms_sites(:default).identifier, :hostname => 'site.host')
     assert site.invalid?
     assert_has_errors_on site, :identifier
     
-    site = Cms::Site.new(:identifier => 'test', :hostname => 'site.host')
+    site = Comfy::Cms::Site.new(:identifier => 'test', :hostname => 'site.host')
     assert site.valid?, site.errors.inspect
     
-    site = Cms::Site.new(:identifier => 'test', :hostname => 'localhost:3000')
+    site = Comfy::Cms::Site.new(:identifier => 'test', :hostname => 'localhost:3000')
     assert site.valid?, site.errors.inspect
   end
   
   def test_validation_path_uniqueness
-    s1 = cms_sites(:default)
-    s2 = Cms::Site.new(
+    s1 = comfy_cms_sites(:default)
+    s2 = Comfy::Cms::Site.new(
       :identifier => 'test',
       :hostname   => s1.hostname,
       :path       => s1.path
@@ -38,7 +38,7 @@ class CmsSiteTest < ActiveSupport::TestCase
     assert s2.invalid?
     assert_has_errors_on s2, :hostname
     
-    s2 = Cms::Site.new(
+    s2 = Comfy::Cms::Site.new(
       :identifier => 'test',
       :hostname   => s1.hostname,
       :path       => '/en'
@@ -47,34 +47,34 @@ class CmsSiteTest < ActiveSupport::TestCase
   end
   
   def test_identifier_assignment
-    site = Cms::Site.new(:hostname => 'my-site.host')
+    site = Comfy::Cms::Site.new(:hostname => 'my-site.host')
     assert site.valid?
     assert_equal 'my-site-host', site.identifier
   end
   
   def test_hostname_assignment
-    site = Cms::Site.new(:identifier => 'test-site')
+    site = Comfy::Cms::Site.new(:identifier => 'test-site')
     assert site.valid?
     assert_equal 'test-site', site.hostname
   end
   
   def test_label_assignment
-    site = Cms::Site.new(:identifier => 'test', :hostname => 'my-site.host')
+    site = Comfy::Cms::Site.new(:identifier => 'test', :hostname => 'my-site.host')
     assert site.valid?
     assert_equal 'Test', site.label
   end
   
   def test_clean_path
-    site = Cms::Site.create!(:identifier => 'test_a', :hostname => 'test.host', :path => '/en///test//')
+    site = Comfy::Cms::Site.create!(:identifier => 'test_a', :hostname => 'test.host', :path => '/en///test//')
     assert_equal '/en/test', site.path
     
-    site = Cms::Site.create!(:identifier => 'test_b', :hostname => 'my-site.host', :path => '/')
+    site = Comfy::Cms::Site.create!(:identifier => 'test_b', :hostname => 'my-site.host', :path => '/')
     assert_equal '', site.path
   end
   
   def test_creation
-    assert_difference 'Cms::Site.count' do
-      Cms::Site.create!(
+    assert_difference 'Comfy::Cms::Site.count' do
+      Comfy::Cms::Site.create!(
         :identifier => 'test',
         :label      => 'Test Site',
         :hostname   => 'test.test'
@@ -83,12 +83,12 @@ class CmsSiteTest < ActiveSupport::TestCase
   end
   
   def test_cascading_destroy
-    assert_difference 'Cms::Site.count', -1 do
-      assert_difference 'Cms::Layout.count', -3 do
-        assert_difference 'Cms::Page.count', -2 do
-          assert_difference 'Cms::Snippet.count', -1 do
-            assert_difference 'Cms::Category.count', -1 do
-              cms_sites(:default).destroy
+    assert_difference 'Comfy::Cms::Site.count', -1 do
+      assert_difference 'Comfy::Cms::Layout.count', -3 do
+        assert_difference 'Comfy::Cms::Page.count', -2 do
+          assert_difference 'Comfy::Cms::Snippet.count', -1 do
+            assert_difference 'Comfy::Cms::Category.count', -1 do
+              comfy_cms_sites(:default).destroy
             end
           end
         end
@@ -97,56 +97,56 @@ class CmsSiteTest < ActiveSupport::TestCase
   end
   
   def test_scope_mirrored
-    site = cms_sites(:default)
+    site = comfy_cms_sites(:default)
     assert !site.is_mirrored
-    assert_equal 0, Cms::Site.mirrored.count
+    assert_equal 0, Comfy::Cms::Site.mirrored.count
     site.update_columns(:is_mirrored => true)
-    assert_equal 1, Cms::Site.mirrored.count
+    assert_equal 1, Comfy::Cms::Site.mirrored.count
   end
   
   def test_find_site
-    site_a = cms_sites(:default)
+    site_a = comfy_cms_sites(:default)
     assert_equal 'test.host', site_a.hostname
     assert_equal nil, site_a.path
     
-    assert_equal site_a, Cms::Site.find_site('test.host')
-    assert_equal site_a, Cms::Site.find_site('test.host', '/some/path')
-    assert_equal site_a, Cms::Site.find_site('test99.host', '/some/path')
+    assert_equal site_a, Comfy::Cms::Site.find_site('test.host')
+    assert_equal site_a, Comfy::Cms::Site.find_site('test.host', '/some/path')
+    assert_equal site_a, Comfy::Cms::Site.find_site('test99.host', '/some/path')
     
-    site_b = Cms::Site.create!(:identifier => 'test_a', :hostname => 'test2.host', :path => 'en')
-    site_c = Cms::Site.create!(:identifier => 'test_b', :hostname => 'test2.host', :path => 'fr')
+    site_b = Comfy::Cms::Site.create!(:identifier => 'test_a', :hostname => 'test2.host', :path => 'en')
+    site_c = Comfy::Cms::Site.create!(:identifier => 'test_b', :hostname => 'test2.host', :path => 'fr')
     
-    assert_equal site_a,  Cms::Site.find_site('test.host')
-    assert_equal site_a,  Cms::Site.find_site('test.host', '/some/path')
-    assert_equal site_a,  Cms::Site.find_site('test.host', '/some/path')
-    assert_equal nil,     Cms::Site.find_site('test99.host', '/some/path')
+    assert_equal site_a,  Comfy::Cms::Site.find_site('test.host')
+    assert_equal site_a,  Comfy::Cms::Site.find_site('test.host', '/some/path')
+    assert_equal site_a,  Comfy::Cms::Site.find_site('test.host', '/some/path')
+    assert_equal nil,     Comfy::Cms::Site.find_site('test99.host', '/some/path')
     
-    assert_equal nil,     Cms::Site.find_site('test2.host')
-    assert_equal nil,     Cms::Site.find_site('test2.host', '/some/path')
-    assert_equal site_b,  Cms::Site.find_site('test2.host', '/en')
-    assert_equal site_b,  Cms::Site.find_site('test2.host', '/en?a=b')
-    assert_equal site_b,  Cms::Site.find_site('test2.host', '/en/some/path?a=b')
+    assert_equal nil,     Comfy::Cms::Site.find_site('test2.host')
+    assert_equal nil,     Comfy::Cms::Site.find_site('test2.host', '/some/path')
+    assert_equal site_b,  Comfy::Cms::Site.find_site('test2.host', '/en')
+    assert_equal site_b,  Comfy::Cms::Site.find_site('test2.host', '/en?a=b')
+    assert_equal site_b,  Comfy::Cms::Site.find_site('test2.host', '/en/some/path?a=b')
     
-    assert_equal nil,     Cms::Site.find_site('test2.host', '/english/some/path')
+    assert_equal nil,     Comfy::Cms::Site.find_site('test2.host', '/english/some/path')
     
-    assert_equal site_c,  Cms::Site.find_site('test2.host', '/fr')
-    assert_equal site_c,  Cms::Site.find_site('test2.host', '/fr?a=b')
-    assert_equal site_c,  Cms::Site.find_site('test2.host', '/fr/some/path')
-    assert_equal site_c,  Cms::Site.find_site('test2.host', '/fr/some/path?a=b')
+    assert_equal site_c,  Comfy::Cms::Site.find_site('test2.host', '/fr')
+    assert_equal site_c,  Comfy::Cms::Site.find_site('test2.host', '/fr?a=b')
+    assert_equal site_c,  Comfy::Cms::Site.find_site('test2.host', '/fr/some/path')
+    assert_equal site_c,  Comfy::Cms::Site.find_site('test2.host', '/fr/some/path?a=b')
   end
   
   def test_find_site_with_site_alias
-    site_a = cms_sites(:default)
-    site_b = Cms::Site.create!(:identifier => 'site_b', :hostname => 'test2.host')
+    site_a = comfy_cms_sites(:default)
+    site_b = Comfy::Cms::Site.create!(:identifier => 'site_b', :hostname => 'test2.host')
     
     ComfortableMexicanSofa.config.hostname_aliases = {
       'test.host'   => 'alias_a.host',
       'test2.host'  => %w(alias_b.host alias_c.host)
     }
     
-    assert_equal site_a, Cms::Site.find_site('alias_a.host')
-    assert_equal site_b, Cms::Site.find_site('alias_b.host')
-    assert_equal site_b, Cms::Site.find_site('alias_c.host')
+    assert_equal site_a, Comfy::Cms::Site.find_site('alias_a.host')
+    assert_equal site_b, Comfy::Cms::Site.find_site('alias_b.host')
+    assert_equal site_b, Comfy::Cms::Site.find_site('alias_c.host')
   end
   
 end