alchemy_cms 3.0.4 → 3.1.0.beta1

data/spec/controllers/pages_controller_spec.rb

@@ -7,16 +7,16 @@ module Alchemy
     let(:default_language_root) { FactoryGirl.create(:language_root_page, language: default_language, name: 'Home', public: true) }
     let(:page) { FactoryGirl.create(:public_page, parent_id: default_language_root.id, page_layout: 'news', name: 'News', urlname: 'news', language: default_language, do_not_autogenerate: false) }
 
-    before { controller.stub(:signup_required?).and_return(false) }
+    before { allow(controller).to receive(:signup_required?).and_return(false) }
 
     context 'an author' do
       let(:unpublic) { create(:page, parent: default_language_root) }
 
-      before { controller.stub(current_alchemy_user: author_user) }
+      before { allow(controller).to receive(:current_alchemy_user).and_return(author_user) }
 
       it "should not be able to visit a unpublic page" do
         get :show, urlname: unpublic.urlname
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
@@ -25,20 +25,29 @@ module Alchemy
 
       it "should render a rss feed" do
         get :show, urlname: page.urlname, format: :rss
-        response.content_type.should == 'application/rss+xml'
+        expect(response.content_type).to eq('application/rss+xml')
       end
 
       it "should include content" do
         page.elements.first.content_by_name('news_headline').essence.update_attributes({body: 'Peters Petshop'})
         get :show, urlname: 'news', format: :rss
-        response.body.should match /Peters Petshop/
+        expect(response.body).to match /Peters Petshop/
       end
     end
 
     context "requested for a page that does not contain a feed" do
       it "should render xml 404 error" do
         get :show, urlname: default_language_root.urlname, format: :rss
-        response.status.should == 404
+        expect(response.status).to eq(404)
+      end
+    end
+
+    context "requested for json format" do
+      it "should render json response but warns about deprecation" do
+        expect(ActiveSupport::Deprecation).to receive(:warn)
+        get :show, urlname: default_language_root.urlname, format: :json
+        expect(response.status).to eq(200)
+        expect(response.content_type).to eq('application/json')
       end
     end
 
@@ -46,8 +55,8 @@ module Alchemy
       context "with ajax request" do
         it "should not render a layout" do
           xhr :get, :show, urlname: page.urlname
-          response.should render_template(:show)
-          response.should_not render_template(layout: 'application')
+          expect(response).to render_template(:show)
+          expect(response).not_to render_template(layout: 'application')
         end
       end
     end
@@ -60,24 +69,24 @@ module Alchemy
       let(:product)  { FactoryGirl.create(:public_page, name: "Screwdriver", urlname: 'screwdriver', parent: products, language: default_language, do_not_autogenerate: false, visible: true) }
 
       before do
-        Alchemy.user_class.stub(:admins).and_return(OpenStruct.new(count: 1))
-        Config.stub(:get) { |arg| arg == :url_nesting ? true : false }
+        allow(Alchemy.user_class).to receive(:admins).and_return(OpenStruct.new(count: 1))
+        allow(Config).to receive(:get) { |arg| arg == :url_nesting ? true : false }
         product.elements.find_by_name('article').contents.essence_texts.first.essence.update_column(:body, 'screwdriver')
       end
 
       context "with correct levelnames in params" do
         it "should show the requested page" do
           get :show, {urlname: 'catalog/products/screwdriver'}
-          response.status.should == 200
-          response.body.should have_content("screwdriver")
+          expect(response.status).to eq(200)
+          expect(response.body).to have_content("screwdriver")
         end
       end
 
       context "with incorrect levelnames in params" do
         it "should render a 404 page" do
           get :show, {urlname: 'catalog/faqs/screwdriver'}
-          response.status.should == 404
-          response.body.should have_content('The page you were looking for doesn\'t exist')
+          expect(response.status).to eq(404)
+          expect(response.body).to have_content('The page you were looking for doesn\'t exist')
         end
       end
     end
@@ -85,8 +94,8 @@ module Alchemy
     context "when a non-existent page is requested" do
       it "should rescue a RoutingError with rendering a 404 page." do
         get :show, {urlname: 'doesntexist'}
-        response.status.should == 404
-        response.body.should have_content('The page you were looking for doesn\'t exist')
+        expect(response.status).to eq(404)
+        expect(response.body).to have_content('The page you were looking for doesn\'t exist')
       end
     end
 
@@ -105,9 +114,9 @@ module Alchemy
           end
 
           it "should redirect to first public child" do
-            controller.should_receive(:redirect_page)
+            expect(controller).to receive(:redirect_page)
             controller.send(:redirect_to_public_child)
