alchemy_cms 2.2.4 → 2.3.rc5

data/spec/integration/pages_controller_spec.rb

@@ -4,15 +4,19 @@ require 'spec_helper'
 module Alchemy
   describe PagesController do
 
-    before(:all) do
-      @default_language = Language.get_default
-      @default_language_root = FactoryGirl.create(:language_root_page, :language => @default_language, :name => 'Home')
-    end
+    let(:default_language) { Language.get_default }
+    let(:default_language_root) { FactoryGirl.create(:language_root_page, :language => default_language, :name => 'Home') }
+    let(:public_page_1) { FactoryGirl.create(:public_page, :visible => true, :name => 'Page 1') }
+    let(:public_child) { FactoryGirl.create(:public_page, :name => 'Public Child', :parent_id => public_page_1.id) }
+    let(:search_page) { FactoryGirl.create(:public_page, :name => 'Suche', :page_layout => 'search', :do_not_autogenerate => false) }
+    let(:element) { FactoryGirl.create(:element, :page => public_page_1, :create_contents_after_create => true) }
+
+    before { default_language_root }
 
     describe "#show" do
 
       it "should include all its elements and contents" do
-        p = FactoryGirl.create(:public_page, :language => @default_language)
+        p = FactoryGirl.create(:public_page, :do_not_autogenerate => false)
         article = p.elements.find_by_name('article')
         article.content_by_name('intro').essence.update_attributes(:body => 'Welcome to Peters Petshop', :public => true)
         visit "/alchemy/#{p.urlname}"
@@ -21,8 +25,8 @@ module Alchemy
 
       it "should show the navigation with all visible pages" do
         pages = [
-          FactoryGirl.create(:public_page, :language => @default_language, :visible => true, :name => 'Page 1', :parent_id => @default_language_root.id),
-          FactoryGirl.create(:public_page, :language => @default_language, :visible => true, :name => 'Page 2', :parent_id => @default_language_root.id)
+          FactoryGirl.create(:public_page, :visible => true, :name => 'Page 1'),
+          FactoryGirl.create(:public_page, :visible => true, :name => 'Page 2')
         ]
         visit '/alchemy/'
         within('div#navigation ul') { page.should have_selector('li a[href="/alchemy/page-1"], li a[href="/alchemy/page-2"]') }
@@ -32,11 +36,7 @@ module Alchemy
 
     describe "fulltext search" do
 
-      before(:all) do
-        @page = FactoryGirl.create(:public_page, :language => @default_language, :visible => true, :name => 'Page 1', :parent_id => @default_language_root.id)
-        @element = FactoryGirl.create(:element, :name => 'article', :page => @page)
-        FactoryGirl.create(:public_page, :language => @default_language, :name => 'Suche', :page_layout => 'search', :parent_id => @default_language_root.id)
-      end
+      before { search_page }
 
       it "should have a correct path in the form tag" do
         visit('/alchemy/suche')
@@ -46,34 +46,34 @@ module Alchemy
       context "performing the search" do
 
         it "should display search results for richtext essences" do
-          @element.content_by_name('text').essence.update_attributes(:body => '<p>Welcome to Peters Petshop</p>', :public => true)
+          element.content_by_name('text').essence.update_attributes(:body => '<p>Welcome to Peters Petshop</p>', :public => true)
           visit('/alchemy/suche?query=Petshop')
           within('div#content .search_result') { page.should have_content('Petshop') }
         end
 
         it "should display search results for text essences" do
-          @element.content_by_name('intro').essence.update_attributes(:body => 'Welcome to Peters Petshop', :public => true)
+          element.content_by_name('intro').essence.update_attributes(:body => 'Welcome to Peters Petshop', :public => true)
           visit('/alchemy/suche?query=Petshop')
           within('div#content .search_result') { page.should have_content('Petshop') }
         end
 
         it "should not find contents placed on global-pages (layoutpage => true)" do
