alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

data/spec/features/picture_security_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-describe 'Picture renderung security' do
-  let(:picture) { Alchemy::Picture.create(image_file: File.new(File.expand_path('../../fixtures/image.png', __FILE__))) }
-
-  # Prevent the signup view from being rendered.
-  before { allow(Alchemy.user_class).to receive(:count).and_return 1 }
-
-  context "passing no security token" do
-    it 'should return a bad request (400)' do
-      visit "/pictures/#{picture.id}/show/image.png"
-      expect(page.status_code).to eq(400)
-    end
-  end
-
-  context "passing correct security token" do
-    before do
-      visit "/pictures/#{picture.id}/show/image.png?sh=#{picture.security_token}"
-    end
-
-    it 'should return image' do
-      expect(page.body).to match(/PNG/)
-    end
-
-    it 'should return status ok (200)' do
-      expect(page.status_code).to eq(200)
-    end
-  end
-end

data/spec/features/security_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe "Security." do
-  context "If user is not logged in" do
-    it "should see login form" do
-      visit '/admin/dashboard'
-      expect(current_path).to eq(Alchemy.login_path)
-    end
-  end
-
-  context "If ssl is enforced" do
-    before do
-      allow_any_instance_of(Alchemy::BaseController)
-        .to receive(:ssl_required?)
-        .and_return(true)
-      authorize_user(:as_admin)
-    end
-
-    it "redirects every request to https." do
-      visit '/admin/dashboard'
-      expect(current_url).to eq('https://www.example.com/admin/dashboard')
-    end
-  end
-end

data/spec/features/translation_integration_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-describe "Translation integration" do
-  context "in admin backend" do
-    let(:dummy_user) { mock_model(Alchemy.user_class, alchemy_roles: %w(admin), language: 'de') }
-
-    before { authorize_user(dummy_user) }
-
-    it "should be possible to set the locale of the admin backend via params" do
-      visit admin_dashboard_path(locale: 'nl')
-      expect(page).to have_content('Welkom')
-    end
-
-    it "should store the current locale in the session" do
-      visit admin_dashboard_path(locale: 'nl')
-      visit admin_dashboard_path
-      expect(page).to have_content('Welkom')
-    end
-
-    it "should be possible to change the current locale in the session" do
-      visit admin_dashboard_path(locale: 'de')
-      expect(page).to have_content('Willkommen')
-      visit admin_dashboard_path(locale: 'en')
-      expect(page).to have_content('Welcome')
-    end
-
-    context 'with unknown locale' do
-      it "it uses the users default language" do
-        visit admin_dashboard_path(locale: 'ko')
-        expect(page).to have_content('Willkommen')
-      end
-    end
-
-    context "if no other parameter is given" do
-      it "should use the current users language setting" do
-        visit admin_dashboard_path
-        expect(page).to have_content('Willkommen')
-      end
-
-      context "if user has no preferred locale" do
-        let(:dummy_user) { mock_model(Alchemy.user_class, alchemy_roles: %w(admin), language: nil) }
-
-        it "should use the browsers language setting" do
-          page.driver.header 'ACCEPT-LANGUAGE', 'es-ES'
-          visit admin_dashboard_path
-          expect(page).to have_content('Bienvenido')
-        end
-      end
-    end
-  end
-end

data/spec/helpers/alchemy/admin/attachments_helper_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Alchemy::Admin::AttachmentsHelper do
-  describe '#mime_to_human' do
-    context 'when given mime type has no translation' do
-      it "should return the default" do
-        expect(helper.mime_to_human('something')).to eq('File')
-      end
-    end
-
-    it "should return the translation for the given mime type" do
-      expect(helper.mime_to_human('text/plain')).to eq('Text-Document')
-    end
-  end
-end

data/spec/helpers/alchemy/admin/base_helper_spec.rb

