alchemy_cms 3.2.1 → 3.3.0.rc1

data/spec/models/{element_spec.rb → alchemy/element_spec.rb}

@@ -37,36 +37,87 @@ module Alchemy
     end
 
     describe '.copy' do
-      let(:element) { FactoryGirl.create(:element, :create_contents_after_create => true, :tag_list => 'red, yellow') }
+      subject { Element.copy(element) }
+
+      let(:element) do
+        create(:alchemy_element, create_contents_after_create: true, tag_list: 'red, yellow')
+      end
 
       it "should not create contents from scratch" do
-        copy = Element.copy(element)
-        expect(copy.contents.count).to eq(element.contents.count)
+        expect(subject.contents.count).to eq(element.contents.count)
       end
 
-      it "should create a new record with all attributes of source except given differences" do
-        copy = Element.copy(element, {:name => 'foobar'})
-        expect(copy.name).to eq('foobar')
+      context 'with differences' do
+        subject(:copy) { Element.copy(element, {name: 'foobar'}) }
+
+        it "should create a new record with all attributes of source except given differences" do
+          expect(copy.name).to eq('foobar')
+        end
       end
 
       it "should make copies of all contents of source" do
-        copy = Element.copy(element)
-        expect(copy.contents.pluck(:id)).not_to eq(element.contents.pluck(:id))
+        expect(subject.contents).not_to be_empty
+        expect(subject.contents.pluck(:id)).not_to eq(element.contents.pluck(:id))
       end
 
       it "the copy should include source element tags" do
-        copy = Element.copy(element)
-        expect(copy.tag_list).to eq(element.tag_list)
+        expect(subject.tag_list).to eq(element.tag_list)
+      end
+
+      context 'with nested elements' do
+        let(:element) do
+          create(:alchemy_element, :with_nestable_elements, {
+            create_contents_after_create: true,
+            tag_list: 'red, yellow',
+            page: create(:alchemy_page)
+          })
+        end
+
+        before do
+          element.nested_elements << create(:alchemy_element, name: 'slide')
+        end
+
+        it "should copy nested elements" do
+          expect(subject.nested_elements).to_not be_empty
+        end
+
+        context 'copy to new page' do
+          let(:new_page) { create(:alchemy_page) }
+
+          subject(:new_element) do
+            Element.copy(element, {page_id: new_page.id})
+          end
+
+          it "should set page id to new page's id" do
+            new_element.nested_elements.each do |nested_element|
+              expect(nested_element.page_id).to eq(new_page.id)
+            end
+          end
+        end
+
+        context 'copy to new cell' do
+          let(:new_cell) { create(:alchemy_cell) }
+
+          subject(:new_element) do
+            Element.copy(element, {cell_id: new_cell.id})
+          end
+
+          it "should set cell id to new cell's id" do
+            new_element.nested_elements.each do |nested_element|
+              expect(nested_element.cell_id).to eq(new_cell.id)
+            end
+          end
+        end
       end
     end
 
     describe '.definitions' do
       it "should allow erb generated elements" do
-        expect(Element.definitions.collect { |el| el['name']} ).to include('erb_element')
+        expect(Element.definitions.collect { |el| el['name'] }).to include('erb_element')
       end
 
       context "without existing yml files" do
-        before { allow(File).to receive(:exists?).and_return(false) }
+        before { allow(File).to receive(:exist?).and_return(false) }
 
         it "should raise an error" do
           expect { Element.definitions }.to raise_error(LoadError)
@@ -85,7 +136,7 @@ module Alchemy
 
     describe '.display_name_for' do
       it "should return the translation for the given name" do
-        expect(I18n).to receive(:t).with('subheadline', scope: "element_names", default: 'Subheadline').and_return('Überschrift')
+        expect(Alchemy).to receive(:t).with('subheadline', scope: "element_names", default: 'Subheadline').and_return('Überschrift')
         expect(Element.display_name_for('subheadline')).to eq('Überschrift')
       end
 
@@ -96,44 +147,64 @@ module Alchemy
 
     describe '.excluded' do
       it "should return all elements but excluded ones" do
-        FactoryGirl.create(:element, :name => 'article')
-        FactoryGirl.create(:element, :name => 'article')
-        excluded = FactoryGirl.create(:element, :name => 'claim')
+        create(:alchemy_element, name: 'article')
+        create(:alchemy_element, name: 'article')
+        excluded = create(:alchemy_element, name: 'claim')
         expect(Element.excluded(['claim'])).not_to include(excluded)
       end
     end
 
     describe '.named' do
       it "should return all elements by name" do
