alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/models/picture_spec.rb

@@ -4,6 +4,10 @@ require 'spec_helper'
 module Alchemy
   describe Picture do
 
+    it_behaves_like "has image transformations" do
+      let(:picture) { FactoryGirl.build_stubbed(:picture) }
+    end
+
     let :image_file do
       File.new(File.expand_path('../../fixtures/image.png', __FILE__))
     end
@@ -12,24 +16,24 @@ module Alchemy
 
     it "is valid with valid attributes" do
       picture = Picture.new(image_file: image_file)
-      picture.should be_valid
+      expect(picture).to be_valid
     end
 
     it "is not valid without image file" do
       picture = Picture.new
-      picture.should_not be_valid
+      expect(picture).not_to be_valid
     end
 
     it "is valid with capitalized image file extension" do
       image_file = File.new(File.expand_path('../../fixtures/image2.PNG', __FILE__))
       picture = Picture.new(image_file: image_file)
-      picture.should be_valid
+      expect(picture).to be_valid
     end
 
     it "is valid with jpeg image file extension" do
       image_file = File.new(File.expand_path('../../fixtures/image3.jpeg', __FILE__))
       picture = Picture.new(image_file: image_file)
-      picture.should be_valid
+      expect(picture).to be_valid
     end
 
     context 'with enabled preprocess_image_resize config option' do
@@ -38,7 +42,7 @@ module Alchemy
       end
 
       before do
-        Config.stub(:get) do |arg|
+        allow(Config).to receive(:get) do |arg|
           if arg == :preprocess_image_resize
             '10x10'
           end
@@ -54,15 +58,15 @@ module Alchemy
     describe '#suffix' do
       it "should return the suffix of original filename" do
         pic = stub_model(Picture, image_file_name: 'kitten.JPG')
-        pic.stub(:image_file).and_return(OpenStruct.new({ext: 'jpg'}))
-        pic.suffix.should == "jpg"
+        allow(pic).to receive(:image_file).and_return(OpenStruct.new({ext: 'jpg'}))
+        expect(pic.suffix).to eq("jpg")
       end
 
       context "image has no suffix" do
         it "should return empty string" do
           pic = stub_model(Picture, image_file_name: 'kitten')
-          pic.stub(:image_file).and_return(OpenStruct.new({ext: ''}))
-          pic.suffix.should == ""
+          allow(pic).to receive(:image_file).and_return(OpenStruct.new({ext: ''}))
+          expect(pic.suffix).to eq("")
         end
       end
     end
@@ -70,22 +74,22 @@ module Alchemy
     describe '#humanized_name' do
       it "should return a humanized version of original filename" do
         pic = stub_model(Picture, image_file_name: 'cute_kitten.JPG')
-        pic.stub(:image_file).and_return(OpenStruct.new({ext: 'jpg'}))
-        pic.humanized_name.should == "cute kitten"
+        allow(pic).to receive(:image_file).and_return(OpenStruct.new({ext: 'jpg'}))
+        expect(pic.humanized_name).to eq("cute kitten")
       end
 
       it "should not remove incidents of suffix from filename" do
         pic = stub_model(Picture, image_file_name: 'cute_kitten_mo.jpgi.JPG')
-        pic.stub(:image_file).and_return(OpenStruct.new({ext: 'jpg'}))
-        pic.humanized_name.should == "cute kitten mo.jpgi"
-        pic.humanized_name.should_not == "cute kitten moi"
+        allow(pic).to receive(:image_file).and_return(OpenStruct.new({ext: 'jpg'}))
+        expect(pic.humanized_name).to eq("cute kitten mo.jpgi")
+        expect(pic.humanized_name).not_to eq("cute kitten moi")
       end
 
       context "image has no suffix" do
         it "should return humanized name" do
           pic = stub_model(Picture, image_file_name: 'cute_kitten')
-          pic.stub(:suffix).and_return("")
-          pic.humanized_name.should == "cute kitten"
+          allow(pic).to receive(:suffix).and_return("")
+          expect(pic.humanized_name).to eq("cute kitten")
         end
       end
     end
