alchemy_cms 2.2.2 → 2.2.3.1

data/spec/integration/security_spec.rb

@@ -19,7 +19,7 @@ describe "Security: " do
 
   context "If user is present" do
 
-    before(:all) do
+    before(:each) do
       create_admin_user
     end
 

data/spec/models/element_spec.rb

@@ -1,272 +1,294 @@
 require 'spec_helper'
 
-describe Alchemy::Element do
+module Alchemy
+  describe Element do
 
-  context "scoped" do
+    context "scoped" do
 
-    before(:each) do
-      Alchemy::Element.delete_all
-    end
+      before(:each) do
+        Element.delete_all
+      end
 
-    it "should return all public elements" do
-      elements = [FactoryGirl.create(:element, :public => true), FactoryGirl.create(:element, :public => true)]
-      Alchemy::Element.published.all.should == elements
-    end
+      it "should return all public elements" do
+        elements = [FactoryGirl.create(:element, :public => true), FactoryGirl.create(:element, :public => true)]
+        Element.published.all.should == elements
+      end
 
-    it "should return all elements by name" do
-      elements = [FactoryGirl.create(:element, :name => 'article'), FactoryGirl.create(:element, :name => 'article')]
-      Alchemy::Element.named(['article']).all.should == elements
-    end
+      it "should return all elements by name" do
+        elements = [FactoryGirl.create(:element, :name => 'article'), FactoryGirl.create(:element, :name => 'article')]
+        Element.named(['article']).all.should == elements
+      end
 
-    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')]
-      Alchemy::Element.excluded(['article']).all.should == excluded
-    end
+      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')]
+        Element.excluded(['article']).all.should == excluded
+      end
 
-    context "not_in_cell" do
-      it "should return all elements that are not in a cell" do
-        FactoryGirl.create(:element, :cell_id => 6)
-        FactoryGirl.create(:element, :cell_id => nil)
-        Alchemy::Element.not_in_cell.should have(1).element
+      context "not_in_cell" do
+        it "should return all elements that are not in a cell" do
+          FactoryGirl.create(:element, :cell_id => 6)
+          FactoryGirl.create(:element, :cell_id => nil)
+          Element.not_in_cell.should have(1).element
+        end
       end
+
     end
 
-  end
+    it "should return a list of element definitions for a list of element names" do
+      element_names = ["article"]
+      definitions = Element.all_definitions_for(element_names)
+      definitions.first.fetch("name").should == 'article'
+    end
 
-  it "should return a list of element definitions for a list of element names" do
-    element_names = ["article"]
-    definitions = Alchemy::Element.all_definitions_for(element_names)
-    definitions.first.fetch("name").should == 'article'
-  end
+    it "should always return an array calling all_definitions_for()" do
+      definitions = Element.all_definitions_for(nil)
+      definitions.should == []
+    end
 
-  it "should always return an array calling all_definitions_for()" do
-    definitions = Alchemy::Element.all_definitions_for(nil)
-    definitions.should == []
-  end
+    context "no description files are found" do
 
-  context "no description files are found" do
+      before(:each) do
+        FileUtils.mv(File.join(File.dirname(__FILE__), '..', '..', 'config', 'alchemy', 'elements.yml'), File.join(File.dirname(__FILE__), '..', '..', 'config', 'alchemy', 'elements.yml.bak'))
+      end
 
-    before(:each) do
-      FileUtils.mv(File.join(File.dirname(__FILE__), '..', '..', 'config', 'alchemy', 'elements.yml'), File.join(File.dirname(__FILE__), '..', '..', 'config', 'alchemy', 'elements.yml.bak'))
-    end
+      it "should raise an error" do
+        expect { Element.descriptions }.to raise_error(LoadError)
+      end
 
