alchemy_cms 2.2.4 → 2.3.rc5

data/spec/libraries/resources_helper_spec.rb

@@ -6,6 +6,9 @@ module Namespace
   end
 end
 
+module EngineResource
+end
+
 class ResourcesController
   def resource_handler
     @resource_handler = Alchemy::Resource.new('admin/namespace/my_resources')

data/spec/models/content_spec.rb

@@ -1,100 +1,103 @@
 require 'spec_helper'
 
-describe Alchemy::Content do
+module Alchemy
+  describe Content do
 
-  it "should return the ingredient from its essence" do
-    @element = FactoryGirl.create(:element, :name => 'headline')
-    @content = @element.contents.find_by_essence_type('Alchemy::EssenceText')
-    @content.essence.update_attributes(:body => "Hello")
-    @content.ingredient.should == "Hello"
-  end
+    let(:element) { FactoryGirl.create(:element, :name => 'headline', :create_contents_after_create => true) }
+    let(:content) { element.contents.find_by_essence_type('Alchemy::EssenceText') }
+
+    it "should return the ingredient from its essence" do
+      content.essence.update_attributes(:body => "Hello")
+      content.ingredient.should == "Hello"
+    end
 
-  describe '.normalize_essence_type' do
+    describe '.normalize_essence_type' do
 
-    context "passing namespaced essence type" do
+      context "passing namespaced essence type" do
+
+        it "should not add alchemy namespace" do
+          Content.normalize_essence_type('Alchemy::EssenceText').should == "Alchemy::EssenceText"
+        end
 
-      it "should not add alchemy namespace" do
-        Alchemy::Content.normalize_essence_type('Alchemy::EssenceText').should == "Alchemy::EssenceText"
       end
 
-    end
+      context "passing not namespaced essence type" do
 
-    context "passing not namespaced essence type" do
+        it "should add alchemy namespace" do
+          Content.normalize_essence_type('EssenceText').should == "Alchemy::EssenceText"
+        end
 
-      it "should add alchemy namespace" do
-        Alchemy::Content.normalize_essence_type('EssenceText').should == "Alchemy::EssenceText"
       end
 
     end
 
-  end
+    describe '#normalized_essence_type' do
 
-  describe '#normalized_essence_type' do
+      context "without namespace in essence_type column" do
 
-    context "without namespace in essence_type column" do
+        it "should return the namespaced essence type" do
+          Content.new(:essence_type => 'EssenceText').normalized_essence_type.should == 'Alchemy::EssenceText'
+        end
 
-      it "should return the namespaced essence type" do
-        Alchemy::Content.new(:essence_type => 'EssenceText').normalized_essence_type.should == 'Alchemy::EssenceText'
       end
 
-    end
+      context "with namespace in essence_type column" do
 
-    context "with namespace in essence_type column" do
+        it "should return the namespaced essence type" do
+          Content.new(:essence_type => 'Alchemy::EssenceText').normalized_essence_type.should == 'Alchemy::EssenceText'
+        end
 
-      it "should return the namespaced essence type" do
-        Alchemy::Content.new(:essence_type => 'Alchemy::EssenceText').normalized_essence_type.should == 'Alchemy::EssenceText'
       end
 
     end
 
-  end
+    describe '#update_essence' do
 
-  describe '#update_essence' do
+      it "should update the attributes of related essence and return true" do
+        @element = FactoryGirl.create(:element, :name => 'text', :create_contents_after_create => true)
+        @content = @element.contents.first
+        @content.update_essence(:body => 'Mikes Petshop')
+        @content.ingredient.should == "Mikes Petshop"
+      end
 
-    it "should update the attributes of related essence and return true" do
-      @element = FactoryGirl.create(:element, :name => 'text')
-      @content = @element.contents.first
-      @content.update_essence(:body => 'Mikes Petshop')
-      @content.ingredient.should == "Mikes Petshop"
-    end
+      it "should add error messages if save fails and return false" do
+        @element = FactoryGirl.create(:element, :name => 'contactform', :create_contents_after_create => true)
+        @content = @element.contents.first
+        @content.update_essence
+        @content.errors[:essence].should have(1).item
+      end
 