-            controller.instance_variable_get('@page').should == public_page
+            expect(controller.instance_variable_get('@page')).to eq(public_page)
           end
         end
 
@@ -137,24 +146,24 @@ module Alchemy
 
         it "should redirect permanently to page that belongs to legacy page url." do
           get :show, urlname: legacy_url.urlname
-          response.status.should == 301
-          response.should redirect_to("/#{page.urlname}")
+          expect(response.status).to eq(301)
+          expect(response).to redirect_to("/#{page.urlname}")
         end
 
         it "should only redirect to legacy url if no page was found for urlname" do
           get :show, urlname: legacy_page.urlname
-          response.status.should == 200
-          response.should_not redirect_to("/#{page.urlname}")
+          expect(response.status).to eq(200)
+          expect(response).not_to redirect_to("/#{page.urlname}")
         end
 
         it "should redirect to last page that has that legacy url" do
           get :show, urlname: legacy_url2.urlname
-          response.should redirect_to("/#{second_page.urlname}")
+          expect(response).to redirect_to("/#{second_page.urlname}")
         end
 
         it "should redirect even if the url has get parameters" do
           get :show, urlname: legacy_url3.urlname
-          response.should redirect_to("/#{second_page.urlname}")
+          expect(response).to redirect_to("/#{second_page.urlname}")
         end
       end
     end
@@ -162,18 +171,18 @@ module Alchemy
     describe "while redirecting" do
       context "not in multi language mode" do
         before do
-          PagesController.any_instance.stub(:multi_language?).and_return(false)
+          allow_any_instance_of(PagesController).to receive(:multi_language?).and_return(false)
         end
 
         context "with no lang parameter present" do
           it "should store defaults language id in the session." do
             get :show, urlname: 'a-public-page'
-            controller.session[:alchemy_language_id].should == Language.default.id
+            expect(controller.session[:alchemy_language_id]).to eq(Language.default.id)
           end
 
           it "should store default language as class var." do
             get :show, urlname: 'a-public-page'
-            Language.current.should == Language.default
+            expect(Language.current).to eq(Language.default)
           end
         end
       end
@@ -183,7 +192,7 @@ module Alchemy
       subject { controller.send(:page_etag) }
 
       before do
-        page.stub(cache_key: 'aaa')
+        expect(page).to receive(:cache_key).and_return('aaa')
         controller.instance_variable_set('@page', page)
       end
 

data/spec/controllers/pictures_controller_spec.rb

@@ -21,21 +21,21 @@ module Alchemy
 
       it "renders the original image without any resizing" do
         get :zoom, id: picture.id, format: :png, sh: picture.security_token
-        response.body[0x10..0x18].unpack('NN').should == [80, 60]
+        expect(response.body[0x10..0x18].unpack('NN')).to eq([80, 60])
       end
     end
 
     context "Requesting a picture with tempared security token" do
       it "should render status 400" do
         get :show, id: picture.id, format: :png, sh: '14m4b4dh4ck3r'
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
     end
 
     context "Requesting a picture with another format then the original image" do
       it "should convert the picture format" do
         get :show, id: picture.id, format: :jpeg, sh: picture.security_token
-        response.content_type.should == 'image/jpeg'
+        expect(response.content_type).to eq('image/jpeg')
       end
     end
 
@@ -55,43 +55,43 @@ module Alchemy
       context 'with size param set to small' do
         it "resizes the image to 80x60 while maintaining aspect ratio" do
           get :thumbnail, id: picture.id, size: 'small', format: :png, sh: picture.security_token(size: 'small')
-          response.body[0x10..0x18].unpack('NN').should == [60, 60]
+          expect(response.body[0x10..0x18].unpack('NN')).to eq([60, 60])
         end
       end
 
       context 'with size param set to medium' do
         it "resizes the image to 160x120 while maintaining aspect ratio" do
           get :thumbnail, id: picture.id, size: 'medium', format: :png, sh: picture.security_token(size: 'medium')
-          response.body[0x10..0x18].unpack('NN').should == [120, 120]
+          expect(response.body[0x10..0x18].unpack('NN')).to eq([120, 120])
         end
       end
 
       context 'with size param set to large' do
         it "resizes the image to 240x180 while maintaining aspect ratio" do
           get :thumbnail, id: picture.id, size: 'large', format: :png, sh: picture.security_token(size: 'large')
-          response.body[0x10..0x18].unpack('NN').should == [180, 180]
+          expect(response.body[0x10..0x18].unpack('NN')).to eq([180, 180])
         end
       end
 
       context 'with size param set to nil' do
         it "resizes the image to 111x93 while maintaining aspect ratio" do
           get :thumbnail, id: picture.id, format: :png, sh: picture.security_token
