comfortable_mexican_sofa 1.12.11 → 2.0.0

data/test/models/fragment_test.rb

@@ -0,0 +1,131 @@
+require_relative '../test_helper'
+
+class CmsFragmentTest < ActiveSupport::TestCase
+
+  setup do
+    @site   = comfy_cms_sites(:default)
+    @layout = comfy_cms_layouts(:default)
+    @page   = comfy_cms_pages(:default)
+
+    @upload_doc = fixture_file_upload("files/document.pdf", "application/pdf")
+    @upload_img = fixture_file_upload("files/image.jpg", "image/jpeg")
+  end
+
+  def page_params(frag_params = [])
+    {
+      layout:               @layout,
+      label:                'test page',
+      slug:                 'test_page',
+      parent_id:            @page.id,
+      fragments_attributes: frag_params
+    }
+  end
+
+  # -- Tests -------------------------------------------------------------------
+
+  def test_initialization
+    frag = Comfy::Cms::Fragment.new
+    assert_equal "text", frag.tag
+  end
+
+  def test_fixtures_validity
+    Comfy::Cms::Fragment.all.each do |frag|
+      assert frag.valid?, frag.errors.full_messages.to_s
+    end
+  end
+
+  def test_validation
+    frag = Comfy::Cms::Fragment.new
+    refute frag.valid?
+    assert_has_errors_on frag, :identifier, :record
+  end
+
+  def test_content_serialization
+    fragment = Comfy::Cms::Fragment.new
+
+    fragment.content = 'test'
+    assert_equal 'test', fragment.content
+
+    fragment.content = 12345
+    assert_equal 12345, fragment.content
+
+    fragment.content = [1, 2, 3]
+    assert_equal [1, 2, 3], fragment.content
+  end
+
+  def test_creation
+    assert_difference "Comfy::Cms::Fragment.count" do
+      @page.fragments.create!(
+        identifier: "test",
+        content:    "test content"
+      )
+    end
+  end
+
+  def test_creation_with_files
+    assert_count_difference [Comfy::Cms::Fragment] do
+      assert_count_difference [ActiveStorage::Attachment], 2 do
+        frag = @page.fragments.create!(
+          identifier: "test",
+          tag:        "files",
+          files:      [@upload_doc, @upload_img]
+        )
+        assert_equal 2, frag.attachments.count
+      end
+    end
+  end
+
+  def test_creation_with_file
+    assert_count_difference [Comfy::Cms::Fragment, ActiveStorage::Attachment] do
+      frag = @page.fragments.create!(
+        identifier: "test",
+        tag:        "file",
+        files:      [@upload_doc, @upload_img]
+      )
+      assert_equal 1, frag.attachments.count
+    end
+  end
+
+  def test_update_with_files
+    frag = comfy_cms_fragments(:file)
+    assert_equal 1, frag.attachments.count
+    assert_equal "fragment.jpg", frag.attachments.first.filename.to_s
+    assert_difference -> {frag.attachments.count} do
+      frag.update_attributes(
+        tag:    "files",
+        files:  [@upload_doc]
+      )
+    end
+  end
+
+  def test_update_with_file
+    frag = comfy_cms_fragments(:file)
+    assert_equal 1, frag.attachments.count
+    assert_equal "fragment.jpg", frag.attachments.first.filename.to_s
+    assert_no_difference -> {frag.attachments.count} do
+      frag.update_attributes(
+        tag:    "file",
+        files:  [@upload_doc]
+      )
+    end
+    frag.reload
+    assert_equal "document.pdf", frag.attachments.first.filename.to_s
+  end
+
+  def test_update_with_file_removal
+    frag = comfy_cms_fragments(:file)
+    assert_difference -> {frag.attachments.count}, -1 do
+      frag.update_attributes(
+        file_ids_destroy: frag.attachments.pluck(:id)
+      )
+    end
+  end
+
+  def test_touch
+    timestamp = 2.days.ago
+    @page.update_column(:updated_at, timestamp)
+    comfy_cms_fragments(:default).update_attributes(content: "updated")
+    @page.reload
+    refute_equal timestamp, @page.updated_at
+  end
+end

data/test/models/layout_test.rb

@@ -1,62 +1,112 @@
 require_relative '../test_helper'
 
 class CmsLayoutTest < ActiveSupport::TestCase
-  
+
+  setup do
+    @site   = comfy_cms_sites(:default)
+    @layout = comfy_cms_layouts(:default)
+    @page   = comfy_cms_pages(:default)
+  end
+
   def test_fixtures_validity
     Comfy::Cms::Layout.all.each do |layout|
       assert layout.valid?, layout.errors.full_messages.to_s
     end
   end
