alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

data/spec/features/admin/site_select_feature_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe 'Site select' do
-  before do
-    authorize_user(:as_admin)
-  end
-
-  it "does not display the site change" do
-    visit admin_dashboard_path
-    expect(page).not_to have_select('change_site')
-  end
-
-  context "multiple sites" do
-    let!(:a_site) { create(:alchemy_site) }
-
-    it "contains all sites in a selectbox" do
-      visit admin_dashboard_path
-      expect(page).to have_select('change_site', options: [Alchemy::Site.default.name, a_site.name], selected: Alchemy::Site.default.name)
-    end
-
-    context 'when requesting non-default site' do
-      it "provides the correct site" do
-        visit admin_pages_path(site_id: a_site.id)
-        expect(page).to have_select('change_site', selected: a_site.name)
-
-        visit admin_dashboard_path
-        expect(page).to have_select('change_site', selected: a_site.name)
-      end
-    end
-  end
-end

data/spec/features/admin/tinymce_feature_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe 'TinyMCE Editor' do
-  before do
-    authorize_user(:as_admin)
-  end
-
-  it 'base path should be set to tinymce asset folder' do
-    visit admin_dashboard_path
-    expect(page).to have_content <<-TINYMCE
-var tinyMCEPreInit = {
-  base: '/assets/tinymce',
-  suffix: '.min'
-};
-TINYMCE
-  end
-
-  context 'with asset host' do
-    before do
-      expect(ActionController::Base.config).to receive(:asset_host_set?).and_return(true)
-    end
-
-    it 'base path should be set to tinymce asset folder' do
-      visit admin_dashboard_path
-      expect(page).to have_content <<-TINYMCE
-var tinyMCEPreInit = {
-  base: 'http://www.example.com/assets/tinymce',
-  suffix: '.min'
-};
-TINYMCE
-    end
-  end
-end

data/spec/features/navigation_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe "Dummy App" do
-  include Capybara::DSL
-
-  it "should be a valid app" do
-    expect(::Rails.application).to be_a(Dummy::Application)
-  end
-end

data/spec/features/page_feature_spec.rb

