alchemy_cms 3.2.1 → 3.3.0.rc1

data/spec/libraries/resources_helper_spec.rb

@@ -25,7 +25,6 @@ class ResourcesControllerForEngine
   end
 end
 
-
 describe Alchemy::ResourcesHelper do
   let(:controller) { ResourcesController.new }
   let(:resource_item) { double('resource-item') }
@@ -54,7 +53,7 @@ describe Alchemy::ResourcesHelper do
 
     describe "#resource_scope" do
       it "returns an array containing a proxy and namespaces for url_for-based helper-methods" do
-        expect(controller.resource_scope).to eq(%W[main_app_proxy admin])
+        expect(controller.resource_scope).to eq(%w[main_app_proxy admin])
       end
     end
 
@@ -114,24 +113,58 @@ describe Alchemy::ResourcesHelper do
   end
 
   describe "#render_attribute" do
+    subject { controller.render_attribute(resource_item, attributes, options) }
+
+    let(:options) { {} }
+    let(:attributes) { {name: 'name'} }
+
     it "should return the value from resource attribute" do
       allow(resource_item).to receive(:name).and_return('my-name')
-      expect(controller.render_attribute(resource_item, {name: 'name'})).to eq('my-name')
+      is_expected.to eq('my-name')
     end
 
     context "resource having a relation" do
       let(:associated_object) { double("location", title: 'Title of related object') }
       let(:associated_klass) { double("klass", find: associated_object) }
-      let(:relation) {
+      let(:relation) do
         {
           attr_method: 'title',
           model_association: OpenStruct.new(klass: associated_klass)
         }
-      }
+      end
+      let(:attributes) do
+        {name: 'name', relation: relation}
+      end
 
       it "should return the value from the related object attribute" do
         allow(resource_item).to receive(:name).and_return('my-name')
-        expect(controller.render_attribute(resource_item, {name: 'name', relation: relation})).to eq('Title of related object')
+        is_expected.to eq('Title of related object')
+      end
+    end
+
+    context 'with long values' do
+      before do
+        allow(resource_item).to receive(:name).and_return('*' * 51)
+      end
+
+      it 'truncates the values' do
+        expect(subject.length).to eq(50)
+      end
+
+      context 'but with options[:truncate] set to 10' do
+        let(:options) { {truncate: 10} }
+
+        it 'does not truncate the values' do
+          expect(subject.length).to eq(10)
+        end
+      end
+
+      context 'but with options[:truncate] set to false' do
+        let(:options) { {truncate: false} }
+
+        it 'does not truncate the values' do
+          expect(subject.length).to eq(51)
+        end
       end
     end
   end
@@ -141,4 +174,20 @@ describe Alchemy::ResourcesHelper do
       expect(controller.resource_name).to eq("my_resource")
     end
   end
+
+  describe '#current_location_params' do
+    let(:params) { {q: "some_query", page: 6, action: "some_action"} }
+
+    before do
+      allow(controller).to receive(:params) { params }
+    end
+
+    it 'returns the current location params' do
+      expect(controller.current_location_params).to eq({q: "some_query", page: 6})
+    end
+
+    it 'only includes the q and page parameters' do
+      expect(controller.current_location_params).not_to have_key(:action)
+    end
+  end
 end

data/spec/libraries/shell_spec.rb

@@ -2,14 +2,12 @@ require 'spec_helper'
 require 'alchemy/shell'
 
 module Alchemy
-
   # Class fixture
   class MyToDoList
     extend Shell
   end
 
   describe Shell do
-
     before { allow(MyToDoList).to receive(:puts) }
 
     describe '.todo' do
@@ -98,7 +96,6 @@ module Alchemy
     end
 
     describe '.color' do
-
       context 'if given name is a constant of Thor::Shell::Color' do
         before do
           allow(Thor::Shell::Color).to receive(:const_defined?).and_return(true)
@@ -120,6 +117,5 @@ module Alchemy
         end
       end
     end
-
   end
 end

data/spec/libraries/template_tracker_spec.rb

@@ -46,8 +46,8 @@ module Alchemy
           let(:name) { 'alchemy/elements/_text_view' }
           let(:elements) { [{'name' => 'text', 'contents' => [{'type' => 'EssenceText'}]}] }
 
-          context 'that is having a description' do
-            before { allow(Element).to receive(:descriptions).and_return(elements) }
+          context 'that is having a definition' do
+            before { allow(Element).to receive(:definitions).and_return(elements) }
 
             it "returns all essence layout view partial names for that element" do
               is_expected.to include('alchemy/essences/_essence_text_view')