-  
+
   def test_validations
-    layout = comfy_cms_sites(:default).layouts.create
+    layout = @site.layouts.create
     assert layout.errors.present?
     assert_has_errors_on layout, [:label, :identifier]
   end
-  
+
+  def test_content_tokens
+    layout = Comfy::Cms::Layout.new(content: "a {{cms:text content}} b")
+    assert_equal ["a ", {tag_class: "text", tag_params: "content"}, " b"],
+      layout.content_tokens
+  end
+
+  def test_content_tokens_nested
+    layout_a = Comfy::Cms::Layout.new(content: "a {{cms:text content}} {{cms:text footer}} b")
+    layout_b = Comfy::Cms::Layout.new(content: "c {{cms:text content}} d")
+    layout_b.parent = layout_a
+    assert_equal [
+      "a ", "c ", {tag_class: "text", tag_params: "content"}, " d", " ",
+      {tag_class: "text", tag_params: "footer"}, " b"
+    ], layout_b.content_tokens
+  end
+
+  def test_content_tokens_nested_with_fragment_subclass_tag
+    layout_a = Comfy::Cms::Layout.new(content: "a {{cms:markdown content}} b")
+    layout_b = Comfy::Cms::Layout.new(content: "c {{cms:text content}} d")
+    layout_b.parent = layout_a
+    assert_equal [
+      "a ", "c ", {tag_class: "text", tag_params: "content"}, " d", " b"
+    ], layout_b.content_tokens
+  end
+
+  def test_content_tokens_nested_with_non_fragment_subclass_tag
+    layout_a = Comfy::Cms::Layout.new(content: "a {{cms:snippet content}} b")
+    layout_b = Comfy::Cms::Layout.new(content: "c {{cms:text content}} d")
+    layout_b.parent = layout_a
+    assert_equal [
+      "c ", {tag_class: "text", tag_params: "content"}, " d"
+    ], layout_b.content_tokens
+  end
+
+  def test_content_tokens_nested_without_content_tag
+    layout_a = Comfy::Cms::Layout.new(content: "a {{cms:text footer}} b")
+    layout_b = Comfy::Cms::Layout.new(content: "c {{cms:text content}} d")
+    layout_b.parent = layout_a
+    assert_equal ["c ", {tag_class: "text", tag_params: "content"}, " d"],
+      layout_b.content_tokens
+  end
+
   def test_label_assignment