-    it "should add error messages if save fails and return false" do
-      @element = FactoryGirl.create(:element, :name => 'contactform')
-      @content = @element.contents.first
-      @content.update_essence
-      @content.errors[:essence].should have(1).item
-    end
+      it "should raise error if essence is missing" do
+        @element = FactoryGirl.create(:element, :name => 'text', :create_contents_after_create => true)
+        @content = @element.contents.first
+        @content.update_essence
+      end
 
-    it "should raise error if essence is missing" do
-      @element = FactoryGirl.create(:element, :name => 'text')
-      @content = @element.contents.first
-      @content.update_essence
     end
 
-  end
+    describe '#copy' do
 
-  describe '#copy' do
+      before(:each) do
+        @element = FactoryGirl.create(:element, :name => 'text', :create_contents_after_create => true)
+        @content = @element.contents.first
+      end
 
-    before(:each) do
-      @element = FactoryGirl.create(:element, :name => 'text')
-      @content = @element.contents.first
-    end
+      it "should create a new record with all attributes of source except given differences" do
+        copy = Content.copy(@content, {:name => 'foobar', :element_id => @element.id + 1})
+        copy.name.should == 'foobar'
+      end
 
-    it "should create a new record with all attributes of source except given differences" do
-      copy = Alchemy::Content.copy(@content, {:name => 'foobar', :element_id => @element.id + 1})
-      copy.name.should == 'foobar'
-    end
+      it "should make a new record for essence of source" do
+        copy = Content.copy(@content, {:element_id => @element.id + 1})
+        copy.essence_id.should_not == @content.essence_id
+      end
 
-    it "should make a new record for essence of source" do
-      copy = Alchemy::Content.copy(@content, {:element_id => @element.id + 1})
-      copy.essence_id.should_not == @content.essence_id
-    end
+      it "should copy source essence attributes" do
+        copy = Content.copy(@content, {:element_id => @element.id + 1})
+        copy.essence.body == @content.essence.body
+      end
 
-    it "should copy source essence attributes" do
-      copy = Alchemy::Content.copy(@content, {:element_id => @element.id + 1})
-      copy.essence.body == @content.essence.body
     end
 
   end
-
 end

data/spec/models/element_spec.rb

@@ -3,48 +3,101 @@ require 'spec_helper'
 module Alchemy
   describe Element do
 
-    context "scoped" do
+    describe '#new_from_scratch' do
 
-      before(:each) do
-        Element.delete_all
+      it "should initialize an element by name from scratch" do
+        el = Element.new_from_scratch({'name' => 'article'})
+        el.should be_valid
+      end
+
+      it "should raise an error if the given name is not defined in the elements.yml" do
+        expect { Element.new_from_scratch({'name' => 'foobar'}) }.to raise_error
       end
 
+      it "should take the first part of an given name containing a hash (#)" do
+        el = Element.new_from_scratch({'name' => 'article#header'})
+        el.name.should == "article"
+      end
+
+      it "should merge given attributes into defined ones" do
+        el = Element.new_from_scratch({'name' => 'article', 'page_id' => 1})
+        el.page_id.should == 1
+      end
+
+      it "should not have forbidden attributes from definition" do
+        el = Element.new_from_scratch({'name' => 'article'})
+        el.contents.should == []
+      end
+
+    end
+
+    context "scoped" do
+
       it "should return all public elements" do
-        elements = [FactoryGirl.create(:element, :public => true), FactoryGirl.create(:element, :public => true)]
-        Element.published.all.should == elements
+        element_1 = FactoryGirl.create(:element, :public => true)
+        element_2 = FactoryGirl.create(:element, :public => true)
+        elements = Element.published.all
+        elements.should include(element_1)
+        elements.should include(element_2)
       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
