alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

data/spec/controllers/alchemy/attachments_controller_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe AttachmentsController do
-    let(:attachment) { build_stubbed(:alchemy_attachment) }
-
-    it "should raise ActiveRecord::RecordNotFound for requesting not existing attachments" do
-      expect { alchemy_get :download, id: 0 }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-
-    context 'with public attachment' do
-      before do
-        allow(Attachment).to receive(:find).and_return(attachment)
-      end
-
-      it "sends download as attachment." do
-        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
-        alchemy_get :show, id: attachment.id
-        expect(response.status).to eq(200)
-        expect(response.headers['Content-Disposition']).to match(/inline/)
-      end
-    end
-
-    context 'with restricted attachment' do
-      before do
-        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
-          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
-          alchemy_get :show, id: attachment.id
-          expect(response.status).to eq(302)
-          expect(response).to redirect_to(Alchemy.login_path)
-        end
-      end
-
-      context "as member user" do
-        before { authorize_user(build(:alchemy_dummy_user)) }
-
-        it "should be possible to download attachments from restricted pages" do
-          alchemy_get :download, id: attachment.id
-          expect(response.status).to eq(200)
-        end
-
-        it "should be possible to see attachments from restricted pages" do
-          alchemy_get :show, id: attachment.id
-          expect(response.status).to eq(200)
-        end
-      end
-    end
-  end
-end

data/spec/controllers/alchemy/base_controller_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe BaseController do
-    describe '#set_locale' do
-      context 'with Language.current set' do
-        let(:language) { create(:alchemy_language, :klingon) }
-
-        before { Alchemy::Language.current = language }
-
-        it "sets the ::I18n.locale to current language code" do
-          controller.send(:set_locale)
-          expect(::I18n.locale).to eq(language.code.to_sym)
-        end
-      end
-
-      context 'without Language.current set' do
-        before { Alchemy::Language.current = nil }
-
-        it "sets the ::I18n.locale to default language code" do
-          controller.send(:set_locale)
-          expect(::I18n.locale).to eq(Language.default.code.to_sym)
-        end
-      end
-    end
-
-    describe "#configuration" do
-      it "returns certain configuration options" do
-        allow(Config).to receive(:show).and_return({"some_option" => true})
-        expect(controller.configuration(:some_option)).to eq(true)
-      end
-    end
-
-    describe "#multi_language?" do
-      context "if more than one published language exists" do
-        it "returns true" do
-          allow(Alchemy::Language).to receive(:published).and_return double(count: 2)
-          expect(controller.multi_language?).to eq(true)
-        end
-      end
-
-      context "if less than two published languages exists" do
-        it "returns false" do
-          allow(Alchemy::Language).to receive(:published).and_return double(count: 1)
-          expect(controller.multi_language?).to eq(false)
-        end
-      end
-    end
-
-    describe "#prefix_locale?" do
-      subject(:prefix_locale?) { controller.prefix_locale? }
-
-      context "if multi_language? is true" do
-        before do
-          expect(controller).to receive(:multi_language?) { true }
-        end
-
-        context "and current language is not the default locale" do
-          before do
-            allow(Alchemy::Language).to receive(:current) { double(code: 'en') }
-            allow(::I18n).to receive(:default_locale) { :de }
-          end
-
-          it { expect(prefix_locale?).to be(true) }
-        end
-
-        context "and current language is the default locale" do
-          before do
-            allow(Alchemy::Language).to receive(:current) { double(code: 'de') }
-            allow(::I18n).to receive(:default_locale) { :de }
-          end
-
-          it { expect(prefix_locale?).to be(false) }
-        end
-
-        context "and passed in locale is not the default locale" do
-          subject(:prefix_locale?) { controller.prefix_locale?('en') }
-
-          before do
-            allow(::I18n).to receive(:default_locale) { :de }
-          end
-
-          it { expect(prefix_locale?).to be(true) }
-        end
-
-        context "and passed in locale is the default locale" do
-          subject(:prefix_locale?) { controller.prefix_locale?('de') }
-
-          before do
-            allow(::I18n).to receive(:default_locale) { :de }
-          end
-
-          it { expect(prefix_locale?).to be(false) }
-        end
-      end
-
-      context "if multi_language? is false" do
-        before do
-          expect(controller).to receive(:multi_language?) { false }
-        end
-
-        it { expect(prefix_locale?).to be(false) }
-      end
-    end
-  end
-end