@@ -1,186 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe 'Show page feature:' do
-    let!(:default_language) { Language.default }
-
-    let!(:default_language_root) do
-      create(:alchemy_page, :language_root, language: default_language, name: 'Home')
-    end
-
-    let(:public_page) do
-      create(:alchemy_page, :public, visible: true, name: 'Page 1')
-    end
-
-    let(:public_child) do
-      create(:alchemy_page, :public, name: 'Public Child', parent_id: public_page.id)
-    end
-
-    context "When no page is present" do
-      before do
-        Alchemy::Page.delete_all
-      end
-
-      context "and no admin user is present yet" do
-        before do
-          Alchemy.user_class.delete_all
-        end
-
-        it 'shows a welcome page' do
-          visit "/"
-          expect(page).to have_content('Welcome to Alchemy')
-        end
-      end
-    end
-
-    context 'rendered' do
-      let(:public_page) { create(:alchemy_page, :public, do_not_autogenerate: false) }
-      let(:article) { public_page.elements.find_by_name('article') }
-      let(:essence) { article.content_by_name('intro').essence }
-
-      before do
-        essence.update_attributes(body: 'Welcome to Peters Petshop', public: true)
-      end
-
-      it "should include all its elements and contents" do
-        visit "/#{public_page.urlname}"
-        within('div#content div.article div.intro') do
-          expect(page).to have_content('Welcome to Peters Petshop')
-        end
-      end
-    end
-
-    it "should show the navigation with all visible pages" do
-      create(:alchemy_page, :public, visible: true, name: 'Page 1')
-      create(:alchemy_page, :public, visible: true, name: 'Page 2')
-      visit '/'
-      within('div#navigation ul') do
-        expect(page).to have_selector('li a[href="/page-1"], li a[href="/page-2"]')
-      end
-    end
-
-    describe "Handling of non-existing pages" do
-      before do
-        # We need a admin user or the signup page will show up
-        allow(Alchemy.user_class).to receive(:admins).and_return([1, 2])
-      end
-
-      it "should render public/404.html" do
-        expect {
-          visit "/non-existing-page"
-        }.to raise_error(ActionController::RoutingError)
-      end
-    end
-
-    context "with invalid byte code char in urlname parameter" do
-      it "should raise BadRequest (400) error" do
-        expect { visit '/%ed' }.to raise_error(ActionController::BadRequest)
-      end
-    end
-
-    describe "menubar" do
-      context "rendering for guest users" do
-        it "is prohibited" do
-          visit "/#{public_page.urlname}"
-          within('body') { expect(page).not_to have_selector('#alchemy_menubar') }
-        end
-      end
-
-      context "rendering for members" do
-        it "is prohibited" do
-          authorize_user(build(:alchemy_dummy_user))
-          visit "/#{public_page.urlname}"
-          within('body') { expect(page).not_to have_selector('#alchemy_menubar') }
-        end
-      end
-
-      context "rendering for authors" do
-        it "is allowed" do
-          authorize_user(:as_author)
-          visit "/#{public_page.urlname}"
-          within('body') { expect(page).to have_selector('#alchemy_menubar') }
-        end
-      end
-
-      context "rendering for editors" do
-        it "is allowed" do
-          authorize_user(:as_editor)
-          visit "/#{public_page.urlname}"
-          within('body') { expect(page).to have_selector('#alchemy_menubar') }
-        end
-      end
-
-      context "rendering for admins" do
-        it "is allowed" do
-          authorize_user(:as_admin)
-          visit "/#{public_page.urlname}"
-          within('body') { expect(page).to have_selector('#alchemy_menubar') }
-        end
-      end
-
-      context "contains" do
-        before do
-          authorize_user(:as_admin)
-          visit "/#{public_page.urlname}"
-        end
-
-        it "a link to the admin area" do
-          within('#alchemy_menubar') do
-            expect(page).to have_selector("li a[href='#{alchemy.admin_dashboard_url}']")
-          end
-        end
-
-        it "a link to edit the current page" do
-          within('#alchemy_menubar') do
-            expect(page).to \
-              have_selector("li a[href='#{alchemy.edit_admin_page_url(public_page)}']")
-          end
-        end
-
-        it "a form and button to logout of alchemy" do
-          within('#alchemy_menubar') do
-            expect(page).to \
-              have_selector("li form[action='#{Alchemy.logout_path}'], li button[type='submit']")
-          end
-        end
-      end
-    end
-
-    describe 'navigation rendering' do
-      context 'with page having an external url without protocol' do
-        let!(:external_page) do
-          create(:alchemy_page, urlname: 'google.com', page_layout: 'external', visible: true)
-        end
-
-        it "adds an prefix to url" do
-          visit "/#{public_page.urlname}"
-          within '#navigation' do
-            expect(page.body).to match('http://google.com')
-          end
-        end
-      end
-    end
-
-    describe 'accessing restricted pages' do
-      let!(:restricted_page) { create(:alchemy_page, :restricted, public: true) }
-
-      context 'as a guest user' do
-        it "I am not able to visit the page" do
-          visit restricted_page.urlname
-          expect(current_path).to eq(Alchemy.login_path)
-        end
-      end
-
-      context 'as a member user' do
-        before do
-          authorize_user(create(:alchemy_dummy_user))
-        end
-
-        it "I am able to visit the page" do
-          visit restricted_page.urlname
-          expect(current_path).to eq("/#{restricted_page.urlname}")
-        end
-      end
-    end
-  end
-end

data/spec/features/page_redirects_spec.rb