+        element_1 = FactoryGirl.create(:element, :name => 'article')
+        element_2 = FactoryGirl.create(:element, :name => 'article')
+        elements = Element.named(['article']).all
+        elements.should include(element_1)
+        elements.should include(element_2)
       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
+        excluded = FactoryGirl.create(:element, :name => 'claim')
+        Element.excluded(['claim']).all.should_not include(excluded)
       end
 
       context "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)
           Element.not_in_cell.should have(1).element
         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
+    describe '.all_definitions_for' do
+
+      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
+
+      context "given 'all' as element name" do
+
+        before do
+          @element_definition = [
+            {'name' => 'article'},
+            {'name' => 'headline'}
+          ]
+          Element.stub!(:definitions).and_return @element_definition
+        end
+
+        it "should return all element definitions" do
+          Element.all_definitions_for('all').should == @element_definition
+        end
+
+      end
+
+      it "should always return an array" do
+        definitions = Element.all_definitions_for(nil)
+        definitions.should == []
+      end
 
-    it "should always return an array calling all_definitions_for()" do
-      definitions = Element.all_definitions_for(nil)
-      definitions.should == []
     end
 
     context "no description files are found" do
@@ -65,56 +118,47 @@ module Alchemy
 
     context "retrieving contents, essences and ingredients" do
 
-      before(:each) do
-        @element = FactoryGirl.create(:element, :name => 'news')
-      end
+      let(:element) { FactoryGirl.create(:element, :name => 'news', :create_contents_after_create => true) }
 
       it "should return an ingredient by name" do
-        @element.ingredient('news_headline').should == EssenceText.first.ingredient
+        element.ingredient('news_headline').should == 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')
+        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')
+        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(
+
+      before do
+        defs = [
+          {
+            'name' => 'column_headline',
+            'amount' => 3,
+            'contents' => [{'name' => 'headline', 'type' => 'EssenceText'}]
+          },
+          {
+            'name' => 'unique_headline',
+            'unique' => true,
+            'amount' => 3,
+            'contents' => [{'name' => 'headline', 'type' => 'EssenceText'}]
+          }
+        ]
+        # F&%#ing alias methods
+        Element.stub!(:definitions).and_return(defs)
+        Element.stub!(:descriptions).and_return(defs)
+        PageLayout.stub!(:get).and_return({
           'name' => 'columns',
           'elements' => ['column_headline', 'unique_headline'],
           'autogenerate' => ['unique_headline', 'column_headline', 'column_headline', 'column_headline']
-        )
-        @page = FactoryGirl.create(:page, :page_layout => 'columns')
+        })
+        @page = FactoryGirl.create(:page, :page_layout => 'columns', :do_not_autogenerate => false)
       end
 
       it "should be readable" do
@@ -132,39 +176,22 @@ module Alchemy
 
     end
 
-    context "trashed" do
+    context "collections" do
 
-      before(:each) do
-        @element = FactoryGirl.create(:element)
-        @element.trash
-      end
-
-      it "should be not public" do
-        @element.public.should be_false
-      end
-
-      it "should have no page" do
-        @element.page.should == nil
-      end
-
-      context "collections" do
+      context "for trashed elements" do
 
-        context "for trashed elements" do
-
-          let(:element) do
-            FactoryGirl.create(:element, :page_id => 1)
-          end
-
-          it "should return a collection of trashed elements" do
-            not_trashed_element = FactoryGirl.create(:element)
-            element.trash
-            Element.trashed.should include(element)
-          end
+        let(:element) do
+          FactoryGirl.create(:element, :page_id => 1)
+        end
 
-          it "should return a collection of not trashed elements" do
-            Element.not_trashed.should include(element)
-          end
+        it "should return a collection of trashed elements" do
+          not_trashed_element = FactoryGirl.create(:element)
+          element.trash
+          Element.trashed.should include(element)
+        end
 
+        it "should return a collection of not trashed elements" do
+          Element.not_trashed.should include(element)
         end
 
       end