data/spec/controllers/alchemy/elements_controller_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe ElementsController do
-    let(:public_page)         { create(:alchemy_page, :public) }
-    let(:element)             { create(:alchemy_element, page: public_page, name: 'download') }
-    let(:restricted_page)     { create(:alchemy_page, :public, restricted: true) }
-    let(:restricted_element)  { create(:alchemy_element, page: restricted_page, name: 'download') }
-
-    describe '#show' do
-      it "should render available elements" do
-        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 {
-          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 {
-          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 {
-            alchemy_get :show, id: restricted_element.id
-          }.to raise_error(ActiveRecord::RecordNotFound)
-        end
-      end
-
-      context "for member user" do
-        before { authorize_user(build(:alchemy_dummy_user)) }
-
-        it "should render elements of restricted pages" do
-          alchemy_get :show, id: restricted_element.id
-          expect(response.status).to eq(200)
-        end
-      end
-    end
-  end
-end

data/spec/controllers/alchemy/messages_controller_spec.rb

@@ -1,204 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe MessagesController do
-    let(:page) { mock_model('Page') }
-
-    before do
-      controller.instance_variable_set(:@page, page)
-      allow(controller).to receive(:get_page).and_return(page)
-    end
-
-    describe "#index" do
-      let(:page) { mock_model('Page', {urlname: 'contact', page_layout: 'contact'}) }
-
-      it "should redirect to @page" do
-        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
-        alchemy_get :new
-        expect(alchemy_get(:new)).to render_template('alchemy/pages/show')
-      end
-    end
-
-    describe "#create" do
-      before do
-        allow(controller).to receive(:params).and_return({message: {email: ''}})
-      end
-
-      let(:page)    { mock_model('Page', get_language_root: mock_model('Page')) }
-      let(:element) { mock_model('Element', page: page, ingredient: '') }
-      let(:message) { Message.new }
-
-      it "should raise ActiveRecord::RecordNotFound if element of contactform could not be found" do
-        expect { alchemy_post :create }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-
-      context "if validation of message" do
-        before do
-          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
-            allow_any_instance_of(Message).to receive(:valid?).and_return(false)
-          end
-
-          it "should render 'alchemy/pages/show' template" do
-            expect(alchemy_post(:create)).to render_template('alchemy/pages/show')
-          end
-        end
-
-        context "succeeded" do
-          before do
-            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
-            expect(Messages).to receive(:contact_form_mail)
-            alchemy_post :create
-          end
-
-          describe '#mail_to' do
-            context "with element having mail_to ingredient" do
-              before do
-                allow(element).to receive(:ingredient).with(:mail_to).and_return('peter@schroeder.de')
-                message
-                allow(Message).to receive(:new).and_return(message)
-              end
-
-              it "returns the ingredient" do
-                expect(Messages).to receive(:contact_form_mail).with(message, 'peter@schroeder.de', '', '')
-                alchemy_post :create
-              end
-            end
-
-            context "with element having no mail_to ingredient" do
-              before do
-                allow(element).to receive(:ingredient).with(:mail_to).and_return(nil)
-                message
-                allow(Message).to receive(:new).and_return(message)
-              end
-
-              it "returns the config value" do
-                expect(Messages).to receive(:contact_form_mail).with(message, 'your.mail@your-domain.com', '', '')
-                alchemy_post :create
-              end
-            end
-          end
-
-          describe '#mail_from' do
-            context "with element having mail_from ingredient" do
-              before do
-                allow(element).to receive(:ingredient).with(:mail_from).and_return('peter@schroeder.de')
-                message
-                allow(Message).to receive(:new).and_return(message)
-              end
-
-              it "returns the ingredient" do
-                expect(Messages).to receive(:contact_form_mail).with(message, '', 'peter@schroeder.de', '')
-                alchemy_post :create
-              end
-            end
-
-            context "with element having no mail_from ingredient" do
-              before do
-                allow(element).to receive(:ingredient).with(:mail_from).and_return(nil)
-                message
-                allow(Message).to receive(:new).and_return(message)
-              end
-
-              it "returns the config value" do
-                expect(Messages).to receive(:contact_form_mail).with(message, '', 'your.mail@your-domain.com', '')
-                alchemy_post :create
-              end
-            end
-          end
-
-          describe '#subject' do
-            context "with element having subject ingredient" do
-              before do
-                allow(element).to receive(:ingredient).with(:subject).and_return('A new message')
-                message
-                allow(Message).to receive(:new).and_return(message)
-              end
-
-              it "returns the ingredient" do
-                expect(Messages).to receive(:contact_form_mail).with(message, '', '', 'A new message')
-                alchemy_post :create
-              end
-            end
-
-            context "with element having no subject ingredient" do
-              before do
-                allow(element).to receive(:ingredient).with(:subject).and_return(nil)
-                message
-                allow(Message).to receive(:new).and_return(message)
-              end
-
-              it "returns the config value" do
-                expect(Messages).to receive(:contact_form_mail).with(message, '', '', 'A new contact form message')
-                alchemy_post :create
-              end
-            end
-          end
-
-          describe "#redirect_to_success_page" do
-            context "if 'success_page' ingredient of element is set with urlname" do
-              before do
-                allow(element).to receive(:ingredient).with(:success_page).and_return('success-page')
-              end
-
-              it "should redirect to the given urlname" do
-                expect(
-                  alchemy_post(:create)
-                ).to redirect_to(show_page_path(urlname: 'success-page'))
-              end
-            end
-
-            context "if 'success_page' ingredient of element is not set" do
-              before do
-                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
-                  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
-                  expect(
-                    alchemy_post(:create)
-                  ).to redirect_to(show_page_path(urlname: 'mailer-config-success-page'))
-                end
-              end
-
-              context "and mailer_config has no instructions for success_page" do
-                let(:language) { mock_model('Language', code: 'en', locale: 'en', pages: double(find_by: build_stubbed(:alchemy_page))) }
-
-                before do
-                  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
-                  allow(Language).to receive(:current).and_return(language)
-                  expect(
-                    alchemy_post(:create)
-                  ).to redirect_to(show_page_path(urlname: 'lang-root'))
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/controllers/alchemy/on_page_layout_mixin_spec.rb

@@ -1,330 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Alchemy::PagesController, 'OnPageLayout mixin', type: :controller do
-  before(:all) do
-    ApplicationController.send(:extend, Alchemy::OnPageLayout)
-  end
-
-  let(:page) { create(:alchemy_page, :public, page_layout: 'standard') }
-
-  describe '.on_page_layout' do
-    context 'with :all as argument for page_layout' do
-      before do
-        ApplicationController.class_eval do
-          on_page_layout(:all) do
-            @on_all_layouts = @page.page_layout
-          end
-        end
-      end
-
-      context "for show action" do
-        %w(standard news).each do |page_layout|
-          it "runs callback on #{page_layout} layout" do
-            page = create(:alchemy_page, :public, page_layout: page_layout)
-            alchemy_get :show, urlname: page.urlname
-            expect(assigns(:on_all_layouts)).to eq(page_layout)
-          end
-        end
-      end
-
-      context "for index action" do
-        %w(standard news).each do |page_layout|
-          it "runs callback on #{page_layout} layout" do
-            create(:alchemy_page, :language_root, page_layout: page_layout)
-
-            alchemy_get :index
-            expect(assigns(:on_all_layouts)).to eq(page_layout)
-          end
-        end
-      end
-    end
-
-    context 'with :standard as argument for page_layout' do
-      before do
-        ApplicationController.class_eval do
-          on_page_layout(:standard) do
-            @successful_for_standard = true
-          end
-        end
-      end
-
-      context 'and page having standard layout' do
-        context "for show action" do
-          let(:page) { create(:alchemy_page, :public, page_layout: 'standard') }
-
-          it 'runs the callback' do
-            alchemy_get :show, urlname: page.urlname
-            expect(assigns(:successful_for_standard)).to eq(true)
-          end
-        end
-
-        context "for index action" do
-          let!(:page) { create(:alchemy_page, :language_root, page_layout: 'standard') }
-
-          it 'runs the callback' do
-            alchemy_get :index
-            expect(assigns(:successful_for_standard)).to eq(true)
-          end
-        end
-      end
-
-      context 'and page not having standard layout' do
-        let(:page) { create(:alchemy_page, :public, page_layout: 'news') }
-
-        context "for show action" do
-          it "doesn't run the callback" do
-            alchemy_get :show, urlname: page.urlname
-            expect(assigns(:successful_for_standard)).to eq(nil)
-          end
-        end
-
-        context "for index action" do
-          let!(:page) { create(:alchemy_page, :language_root, page_layout: 'news') }
-
-          it "doesn't run the callback" do
-            alchemy_get :index
-            expect(assigns(:successful_for_standard)).to eq(nil)
-          end
-        end
-      end
-    end
-
-    context 'when defining two callbacks for different page layouts' do
-      context "for show action" do
-        before do
-          ApplicationController.class_eval do
-            on_page_layout(:standard) do
-              @urlname = @page.urlname
-            end
-
-            on_page_layout(:news) do
-              @urlname = @page.urlname
-            end
-          end
-        end
-
-        %w(standard news).each do |page_layout|
-          it "runs both callbacks for #{page_layout} layout" do
-            page = create(:alchemy_page, :public, page_layout: page_layout)
-
-            alchemy_get :show, urlname: page.urlname
-            expect(assigns(:urlname)).to eq(page.urlname)
-          end
-        end
-      end
-
-      context "for index action" do
-        before do
-          ApplicationController.class_eval do
-            on_page_layout(:standard) do
-              @page_layout = @page.page_layout
-            end
-
-            on_page_layout(:news) do
-              @page_layout = @page.page_layout
-            end
-          end
-        end
-
-        %w(standard news).each do |page_layout|
-          it "runs both callbacks on #{page_layout} layout" do
-            create(:alchemy_page, :language_root, page_layout: page_layout)
-
-            alchemy_get :index
-            expect(assigns(:page_layout)).to eq(page_layout)
-          end
-        end
-      end
-    end
-
-    context 'when defining two callbacks for the same page_layout' do
-      before do
-        ApplicationController.class_eval do
-          on_page_layout(:standard) do
-            @successful_for_standard_first = true
-          end
-
-          on_page_layout(:standard) do
-            @successful_for_standard_second = true
-          end
-        end
-      end
-
-      context "for show action" do
-        it 'runs both callbacks' do
-          alchemy_get :show, urlname: page.urlname
-          expect(assigns(:successful_for_standard_first)).to eq(true)
-          expect(assigns(:successful_for_standard_second)).to eq(true)
-        end
-      end
-
-      context "for index action" do
-        let!(:page) { create(:alchemy_page, :language_root, page_layout: 'standard') }
-
-        it 'runs both callbacks' do
-          alchemy_get :index
-          expect(assigns(:successful_for_standard_first)).to eq(true)
-          expect(assigns(:successful_for_standard_second)).to eq(true)
-        end
-      end
-    end
-
-    context 'when block is given' do
-      before do
-        ApplicationController.class_eval do
-          on_page_layout :standard do
-            @successful_for_callback_method = true
-          end
-        end
-      end
-
-      context 'for show action' do
-        it 'evaluates the given block' do
-          alchemy_get :show, urlname: page.urlname
-          expect(assigns(:successful_for_callback_method)).to eq(true)
-        end
-      end
-
-      context 'for index action' do
-        let!(:page) { create(:alchemy_page, :language_root, page_layout: 'standard') }
-
-        it 'evaluates the given block' do
-          alchemy_get :index
-          expect(assigns(:successful_for_callback_method)).to eq(true)
-        end
-      end
-    end
-
-    context 'when callback method name is given' do
-      before do
-        ApplicationController.class_eval do
-          on_page_layout :standard, :run_method
-
-          def run_method
-            @successful_for_callback_method = true
-          end
-        end
-      end
-
-      context 'for show action' do
-        it 'runs the given callback method' do
-          alchemy_get :show, urlname: page.urlname
-          expect(assigns(:successful_for_callback_method)).to eq(true)
-        end
-      end
-
-      context 'for index action' do
-        let!(:page) { create(:alchemy_page, :language_root, page_layout: 'standard') }
-
-        it 'runs the given callback method' do
-          alchemy_get :index
-          expect(assigns(:successful_for_callback_method)).to eq(true)
-        end
-      end
-    end
-
-    context 'when neither callback method name nor block given' do
-      it 'raises an ArgumentError' do
-        expect do
-          ApplicationController.class_eval do
-            on_page_layout :standard
-          end
-        end.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'when passing two page_layouts for a callback' do
-      before do
-        ApplicationController.class_eval do
-          on_page_layout([:standard, :news]) do
-            @successful = @page.page_layout
-          end
-        end
-      end
-
-      %w(standard news).each do |page_layout|
-        it 'evaluates the given callback on both page_layouts for show action' do
-          page = create(:alchemy_page, :public, page_layout: page_layout)
-
-          alchemy_get :show, urlname: page.urlname
-          expect(assigns(:successful)).to eq(page_layout)
-        end
-      end
-
-      %w(standard news).each do |page_layout|
-        it 'evaluates the given callback on both page_layouts for index action' do
-          create(:alchemy_page, :language_root, page_layout: page_layout)
-
-          alchemy_get :index
-          expect(assigns(:successful)).to eq(page_layout)
-        end
-      end
-    end
-  end
-end
-
-RSpec.describe ApplicationController, 'OnPageLayout mixin', type: :controller do
-  before(:all) do
-    ApplicationController.send(:extend, Alchemy::OnPageLayout)
-  end
-
-  controller do
-    def index
-      @another_controller = true
-      render nothing: true
-    end
-  end
-
-  context 'in another controller' do
-    before do
-      ApplicationController.class_eval do
-        on_page_layout(:standard) do
-          @successful_for_another_controller = true
-        end
-      end
-    end
-
-    it 'callback does not run' do
-      get :index
-      expect(assigns(:another_controller)).to eq(true)
-      expect(assigns(:successful_for_another_controller)).to eq(nil)
-    end
-  end
-end
-
-RSpec.describe Alchemy::Admin::PagesController, 'OnPageLayout mixin', type: :controller do
-  before(:all) do
-    ApplicationController.send(:extend, Alchemy::OnPageLayout)
-  end
-
-  context 'in admin/pages_controller' do
-    before do
-      ApplicationController.class_eval do
-        on_page_layout(:standard) do
-          @successful_for_alchemy_admin_pages_controller = true
-        end
-      end
-      authorize_user(:as_admin)
-    end
-
-    context "for show action" do
-      let(:page) { create(:alchemy_page, page_layout: 'standard') }
-
-      it 'callback also runs' do
-        alchemy_get :show, id: page.id
-        expect(assigns(:successful_for_alchemy_admin_pages_controller)).to be(true)
-      end
-    end
-
-    context "for index action" do
-      it 'does not run callback' do
-        alchemy_get :index
-        expect(assigns(:successful_for_alchemy_admin_pages_controller)).to be(nil)
-      end
-    end
-  end
-
-  after(:all) do
-    Alchemy::OnPageLayout.instance_variable_set(:@callbacks, nil)
-  end
-end