@@ -1,280 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Admin::BaseHelper do
-    context "maximum amount of images option" do
-      subject { helper.max_image_count }
-
-      before { helper.instance_variable_set('@options', options) }
-
-      context "with max_images option set to emtpy string" do
-        let(:options) { {max_images: ""} }
-
-        it { is_expected.to eq(nil) }
-      end
-
-      context "with max_images option set to '1'" do
-        let(:options) { {max_images: "1"} }
-
-        it { is_expected.to eq(1) }
-      end
-
-      context "with maximum_amount_of_images option set to emtpy string" do
-        let(:options) { {maximum_amount_of_images: ""} }
-
-        it { is_expected.to eq(nil) }
-      end
-
-      context "with maximum_amount_of_images option set to '1'" do
-        let(:options) { {maximum_amount_of_images: "1"} }
-
-        it { is_expected.to eq(1) }
-      end
-    end
-
-    describe "#merge_params" do
-      before do
-        allow(controller).to receive(:params).and_return({first: '1', second: '2'})
-      end
-
-      it "returns a hash that contains the current params and additional params given as attributes" do
-        expect(helper.merge_params(third: '3', fourth: '4')).to eq({first: '1', second: '2', third: '3', fourth: '4'})
-      end
-    end
-
-    describe "#merge_params_without" do
-      before do
-        allow(controller).to receive(:params).and_return({first: '1', second: '2'})
-      end
-
-      it "can delete a single param" do
-        expect(helper.merge_params_without(:second)).to eq({first: '1'})
-      end
-
-      it "can delete several params" do
-        expect(helper.merge_params_without([:first, :second])).to eq({})
-      end
-
-      it "can delete a param and add new params at the same time" do
-        expect(helper.merge_params_without([:first], {third: '3'})).to eq({second: '2', third: '3'})
-      end
-
-      it "should not change params" do
-        helper.merge_params_without([:first])
-        expect(controller.params).to eq({first: '1', second: '2'})
-      end
-    end
-
-    describe "#merge_params_only" do
-      before do
-        allow(controller).to receive(:params).and_return({first: '1', second: '2', third: '3'})
-      end
-
-      it "can keep a single param" do
-        expect(helper.merge_params_only(:second)).to eq({second: '2'})
-      end
-
-      it "can keep several params" do
-        expect(helper.merge_params_only([:first, :second])).to eq({first: '1', second: '2'})
-      end
-
-      it "can keep a param and add new params at the same time" do
-        expect(helper.merge_params_only([:first], {third: '3'})).to eq({first: '1', third: '3'})
-      end
-
-      it "should not change params" do
-        helper.merge_params_only([:first])
-        expect(controller.params).to eq({first: '1', second: '2', third: '3'})
-      end
-    end
-
-    describe '#toolbar_button' do
-      context "with permission" do
-        before { allow(helper).to receive(:can?).and_return(true) }
-
-        it "renders a toolbar button" do
-          expect(helper.toolbar_button(
-                   url: admin_dashboard_path
-          )).to match /<div.+class="button_with_label/
-        end
-      end
-
-      context "without permission" do
-        before { allow(helper).to receive(:can?).and_return(false) }
-
-        it "returns empty string" do
-          expect(
-            helper.toolbar_button(url: admin_dashboard_path)
-          ).to be_empty
-        end
-      end
-
-      context "with disabled permission check" do
-        before { allow(helper).to receive(:can?).and_return(false) }
-
-        it "returns the button" do
-          expect(
-            helper.toolbar_button(
-              url: admin_dashboard_path,
-              skip_permission_check: true
-            )
-          ).to match /<div.+class="button_with_label/
-        end
-      end
-
-      context "with empty permission option" do
-        before { allow(helper).to receive(:can?).and_return(true) }
-
-        it "returns reads the permission from url" do
-          expect(helper).to receive(:permission_array_from_url)
-          expect(
-            helper.toolbar_button(
-              url: admin_dashboard_path,
-              if_permitted_to: ''
-            )
-          ).not_to be_empty
-        end
-      end
-
-      context "with overlay option set to false" do
-        before do
-          allow(helper).to receive(:can?).and_return(true)
-          expect(helper).to receive(:permission_array_from_url)
-        end
-
-        it "renders a normal link" do
-          button = helper.toolbar_button(
-            url: admin_dashboard_path,
-            overlay: false
-          )
-          expect(button).to match /<a.+href="#{admin_dashboard_path}"/
-          expect(button).not_to match /data-alchemy-overlay/
-        end
-      end
-    end
-
-    describe "#translations_for_select" do
-      it "should return an Array of Arrays with available locales" do
-        allow(Alchemy::I18n).to receive(:available_locales).and_return([:de, :en, :cz, :it])
-        expect(helper.translations_for_select.size).to eq(4)
-      end
-    end
-
-    describe '#clipboard_select_tag_options' do
-      let(:page) { build_stubbed(:alchemy_page) }
-
-      before { helper.instance_variable_set('@page', page) }
-
-      context 'with element items' do
-        let(:element) { build_stubbed(:alchemy_element) }
-        let(:clipboard_items) { [element] }
-
-        it "should include select options with the display name and preview text" do
-          allow(element).to receive(:display_name_with_preview_text).and_return('Name with Preview text')
-          expect(helper.clipboard_select_tag_options(clipboard_items)).to have_selector('option', text: 'Name with Preview text')
-        end
-
-        context "when @page can have cells" do
-          before { allow(page).to receive(:can_have_cells?).and_return(true) }
-
-          it "should group the elements in the clipboard by cell" do
-            expect(helper).to receive(:grouped_elements_for_select).and_return({})
-            helper.clipboard_select_tag_options(clipboard_items)
-          end
-        end
-      end
-
-      context 'with page items' do
-        let(:page_in_clipboard) { build_stubbed(:alchemy_page, name: 'Page name') }
-        let(:clipboard_items) { [page_in_clipboard] }
-
-        it "should include select options with page names" do
-          expect(helper.clipboard_select_tag_options(clipboard_items)).to have_selector('option', text: 'Page name')
-        end
-      end
-    end
-
-    describe '#button_with_confirm' do
-      subject { button_with_confirm }
-
-      it "renders a button tag with a data attribute for confirm dialog" do
-        is_expected.to have_selector('button[data-alchemy-confirm]')
-      end
-    end
-
-    describe '#delete_button' do
-      subject { delete_button('/admin/pages') }
-
-      it "renders a button tag" do
-        is_expected.to have_selector('button')
-      end
-
-      it "returns a form tag with method=delete" do
-        is_expected.to have_selector('form input[name="_method"][value="delete"]')
-      end
-    end
-
-    describe '#alchemy_datepicker' do
-      subject { alchemy_datepicker(essence, :date, {value: now}) }
-
-      let(:essence) { EssenceDate.new }
-      let(:now)     { Time.current }
-
-      it "renders a date field" do
-        is_expected.to have_selector("input[type='date']")
-      end
-
-      it "sets default date as value" do
-        is_expected.to have_selector("input[value='#{::I18n.l(now, format: :datepicker)}']")
-      end
-
-      context 'with date stored on object' do
-        let(:date)    { Time.parse('1976-10-07 00:00 Z') }
-        let(:essence) { EssenceDate.new(date: date) }
-
-        it "sets this date as value" do
-          is_expected.to have_selector("input[value='#{::I18n.l(date, format: :datepicker)}']")
-        end
-      end
-    end
-
-    describe '#current_alchemy_user_name' do
-      subject { helper.current_alchemy_user_name }
-
-      before { expect(helper).to receive(:current_alchemy_user).and_return(user) }
-
-      context 'with a user having a `alchemy_display_name` method' do
-        let(:user) { double('User', alchemy_display_name: 'Peter Schroeder') }
-
-        it "Returns a span showing the name of the currently logged in user." do
-          is_expected.to have_content("#{Alchemy.t('Logged in as')} Peter Schroeder")
-          is_expected.to have_selector("span.current-user-name")
-        end
-      end
-
-      context 'with a user not having a `alchemy_display_name` method' do
-        let(:user) { double('User', name: 'Peter Schroeder') }
-
-        it { is_expected.to be_nil }
-      end
-    end
-
-    describe '#link_url_regexp' do
-      subject { helper.link_url_regexp }
-
-      it "returns the regular expression for external link urls" do
-        expect(subject).to be_a(Regexp)
-      end
-
-      context 'if the expression from config is nil' do
-        before do
-          expect(Alchemy::Config).to receive(:get).and_return({link_url: nil})
-        end
-
-        it "returns the default expression" do
-          expect(subject).to_not be_nil
-        end
-      end
-    end
-  end
-end

