alchemy_cms 2.6.3 → 2.7.0

data/spec/libraries/tinymce_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+module Alchemy
+  describe Tinymce do
+
+    describe '.init' do
+      subject { Tinymce.init }
+
+      it "returns the default config" do
+        should eq(Tinymce.class_variable_get('@@init'))
+      end
+    end
+
+    describe '.init=' do
+      let(:another_config) { {theme_advanced_buttons3: 'table'} }
+
+      it "merges the default config with given config" do
+        Tinymce.init = another_config
+        Tinymce.init.should include(another_config)
+      end
+    end
+
+    context 'Methods for contents with custom tinymce config.' do
+      let(:content_definition) { {'name' => 'text', 'settings' => {'tinymce' => {'foo' => 'bar'}}} }
+      let(:element_definition) { {'name' => 'article', 'contents' => [content_definition]} }
+
+      describe '.custom_config_contents' do
+        subject { Tinymce.custom_config_contents }
+
+        before do
+          Element.stub(:definitions).and_return([element_definition])
+          # Preventing memoization
+          Tinymce.class_variable_set('@@custom_config_contents', nil)
+        end
+
+        it "returns an array of content definitions that contain custom tinymce config and element name" do
+          should be_an(Array)
+          should include({'element' => element_definition['name']}.merge(content_definition))
+        end
+
+        context 'with no contents having custom tinymce config' do
+          let(:content_definition) { {'name' => 'text'} }
+          it { should eq([]) }
+        end
+      end
+
+      describe '.page_custom_config_contents' do
+        let(:page) { FactoryGirl.build_stubbed(:page) }
+        subject { Tinymce.page_custom_config_contents(page) }
+
+        before { page.stub(:element_definitions).and_return([element_definition]) }
+
+        it "returns an array of content definitions that contain custom tinymce config for page" do
+          should be_an(Array)
+          should include({'element' => element_definition['name']}.merge(content_definition))
+        end
+      end
+    end
+
+  end
+end

data/spec/mailers/messages_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module Alchemy
+  describe Messages do
+
+    let(:message) { Message.new(email: 'jon@doe.com', message: 'Lorem ipsum') }
+    let(:mail) { Messages.contact_form_mail(message, 'admin@page.com', 'contact@page.com', 'Subject') }
+
+    it "delivers a mail to owner" do
+      mail.to.should == ['admin@page.com']
+      mail.subject.should == 'Subject'
+    end
+
+    it "reply_to should be set to senders email" do
+      mail.reply_to.should == [message.email]
+    end
+
+    it "mail body includes message" do
+      mail.body.should match /#{message.message}/
+    end
+
+  end
+end

data/spec/models/attachment_spec.rb

@@ -73,6 +73,11 @@ module Alchemy
         its(:icon_css_class) { should == "audio" }
       end
 
+      context 'video file' do
+        subject { stub_model(Attachment, :file_mime_type => 'video/mpeg') }
+        its(:icon_css_class) { should == "video" }
+      end
+
       context 'png file' do
         subject { stub_model(Attachment, :file_mime_type => 'image/png') }
         its(:icon_css_class) { should == "image" }
@@ -87,6 +92,46 @@ module Alchemy
         subject { stub_model(Attachment, :file_mime_type => 'application/zip') }
         its(:icon_css_class) { should == "archive" }
       end
+
+      context 'flash file' do
+        subject { stub_model(Attachment, :file_mime_type => 'application/x-shockwave-flash') }
+        its(:icon_css_class) { should == "flash" }
+      end
+
+      context 'photoshop file' do
+        subject { stub_model(Attachment, :file_mime_type => 'image/x-psd') }
+        its(:icon_css_class) { should == "psd" }
+      end
+
+      context 'text file' do
+        subject { stub_model(Attachment, :file_mime_type => 'text/plain') }
+        its(:icon_css_class) { should == "text" }
+      end
+
+      context 'rtf file' do
+        subject { stub_model(Attachment, :file_mime_type => 'application/rtf') }
+        its(:icon_css_class) { should == "rtf" }
+      end
+
+      context 'pdf file' do
+        subject { stub_model(Attachment, :file_mime_type => 'application/pdf') }
+        its(:icon_css_class) { should == "pdf" }
+      end
+
+      context 'word file' do
+        subject { stub_model(Attachment, :file_mime_type => 'application/msword') }
+        its(:icon_css_class) { should == "word" }
+      end
+
+      context 'excel file' do
+        subject { stub_model(Attachment, :file_mime_type => 'application/vnd.ms-excel') }
+        its(:icon_css_class) { should == "excel" }
+      end
+
+      context 'unknown file' do
+        subject { stub_model(Attachment, :file_mime_type => '') }
+        its(:icon_css_class) { should == "file" }
+      end
     end
 
   end

data/spec/models/cell_spec.rb