-        element_1 = FactoryGirl.create(:element, :name => 'article')
-        element_2 = FactoryGirl.create(:element, :name => 'article')
+        element_1 = create(:alchemy_element, name: 'article')
+        element_2 = create(:alchemy_element, name: 'headline')
         elements = Element.named(['article'])
         expect(elements).to include(element_1)
-        expect(elements).to include(element_2)
+        expect(elements).to_not include(element_2)
       end
     end
 
     describe '.not_in_cell' do
       it "should return all elements that are not in a cell" do
         Element.delete_all
-        FactoryGirl.create(:element, :cell_id => 6)
-        FactoryGirl.create(:element, :cell_id => nil)
+        create(:alchemy_element, cell_id: 6)
+        create(:alchemy_element, cell_id: nil)
         expect(Element.not_in_cell.size).to eq(1)
       end
     end
 
     describe '.published' do
       it "should return all public elements" do
-        element_1 = FactoryGirl.create(:element, :public => true)
-        element_2 = FactoryGirl.create(:element, :public => true)
+        element_1 = create(:alchemy_element, public: true)
+        element_2 = create(:alchemy_element, public: false)
         elements = Element.published
         expect(elements).to include(element_1)
-        expect(elements).to include(element_2)
+        expect(elements).to_not include(element_2)
+      end
+    end
+
+    describe '.folded' do
+      it "returns all folded elements" do
+        element_1 = create(:alchemy_element, folded: true)
+        element_2 = create(:alchemy_element, folded: false)
+        elements = Element.folded
+        expect(elements).to include(element_1)
+        expect(elements).to_not include(element_2)
+      end
+    end
+
+    describe '.expanded' do
+      it "returns all expanded elements" do
+        element_1 = create(:alchemy_element, folded: false)
+        element_2 = create(:alchemy_element, folded: true)
+        elements = Element.expanded
+        expect(elements).to include(element_1)
+        expect(elements).to_not include(element_2)
       end
     end
 
     context 'trash' do
-      let(:element) { FactoryGirl.create(:element, page_id: 1) }
+      let(:element) { create(:alchemy_element, page_id: 1) }
 
       describe '.not_trashed' do
         before { element }
@@ -153,9 +224,9 @@ module Alchemy
     end
 
     describe '.all_from_clipboard_for_page' do
-      let(:element_1) { FactoryGirl.build_stubbed(:element) }
-      let(:element_2) { FactoryGirl.build_stubbed(:element, name: 'news') }
-      let(:page)      { FactoryGirl.build_stubbed(:public_page) }
+      let(:element_1) { build_stubbed(:alchemy_element) }
+      let(:element_2) { build_stubbed(:alchemy_element, name: 'news') }
+      let(:page)      { build_stubbed(:alchemy_page, :public) }
       let(:clipboard) { [{'id' => element_1.id.to_s}, {'id' => element_2.id.to_s}] }
 
       before do
@@ -184,7 +255,7 @@ module Alchemy
     # InstanceMethods
 
     describe '#all_contents_by_type' do
-      let(:element) { FactoryGirl.create(:element, create_contents_after_create: true) }
+      let(:element) { create(:alchemy_element, create_contents_after_create: true) }
       let(:expected_contents) { element.contents.essence_texts }
 
       context "with namespaced essence type" do
@@ -201,8 +272,8 @@ module Alchemy
     end
 
     describe '#available_page_cell_names' do
-      let(:page)    { FactoryGirl.create(:public_page) }
-      let(:element) { FactoryGirl.create(:element, page: page) }
+      let(:page)    { create(:alchemy_page, :public) }
+      let(:element) { create(:alchemy_element, page: page) }
 
       context "with page having cells defining the correct elements" do
         before do
@@ -214,9 +285,9 @@ module Alchemy
         end
 
         it "should return a list of all cells from given page this element could be placed in" do
-          FactoryGirl.create(:cell, name: 'header', page: page)
-          FactoryGirl.create(:cell, name: 'footer', page: page)
-          FactoryGirl.create(:cell, name: 'sidebar', page: page)
+          create(:alchemy_cell, name: 'header', page: page)
+          create(:alchemy_cell, name: 'footer', page: page)
+          create(:alchemy_cell, name: 'sidebar', page: page)
           expect(element.available_page_cell_names(page)).to include('header')
           expect(element.available_page_cell_names(page)).to include('footer')
         end
@@ -226,7 +297,6 @@ module Alchemy
             expect(element.available_page_cell_names(page)).to eq(['for_other_elements'])
           end
         end