@@ -202,6 +229,35 @@ module Alchemy
 
     end
 
+    it "should raise error if all_for_page method has no page" do
+      expect { Element.all_for_page(nil) }.to raise_error(TypeError)
+    end
+
+    describe "#content_by_type" do
+
+      before(:each) do
+        @element = FactoryGirl.create(:element, :name => 'headline')
+        @content = @element.contents.first
+      end
+
+      context "with namespaced essence type" do
+
+        it "should return content by passing a essence type" do
+          @element.content_by_type('Alchemy::EssenceText').should == @content
+        end
+
+      end
+
+      context "without namespaced essence type" do
+
+        it "should return content by passing a essence type" do
+          @element.content_by_type('EssenceText').should == @content
+        end
+
+      end
+
+    end
+
     describe "#all_contents_by_type" do
 
       before(:each) do
@@ -229,35 +285,33 @@ module Alchemy
 
     describe '#copy' do
 
-      before(:each) do
-        @element = FactoryGirl.create(:element)
-      end
+      let(:element) { FactoryGirl.create(:element, :create_contents_after_create => true) }
 
       it "should not create contents from scratch" do
-        copy = Element.copy(@element)
-        copy.contents.count.should == @element.contents.count
+        copy = Element.copy(element)
+        copy.contents.count.should == 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'})
+        copy = Element.copy(element, {:name => 'foobar'})
         copy.name.should == 'foobar'
       end
 
       it "should make copies of all contents of source" do
-        copy = Element.copy(@element)
-        copy.contents.collect(&:id).should_not == @element.contents.collect(&:id)
+        copy = Element.copy(element)
+        copy.contents.collect(&:id).should_not == element.contents.collect(&:id)
       end
 
     end
 
     describe "Finding previous or next element." do
 
+      let(:page) { FactoryGirl.create(:language_root_page) }
+
       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')
+        @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
@@ -290,5 +344,61 @@ module Alchemy
 
     end
 
+    describe '#belonging_cellnames' do
+
+      before do
+        @page = FactoryGirl.create(:public_page)
+        @element = FactoryGirl.create(:element, :page => @page)
+      end
+
+      context "with page having cells defining the correct elements" do
+
+        before do
+          Cell.stub!(:definitions).and_return([
+            {'name' => 'header', 'elements' => ['article', 'headline']},
+            {'name' => 'footer', 'elements' => ['article', 'text']},
+            {'name' => 'sidebar', 'elements' => ['teaser']}
+          ])
+        end
+
+        it "should return a list of all cells from given page this element could be placed in" do
+          @header_cell = FactoryGirl.create(:cell, :name => 'header', :page => @page)
+          @footer_cell = FactoryGirl.create(:cell, :name => 'footer', :page => @page)
+          @sidebar_cell = FactoryGirl.create(:cell, :name => 'sidebar', :page => @page)
+          @element.belonging_cellnames(@page).should include('header')
+          @element.belonging_cellnames(@page).should include('footer')
+        end
+
+        context "but without any cells" do
+
+          it "should return the 'nil cell'" do
+            @element.belonging_cellnames(@page).should == ['for_other_elements']
+          end
+
+        end
+
+      end
+
+      context "with page having cells defining the wrong elements" do
+
+        before do
+          Cell.stub!(:definitions).and_return([
+            {'name' => 'header', 'elements' => ['download', 'headline']},
+            {'name' => 'footer', 'elements' => ['contactform', 'text']},
+            {'name' => 'sidebar', 'elements' => ['teaser']}
+          ])
+        end
+
+        it "should return the 'nil cell'" do
+          @header_cell = FactoryGirl.create(:cell, :name => 'header', :page => @page)
+          @footer_cell = FactoryGirl.create(:cell, :name => 'footer', :page => @page)
+          @sidebar_cell = FactoryGirl.create(:cell, :name => 'sidebar', :page => @page)
+          @element.belonging_cellnames(@page).should == ['for_other_elements']
+        end
+
+      end
+
+    end
+
   end
 end