@@ -2,43 +2,96 @@ require 'spec_helper'
 
 module Alchemy
   describe Cell do
-
     let(:cell) { FactoryGirl.build(:cell) }
 
-    describe "#available_elements" do
+    # class methods
+
+    describe '.definitions' do
+      it "should return an Array" do
+        expect(Cell.definitions).to be_a(Array)
+      end
+    end
+
+    describe '.definition_for' do
+      subject { Cell.definition_for('right_column') }
+
+      it "returns a definition for given name" do
+        eq({'name' => 'right_column', 'elements' => %w(search)})
+      end
+    end
+
+    describe '.all_definitions_for' do
+      subject { Cell.all_definitions_for(%(right_column)) }
+
+      it "returns definitions for given names" do
+        eq([{'name' => 'right_column', 'elements' => %w(search)}])
+      end
+    end
+
+    describe ".definitions_for_element" do
+      before do
+        Cell.stub!(:definitions).and_return([
+          {'name' => 'cell_1', 'elements' => ['target', 'other']},
+          {'name' => 'cell_2', 'elements' => ['other', 'other']},
+          {'name' => 'cell_3', 'elements' => ['other', 'target']}
+        ])
+      end
+
+      it "should return all cell definitions that includes the given element name" do
+        expect(Cell.definitions_for_element('target')).to eq([
+          {'name' => 'cell_1', 'elements' => ['target', 'other']},
+          {'name' => 'cell_3', 'elements' => ['other', 'target']}
+        ])
+      end
+    end
+
+    describe '.translated_label_for' do
+      subject { Cell.translated_label_for('right_column') }
+
+      it "returns a translated label" do
+        eq('Right column')
+      end
+    end
+
+    # instance methods
 
+    describe "#available_elements" do
       context "without assigned elements" do
         it "should return an empty Array" do
-          cell.stub!(:description).and_return({})
+          cell.stub!(:definition).and_return({})
           cell.available_elements.should == []
         end
       end
 
       context "with assigned elements" do
         it "should return an Array of element names" do
-          cell.stub!(:description).and_return({'elements' => ['test_element', 'test_element_2']})
+          cell.stub!(:definition).and_return({'elements' => ['test_element', 'test_element_2']})
           cell.available_elements.should == ['test_element', 'test_element_2']
         end
       end
-
     end
 
-    describe "#description" do
-
+    describe "#definition" do
       context "without a definition for the expected cellname" do
         it "should return an empty Hash" do
           Cell.stub!(:definition_for).and_return({})
-          cell.description.should == {}
+          cell.definition.should == {}
         end
       end
 
       context "with a definition for the expected cellname found" do
         it "should return its definition Hash" do
           Cell.stub!(:definition_for).and_return({'name' => 'test_cell', 'elements' => ['test_element', 'test_element_2']})
-          cell.description.should == {'name' => 'test_cell', 'elements' => ['test_element', 'test_element_2']}
+          cell.definition.should == {'name' => 'test_cell', 'elements' => ['test_element', 'test_element_2']}
         end
       end
+    end
 
+    describe "#name_for_label" do
+      it "should call translated_label_for" do
+        Cell.should_receive(:translated_label_for).with(cell.name)
+        cell.name_for_label
+      end
     end
 
   end

data/spec/models/content_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
+require 'ostruct'
 
 module Alchemy
   describe Content do
-
-    let(:element) { FactoryGirl.create(:element, :name => 'headline', :create_contents_after_create => true) }
+    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
@@ -12,47 +12,34 @@ module Alchemy
     end
 
     describe '.normalize_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
-
       end
 
       context "passing not namespaced essence type" do
-
         it "should add alchemy namespace" do
           Content.normalize_essence_type('EssenceText').should == "Alchemy::EssenceText"
         end
-
       end
-
     end
 
     describe '#normalized_essence_type' 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
-
       end
 
       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
-
       end
-
     end
 
     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
@@ -72,11 +59,9 @@ module Alchemy
         @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
@@ -96,42 +81,117 @@ module Alchemy
         copy = Content.copy(@content, {:element_id => @element.id + 1})
         copy.essence.body == @content.essence.body
       end
+    end
 
+    describe '.build' do
+      let(:element) { FactoryGirl.build_stubbed(:element) }
+
+      it "builds a new instance from elements.yml description" do
+        Content.build(element, {name: 'headline'}).should be_instance_of(Content)
+      end
     end
 
-    describe '.create' do
-      let (:element) { FactoryGirl.create(:element, :name => 'headline') }
+    describe '.content_description' do
+      let(:element) { FactoryGirl.build_stubbed(:element) }
 