@@ -94,7 +98,7 @@ module Alchemy
       before { @pic = stub_model(Picture, id: 1) }
 
       it "should return a sha1 hash" do
-        @pic.security_token.should match(/\b([a-f0-9]{16})\b/)
+        expect(@pic.security_token).to match(/\b([a-f0-9]{16})\b/)
       end
 
       it "should return a 16 chars long hash" do
@@ -103,22 +107,22 @@ module Alchemy
 
       it "should convert crop true value into string" do
         digest = PictureAttributes.secure({id: @pic.id, crop: 'crop'})
-        @pic.security_token(crop: true).should == digest
+        expect(@pic.security_token(crop: true)).to eq(digest)
       end
 
       it "should always include picture id" do
         digest = PictureAttributes.secure({id: @pic.id})
-        @pic.security_token.should == digest
+        expect(@pic.security_token).to eq(digest)
       end
 
       it "should remove all not suitable options" do
         digest = PictureAttributes.secure({id: @pic.id})
-        @pic.security_token({foo: 'baz'}).should == digest
+        expect(@pic.security_token({foo: 'baz'})).to eq(digest)
       end
 
       it "should remove all option values that have nil values" do
         digest = PictureAttributes.secure({id: @pic.id})
-        @pic.security_token({crop: nil}).should == digest
+        expect(@pic.security_token({crop: nil})).to eq(digest)
       end
     end
 
@@ -127,29 +131,29 @@ module Alchemy
 
       context "with 'recent' as argument" do
         it 'should call the .recent scope' do
-          Picture.should_receive(:recent).and_return(picture)
-          Picture.filtered_by('recent').should eq(picture)
+          expect(Picture).to receive(:recent).and_return(picture)
+          expect(Picture.filtered_by('recent')).to eq(picture)
         end
       end
 
       context "with 'last_upload' as argument" do
         it 'should call the .last_upload scope' do
-          Picture.should_receive(:last_upload).and_return(picture)
-          Picture.filtered_by('last_upload').should eq(picture)
+          expect(Picture).to receive(:last_upload).and_return(picture)
+          expect(Picture.filtered_by('last_upload')).to eq(picture)
         end
       end
 
       context "with 'without_tag' as argument" do
         it 'should call the .without_tag scope' do
-          Picture.should_receive(:without_tag).and_return(picture)
-          Picture.filtered_by('without_tag').should eq(picture)
+          expect(Picture).to receive(:without_tag).and_return(picture)
+          expect(Picture.filtered_by('without_tag')).to eq(picture)
         end
       end
 
       context "with no argument" do
         it 'should return the scoped collection' do
-          Picture.should_receive(:all).and_return(picture)
-          Picture.filtered_by('').should eq(picture)
+          expect(Picture).to receive(:all).and_return(picture)
+          expect(Picture.filtered_by('')).to eq(picture)
         end
       end
     end
@@ -160,9 +164,9 @@ module Alchemy
         same_upload = Picture.create!(image_file: image_file, upload_hash: '123')
         most_recent = Picture.create!(image_file: image_file, upload_hash: '123')
 
-        Picture.last_upload.should include(most_recent)
-        Picture.last_upload.should include(same_upload)
-        Picture.last_upload.should_not include(other_upload)
+        expect(Picture.last_upload).to include(most_recent)
+        expect(Picture.last_upload).to include(same_upload)
+        expect(Picture.last_upload).not_to include(other_upload)
 
         [other_upload, same_upload, most_recent].each { |p| p.destroy }
       end
@@ -178,11 +182,11 @@ module Alchemy
       end
 
       it "should return all pictures that have been created in the last 24 hours" do
-        Picture.recent.should include(@recent)
+        expect(Picture.recent).to include(@recent)
       end
 
       it "should not return old pictures" do
-        Picture.recent.should_not include(@old_picture)
+        expect(Picture.recent).not_to include(@old_picture)
       end
     end
 
