alchemy_cms 3.2.0.beta → 3.2.0.rc1

data/spec/models/element_to_page_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module Alchemy
+  describe ElementToPage do
+
+    # ClassMethods
+
+    describe '.table_name' do
+      it "should return table name" do
+        expect(ElementToPage.table_name).to eq('alchemy_elements_alchemy_pages')
+      end
+    end
+  end
+end

data/spec/models/page_spec.rb

@@ -416,6 +416,26 @@ module Alchemy
       end
     end
 
+    describe '.ancestors_for' do
+      let(:lang_root) { Page.language_root_for(Language.default.id) }
+      let(:parent)    { create(:public_page) }
+      let(:page)      { create(:public_page, parent_id: parent.id) }
+
+      it "returns an array of all parents including self" do
+        expect(Page.ancestors_for(page)).to eq([lang_root, parent, page])
+      end
+
+      it "does not include the root page" do
+        expect(Page.ancestors_for(page)).not_to include(Page.root)
+      end
+
+      context "with current page nil" do
+        it "should return an empty array" do
+          expect(Page.ancestors_for(nil)).to eq([])
+        end
+      end
+    end
+
     describe '.contentpages' do
       before do
         layoutroot = Page.find_or_create_layout_root_for(klingonian.id)
@@ -760,7 +780,7 @@ module Alchemy
     describe '#cell_definitions' do
       before do
         @page = FactoryGirl.build(:page, page_layout: 'foo')
-        allow(@page).to receive(:layout_description).and_return({'name' => "foo", 'cells' => ["foo_cell"]})
+        allow(@page).to receive(:definition).and_return({'name' => "foo", 'cells' => ["foo_cell"]})
         @cell_descriptions = [{'name' => "foo_cell", 'elements' => ["1", "2"]}]
         allow(Cell).to receive(:definitions).and_return(@cell_descriptions)
       end
@@ -770,7 +790,7 @@ module Alchemy
       end
 
       it "should return empty array if no cells defined in page layout" do
-        allow(@page).to receive(:layout_description).and_return({'name' => "foo"})
+        allow(@page).to receive(:definition).and_return({'name' => "foo"})
         expect(@page.cell_definitions).to eq([])
       end
     end
@@ -797,17 +817,6 @@ module Alchemy
       end
     end
 
-    describe '#element_definitions' do
-      let(:page) { FactoryGirl.build_stubbed(:page) }
-      subject { page.element_definitions }
-      before { expect(Element).to receive(:definitions).and_return([{'name' => 'article'}, {'name' => 'header'}]) }
-
-      it "returns all element definitions that could be placed on current page" do
-        is_expected.to include({'name' => 'article'})
-        is_expected.to include({'name' => 'header'})
-      end
-    end
-
     describe '#element_definitions_by_name' do
       let(:page) { FactoryGirl.build_stubbed(:public_page) }
 
@@ -835,13 +844,96 @@ module Alchemy
     describe '#element_definition_names' do
       let(:page) { FactoryGirl.build_stubbed(:public_page) }
 
-      it "returns all element names defined in page layout" do
-        expect(page.element_definition_names).to eq(%w(article header))
+      context "with assigned elements from page and cell definition" do
+        before do
+          allow(page).to receive(:element_names_from_page_definition).and_return(['header', 'article'])
+          allow(page).to receive(:element_names_from_cell_definition).and_return(['search'])
+        end
+
+        it "returns the combined element names" do
+          expect(page.element_definition_names).to eq(%w(header article search))
+        end
+
+        context "when cell definition contains same element name as page definition" do
+          before do
+            allow(page).to receive(:element_names_from_page_definition).and_return(['header', 'article'])
+            allow(page).to receive(:element_names_from_cell_definition).and_return(['header', 'search'])
+          end
+
+          it "returns no duplicates" do
+            expect(page.element_definition_names).to eq(%w(header article search))
+          end
+        end
       end
 
-      it "returns always an array" do
-        allow(page).to receive(:definition).and_return({})
-        expect(page.element_definition_names).to be_an(Array)
+      context "without assigned elements from page definition" do
+        before do
+          allow(page).to receive(:element_names_from_page_definition).and_return([])
+          allow(page).to receive(:element_names_from_cell_definition).and_return(['article'])
+        end
+
+        it "returns an array" do
+          expect(page.element_definition_names).to be_an(Array)
+        end
+      end
+
+      context "without assigned elements from cell definition" do
+        before do
+          allow(page).to receive(:element_names_from_page_definition).and_return(['article'])
+          allow(page).to receive(:element_names_from_cell_definition).and_return([])
+        end
+
+        it "returns an array" do
+          expect(page.element_definition_names).to be_an(Array)
+        end
+      end
+    end
+
+    describe "#element_names_from_page_definition" do
+      let(:page) { FactoryGirl.build_stubbed(:public_page) }
+
+      context "with assigned elements from page definition" do
+        before do
+          allow(page).to receive(:definition).and_return(
+            {'name' => 'test_page', 'elements' => ['article']}
+          )
+        end
+
+        it "returns an array of the page's element names" do
+          expect(page.element_names_from_page_definition).to eq(['article'])
+        end
+      end
+
+      context "without assigned elements from page definition" do
+        before do
+          allow(page).to receive(:definition).and_return({})
+        end
+
+        it "returns an array" do
+          expect(page.element_names_from_page_definition).to be_an(Array)
+        end
+      end
+    end
+
+    describe "#element_names_from_cell_definition" do
+      let(:page) { FactoryGirl.build_stubbed(:public_page) }
+
+      context "with assigned elements from cell definition" do
+        before do
+          allow(page).to receive(:cell_definitions).and_return([
+            {'name' => 'header', 'elements' => ['article']}
+          ])
+        end
+
+        it "returns an array of the cell's element names" do
+          expect(page.element_names_from_cell_definition).to eq(['article'])
+        end
+      end
+
+      context "without assigned elements from cell definition" do
+        it "returns an array" do
+          expect(page.element_names_from_cell_definition).to be_an(Array)
+        end
       end
     end
 