-      context "with default value present" do
-        before do
-          element.stub(:content_description_for).and_return({'name' => 'headline', 'type' => 'EssenceText', 'default' => 'Welcome'})
+      context "with blank name key" do
+        it "returns a essence hash build from essence type" do
+          Content.should_receive(:content_description_from_essence_type).with(element, 'EssenceText')
+          Content.content_description(element, essence_type: 'EssenceText')
+        end
+      end
+
+      context "with name key present" do
+        it "returns a essence hash from element" do
+          Content.should_receive(:content_description_from_element).with(element, 'headline')
+          Content.content_description(element, name: 'headline')
+        end
+      end
+    end
+
+    describe '.content_description_from_element' do
+      let(:element) { FactoryGirl.build_stubbed(:element) }
+      let(:essence) { {name: 'headline', type: 'EssenceText'} }
+
+      it "returns the description hash from element" do
+        element.should_receive(:content_description_for).and_return(essence)
+        Content.content_description(element, name: 'headline').should == essence
+      end
+
+      context "with content description not found" do
+        before {
+          element.should_receive(:content_description_for).and_return(nil)
+          element.should_receive(:available_content_description_for).and_return(essence)
+        }
+
+        it "returns the description hash from available contents" do
+          Content.content_description(element, name: 'headline').should == essence
         end
+      end
+    end
+
+    describe '.content_description_from_essence_type' do
+      let(:element) { FactoryGirl.build_stubbed(:element) }
+
+      it "returns the description hash from element" do
+        Content.should_receive(:content_name_from_element_and_essence_type).with(element, 'EssenceText').and_return('Foo')
+        Content.content_description_from_essence_type(element, 'EssenceText').should == {
+          'type' => 'EssenceText',
+          'name' => 'Foo'
+        }
+      end
+    end
+
+    describe '.content_name_from_element_and_essence_type' do
+      let(:element) { FactoryGirl.build_stubbed(:element) }
+
+      it "returns a name from essence type and count of essences in element" do
+        Content.content_name_from_element_and_essence_type(element, 'EssenceText').should == "essence_text_1"
+      end
+    end
+
+    describe '.create_from_scratch' do
+      let(:element) { FactoryGirl.create(:element, name: 'article') }
+
+      it "builds the content" do
+        expect(Content.create_from_scratch(element, name: 'headline')).to be_instance_of(Alchemy::Content)
+      end
 
+      it "creates the essence from name" do
+        expect(Content.create_from_scratch(element, name: 'headline').essence).to_not be_nil
+      end
+
+      it "creates the essence from essence_type" do
+        expect(Content.create_from_scratch(element, essence_type: 'EssenceText').essence).to_not be_nil
+      end
+
+      context "with default value present" do
         it "should have the ingredient column filled with default value." do
-          Content.create_from_scratch(element, :name => 'headline').ingredient.should == "Welcome"
+          Content.stub(:content_description_from_element).and_return({'name' => 'headline', 'type' => 'EssenceText', 'default' => 'Welcome'})
+          content = Content.create_from_scratch(element, name: 'headline')
+          content.ingredient.should == "Welcome"
         end
       end
     end
 
     describe '#ingredient=' do
       it "should set the given value to the ingredient column of essence" do
-        c = Content.create_from_scratch(element, :name => 'headline')
+        c = Content.create_from_scratch(element, name: 'headline')
         c.ingredient = "Welcome"
         c.ingredient.should == "Welcome"
       end
 
       context "no essence associated" do
-        let (:element) { FactoryGirl.create(:element, :name => 'headline') }
+        let (:element) { FactoryGirl.create(:element, name: 'headline') }
 
         it "should raise error" do
-          c = Content.create(:element_id => element.id, :name => 'headline')
+          c = Content.create(:element_id => element.id, name: 'headline')
           expect { c.ingredient = "Welcome" }.to raise_error
         end
       end
     end
 
     describe "#descriptions" do
-
       context "without any descriptions in elements.yml file" do
         before { Element.stub(:descriptions).and_return([]) }
 
@@ -139,7 +199,29 @@ module Alchemy
           Content.descriptions.should == []
         end
       end
+    end
+
+    describe '#preview_text' do
+      let(:essence) { mock_model(EssenceText, preview_text: 'Lorem') }
+      let(:content) { c = Content.new; c.essence = essence; c }
+
+      it "should return the essences preview_text" do
+        essence.should_receive(:preview_text).with(30)
+        content.preview_text
+      end
+    end
 
+    describe '#tinymce_class_name' do
+      let(:element) { FactoryGirl.build_stubbed(:element, name: 'article') }
+      let(:content) { c = Content.new(name: 'text'); c.element = element; c }
+      subject { content.tinymce_class_name }
+
+      it { eq('default_tinymce') }
+
+      context 'having custom tinymce config' do
+        before { content.stub(:has_custom_tinymce_config?).and_return(true) }
+        it('returns name including element name') { eq('custom_tinymce article_text') }
+      end
     end
 
   end