alchemy_cms 3.0.4 → 3.1.0.beta1

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

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module Alchemy
+  describe API::ContentsController do
+    describe '#index' do
+      let!(:page)    { create(:page) }
+      let!(:element) { create(:element, page: page) }
+      let!(:content) { create(:content, element: element) }
+
+      it "returns all public contents as json objects" do
+        get :index, format: :json
+        expect(response.status).to eq(200)
+        expect(response.content_type).to eq('application/json')
+        expect(response.body).to_not eq('{"contents":[]}')
+      end
+
+      context 'with element_id' do
+        let!(:other_element) { create(:element, page: page) }
+        let!(:other_content) { create(:content, element: other_element) }
+
+        it "returns only contents from this element" do
+          get :index, element_id: element.id, format: :json
+          expect(response.status).to eq(200)
+          expect(response.content_type).to eq('application/json')
+          expect(response.body).to_not eq('{"contents":[]}')
+          expect(response.body).to_not match(/element_id\"\:#{other_element.id}/)
+        end
+      end
+    end
+
+    describe '#show' do
+      context 'with no other params given' do
+        let(:page)    { build_stubbed(:page) }
+        let(:element) { build_stubbed(:element, page: page, position: 1) }
+        let(:content) { build_stubbed(:content, element: element) }
+
+        before do
+          expect(Content).to receive(:find).and_return(content)
+        end
+
+        it "responds to json" do
+          get :show, id: content.id, format: :json
+          expect(response.status).to eq(200)
+          expect(response.content_type).to eq('application/json')
+        end
+
+        context 'requesting an restricted content' do
+          let(:page) { build_stubbed(:page, restricted: true) }
+
+          it "responds with 403" do
+            get :show, id: content.id, format: :json
+            expect(response.content_type).to eq('application/json')
+            expect(response.status).to eq(403)
+          end
+        end
+      end
+
+      context 'with element_id and name params given' do
+        let!(:page)    { create(:page) }
+        let!(:element) { create(:element, page: page) }
+        let!(:content) { create(:content, element: element) }
+
+        it 'returns the named content from element with given id.' do
+          get :show, element_id: element.id, name: content.name, format: :json
+          expect(response.status).to eq(200)
+          expect(response.content_type).to eq('application/json')
+          expect(response.body).to match(/element_id\"\:#{element.id}/)
+          expect(response.body).to match(/name\"\:\"#{content.name}\"/)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Alchemy
+  describe API::ElementsController do
+    describe '#index' do
+      let!(:page)    { create(:public_page) }
+      let!(:element) { create(:element, page: page) }
+
+      it "returns all public elements as json objects" do
+        get :index, format: :json
+        expect(response.status).to eq(200)
+        expect(response.content_type).to eq('application/json')
+        expect(response.body).to_not eq('{"elements":[]}')
+      end
+
+      context 'with page_id param' do
+        let!(:other_page)    { create(:public_page) }
+        let!(:other_element) { create(:element, page: other_page) }
+
+        it "returns only elements from this element" do
+          get :index, page_id: other_page.id, format: :json
+          expect(response.status).to eq(200)
+          expect(response.content_type).to eq('application/json')
+          expect(response.body).to_not eq('{"elements":[]}')
+          expect(response.body).to match(/page_id\"\:#{other_page.id}/)
+          expect(response.body).to_not match(/page_id\"\:#{page.id}/)
+        end
+      end
+
+      context 'with named param' do
+        let!(:other_element) { create(:element, page: page, name: 'news') }
+
+        it "returns only elements named like this." do
+          get :index, named: 'news', format: :json
+          expect(response.status).to eq(200)
+          expect(response.content_type).to eq('application/json')
+          expect(response.body).to_not eq('{"elements":[]}')
+          expect(response.body).to match(/name\"\:\"#{other_element.name}\"/)
+          expect(response.body).to_not match(/name\"\:\"#{element.name}\"/)
+        end
+      end
+    end
+
+    describe '#show' do
+      let(:page)    { build_stubbed(:page) }
+      let(:element) { build_stubbed(:element, page: page, position: 1) }
+
+      before do
+        expect(Element).to receive(:find).and_return(element)
+      end
+
+      it "responds to json" do
+        get :show, id: element.id, format: :json
+        expect(response.status).to eq(200)
+        expect(response.content_type).to eq('application/json')
+      end
+
+      context 'requesting an restricted element' do
+        let(:page) { build_stubbed(:page, restricted: true) }
+
+        it "responds with 403" do
+          get :show, id: element.id, format: :json
+          expect(response.content_type).to eq('application/json')
+          expect(response.status).to eq(403)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+module Alchemy
+  describe API::PagesController do
+
+    describe '#index' do
+      let!(:page)    { create(:public_page) }
+
+      it "returns all public pages as json objects" do
+        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":[]}')
+      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
+          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}/)
+        end
+      end
+    end
+
+    describe '#show' do
+      context 'for existing page' do
+        let(:page) { build_stubbed(:public_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
+          expect(response.status).to eq(200)
+          expect(response.content_type).to eq('application/json')
+        end
+
+        context 'requesting an restricted page' do
+          let(:page) { build_stubbed(:page, restricted: true) }
+
+          it "responds with 403" do
+            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"}')
+          end
+        end
+
+        context 'requesting a not public page' do
+          let(:page) { build_stubbed(:page) }
+
+          it "responds with 403" do
+            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"}')
+          end
+        end
+      end
+
+      context 'requesting an unknown page' do
+        it "responds with 404" do
+          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"}')
+        end
+      end
+
+      context 'requesting a page with id' do
+        let(:page) { create(:public_page) }
+
+        it "responds with json" do
+          get :show, id: page.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/attachments_controller_spec.rb

@@ -10,21 +10,21 @@ module Alchemy
 
     context 'with restricted attachment' do
       before do
-        attachment.stub(:restricted?).and_return(true)
-        Attachment.stub(:find).and_return(attachment)
+        allow(attachment).to receive(:restricted?).and_return(true)
+        allow(Attachment).to receive(:find).and_return(attachment)
       end
 
       context 'as anonymous user' do
         it "should not be possible to download attachments from restricted pages" do
           get :download, :id => attachment.id
-          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
 
         it "should not be possible to see attachments from restricted pages" do
           get :show, :id => attachment.id
-          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
 
@@ -33,12 +33,12 @@ module Alchemy
 
         it "should be possible to download attachments from restricted pages" do
           get :download, :id => attachment.id
-          response.status.should == 200
+          expect(response.status).to eq(200)
         end
 
         it "should be possible to see attachments from restricted pages" do
           get :show, :id => attachment.id
-          response.status.should == 200
+          expect(response.status).to eq(200)
         end
       end
     end

data/spec/controllers/contents_controller_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Alchemy
+  describe ContentsController do
+    let(:page)    { build_stubbed(:page) }
+    let(:element) { build_stubbed(:element, page: page, position: 1) }
+    let(:content) { build_stubbed(:content, element: element) }
+
+    describe '#show' do
+      before { expect(Content).to receive(:find).and_return(content) }
+
+      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: content.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/elements_controller_spec.rb

@@ -8,10 +8,9 @@ module Alchemy
     let(:restricted_element)  { FactoryGirl.create(:element, :page => restricted_page, :name => 'download') }
 
     describe '#show' do
-
       it "should render available elements" do
         get :show, :id => element.id
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
 
       it "should raise ActiveRecord::RecordNotFound error for trashed elements" do
@@ -35,11 +34,18 @@ module Alchemy
 
         it "should render elements of restricted pages" do
           get :show, :id => restricted_element.id
-          response.status.should == 200
+          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

@@ -2,10 +2,11 @@ require 'spec_helper'
 
 module Alchemy
   describe MessagesController do
+    let(:page) { mock_model('Page') }
 
     before do
       controller.instance_variable_set(:@page, page)
-      controller.stub(:get_page).and_return(page)
+      allow(controller).to receive(:get_page).and_return(page)
     end
 
     describe "#index" do
@@ -25,7 +26,7 @@ module Alchemy
 
     describe "#create" do
       before do
-        controller.stub(:params).and_return({message: {email: ''}})
+        allow(controller).to receive(:params).and_return({message: {email: ''}})
       end
 
       let(:page)    { mock_model('Page', get_language_root: mock_model('Page')) }
@@ -39,14 +40,14 @@ module Alchemy
       context "if validation of message" do
 
         before do
-          Element.stub(:find_by).and_return(element)
-          element.stub(:ingredient).with(:success_page).and_return('thank-you')
-          Message.any_instance.stub(:contact_form_id).and_return(1)
+          allow(Element).to receive(:find_by).and_return(element)
+          allow(element).to receive(:ingredient).with(:success_page).and_return('thank-you')
+          allow_any_instance_of(Message).to receive(:contact_form_id).and_return(1)
         end
 
         context "failed" do
           before do
-            Message.any_instance.stub(:valid?).and_return(false)
+            allow_any_instance_of(Message).to receive(:valid?).and_return(false)
           end
 
           it "should render 'alchemy/pages/show' template" do
@@ -56,38 +57,38 @@ module Alchemy
 
         context "succeeded" do
           before do
-            Message.any_instance.stub(:valid?).and_return(true)
-            Messages.stub_chain(:contact_form_mail, :deliver).and_return(true)
+            allow_any_instance_of(Message).to receive(:valid?).and_return(true)
+            allow(Messages).to receive(:contact_form_mail).and_return double(deliver: true)
           end
 
           it "Messages should call Messages#contact_form_mail to send the email" do
-            Messages.should_receive(:contact_form_mail)
+            expect(Messages).to receive(:contact_form_mail)
             post :create
           end
 
           describe '#mail_to' do
             context "with element having mail_to ingredient" do
               before do
-                element.stub(:ingredient).with(:mail_to).and_return('peter@schroeder.de')
+                allow(element).to receive(:ingredient).with(:mail_to).and_return('peter@schroeder.de')
                 message
-                Message.stub(:new).and_return(message)
+                allow(Message).to receive(:new).and_return(message)
               end
 
               it "returns the ingredient" do
-                Messages.should_receive(:contact_form_mail).with(message, 'peter@schroeder.de', '', '')
+                expect(Messages).to receive(:contact_form_mail).with(message, 'peter@schroeder.de', '', '')
                 post :create
               end
             end
 
             context "with element having no mail_to ingredient" do
               before do
-                element.stub(:ingredient).with(:mail_to).and_return(nil)
+                allow(element).to receive(:ingredient).with(:mail_to).and_return(nil)
                 message
-                Message.stub(:new).and_return(message)
+                allow(Message).to receive(:new).and_return(message)
               end
 
               it "returns the config value" do
-                Messages.should_receive(:contact_form_mail).with(message, 'your.mail@your-domain.com', '', '')
+                expect(Messages).to receive(:contact_form_mail).with(message, 'your.mail@your-domain.com', '', '')
                 post :create
               end
             end
@@ -96,26 +97,26 @@ module Alchemy
           describe '#mail_from' do
             context "with element having mail_from ingredient" do
               before do
-                element.stub(:ingredient).with(:mail_from).and_return('peter@schroeder.de')
+                allow(element).to receive(:ingredient).with(:mail_from).and_return('peter@schroeder.de')
                 message
-                Message.stub(:new).and_return(message)
+                allow(Message).to receive(:new).and_return(message)
               end
 
               it "returns the ingredient" do
-                Messages.should_receive(:contact_form_mail).with(message, '', 'peter@schroeder.de', '')
+                expect(Messages).to receive(:contact_form_mail).with(message, '', 'peter@schroeder.de', '')
                 post :create
               end
             end
 
             context "with element having no mail_from ingredient" do
               before do
-                element.stub(:ingredient).with(:mail_from).and_return(nil)
+                allow(element).to receive(:ingredient).with(:mail_from).and_return(nil)
                 message
-                Message.stub(:new).and_return(message)
+                allow(Message).to receive(:new).and_return(message)
               end
 
               it "returns the config value" do
-                Messages.should_receive(:contact_form_mail).with(message, '', 'your.mail@your-domain.com', '')
+                expect(Messages).to receive(:contact_form_mail).with(message, '', 'your.mail@your-domain.com', '')
                 post :create
               end
             end
@@ -124,26 +125,26 @@ module Alchemy
           describe '#subject' do
             context "with element having subject ingredient" do
               before do
-                element.stub(:ingredient).with(:subject).and_return('A new message')
+                allow(element).to receive(:ingredient).with(:subject).and_return('A new message')
                 message
-                Message.stub(:new).and_return(message)
+                allow(Message).to receive(:new).and_return(message)
               end
 
               it "returns the ingredient" do
-                Messages.should_receive(:contact_form_mail).with(message, '', '', 'A new message')
+                expect(Messages).to receive(:contact_form_mail).with(message, '', '', 'A new message')
                 post :create
               end
             end
 
             context "with element having no subject ingredient" do
               before do
-                element.stub(:ingredient).with(:subject).and_return(nil)
+                allow(element).to receive(:ingredient).with(:subject).and_return(nil)
                 message
-                Message.stub(:new).and_return(message)
+                allow(Message).to receive(:new).and_return(message)
               end
 
               it "returns the config value" do
-                Messages.should_receive(:contact_form_mail).with(message, '', '', 'A new contact form message')
+                expect(Messages).to receive(:contact_form_mail).with(message, '', '', 'A new contact form message')
                 post :create
               end
             end
@@ -152,7 +153,7 @@ module Alchemy
           describe "#redirect_to_success_page" do
             context "if 'success_page' ingredient of element is set with urlname" do
               before do
-                element.stub(:ingredient).with(:success_page).and_return('success-page')
+                allow(element).to receive(:ingredient).with(:success_page).and_return('success-page')
               end
 
               it "should redirect to the given urlname" do
@@ -162,13 +163,13 @@ module Alchemy
 
             context "if 'success_page' ingredient of element is not set" do
               before do
-                element.stub(:ingredient).with(:success_page).and_return(nil)
+                allow(element).to receive(:ingredient).with(:success_page).and_return(nil)
               end
 
               context "but mailer_config['forward_to_page'] is true and mailer_config['mail_success_page'] is set" do
                 before do
-                  controller.stub(:mailer_config).and_return({'forward_to_page' => true, 'mail_success_page' => 'mailer-config-success-page'})
-                  Page.stub_chain(:find_by, :urlname).and_return('mailer-config-success-page')
+                  allow(controller).to receive(:mailer_config).and_return({'forward_to_page' => true, 'mail_success_page' => 'mailer-config-success-page'})
+                  allow(Page).to receive(:find_by).and_return double(urlname: 'mailer-config-success-page')
                 end
 
                 it "redirect to the given success page" do
@@ -180,12 +181,12 @@ module Alchemy
                 let(:language) { mock_model('Language', code: 'en', pages: double(find_by: build_stubbed(:page))) }
 
                 before do
-                  controller.stub(:mailer_config).and_return({})
-                  Language.stub_chain(:current_root_page, :urlname).and_return('lang-root')
+                  allow(controller).to receive(:mailer_config).and_return({})
+                  allow(Language).to receive(:current_root_page).and_return double(urlname: 'lang-root')
                 end
 
                 it "should redirect to the language root page" do
-                  Language.stub(current: language)
+                  expect(Language).to receive(:current).and_return(language)
                   expect(post :create).to redirect_to(show_page_path(urlname: 'lang-root'))
                 end
               end