alchemy_cms 3.0.0.rc5 → 3.0.0.rc6

data/spec/controllers/admin/elements_controller_spec.rb

@@ -96,25 +96,28 @@ module Alchemy
       describe 'insertion position' do
         before { element }
 
-        it "should insert the element at bottom of list" do
-          xhr :post, :create, {element: {name: 'news', page_id: alchemy_page.id}}
-          alchemy_page.elements.count.should == 2
-          alchemy_page.elements.last.name.should == 'news'
+        context 'with no insert_after passed' do
+          it "should insert the element at top of list" do
+            xhr :post, :create, {element: {name: 'news', page_id: alchemy_page.id}}
+            alchemy_page.elements.count.should == 2
+            alchemy_page.elements.first.name.should == 'news'
+          end
         end
 
-        context "on a page with a setting for insert_elements_at of top" do
+        context "with insert_after passed in the params" do
+          let(:element_before) { create(:element, name: 'headline', page: alchemy_page) }
+
           before do
-            PageLayout.stub(:get).and_return({
-              'name' => 'news',
-              'elements' => ['news'],
-              'insert_elements_at' => 'top'
-            })
+            alchemy_page.elements.delete_all
+            element_before
           end
 
-          it "should insert the element at top of list" do
-            xhr :post, :create, {element: {name: 'news', page_id: alchemy_page.id}}
+          it "should insert the new element after that element" do
+            xhr :post, :create, {element: {name: 'news', page_id: alchemy_page.id}, insert_after: element_before.id}
             alchemy_page.elements.count.should == 2
-            alchemy_page.elements.first.name.should == 'news'
+            alchemy_page.elements.reload
+            alchemy_page.elements.first.name.should == 'headline'
+            alchemy_page.elements.last.name.should == 'news'
           end
         end
       end
@@ -223,7 +226,7 @@ module Alchemy
         it "should create an element from clipboard" do
           xhr :post, :create, {paste_from_clipboard: element_in_clipboard.id, element: {page_id: alchemy_page.id}}
           response.status.should == 200
-          response.body.should match(/Succesfully added new element/)
+          response.body.should match(/Successfully added new element/)
         end
 
         context "and with cut as action parameter" do

data/spec/controllers/admin/pages_controller_spec.rb

@@ -100,10 +100,9 @@ module Alchemy
       render_views
 
       context "with page having nested urlname" do
-        let(:page) { mock_model(Page, {name: 'Foobar', slug: 'foobar', urlname: 'root/parent/foobar', redirects_to_external?: false, layoutpage?: false, taggable?: false}) }
+        let(:page) { create(:page, name: 'Foobar') }
 
         it "should always show the slug" do
-          Page.stub(:find).and_return(page)
           xhr :get, :configure, {id: page.id}
           response.body.should match /value="foobar"/
         end

data/spec/controllers/pages_controller_spec.rb

@@ -131,8 +131,9 @@ module Alchemy
         let(:page)        { FactoryGirl.create(:public_page, name: 'New page name') }
         let(:second_page) { FactoryGirl.create(:public_page, name: 'Second Page') }
         let(:legacy_page) { FactoryGirl.create(:public_page, name: 'Legacy Url') }
-        let(:legacy_url)  { LegacyPageUrl.create(urlname: 'legacy-url', page: page) }
+        let!(:legacy_url) { LegacyPageUrl.create(urlname: 'legacy-url', page: page) }
         let(:legacy_url2) { LegacyPageUrl.create(urlname: 'legacy-url', page: second_page) }
+        let(:legacy_url3) { LegacyPageUrl.create(urlname: 'index.php?id=2', page: second_page) }
 
         it "should redirect permanently to page that belongs to legacy page url." do
           get :show, urlname: legacy_url.urlname
@@ -141,17 +142,20 @@ module Alchemy
         end
 
         it "should only redirect to legacy url if no page was found for urlname" do
-          legacy_url
           get :show, urlname: legacy_page.urlname
           response.status.should == 200
           response.should_not redirect_to("/#{page.urlname}")
         end
 
         it "should redirect to last page that has that legacy url" do