-
       end
 
       context "with page having cells defining the wrong elements" do
@@ -239,9 +309,9 @@ module Alchemy
         end
 
         it "should return the 'nil cell'" do
-          FactoryGirl.create(:cell, name: 'header', page: page)
-          FactoryGirl.create(:cell, name: 'footer', page: page)
-          FactoryGirl.create(:cell, name: 'sidebar', page: page)
+          create(:alchemy_cell, name: 'header', page: page)
+          create(:alchemy_cell, name: 'footer', page: page)
+          create(:alchemy_cell, name: 'sidebar', page: page)
           expect(element.available_page_cell_names(page)).to eq(['for_other_elements'])
         end
       end
@@ -249,7 +319,7 @@ module Alchemy
 
     describe '#content_by_type' do
       before(:each) do
-        @element = FactoryGirl.create(:element, :name => 'headline')
+        @element = create(:alchemy_element, name: 'headline')
         @content = @element.contents.first
       end
 
@@ -275,17 +345,34 @@ module Alchemy
       end
     end
 
+    describe '#essence_errors' do
+      let(:element) { Element.new(name: 'article') }
+      let(:content) { Content.new(name: 'headline') }
+      let(:essence) { EssenceText.new(body: '') }
+
+      before do
+        allow(element).to receive(:contents) { [content] }
+        allow(content).to receive(:essence) { essence }
+        allow(content).to receive(:essence_validation_failed?) { true }
+        allow(essence).to receive(:validation_errors) { 'Cannot be blank' }
+      end
+
+      it "returns hash with essence errors" do
+        expect(element.essence_errors).to eq({'headline' => 'Cannot be blank'})
+      end
+    end
+
     describe '#essence_error_messages' do
       let(:element) { Element.new(name: 'article') }
 
       it "should return the translation with the translated content label" do
-        expect(I18n).to receive(:t)
+        expect(Alchemy).to receive(:t)
           .with('content_names.content', default: 'Content')
           .and_return('Content')
-        expect(I18n).to receive(:t)
+        expect(Alchemy).to receive(:t)
           .with('content', scope: "content_names.article", default: 'Content')
           .and_return('Contenido')