@@ -60,18 +60,10 @@ module Alchemy
                 is_expected.to include('alchemy/essences/_essence_picture_view')
               end
             end
-
-            context 'and element has available_contents defined' do
-              let(:elements) { [{'name' => 'text', 'available_contents' => ['type' => 'EssenceFile']}] }
-
-              it "has these essences as template dependency" do
-                is_expected.to include('alchemy/essences/_essence_file_view')
-              end
-            end
           end
 
-          context 'that has no description' do
-            before { allow(Element).to receive(:descriptions).and_return([]) }
+          context 'that has no definition' do
+            before { allow(Element).to receive(:definitions).and_return([]) }
 
             it "returns empty array" do
               is_expected.to be_empty
@@ -88,7 +80,6 @@ module Alchemy
           end
         end
       end
-
     end
   end
 end

data/spec/libraries/tinymce_spec.rb

@@ -2,7 +2,6 @@ require 'spec_helper'
 
 module Alchemy
   describe Tinymce do
-
     describe '.init' do
       subject { Tinymce.init }
 
@@ -21,8 +20,23 @@ module Alchemy
     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]} }
+      let(:content_definition) do
+        {
+          'name' => 'text',
+          'settings' => {
+            'tinymce' => {
+              'foo' => 'bar'
+            }
+          }
+        }
+      end
+
+      let(:element_definition) do
+        {
+          'name' => 'article',
+          'contents' => [content_definition]
+        }
+      end
 
       describe '.custom_config_contents' do
         subject { Tinymce.custom_config_contents }
@@ -33,18 +47,47 @@ module Alchemy
           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
+        it "returns an array of content definitions that contain custom tinymce config
+        and element name" do
           is_expected.to be_an(Array)
-          is_expected.to include({'element' => element_definition['name']}.merge(content_definition))
+          is_expected.to include({
+            'element' => element_definition['name']
+          }.merge(content_definition))
         end
 
         context 'with no contents having custom tinymce config' do
-          let(:content_definition) { {'name' => 'text'} }
+          let(:content_definition) do
+            {'name' => 'text'}
+          end
+
           it { is_expected.to eq([]) }
         end
 
         context 'with element definition having nil as contents value' do
-          let(:element_definition) { {'name' => 'element', 'contents' => nil} }
+          let(:element_definition) do
+            {
+              'name' => 'element',
+              'contents' => nil
+            }
+          end
+
+          it "returns empty array" do
+            is_expected.to eq([])
+          end
+        end
+
+        context 'with content settings tinymce set to true only' do
+          let(:element_definition) do
+            {
+              'name' => 'element',
+              'contents' => [
+                'name' => 'headline',
+                'settings' => {
+                  'tinymce' => true
+                }
+              ]
+            }
+          end
 
           it "returns empty array" do
             is_expected.to eq([])
@@ -57,11 +100,12 @@ module Alchemy
 
           it "only returns custom tinymce config for elements of that page" do
             expect(page).to receive(:element_definitions).and_return([element_definition])
-            is_expected.to include({'element' => element_definition['name']}.merge(content_definition))
+            is_expected.to include(
+              {'element' => element_definition['name']
+            }.merge(content_definition))
           end
         end
       end
     end
-
   end
 end

data/spec/mailers/{messages_spec.rb → alchemy/messages_spec.rb}

@@ -2,7 +2,6 @@ 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') }
 
@@ -18,6 +17,5 @@ module Alchemy
     it "mail body includes message" do
       expect(mail.body).to match /#{message.message}/
     end
-
   end
 end

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 module Alchemy
   describe Attachment do
-    let(:file)       { File.new(File.expand_path('../../fixtures/image with spaces.png', __FILE__)) }
+    let(:file)       { File.new(File.expand_path('../../../fixtures/image with spaces.png', __FILE__)) }
     let(:attachment) { Attachment.new(file: file) }
 
     describe 'after assign' do
@@ -20,39 +20,38 @@ module Alchemy
         expect(attachment.name).to eq("image with spaces")
       end
 
-      it "should have a valid file_name" do
-        expect(attachment.file_name).to eq("image-with-spaces.png")
-      end
-
       after { attachment.destroy }
     end
 
     describe 'urlname sanitizing' do
-      it "should sanitize url characters in the filename" do
+      it "escapes unsafe url characters" do
         attachment.file_name = 'f#%&cking cute kitten pic.png'