-    it "should raise an error" do
-      expect { Alchemy::Element.descriptions }.should raise_error(LoadError)
-    end
+      after(:each) do
+        FileUtils.mv(File.join(File.dirname(__FILE__), '..', '..', 'config', 'alchemy', 'elements.yml.bak'), File.join(File.dirname(__FILE__), '..', '..', 'config', 'alchemy', 'elements.yml'))
+      end
 
-    after(:each) do
-      FileUtils.mv(File.join(File.dirname(__FILE__), '..', '..', 'config', 'alchemy', 'elements.yml.bak'), File.join(File.dirname(__FILE__), '..', '..', 'config', 'alchemy', 'elements.yml'))
     end
 
-  end
+    context "retrieving contents, essences and ingredients" do
 
-  context "retrieving contents, essences and ingredients" do
+      before(:each) do
+        @element = FactoryGirl.create(:element, :name => 'news')
+      end
 
-    before(:each) do
-      @element = FactoryGirl.create(:element, :name => 'news')
-    end
+      it "should return an ingredient by name" do
+        @element.ingredient('news_headline').should == EssenceText.first.ingredient
+      end
 
-    it "should return an ingredient by name" do
-      @element.ingredient('news_headline').should == Alchemy::EssenceText.first.ingredient
-    end
+      it "should return the content for rss title" do
+        @element.content_for_rss_title.should == @element.contents.find_by_name('news_headline')
+      end
 
-    it "should return the content for rss title" do
-      @element.content_for_rss_title.should == @element.contents.find_by_name('news_headline')
-    end
+      it "should return the content for rss description" do
+        @element.content_for_rss_description.should == @element.contents.find_by_name('body')
+      end
 
-    it "should return the content for rss description" do
-      @element.content_for_rss_description.should == @element.contents.find_by_name('body')
     end
 
-  end
+    it "should return a collection of trashed elements" do
+      @element = FactoryGirl.create(:element)
+      @element.trash
+      Element.trashed.should include(@element)
+    end
+
+    it "should return a collection of not trashed elements" do
+      @element = FactoryGirl.create(:element, :page_id => 1)
+      Element.not_trashed.should include(@element)
+    end
+
+    context "limited amount" do
+      before(:each) do
+        descriptions = Element.descriptions
+        descriptions << {
+          'name' => 'column_headline',
+          'amount' => 3,
+          'contents' => [{'name' => 'headline', 'type' => 'EssenceText'}]
+        }
+        descriptions << {
+          'name' => 'unique_headline',
+          'unique' => true,
+          'amount' => 3,
+          'contents' => [{'name' => 'headline', 'type' => 'EssenceText'}]
+        }
+        Element.stub!(:descriptions).and_return(descriptions)
+        PageLayout.add(
+          'name' => 'columns',
+          'elements' => ['column_headline', 'unique_headline'],
+          'autogenerate' => ['unique_headline', 'column_headline', 'column_headline', 'column_headline']
+        )
+        @page = FactoryGirl.create(:page, :page_layout => 'columns')
+      end
 
-  it "should return a collection of trashed elements" do
-    @element = FactoryGirl.create(:element)
-    @element.trash
-    Alchemy::Element.trashed.should include(@element)
-  end
+      it "should be readable" do
+        element = Element.all_definitions_for(['column_headline']).first
+        element['amount'].should be 3
+      end
 
-  it "should return a collection of not trashed elements" do
-    @element = FactoryGirl.create(:element, :page_id => 1)
-    Alchemy::Element.not_trashed.should include(@element)
-  end
+      it "should limit elements" do
+        Element.all_for_page(@page).each { |e| e['name'].should_not == 'column_headline' }
+      end
 