-          @page.update_attributes(:layoutpage => true)
-          @element.content_by_name('intro').essence.update_attributes(:body => 'Welcome to Peters Petshop', :public => true)
+          public_page_1.update_attributes(:layoutpage => true)
+          element.content_by_name('intro').essence.update_attributes(:body => 'Welcome to Peters Petshop', :public => true)
           visit('/alchemy/suche?query=Petshop')
           within('div#content') { page.should have_css('h2.no_search_results') }
         end
 
         it "should not find contents placed on unpublished pages (public => false)" do
-          @page.update_attributes(:public => false)
-          @element.content_by_name('intro').essence.update_attributes(:body => 'Welcome to Peters Petshop', :public => true)
+          public_page_1.update_attributes(:public => false)
+          element.content_by_name('intro').essence.update_attributes(:body => 'Welcome to Peters Petshop', :public => true)
           visit('/alchemy/suche?query=Petshop')
           within('div#content') { page.should have_css('h2.no_search_results') }
         end
 
         it "should not find contents placed on restricted pages (restricted => true)" do
-          @page.update_attributes(:restricted => true)
-          @element.content_by_name('intro').essence.update_attributes(:body => 'Welcome to Peters Petshop', :public => true)
+          public_page_1.update_attributes(:restricted => true)
+          element.content_by_name('intro').essence.update_attributes(:body => 'Welcome to Peters Petshop', :public => true)
           visit('/alchemy/suche?query=Petshop')
           within('div#content') { page.should have_css('h2.no_search_results') }
         end
@@ -86,44 +86,44 @@ module Alchemy
 
       context "in multi language mode" do
 
-        before(:each) do
-          @page = FactoryGirl.create(:public_page)
+        before do
           Config.stub!(:get) { |arg| arg == :url_nesting ? true : Config.parameter(arg) }
+          PagesController.any_instance.stub(:multi_language?).and_return(true)
         end
 
         it "should redirect to url with nested language code if no language params are given" do
-          visit "/alchemy/#{@page.urlname}"
-          page.current_path.should == "/alchemy/#{@page.language_code}/#{@page.urlname}"
+          visit "/alchemy/#{public_page_1.urlname}"
+          page.current_path.should == "/alchemy/#{public_page_1.language_code}/#{public_page_1.urlname}"
         end
 
         context "should redirect to public child" do
 
-          before(:each) do
-            @page.update_attributes(:public => false, :name => 'Not Public', :urlname => '')
-            @child = FactoryGirl.create(:public_page, :name => 'Public Child', :parent_id => @page.id)
+          before do
+            public_page_1.update_attributes(:public => false, :name => 'Not Public', :urlname => '')
+            public_child
             Config.stub!(:get) { |arg| arg == :url_nesting ? false : Config.parameter(arg) }
           end
 
           it "if requested page is unpublished" do
-            visit '/alchemy/kl/not-public'
-            page.current_path.should == '/alchemy/kl/public-child'
+            visit "/alchemy/#{default_language.code}/not-public"
+            page.current_path.should == "/alchemy/#{default_language.code}/public-child"
           end
 
           it "with nested language code, if requested page is unpublished and url has no language code" do
             visit '/alchemy/not-public'
-            page.current_path.should == '/alchemy/kl/public-child'
+            page.current_path.should == "/alchemy/#{default_language.code}/public-child"
           end
 
         end
 
         it "should redirect to pages url with default language, if requested url is index url" do
           visit '/alchemy/'
-          page.current_path.should == '/alchemy/de/home'
+          page.current_path.should == "/alchemy/#{default_language.code}/home"
         end
 
         it "should redirect to pages url with default language, if requested url is only the language code" do
-          visit '/alchemy/de'
-          page.current_path.should == '/alchemy/de/home'
+          visit "/alchemy/#{default_language.code}"
+          page.current_path.should == "/alchemy/#{default_language.code}/home"
         end
 
         context "requested url is only the urlname" do
