alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

data/spec/controllers/alchemy/pages_controller_spec.rb

@@ -1,343 +0,0 @@
-require 'ostruct'
-require 'spec_helper'
-
-module Alchemy
-  describe PagesController do
-    let(:default_language) { Language.default }
-
-    let(:default_language_root) do
-      create :alchemy_page, :language_root,
-        language: default_language,
-        name: 'Home',
-        public: true
-    end
-
-    let(:page) do
-      create :alchemy_page, :public,
-        parent_id: default_language_root.id,
-        page_layout: 'news',
-        name: 'News',
-        urlname: 'news',
-        language: default_language,
-        do_not_autogenerate: false
-    end
-
-    before do
-      allow(controller).to receive(:signup_required?).and_return(false)
-    end
-
-    describe "#index" do
-      before do
-        default_language_root
-        allow(Config).to receive(:get) do |arg|
-          arg == :redirect_index ? false : Config.parameter(arg)
-        end
-      end
-
-      it 'renders :show template' do
-        expect(alchemy_get(:index)).to render_template(:show)
-      end
-
-      context 'requesting nothing' do
-        it 'loads default language root page' do
-          alchemy_get :index
-          expect(assigns(:page)).to eq(default_language_root)
-        end
-
-        it 'sets @root_page to default language root' do
-          alchemy_get(:index)
-          expect(assigns(:root_page)).to eq(default_language_root)
-        end
-
-        context 'and the root page is not public' do
-          before do
-            default_language_root.update!(public: false)
-          end
-
-          context 'and redirect_to_public_child is set to false' do
-            before do
-              allow(Config).to receive(:get) do |arg|
-                arg == :redirect_to_public_child ? false : Config.parameter(arg)
-              end
-            end
-
-            it 'raises routing error (404)' do
-              expect {
-                alchemy_get :index
-              }.to raise_error(ActionController::RoutingError)
-            end
-          end
-
-          context 'and redirect_to_public_child is set to true' do
-            before do
-              allow(Config).to receive(:get) do |arg|
-                arg == :redirect_to_public_child ? true : Config.parameter(arg)
-              end
-            end
-
-            context 'that has a public child' do
-              let!(:public_child) do
-                create(:alchemy_page, :public, parent: default_language_root)
-              end
-
-              it 'loads this page' do
-                alchemy_get :index
-                expect(assigns(:page)).to eq(public_child)
-              end
-            end
-
-            context 'that has a non public child' do
-              let!(:non_public_child) do
-                create(:alchemy_page, parent: default_language_root)
-              end
-
-              context 'that has a public child' do
-                let!(:public_child) do
-                  create(:alchemy_page, :public, parent: non_public_child)
-                end
-
-                it 'loads this page' do
-                  alchemy_get :index
-                  expect(assigns(:page)).to eq(public_child)
-                end
-              end
-
-              context 'that has a non public child' do
-                before do
-                  create(:alchemy_page, parent: non_public_child)
-                end
-
-                it 'raises routing error (404)' do
-                  expect {
-                    alchemy_get :index
-                  }.to raise_error(ActionController::RoutingError)
-                end
-              end
-            end
-          end
-        end
-      end
-
-      context 'requesting non default locale' do
-        let!(:deutsch) do
-          create(:alchemy_language, name: 'Deutsch', code: 'de', default: false)
-        end
-
-        let!(:startseite) do
-          create :alchemy_page, :language_root,
-            language: deutsch, public: true, name: 'Startseite'
-        end
-
-        before do
-          allow(::I18n).to receive(:default_locale) { 'en' }
-        end
-
-        it 'loads the root page of that language' do
-          alchemy_get :index, locale: 'de'
-          expect(assigns(:page)).to eq(startseite)
-        end
-
-        it 'sets @root_page to root page of that language' do
-          alchemy_get :index, locale: 'de'
-          expect(assigns(:root_page)).to eq(startseite)
-        end
-      end
-    end
-
-    context 'an author' do
-      let(:unpublic) { create(:alchemy_page, parent: default_language_root) }
-
-      before { authorize_user(:as_author) }
-
-      it "should not be able to visit a unpublic page" do
-        expect {
-          alchemy_get :show, urlname: unpublic.urlname
-        }.to raise_error(ActionController::RoutingError)
-      end
-    end
-
-    context "requested for a page containing a feed" do
-      render_views
-
-      it "should render a rss feed" do
-        alchemy_get :show, urlname: page.urlname, format: :rss
-        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'})
-        alchemy_get :show, urlname: 'news', format: :rss
-        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
-        alchemy_get :show, urlname: default_language_root.urlname, format: :rss
-        expect(response.status).to eq(404)
-      end
-    end
-
-    describe "Layout rendering" do
-      context "with ajax request" do
-        it "should not render a layout" do
-          alchemy_xhr :get, :show, urlname: page.urlname
-          expect(response).to render_template(:show)
-          expect(response).not_to render_template(layout: 'application')
-        end
-      end
-    end
-
-    describe "url nesting" do
-      render_views
-
-      let(:catalog)  { create(:alchemy_page, :public, name: "Catalog", urlname: 'catalog', parent: default_language_root, language: default_language, visible: true) }
-      let(:products) { create(:alchemy_page, :public, name: "Products", urlname: 'products', parent: catalog, language: default_language, visible: true) }
-      let(:product)  { create(:alchemy_page, :public, name: "Screwdriver", urlname: 'screwdriver', parent: products, language: default_language, do_not_autogenerate: false, visible: true) }
-
-      before do
-        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
-          alchemy_get :show, {urlname: 'catalog/products/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
-          expect {
-            alchemy_get :show, {urlname: 'catalog/faqs/screwdriver'}
-          }.to raise_error(ActionController::RoutingError)
-        end
-      end
-    end
-
-    context "when a non-existent page is requested" do
-      it "should rescue a RoutingError with rendering a 404 page." do
-        expect {
-          alchemy_get :show, {urlname: 'doesntexist'}
-        }.to raise_error(ActionController::RoutingError)
-      end
-    end
-
-    describe 'Redirecting to legacy page urls' do
-      context 'Request a page with legacy url' do
-        let(:page)        { create(:alchemy_page, :public, name: 'New page name') }
-        let(:second_page) { create(:alchemy_page, :public, name: 'Second Page') }
-        let(:legacy_page) { create(:alchemy_page, :public, name: 'Legacy Url') }
-        let!(:legacy_url) { LegacyPageUrl.create(urlname: 'legacy-url', page: page) }
-        let(:legacy_url2) { LegacyPageUrl.create(urlname: 'legacy-url', page: second_page) }
-        let(:legacy_url3) { LegacyPageUrl.create(urlname: 'index.php?id=2', page: second_page) }
-        let(:legacy_url4) { LegacyPageUrl.create(urlname: 'index.php?option=com_content&view=article&id=48&Itemid=69', page: second_page) }
-        let(:legacy_url5) { LegacyPageUrl.create(urlname: 'nested/legacy/url', page: second_page) }
-
-        it "should redirect permanently to page that belongs to legacy page url even if url has an unknown format & get parameters" do
-          expect(request).to receive(:fullpath).at_least(:once).and_return(legacy_url4.urlname)
-          alchemy_get :show, urlname: legacy_url4.urlname
-          expect(response.status).to eq(301)
-          expect(response).to redirect_to("/#{second_page.urlname}")
-        end
-
-        it "should not pass query string for legacy routes" do
-          expect(request).to receive(:fullpath).at_least(:once).and_return(legacy_url3.urlname)
-          alchemy_get :show, urlname: legacy_url4.urlname
-          expect(URI.parse(response["Location"]).query).to be_nil
-        end
-
-        it "should only redirect to legacy url if no page was found for urlname" do
-          alchemy_get :show, urlname: legacy_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
-          expect(request).to receive(:fullpath).at_least(:once).and_return(legacy_url2.urlname)
-          alchemy_get :show, urlname: legacy_url2.urlname
-          expect(response).to redirect_to("/#{second_page.urlname}")
-        end
-
-        it "should redirect even if the url has get parameters" do
-          expect(request).to receive(:fullpath).at_least(:once).and_return(legacy_url3.urlname)
-          alchemy_get :show, urlname: legacy_url3.urlname
-          expect(response).to redirect_to("/#{second_page.urlname}")
-        end
-
-        it "should redirect even if the url has nested urlname" do
-          expect(request).to receive(:fullpath).at_least(:once).and_return(legacy_url5.urlname)
-          alchemy_get :show, urlname: legacy_url5.urlname
-          expect(response).to redirect_to("/#{second_page.urlname}")
-        end
-      end
-    end
-
-    describe "while redirecting" do
-      context "not in multi language mode" do
-        before do
-          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
-            alchemy_get :show, urlname: page.urlname
-            expect(controller.session[:alchemy_language_id]).to eq(Language.default.id)
-          end
-
-          it "should store default language as class var." do
-            alchemy_get :show, urlname: page.urlname
-            expect(Language.current).to eq(Language.default)
-          end
-        end
-      end
-    end
-
-    context 'in an environment with multiple languages' do
-      let(:klingon) { create(:alchemy_language, :klingon) }
-
-      context 'having two pages with the same url names in different languages' do
-        render_views
-
-        let!(:klingon_page) { create(:alchemy_page, :public, language: klingon, name: "same-name", do_not_autogenerate: false) }
-        let!(:english_page) { create(:alchemy_page, :public, language: default_language, name: "same-name") }
-
-        before do
-          # Set a text in an essence rendered on the page so we can match against that
-          klingon_page.essence_texts.first.update_column(:body, 'klingon page')
-        end
-
-        it 'renders the page related to its language' do
-          alchemy_get :show, {urlname: "same-name", locale: klingon_page.language_code}
-          expect(response.body).to have_content("klingon page")
-        end
-      end
-    end
-
-    describe '#page_etag' do
-      subject { controller.send(:page_etag) }
-
-      before do
-        expect(page).to receive(:cache_key).and_return('aaa')
-        controller.instance_variable_set('@page', page)
-      end
-
-      it "returns the etag for response headers" do
-        expect(subject).to eq('aaa')
-      end
-
-      context 'with user logged in' do
-        before do
-          authorize_user(mock_model(Alchemy.user_class, cache_key: 'bbb'))
-        end
-
-        it "returns another etag for response headers" do
-          expect(subject).to eq('aaabbb')
-        end
-      end
-    end
-  end
-end

data/spec/controllers/alchemy/pictures_controller_spec.rb

@@ -1,415 +0,0 @@
-require 'spec_helper'
-
-# Fixes missing method tempfile error
-class Rack::Test::UploadedFile
-  attr_reader :tempfile
-end
-
-module Alchemy
-  describe PicturesController do
-    let(:public_page)        { create(:alchemy_page, :public, restricted: false) }
-    let(:restricted_page)    { create(:alchemy_page, :public, restricted: true) }
-    let(:element)            { create(:alchemy_element, page: public_page, name: 'bild', create_contents_after_create: true) }
-    let(:restricted_element) { create(:alchemy_element, page: restricted_page, name: 'bild', create_contents_after_create: true) }
-    let(:picture)            { create(:alchemy_picture, image_file: fixture_file_upload(File.expand_path('../../../fixtures/image.png', __FILE__), 'image/png')) }
-
-    describe '#zoom' do
-      let(:picture) do
-        create(:alchemy_picture, image_file: fixture_file_upload(File.expand_path('../../../fixtures/80x60.png', __FILE__), 'image/png'))
-      end
-
-      it "renders the original image without any resizing" do
-        alchemy_get :zoom, id: picture.id, name: picture.urlname, format: :png, sh: picture.security_token
-        expect(response.body[0x10..0x18].unpack('NN')).to eq([80, 60])
-      end
-
-      context "Requesting a picture that is assigned with restricted pages only" do
-        before do
-          essence = restricted_element.contents.where(name: 'image').first.essence
-          essence.picture_id = picture.id
-          essence.save
-        end
-
-        context "as guest user" do
-          it "should not render the picture, but redirect to login path" do
-            alchemy_get :zoom, id: picture.id, name: picture.urlname, format: :png, sh: picture.security_token
-            expect(response.status).to eq(302)
-            expect(response).to redirect_to(Alchemy.login_path)
-          end
-        end
-
-        context "as member user" do
-          before do
-            authorize_user(build(:alchemy_dummy_user))
-          end
-
-          it "should render the picture" do
-            alchemy_get :zoom, id: picture.id, name: picture.urlname, format: :png, sh: picture.security_token
-            expect(response.status).to eq(200)
-          end
-        end
-      end
-    end
-
-    describe '#show' do
-      it "skips the session cookie" do
-        expect {
-          alchemy_get :show, id: picture.id, name: picture.urlname, format: :png, sh: picture.security_token
-        }.to change {
-          request.session_options.fetch(:skip) { false }
-        }.to(true)
-      end
-
-      context "Requesting a picture with tempared security token" do
-        it "should render status 400" do
-          alchemy_get :show, id: picture.id, name: picture.urlname, format: :png, sh: '14m4b4dh4ck3r'
-          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
-          alchemy_get :show, id: picture.id, name: picture.urlname, format: :jpeg, sh: picture.security_token
-          expect(response.content_type).to eq('image/jpeg')
-        end
-      end
-
-      context "Requesting a picture with not allowed format" do
-        it "should raise error" do
-          expect {
-            alchemy_get :show, id: picture.id, name: picture.urlname, format: :wim, sh: picture.security_token
-          }.to raise_error(ActionController::UnknownFormat)
-        end
-      end
-
-      context "Requesting a picture that has no image file attached" do
-        before do
-          expect(picture).to receive(:image_file).and_return(nil)
-          expect(Picture).to receive(:find).and_return(picture)
-        end
-
-        it "raises missing file error" do
-          expect {
-            alchemy_get :show, id: picture.id, name: picture.urlname, format: :png, sh: picture.security_token
-          }.to raise_error(Alchemy::MissingImageFileError)
-        end
-      end
-
-      context "Requesting a picture with crop_from and crop_size parameters" do
-        let(:picture) do
-          create(:alchemy_picture, image_file: fixture_file_upload(File.expand_path('../../../fixtures/500x500.png', __FILE__), 'image/png'))
-        end
-
-        it "renders the cropped picture" do
-          alchemy_get :show, id: picture.id, name: picture.urlname, 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) do
-          create(:alchemy_picture, image_file: fixture_file_upload(File.expand_path('../../../fixtures/500x500.png', __FILE__), 'image/png'))
-        end
-
-        it "renders the cropped picture" do
-          alchemy_get :show,
-            id: picture.id,
-            name: picture.urlname,
-            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) do
-          create(:alchemy_picture, image_file: fixture_file_upload(File.expand_path('../../../fixtures/500x500.png', __FILE__), 'image/png'))
-        end
-
-        it "renders the cropped picture without upsampling" do
-          alchemy_get :show,
-            id: picture.id,
-            name: picture.urlname,
-            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) do
-          create(:alchemy_picture, image_file: fixture_file_upload(File.expand_path('../../../fixtures/500x500.png', __FILE__), 'image/png'))
-        end
-
-        it "renders the cropped picture with upsampling" do
-          alchemy_get :show,
-            id: picture.id,
-            name: picture.urlname,
-            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
-          alchemy_get :show, id: picture.id, name: picture.urlname, format: :png, sh: picture.security_token
-          expect(response.status).to eq(200)
-        end
-      end
-
-      context "Requesting a picture that is assigned on restricted and non-restricted pages" do
-        before do
-          essence = element.contents.where(name: 'image').first.essence
-          essence.picture_id = picture.id
-          essence.save
-
-          essence = restricted_element.contents.where(name: 'image').first.essence
-          essence.picture_id = picture.id
-          essence.save
-        end
-
-        context "as guest user" do
-          it "should render the picture" do
-            alchemy_get :show, id: picture.id, name: picture.urlname, format: :png, sh: picture.security_token
-            expect(response.status).to eq(200)
-          end
-        end
-      end
-
-      context "Requesting a picture that is assigned with restricted pages only" do
-        before do
-          essence = restricted_element.contents.where(name: 'image').first.essence
-          essence.picture_id = picture.id
-          essence.save
-        end
-
-        context "as guest user" do
-          it "should not render the picture, but redirect to login path" do
-            alchemy_get :show, id: picture.id, name: picture.urlname, format: :png, sh: picture.security_token
-            expect(response.status).to eq(302)
-            expect(response).to redirect_to(Alchemy.login_path)
-          end
-        end
-
-        context "as member user" do
-          before do
-            authorize_user(build(:alchemy_dummy_user))
-          end
-
-          it "should render the picture" do
-            alchemy_get :show, id: picture.id, name: picture.urlname, format: :png, sh: picture.security_token
-            expect(response.status).to eq(200)
-          end
-        end
-      end
-
-      context 'requesting an animated gif with different format' do
-        let(:image) do
-          fixture_file_upload(
-            File.expand_path('../../../fixtures/animated.gif', __FILE__),
-            'image/gif'
-          )
-        end
-
-        let(:picture) { build_stubbed(:alchemy_picture, image_file: image) }
-
-        before do
-          expect(image).to receive(:ext) { 'gif' }
-          expect(picture).to receive(:image_file) { image }
-          expect(Alchemy::Picture).to receive(:find) { picture }
-        end
-
-        it 'flattens the gif before converting the format.' do
-          expect(image).to receive(:encode).with('png', '-flatten') { double(data: '') }
-          alchemy_get :show, id: picture.id, name: picture.urlname,
-            format: 'png', sh: picture.security_token
-        end
-      end
-    end
-
-    describe '#thumbnail' do
-      let(:picture) do
-        create(:alchemy_picture, image_file: fixture_file_upload(File.expand_path('../../../fixtures/500x500.png', __FILE__), 'image/png'))
-      end
-
-      context 'with size param set to small' do
-        it "resizes the image to 80x60 while maintaining aspect ratio" do
-          alchemy_get :thumbnail, id: picture.id, name: picture.urlname, size: 'small', format: :png, sh: picture.security_token(size: 'small')
-          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
-          alchemy_get :thumbnail, id: picture.id, name: picture.urlname, size: 'medium', format: :png, sh: picture.security_token(size: 'medium')
-          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
-          alchemy_get :thumbnail, id: picture.id, name: picture.urlname, size: 'large', format: :png, sh: picture.security_token(size: 'large')
-          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
-          alchemy_get :thumbnail, id: picture.id, name: picture.urlname, format: :png, sh: picture.security_token
-          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
-          alchemy_get :thumbnail, id: picture.id, name: picture.urlname, size: '33x33', format: :png, sh: picture.security_token(size: '33x33')
-          expect(response.body[0x10..0x18].unpack('NN')).to eq([33, 33])
-        end
-      end
-
-      context "Requesting a picture that is assigned with restricted pages only" do
-        before do
-          essence = restricted_element.contents.where(name: 'image').first.essence
-          essence.picture_id = picture.id
-          essence.save
-        end
-
-        context "as guest user" do
-          it "should not render the picture, but redirect to login path" do
-            alchemy_get :thumbnail, id: picture.id, name: picture.urlname, format: :png, sh: picture.security_token
-            expect(response.status).to eq(302)
-            expect(response).to redirect_to(Alchemy.login_path)
-          end
-        end
-
-        context "as member user" do
-          before do
-            authorize_user(build(:alchemy_dummy_user))
-          end
-
-          it "should render the picture" do
-            alchemy_get :thumbnail, id: picture.id, name: picture.urlname, format: :png, sh: picture.security_token
-            expect(response.status).to eq(200)
-          end
-        end
-      end
-    end
-
-    describe 'Picture processing' do
-      let(:big_picture) do
-        create(:alchemy_picture, image_file: fixture_file_upload(File.expand_path('../../../fixtures/80x60.png', __FILE__), 'image/png'))
-      end
-
-      context "with crop and size parameters" do
-        it "should return a cropped image." do
-          options = {
-            crop: 'crop',
-            size: '10x10',
-            format: 'png'
-          }
-          alchemy_get :show, options.merge(id: big_picture.id, name: big_picture.urlname, sh: big_picture.security_token(options))
-          expect(response.body[0x10..0x18].unpack('NN')).to eq([10, 10])
-        end
-
-        context "without a full size specification" do
-          it "should raise an error" do
-            options = {
-              crop: 'crop',
-              size: '10',
-              format: 'png'
-            }
-            expect {
-              alchemy_get :show, options.merge(id: big_picture.id, name: big_picture.urlname, sh: big_picture.security_token(options))
-            }.to raise_error ArgumentError
-          end
-        end
-
-        context "without upsample parameter" do
-          it "should not upsample the image." do
-            options = {
-              crop: 'crop',
-              size: '10x10',
-              format: 'png'
-            }
-            alchemy_get :show, options.merge(id: picture.id, name: big_picture.urlname, sh: picture.security_token(options))
-            expect(response.body[0x10..0x18].unpack('NN')).to eq([1, 1])
-          end
-        end
-
-        context "and with upsample true" do
-          it "should return an upsampled image." do
-            options = {
-              crop: 'crop',
-              size: '10x10',
-              upsample: 'true',
-              format: 'png'
-            }
-            alchemy_get :show, options.merge(id: picture.id, name: big_picture.urlname, sh: picture.security_token(options))
-            expect(response.body[0x10..0x18].unpack('NN')).to eq([10, 10])
-          end
-        end
-      end
-
-      context "without crop but with size parameter" do
-        it "should resize the image preserving aspect ratio" do
-          options = {
-            size: '40x40',
-            format: 'png'
-          }
-          alchemy_get :show, options.merge(id: big_picture.id, name: big_picture.urlname, sh: big_picture.security_token(options))
-          expect(response.body[0x10..0x18].unpack('NN')).to eq([40, 30])
-        end
-
-        it "should resize the image inferring the height if not given" do
-          options = {
-            size: '40x',
-            format: 'png'
-          }
-          alchemy_get :show, options.merge(id: big_picture.id, name: big_picture.urlname, sh: big_picture.security_token(options))
-          expect(response.body[0x10..0x18].unpack('NN')).to eq([40, 30])
-        end
-
-        it "should resize the image inferring the width if not given" do
-          options = {
-            size: 'x30',
-            format: 'png'
-          }
-          alchemy_get :show, options.merge(id: big_picture.id, name: big_picture.urlname, sh: big_picture.security_token(options))
-          expect(response.body[0x10..0x18].unpack('NN')).to eq([40, 30])
-        end
-      end
-    end
-  end
-end