-  context "limited amount" do
-    before(:each) do
-      descriptions = Alchemy::Element.descriptions
-      descriptions << {
-        'name' => 'column_headline',
-        'amount' => 3,
-        'contents' => [{'name' => 'headline', 'type' => 'EssenceText'}]
-      }
-      descriptions << {
-        'name' => 'unique_headline',
-        'unique' => true,
-        'amount' => 3,
-        'contents' => [{'name' => 'headline', 'type' => 'EssenceText'}]
-      }
-      Alchemy::Element.stub!(:descriptions).and_return(descriptions)
-      Alchemy::PageLayout.add(
-        'name' => 'columns',
-        'elements' => ['column_headline', 'unique_headline'],
-        'autogenerate' => ['unique_headline', 'column_headline', 'column_headline', 'column_headline']
-      )
-      @page = FactoryGirl.create(:page, :page_layout => 'columns')
-    end
+      it "should be ignored if unique" do
+        Element.all_for_page(@page).each { |e| e['name'].should_not == 'unique_headline' }
+      end
 
-    it "should be readable" do
-      element = Alchemy::Element.all_definitions_for(['column_headline']).first
-      element['amount'].should be 3
     end
 
-    it "should limit elements" do
-      Alchemy::Element.all_for_page(@page).each { |e| e['name'].should_not == 'column_headline' }
-    end
+    context "trashed" do
 
-    it "should be ignored if unique" do
-      Alchemy::Element.all_for_page(@page).each { |e| e['name'].should_not == 'unique_headline' }
-    end
+      before(:each) do
+        @element = FactoryGirl.create(:element)
+        @element.trash
+      end
 
-  end
+      it "should be not public" do
+        @element.public.should be_false
+      end
 
-  context "trashed" do
+      it "should have no page" do
+        @element.page.should == nil
+      end
 
-    before(:each) do
-      @element = FactoryGirl.create(:element)
-      @element.trash
-    end
+      context "collections" do
 
-    it "should be not public" do
-      @element.public.should be_false
-    end
+        context "for trashed elements" do
 
-    it "should have no page" do
-      @element.page.should == nil
-    end
+          let(:element) do
+            FactoryGirl.create(:element, :page_id => 1)
+          end
 
-    it "should be folded" do
-      @element.folded.should == true
-    end
+          it "should return a collection of trashed elements" do
+            not_trashed_element = FactoryGirl.create(:element)
+            element.trash
+            Element.trashed.should include(element)
+          end
 
-  end
+          it "should return a collection of not trashed elements" do
+            Element.not_trashed.should include(element)
+          end
 
-  it "should raise error if all_for_page method has no page" do
-    expect { Alchemy::Element.all_for_page(nil) }.should raise_error(TypeError)
-  end
+        end
 
-  describe "#content_by_type" do
+      end
 
-    before(:each) do
-      @element = FactoryGirl.create(:element, :name => 'headline')
-      @content = @element.contents.first
     end
 
-    context "with namespaced essence type" do
+    describe "#trash" do
 
-      it "should return content by passing a essence type" do
-        @element.content_by_type('Alchemy::EssenceText').should == @content
+      before(:each) do
+        @element = FactoryGirl.create(:element, :page_id => 1, :cell_id => 1)
+        @element.trash
       end
 
-    end
-
-    context "without namespaced essence type" do
+      it "should remove the elements position" do
+        @element.position.should == nil
+      end
 
-      it "should return content by passing a essence type" do
-        @element.content_by_type('EssenceText').should == @content
+      it "should set the public state to false" do
+        @element.public?.should == false
       end
 
-    end
+      it "should not remove the page_id" do
+        @element.page_id.should == 1
+      end
 
-  end
+      it "should not remove the cell_id" do
+        @element.cell_id.should == 1
+      end
 
-  describe "#all_contents_by_type" do
+      it "it should be possible to trash more than one element from the same page" do
+        trashed_element_2 = FactoryGirl.create(:element, :page_id => 1)
+        trashed_element_2.trash
+        Element.trashed.should include(@element, trashed_element_2)
+      end
 
-    before(:each) do
-      @element = FactoryGirl.create(:element)
-      @contents = @element.contents.select { |c| c.essence_type == 'Alchemy::EssenceText' }
     end
 
-    context "with namespaced essence type" do
+    describe "#all_contents_by_type" do
 