@@ -201,56 +205,6 @@ module Alchemy
       end
     end
 
-    describe '#default_mask' do
-      before do
-        picture.stub(:image_file_width).and_return(200)
-        picture.stub(:image_file_height).and_return(100)
-      end
-
-      it "should return a Hash" do
-        expect(picture.default_mask('10x10')).to be_a(Hash)
-      end
-
-      context "cropping the picture to 200x50 pixel" do
-        it "should contain the correct coordination values in the hash" do
-          expect(picture.default_mask('200x50')).to eq({x1: 0, y1: 25, x2: 200, y2: 75})
-        end
-      end
-
-      context "if picture´s cropping size is 0x0 pixel" do
-        it "should not crop the picture" do
-          expect(picture.default_mask('0x0')).to eq({x1: 0, y1: 0, x2: 200, y2: 100})
-        end
-      end
-
-      context "cropping the picture to 50x100 pixel" do
-        it "should contain the correct coordination values in the hash" do
-          expect(picture.default_mask('50x100')).to eq({x1: 75, y1: 0, x2: 125, y2: 100})
-        end
-      end
-    end
-
-    describe "#cropped_thumbnail_size" do
-      context "if given size is blank or 111x93" do
-        it "should return the default size of '111x93'" do
-          expect(picture.cropped_thumbnail_size('')).to eq('111x93')
-          expect(picture.cropped_thumbnail_size('111x93')).to eq('111x93')
-        end
-      end
-
-      context "if the given width is 400 and the height is 300 because of picture cropping" do
-        it "should return the correct recalculated size value" do
-          expect(picture.cropped_thumbnail_size('400x300')).to eq('111x83')
-        end
-      end
-
-      context "if the given width is 300 and the height is 400 because of picture cropping" do
-        it "should return the correct recalculated size value" do
-          expect(picture.cropped_thumbnail_size('300x400')).to eq('70x93')
-        end
-      end
-    end
-
     describe "#image_file_dimensions" do
       it "should return the width and height in the format of '1024x768'" do
         picture.image_file = image_file
@@ -261,23 +215,23 @@ module Alchemy
     describe '#update_name_and_tag_list!' do
       let(:picture) { Picture.new(image_file: image_file) }
 
-      before { picture.stub(save!: true) }
+      before { allow(picture).to receive(:save!).and_return(true) }
 
       it "updates tag_list" do
-        picture.should_receive(:tag_list=).with('Foo')
+        expect(picture).to receive(:tag_list=).with('Foo')
         picture.update_name_and_tag_list!({pictures_tag_list: 'Foo'})
       end
 
       context 'name is present' do
         it "updates name" do
-          picture.should_receive(:name=).with('Foo')
+          expect(picture).to receive(:name=).with('Foo')
           picture.update_name_and_tag_list!({pictures_name: 'Foo'})
         end
       end
 
       context 'name is not present' do
         it "does not update name" do
-          picture.should_not_receive(:name=).with('Foo')
+          expect(picture).not_to receive(:name=).with('Foo')
           picture.update_name_and_tag_list!({pictures_name: ''})
         end
       end
@@ -289,14 +243,14 @@ module Alchemy
       let(:picture) { build_stubbed(:picture, name: 'Cute kittens.jpg') }
 
       it "returns a uri escaped name" do
-        should eq('Cute+kittens')
+        is_expected.to eq('Cute+kittens')
       end
 
       context 'with blank name' do
         let(:picture) { build_stubbed(:picture, name: '') }
 
         it "returns generic name" do
-          should eq("image_#{picture.id}")
+          is_expected.to eq("image_#{picture.id}")
         end
       end
     end
@@ -307,107 +261,60 @@ module Alchemy
       let(:picture) { build_stubbed(:picture, image_file_name: 'cute-kittens.jpg', image_file_size: 1024) }
 
       it "returns a hash containing data for jquery fileuploader" do