@@ -134,22 +134,33 @@ module Alchemy
         end
 
         it "should keep additional params" do
-          visit "/alchemy/#{@page.urlname}?query=Peter"
+          visit "/alchemy/#{public_page_1.urlname}?query=Peter"
           page.current_url.should match(/\?query=Peter/)
         end
 
-        it "should render 404 if urlname and lang parameter do not belong to same page" do
-          User.stub!(:admins).and_return(OpenStruct.new(:count => 2))
-          visit "/alchemy/en/#{@page.urlname}"
-          page.status_code.should == 404
+        context "wrong language requested" do
+
+          before { User.stub!(:admins).and_return([1, 2]) }
+
+          it "should render 404 if urlname and lang parameter do not belong to same page" do
+            FactoryGirl.create(:english)
+            visit "/alchemy/en/#{public_page_1.urlname}"
+            page.status_code.should == 404
+          end
+
+          it "should render 404 if requested language does not exist" do
+            visit "/alchemy/fo/#{public_page_1.urlname}"
+            page.status_code.should == 404
+          end
+
         end
 
         context "with url nesting" do
 
-          before(:all) do
-            @level1 = FactoryGirl.create(:public_page, :parent_id => @default_language_root.id, :name => 'catalog', :language => @default_language)
-            @level2 = FactoryGirl.create(:public_page, :parent_id => @level1.id, :name => 'products', :language => @default_language)
-            @level3 = FactoryGirl.create(:public_page, :parent_id => @level2.id, :name => 'screwdriver', :language => @default_language)
+          before do
+            level1 = FactoryGirl.create(:public_page, :name => 'catalog')
+            level2 = FactoryGirl.create(:public_page, :parent_id => level1.id, :name => 'products')
+            level3 = FactoryGirl.create(:public_page, :parent_id => level2.id, :name => 'screwdriver')
           end
 
           context "enabled" do
@@ -198,14 +209,14 @@ module Alchemy
 
       context "not in multi language mode" do
 
-        before(:each) do
-          @page = FactoryGirl.create(:public_page, :language => @default_language, :parent_id => @default_language_root.id)
+        before do
+          PagesController.any_instance.stub(:multi_language?).and_return(false)
           Config.stub!(:get) { |arg| arg == :url_nesting ? false : Config.parameter(arg) }
         end
 
         it "should redirect from nested language code url to normal url" do
-          visit "/alchemy/de/#{@page.urlname}"
-          page.current_path.should == "/alchemy/#{@page.urlname}"
+          visit "/alchemy/de/#{public_page_1.urlname}"
+          page.current_path.should == "/alchemy/#{public_page_1.urlname}"
         end
 
         context "with no lang parameter" do
@@ -224,9 +235,9 @@ module Alchemy
 
         context "should redirect to public child" do
 
-          before(:each) do
-            @page.update_attributes(:public => false, :name => 'Not Public', :urlname => '')
-            @child = FactoryGirl.create(:public_page, :name => 'Public Child', :parent_id => @page.id, :language => @default_language)
+          before do
+            public_page_1.update_attributes(:public => false, :name => 'Not Public', :urlname => '')
+            public_child
           end
 
           it "if requested page is unpublished" do
@@ -247,7 +258,7 @@ module Alchemy
         end
 
         it "should keep additional params" do
-          visit "/alchemy/de/#{@page.urlname}?query=Peter"
+          visit "/alchemy/de/#{public_page_1.urlname}?query=Peter"
           page.current_url.should match(/\?query=Peter/)
         end
 
@@ -257,12 +268,12 @@ module Alchemy
 
     describe "Handling of non-existing pages" do
 
-      context "when a language root page exists" do
+      before do
+        User.stub!(:admins).and_return([1, 2]) # We need a admin user or the signup page will show up
+        visit "/alchemy/non-existing-page"
+      end
 