-          legacy_url
           get :show, urlname: legacy_url2.urlname
           response.should redirect_to("/#{second_page.urlname}")
         end
+
+        it "should redirect even if the url has get parameters" do
+          get :show, urlname: legacy_url3.urlname
+          response.should redirect_to("/#{second_page.urlname}")
+        end
       end
     end
 

data/spec/dummy/app/models/dummy_user.rb

@@ -1,7 +1,17 @@
-class DummyUser < ActiveRecord::Base
-  attr_accessor :alchemy_roles
+class DummyUser
+  include ActiveModel::Validations
+
+  attr_accessor :alchemy_roles, :language, :cache_key, :email, :password, :name, :id
 
   def self.logged_in
     []
   end
+
+  def self.stamper_class_name
+    :DummyUser
+  end
+
+  def update_attributes(attributes)
+    attributes.each { |key,value| send("#{key}=".to_sym, value) }
+  end
 end

data/spec/features/admin/dashboard_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe 'Dashboard feature' do
+  let(:a_page) { FactoryGirl.create(:public_page, visible: true) }
+
+  before do
+    @user = DummyUser.new
+    @user.update_attributes(alchemy_roles: %w(admin), name: "Joe User", id: 1)
+    authorize_as_admin(@user)
+  end
+
+  describe 'Locked pages summary' do
+    it "should initially show no pages are locked" do
+      visit admin_dashboard_path
+      locked_pages_widget = all('div[@class="widget"]').first
+      expect(locked_pages_widget).to have_content "Currently locked pages:"
+      expect(locked_pages_widget).to have_content "no pages"
+    end
+
+    context 'When locked by current user' do
+      it "should show locked by me" do
+        a_page.lock_to!(@user)
+        visit admin_dashboard_path
+        locked_pages_widget = all('div[@class="widget"]').first
+        expect(locked_pages_widget).to have_content "Currently locked pages:"
+        expect(locked_pages_widget).to have_content a_page.name
+        expect(locked_pages_widget).to have_content "Me"
+      end
+    end
+
+    context 'When locked by another user' do
+      it "should show locked by user's name" do
+        user = DummyUser.new
+        user.update_attributes(alchemy_roles: %w(admin), name: "Sue Smith", id: 2)
+        a_page.lock_to!(user)
+        DummyUser.stub(:find).and_return(user)
+        visit admin_dashboard_path
+        locked_pages_widget = all('div[@class="widget"]').first
+        expect(locked_pages_widget).to have_content "Currently locked pages:"
+        expect(locked_pages_widget).to have_content a_page.name
+        expect(locked_pages_widget).to have_content "Sue Smith"
+      end
+    end
+  end
+end

data/spec/features/admin/legacy_page_url_management_spec.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe 'Legacy page url management', js: true do
+  before do
+    authorize_as_admin
+  end
+
+  let!(:a_page) { create(:page) }
+
+  def open_page_properties
+    visit admin_pages_path
+    within "#page_#{a_page.id}" do
+      click_link Alchemy::I18n.t(:edit_page_properties)
+    end
+  end
+
+  it "lets a user add a page link" do
+    open_page_properties
+    click_link 'Links'
+    fill_in 'legacy_page_url_urlname', with: 'new-urlname'
+    click_button 'Add'
+    within '#legacy_page_urls' do
+      expect(page).to have_content('new-urlname')
+    end
+    within '#legacy_urls_label' do
+      expect(page).to have_content('(1) Link')
+    end
+  end
+
+  context 'with wrong url format' do
+    it "displays error message" do
+      open_page_properties
+      click_link 'Links'
+      fill_in 'legacy_page_url_urlname', with: 'invalid url name'
+      click_button 'Add'
+      within '#new_legacy_page_url' do
+        expect(page).to have_content('URL path is invalid')
+      end
+    end
+  end
+
+  context 'with legacy page url present' do
+    before do
+      a_page.legacy_urls.create!(urlname: 'a-page-link')
+      open_page_properties
+      click_link '(1) Link'
+    end
+
+    it "lets a user remove a page link" do
+      click_link 'Remove'
+      click_button 'Yes'
+      within '#legacy_page_urls' do
+        expect(page).to_not have_content('a-page-link')
+        expect(page).to have_content(Alchemy::I18n.t('No page links for this page found'))
+      end
+      within '#legacy_urls_label' do
+        expect(page).to have_content('(0) Links')
+      end
+    end
+  end
+end