-    layout = comfy_cms_sites(:default).layouts.new(
-      :identifier => 'test',
-      :content    => '{{cms:page:content}}'
+    layout = @site.layouts.new(
+      identifier: 'test',
+      content:    'content'
     )
     assert layout.valid?
     assert_equal 'Test', layout.label
   end
-  
+
   def test_creation
     assert_difference 'Comfy::Cms::Layout.count' do
-      layout = comfy_cms_sites(:default).layouts.create(
-        :label      => 'New Layout',
-        :identifier => 'new-layout',
-        :content    => '{{cms:page:content}}',
-        :css        => 'css',
-        :js         => 'js'
+      layout = @site.layouts.create(
+        label:      'New Layout',
+        identifier: 'new-layout',
+        content:    '{{cms:text default}}',
+        css:        'css',
+        js:         'js'
       )
-      assert_equal 'New Layout', layout.label
-      assert_equal 'new-layout', layout.identifier
-      assert_equal '{{cms:page:content}}', layout.content
-      assert_equal 'css', layout.css
-      assert_equal 'js', layout.js
-      assert_equal 1, layout.position
+      assert_equal 'New Layout',            layout.label
+      assert_equal 'new-layout',            layout.identifier
+      assert_equal '{{cms:text default}}',  layout.content
+      assert_equal 'css',                   layout.css
+      assert_equal 'js',                    layout.js
+      assert_equal 1,                       layout.position
     end
   end
-  
+
   def test_options_for_select
     assert_equal ['Default Layout', 'Nested Layout', '. . Child Layout'],
-      Comfy::Cms::Layout.options_for_select(comfy_cms_sites(:default)).collect{|t| t.first}
+      Comfy::Cms::Layout.options_for_select(@site).collect{|t| t.first}
     assert_equal ['Default Layout', 'Nested Layout'],
-      Comfy::Cms::Layout.options_for_select(comfy_cms_sites(:default), comfy_cms_layouts(:child)).collect{|t| t.first}
+      Comfy::Cms::Layout.options_for_select(@site, comfy_cms_layouts(:child)).collect{|t| t.first}
     assert_equal ['Default Layout'],
-      Comfy::Cms::Layout.options_for_select(comfy_cms_sites(:default), comfy_cms_layouts(:nested)).collect{|t| t.first}
+      Comfy::Cms::Layout.options_for_select(@site, comfy_cms_layouts(:nested)).collect{|t| t.first}
   end
-  
+
   def test_app_layouts_for_select
     FileUtils.touch(File.expand_path('app/views/layouts/comfy/admin/cms/nested.html.erb', Rails.root))
     FileUtils.touch(File.expand_path('app/views/layouts/comfy/_partial.html.erb', Rails.root))
     FileUtils.touch(File.expand_path('app/views/layouts/comfy/not_a_layout.erb', Rails.root))
 
     view_paths = [File.expand_path('app/views/', Rails.root)]
-    assert_equal ['comfy/admin/cms', 'comfy/admin/cms/nested'], Comfy::Cms::Layout.app_layouts_for_select(view_paths)
+    assert_equal ['comfy/admin/cms', 'comfy/admin/cms/nested'],
+      Comfy::Cms::Layout.app_layouts_for_select(view_paths)
+
   ensure
     FileUtils.rm(File.expand_path('app/views/layouts/comfy/admin/cms/nested.html.erb', Rails.root))
     FileUtils.rm(File.expand_path('app/views/layouts/comfy/_partial.html.erb', Rails.root))
@@ -72,71 +122,52 @@ class CmsLayoutTest < ActiveSupport::TestCase
   ensure
     FileUtils.rm_r(File.expand_path('app/additional_views', Rails.root))
   end
-  
-  def test_merged_content_with_same_child_content
-    parent_layout = comfy_cms_layouts(:nested)
-    assert_equal "{{cms:page:header}}\n{{cms:page:content}}", parent_layout.content
-    assert_equal "{{cms:page:header}}\n{{cms:page:content}}", parent_layout.merged_content
-    
-    child_layout = comfy_cms_layouts(:child)
-    assert_equal parent_layout, child_layout.parent
-    assert_equal "{{cms:page:left_column}}\n{{cms:page:right_column}}", child_layout.content
-    assert_equal "{{cms:page:header}}\n{{cms:page:left_column}}\n{{cms:page:right_column}}", child_layout.merged_content
-    
-    child_layout.update_columns(:content => '{{cms:page:content}}')
-    assert_equal "{{cms:page:header}}\n{{cms:page:content}}", child_layout.merged_content
-    
-    parent_layout.update_columns(:content => '{{cms:page:whatever}}')
-    child_layout.reload
-    assert_equal '{{cms:page:content}}', child_layout.merged_content
-  end
-  
+
   def test_update_forces_page_content_reload
     layout_1 = comfy_cms_layouts(:nested)
     layout_2 = comfy_cms_layouts(:child)
-    page_1 = comfy_cms_sites(:default).pages.create!(
-      :label        => 'page_1',
-      :slug         => 'page-1',
-      :parent_id    => comfy_cms_pages(:default).id,
-      :layout_id    => layout_1.id,
-      :is_published => '1',
-      :blocks_attributes => [
-        { :identifier => 'header',
-          :content    => 'header_content' },
-        { :identifier => 'content',
-          :content    => 'content_content' }
+    page_1 = @site.pages.create!(
+      label:        'page_1',
+      slug:         'page-1',
+      parent_id:    @page.id,
+      layout_id:    layout_1.id,
+      is_published: '1',
+      fragments_attributes: [
+        { identifier: 'header',
+          content:    'header_content' },
+        { identifier: 'content',
+          content:    'content_content' }
       ]
     )
-    page_2 = comfy_cms_sites(:default).pages.create!(
-      :label          => 'page_2',
-      :slug           => 'page-2',
-      :parent_id      => comfy_cms_pages(:default).id,
-      :layout_id      => layout_2.id,
-      :is_published   => '1',
-      :blocks_attributes => [
-        { :identifier => 'header',
-          :content    => 'header_content' },
-        { :identifier => 'left_column',
-          :content    => 'left_column_content' },
-        { :identifier => 'right_column',
-          :content    => 'left_column_content' }
+    page_2 = @site.pages.create!(
+      label:          'page_2',
+      slug:           'page-2',
+      parent_id:      @page.id,
+      layout_id:      layout_2.id,
+      is_published:   '1',
+      fragments_attributes: [
+        { identifier: 'header',
+          content:    'header_content' },
+        { identifier: 'left_column',
+          content:    'left_column_content' },
+        { identifier: 'right_column',
+          content:    'left_column_content' }
       ]
     )
     assert_equal "header_content\ncontent_content", page_1.content_cache
     assert_equal "header_content\nleft_column_content\nleft_column_content", page_2.content_cache
-    
-    layout_1.update_attributes(:content => "Updated {{cms:page:content}}")
+
+    layout_1.update_attributes(content: "Updated {{cms:text content}}")
     page_1.reload
     page_2.reload
-    
+
     assert_equal "Updated content_content", page_1.content_cache
     assert_equal "Updated left_column_content\nleft_column_content", page_2.content_cache
   end
 
   def test_cache_buster
     timestamp = Time.current
-    layout = comfy_cms_sites(:default).layouts.create(updated_at: timestamp)
-
+    layout = @site.layouts.create(updated_at: timestamp)
     assert_equal timestamp.to_i, layout.cache_buster
   end
 end

data/test/models/page_test.rb

@@ -1,9 +1,22 @@
-# encoding: utf-8
-
 require_relative '../test_helper'
 
 class CmsPageTest < ActiveSupport::TestCase
 
+  setup do
+    @site   = comfy_cms_sites(:default)
+    @layout = comfy_cms_layouts(:default)
+    @page   = comfy_cms_pages(:default)
+  end
+
+  def new_params(options = {})
+    { label:  "Test Page",
+      slug:   "test-page",
+      layout: @layout
+    }.merge(options)
+  end
+
+  # -- Tests -------------------------------------------------------------------
+
   def test_fixtures_validity
     Comfy::Cms::Page.all.each do |page|
       assert page.valid?, page.errors.full_messages.to_s
@@ -15,32 +28,32 @@ class CmsPageTest < ActiveSupport::TestCase
     page = Comfy::Cms::Page.new
     page.save
     assert page.invalid?
-    assert_has_errors_on page, :site_id, :layout, :slug, :label
+    assert_has_errors_on page, :site, :layout, :slug, :label
   end
 
   def test_validation_of_parent_presence
-    page = comfy_cms_sites(:default).pages.new(new_params)
+    page = @site.pages.new(new_params)
     assert !page.parent
     assert page.valid?, page.errors.full_messages.to_s
-    assert_equal comfy_cms_pages(:default), page.parent
+    assert_equal @page, page.parent
   end
 
   def test_validation_of_parent_relationship
-    page = comfy_cms_pages(:default)
-    assert !page.parent
-    page.parent = page
-    assert page.invalid?
-    assert_has_errors_on page, :parent_id
-    page.parent = comfy_cms_pages(:child)
-    assert page.invalid?
-    assert_has_errors_on page, :parent_id
+    assert !@page.parent
+    @page.parent = @page
+    assert @page.invalid?
+    assert_has_errors_on @page, :parent_id
+
+    @page.parent = comfy_cms_pages(:child)
+    assert @page.invalid?
+    assert_has_errors_on @page, :parent_id
   end
 
   def test_validation_of_target_page
     page = comfy_cms_pages(:child)
-    page.target_page = comfy_cms_pages(:default)
+    page.target_page = @page
     page.save!
-    assert_equal comfy_cms_pages(:default), page.target_page
+    assert_equal @page, page.target_page
     page.target_page = page
     assert page.invalid?
     assert_has_errors_on page, :target_page_id
@@ -60,73 +73,225 @@ class CmsPageTest < ActiveSupport::TestCase
 
   def test_validation_of_slug_allows_unicode_accent_characters
     page = comfy_cms_pages(:child)
-    thai_character_ko_kai = "\u0e01"
-    thai_character_mai_tho = "\u0E49"
+    thai_character_ko_kai   = "\u0e01"
+    thai_character_mai_tho  = "\u0E49"
     page.slug = thai_character_ko_kai + thai_character_mai_tho
     assert page.valid?
   end
 
   def test_label_assignment
-    page = comfy_cms_sites(:default).pages.new(
-      :slug   => 'test',
-      :parent => comfy_cms_pages(:default),
-      :layout => comfy_cms_layouts(:default)
+    page = @site.pages.new(
+      slug:   'test',
+      parent: @page,
+      layout: @layout
     )
     assert page.valid?
     assert_equal 'Test', page.label
   end
 
-  def test_creation
-    assert_difference ['Comfy::Cms::Page.count', 'Comfy::Cms::Block.count'] do
-      page = comfy_cms_sites(:default).pages.create!(
-        :label  => 'test',
-        :slug   => 'test',
-        :parent => comfy_cms_pages(:default),
-        :layout => comfy_cms_layouts(:default),
-        :blocks_attributes => [
-          { :identifier => 'default_page_text',
-            :content    => 'test' }
+  def test_create
+    assert_count_difference [Comfy::Cms::Page, Comfy::Cms::Fragment] do
+      page = @site.pages.create!(new_params(
+        parent: @page,
+        fragments_attributes: [
+          { identifier: "content",
+            tag:        "text",
+            content:    "test" }
         ]
-      )
+      ))
       assert page.is_published?
       assert_equal 1, page.position
     end
   end
 
+  def test_create_with_file
+    assert_count_difference [Comfy::Cms::Page, Comfy::Cms::Fragment, ActiveStorage::Attachment] do
+      page = @site.pages.create!(new_params(
+        parent: @page,
+        fragments_attributes: [{
+          identifier: "test",
+          tag:        "file",
+          files:      [fixture_file_upload("files/image.jpg", "image/jpeg")]
+        }]
+      ))
+      assert_equal 1, page.fragments.count
+      assert page.fragments.first.attachments.attached?
+    end
+  end
+
+  def test_create_with_files
+    assert_count_difference [Comfy::Cms::Page, Comfy::Cms::Fragment] do
+      assert_count_difference [ActiveStorage::Attachment], 2 do
+        page = @site.pages.create!(new_params(
+          parent: @page,
+          fragments_attributes: [{
+            identifier: "test",
+            tag:        "files",
+            files:      [
+              fixture_file_upload("files/image.jpg", "image/jpeg"),
+              fixture_file_upload("files/document.pdf", "application/pdf")
+            ]
+          }]
+        ))
+        assert_equal 1, page.fragments.count
+        assert page.fragments.first.attachments.attached?
+      end
+    end
+  end
+
+  def test_create_with_date
+    string = "1981-10-04 12:34:56"
+    datetime = DateTime.parse(string)
+    assert_count_difference [Comfy::Cms::Page, Comfy::Cms::Fragment] do
+      page = @site.pages.create!(new_params(
+        parent: @page,
+        fragments_attributes: [{
+          identifier: "test",
+          tag:        "date_time",
+          datetime:   string
+        }]
+      ))
+      frag = page.fragments.first
+      assert_equal datetime, frag.datetime
+    end
+  end
+
+  def test_create_with_boolean
+    assert_count_difference [Comfy::Cms::Page, Comfy::Cms::Fragment] do
+      page = @site.pages.create!(new_params(
+        parent: @page,
+        fragments_attributes: [{
+          identifier: "test",
+          tag:        "checkbox",
+          boolean:    "1"
+        }]
+      ))
+      frag = page.fragments.first
+      assert frag.boolean
+    end
+  end
+
+  def test_update
+    frag = comfy_cms_fragments(:default)
+    assert_count_no_difference [Comfy::Cms::Page, Comfy::Cms::Fragment] do
+      @page.update_attributes!(fragments_attributes: [{
+        identifier: frag.identifier,
+        content:    "updated content"
+      }])
+    end
+    frag.reload
+    assert_equal "updated content", frag.content
+  end
+
+  def test_update_with_file
+    assert_count_no_difference [ActiveStorage::Attachment] do
+      @page.update_attributes!(
+        fragments_attributes: [{
+          identifier: "file",
+          tag:        "file",
+          files:      fixture_file_upload("files/document.pdf", "application/pdf")
+        }]
+      )
+      assert_equal "document.pdf", comfy_cms_fragments(:file).attachments.first.filename.to_s
+    end
+  end
+
+  def test_update_with_file_removal
+    id = comfy_cms_fragments(:file).attachments.first.id
+    assert_count_difference [ActiveStorage::Attachment], -1 do
+      @page.update_attributes!(
+        fragments_attributes: [{
+          identifier:       "file",
+          file_ids_destroy: [id]
+        }]
+      )
+    end
+  end
+
+  def test_update_with_date
+    frag = comfy_cms_fragments(:datetime)
+    string = "2020-01-01"
+    date    = DateTime.parse(string)
+    assert_count_no_difference [Comfy::Cms::Page, Comfy::Cms::Fragment] do
+      @page.update_attributes!(fragments_attributes: [{
+        identifier: frag.identifier,
+        datetime:   string
+      }])
+    end
+    frag.reload
+    assert_equal date, frag.datetime
+  end
+
+  def test_update_with_boolean
+    frag = comfy_cms_fragments(:boolean)
+    assert frag.boolean
+    assert_count_no_difference [Comfy::Cms::Page, Comfy::Cms::Fragment] do
+      @page.update_attributes!(fragments_attributes: [{
+        identifier: frag.identifier,
+        boolean:    "0"
+      }])
+    end
+    frag.reload
+    refute frag.boolean
+  end
+
+  def test_update_with_parent_id_change
+    page_a = @page
+    page_b = comfy_cms_pages(:child)
+    page_c = @site.pages.create!(
+      label:  'Test Page',
+      slug:   'test-page',
+      layout: @layout,
+      parent: page_a
+    )
+
+    assert_equal 2, page_a.children_count
+    assert_equal 0, page_b.children_count
+    assert_equal 0, page_c.children_count
+
+    page_c.update_attributes!(parent_id: page_b)
+
+    page_a.reload; page_b.reload; page_c.reload
+    assert_equal 1, page_a.children_count
+    assert_equal 1, page_b.children_count
+    assert_equal 0, page_c.children_count
+  end
+
   def test_initialization_of_full_path
     page = Comfy::Cms::Page.new
     assert_equal '/', page.full_path
 
     page = Comfy::Cms::Page.new(new_params)
     assert page.invalid?
-    assert_has_errors_on page, :site_id
+    assert_has_errors_on page, :site
 
-    page = comfy_cms_sites(:default).pages.new(new_params(:parent => comfy_cms_pages(:default)))
+    page = @site.pages.new(new_params(parent: @page))
     assert page.valid?
     assert_equal '/test-page', page.full_path
 
-    page = comfy_cms_sites(:default).pages.new(new_params(:parent => comfy_cms_pages(:child)))
+    page = @site.pages.new(new_params(parent: comfy_cms_pages(:child)))
     assert page.valid?
     assert_equal '/child-page/test-page', page.full_path
 
     Comfy::Cms::Page.destroy_all
-    page = comfy_cms_sites(:default).pages.new(new_params)
+    page = @site.pages.new(new_params)
     assert page.valid?
     assert_equal '/', page.full_path
   end
 
   def test_sync_child_pages
     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'))
+    page_1 = @site.pages.create!(new_params(parent: page, slug: 'test-page-1'))
+    page_2 = @site.pages.create!(new_params(parent: page, slug: 'test-page-2'))
+    page_3 = @site.pages.create!(new_params(parent: page_2, slug: 'test-page-3'))
+    page_4 = @site.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
     assert_equal '/child-page/test-page-1/test-page-4', page_4.full_path
 
-    page.update_attributes!(:slug => 'updated-page')
+    page.update_attributes!(slug: 'updated-page')
     assert_equal '/updated-page', page.full_path
     page_1.reload; page_2.reload; page_3.reload; page_4.reload
     assert_equal '/updated-page/test-page-1', page_1.full_path
@@ -134,7 +299,7 @@ class CmsPageTest < ActiveSupport::TestCase
     assert_equal '/updated-page/test-page-2/test-page-3', page_3.full_path
     assert_equal '/updated-page/test-page-1/test-page-4', page_4.full_path
 
-    page_2.update_attributes!(:parent => page_1)
+    page_2.update_attributes!(parent: page_1)
     page_1.reload; page_2.reload; page_3.reload; page_4.reload
     assert_equal '/updated-page/test-page-1', page_1.full_path
     assert_equal '/updated-page/test-page-1/test-page-2', page_2.full_path
@@ -143,12 +308,12 @@ class CmsPageTest < ActiveSupport::TestCase
   end
 
   def test_children_count_updating
-    page_1 = comfy_cms_pages(:default)
+    page_1 = @page
     page_2 = comfy_cms_pages(:child)
     assert_equal 1, page_1.children_count
     assert_equal 0, page_2.children_count
 
-    page_3 = comfy_cms_sites(:default).pages.create!(new_params(:parent => page_2))
+    page_3 = @site.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,120 +331,195 @@ class CmsPageTest < ActiveSupport::TestCase
   end
 
   def test_cascading_destroy
-    assert_difference 'Comfy::Cms::Page.count', -2 do
-      assert_difference 'Comfy::Cms::Block.count', -2 do
-        comfy_cms_pages(:default).destroy
+    assert_count_difference [Comfy::Cms::Page], -2 do
+      assert_count_difference [Comfy::Cms::Fragment], -4 do
+        assert_count_difference [Comfy::Cms::Translation], -1 do
+          @page.destroy
+        end
       end
     end
   end
 
   def test_options_for_select
     assert_equal ['Default Page', '. . Child Page'],
-      Comfy::Cms::Page.options_for_select(comfy_cms_sites(:default)).collect{|t| t.first }
+      Comfy::Cms::Page.options_for_select(@site).collect{|t| t.first }
     assert_equal ['Default Page'],
-      Comfy::Cms::Page.options_for_select(comfy_cms_sites(:default), comfy_cms_pages(:child)).collect{|t| t.first }
+      Comfy::Cms::Page.options_for_select(@site, comfy_cms_pages(:child)).collect{|t| t.first }
     assert_equal [],
-      Comfy::Cms::Page.options_for_select(comfy_cms_sites(:default), comfy_cms_pages(:default))
+      Comfy::Cms::Page.options_for_select(@site, @page)
 
-    page = Comfy::Cms::Page.new(new_params(:parent => comfy_cms_pages(:default)))
+    page = Comfy::Cms::Page.new(new_params(parent: @page))
     assert_equal ['Default Page', '. . Child Page'],
-      Comfy::Cms::Page.options_for_select(comfy_cms_sites(:default), page).collect{|t| t.first }
+      Comfy::Cms::Page.options_for_select(@site, page).collect{|t| t.first }
+  end
+
+  def test_fragments_attributes
+    assert_equal @page.fragments.count, @page.fragments_attributes.size
+
+    @page.fragments_attributes = [
+      { identifier: "content",
+        content:    "updated content"
+      }
+    ]
+
+    assert_equal [
+      { identifier: "boolean",
+        tag:        "checkbox",
+        content:    nil,
+        datetime:   nil,
+        boolean:    true },
+      { identifier: "file",
+        tag:        "file",
+        content:    nil,
+        datetime:   nil,
+        boolean:    false },
+      { identifier: "datetime",
+        tag:        "datetime",
+        content:    nil,
+        datetime:   comfy_cms_fragments(:datetime).datetime,
+        boolean:    false },
+      { identifier: "content",
+        tag:        "text",
+        content:    "updated content",
+        datetime:   nil,
+        boolean:    false }
+    ], @page.fragments_attributes
+
+    assert_equal [
+      { identifier: "boolean",
+        tag:        "checkbox",
+        content:    nil,
+        datetime:   nil,
+        boolean:    true },
+      { identifier: "file",
+        tag:        "file",
+        content:    nil,
+        datetime:   nil,
+        boolean:    false },
+      { identifier: "datetime",
+        tag:        "datetime",
+        content:    nil,
+        datetime:   comfy_cms_fragments(:datetime).datetime,
+        boolean:    false },
+      { identifier: "content",
+        tag:        "text",
+        content:    "content",
+        datetime:   nil,
+        boolean:    false }
+    ], @page.fragments_attributes_was
   end
 
-  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]
+  def test_render
+    expected = @page.render
+    assert_equal "content", expected
+  end
+
+  def test_fragment_nodes
+    content = "a {{cms:text a}} b {{cms:snippet b}} c {{cms:text c}}"
+    @page.layout.update_column(:content, content)
+    nodes = @page.fragment_nodes
+    assert_equal 2, nodes.count
+    assert_equal "a", nodes[0].identifier
+    assert_equal "c", nodes[1].identifier
+  end
+
+  def test_fragment_nodes_with_duplicates
+    content = "{{cms:wysiwyg test}} {{cms:markdown test}}"
+    @page.layout.update_column(:content, content)
+    nodes = @page.fragment_nodes
+    assert_equal 1, nodes.count
+    assert_equal ComfortableMexicanSofa::Content::Tag::Wysiwyg, nodes[0].class
+    assert_equal "test", nodes[0].identifier
+  end
+
+  def test_fragment_nodes_with_no_layout
+    @page.update_column(:layout_id, nil)
+    assert_equal [], @page.fragment_nodes
   end
 
   def test_content_caching
-    page = comfy_cms_pages(:default)
-    assert_equal page.content_cache, page.render
+    assert_equal @page.content_cache, @page.render
 
-    page.update_columns(:content_cache => 'Old Content')
-    refute_equal page.content_cache, page.render
+    @page.update_columns(content_cache: 'Old Content')
+    refute_equal @page.content_cache, @page.render
 
-    page.clear_content_cache!
-    assert_equal page.content_cache, 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.update_columns(content_cache: old_content)
 
-    page.save!
-    refute_equal old_content, page.content_cache
+    @page.save!
+    refute_equal old_content, @page.content_cache
   end
 
   def test_scope_published
     assert_equal 2, Comfy::Cms::Page.published.count
-    comfy_cms_pages(:child).update_columns(:is_published => false)
+    comfy_cms_pages(:child).update_columns(is_published: false)
     assert_equal 1, Comfy::Cms::Page.published.count
   end
 
   def test_root?
-    assert comfy_cms_pages(:default).root?
-    assert !comfy_cms_pages(:child).root?
+    assert @page.root?
+    refute comfy_cms_pages(:child).root?
   end
 
   def test_url
-    site = comfy_cms_sites(:default)
-
-    assert_equal '//test.host/', comfy_cms_pages(:default).url
+    assert_equal '//test.host/', @page.url
     assert_equal '//test.host/child-page', comfy_cms_pages(:child).url
 
-    assert_equal '/', comfy_cms_pages(:default).url(:relative)
-    assert_equal '/child-page', comfy_cms_pages(:child).url(:relative)
+    assert_equal '/', @page.url(relative: true)
+    assert_equal '/child-page', comfy_cms_pages(:child).url(relative: true)
 
-    site.update_columns(:path => '/en/site')
-    comfy_cms_pages(:default).reload
+    @site.update_columns(path: '/en/site')
+    @page.reload
     comfy_cms_pages(:child).reload
 
-    assert_equal '//test.host/en/site/', comfy_cms_pages(:default).url
+    assert_equal '//test.host/en/site/', @page.url
     assert_equal '//test.host/en/site/child-page', comfy_cms_pages(:child).url
 
-    assert_equal '/en/site/', comfy_cms_pages(:default).url(:relative)
-    assert_equal '/en/site/child-page', comfy_cms_pages(:child).url(:relative)
+    assert_equal '/en/site/', @page.url(relative: true)
+    assert_equal '/en/site/child-page', comfy_cms_pages(:child).url(relative: true)
   end
 
   def test_url_with_public_cms_path
     ComfortableMexicanSofa.config.public_cms_path = '/custom'
-    assert_equal '//test.host/custom/', comfy_cms_pages(:default).url
+    assert_equal '//test.host/custom/', @page.url
     assert_equal '//test.host/custom/child-page', comfy_cms_pages(:child).url
 
-    assert_equal '/custom/', comfy_cms_pages(:default).url(:relative)
-    assert_equal '/custom/child-page', comfy_cms_pages(:child).url(:relative)
+    assert_equal '/custom/', @page.url(relative: true)
+    assert_equal '/custom/child-page', comfy_cms_pages(:child).url(relative: true)
   end
 
   def test_unicode_slug_escaping
     page = comfy_cms_pages(:child)
-    page_1 = comfy_cms_sites(:default).pages.create!(new_params(:parent => page, :slug => 'tést-ünicode-slug'))
+    page_1 = @site.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 = 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
+    page_1 = @site.pages.create!(new_params(parent: page, slug: 'tést-ünicode-slug'))
+    found_page = @site.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',       comfy_cms_pages(:default).identifier
+    assert_equal 'index',       @page.identifier
     assert_equal 'child-page',  comfy_cms_pages(:child).identifier
 
-    comfy_cms_pages(:default).update_column(:slug, 'index')
+    @page.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_1 = @page
     page_2 = comfy_cms_pages(:child)
-    page_3 = comfy_cms_sites(:default).pages.create!(new_params(:parent => page_2))
+    page_3 = @site.pages.create!(new_params(parent: page_2))
 
     page_2.reload
 
@@ -297,13 +537,28 @@ class CmsPageTest < ActiveSupport::TestCase
     assert_equal 0, page_3.children_count
   end
 
-protected
+  def test_translate
+    translation = comfy_cms_translations(:default)
+    translation.update_columns(layout_id: comfy_cms_layouts(:nested).id)
 
-  def new_params(options = {})
-    {
-      :label  => 'Test Page',
-      :slug   => 'test-page',
-      :layout => comfy_cms_layouts(:default)
-    }.merge(options)
+    @page.translate!(:fr)
+    assert @page.readonly?
+
+    assert_equal comfy_cms_layouts(:nested), @page.layout
+    assert_equal 'Default Translation', @page.label
+    assert_equal 'Translation Content', @page.content_cache
+  end
+
+  def test_translate_with_unpublished
+    comfy_cms_translations(:default).update_column(:is_published, false)
+    assert_exception_raised ActiveRecord::RecordNotFound do
+      @page.translate!(:fr)
+    end
+  end
+
+  def test_translate_with_invalid_locale
+    assert_exception_raised ActiveRecord::RecordNotFound do
+      @page.translate!(:es)
+    end
   end
 end