-        should be_an_instance_of(Hash)
-        should include(name: picture.image_file_name)
-        should include(size: picture.image_file_size)
+        is_expected.to be_an_instance_of(Hash)
+        is_expected.to include(name: picture.image_file_name)
+        is_expected.to include(size: picture.image_file_size)
       end
 
       context 'with error' do
         let(:picture) { build_stubbed(:picture) }
 
         before do
-          picture.stub(errors: {image_file: %w(stupid_cats)})
+          expect(picture).to receive(:errors).and_return({image_file: %w(stupid_cats)})
         end
 
         it "returns hash with error message" do
-          should be_an_instance_of(Hash)
-          should include(error: 'stupid_cats')
+          is_expected.to be_an_instance_of(Hash)
+          is_expected.to include(error: 'stupid_cats')
         end
       end
     end
 
-    describe '#landscape_format?' do
-      subject { picture.landscape_format? }
-
-      let(:picture) { build_stubbed(:picture) }
-
-      context 'image has landscape format' do
-        before { picture.stub_chain(:image_file, :landscape?).and_return(true) }
-        it { should be_true }
-      end
-
-      context 'image has portrait format' do
-        before { picture.stub_chain(:image_file, :landscape?).and_return(false) }
-        it { should be_false }
-      end
-
-      it "is aliased as landscape?" do
-        picture.respond_to?(:landscape?).should be_true
-      end
-    end
-
-    describe '#portrait_format?' do
-      subject { picture.portrait_format? }
-
-      let(:picture) { build_stubbed(:picture) }
-
-      context 'image has portrait format' do
-        before { picture.stub_chain(:image_file, :portrait?).and_return(true) }
-        it { should be_true }
-      end
-
-      context 'image has landscape format' do
-        before { picture.stub_chain(:image_file, :portrait?).and_return(false) }
-        it { should be_false }
-      end
-
-      it "is aliased as portrait?" do
-        picture.respond_to?(:portrait?).should be_true
-      end
-    end
-
-    describe '#square_format?' do
-      subject { picture.square_format? }
-
-      let(:picture) { build_stubbed(:picture) }
-
-      context 'image has square format' do
-        before { picture.stub_chain(:image_file, :aspect_ratio).and_return(1.0) }
-        it { should be_true }
-      end
-
-      context 'image has rectangle format' do
-        before { picture.stub_chain(:image_file, :aspect_ratio).and_return(1.8) }
-        it { should be_false }
-      end
-
-      it "is aliased as square?" do
-        picture.respond_to?(:square?).should be_true
-      end
-    end
-
     describe '#restricted?' do
       subject { picture.restricted? }
 
       let(:picture) { build_stubbed(:picture) }
 
       context 'is assigned on pages' do
-        before { picture.stub_chain(:pages, :any?).and_return(true) }
-
         context 'that are all restricted' do
-          before { picture.stub_chain(:pages, :not_restricted, :blank?).and_return(true) }
-          it { should be_true }
+          before do
+            expect(picture).to receive(:pages).at_least(:once).and_return double(
+              not_restricted: double(blank?: true),
+              any?: true
+            )
+          end
+
+          it { is_expected.to be_truthy }
         end
 
         context 'that are not all restricted' do
-          before { picture.stub_chain(:pages, :not_restricted, :blank?).and_return(false) }
-          it { should be_false }
+          before do
+            expect(picture).to receive(:pages).at_least(:once).and_return double(
+              not_restricted: double(blank?: false),
+              any?: true
+            )
+          end
+
+          it { is_expected.to be_falsey }
         end
       end
 
       context 'is not assigned on any page' do
-        before { picture.stub_chain(:pages, :any?).and_return(false) }
-        it { should be_false }
+        before do
+          expect(picture).to receive(:pages).and_return double(any?: false)
+        end
+
+        it { is_expected.to be_falsey }
       end
     end
 
@@ -415,10 +322,9 @@ module Alchemy
       subject { Picture.find_paginated({query: 'kitten'}, 5) }
 
       it "finds pages by name" do
