alchemy_cms 3.1.3 → 3.2.0.beta

data/spec/controllers/alchemy/api/pages_controller_spec.rb

@@ -4,47 +4,56 @@ module Alchemy
   describe Api::PagesController do
 
     describe '#index' do
-      let!(:page)    { create(:public_page) }
+      let!(:page) { create(:public_page) }
 
       it "returns all public pages as json objects" do
-        get :index, format: :json
+        alchemy_get :index, format: :json
         expect(response.status).to eq(200)
         expect(response.content_type).to eq('application/json')
-        expect(response.body).to_not eq('{"pages":[]}')
+        expect(response.body).to eq("{\"pages\":[#{PageSerializer.new(page.parent).to_json},#{PageSerializer.new(page).to_json}]}")
       end
 
       context 'with page_layout' do
         let!(:other_page) { create(:public_page, page_layout: 'news') }
 
-        it "returns only pages from this element" do
-          get :index, page_layout: 'news', format: :json
+        it "returns only pages with this page layout" do
+          alchemy_get :index, {page_layout: 'news', format: :json}
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
-          expect(response.body).to_not eq('{"pages":[]}')
-          expect(response.body).to_not match(/page_layout\"\:#{page.page_layout}/)
+          expect(response.body).to eq("{\"pages\":[#{PageSerializer.new(other_page).to_json}]}")
+        end
+      end
+
+      context 'with empty string as page_layout' do
+        it "returns all pages" do
+          alchemy_get :index, {page_layout: '', format: :json}
+          expect(response.status).to eq(200)
+          expect(response.content_type).to eq('application/json')
+          expect(response.body).to eq("{\"pages\":[#{PageSerializer.new(page.parent).to_json},#{PageSerializer.new(page).to_json}]}")
         end
       end
     end
 
     describe '#show' do
       context 'for existing page' do
-        let(:page) { build_stubbed(:public_page) }
+        let(:page) { build_stubbed(:public_page, urlname: 'a-page') }
 
         before do
           expect(Page).to receive(:find_by).and_return(page)
         end
 
-        it "responds to json" do
-          get :show, urlname: page.urlname, format: :json
+        it "returns page as json" do
+          alchemy_get :show, {urlname: page.urlname, format: :json}
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
+          expect(response.body).to eq(PageSerializer.new(page).to_json)
         end
 
         context 'requesting an restricted page' do
-          let(:page) { build_stubbed(:page, restricted: true) }
+          let(:page) { build_stubbed(:page, restricted: true, urlname: 'a-page') }
 
           it "responds with 403" do
-            get :show, urlname: page.urlname, format: :json
+            alchemy_get :show, {urlname: page.urlname, format: :json}
             expect(response.content_type).to eq('application/json')
             expect(response.status).to eq(403)
             expect(response.body).to eq('{"error":"Not authorized"}')
@@ -52,10 +61,10 @@ module Alchemy
         end
 
         context 'requesting a not public page' do
-          let(:page) { build_stubbed(:page) }
+          let(:page) { build_stubbed(:page, urlname: 'a-page') }
 
           it "responds with 403" do
-            get :show, urlname: page.urlname, format: :json
+            alchemy_get :show, {urlname: page.urlname, format: :json}
             expect(response.content_type).to eq('application/json')
             expect(response.status).to eq(403)
             expect(response.body).to eq('{"error":"Not authorized"}')
@@ -65,7 +74,7 @@ module Alchemy
 
       context 'requesting an unknown page' do
         it "responds with 404" do
-          get :show, urlname: 'not-existing', format: :json
+          alchemy_get :show, {urlname: 'not-existing', format: :json}
           expect(response.content_type).to eq('application/json')
           expect(response.status).to eq(404)
           expect(response.body).to eq('{"error":"Record not found"}')
@@ -76,9 +85,10 @@ module Alchemy
         let(:page) { create(:public_page) }
 
         it "responds with json" do
-          get :show, id: page.id, format: :json
+          alchemy_get :show, {id: page.id, format: :json}
           expect(response.status).to eq(200)
           expect(response.content_type).to eq('application/json')
+          expect(response.body).to eq(PageSerializer.new(page).to_json)
         end
       end
     end

data/spec/controllers/attachments_controller_spec.rb

@@ -5,7 +5,7 @@ module Alchemy
     let(:attachment) { build_stubbed(:attachment) }
 
     it "should raise ActiveRecord::RecordNotFound for requesting not existing attachments" do
-      expect { get :download, id: 0 }.to raise_error(ActiveRecord::RecordNotFound)
+      expect { alchemy_get :download, id: 0 }.to raise_error(ActiveRecord::RecordNotFound)
     end
 
     context 'with public attachment' do
@@ -14,13 +14,13 @@ module Alchemy
       end
 
       it "sends download as attachment." do
-        get :download, :id => attachment.id
+        alchemy_get :download, :id => attachment.id
         expect(response.status).to eq(200)
         expect(response.headers['Content-Disposition']).to match(/attachment/)
       end
 
       it "sends download inline." do
-        get :show, :id => attachment.id
+        alchemy_get :show, :id => attachment.id
         expect(response.status).to eq(200)
         expect(response.headers['Content-Disposition']).to match(/inline/)
       end
@@ -34,13 +34,13 @@ module Alchemy
 
       context 'as anonymous user' do
         it "should not be possible to download attachments from restricted pages" do
-          get :download, :id => attachment.id
+          alchemy_get :download, :id => attachment.id
           expect(response.status).to eq(302)
           expect(response).to redirect_to(Alchemy.login_path)
         end
 
         it "should not be possible to see attachments from restricted pages" do
-          get :show, :id => attachment.id
+          alchemy_get :show, :id => attachment.id
           expect(response.status).to eq(302)
           expect(response).to redirect_to(Alchemy.login_path)
         end
@@ -50,12 +50,12 @@ module Alchemy
         before { sign_in(member_user) }
 
         it "should be possible to download attachments from restricted pages" do
-          get :download, :id => attachment.id
+          alchemy_get :download, :id => attachment.id
           expect(response.status).to eq(200)
         end
 
         it "should be possible to see attachments from restricted pages" do
-          get :show, :id => attachment.id
+          alchemy_get :show, :id => attachment.id
           expect(response.status).to eq(200)
         end
       end

data/spec/controllers/elements_controller_spec.rb

@@ -2,30 +2,36 @@ require 'spec_helper'
 
 module Alchemy
   describe ElementsController do
-    let(:public_page)         { FactoryGirl.create(:public_page) }
-    let(:element)             { FactoryGirl.create(:element, :page => public_page, :name => 'download') }
-    let(:restricted_page)     { FactoryGirl.create(:public_page, :restricted => true) }
-    let(:restricted_element)  { FactoryGirl.create(:element, :page => restricted_page, :name => 'download') }
+    let(:public_page)         { create(:public_page) }
+    let(:element)             { create(:element, page: public_page, name: 'download') }
+    let(:restricted_page)     { create(:public_page, restricted: true) }
+    let(:restricted_element)  { create(:element, page: restricted_page, name: 'download') }
 
     describe '#show' do
       it "should render available elements" do
-        get :show, :id => element.id
+        alchemy_get :show, id: element.id
         expect(response.status).to eq(200)
       end
 
       it "should raise ActiveRecord::RecordNotFound error for trashed elements" do
         element.trash!
-        expect { get(:show, :id => element.id) }.to raise_error(ActiveRecord::RecordNotFound)
+        expect {
+          alchemy_get :show, id: element.id
+        }.to raise_error(ActiveRecord::RecordNotFound)
       end
 
       it "should raise ActiveRecord::RecordNotFound error for unpublished elements" do
-        element.update_attributes(:public => false)
-        expect { get(:show, :id => element.id) }.to raise_error(ActiveRecord::RecordNotFound)
+        element.update_attributes(public: false)
+        expect {
+          alchemy_get :show, id: element.id
+        }.to raise_error(ActiveRecord::RecordNotFound)
       end
 
       context "for guest user" do
         it "should raise ActiveRecord::RecordNotFound error for elements of restricted pages" do
-          expect { get(:show, :id => restricted_element.id) }.to raise_error(ActiveRecord::RecordNotFound)
+          expect {
+            alchemy_get :show, id: restricted_element.id
+          }.to raise_error(ActiveRecord::RecordNotFound)
         end
       end
 
@@ -33,19 +39,10 @@ module Alchemy
         before { sign_in(member_user) }
 
         it "should render elements of restricted pages" do
-          get :show, :id => restricted_element.id
+          alchemy_get :show, id: restricted_element.id
           expect(response.status).to eq(200)
         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, id: element.id, format: :json
-          expect(response.status).to eq(200)
-          expect(response.content_type).to eq('application/json')
-        end
-      end
     end
   end
 end

data/spec/controllers/messages_controller_spec.rb

@@ -13,14 +13,14 @@ module Alchemy
       let(:page) { mock_model('Page', {urlname: 'contact', page_layout: 'contact'}) }
 
       it "should redirect to @page" do
-        expect(get :index).to redirect_to(show_page_path(urlname: page.urlname))
+        expect(alchemy_get :index).to redirect_to(show_page_path(urlname: page.urlname))
       end
     end
 
     describe "#new" do
       it "should render the alchemy/pages/show template" do
-        get :new
-        expect(get :new).to render_template('alchemy/pages/show')
+        alchemy_get :new
+        expect(alchemy_get :new).to render_template('alchemy/pages/show')
       end
     end
 
@@ -34,7 +34,7 @@ module Alchemy
       let(:message) { Message.new }
 
       it "should raise ActiveRecord::RecordNotFound if element of contactform could not be found" do
-        expect { post :create }.to raise_error(ActiveRecord::RecordNotFound)
+        expect { alchemy_post :create }.to raise_error(ActiveRecord::RecordNotFound)
       end
 
       context "if validation of message" do
@@ -51,7 +51,7 @@ module Alchemy
           end
 
           it "should render 'alchemy/pages/show' template" do
-            expect(post :create).to render_template('alchemy/pages/show')
+            expect(alchemy_post :create).to render_template('alchemy/pages/show')
           end
         end
 
@@ -63,7 +63,7 @@ module Alchemy
 
           it "Messages should call Messages#contact_form_mail to send the email" do
             expect(Messages).to receive(:contact_form_mail)
-            post :create
+            alchemy_post :create
           end
 
           describe '#mail_to' do
@@ -76,7 +76,7 @@ module Alchemy
 
               it "returns the ingredient" do
                 expect(Messages).to receive(:contact_form_mail).with(message, 'peter@schroeder.de', '', '')
-                post :create
+                alchemy_post :create
               end
             end
 
@@ -89,7 +89,7 @@ module Alchemy
 
               it "returns the config value" do
                 expect(Messages).to receive(:contact_form_mail).with(message, 'your.mail@your-domain.com', '', '')
-                post :create
+                alchemy_post :create
               end
             end
           end
@@ -104,7 +104,7 @@ module Alchemy
 
               it "returns the ingredient" do
                 expect(Messages).to receive(:contact_form_mail).with(message, '', 'peter@schroeder.de', '')
-                post :create
+                alchemy_post :create
               end
             end
 
@@ -117,7 +117,7 @@ module Alchemy
 
               it "returns the config value" do
                 expect(Messages).to receive(:contact_form_mail).with(message, '', 'your.mail@your-domain.com', '')
-                post :create
+                alchemy_post :create
               end
             end
           end
@@ -132,7 +132,7 @@ module Alchemy
 
               it "returns the ingredient" do
                 expect(Messages).to receive(:contact_form_mail).with(message, '', '', 'A new message')
-                post :create
+                alchemy_post :create
               end
             end
 
@@ -145,7 +145,7 @@ module Alchemy
 
               it "returns the config value" do
                 expect(Messages).to receive(:contact_form_mail).with(message, '', '', 'A new contact form message')
-                post :create
+                alchemy_post :create
               end
             end
           end
@@ -157,7 +157,7 @@ module Alchemy
               end
 
               it "should redirect to the given urlname" do
-                expect(post :create).to redirect_to(show_page_path(urlname: 'success-page'))
+                expect(alchemy_post :create).to redirect_to(show_page_path(urlname: 'success-page'))
               end
             end
 
@@ -173,7 +173,7 @@ module Alchemy
                 end
 
                 it "redirect to the given success page" do
-                  expect(post :create).to redirect_to(show_page_path(urlname: 'mailer-config-success-page'))
+                  expect(alchemy_post :create).to redirect_to(show_page_path(urlname: 'mailer-config-success-page'))
                 end
               end
 
@@ -187,7 +187,7 @@ module Alchemy
 
                 it "should redirect to the language root page" do
                   expect(Language).to receive(:current).and_return(language)
-                  expect(post :create).to redirect_to(show_page_path(urlname: 'lang-root'))
+                  expect(alchemy_post :create).to redirect_to(show_page_path(urlname: 'lang-root'))
                 end
               end
             end

data/spec/controllers/pages_controller_spec.rb

@@ -15,7 +15,7 @@ module Alchemy
       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
+        alchemy_get :show, urlname: unpublic.urlname
         expect(response.status).to eq(404)
       end
     end
@@ -24,37 +24,28 @@ module Alchemy
       render_views
 
       it "should render a rss feed" do
-        get :show, urlname: page.urlname, format: :rss
+        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'})
-        get :show, urlname: 'news', format: :rss
+        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
-        get :show, urlname: default_language_root.urlname, format: :rss
+        alchemy_get :show, urlname: default_language_root.urlname, format: :rss
         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
-
     describe "Layout rendering" do
       context "with ajax request" do
         it "should not render a layout" do
-          xhr :get, :show, urlname: page.urlname
+          alchemy_xhr :get, :show, urlname: page.urlname
           expect(response).to render_template(:show)
           expect(response).not_to render_template(layout: 'application')
         end
@@ -76,7 +67,7 @@ module Alchemy
 
       context "with correct levelnames in params" do
         it "should show the requested page" do
-          get :show, {urlname: 'catalog/products/screwdriver'}
+          alchemy_get :show, {urlname: 'catalog/products/screwdriver'}
           expect(response.status).to eq(200)
           expect(response.body).to have_content("screwdriver")
         end
@@ -84,7 +75,7 @@ module Alchemy
 
       context "with incorrect levelnames in params" do
         it "should render a 404 page" do
-          get :show, {urlname: 'catalog/faqs/screwdriver'}
+          alchemy_get :show, {urlname: 'catalog/faqs/screwdriver'}
           expect(response.status).to eq(404)
           expect(response.body).to have_content('The page you were looking for doesn\'t exist')
         end
@@ -93,7 +84,7 @@ 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'}
+        alchemy_get :show, {urlname: 'doesntexist'}
         expect(response.status).to eq(404)
         expect(response.body).to have_content('The page you were looking for doesn\'t exist')
       end
@@ -148,38 +139,38 @@ module Alchemy
 
         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)
-          get :show, urlname: "index.php"
+          alchemy_get :show, urlname: "index.php"
           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)
-          get :show, urlname: "index.php"
+          alchemy_get :show, urlname: "index.php"
           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
-          get :show, urlname: legacy_page.urlname
+          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)
-          get :show, urlname: 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)
-          get :show, urlname: 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)
-          get :show, urlname: legacy_url5.urlname
+          alchemy_get :show, urlname: legacy_url5.urlname
           expect(response).to redirect_to("/#{second_page.urlname}")
         end
       end
@@ -193,12 +184,12 @@ module Alchemy
 
         context "with no lang parameter present" do
           it "should store defaults language id in the session." do
-            get :show, urlname: 'a-public-page'
+            alchemy_get :show, urlname: 'a-public-page'
             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'
+            alchemy_get :show, urlname: 'a-public-page'
             expect(Language.current).to eq(Language.default)
           end
         end