-        attachment.save!
-        expect(attachment.urlname).to eq('f-cking-cute-kitten-pic.png')
+        expect(attachment.urlname).to eq('f%23%25%26cking+cute+kitten+pic')
+      end
+
+      it "removes format suffix from end of file name" do
+        attachment.file_name = 'pic.png.png'
+        expect(attachment.urlname).to eq('pic+png')
       end
 
-      it "should sanitize lot of dots in the name" do
+      it "converts dots into escaped spaces" do
         attachment.file_name = 'cute.kitten.pic.png'
-        attachment.save!
-        expect(attachment.urlname).to eq('cute-kitten-pic.png')
+        expect(attachment.urlname).to eq('cute+kitten+pic')
       end
 
-      it "should sanitize umlauts in the name" do
+      it "escapes umlauts in the name" do
         attachment.file_name = 'süßes katzenbild.png'
-        attachment.save!
-        expect(attachment.urlname).to eq('suesses-katzenbild.png')
+        expect(attachment.urlname).to eq('s%C3%BC%C3%9Fes+katzenbild')
       end
-
-      after { attachment.destroy }
     end
 
     describe 'validations' do
-
       context "having a png, but only pdf allowed" do
-        before { allow(Config).to receive(:get).and_return({'allowed_filetypes' => {'attachments' => ['pdf']}}) }
+        before do
+          allow(Config).to receive(:get) do
+            {'allowed_filetypes' => {'alchemy/attachments' => ['pdf']}}
+          end
+        end
 
         it "should not be valid" do
           expect(attachment).not_to be_valid
@@ -60,13 +59,38 @@ module Alchemy
       end
 
       context "having a png and everything allowed" do
-        before { allow(Config).to receive(:get).and_return({'allowed_filetypes' => {'attachments' => ['*']}}) }
+        before do
+          allow(Config).to receive(:get) do
+            {'allowed_filetypes' => {'alchemy/attachments' => ['*']}}
+          end
+        end
 
         it "should be valid" do
           expect(attachment).to be_valid
         end
       end
 
+      context "having a filename with special characters" do
+        before do
+           attachment.file_name = 'my FileNämü.pdf'
+           attachment.save
+        end
+
+        it "should be valid" do
+          expect(attachment).to be_valid
+        end
+      end
+
+      context "having a filename with unallowed character" do
+        before do
+          attachment.file_name = 'my FileNämü?!.pdf'
+          attachment.save
+        end
+
+        it "should not be valid" do
+          expect(attachment).not_to be_valid
+        end
+      end
     end
 
     context 'PNG image' do
@@ -222,6 +246,5 @@ module Alchemy
         it { is_expected.to be_falsey }
       end
     end
-
   end
 end

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Alchemy
   describe Cell do
-    let(:cell) { FactoryGirl.build(:cell) }
+    let(:cell) { build(:alchemy_cell) }
 
     # class methods
 
@@ -12,7 +12,7 @@ module Alchemy
       end
 
       it "should allow erb generated definitions" do
-        expect(Cell.definitions.collect { |d| d['name']} ).to include('erb_cell')
+        expect(Cell.definitions.collect { |d| d['name'] }).to include('erb_cell')
       end
     end
 
@@ -97,6 +97,5 @@ module Alchemy
         cell.name_for_label
       end
     end
-
   end
 end

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

@@ -2,11 +2,11 @@ require 'spec_helper'
 
 module Alchemy
   describe Content do