-        Picture.should_receive(:named).with('kitten').and_return(Picture.none)
+        expect(Picture).to receive(:named).with('kitten').and_return(Picture.none)
         subject
       end
     end
-
   end
 end

data/spec/models/site_spec.rb

@@ -9,15 +9,15 @@ module Alchemy
       subject { FactoryGirl.build(:site) }
 
       it 'should start out with no languages' do
-        subject.languages.should be_empty
+        expect(subject.languages).to be_empty
       end
 
       context 'when being saved' do
         context 'when it has no languages yet' do
           it 'should automatically create a default language' do
             subject.save!
-            subject.languages.length.should == 1 # using count returns 0, although the resulting array has a length of 1 / O.o
-            subject.languages.first.should be_default
+            expect(subject.languages.length).to eq(1) # using count returns 0, although the resulting array has a length of 1 / O.o
+            expect(subject.languages.first).to be_default
           end
         end
 
@@ -26,7 +26,7 @@ module Alchemy
           before { subject.languages << language }
 
           it 'should not create any additional languages' do
-            subject.languages.should == [language]
+            expect(subject.languages).to eq([language])
 
             expect { subject.save! }.
               to_not change(subject, "languages")
@@ -46,32 +46,32 @@ module Alchemy
 
       context "when the request doesn't match anything" do
         let(:host) { 'oogabooga.com' }
-        it { should == default_site }
+        it { is_expected.to eq(default_site) }
       end
 
       context "when the request matches a site's host field" do
         let(:host) { 'www.magiclabs.de' }
-        it { should == magiclabs_site }
+        it { is_expected.to eq(magiclabs_site) }
       end
 
       context "when the request matches one of the site's aliases" do
         let(:host) { 'magiclabs.com' }
-        it { should == magiclabs_site }
+        it { is_expected.to eq(magiclabs_site) }
       end
 
       context "when the request matches the site's first alias" do
         let(:host) { 'magiclabs.de' }
-        it { should == magiclabs_site }
+        it { is_expected.to eq(magiclabs_site) }
       end
 
       context "when the request matches the site's last alias" do
         let(:host) { 'www.magiclabs.com' }
-        it { should == magiclabs_site }
+        it { is_expected.to eq(magiclabs_site) }
       end
 
       context "when the request host matches only part of a site's aliases" do
         let(:host) { 'labs.com' }
-        it { should == default_site }
+        it { is_expected.to eq(default_site) }
       end
     end
 
@@ -79,19 +79,19 @@ module Alchemy
       context 'when set to a site' do
         before { Site.current = site }
         specify "Language should be scoped to that site" do