@@ -1589,7 +1681,7 @@ module Alchemy
 
     context 'indicate page editors' do
       let(:page) { Page.new }
-      let(:user) { create(:editor_user) }
+      let(:user) { create(:alchemy_dummy_user, :as_editor) }
 
       describe '#creator' do
         before { page.update(creator_id: user.id) }

data/spec/routing/routing_spec.rb

@@ -1,142 +1,124 @@
 require 'spec_helper'
 
 describe "The Routing" do
-
   routes { Alchemy::Engine.routes }
 
   context "for downloads" do
-
     it "should have a named route" do
       expect({
-        :get => "/attachment/32/download/Presseveranstaltung.pdf"
+        get: "/attachment/32/download/Presseveranstaltung.pdf"
       }).to route_to(
-        :controller => "alchemy/attachments",
-        :action => "download",
-        :id => "32",
-        :name => "Presseveranstaltung",
-        :format => "pdf"
+        controller: "alchemy/attachments",
+        action: "download",
+        id: "32",
+        name: "Presseveranstaltung",
+        format: "pdf"
       )
     end
-
   end
 
   describe "nested url" do
-
     context "one level deep nested" do
-
       it "should route to pages show" do
         expect({
-          :get => "/products/my-product"
+          get: "/products/my-product"
         }).to route_to(
-          :controller => "alchemy/pages",
-          :action => "show",
-          :urlname => "products/my-product"
+          controller: "alchemy/pages",
+          action: "show",
+          urlname: "products/my-product"
         )
       end
 
       context "and language" do
-
         it "should route to pages show" do
           expect({
-            :get => "/de/products/my-product"
+            get: "/de/products/my-product"
           }).to route_to(
-            :controller => "alchemy/pages",
-            :action => "show",
-            :urlname => "products/my-product",
-            :lang => "de"
+            controller: "alchemy/pages",
+            action: "show",
+            urlname: "products/my-product",
+            locale: "de"
           )
         end
-
       end
-
     end
 
     context "two levels deep nested" do
-
       it "should route to pages show" do
         expect({
-          :get => "/catalog/products/my-product"
+          get: "/catalog/products/my-product"
         }).to route_to(
-          :controller => "alchemy/pages",
-          :action => "show",
-          :urlname => "catalog/products/my-product"
+          controller: "alchemy/pages",
+          action: "show",
+          urlname: "catalog/products/my-product"
         )
       end
 
       context "and language" do
-
         it "should route to pages show" do
           expect({
-            :get => "/de/catalog/products/my-product"
+            get: "/de/catalog/products/my-product"
           }).to route_to(
-            :controller => "alchemy/pages",
-            :action => "show",
-            :urlname => "catalog/products/my-product",
-            :lang => "de"
+            controller: "alchemy/pages",
+            action: "show",
+            urlname: "catalog/products/my-product",
+            locale: "de"
           )
         end
-
       end
-
     end
 
     context "with a blog date url" do
-
       it "should route to pages show" do
         expect({
-          :get => "/2011/12/08/my-post"
+          get: "/2011/12/08/my-post"
         }).to route_to(
-          :controller => "alchemy/pages",
-          :action => "show",
-          :urlname => "2011/12/08/my-post"
+          controller: "alchemy/pages",
+          action: "show",
+          urlname: "2011/12/08/my-post"
         )
       end
 
       context "and language" do
-
         it "should route to pages show" do
           expect({
-            :get => "/de/2011/12/08/my-post"
+            get: "/de/2011/12/08/my-post"
           }).to route_to(
-            :controller => "alchemy/pages",
-            :action => "show",
-            :urlname => "2011/12/08/my-post",
-            :lang => "de"
+            controller: "alchemy/pages",
+            action: "show",
+            urlname: "2011/12/08/my-post",
+            locale: "de"
           )
         end
-
       end
-
     end
-
   end
 
   describe "for displaying pictures" do