-          response.body[0x10..0x18].unpack('NN').should == [93, 93]
+          expect(response.body[0x10..0x18].unpack('NN')).to eq([93, 93])
         end
       end
 
       context 'with size param set to another value' do
         it "resizes the image to the given size while maintaining aspect ratio" do
           get :thumbnail, id: picture.id, size: '33x33', format: :png, sh: picture.security_token(size: '33x33')
-          response.body[0x10..0x18].unpack('NN').should == [33, 33]
+          expect(response.body[0x10..0x18].unpack('NN')).to eq([33, 33])
         end
       end
     end
 
     context "Requesting a picture that has no image file attached" do
       before do
-        picture.stub(image_file: nil)
-        Picture.stub(find: picture)
+        expect(picture).to receive(:image_file).and_return(nil)
+        expect(Picture).to receive(:find).and_return(picture)
       end
 
       it "raises missing file error" do
@@ -105,15 +105,82 @@ module Alchemy
       let(:picture) { Picture.create(image_file: fixture_file_upload(File.expand_path('../../fixtures/500x500.png', __FILE__), 'image/png')) }
 
       it "renders the cropped picture" do
-        get :show, id: picture.id, crop: 'crop', size: '123x44', crop_size: '123x44', crop_from: '0x0', format: :png, sh: picture.security_token(crop_size: '123x44', crop_from: '0x0', crop: true, size: '123x44')
-        response.body[0x10..0x18].unpack('NN').should == [123, 44]
+        get :show, id: picture.id, crop: 'crop', size: '123x44', crop_size: '123x44',
+          crop_from: '0x0', format: :png,
+          sh: picture.security_token(crop_size: '123x44', crop_from: '0x0', crop: true, size: '123x44')
+        expect(response.body[0x10..0x18].unpack('NN')).to eq([123, 44])
+      end
+    end
+
+    context "Requesting a picture with crop_from and crop_size parameters with different size param" do
+      let(:picture) { Picture.create(image_file: fixture_file_upload(File.expand_path('../../fixtures/500x500.png', __FILE__), 'image/png')) }
+
+      it "renders the cropped picture" do
+        get :show,
+          id: picture.id,
+          crop: 'crop',
+          size: '100x100',
+          crop_size: '200x200',
+          crop_from: '0x0',
+          format: :png,
+          sh: picture.security_token(
+            crop_size: '200x200',
+            crop_from: '0x0',
+            crop: true,
+            size: '100x100'
+          )
+       expect(response.body[0x10..0x18].unpack('NN')).to eq [100, 100]
+      end
+    end
+
+    context "Requesting a picture with crop_from and crop_size parameters with larger size param" do
+      let(:picture) { Picture.create(image_file: fixture_file_upload(File.expand_path('../../fixtures/500x500.png', __FILE__), 'image/png')) }
+
+      it "renders the cropped picture without upsampling" do
+        get :show,
+          id: picture.id,
+          crop: 'crop',
+          size: '400x400',
+          crop_size: '200x200',
+          crop_from: '0x0',
+          format: :png,
+          sh: picture.security_token(
+            crop_size: '200x200',
+            crop_from: '0x0',
+            crop: true,
+            size: '400x400'
+          )
+        expect(response.body[0x10..0x18].unpack('NN')).to eq [200, 200]
+      end
+    end
+
+    context "Requesting a picture with crop_from and crop_size parameters with larger size param and upsample set" do
+      let(:picture) { Picture.create(image_file: fixture_file_upload(File.expand_path('../../fixtures/500x500.png', __FILE__), 'image/png')) }
+
+      it "renders the cropped picture with upsampling" do
+        get :show,
+          id: picture.id,
+          crop: 'crop',
+          size: '400x400',
+          crop_size: '200x200',
+          crop_from: '0x0',
+          format: :png,
+          upsample: 'true',
+          sh: picture.security_token(
+            crop_size: '200x200',
+            crop_from: '0x0',
+            crop: true,
+            size: '400x400',
+            upsample: 'true'
+          )
+        expect(response.body[0x10..0x18].unpack('NN')).to eq [400, 400]
       end
     end
 
     context "Requesting a picture that is not assigned with any page" do
       it "should render the picture" do
         get :show, id: picture.id, format: :png, sh: picture.security_token
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
     end
 
@@ -131,7 +198,7 @@ module Alchemy
       context "as guest user" do
         it "should render the picture" do
           get :show, id: picture.id, format: :png, sh: picture.security_token
-          response.status.should == 200
+          expect(response.status).to eq(200)
         end
       end
     end