data/spec/features/admin/page_editing_feature_spec.rb

@@ -1,15 +1,75 @@
 require 'spec_helper'
 
-describe 'Page editing feature', js: true do
-  let(:a_page) { FactoryGirl.create(:page) }
+describe 'Page editing feature' do
+  let(:a_page) { FactoryGirl.create(:public_page, visible: true) }
 
   before { authorize_as_admin }
 
-  context "in preview mode" do
+  context "in configure overlay" do
+
+    context "when editing a normal page" do
+      it "should show all relevant input fields" do
+        visit alchemy.configure_admin_page_path(a_page)
+        expect(page).to have_selector('input#page_urlname')
+        expect(page).to have_selector('input#page_title')
+        expect(page).to have_selector('input#page_robot_index')
+        expect(page).to have_selector('input#page_robot_follow')
+      end
+
+      context "with sitemaps show_flag config option set to true" do
+        before do
+          Alchemy::Config.stub(:get) { |arg| arg == :sitemap ? {'show_flag' => true} : Alchemy::Config.show[arg.to_s] }
+        end
+
+        it "should show sitemap checkbox" do
+          visit alchemy.configure_admin_page_path(a_page)
+          expect(page).to have_selector('input[type="checkbox"]#page_sitemap')
+        end
+      end
+
+      context "with sitemaps show_flag config option set to false" do
+        before do
+          Alchemy::Config.stub(:get) { |arg| arg == :sitemap ? {'show_flag' => false} : Alchemy::Config.show[arg.to_s] }
+        end
+
+        it "should show sitemap checkbox" do
+          visit alchemy.configure_admin_page_path(a_page)
+          expect(page).to_not have_selector('input[type="checkbox"]#page_sitemap')
+        end
+      end
+    end
+
+    context "when editing a global page" do
+      let(:layout_page) { FactoryGirl.create(:page, layoutpage: true) }
+
+      it "should not show the input fields for normal pages" do
+        visit alchemy.edit_admin_layoutpage_path(layout_page)
+        expect(page).to_not have_selector('input#page_urlname')
+        expect(page).to_not have_selector('input#page_title')
+        expect(page).to_not have_selector('input#page_robot_index')
+        expect(page).to_not have_selector('input#page_robot_follow')
+      end
+    end
+
+    context "when page is taggable" do
+      before { Alchemy::Page.any_instance.stub(:taggable?).and_return(true) }
+      it "should show the tag_list input field" do
+        visit alchemy.configure_admin_page_path(a_page)
+        expect(page).to have_selector('input#page_tag_list')
+      end
+    end
+  end
+
+  context "in preview frame" do
     it "the menubar does not render on the page" do
-      visit alchemy.edit_admin_page_path(a_page)
-      within_frame('alchemy_preview_window') do
-        a_page.should_not have_selector('#alchemy_menubar')
+      visit alchemy.admin_page_path(a_page)
+      page.should_not have_selector('#alchemy_menubar')
+    end
+
+    it "navigation links are not clickable" do
+      visit alchemy.admin_page_path(a_page)
+      within('#navigation') do
+        page.should have_selector('a[href="javascript: void(0)"]')
       end
     end
   end

data/spec/features/page_feature_spec.rb

@@ -221,5 +221,18 @@ module Alchemy
       end
     end
 
+    describe 'navigation rendering' do
+      context 'with page having an external url without protocol' do
+        let!(:external_page) { create(:page, urlname: 'google.com', page_layout: 'external', visible: true) }
+
+        it "adds an prefix to url" do
+          visit "/#{public_page_1.urlname}"
+          within '#navigation' do
+            expect(page.body).to match('http://google.com')
+          end
+        end
+      end
+    end
+
   end
 end

data/spec/helpers/admin/base_helper_spec.rb

@@ -228,5 +228,41 @@ module Alchemy
       end
     end
 