-        before do
-          User.stub!(:admins).and_return([1, 2]) # We need a admin user or the signup page will show up
-          visit "/alchemy/non-existing-page"
-        end
+      context "if a language root page exists" do
 
         it "should render the status code in the title tag" do
           within("title") { page.should have_content("404") }
@@ -274,14 +285,12 @@ module Alchemy
 
       end
 
-      context "404-Errors are handled by Rails now, so no need to test anymore.
-               However, it still serves as documentation how they can be handled, so we leave it here" do
-
-        it "should render public/404.html when it exists"
-        it "can be handled by matching /404 and routing it to a controller of choice when no public/404.html exists"
-
+      it "should render public/404.html when it exists" do
+        within("title") { page.should have_content("404") }
       end
 
+      it "can be handled by matching /404 and routing it to a controller of choice when no public/404.html exists"
+
     end
   end
 end

data/spec/integration/security_spec.rb

@@ -2,11 +2,9 @@ require 'spec_helper'
 
 describe "Security: " do
 
-  before(:all) do
+  before do
     Alchemy::Page.root.children.destroy_all
     Alchemy::User.delete_all
-    # ensuring that we have the correct locale here
-    ::I18n.locale = :en
   end
 
   context "If no user is present" do
@@ -19,7 +17,7 @@ describe "Security: " do
 
   context "If user is present" do
 
-    before(:each) do
+    before do
       create_admin_user
     end
 
@@ -37,7 +35,7 @@ describe "Security: " do
 
     context "that is already logged in" do
 
-      before(:each) do
+      before do
         login_into_alchemy
       end
 

data/spec/integration/translation_integration_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "Translation integration" do
+
+  context "in admin backend" do
+
+    before do
+      authorize_as_admin
+    end
+
+    it "should be possible to set the locale of the admin backend via params" do
+      visit admin_dashboard_path(:locale => :de)
+      page.should have_content('Willkommen')
+    end
+
+    it "should store the current locale in the session" do
+      visit admin_dashboard_path(:locale => :de)
+      visit admin_dashboard_path
+      page.should have_content('Willkommen')
+    end
+
+    it "should be possible to change the current locale in the session" do
+      visit admin_dashboard_path(:locale => :de)
+      visit admin_dashboard_path(:locale => :en)
+      page.should have_content('Welcome')
+    end
+
+    it "should not be possible to switch the locale of the admin backend to an unknown locale" do
+      visit admin_dashboard_path(:locale => :ko)
+      page.should have_content('Welcome')
+    end
+
+    it "should use the current users language setting if no other parameter is given" do
+      Alchemy::User.first.update_attributes(:language => :de)
+      visit admin_dashboard_path
+      page.should have_content('Willkommen')
+    end
+
+  end
+
+  context "with translated header" do
+
+    before do
+      # Hack my hack.... OMG
+      Rails.stub(:env).and_return('foo')
+      Capybara.current_driver = :rack_test_translated_header
+    end
+
+    it "should use the browsers language setting if no other parameter is given" do
+      visit root_path
+      ::I18n.locale.should == :de
+    end
+
+  end
+
+end

data/spec/libraries/essence_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe "ActsAsEssence" do
+
+  let(:element) { FactoryGirl.create(:element, :name => 'headline', :create_contents_after_create => true) }
+
+  describe '#ingredient=' do
+
+    it "should set the value to ingredient column" do
+      content = element.content_by_name('headline')
+      content.essence.ingredient = 'Hallo'
+      content.essence.save
+      content.essence.ingredient.should == 'Hallo'
+    end
+
+  end
+
+end

data/spec/libraries/resource_spec.rb

@@ -4,117 +4,139 @@ require File.dirname(__FILE__) + '/../../lib/alchemy/resource'
 class Event
 end
 