-      it "should return content by passing a essence type" do
-        @element.all_contents_by_type('Alchemy::EssenceText').should == @contents
+      before(:each) do
+        @element = FactoryGirl.create(:element)
+        @contents = @element.contents.select { |c| c.essence_type == 'Alchemy::EssenceText' }
       end
 
-    end
+      context "with namespaced essence type" do
 
-    context "without namespaced essence type" do
+        it "should return content by passing a essence type" do
+          @element.all_contents_by_type('Alchemy::EssenceText').should == @contents
+        end
 
-      it "should return content by passing a essence type" do
-        @element.all_contents_by_type('EssenceText').should == @contents
       end
 
-    end
+      context "without namespaced essence type" do
 
-  end
+        it "should return content by passing a essence type" do
+          @element.all_contents_by_type('EssenceText').should == @contents
+        end
 
-  describe '#copy' do
+      end
 
-    before(:each) do
-      @element = FactoryGirl.create(:element)
     end
 
-    it "should not create contents from scratch" do
-      copy = Alchemy::Element.copy(@element)
-      copy.contents.count.should == @element.contents.count
-    end
+    describe '#copy' do
 
-    it "should create a new record with all attributes of source except given differences" do
-      copy = Alchemy::Element.copy(@element, {:name => 'foobar'})
-      copy.name.should == 'foobar'
-    end
+      before(:each) do
+        @element = FactoryGirl.create(:element)
+      end
 
-    it "should make copies of all contents of source" do
-      copy = Alchemy::Element.copy(@element)
-      copy.contents.collect(&:id).should_not == @element.contents.collect(&:id)
-    end
+      it "should not create contents from scratch" do
+        copy = Element.copy(@element)
+        copy.contents.count.should == @element.contents.count
+      end
 
-  end
+      it "should create a new record with all attributes of source except given differences" do
+        copy = Element.copy(@element, {:name => 'foobar'})
+        copy.name.should == 'foobar'
+      end
 
-  describe "Finding previous or next element." do
+      it "should make copies of all contents of source" do
+        copy = Element.copy(@element)
+        copy.contents.collect(&:id).should_not == @element.contents.collect(&:id)
+      end
 
-    before(:each) do
-      @page = FactoryGirl.create(:language_root_page)
-      @page.elements.delete_all
-      @element1 = FactoryGirl.create(:element, :page => @page, :name => 'headline')
-      @element2 = FactoryGirl.create(:element, :page => @page)
-      @element3 = FactoryGirl.create(:element, :page => @page, :name => 'text')
     end
 
-    describe '#prev' do
+    describe "Finding previous or next element." do
 
-      it "should return previous element on same page" do
-        @element2.prev.should == @element1
+      before(:each) do
+        @page = FactoryGirl.create(:language_root_page)
+        @page.elements.delete_all
+        @element1 = FactoryGirl.create(:element, :page => @page, :name => 'headline')
+        @element2 = FactoryGirl.create(:element, :page => @page)
+        @element3 = FactoryGirl.create(:element, :page => @page, :name => 'text')
       end
 
-      context "with name as parameter" do
-        it "should return previous of this kind" do
-          @element3.prev('headline').should == @element1
-        end
-      end
+      describe '#prev' do
 
-    end
+        it "should return previous element on same page" do
+          @element2.prev.should == @element1
+        end
 
-    describe '#next' do
+        context "with name as parameter" do
+          it "should return previous of this kind" do
+            @element3.prev('headline').should == @element1
+          end
+        end
 
-      it "should return next element on same page" do
-        @element1.next.should == @element2
       end
 
-      context "with name as parameter" do
-        it "should return next of this kind" do
-          @element1.next('text').should == @element3
+      describe '#next' do
+
+        it "should return next element on same page" do
+          @element1.next.should == @element2
+        end
+
+        context "with name as parameter" do
+          it "should return next of this kind" do
+            @element1.next('text').should == @element3
+          end
         end
+
       end
 
     end
 
   end
-
 end