@@ -1,358 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe 'Requesting a page' do
-    let!(:default_language) { Language.default }
-
-    let!(:default_language_root) do
-      create(:alchemy_page, :language_root, language: default_language, name: 'Home')
-    end
-
-    let(:public_page) do
-      create(:alchemy_page, :public, visible: true, name: 'Page 1')
-    end
-
-    let(:public_child) do
-      create(:alchemy_page, :public, name: 'Public Child', parent_id: public_page.id)
-    end
-
-    context "in multi language mode" do
-      let(:second_page) { create(:alchemy_page, :public, name: 'Second Page') }
-
-      let(:legacy_url) do
-        LegacyPageUrl.create(
-          urlname: 'index.php?option=com_content&view=article&id=48&Itemid=69',
-          page: second_page
-        )
-      end
-
-      before do
-        allow_any_instance_of(PagesController).to receive(:multi_language?).and_return(true)
-      end
-
-      context 'if language params are given' do
-        context "and page locale is default locale" do
-          it "redirects to unprefixed locale url" do
-            allow(::I18n).to receive(:default_locale) { public_page.language_code.to_sym }
-            visit("/#{public_page.language_code}/#{public_page.urlname}")
-            expect(page.current_path).to eq("/#{public_page.urlname}")
-          end
-        end
-
-        context "and page locale is not default locale" do
-          it "does not redirect" do
-            allow(::I18n).to receive(:default_locale).and_return(:de)
-            visit("/#{public_page.language_code}/#{public_page.urlname}")
-            expect(page.current_path).to eq("/#{public_page.language_code}/#{public_page.urlname}")
-          end
-        end
-      end
-
-      context 'if no language params are given' do
-        context "and page locale is default locale" do
-          it "doesn't prepend the url with the locale string" do
-            allow(::I18n).to receive(:default_locale) { public_page.language_code.to_sym }
-            visit("/#{public_page.urlname}")
-            expect(page.current_path).to eq("/#{public_page.urlname}")
-          end
-
-          it "redirects legacy url with unknown format & query string without locale prefix" do
-            allow(::I18n).to receive(:default_locale) { second_page.language_code.to_sym }
-            visit "/#{legacy_url.urlname}"
-            uri = URI.parse(page.current_url)
-            expect(uri.query).to be_nil
-            expect(uri.request_uri).to eq("/#{second_page.urlname}")
-          end
-        end
-
-        context "and page locale is not default locale" do
-          before do
-            allow(::I18n).to receive(:default_locale).and_return(:de)
-          end
-
-          it "redirects to url with the locale prefixed" do
-            visit("/#{public_page.urlname}")
-            expect(page.current_path).to eq("/en/#{public_page.urlname}")
-          end
-
-          it "redirects legacy url with unknown format & query string with locale prefix" do
-            visit "/#{legacy_url.urlname}"
-            uri = URI.parse(page.current_url)
-            expect(uri.query).to be_nil
-            expect(uri.request_uri).to eq("/en/#{second_page.urlname}")
-          end
-        end
-      end
-
-      context "if requested page is unpublished" do
-        before do
-          public_page.update_attributes(
-            public: false,
-            visible: false,
-            name: 'Not Public',
-            urlname: ''
-          )
-          public_child
-        end
-
-        it "redirects to public child" do
-          visit "/not-public"
-          expect(page.current_path).to eq("/public-child")
-        end
-
-        context "with only unpublished pages in page tree" do
-          before do
-            public_child.update_attributes(public: false)
-          end
-
-          it "should raise not found error" do
-            expect {
-              visit "/not-public"
-            }.to raise_error(ActionController::RoutingError)
-          end
-        end
-
-        context "if page locale is the default locale" do
-          it "redirects to public child with prefixed locale" do
-            allow(::I18n).to receive(:default_locale).and_return(:de)
-            visit "/not-public"
-            expect(page.current_path).to eq("/en/public-child")
-          end
-        end
-      end
-
-      context "if requested url is the index url" do
-        context 'and redirect_index is set to true' do
-          before do
-            allow(Config).to receive(:get) do |arg|
-              arg == :redirect_index ? true : Config.parameter(arg)
-            end
-            if Alchemy.version == "4.0.0.rc1"
-              raise "Remove deprecated `redirect_index` configuration!"
-            end
-            ActiveSupport::Deprecation.silenced = true
-          end
-
-          after do
-            ActiveSupport::Deprecation.silenced = false
-          end
-
-          context "and if page locale is the default locale" do
-            it "redirects to the default language root page without prefixed locale" do
-              visit '/'
-              expect(page.current_path).to eq('/home')
-            end
-
-            context "having additional parameter" do
-              it "redirects to the default language root page with prefixed locale while keeping the additional params" do
-                visit '/?search=kitten'
-                expect(page.current_url).to eq('http://www.example.com/home?search=kitten')
-              end
-            end
-          end
-
-          context "and if page locale is not the default locale" do
-            before do
-              allow(::I18n).to receive(:default_locale).and_return(:de)
-            end
-
-            it "redirects to the default language root page with prefixed locale" do
-              visit '/'
-              expect(page.current_path).to eq('/en/home')
-            end
-
-            context "having additional parameter" do
-              it "redirects to the default language root page with prefixed locale while keeping the additional params" do
-                visit '/?search=kitten'
-                expect(page.current_url).to eq('http://www.example.com/en/home?search=kitten')
-              end
-            end
-          end
-        end
-
-        context 'and redirect_index is set to false' do
-          before do
-            allow(Config).to receive(:get) do |arg|
-              arg == :redirect_index ? false : Config.parameter(arg)
-            end
-          end
-
-          it "does not redirect" do
-            visit '/'
-            expect(page.current_path).to eq('/')
-          end
-        end
-      end
-
-      context "if requested url is only the language code" do
-        context 'and redirect_index is set to true' do
-          before do
-            allow(Config).to receive(:get) do |arg|
-              arg == :redirect_index ? true : Config.parameter(arg)
-            end
-            if Alchemy.version == "4.0.0.rc1"
-              raise "Remove deprecated `redirect_index` configuration!"
-            end
-            ActiveSupport::Deprecation.silenced = true
-          end
-
-          after do
-            ActiveSupport::Deprecation.silenced = false
-          end
-
-          context "if page locale is the default locale" do
-            it "redirects to pages url without locale prefixed" do
-              visit "/#{default_language.code}"
-              expect(page.current_path).to eq("/home")
-            end
-          end
-
-          context "if page locale is not the default locale" do
-            it "redirects to the default language root url with prefixed locale" do
-              allow(::I18n).to receive(:default_locale).and_return(:de)
-              visit "/#{default_language.code}"
-              expect(page.current_path).to eq('/en/home')
-            end
-          end
-        end
-
-        context 'and redirect_index is set to false' do
-          before do
-            allow(Config).to receive(:get) do |arg|
-              arg == :redirect_index ? false : Config.parameter(arg)
-            end
-          end
-
-          context "if requested locale is the default locale" do
-            before do
-              allow(::I18n).to receive(:default_locale) { default_language.code }
-            end
-
-            it "redirects to '/'" do
-              visit "/#{default_language.code}"
-              expect(page.current_path).to eq('/')
-            end
-          end
-
-          context "if page locale is not the default locale" do
-            before do
-              allow(::I18n).to receive(:default_locale) { :de }
-            end
-
-            it "does not redirect" do
-              visit "/#{default_language.code}"
-              expect(page.current_path).to eq("/#{default_language.code}")
-            end
-          end
-        end
-      end
-
-      it "should keep additional params" do
-        visit "/#{public_page.urlname}?query=Peter"
-        expect(page.current_url).to match(/\?query=Peter/)
-      end
-
-      context "wrong language requested" do
-        before do
-          allow(Alchemy.user_class).to receive(:admins).and_return([1, 2])
-        end
-
-        it "should render 404 if urlname and lang parameter do not belong to same page" do
-          create(:alchemy_language, :klingon)
-          expect {
-            visit "/kl/#{public_page.urlname}"
-          }.to raise_error(ActionController::RoutingError)
-        end
-
-        it "should render 404 if requested language does not exist" do
-          public_page
-          LegacyPageUrl.delete_all
-          expect {
-            visit "/fo/#{public_page.urlname}"
-          }.to raise_error(ActionController::RoutingError)
-        end
-      end
-    end
-
-    context "not in multi language mode" do
-      let(:second_page) { create(:alchemy_page, :public, name: 'Second Page') }
-
-      let(:legacy_url) do
-        LegacyPageUrl.create(
-          urlname: 'index.php?option=com_content&view=article&id=48&Itemid=69',
-          page: second_page
-        )
-      end
-
-      before do
-        allow_any_instance_of(PagesController).to receive(:multi_language?).and_return(false)
-      end
-
-      it "redirects legacy url with unknown format & query string" do
-        visit "/#{legacy_url.urlname}"
-        uri = URI.parse(page.current_url)
-        expect(uri.query).to be_nil
-        expect(uri.request_uri).to eq("/#{second_page.urlname}")
-      end
-
-      it "redirects from nested language code url to normal url" do
-        visit "/en/#{public_page.urlname}"
-        expect(page.current_path).to eq("/#{public_page.urlname}")
-      end
-
-      context "redirects to public child" do
-        before do
-          public_page.update_attributes(
-            public: false,
-            visible: false,
-            name: 'Not Public',
-            urlname: ''
-          )
-          public_child
-        end
-
-        it "if requested page is unpublished" do
-          visit '/not-public'
-          expect(page.current_path).to eq('/public-child')
-        end
-
-        it "with normal url, if requested url has nested language code and is not public" do
-          visit '/en/not-public'
-          expect(page.current_path).to eq('/public-child')
-        end
-      end
-
-      context 'if requested url is index url' do
-        context "when locale is prefixed" do
-          it "redirects to normal url" do
-            visit "/en"
-            expect(page.current_path).to eq("/")
-          end
-        end
-
-        context "when redirect_index is enabled" do
-          before do
-            allow(Config).to receive(:get) do |arg|
-              arg == :redirect_index ? true : Config.parameter(arg)
-            end
-            if Alchemy.version == "4.0.0.rc1"
-              raise "Remove deprecated `redirect_index` configuration!"
-            end
-          end
-
-          it "redirects to pages url" do
-            ActiveSupport::Deprecation.silence do
-              visit '/'
-              expect(page.current_path).to eq('/home')
-            end
-          end
-        end
-      end
-
-      it "should keep additional params" do
-        visit "/en/#{public_page.urlname}?query=Peter"
-        expect(page.current_url).to match(/\?query=Peter/)
-      end
-    end
-  end
-end