+    describe '#current_alchemy_user_name' do
+      subject { helper.current_alchemy_user_name }
+
+      before { helper.stub(current_alchemy_user: 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
+          should have_content("#{Alchemy::I18n.t('Logged in as')} Peter Schroeder")
+          should 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 { should 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 { Alchemy::Config.stub(get: {link_url: nil}) }
+
+        it "returns the default expression" do
+          expect(subject).to_not be_nil
+        end
+      end
+    end
   end
 end

data/spec/libraries/resource_spec.rb

@@ -1,5 +1,4 @@
-require File.dirname(__FILE__) + '/../../lib/alchemy/resource'
-require File.dirname(__FILE__) + '/../../lib/alchemy/errors'
+require 'spec_helper'
 
 class Party
 end
@@ -23,47 +22,54 @@ module PartyEngine
   end
 end
 
-# Alchemy's standard module definition. Only engine_name is relevant here
-def module_definition
-  {
-    "name" => "party_list",
-    "engine_name" => "party_engine",
-    "navigation" => {
-      "name" => "modules.party_list",
-      "controller" => "/admin/parties",
-      "action" => "index",
-      "image" => "/assets/party_list_module.png"
-    }
-  }
-end
-
 module Alchemy
   describe Resource do
+    # Alchemy's standard module definition. Only engine_name is relevant here
+    let(:module_definition) do
+      {
+        "name" => "party_list",
+        "engine_name" => "party_engine",
+        "navigation" => {
+          "name" => "modules.party_list",
+          "controller" => "/admin/parties",
+          "action" => "index",
+          "image" => "/assets/party_list_module.png"
+        }
+      }
+    end
+
+    let(:columns) do
+      [
+        double(:column, {name: 'name', type: :string, array: false}),
+        double(:column, {name: 'hidden_value', type: :string, array: false}),
+        double(:column, {name: 'description', type: :string, array: false}),
+        double(:column, {name: 'id', type: :integer, array: false}),
+        double(:column, {name: 'starts_at', type: :datetime, array: false}),
+        double(:column, {name: 'location_id', type: :integer, array: false}),
+        double(:column, {name: 'organizer_id', type: :integer, array: false}),
+      ]
+    end
+
+    let(:resource) { Resource.new("admin/parties", module_definition) }
 
     before :each do
       # stubbing an ActiveRecord::ModelSchema...
-      columns = [
-        double(:column, {:name => 'name', :type => :string}),
-        double(:column, {:name => 'hidden_value', :type => :string}),
-        double(:column, {:name => 'description', :type => :string}),
-        double(:column, {:name => 'id', :type => :integer}),
-        double(:column, {:name => 'starts_at', :type => :datetime}),
-        double(:column, {:name => 'location_id', :type => :integer}),
-        double(:column, {:name => 'organizer_id', :type => :integer}),
-      ]
       Party.stub(:columns).and_return columns
     end
 
     describe "#initialize" do
+      it "sets the standard database attributes (rails defaults) to be skipped" do
+        resource = Resource.new("admin/parties")
+        resource.skipped_attributes.should == %w(id updated_at created_at creator_id updater_id)
+      end
 
-      it "should set an instance variable that holds the controller path" do
+      it "sets an instance variable that holds the controller path" do
         resource = Resource.new("admin/parties")
         resource.instance_variable_get(:@controller_path).should == "admin/parties"
       end
 
       context "when initialized with a module definition" do
         it "sets an instance variable that holds the module definition" do
-          resource = Resource.new("admin/parties", module_definition)
           resource.instance_variable_get(:@module_definition).should == module_definition
         end
       end
@@ -90,17 +96,20 @@ module Alchemy
               {location: {attr_method: 'name', type: 'string'}}
             end
           end
-          Party.stub(:respond_to?).and_return { |arg|
-            case arg
-            when :reflect_on_all_associations
-              then false
-            when :alchemy_resource_relations
-              then true
-            end
-          }
         end
 
         context ", but not an ActiveRecord association" do
+          before do
+            Party.stub(:respond_to?).and_return do |arg|
+              case arg
+              when :reflect_on_all_associations
+                then false
+              when :alchemy_resource_relations
+                then true
+              end
+            end
+          end
+
           it "should raise error." do
             expect { Resource.new("admin/parties") }.to raise_error(MissingActiveRecordAssociation)
           end
@@ -114,46 +123,38 @@ module Alchemy
           end
         end
       end
-
     end
 
     describe "#resource_array" do
-
       it "splits the controller_path and returns it as array." do
         resource = Resource.new("namespace1/namespace2/parties")
-        resource.resource_array.should eql(%W[namespace1 namespace2 parties])
+        resource.resource_array.should eql(%w(namespace1 namespace2 parties))
       end
 
       it "deletes 'admin' if found hence our model isn't in the admin-namespace by convention" do
-        resource = Resource.new("admin/parties")
-        resource.resource_array.should eql(%W[parties])
+        resource.resource_array.should eql(%w(parties))
       end
-
     end
 
     describe "#model" do
       it "returns the @model instance variable" do
-        resource = Resource.new("admin/parties")
         resource.model.should == resource.instance_variable_get(:@model)
       end
     end
 
     describe "#resources_name" do
       it "returns plural name (like parties for model Party)" do
-        resource = Resource.new("admin/parties")
         resource.resources_name.should == "parties"
       end
     end
 
     describe "#resource_name" do
       it "returns the resources name as singular" do
-        resource = Resource.new("admin/parties")
         resource.resource_name.should == "party"
       end
     end
 
     describe "#namespaced_resource_name" do
-
       it "returns resource_name with namespace (namespace_party for Namespace::Party), i.e. for use in forms" do
         namespaced_resource = Resource.new("admin/namespace/parties")
         namespaced_resource.namespaced_resource_name.should == 'namespace_party'
@@ -168,7 +169,6 @@ module Alchemy
         namespaced_resource = Resource.new("admin/party_engine/namespace/parties", module_definition)
         namespaced_resource.namespaced_resource_name.should == 'namespace_party'
       end
-
     end
 
     describe "#engine_name" do
@@ -179,16 +179,13 @@ module Alchemy
     end
 
     describe "#namespace_for_scope" do
-      it "returns a scope for use in url_for-based path-helpers" do
-        resource = Resource.new("admin/parties")
-        resource.namespace_for_scope.should == %W[admin]
+      it "returns a scope for use in url_for based path helpers" do
+        resource.namespace_for_scope.should == %w(admin)
       end
     end
 
     describe "#attributes" do
-      let(:resource) { Resource.new("admin/parties") }
-
-      it "parses and returns the resource-model's attributes from ActiveRecord::ModelSchema" do
+      it "parses and returns the resource model's attributes from ActiveRecord::ModelSchema" do
         resource.attributes.should == [
           {:name => "name", :type => :string},
           {:name => "hidden_value", :type => :string},
@@ -199,59 +196,146 @@ module Alchemy
         ]
       end
 
-      it "skips attributes returned by skip_attributes" do
-        # attr_accessor, hence skip_attributes= works
-        resource.skip_attributes = %W[hidden_value]
+      it "skips attributes returned by skipped_alchemy_resource_attributes" do
+        # attr_accessor, hence skipped_alchemy_resource_attributes= works
+        resource.skipped_attributes = %w(hidden_value)
         resource.attributes.should include({:name => "id", :type => :integer})
         resource.attributes.should_not include({:name => "hidden_value", :type => :string})
       end
+
+      context "when resource_relations are not defined" do
+        it "includes the attribute" do
+          resource.attributes.detect { |a| a[:name] == "location_id" }.should == {:name => "location_id", :type => :integer}
+        end
+      end
     end
 
+    context "when `skipped_alchemy_resource_attributes` is defined as class method in the model" do
+      before do
+        Party.class_eval do
+          def self.skipped_alchemy_resource_attributes
+            %w(hidden_name)
+          end
+        end
+      end
 
-    describe "#skip_attributes" do
-      let(:resource) { Resource.new("admin/parties") }
+      describe '#attributes' do
+        it "does not return the attributes returned by that method" do
+          resource.attributes.detect { |a| a[:name] == 'hidden_name' }.should be_nil
+          resource.attributes.detect { |a| a[:name] == 'name' }.should_not be_nil
+        end
+      end
 
-      it "returns a set of default attributes (Rails' default database attributes)" do
-        # read from Resource::DEFAULT_SKIPPED_ATTRIBUTES
-        default_skipped_attributes = %W[id updated_at created_at creator_id updater_id]
-        resource.skip_attributes = default_skipped_attributes
+      describe '#skipped_attributes' do
+        it "returns the result of Model.skipped_alchemy_resource_attributes" do
+          custom_skipped_attributes = %w(hidden_name)
+          resource.skipped_attributes = custom_skipped_attributes
+        end
       end
 
-      context "when skip_attributes is defined as class-method in the model" do
-        before do
-          Party.class_eval do
-            def self.skip_attributes
-              %W[hidden_name]
-            end
+      after do
+        Party.class_eval do
+          class << self
+            undef skipped_alchemy_resource_attributes
           end
         end
-        after do
-          Party.class_eval do
-            class << self
-              undef skip_attributes
-            end
+      end
+    end
+
+    describe "#searchable_attributes" do
+      subject { resource.searchable_attributes }
+
+      before { resource.skipped_attributes = [] }
+
+      it "returns all attributes of type string" do
+        should == [
+          {:name => "name", :type => :string},
+          {:name => "hidden_value", :type => :string},
+          {:name => "description", :type => :string}
+        ]
+      end
+
+      context "with an array attribute" do
+        let(:columns) do
+          [
+            double(:column, {name: 'name', type: :string, array: false}),
+            double(:column, {name: 'languages', type: :string, array: true})
+          ]
+        end
+
+        it "does not include this column" do
+          should == [{name: "name", type: :string}]
+        end
+      end
+    end
+
+    context "when alchemy_resource_relations defined as class method in the model" do
+      let(:resource) { Resource.new("admin/events") }
+
+      before do
+        Event.class_eval do
+          def self.alchemy_resource_relations
+            {
+              :location => {:attr_method => "name", :attr_type => :string}
+            }
           end
         end
+      end
+
+      describe '#resource_relations' do
+        it "should contain model_association from ActiveRecord::Reflections" do
+          relation = resource.resource_relations[:location_id]
+          relation.keys.should include(:model_association)
+          relation[:model_association].class.should be(ActiveRecord::Reflection::AssociationReflection)
+        end
 
-        it "returns the result of Model.skip_attributes" do
-          custom_skipped_attributes = %W[hidden_name]
-          resource.skip_attributes = custom_skipped_attributes
+        it "adds '_id' to relation key" do
+          resource.resource_relations[:location_id].should_not be_nil
         end
 
+        it "stores the relation name" do
+          relation = resource.resource_relations[:location_id]
+          relation.keys.should include(:name)
+          relation[:name].should == 'location'
+        end
       end
 
-      describe "#searchable_attributes" do
-        it "returns all attributes of type string" do
-          resource = Resource.new("admin/parties")
-          resource.skip_attributes = []
-          resource.searchable_attributes.should == [
-            {:name => "name", :type => :string},
-            {:name => "hidden_value", :type => :string},
-            {:name => "description", :type => :string}
-          ]
+      describe '#model_associations' do
+        it "skip default alchemy model associations" do
+          resource.model_associations.collect(&:name).should_not include(*resource.class.const_get(:DEFAULT_SKIPPED_ASSOCIATIONS).map(&:to_sym))
+        end
+      end
+
+      describe '#attributes' do
+        it "contains the attribute of the related model" do
+          resource.attributes.detect { |a| a[:name] == 'location_id' }.keys.should include(:relation)
+        end
+
+        it "contains the related model's column type as type" do
+          resource.attributes.detect { |a| a[:name] == "location_id" }[:type].should == :string
+        end
+      end
+
+      after do
+        Event.class_eval do
+          class << self
+            undef :alchemy_resource_relations
+          end
         end
       end
+    end
+
+    describe "#engine_name" do
+      it "should return the engine name of the module" do
+        resource.engine_name.should == "party_engine"
+      end
+    end
 
+    describe "#in_engine?" do
+      it "should return true if the module is shipped within an engine" do
+        resource.in_engine?.should == true
+      end
     end
+
   end
 end