-    let(:element) { create(:element, name: 'headline', create_contents_after_create: true) }
+    let(:element) { create(:alchemy_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.essence.update_attributes(body: "Hello")
       expect(content.ingredient).to eq("Hello")
     end
 
@@ -33,13 +33,13 @@ module Alchemy
     describe '#normalized_essence_type' do
       context "without namespace in essence_type column" do
         it "should return the namespaced essence type" do
-          expect(Content.new(:essence_type => 'EssenceText').normalized_essence_type).to eq('Alchemy::EssenceText')
+          expect(Content.new(essence_type: 'EssenceText').normalized_essence_type).to eq('Alchemy::EssenceText')
         end
       end
 
       context "with namespace in essence_type column" do
         it "should return the namespaced essence type" do
-          expect(Content.new(:essence_type => 'Alchemy::EssenceText').normalized_essence_type).to eq('Alchemy::EssenceText')
+          expect(Content.new(essence_type: 'Alchemy::EssenceText').normalized_essence_type).to eq('Alchemy::EssenceText')
         end
       end
     end
@@ -47,7 +47,7 @@ module Alchemy
     describe '#update_essence' do
       subject { content.update_essence(params) }
 
-      let(:element) { create(:element, name: 'text', create_contents_after_create: true) }
+      let(:element) { create(:alchemy_element, name: 'text', create_contents_after_create: true) }
       let(:content) { element.contents.first }
       let(:params)  { {} }
 
@@ -71,7 +71,7 @@ module Alchemy
       end
 
       context 'with validations and without params given' do
-        let(:element) { create(:element, name: 'contactform', create_contents_after_create: true) }
+        let(:element) { create(:alchemy_element, name: 'contactform', create_contents_after_create: true) }
 
         it "should add error messages if save fails and return false" do
           is_expected.to be_falsey
@@ -92,79 +92,58 @@ module Alchemy
 
     describe '.copy' do
       before(:each) do
-        @element = FactoryGirl.create(:element, :name => 'text', :create_contents_after_create => true)
+        @element = create(:alchemy_element, name: 'text', create_contents_after_create: true)
         @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 = Content.copy(@content, {name: 'foobar', element_id: @element.id + 1})
         expect(copy.name).to eq('foobar')
       end
 
       it "should make a new record for essence of source" do
-        copy = Content.copy(@content, {:element_id => @element.id + 1})
+        copy = Content.copy(@content, {element_id: @element.id + 1})
         expect(copy.essence_id).not_to eq(@content.essence_id)
       end
 
       it "should copy source essence attributes" do
-        copy = Content.copy(@content, {:element_id => @element.id + 1})
+        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) }
+      let(:element) { build_stubbed(:alchemy_element) }
 
-      it "builds a new instance from elements.yml description" do
+      it "builds a new instance from elements.yml definition" do
         expect(Content.build(element, {name: 'headline'})).to be_instance_of(Content)
       end
     end
 
-    describe '.content_description' do
-      let(:element) { FactoryGirl.build_stubbed(:element) }
+    describe '.content_definition' do
+      let(:element) { build_stubbed(:alchemy_element) }
 
       context "with blank name key" do
         it "returns a essence hash build from essence type" do
-          expect(Content).to receive(:content_description_from_essence_type).with(element, 'EssenceText')
-          Content.content_description(element, essence_type: 'EssenceText')
+          expect(Content).to receive(:content_definition_from_essence_type).with(element, 'EssenceText')
+          Content.content_definition(element, essence_type: 'EssenceText')
         end
       end
 
       context "with name key present" do
         it "returns a essence hash from element" do
-          expect(Content).to receive(:content_description_from_element).with(element, 'headline')
-          Content.content_description(element, name: 'headline')
+          expect(element).to receive(:content_definition_for).with('headline')
+          Content.content_definition(element, name: 'headline')
         end
       end
     end
 
-    describe '.content_description_from_element' do
-      let(:element) { FactoryGirl.build_stubbed(:element) }
-      let(:essence) { {name: 'headline', type: 'EssenceText'} }
+    describe '.content_definition_from_essence_type' do
+      let(:element) { build_stubbed(:alchemy_element) }
 