data/spec/helpers/alchemy/admin/contents_helper_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Alchemy::Admin::ContentsHelper do
-  let(:element) { build_stubbed(:alchemy_element, name: 'article') }
-  let(:content) { mock_model('Content', essence_partial_name: 'essence_text') }
-
-  describe 'render_content_name' do
-    let(:content) do
-      mock_model 'Content',
-        name: 'intro',
-        definition: {name: 'intro', type: 'EssenceText'},
-        name_for_label: 'Intro',
-        has_validations?: false
-    end
-    subject { helper.render_content_name(content) }
-
-    it "returns the content name" do
-      is_expected.to eq("Intro")
-    end
-
-    context 'if content is nil' do
-      let(:content) { nil }
-
-      it "returns nil" do
-        is_expected.to be_nil
-      end
-    end
-
-    context 'with missing definition' do
-      before { expect(content).to receive(:definition).and_return({}) }
-
-      it "renders a warning" do
-        is_expected.to have_selector('span.warning')
-        is_expected.to have_content('Intro')
-      end
-    end
-
-    context 'with validations' do
-      before { expect(content).to receive(:has_validations?).and_return(true) }
-
-      it "show a validation indicator" do
-        is_expected.to have_selector('.validation_indicator')
-      end
-    end
-  end
-end