-        expect(I18n).to receive(:t)
+        expect(Alchemy).to receive(:t)
           .with('article.content.invalid', {
             scope: "content_validations",
             default: [:"fields.content.invalid", :"errors.invalid"],
@@ -298,7 +385,7 @@ module Alchemy
     end
 
     describe '#display_name_with_preview_text' do
-      let(:element) { FactoryGirl.build_stubbed(:element, name: 'Foo') }
+      let(:element) { build_stubbed(:alchemy_element, name: 'Foo') }
 
       it "returns a string with display name and preview text" do
         allow(element).to receive(:preview_text).and_return('Fula')
@@ -307,7 +394,7 @@ module Alchemy
     end
 
     describe '#dom_id' do
-      let(:element) { FactoryGirl.build_stubbed(:element) }
+      let(:element) { build_stubbed(:alchemy_element) }
 
       it "returns an string from element name and id" do
         expect(element.dom_id).to eq("#{element.name}_#{element.id}")
@@ -315,14 +402,26 @@ module Alchemy
     end
 
     describe '#preview_text' do
-      let(:element) { FactoryGirl.build_stubbed(:element) }
-      let(:content) { mock_model(Content, preview_text: 'Lorem', preview_content?: false) }
-      let(:content_2) { mock_model(Content, preview_text: 'Lorem', preview_content?: false) }
-      let(:preview_content) { mock_model(Content, preview_text: 'Lorem', preview_content?: true) }
+      let(:element) { build_stubbed(:alchemy_element) }
+
+      let(:content) do
+        mock_model(Content, preview_text: 'Content 1', preview_content?: false)
+      end
+
+      let(:content_2) do
+        mock_model(Content, preview_text: 'Content 2', preview_content?: false)
+      end
+
+      let(:preview_content) do
+        mock_model(Content, preview_text: 'Preview Content', preview_content?: true)
+      end
 
       context "without a content marked as preview" do
         let(:contents) { [content, content_2] }
-        before { allow(element).to receive(:contents).and_return(contents) }
+
+        before do
+          allow(element).to receive(:contents).and_return(contents)
+        end
 
         it "returns the preview text of first content found" do
           expect(content).to receive(:preview_text).with(30)
@@ -332,7 +431,10 @@ module Alchemy
 
       context "with a content marked as preview" do
         let(:contents) { [content, preview_content] }
-        before { allow(element).to receive(:contents).and_return(contents) }
+
+        before do
+          allow(element).to receive(:contents).and_return(contents)
+        end
 
         it "should return the preview_text of this content" do
           expect(preview_content).to receive(:preview_text).with(30)
@@ -341,21 +443,61 @@ module Alchemy
       end
 
       context "without any contents present" do
-        before { allow(element).to receive(:contents).and_return([]) }
+        before do
+          allow(element).to receive(:contents).and_return([])
+        end
 
         it "should return nil" do
           expect(element.preview_text).to be_nil
         end
       end
+
+      context 'with nested elements' do
+        let(:element) do
+          build_stubbed(:alchemy_element, :with_nestable_elements)
+        end
+
+        let(:nested_element) do
+          build_stubbed(:alchemy_element, name: 'slide')
+        end
+
+        before do
+          allow(nested_element).to receive(:contents) { [content_2] }
+          allow(element).to receive(:nested_elements) { [nested_element] }
+        end
+
+        context 'when parent element has contents' do
+          before do
+            allow(element).to receive(:contents) { [content] }
+          end
+
+          it 'returns the preview text from the parent element' do
+            expect(content).to receive(:preview_text)
+            expect(element.preview_text)
+          end
+        end
+
+        context 'when parent element has no contents but nestable element has' do
+          before do
+            allow(element).to receive(:contents) { [] }
+            allow(nested_element).to receive(:contents) { [content_2] }
+          end
+
+          it 'returns the preview text from the first nested element' do
+            expect(content_2).to receive(:preview_text)
+            expect(element.preview_text)
+          end
+        end
+      end
     end
 
     context 'previous and next elements.' do
-      let(:page) { FactoryGirl.create(:language_root_page) }
+      let(:page) { create(:alchemy_page, :language_root) }
 
       before(:each) do
-        @element1 = FactoryGirl.create(:element, :page => page, :name => 'headline')
-        @element2 = FactoryGirl.create(:element, :page => page)
-        @element3 = FactoryGirl.create(:element, :page => page, :name => 'text')
+        @element1 = create(:alchemy_element, page: page, name: 'headline')
+        @element2 = create(:alchemy_element, page: page)
+        @element3 = create(:alchemy_element, page: page, name: 'text')
       end
 
       describe '#prev' do
@@ -384,7 +526,7 @@ module Alchemy
     end
 
     context 'retrieving contents, essences and ingredients' do
-      let(:element) { FactoryGirl.create(:element, :name => 'news', :create_contents_after_create => true) }
+      let(:element) { create(:alchemy_element, name: 'news', create_contents_after_create: true) }
 
       it "should return an ingredient by name" do
         expect(element.ingredient('news_headline')).to eq(EssenceText.first.ingredient)
@@ -399,7 +541,7 @@ module Alchemy
       end
 
       context 'if no content is defined as rss title' do
-        before { expect(element).to receive(:content_descriptions).and_return([]) }
+        before { expect(element).to receive(:content_definitions).and_return([]) }
 
         it "should return nil" do
           expect(element.content_for_rss_title).to be_nil
@@ -407,7 +549,7 @@ module Alchemy
       end
 
       context 'if no content is defined as rss description' do
-        before { expect(element).to receive(:content_descriptions).and_return([]) }
+        before { expect(element).to receive(:content_definitions).and_return([]) }
 
         it "should return nil" do
           expect(element.content_for_rss_description).to be_nil
@@ -418,8 +560,8 @@ module Alchemy
     describe '#update_contents' do
       subject { element.update_contents(params) }
 
-      let(:page)     { build_stubbed(:page) }
-      let(:element)  { build_stubbed(:element, page: page) }
+      let(:page)     { build_stubbed(:alchemy_page) }
+      let(:element)  { build_stubbed(:alchemy_element, page: page) }
       let(:content1) { double(:content, id: 1) }
       let(:content2) { double(:content, id: 2) }
 
@@ -431,7 +573,7 @@ module Alchemy
       end
 
       context "with valid attributes hash" do
-        let(:params) { {"#{content1.id}" => {body: 'Title'}} }
+        let(:params) { {content1.id.to_s => {body: 'Title'}} }
 
         context 'when certain content is not part of the attributes hash (cause it was not filled by the user)' do
           before do
@@ -469,9 +611,9 @@ module Alchemy
     end
 
     describe '.after_update' do
-      let(:page)    { create(:page) }
-      let(:element) { create(:element, page: page) }
-      let(:now)     { Time.now }
+      let(:page)    { create(:alchemy_page) }
+      let(:element) { create(:alchemy_element, page: page) }
+      let(:now)     { Time.current }
 
       before do
         allow(Time).to receive(:now).and_return(now)
@@ -519,7 +661,7 @@ module Alchemy
     end
 
     describe '#taggable?' do
-      let(:element) { FactoryGirl.build(:element) }
+      let(:element) { build(:alchemy_element) }
 
       context "definition has 'taggable' key with true value" do
         it "should return true" do
@@ -552,8 +694,8 @@ module Alchemy
     end
 
     describe '#trash!' do
-      let(:element)         { FactoryGirl.create(:element, page_id: 1, cell_id: 1) }
-      let(:trashed_element) { element.trash! ; element }
+      let(:element)         { create(:alchemy_element, page_id: 1, cell_id: 1) }
+      let(:trashed_element) { element.trash!; element }
       subject               { trashed_element }
 
       it             { is_expected.not_to be_public }
@@ -567,7 +709,7 @@ module Alchemy
       specify        { expect { element.trash! }.to_not change(element, :cell_id) }
 
       context "with already one trashed element on the same page" do
-        let(:element_2) { FactoryGirl.create(:element, page_id: 1) }
+        let(:element_2) { create(:alchemy_element, page_id: 1) }
 
         before do
           trashed_element
@@ -588,8 +730,8 @@ module Alchemy
     end
 
     describe '#cache_key' do
-      let(:page) { stub_model(Page, published_at: Time.now - 1.week) }
-      let(:element) { stub_model(Element, page: page, updated_at: Time.now) }
+      let(:page) { stub_model(Page, published_at: Time.current - 1.week) }
+      let(:element) { stub_model(Element, page: page, updated_at: Time.current) }
 
       subject { element.cache_key }
 
@@ -613,5 +755,108 @@ module Alchemy
     it_behaves_like "having a hint" do
       let(:subject) { Element.new }
     end
+
+    describe "#nestable_elements" do
+      let(:element) { Element.new }
+
+      subject { element.nestable_elements }
+
+      context 'with nestable_elements defined' do
+        before do
+          allow(element).to receive(:definition) do
+            {
+              'nestable_elements' => %w(news article)
+            }
+          end
+        end
+
+        it 'returns an array containing all available nested element names' do
+          is_expected.to eq %w(news article)
+        end
+      end
+
+      context 'without nestable_elements defined' do
+        before do
+          allow(element).to receive(:definition) do
+            {}
+          end
+        end
+
+        it 'returns an empty array' do
+          is_expected.to eq []
+        end
+      end
+    end
+
+    describe "#nested_elements" do
+      subject { element.nested_elements }
+
+      context 'with nestable_elements defined' do
+        let(:element) { create(:alchemy_element, :with_nestable_elements) }
+
+        before do
+          element.nested_elements << create(:alchemy_element, name: 'slide')
+        end
+
+        it 'returns an AR scope containing nested elements' do
+          expect(subject.count).to eq(1)
+        end
+      end
+    end
+
+    describe '#richtext_contents_ids' do
+      subject { element.richtext_contents_ids }
+
+      let(:element) { create(:alchemy_element, :with_contents, name: 'text') }
+
+      it { is_expected.to eq(element.content_ids) }
+
+      context 'for element with nested elements' do
+        let!(:element) do
+          create(:alchemy_element, :with_contents, name: 'text')
+        end
+
+        let!(:nested_element_1) do
+          create(:alchemy_element, :with_contents, {
+            name: 'text',
+            parent_element: element,
+            folded: false
+          })
+        end
+
+        let!(:nested_element_2) do
+          create(:alchemy_element, :with_contents, {
+            name: 'text',
+            parent_element: nested_element_1,
+            folded: false
+          })
+        end
+
+        let!(:folded_nested_element_3) do
+          create(:alchemy_element, :with_contents, {
+            name: 'text',
+            parent_element: nested_element_1,
+            folded: true
+          })
+        end
+
+        it 'includes all richtext contents from all expanded descendent elements' do
+          is_expected.to eq(
+            element.content_ids +
+            nested_element_1.content_ids +
+            nested_element_2.content_ids
+          )
+        end
+      end
+    end
+
+    context 'with parent element' do
+      let!(:parent_element) { create(:alchemy_element, :with_nestable_elements) }
+      let!(:element)        { create(:alchemy_element, name: 'slide', parent_element: parent_element) }
+
+      it "touches parent after update" do
+        expect { element.update!(public: false) }.to change(parent_element, :updated_at)
+      end
+    end
   end
 end