-          Language.all.to_sql.should match(/alchemy_languages.+site_id.+#{site.id}/)
+          expect(Language.all.to_sql).to match(/alchemy_languages.+site_id.+#{site.id}/)
         end
       end
 
       context 'when set to nil' do
         before { Site.current = nil }
         specify "Language should not be scoped to a site" do
-          Language.all.to_sql.should_not match(/alchemy_languages.+site_id.+#{site.id}/)
+          expect(Language.all.to_sql).not_to match(/alchemy_languages.+site_id.+#{site.id}/)
         end
 
         it "should return default site" do
-          Site.current.should_not be_nil
-          Site.current.should == Site.default
+          expect(Site.current).not_to be_nil
+          expect(Site.current).to eq(Site.default)
         end
       end
     end
@@ -104,17 +104,17 @@ module Alchemy
 
       context "with file present" do
         let(:definitions) { [{'name' => 'lala'}] }
-        before { YAML.should_receive(:load_file).and_return(definitions) }
-        it { should == definitions }
+        before { expect(YAML).to receive(:load_file).and_return(definitions) }
+        it { is_expected.to eq(definitions) }
       end
 
       context "with empty file" do
-        before { YAML.should_receive(:load_file).and_return(false) }
-        it { should == [] }
+        before { expect(YAML).to receive(:load_file).and_return(false) }
+        it { is_expected.to eq([]) }
       end
 
       context "with no file present" do
-        it { should == [] }
+        it { is_expected.to eq([]) }
       end
     end
 
@@ -126,17 +126,17 @@ module Alchemy
 
       context "with file present" do
         let(:definitions) { [{'name' => 'lala'}] }
-        before { YAML.should_receive(:load_file).and_return(definitions) }
-        it { should == definitions }
+        before { expect(YAML).to receive(:load_file).and_return(definitions) }
+        it { is_expected.to eq(definitions) }
       end
 
       context "with empty file" do
-        before { YAML.should_receive(:load_file).and_return(false) }
-        it { should == [] }
+        before { expect(YAML).to receive(:load_file).and_return(false) }
+        it { is_expected.to eq([]) }
       end
 
       context "with no file present" do
-        it { should == [] }
+        it { is_expected.to eq([]) }
       end
     end
 
@@ -148,17 +148,17 @@ module Alchemy
 
       context "with file present" do
         let(:definitions) { [{'name' => 'lala'}] }
-        before { YAML.should_receive(:load_file).and_return(definitions) }
-        it { should == definitions }
+        before { expect(YAML).to receive(:load_file).and_return(definitions) }
+        it { is_expected.to eq(definitions) }
       end
 
       context "with empty file" do
-        before { YAML.should_receive(:load_file).and_return(false) }
-        it { should == [] }
+        before { expect(YAML).to receive(:load_file).and_return(false) }
+        it { is_expected.to eq([]) }
       end
 
       context "with no file present" do
-        it { should == [] }
+        it { is_expected.to eq([]) }
       end
     end
 
@@ -170,17 +170,17 @@ module Alchemy
 
       context "with file present" do
         let(:definitions) { [{'name' => 'lala'}] }
-        before { YAML.should_receive(:load_file).and_return(definitions) }
-        it { should == definitions }
+        before { expect(YAML).to receive(:load_file).and_return(definitions) }
+        it { is_expected.to eq(definitions) }
       end
 
       context "with empty file" do
-        before { YAML.should_receive(:load_file).and_return(false) }
-        it { should == [] }
+        before { expect(YAML).to receive(:load_file).and_return(false) }
+        it { is_expected.to eq([]) }
       end
 
       context "with no file present" do
-        it { should == [] }
+        it { is_expected.to eq([]) }
       end
     end
 
@@ -189,17 +189,17 @@ module Alchemy
 
       context 'when Site.current is set to the same site' do
         before { Site.current = site }
-        it { should be_true }
+        it { is_expected.to be_truthy }
       end
 
       context 'when Site.current is set to nil' do
         before { Site.current = nil }
-        it { should be_false }
+        it { is_expected.to be_falsey }
       end
 
       context 'when Site.current is set to a different site' do
         before { Site.current = another_site }
-        it { should be_false }
+        it { is_expected.to be_falsey }
       end
     end
 
@@ -207,7 +207,7 @@ module Alchemy
       let(:site) {Site.new(name: 'My custom site')}
 
       it "returns the path to partial" do
-        site.to_partial_path.should == "alchemy/site_layouts/my_custom_site"
+        expect(site.to_partial_path).to eq("alchemy/site_layouts/my_custom_site")
       end
     end
 
@@ -215,7 +215,7 @@ module Alchemy
       let(:site) {Site.new(name: 'My custom site')}
 
       it "returns the name for layout partial" do
-        site.layout_partial_name.should == "my_custom_site"
+        expect(site.layout_partial_name).to eq("my_custom_site")
       end
     end
 
@@ -224,8 +224,8 @@ module Alchemy
       let(:definitions) { [{'name' => 'my_custom_site', 'page_layouts' => %w(standard)}] }
 
       it "returns layout definition from site_layouts.yml file" do
-        Site.stub(:layout_definitions).and_return(definitions)
-        site.layout_definition.should == definitions.first
+        allow(Site).to receive(:layout_definitions).and_return(definitions)
+        expect(site.layout_definition).to eq(definitions.first)
       end
     end