-
-describe Alchemy::Resource do
-
-  it "is initialized with a controller_path" do
-    resource = Alchemy::Resource.new("admin/events")
-    resource.should be_a Alchemy::Resource
-  end
-  it "can be can be initialized with an alchemy module_definition" do
-    resource = Alchemy::Resource.new("admin/events", {'engine_name' => 'engine'})
-    resource.should be_a Alchemy::Resource
+module Namespace1
+  module Namespace2
+    class Event
+    end
   end
+end
 
-  describe "model_array" do
-    it "splits the controller_path and returns it as array." do
-      resource = Alchemy::Resource.new("namespace1/namespace2/events")
-      resource.model_array.should eql(['namespace1', 'namespace2', 'events'])
-    end
+module Namespace
+  class Event
+  end
+end
 
-    it "deletes 'admin' if found hence our model isn't in the admin-namespace by convention" do
-      resource = Alchemy::Resource.new("admin/events")
-      resource.model_array.should eql(['events'])
+module Engine
+  module Namespace
+    class Event
     end
   end
+end
 
-  describe "instance methods" do
-      let(:resource) { Alchemy::Resource.new("admin/events") }
+module Alchemy
+  describe Resource do
 
-    describe "model" do
-      it "returns resource's model-class" do
-        resource.model.should be(Event)
-      end
+    it "is initialized with a controller_path" do
+      resource = Resource.new("admin/events")
+      resource.should be_a Resource
+    end
+    it "can be can be initialized with an alchemy module_definition" do
+      resource = Resource.new("admin/events", {'engine_name' => 'engine'})
+      resource.should be_a Resource
+    end
 
-      describe "resources_name" do
-        it "returns plural name (like events for model Event)" do
-          resource.resources_name.should == 'events'
-        end
+    describe "model_array" do
+      it "splits the controller_path and returns it as array." do
+        resource = Resource.new("namespace1/namespace2/events")
+        resource.model_array.should eql(['namespace1', 'namespace2', 'events'])
       end
 
-      describe "model_name" do
-        it "returns model_name (like event for model Event" do
-          resource.model_name.should == 'event'
-        end
+      it "deletes 'admin' if found hence our model isn't in the admin-namespace by convention" do
+        resource = Resource.new("admin/events")
+        resource.model_array.should eql(['events'])
       end
+    end
 
-      describe "permission_scope" do
-        it "should return the permissions_scope usable in declarative authorization" do
-          resource.permission_scope.should == :admin_events
-        end
-      end
+    describe "instance methods" do
+      let(:resource) { Resource.new("admin/events") }
 
-      describe "namespace_for_scope" do
-        it "returns a scope for use in url_for-based path-helpers" do
-          resource.namespace_for_scope.should == ['admin']
+      describe "model" do
+        it "returns resource's model-class" do
+          resource.model.should be(Event)
         end
-      end
 
-      describe "attributes" do
-        before :each do
-          ##stubbing an ActiveRecord::ModelSchema...
-          columns = [
-            mock(:column, {:name => 'name', :type => :string}),
-            mock(:column, {:name => 'hidden_value', :type => :string}),
-            mock(:column, {:name => 'description', :type => :string}),
-            mock(:column, {:name => 'id', :type => :integer}),
-            mock(:column, {:name => 'starts_at', :type => :datetime}),
-          ]
-          Event.stub(:columns).and_return columns
+        describe "resources_name" do
+          it "returns plural name (like events for model Event)" do
+            resource.resources_name.should == 'events'
+          end
         end
 
-        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}, {:name => "description", :type => :string}, {:name => "starts_at", :type => :datetime}]
+        describe "model_name" do
+          it "returns model_name (like event for model Event" do
+            resource.model_name.should == 'event'
+          end
         end
 
-        it "skips a set of default attributes (DEFAULT_SKIPPED_ATTRIBUTES)" do
-          resource.attributes.should_not include({:name => "id", :type => :integer})
-          resource.attributes.should include({:name => "hidden_value", :type => :string})
+        describe "permission_scope" do
+          it "should return the permissions_scope usable in declarative authorization" do
+            resource.permission_scope.should == :admin_events
+          end
         end
 
