alchemy_cms 3.3.0.rc1 → 3.3.0.rc2

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

@@ -1,294 +0,0 @@
-require 'spec_helper'
-
-describe Alchemy::Admin::NavigationHelper do
-  let(:alchemy_module) do
-    {
-      'name' => 'dashboard',
-      'engine_name' => 'alchemy',
-      'navigation' => {
-        'name' => 'modules.dashboard',
-        'controller' => 'alchemy/admin/dashboard',
-        'action' => 'index',
-        'icon' => 'dashboard',
-        'sub_navigation' => [{
-          'controller' => 'alchemy/admin/layoutpages',
-          'action' => 'index'
-        }]
-      }
-    }
-  end
-
-  let(:event_module) do
-    {
-      'navigation' => {
-        'controller' => '/admin/events',
-        'action' => 'index',
-        'sub_navigation' => [{
-          'controller' => '/admin/events',
-          'action' => 'index'
-        }]
-      }
-    }
-  end
-
-  let(:event_module_with_params) do
-    {
-      'navigation' => {
-        'controller' => '/admin/events',
-        'action' => 'index',
-        'params' => {
-            'key' => 'value'
-        },
-        'sub_navigation' => [{
-          'controller' => '/admin/events',
-          'action' => 'index',
-          'params' => {
-             'key' => 'value',
-             'key2' => 'value2'
-          }
-       }]
-      }
-    }
-  end
-
-  let(:navigation) { alchemy_module['navigation'] }
-
-  describe '#alchemy_main_navigation_entry' do
-    before do
-      allow(helper).to receive(:url_for_module).and_return('')
-      allow(Alchemy).to receive(:t).and_return(alchemy_module['name'])
-    end
-
-    context "with permission" do
-      before do
-        expect(helper).to receive(:can?).and_return(true)
-      end
-
-      it "renders the main navigation entry partial" do
-        expect(helper.alchemy_main_navigation_entry(alchemy_module)).to match /<a.+class="main_navi_entry/
-      end
-    end
-
-    context "without permission" do
-      before do
-        allow(helper).to receive(:can?).and_return(false)
-      end
-
-      it "returns empty string" do
-        expect(helper.alchemy_main_navigation_entry(alchemy_module)).to be_empty
-      end
-    end
-  end
-
-  describe '#admin_subnavigation' do
-    before do
-      allow(helper).to receive(:current_alchemy_module).and_return(alchemy_module)
-      allow(helper).to receive(:url_for_module_sub_navigation).and_return('')
-      allow(Alchemy).to receive(:t).and_return(alchemy_module['name'])
-    end
-
-    context "with permission" do
-      before do
-        expect(helper).to receive(:can?).and_return(true)
-      end
-
-      it "renders the sub navigation for current module" do
-        expect(helper.admin_subnavigation).to match /<div.+class="subnavi_tab/
-      end
-    end
-
-    context "without permission" do
-      before do
-        expect(helper).to receive(:can?).and_return(false)
-      end
-
-      it "renders the sub navigation for current module" do
-        expect(helper.admin_subnavigation).to be_empty
-      end
-    end
-
-    context "without a module present" do
-      before do
-        expect(helper).to receive(:current_alchemy_module).and_return(nil)
-      end
-
-      it "returns nil" do
-        expect(helper.admin_subnavigation).to be_nil
-      end
-    end
-  end
-
-  describe '#navigate_module' do
-    it "returns array with symbolized action and controller name" do
-      expect(helper.navigate_module(navigation)).to eq([:index, :alchemy_admin_dashboard])
-    end
-
-    it "stringifies keys" do
-      expect(helper.navigate_module({action: 'index', controller: 'alchemy/admin/pictures'})).to eq([:index, :alchemy_admin_pictures])
-    end
-
-    it "removes leading slash" do
-      expect(helper.navigate_module({action: 'index', controller: '/admin/pictures'})).to eq([:index, :admin_pictures])
-    end
-  end
-
-  describe '#main_navigation_css_classes' do
-    it "returns string with css classes for main navigation entry" do
-      expect(helper.main_navigation_css_classes(navigation)).to eq("main_navi_entry")
-    end
-
-    context "with active entry" do
-      before do
-        allow(helper).to receive(:params).and_return({
-          controller: 'alchemy/admin/dashboard',
-          action: 'index'
-        })
-      end
-
-      it "includes active class" do
-        expect(helper.main_navigation_css_classes(navigation)).to eq("main_navi_entry active")
-      end
-    end
-  end
-
-  describe '#entry_active?' do
-    let(:entry) do
-      {'controller' => 'alchemy/admin/dashboard', 'action' => 'index'}
-    end
-
-    context "with active entry" do
-      before do
-        allow(helper).to receive(:params).and_return({
-          controller: 'alchemy/admin/dashboard',
-          action: 'index'
-        })
-      end
-
-      it "returns true" do
-        expect(helper.entry_active?(entry)).to be_truthy
-      end
-
-      context "and with leading slash in controller name" do
-        before { entry['controller'] = '/alchemy/admin/dashboard' }
-
-        it "returns true" do
-          expect(helper.entry_active?(entry)).to be_truthy
-        end
-      end
-
-      context "but with action listed in nested_actions key" do
-        before do
-          entry['action'] = nil
-          entry['nested_actions'] = %w(index)
-        end
-
-        it "returns true" do
-          expect(helper.entry_active?(entry)).to be_truthy
-        end
-      end
-    end
-
-    context "with inactive entry" do
-      before do
-        expect(helper).to receive(:params).and_return({
-          controller: 'alchemy/admin/users',
-          action: 'index'
-        })
-      end
-
-      it "returns false" do
-        expect(helper.entry_active?(entry)).to be_falsey
-      end
-    end
-  end
-
-  describe '#url_for_module' do
-    context "with module within an engine" do
-      it "returns correct url string" do
-        expect(helper.url_for_module(alchemy_module)).to eq('/admin/dashboard')
-      end
-    end
-
-    context "with module within host app" do
-      it "returns correct url string" do
-        expect(helper.url_for_module(event_module)).to eq('/admin/events')
-      end
-
-      it "returns correct url string with params" do
-        expect(helper.url_for_module(event_module_with_params)).to eq('/admin/events?key=value')
-      end
-    end
-  end
-
-  describe '#url_for_module_sub_navigation' do
-    subject { helper.url_for_module_sub_navigation(navigation) }
-
-    let(:current_module) { alchemy_module }
-    let(:navigation)     { current_module['navigation']['sub_navigation'].first }
-
-    context 'with module found' do
-      before do
-        expect(helper).to receive(:module_definition_for).and_return current_module
-      end
-
-      context "with module within an engine" do
-        let(:current_module) { alchemy_module }
-
-        it "returns correct url string" do
-          is_expected.to eq('/admin/layoutpages')
-        end
-      end
-
-      context "with module within host app" do
-        let(:current_module) { event_module }
-
-        it "returns correct url string" do
-          is_expected.to eq('/admin/events')
-        end
-      end
-
-      context "with module within host app with params" do
-        let(:current_module) { event_module_with_params }
-
-        it "returns correct url string with params" do
-          is_expected.to eq('/admin/events?key2=value2&key=value')
-        end
-      end
-    end
-
-    context 'without module found' do
-      before do
-        expect(helper).to receive(:module_definition_for).and_return nil
-      end
-
-      it { is_expected.to be_nil }
-    end
-  end
-
-  describe "#sorted_alchemy_modules" do
-    subject { helper.sorted_alchemy_modules }
-
-    context 'with position attribute on modules' do
-      before do
-        alchemy_module['position'] = 1
-        event_module['position'] = 2
-        expect(helper).to receive(:alchemy_modules).and_return [event_module, alchemy_module]
-      end
-
-      it "returns sorted alchemy modules" do
-        is_expected.to eq([alchemy_module, event_module])
-      end
-    end
-
-    context 'with no position attribute on one module' do
-      before do
-        event_module['position'] = 2
-        expect(helper).to receive(:alchemy_modules).and_return [alchemy_module, event_module]
-      end
-
-      it "appends this module at the end" do
-        is_expected.to eq([event_module, alchemy_module])
-      end
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe Alchemy::Admin::PagesHelper do
-
-  describe '#preview_sizes_for_select' do
-    it "returns a options string of preview screen sizes for select tag" do
-      expect(helper.preview_sizes_for_select).to include('option', 'auto', '240', '320', '480', '768', '1024', '1280')
-    end
-  end
-
-  describe '#combined_page_status' do
-    let(:page) { build_stubbed(:alchemy_page, restricted: true, visible: true, public: true, locked: true) }
-    subject { helper.combined_page_status(page) }
-
-    context 'when page is locked' do
-      it { is_expected.not_to match(/locked/) } # We don't want the locked status in the return string
-    end
-
-    context 'when page is restricted' do
-      it { is_expected.to match(/is restricted/) }
-    end
-
-    context 'when page is visible in navigation' do
-      it { is_expected.to match(/is visible/) }
-    end
-
-    context 'when page is published' do
-      it { is_expected.to match(/is published/) }
-    end
-  end
-
-  describe '#page_layout_label' do
-    let(:page) { build(:alchemy_page) }
-
-    subject { helper.page_layout_label(page) }
-
-    context 'when page is not yet persisted' do
-      it 'displays text only' do
-        is_expected.to eq(Alchemy.t(:page_type))
-      end
-    end
-
-    context 'when page is persited' do
-      before { page.save! }
-
-      context 'with page layout existing' do
-        it 'displays text only' do
-          is_expected.to eq(Alchemy.t(:page_type))
-        end
-      end
-
-      context 'with page layout definition missing' do
-        before do
-          expect(page).to receive(:definition).and_return([])
-        end
-
-        it 'displays icon with warning' do
-          is_expected.to match /warning icon/
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe Alchemy::Admin::PicturesHelper do
-  describe "#create_or_assign_url" do
-    let(:picture) { mock_model('Picture') }
-    let(:options) { Hash.new }
-
-    before { @element = mock_model('Element') }
-
-    it "should return a Hash" do
-      expect(helper.create_or_assign_url(picture, options)).to be_a(Hash)
-    end
-
-    context "when creating" do
-      it "should include 'create' as the value for the action key" do
-        expect(helper.create_or_assign_url(picture, options)[:action]).to be(:create)
-      end
-    end
-
-    context "when assigning" do
-      before { @content = mock_model('Content') }
-
-      it "should include 'assign' as the value for the action key" do
-        expect(helper.create_or_assign_url(picture, options)[:action]).to be(:assign)
-      end
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-require 'spec_helper'
-
-module Alchemy
-  describe Admin::TagsHelper do
-    let(:tag)    { mock_model(ActsAsTaggableOn::Tag, name: 'foo', count: 1) }
-    let(:tag2)   { mock_model(ActsAsTaggableOn::Tag, name: 'abc', count: 1) }
-    let(:params) { {controller: 'admin/attachments', action: 'index', use_route: 'alchemy', tagged_with: 'foo'} }
-
-    describe '#render_tag_list' do
-      context "with tagged objects" do
-        before { allow(Attachment).to receive(:tag_counts).and_return([tag, tag2]) }
-
-        it "returns a tag list as <li> tags" do
-          expect(helper.render_tag_list('Alchemy::Attachment', params)).to match(/li/)
-        end
-
-        it "has the tags name in the li's name attribute" do
-          expect(helper.render_tag_list('Alchemy::Attachment', params)).to match(/li.+name="#{tag.name}"/)
-        end
-
-        it "has active class if tag is present in params" do
-          expect(helper.render_tag_list('Alchemy::Attachment', params)).to match(/li.+class="active"/)
-        end
-
-        it "tags are sorted alphabetically" do
-          expect(helper.render_tag_list('Alchemy::Attachment', params)).to match(/li.+name="#{tag2.name}.+li.+name="#{tag.name}/)
-        end
-
-        context "with lowercase and uppercase tag names mixed" do
-          let(:tag) { mock_model(ActsAsTaggableOn::Tag, name: 'Foo', count: 1) }
-
-          it "tags are sorted alphabetically correctly" do
-            expect(helper.render_tag_list('Alchemy::Attachment', params)).to match(/li.+name="#{tag2.name}.+li.+name="#{tag.name}/)
-          end
-        end
-
-        it "output is html_safe" do
-          expect(helper.render_tag_list('Alchemy::Attachment', params).html_safe?).to be_truthy
-        end
-      end
-
-      context "without any tagged objects" do
-        it "returns empty string" do
-          expect(render_tag_list('Alchemy::Attachment', params)).to be_empty
-        end
-      end
-
-      context "with nil given as class_name parameter" do
-        it "raises argument error" do
-          expect { render_tag_list(nil, params) }.to raise_error(ArgumentError)
-        end
-      end
-    end
-
-    describe '#tag_list_tag_active?' do
-      context "the tag is in params" do
-        it "returns true" do
-          expect(tag_list_tag_active?(tag, params)).to be_truthy
-        end
-      end
-
-      context "params[:tagged_with] is not present" do
-        it "returns false" do
-          expect(tag_list_tag_active?(tag, {})).to be_falsey
-        end
-      end
-    end
-
-    describe "#filtered_by_tag?" do
-      it "should return true if the filterlist contains the given tag" do
-        controller.params[:tagged_with] = "foo,bar,baz"
-        expect(helper.filtered_by_tag?(tag)).to eq(true)
-      end
-
-      it "should return false if the filterlist does not contain the given tag" do
-        controller.params[:tagged_with] = "bar,baz"
-        expect(helper.filtered_by_tag?(tag)).to eq(false)
-      end
-    end
-
-    describe "#add_to_tag_filter" do
-      context "if params[:tagged_with] is not present" do
-        it "should return an Array with the given tag name" do
-          expect(helper.add_to_tag_filter(tag)).to eq(["foo"])
-        end
-      end
-
-      context "if params[:tagged_with] contains some tag names" do
-        it "should return an Array of tag names including the given one" do
-          controller.params[:tagged_with] = "bar,baz"
-          expect(helper.add_to_tag_filter(tag)).to eq(["bar", "baz", "foo"])
-        end
-      end
-    end
-
-    describe "#remove_from_tag_filter" do
-      context "if params[:tagged_with] is not present" do
-        it "should return an empty Array" do
-          expect(helper.remove_from_tag_filter(tag)).to be_empty
-        end
-      end
-
-      context "if params[:tagged_with] contains some tag names" do
-        it "should return an Array of tag names without the given one" do
-          controller.params[:tagged_with] = "bar,baz,foo"
-          expect(helper.remove_from_tag_filter(tag)).to eq(["bar", "baz"])
-        end
-      end
-    end
-  end
-end