-
     it "should route to show action" do
       expect({
-        :get => "/pictures/3/show/900x300/kitten.jpg"
+        get: "/pictures/3/show/900x300/kitten.jpg"
       }).to route_to(
-        :controller => "alchemy/pictures",
-        :action => "show",
-        :id => "3",
-        :size => "900x300",
-        :name => "kitten",
-        :format => "jpg"
+        controller: "alchemy/pictures",
+        action: "show",
+        id: "3",
+        size: "900x300",
+        name: "kitten",
+        format: "jpg"
       )
     end
 
     it "should route to cropped show action" do
       expect({
-        :get => "/pictures/3/show/900x300/crop/kitten.jpg"
+        get: "/pictures/3/show/900x300/crop/kitten.jpg"
       }).to route_to(
-        :controller => "alchemy/pictures",
-        :action => "show",
-        :id => "3",
-        :size => "900x300",
-        :crop => "crop",
-        :name => "kitten",
-        :format => "jpg"
+        controller: "alchemy/pictures",
+        action: "show",
+        id: "3",
+        size: "900x300",
+        crop: "crop",
+        name: "kitten",
+        format: "jpg"
       )
     end
 
@@ -144,15 +126,15 @@ describe "The Routing" do
       expect(get(
         "/pictures/3/show/300x300/crop/200x50/100x100/kitten.jpg"
       )).to route_to(
-        :controller => "alchemy/pictures",
-        :action => "show",
-        :id => "3",
-        :size => "300x300",
-        :crop => "crop",
-        :crop_from => "200x50",
-        :crop_size => "100x100",
-        :name => "kitten",
-        :format => "jpg"
+        controller: "alchemy/pictures",
+        action: "show",
+        id: "3",
+        size: "300x300",
+        crop: "crop",
+        crop_from: "200x50",
+        crop_size: "100x100",
+        name: "kitten",
+        format: "jpg"
       )
     end
 
@@ -160,12 +142,12 @@ describe "The Routing" do
       expect(get(
         "/pictures/3/thumbnails/small/kitten.jpg"
       )).to route_to(
-        :controller => "alchemy/pictures",
-        :action => "thumbnail",
-        :id => "3",
-        :size => "small",
-        :name => "kitten",
-        :format => "jpg"
+        controller: "alchemy/pictures",
+        action: "thumbnail",
+        id: "3",
+        size: "small",
+        name: "kitten",
+        format: "jpg"
       )
     end
 
@@ -173,13 +155,13 @@ describe "The Routing" do
       expect(get(
         "/pictures/3/thumbnails/small/crop/kitten.jpg"
       )).to route_to(
-        :controller => "alchemy/pictures",
-        :action => "thumbnail",
-        :id => "3",
-        :crop => "crop",
-        :size => "small",
-        :name => "kitten",
-        :format => "jpg"
+        controller: "alchemy/pictures",
+        action: "thumbnail",
+        id: "3",
+        crop: "crop",
+        size: "small",
+        name: "kitten",
+        format: "jpg"
       )
     end
 
@@ -187,14 +169,14 @@ describe "The Routing" do
       expect(get(
         "/pictures/3/thumbnails/small/0x0/200x200/kitten.jpg"
       )).to route_to(
-        :controller => "alchemy/pictures",
-        :action => "thumbnail",
-        :id => "3",
-        :crop_from => "0x0",
-        :crop_size => "200x200",
-        :size => "small",
-        :name => "kitten",
-        :format => "jpg"
+        controller: "alchemy/pictures",
+        action: "thumbnail",
+        id: "3",
+        crop_from: "0x0",
+        crop_size: "200x200",
+        size: "small",
+        name: "kitten",
+        format: "jpg"
       )
     end
 
@@ -202,14 +184,51 @@ describe "The Routing" do
       expect(get(
         "/pictures/3/zoom/kitten.jpg"
       )).to route_to(
-        :controller => "alchemy/pictures",
-        :action => "zoom",
-        :id => "3",
-        :name => "kitten",
-        :format => "jpg"
+        controller: "alchemy/pictures",
+        action: "zoom",
+        id: "3",
+        name: "kitten",
+        format: "jpg"
       )
     end
+  end
 
+  describe "image format requests" do
+    it "should not be handled by alchemy/pages controller" do
+      expect({
+        get: "/products/my-product.jpg"
+      }).not_to be_routable
+    end
   end
 
+  describe "unknown formats" do
+    it "should be handled by alchemy/pages controller" do
+      expect({
+        get: "/index.php?id=234"
+      }).to route_to(
+        controller: "alchemy/pages",
+        action: "show",
+        urlname: "index",
+        format: "php",
+        id: "234"
+      )
+
+      expect({
+        get: "/action.do"
+      }).to route_to(
+        controller: "alchemy/pages",
+        action: "show",
+        urlname: "action",
+        format: "do"
+      )
+    end
+  end
+
+  describe "Rails info requests" do
+    it "should not be handled by alchemy/pages controller" do
+      expect({
+        get: "/rails/info/routes"
+      }).not_to be_routable
+    end
+  end
 end