alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

data/spec/models/alchemy/element_to_page_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe ElementToPage do
-    # ClassMethods
-
-    describe '.table_name' do
-      it "should return table name" do
-        expect(ElementToPage.table_name).to eq('alchemy_elements_alchemy_pages')
-      end
-    end
-  end
-end

data/spec/models/alchemy/essence_boolean_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe EssenceBoolean do
-    it_behaves_like "an essence" do
-      let(:essence)          { EssenceBoolean.new }
-      let(:ingredient_value) { true }
-    end
-  end
-end

data/spec/models/alchemy/essence_date_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe EssenceDate do
-    let(:essence) { EssenceDate.new }
-
-    it_behaves_like "an essence" do
-      let(:essence)          { EssenceDate.new }
-      let(:ingredient_value) { DateTime.current }
-    end
-
-    describe '#preview_text' do
-      context "if no date set" do
-        it "should return an empty string" do
-          expect(essence.preview_text).to eq("")
-        end
-      end
-
-      context "if date set" do
-        it "should format the date by i18n" do
-          essence.date = DateTime.current
-          expect(::I18n).to receive(:l).with(essence.date, format: :date)
-          essence.preview_text
-        end
-      end
-    end
-  end
-end

data/spec/models/alchemy/essence_file_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe EssenceFile do
-    let(:attachment) { build_stubbed(:alchemy_attachment) }
-    let(:essence)    { EssenceFile.new(attachment: attachment) }
-
-    it_behaves_like "an essence" do
-      let(:essence)          { EssenceFile.new }
-      let(:ingredient_value) { attachment }
-    end
-
-    describe '#attachment_url' do
-      subject { essence.attachment_url }
-
-      it "returns the download attachment url." do
-        is_expected.to match(/\/attachment\/#{attachment.id}\/download\/#{attachment.urlname}\.#{attachment.suffix}/)
-      end
-
-      context 'without attachment assigned' do
-        let(:attachment) { nil }
-
-        it { is_expected.to be_nil }
-      end
-    end
-
-    describe '#preview_text' do
-      it "returns the attachment's name as preview text" do
-        expect(essence.preview_text).to eq(attachment.name)
-      end
-
-      context "with no attachment assigned" do
-        it "returns empty string" do
-          essence.attachment = nil
-          expect(essence.preview_text).to eq('')
-        end
-      end
-    end
-  end
-end

data/spec/models/alchemy/essence_html_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe EssenceHtml do
-    let(:essence) { EssenceHtml.new(source: '<p>hello!</p>') }
-
-    it_behaves_like "an essence" do
-      let(:essence)          { EssenceHtml.new }
-      let(:ingredient_value) { '<p>hello!</p>' }
-    end
-
-    describe '#preview_text' do
-      it "should return html escaped source code" do
-        expect(essence.preview_text).to eq('&lt;p&gt;hello!&lt;/p&gt;')
-      end
-    end
-  end
-end

data/spec/models/alchemy/essence_link_spec.rb

@@ -1,10 +0,0 @@
-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/alchemy/essence_picture_spec.rb

@@ -1,255 +0,0 @@
-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_behaves_like "has image transformations" do
-      let(:picture) { build_stubbed(:alchemy_essence_picture) }
-    end
-
-    it "should not store negative values for crop values" do
-      essence = EssencePicture.new(crop_from: '-1x100', crop_size: '-20x30')
-      essence.save!
-      expect(essence.crop_from).to eq("0x100")
-      expect(essence.crop_size).to eq("0x30")
-    end
-
-    it "should not store float values for crop values" do
-      essence = EssencePicture.new(crop_from: '0.05x104.5', crop_size: '99.5x203.4')
-      essence.save!
-      expect(essence.crop_from).to eq("0x105")
-      expect(essence.crop_size).to eq("100x203")
-    end
-
-    it "should convert newlines in caption into <br/>s" do
-      essence = EssencePicture.new(caption: "hello\nkitty")
-      essence.save!
-      expect(essence.caption).to eq("hello<br/>kitty")
-    end
-
-    describe '#picture_url' do
-      subject { essence.picture_url(options) }
-
-      let(:options) { {} }
-      let(:picture) { build_stubbed(:alchemy_picture) }
-      let(:essence) { build_stubbed(:alchemy_essence_picture, picture: picture) }
-
-      it "returns the show picture url." do
-        is_expected.to match(/\/pictures\/#{picture.id}\/show\/#{picture.urlname}\.#{Config.get(:image_output_format)}/)
-      end
-
-      it "includes the secure hash." do
-        is_expected.to match(/\?sh=\S+\z/)
-      end
-
-      context 'with size in the options' do
-        let(:options) { {size: '200x300'} }
-
-        it "includes the size in the url." do
-          is_expected.to match(/200x300/)
-        end
-      end
-
-      context 'with no format in the options' do
-        it "includes the default image output format." do
-          is_expected.to 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
-          is_expected.to match(/png/)
-        end
-      end
-
-      context 'when cropping is allowed' do
-        let(:options) { {crop: true} }
-
-        it 'converts the value `true` of the `crop` option into `crop` as part of the url' do
-          is_expected.to match /crop/
-          is_expected.not_to match /true/
-        end
-
-        context 'and crop sizes are set' do
-          before do
-            expect(essence).to receive(:crop_size).at_least(:once).and_return('200x200')
-            expect(essence).to receive(:crop_from).at_least(:once).and_return('10x10')
-          end
-
-          it "includes the crop sizes in the url." do
-            is_expected.to match(/200x200/)
-            is_expected.to match(/10x10/)
-          end
-
-          context 'but with crop sizes in the options' do
-            before do
-              options.update({crop_from: '30x30', crop_size: '75x75'})
-            end
-
-            it "includes these crop sizes instead." do
-              is_expected.to match(/30x30/)
-              is_expected.to match(/75x75/)
-            end
-          end
-        end
-      end
-
-      context 'when cropping is prohibited' do
-        before do
-          expect(essence).not_to receive(:crop_size)
-          expect(essence).not_to receive(:crop_from)
-        end
-
-        context 'without setting `crop` in the options' do
-          it "does not include `crop` in the url" do
-            is_expected.not_to match(/crop/)
-          end
-        end
-
-        context 'when `crop` is explicitly set to `false`' do
-          let(:options) { {crop: false} }
-
-          it "does not include `crop` in the url" do
-            is_expected.not_to match(/crop/)
-          end
-        end
-
-        context 'even when crop sizes are set' do
-          it "does not include any cropping information in the url" do
-            is_expected.not_to match(/crop/)
-            is_expected.not_to match(/200x200/)
-            is_expected.not_to match(/10x10/)
-          end
-        end
-      end
-
-      context 'with `image_size` in the options' do
-        let(:options) { {image_size: '100x100'} }
-
-        it 'converts the key into `size`' do
-          is_expected.to match /100x100/
-        end
-      end
-
-      context 'with other options' do
-        let(:options) { {foo: 'baz'} }
-
-        it 'it removes them from params' do
-          is_expected.not_to match /foo/
-        end
-      end
-
-      context 'without picture assigned' do
-        let(:picture) { nil }
-
-        it { is_expected.to be_nil }
-      end
-    end
-
-    describe '#cropping_mask' do
-      subject { essence.cropping_mask }
-
-      context 'with crop values given' do
-        let(:essence) { build_stubbed(:alchemy_essence_picture, crop_from: '0x0', crop_size: '100x100') }
-
-        it "returns a hash containing cropping coordinates" do
-          is_expected.to eq({x1: 0, y1: 0, x2: 100, y2: 100})
-        end
-      end
-
-      context 'with no crop values given' do
-        let(:essence) { build_stubbed(:alchemy_essence_picture) }
-
-        it { is_expected.to be_nil }
-      end
-    end
-
-    describe '#preview_text' do
-      let(:picture) { mock_model(Picture, name: 'Cute Cat Kittens') }
-      let(:essence) { EssencePicture.new }
-
-      it "should return the pictures name as preview text" do
-        allow(essence).to receive(:picture).and_return(picture)
-        expect(essence.preview_text).to eq('Cute Cat Kittens')
-      end
-
-      context "with no picture assigned" do
-        it "returns empty string" do
-          expect(essence.preview_text).to eq('')
-        end
-      end
-    end
-
-    describe '#serialized_ingredient' do
-      let(:content) { Content.new }
-      let(:picture) { mock_model(Picture, name: 'Cute Cat Kittens', urlname: 'cute-cat-kittens', security_token: 'kljhgfd') }
-      let(:essence) { EssencePicture.new(content: content, picture: picture) }
-
-      it "returns the url to render the picture" do
-        expect(essence.serialized_ingredient).to eq("/pictures/#{picture.id}/show/#{picture.urlname}.jpg?sh=#{picture.security_token}")
-      end
-
-      context 'with image settings given at content' do
-        before do
-          expect(content).to receive(:settings).and_return({size: '150x150', format: 'png', select_values: [1, 2, 3]})
-        end
-
-        it "returns the url with cropping and resizing options" do
-          expect(essence.serialized_ingredient).to eq("/pictures/#{picture.id}/show/150x150/#{picture.urlname}.png?sh=#{picture.security_token}")
-        end
-
-        it "rejects options that are not cropping and resizing options" do
-          expect(essence.serialized_ingredient).to_not match("select_values")
-        end
-      end
-    end
-
-    describe "#allow_image_cropping?" do
-      let(:essence_picture) { stub_model(Alchemy::EssencePicture) }
-      let(:content) { stub_model(Alchemy::Content) }
-      let(:picture) { stub_model(Alchemy::Picture) }
-
-      subject { essence_picture.allow_image_cropping? }
-
-      it { is_expected.to be_falsy }
-
-      context "with content existing?" do
-        before do
-          allow(essence_picture).to receive(:content) { content }
-        end
-
-        it { is_expected.to be_falsy }
-
-        context "with picture assigned" do
-          before do
-            allow(essence_picture).to receive(:picture) { picture }
-          end
-
-          it { is_expected.to be_falsy }
-
-          context "and with image larger than crop size" do
-            before do
-              allow(picture).to receive(:can_be_cropped_to) { true }
-            end
-
-            it { is_expected.to be_falsy }
-
-            context "with crop set to true" do
-              before do
-                allow(content).to receive(:settings_value) { true }
-              end
-
-              it { is_expected.to be(true) }
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/models/alchemy/essence_richtext_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe EssenceRichtext do
-    let(:essence) do
-      EssenceRichtext.new(body: '<h1>Hello!</h1><p>Welcome to Peters Petshop.</p>')
-    end
-
-    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.save
-      expect(essence.stripped_body).to eq("Hello!Welcome to Peters Petshop.")
-    end
-
-    it 'has tinymce enabled' do
-      expect(essence.has_tinymce?).to eq(true)
-    end
-  end
-end

data/spec/models/alchemy/essence_select_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe EssenceSelect do
-    it_behaves_like "an essence" do
-      let(:essence)          { EssenceSelect.new }
-      let(:ingredient_value) { 'select value' }
-    end
-  end
-end

data/spec/models/alchemy/essence_text_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe EssenceText do
-    let(:essence) { EssenceText.new }
-    let(:ingredient_value) { 'Lorem ipsum' }
-
-    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 return a preview text" do
-        expect(essence.preview_text).to eq(ingredient_value.to_s)
-      end
-
-      context "with given maxlength" do
-        it "should return as much beginning characters as defined with maxlength" do
-          expect(essence.preview_text(2)).to eq(ingredient_value.to_s[0..1])
-        end
-      end
-
-      context "with another preview_text_column defined" do
-        before do
-          allow(essence).to receive(:title).and_return('Title column')
-          allow(essence).to receive(:preview_text_column).and_return(:title)
-        end
-
-        it "should use this column as preview text method" do
-          expect(essence.preview_text).to eq('Title column')
-        end
-      end
-    end
-
-    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
-
-    describe 'validations' do
-      describe 'format' do
-        context 'given a regex string' do
-          before do
-            allow(essence).to receive(:definition).and_return({'validate' => [{'format' => /\Ahttps:\/\/[\S]+/}]})
-          end
-
-          context 'when ingredient string does not match the given regex' do
-            before { essence.update(essence.ingredient_column.to_sym => 'http://alchemy-cms.com') }
-
-            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 'given a key from the config`s format_matcher list' do
-          before do
-            allow(essence).to receive(:definition).and_return({'validate' => [{'format' => 'email'}]})
-          end
-
-          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