-      it "returns the description hash from element" do
-        expect(element).to receive(:content_description_for).and_return(essence)
-        expect(Content.content_description(element, name: 'headline')).to eq(essence)
-      end
-
-      context "with content description not found" do
-        before {
-          expect(element).to receive(:content_description_for).and_return(nil)
-          expect(element).to receive(:available_content_description_for).and_return(essence)
-        }
-
-        it "returns the description hash from available contents" do
-          expect(Content.content_description(element, name: 'headline')).to eq(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
+      it "returns the definition hash from element" do
         expect(Content).to receive(:content_name_from_element_and_essence_type).with(element, 'EssenceText').and_return('Foo')
-        expect(Content.content_description_from_essence_type(element, 'EssenceText')).to eq({
+        expect(Content.content_definition_from_essence_type(element, 'EssenceText')).to eq({
           'type' => 'EssenceText',
           'name' => 'Foo'
         })
@@ -172,7 +151,7 @@ module Alchemy
     end
 
     describe '.content_name_from_element_and_essence_type' do
-      let(:element) { FactoryGirl.build_stubbed(:element) }
+      let(:element) { build_stubbed(:alchemy_element) }
 
       it "returns a name from essence type and count of essences in element" do
         expect(Content.content_name_from_element_and_essence_type(element, 'EssenceText')).to eq("essence_text_1")
@@ -180,7 +159,7 @@ module Alchemy
     end
 
     describe '.create_from_scratch' do
-      let(:element) { FactoryGirl.create(:element, name: 'article') }
+      let(:element) { create(:alchemy_element, name: 'article') }
 
       it "builds the content" do
         expect(Content.create_from_scratch(element, name: 'headline')).to be_instance_of(Alchemy::Content)
@@ -196,7 +175,9 @@ module Alchemy
 
       context "with default value present" do
         it "should have the ingredient column filled with default value." do
-          allow(Content).to receive(:content_description_from_element).and_return({'name' => 'headline', 'type' => 'EssenceText', 'default' => 'Welcome'})
+          allow_any_instance_of(Element).to receive(:content_definition_for) do
+            {'name' => 'headline', 'type' => 'EssenceText', 'default' => 'Welcome'}
+          end
           content = Content.create_from_scratch(element, name: 'headline')
           expect(content.ingredient).to eq("Welcome")
         end
@@ -204,7 +185,7 @@ module Alchemy
     end
 
     describe '#ingredient=' do
-      let(:element) { FactoryGirl.create(:element, name: 'headline') }
+      let(:element) { create(:alchemy_element, name: 'headline') }
 
       it "should set the given value to the ingredient column of essence" do
         c = Content.create_from_scratch(element, name: 'headline')
@@ -213,27 +194,27 @@ module Alchemy
       end
 
       context "no essence associated" do
-        let(:element) { FactoryGirl.create(:element, name: 'headline') }
+        let(:element) { create(:alchemy_element, name: 'headline') }
 
         it "should raise error" do
-          c = Content.create(:element_id => element.id, name: 'headline')
-          expect { c.ingredient = "Welcome" }.to raise_error(EssenceMissingError)
+          content = Content.create(element_id: element.id, name: 'headline')
+          expect { content.ingredient = "Welcome" }.to raise_error(EssenceMissingError)
         end
       end
     end
 
-    describe "#descriptions" do
-      context "without any descriptions in elements.yml file" do
-        before { allow(Element).to receive(:descriptions).and_return([]) }
+    describe "#definitions" do
+      context "without any definitions in elements.yml file" do
+        before { allow(Element).to receive(:definitions).and_return([]) }
 
         it "should return an empty array" do
-          expect(Content.descriptions).to eq([])
+          expect(Content.definitions).to eq([])
         end
       end
     end
 
     describe "#dom_id" do
-      let(:content) { build_stubbed(:content) }
+      let(:content) { build_stubbed(:alchemy_content) }
 
       it "returns a dom id string" do
         expect(content.dom_id).to eq("essence_text_#{content.id}")
@@ -249,7 +230,7 @@ module Alchemy
     end
 
     describe "#essence_partial_name" do
-      let(:content) { build_stubbed(:content) }
+      let(:content) { build_stubbed(:alchemy_content) }
 
       it "returns the essence#partial_name" do
         expect(content.essence).to receive(:partial_name)
@@ -266,7 +247,7 @@ module Alchemy
     end
 
     describe '#preview_content?' do
-      let(:content) { build_stubbed(:content) }
+      let(:content) { build_stubbed(:alchemy_content) }
 
       context 'not defined as preview content' do
         it "returns false" do
@@ -276,7 +257,7 @@ module Alchemy
 
       context 'defined as preview content via take_me_for_preview' do
         before do
-          expect(content).to receive(:description).at_least(:once).and_return({
+          expect(content).to receive(:definition).at_least(:once).and_return({
             'take_me_for_preview' => true
           })
         end
@@ -295,7 +276,7 @@ module Alchemy
 
       context 'defined as preview content via as_element_title' do
         before do
-          expect(content).to receive(:description).at_least(:once).and_return({
+          expect(content).to receive(:definition).at_least(:once).and_return({
             'as_element_title' => true
           })
         end
@@ -316,16 +297,68 @@ module Alchemy
       end
     end
 
+    describe '#has_tinymce?' do
+      let(:element) { build_stubbed(:alchemy_element, name: 'article') }
+      let(:content) { build_stubbed(:alchemy_content, name: 'text', element: element) }
+
+      subject { content.has_tinymce? }
+
+      it { is_expected.to eq(false) }
+
+      context 'having custom tinymce config hash' do
+        before do
+          expect(content).to receive(:settings) do
+            {tinymce: {toolbar: []}}
+          end
+        end
+
+        it { is_expected.to eq(true) }
+      end
+
+      context 'having essence that has_tinymce? eq true' do
+        before do
+          expect(content.essence).to receive(:has_tinymce?) { true }
+        end
+
+        it { is_expected.to eq(true) }
+      end
+    end
+
+    describe '#has_custom_tinymce_config?' do
+      let(:element) { build_stubbed(:alchemy_element, name: 'article') }
+      let(:content) { build_stubbed(:alchemy_content, name: 'text', element: element) }
+
+      subject { content.has_custom_tinymce_config? }
+
+      it { is_expected.to eq(false) }
+
+      context 'having custom tinymce config hash' do
+        before do
+          expect(content).to receive(:settings) do
+            {tinymce: {toolbar: []}}
+          end
+        end
+
+        it { is_expected.to eq(true) }
+      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 }
+      let(:element) { build_stubbed(:alchemy_element, name: 'article') }
+      let(:content) { build_stubbed(:alchemy_content, name: 'text', element: element) }
+
       subject { content.tinymce_class_name }
 
-      it { eq('default_tinymce') }
+      it { is_expected.to eq('has_tinymce') }
 
       context 'having custom tinymce config' do
-        before { allow(content).to receive(:has_custom_tinymce_config?).and_return(true) }
-        it('returns name including element name') { eq('custom_tinymce article_text') }
+        before do
+          expect(content).to receive(:has_custom_tinymce_config?).and_return(true)
+        end
+
+        it 'returns name including element name' do
+          is_expected.to eq('has_tinymce article_text')
+        end
       end
     end
 
@@ -362,15 +395,15 @@ module Alchemy
     end
 
     describe '#settings' do
-      let(:element) { build_stubbed(:element, name: 'article') }
-      let(:content) { build_stubbed(:content, name: 'headline', element: element) }
+      let(:element) { build_stubbed(:alchemy_element, name: 'article') }
+      let(:content) { build_stubbed(:alchemy_content, name: 'headline', element: element) }
 
-      it "returns the settings hash from description" do
-        expect(content.settings).to eq({deletable: true})
+      it "returns the settings hash from definition" do
+        expect(content.settings).to eq({linkable: true})
       end
 
       context 'if settings are not defined' do
-        let(:content) { build_stubbed(:content, name: 'intro', element: element) }
+        let(:content) { build_stubbed(:alchemy_content, name: 'intro', element: element) }
 
         it "returns empty hash" do
           expect(content.settings).to eq({})
@@ -378,8 +411,84 @@ module Alchemy
       end
     end
 
+    describe '#settings_value' do
+      let(:key) { :key }
+      let(:settings) { Hash.new }
+
+      subject { content.settings_value(key, options) }
+
+      before do
+        allow(content).to receive(:settings) { settings }
+      end
+
+      context 'with content having settings' do
+        let(:settings) { {key: 'settings_value'} }
+
+        context 'and empty options' do
+          let(:options) { {} }
+
+          it "returns the value for key from content settings" do
+            expect(subject).to eq('settings_value')
+          end
+        end
+
+        context 'and nil options' do
+          let(:options) { nil }
+
+          it "returns the value for key from content settings" do
+            expect(subject).to eq('settings_value')
+          end
+        end
+
+        context 'but same key present in options' do
+          let(:options) { {key: 'options_value'} }
+
+          it "returns the value for key from options" do
+            expect(subject).to eq('options_value')
+          end
+        end
+      end
+
+      context 'with content having no settings' do
+        let(:settings) { {} }
+
+        context 'and empty options' do
+          let(:options) { {} }
+
+          it { expect(subject).to eq(nil) }
+        end
+
+        context 'but key present in options' do
+          let(:options) { {key: 'options_value'} }
+
+          it "returns the value for key from options" do
+            expect(subject).to eq('options_value')
+          end
+        end
+      end
+
+      context 'with content having settings with string as key' do
+        let(:settings) { {'key' => 'value_from_string_key'} }
+        let(:options) { {} }
+
+        it "returns value" do
+          expect(subject).to eq('value_from_string_key')
+        end
+      end
+
+      context 'with key passed as string' do
+        let(:settings) { {key: 'value_from_symbol_key'} }
+        let(:key)     { 'key' }
+        let(:options) { {} }
+
+        it "returns value" do
+          expect(subject).to eq('value_from_symbol_key')
+        end
+      end
+    end
+
     context 'delegations' do
-      let(:page) { create(:restricted_page) }
+      let(:page) { create(:alchemy_page, :restricted) }
 
       it "delegates restricted? to page" do
         element.update!(page: page)