@@ -146,8 +213,8 @@ module Alchemy
       context "as guest user" do
         it "should not render the picture, but redirect to login path" do
           get :show, id: picture.id, sh: picture.security_token
-          response.status.should == 302
-          response.should redirect_to(Alchemy.login_path)
+          expect(response.status).to eq(302)
+          expect(response).to redirect_to(Alchemy.login_path)
         end
       end
 
@@ -158,7 +225,7 @@ module Alchemy
 
         it "should render the picture" do
           get :show, id: picture.id, format: :png, sh: picture.security_token
-          response.status.should == 200
+          expect(response.status).to eq(200)
         end
       end
     end
@@ -174,7 +241,7 @@ module Alchemy
             format: 'png'
           }
           get :show, options.merge(id: big_picture.id, sh: big_picture.security_token(options))
-          response.body[0x10..0x18].unpack('NN').should == [10,10]
+          expect(response.body[0x10..0x18].unpack('NN')).to eq([10,10])
         end
 
         context "without a full size specification" do
@@ -198,7 +265,7 @@ module Alchemy
               format: 'png'
             }
             get :show, options.merge(id: picture.id, sh: picture.security_token(options))
-            response.body[0x10..0x18].unpack('NN').should == [1,1]
+            expect(response.body[0x10..0x18].unpack('NN')).to eq([1,1])
           end
         end
 
@@ -211,7 +278,7 @@ module Alchemy
               format: 'png'
             }
             get :show, options.merge(id: picture.id, sh: picture.security_token(options))
-            response.body[0x10..0x18].unpack('NN').should == [10,10]
+            expect(response.body[0x10..0x18].unpack('NN')).to eq([10,10])
           end
         end
       end
@@ -223,7 +290,7 @@ module Alchemy
             :format => 'png'
           }
           get :show, options.merge(:id => big_picture.id, :sh => big_picture.security_token(options))
-          response.body[0x10..0x18].unpack('NN').should == [40,30]
+          expect(response.body[0x10..0x18].unpack('NN')).to eq([40,30])
         end
 
         it "should resize the image inferring the height if not given" do
@@ -232,7 +299,7 @@ module Alchemy
             :format => 'png'
           }
           get :show, options.merge(:id => big_picture.id, :sh => big_picture.security_token(options))
-          response.body[0x10..0x18].unpack('NN').should == [40,30]
+          expect(response.body[0x10..0x18].unpack('NN')).to eq([40,30])
         end
 
         it "should resize the image inferring the width if not given" do
@@ -241,7 +308,7 @@ module Alchemy
             :format => 'png'
           }
           get :show, options.merge(:id => big_picture.id, :sh => big_picture.security_token(options))
-          response.body[0x10..0x18].unpack('NN').should == [40,30]
+          expect(response.body[0x10..0x18].unpack('NN')).to eq([40,30])
         end
       end
     end

data/spec/dummy/app/models/dummy_user.rb

@@ -4,8 +4,4 @@ class DummyUser < ActiveRecord::Base
   def self.logged_in
     []
   end
-
-  def alchemy_roles
-    @alchemy_roles || %w(admin)
-  end
 end

data/spec/dummy/app/views/alchemy/elements/_all_you_can_eat_editor.html.erb

@@ -0,0 +1,11 @@
+<%= element_editor_for(element) do |el| -%>
+  <%= el.edit :essence_boolean %>
+  <%= el.edit :essence_date %>
+  <%= el.edit :essence_file %>
+  <%= el.edit :essence_html %>
+  <%= el.edit :essence_link %>
+  <%= el.edit :essence_picture %>
+  <%= el.edit :essence_richtext %>
+  <%= el.edit :essence_select %>
+  <%= el.edit :essence_text %>
+<%- end -%>

data/spec/dummy/config/alchemy/elements.yml

@@ -74,10 +74,31 @@
       - presence
   - name: subject
     type: EssenceText
-    take_me_for_preview: true
+    as_element_title: true
     validate:
       - presence
   - name: success_page
     type: EssenceSelect
     validate:
       - presence
+
+- name: all_you_can_eat
+  contents:
+  - name: essence_boolean
+    type: EssenceBoolean
+  - name: essence_date
+    type: EssenceDate
+  - name: essence_file
+    type: EssenceFile
+  - name: essence_html
+    type: EssenceHtml
+  - name: essence_link
+    type: EssenceLink
+  - name: essence_picture
+    type: EssencePicture
+  - name: essence_richtext
+    type: EssenceRichtext
+  - name: essence_select
+    type: EssenceSelect
+  - name: essence_text
+    type: EssenceText