alchemy_cms 2.9.1 → 3.0.0.rc5

data/spec/models/essence_link_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+module Alchemy
+  describe EssenceLink do
+    it_behaves_like "an essence" do
+      let(:essence)          { EssenceLink.new }
+      let(:ingredient_value) { 'http://alchemy-cms.com' }
+    end
+  end
+end

data/spec/models/essence_picture_spec.rb

@@ -2,6 +2,10 @@ require 'spec_helper'
 
 module Alchemy
   describe EssencePicture do
+    it_behaves_like "an essence" do
+      let(:essence)          { EssencePicture.new }
+      let(:ingredient_value) { Picture.new }
+    end
 
     it "should not store negative values for crop values" do
       essence = EssencePicture.new(:crop_from => '-1x100', :crop_size => '-20x30')
@@ -23,6 +27,111 @@ module Alchemy
       essence.caption.should == "hello<br/>kitty"
     end
 
+    describe '#picture_url' do
+      subject { essence.picture_url(options) }
+
+      let(:options) { {} }
+      let(:picture) { build_stubbed(:picture) }
+      let(:essence) { build_stubbed(:essence_picture, picture: picture) }
+
+      it "returns the show picture url." do
+        should match(/\/pictures\/#{picture.id}\/show\/#{picture.urlname}\.#{Config.get(:image_output_format)}/)
+      end
+
+      it "includes the secure hash." do
+        should match(/\?sh=\S+\z/)
+      end
+
+      context 'with size in the options' do
+        let(:options) { {size: '200x300'} }
+
+        it "includes the size in the url." do
+          should match(/200x300/)
+        end
+      end
+
+      context 'with no format in the options' do
+        it "includes the default image output format." do
+          should match(/#{Config.get(:image_output_format)}/)
+        end
+      end
+
+      context 'with format in the options' do
+        let(:options) { {format: 'png'} }
+
+        it "takes this as format." do
+          should match(/png/)
+        end
+      end
+
+      context 'with crop sizes set' do
+        before { essence.stub(crop_size: '200x200', crop_from: '10x10') }
+
+        it "includes the crop sizes in the url." do
+          should match(/200x200/)
+          should match(/10x10/)
+        end
+
+        context 'but with crop sizes in the options' do
+          let(:options) { {crop_from: '30x30', crop_size: '75x75'} }
+
+          it "includes these crop sizes instead." do
+            should match(/30x30/)
+            should match(/75x75/)
+          end
+        end
+      end
+
+      context 'with crop true in the options' do
+        let(:options) { {crop: true} }
+
+        it 'converts the value into `crop`' do
+          should match /crop/
+          should_not match /true/
+        end
+      end
+
+      context 'with `image_size` in the options' do
+        let(:options) { {image_size: '100x100'} }
+
+        it 'converts the key into `size`' do
+          should match /100x100/
+        end
+      end
+
+      context 'with other options' do
+        let(:options) { {foo: 'baz'} }
+
+        it 'it removes them from params' do
+          should_not match /foo/
+        end
+      end
+
+      context 'without picture assigned' do
+        let(:picture) { nil }
+
+        it { should be_nil }
+      end
+    end
+
+    describe '#cropping_mask' do
+      subject { essence.cropping_mask }
+
+      context 'with crop values given' do
+        let(:essence) { build_stubbed(:essence_picture, crop_from: '0x0', crop_size: '100x100') }
+
+        it "returns a hash containing cropping coordinates" do
+          should == {x1: 0, y1: 0, x2: 100, y2: 100}
+        end
+      end
+
+      context 'with no crop values given' do
+        let(:essence) { build_stubbed(:essence_picture) }
+
+        it { should be_nil }
+      end
+    end
+
     describe '#preview_text' do
       let(:picture) { mock_model(Picture, name: 'Cute Cat Kittens')}
       let(:essence) { EssencePicture.new }

data/spec/models/essence_richtext_spec.rb

@@ -2,46 +2,17 @@ require 'spec_helper'
 
 module Alchemy
   describe EssenceRichtext do
+    let(:essence) { EssenceRichtext.new(:body => '<h1>Hello!</h1><p>Welcome to Peters Petshop.</p>') }
+
+    it_behaves_like "an essence" do
+      let(:essence)          { EssenceRichtext.new }
+      let(:ingredient_value) { '<h1>Hello!</h1><p>Welcome to Peters Petshop.</p>' }
+    end
 
     it "should save a HTML tag free version of body column" do
-      essence = EssenceRichtext.new(:body => '<h1>Hello!</h1><p>Welcome to Peters Petshop.</p>')
       essence.save
       essence.stripped_body.should == "Hello!Welcome to Peters Petshop."
     end
 
-    describe '.after_save' do
-      let(:essence) { EssenceRichtext.create }
-
-      it "should update the value for `do_not_index`" do
-        essence.stub!(:description).and_return({'do_not_index' => true})
-        essence.update_attributes(:body => 'hello')
-        essence.do_not_index.should be_true
-      end
-
-      context "with `do_not_index` set to nil" do
-        it "should update the value to false" do
-          essence.stub!(:description).and_return({'do_not_index' => nil})
-          essence.update_attributes(:body => 'hello')
-          essence.do_not_index.should_not be_nil
-        end
-      end
-    end
-
-    context "with `do_not_index` set to true" do
-      it "should disable ferret indexing" do
-        EssenceRichtext.any_instance.stub(:description).and_return({'do_not_index' => true})
-        essence = EssenceRichtext.create
-        essence.ferret_enabled?.should be_false
-      end
-    end
-
-    context "with `do_not_index` set to false" do
-      it "should enable ferret indexing" do
-        EssenceRichtext.any_instance.stub(:description).and_return({'do_not_index' => false})
-        essence = EssenceRichtext.create
-        essence.ferret_enabled?.should be_true
-      end
-    end
-
   end
 end

data/spec/models/essence_select_spec.rb

@@ -2,14 +2,9 @@ require 'spec_helper'
 
 module Alchemy
   describe EssenceSelect do
-
-    it "should act as essence" do
-      expect { EssenceSelect.new.acts_as_essence? }.to_not raise_error(NoMethodError)
-    end
-
-    it "should have correct partial path" do
-      EssenceSelect.new.to_partial_path.should == 'alchemy/essences/essence_select_view'
+    it_behaves_like "an essence" do
+      let(:essence)          { EssenceSelect.new }
+      let(:ingredient_value) { 'select value' }
     end
-
   end
 end

data/spec/models/essence_text_spec.rb

@@ -2,68 +2,112 @@ require 'spec_helper'
 
 module Alchemy
   describe EssenceText do
+    let(:essence) { EssenceText.new }
+    let(:ingredient_value) { 'Lorem ipsum' }
 
-    describe '.after_save' do
-      let(:essence) { EssenceText.create }
+    it_behaves_like "an essence" do
+      let(:essence)          { EssenceText.new }
+      let(:ingredient_value) { 'Lorem ipsum' }
+    end
+
+    describe '#preview_text' do
+      before do
+        ingredient_column = essence.ingredient_column
+        essence.send("#{ingredient_column}=", ingredient_value)
+      end
 
-      it "should update the value for `do_not_index`" do
-        essence.stub!(:description).and_return({'do_not_index' => true})
-        essence.update_attributes(:body => 'hello')
-        essence.do_not_index.should be_true
+      it "should return a preview text" do
+        essence.preview_text.should == "#{ingredient_value}"
       end
 
-      context "with `do_not_index` set to nil" do
-        it "should update the value to false" do
-          essence.stub!(:description).and_return({'do_not_index' => nil})
-          essence.update_attributes(:body => 'hello')
-          essence.do_not_index.should_not be_nil
+      context "with given maxlength" do
+        it "should return as much beginning characters as defined with maxlength" do
+          essence.preview_text(2).should == "#{ingredient_value}"[0..1]
         end
       end
-    end
 
-    context "with `do_not_index` set to true" do
-      it "should disable ferret indexing" do
-        EssenceText.any_instance.stub(:description).and_return({'do_not_index' => true})
-        essence = EssenceText.create!
-        essence.ferret_enabled?.should be_false
+      context "with another preview_text_column defined" do
+        before do
+          essence.stub(:title).and_return('Title column')
+          essence.stub(:preview_text_column).and_return(:title)
+        end
+
+        it "should use this column as preview text method" do
+          essence.preview_text.should == 'Title column'
+        end
       end
     end
 
-    context "with `do_not_index` set to false" do
-      it "should enable ferret indexing" do
-        EssenceText.any_instance.stub(:description).and_return({'do_not_index' => false})
-        essence = EssenceText.create
-        essence.ferret_enabled?.should be_true
+    describe '#open_link_in_new_window?' do
+      let(:essence) { EssenceText.new }
+      subject { essence.open_link_in_new_window? }
+
+      context 'essence responds to link_taget' do
+        context 'if link_target attribute is set to "blank"' do
+
+          before { essence.link_target = 'blank' }
+
+          it "should return true" do
+            expect(subject).to eq(true)
+          end
+        end
+
+        context 'if link_target attribute is not "blank"' do
+          it "should return false" do
+            expect(subject).to eq(false)
+          end
+        end
       end
     end
 
-    context "acts_as_essence methods" do
+    describe 'validations' do
+      describe 'format' do
 
-      describe '#preview_text' do
-        let(:essence) { EssenceText.new(body: 'Lorem ipsum') }
+        context 'given a regex string' do
+          before do
+            essence.stub(:description).and_return({'validate' => [{'format' => /\Ahttps:\/\/[\S]+/}]})
+          end
 
-        it "should return a preview text" do
-          essence.preview_text.should == 'Lorem ipsum'
-        end
+          context 'when ingredient string does not match the given regex' do
+            before { essence.update(essence.ingredient_column.to_sym => 'http://alchemy-cms.com') }
 
-        context "with maxlength of 2" do
-          it "should return very short preview text" do
-            essence.preview_text(2).should == 'Lo'
+            it 'should not be valid' do
+              expect(essence).to_not be_valid
+            end
+          end
+
+          context 'when ingredient string matches the given regex' do
+            before { essence.update(essence.ingredient_column.to_sym => 'https://alchemy-cms.com') }
+
+            it 'should be valid' do
+              expect(essence).to be_valid
+            end
           end
         end
 
-        context "with another preview_text_column defined" do
-          before {
-            essence.stub(:title).and_return('Title column')
-            essence.stub(:preview_text_column).and_return(:title)
-          }
+        context 'given a key from the config`s format_matcher list' do
+          before do
+            essence.stub(:description).and_return({'validate' => [{'format' => 'email'}]})
+          end
 
-          it "should use this column as preview text method" do
-            essence.preview_text.should == 'Title column'
+          context 'when ingredient string does not match the given format matcher' do
+            before { essence.update(essence.ingredient_column.to_sym => ingredient_value) }
+
+            it 'should not be valid' do
+              expect(essence).to_not be_valid
+            end
+          end
+
+          context 'when ingredient string matches the given format matcher' do
+            before { essence.update(essence.ingredient_column.to_sym => 'email@email.com') }
+
+            it 'should be valid' do
+              expect(essence).to be_valid
+            end
           end
         end
-      end
 
+      end
     end
 
   end

data/spec/models/language_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 
 module Alchemy
   describe Language do
-
-    let(:language) { FactoryGirl.create(:klingonian) }
-    let(:page) { FactoryGirl.create(:page, :language => language) }
+    let(:default_language) { Alchemy::Language.default }
+    let(:language)         { FactoryGirl.create(:klingonian) }
+    let(:page)             { FactoryGirl.create(:page, language: language) }
 
     it "should return a label for code" do
       language.label(:code).should == 'kl'
@@ -16,111 +16,78 @@ module Alchemy
     end
 
     context "with language_code and empty country_code" do
-
       it "#code should return language locale only" do
         language.country_code = ''
         language.code.should == 'kl'
       end
 
       context "adding a value for country code" do
-
         it "#code should return a joined locale" do
           language.country_code = 'cr'
           language.code.should == 'kl-cr'
         end
 
         it "should update all associated Pages with self.code as value for Page#language_code" do
-          page = FactoryGirl.create(:page, :language => language)
+          page = FactoryGirl.create(:page, language: language)
           language.country_code = 'cr'
           language.save
           page.reload; page.language_code.should == 'kl-cr'
         end
       end
-
     end
 
     context "with country_code and_language_code" do
-
       context "removing the country_code" do
-
         it "should update all associated Pages´s language_code with Language#code" do
-          language = FactoryGirl.create(:language, :country_code => 'kl')
-
+          language = FactoryGirl.create(:language, country_code: 'kl')
           language.country_code = ''
           language.save
           page.reload; page.language_code.should == "kl"
         end
-
       end
-
     end
 
     it "should not be deletable if it is the default language" do
-      @default_language = Alchemy::Language.find_by_default(true)
-      if !@default_language
-        @default_language = FactoryGirl.create(:language, :name => "default", :code => "aa", :frontpage_name => "intro", :default => true)
-      end
-      expect { @default_language.destroy }.to raise_error
+      expect { default_language.destroy }.to raise_error
     end
 
     describe "before save" do
-
       describe "#remove_old_default if default attribute has changed to true" do
-
-        it "should unset the default status of the old default-language" do
-          @default_language = Alchemy::Language.get_default
-          language.update_attributes(:default => true)
-          @default_language.reload
-          @default_language.default.should be(false)
+        it "should unset the default status of the old default language" do
+          default_language
+          language.update_attributes(default: true)
+          default_language.reload
+          default_language.default.should be_false
         end
-
       end
-
     end
 
     context "after_update" do
-
       describe "#set_pages_language if language´s code has changed" do
-
         it "should update all its pages with the new code" do
-          @other_page = FactoryGirl.create(:page, :language => language)
-          language.update_attributes(:code => "fo")
+          @other_page = FactoryGirl.create(:page, language: language)
+          language.update_attributes(code: "fo")
           language.reload; page.reload; @other_page.reload
           [page.language_code, @other_page.language_code].should == [language.code, language.code]
         end
-
       end
 
       describe "#unpublish_pages" do
-
         it "should set all pages to unpublic if it gets set to unpublic" do
-          page = FactoryGirl.create(:page, :language => language)
-          @other_page = FactoryGirl.create(:page, :language => language)
-          language.update_attributes(:public => false)
+          page = FactoryGirl.create(:page, language: language)
+          @other_page = FactoryGirl.create(:page, language: language)
+          language.update_attributes(public: false)
           language.reload; page.reload; @other_page.reload
           [page.public?, @other_page.public?].should == [false, false]
         end
-
       end
-
     end
 
     describe '.find_by_code' do
-
       context "with only the language code given" do
-
         it "should find the language" do
           Language.find_by_code(language.code).should == language
         end
-
-      end
-
-    end
-
-    describe '.all_codes_for_published' do
-      it "should return all codes of published languages" do
-        Language.stub!(:published).and_return([mock_model('Language', code: 'de'), mock_model('Language', code: 'en')])
-        expect(Language.all_codes_for_published).to eq(['de', 'en'])
       end
     end
 
@@ -131,7 +98,7 @@ module Alchemy
         context 'if language is not published' do
           it "should add an error to the object" do
             expect(language.valid?).to eq(false)
-            expect(language.errors.messages).to have_key(:base)
+            expect(language.errors.messages).to have_key(:public)
           end
         end
       end
@@ -139,17 +106,16 @@ module Alchemy
       describe 'presence_of_default_language' do
         context 'if no default language would exist anymore' do
           before do
-            Language.stub!(:get_default).and_return(language)
-            language.stub!(:default_changed?).and_return(true)
+            Language.stub(:default).and_return(language)
+            language.stub(:default_changed?).and_return(true)
           end
 
           it "should add an error to the object" do
             expect(language.valid?).to eq(false)
-            expect(language.errors.messages).to have_key(:base)
+            expect(language.errors.messages).to have_key(:default)
           end
         end
       end
     end
-
   end
 end