-        it "should skip attributes set via skip_attributes" do
-          resource.skip_attributes = %W[hidden_value]
-          resource.attributes.should include({:name => "id", :type => :integer})
-          resource.attributes.should_not include({:name => "hidden_value", :type => :string})
+        describe "namespace_for_scope" do
+          it "returns a scope for use in url_for-based path-helpers" do
+            resource.namespace_for_scope.should == ['admin']
+          end
         end
 
-        describe "searchable_attributes" do
-          it "should return all attributes of type string" do
-            resource.skip_attributes = []
-            resource.searchable_attributes.should == [{:name => "name", :type => :string}, {:name => "hidden_value", :type => :string}, {:name => "description", :type => :string}]
+        describe "attributes" do
+          before :each do
+            ##stubbing an ActiveRecord::ModelSchema...
+            columns = [
+              mock(:column, {:name => 'name', :type => :string}),
+              mock(:column, {:name => 'hidden_value', :type => :string}),
+              mock(:column, {:name => 'description', :type => :string}),
+              mock(:column, {:name => 'id', :type => :integer}),
+              mock(:column, {:name => 'starts_at', :type => :datetime}),
+            ]
+            Event.stub(:columns).and_return columns
+            Config.stub(:get).and_return {}
+          end
+
+          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}, {:name => "description", :type => :string}, {:name => "starts_at", :type => :datetime}]
+          end
+
+          it "skips a set of default attributes (DEFAULT_SKIPPED_ATTRIBUTES)" do
+            resource.attributes.should_not include({:name => "id", :type => :integer})
+            resource.attributes.should include({:name => "hidden_value", :type => :string})
+          end
+
+          it "should skip attributes set via skip_attributes" do
+            resource.skip_attributes = %W[hidden_value]
+            resource.attributes.should include({:name => "id", :type => :integer})
+            resource.attributes.should_not include({:name => "hidden_value", :type => :string})
+          end
+
+          describe "searchable_attributes" do
+            it "should return all attributes of type string" do
+              resource.skip_attributes = []
+              resource.searchable_attributes.should == [{:name => "name", :type => :string}, {:name => "hidden_value", :type => :string}, {:name => "description", :type => :string}]
+            end
           end
         end
+
       end
 
-    end
+      describe "namespaced_model_name" do
 
-    describe "namespaced_model_name" do
-      it "returns model_name with namespace (namespace_event for Namespace::Event), i.e. for use in forms" do
-        namespaced_resource = Alchemy::Resource.new("admin/namespace/events")
-        namespaced_resource.namespaced_model_name.should == 'namespace_event'
-      end
+        it "returns model_name with namespace (namespace_event for Namespace::Event), i.e. for use in forms" do
+          namespaced_resource = Resource.new("admin/namespace/events")
+          namespaced_resource.namespaced_model_name.should == 'namespace_event'
+        end
 
-      it "should not include the engine's name" do
-        namespaced_resource = Alchemy::Resource.new("admin/engine/namespace/events", {'engine_name' => 'engine'})
-        namespaced_resource.namespaced_model_name.should == 'namespace_event'
-      end
+        it "should not include the engine's name" do
+          namespaced_resource = Resource.new("admin/engine/namespace/events", {'engine_name' => 'engine'})
+          namespaced_resource.namespaced_model_name.should == 'namespace_event'
+        end
 
-      it "should equal model_name if model not namespaced" do
-        namespaced_resource = Alchemy::Resource.new("admin/events")
-        namespaced_resource.namespaced_model_name.should == namespaced_resource.model_name
+        it "should equal model_name if model not namespaced" do
+          namespaced_resource = Resource.new("admin/events")
+          namespaced_resource.namespaced_model_name.should == namespaced_resource.model_name
+        end
       end
-    end
 
 
+    end
   end
 end