alchemy_cms 2.5.3.1 → 2.6.0.rc5

data/spec/models/attachment_spec.rb

@@ -1,27 +1,93 @@
+# encoding: utf-8
 require 'spec_helper'
 
 module Alchemy
   describe Attachment do
+    let(:file) { File.new(File.expand_path('../../support/image with spaces.png', __FILE__)) }
+    let(:attachment) { Attachment.new(:file => file) }
 
-    describe '#urlname' do
+    describe 'after create' do
+      before { attachment.save! }
 
-      context "with url characters in the filename" do
-        subject { Attachment.new(:filename => 'f#%&cking cute kitten pic.png') }
+      it "should have a humanized name" do
+        attachment.name.should == "image with spaces"
+      end
+
+      it "should have a valid file_name" do
+        attachment.file_name.should == "image-with-spaces.png"
+      end
+
+      after { attachment.destroy }
+    end
+
+    describe 'urlname sanitizing' do
+      it "should sanitize url characters in the filename" do
+        attachment.file_name = 'f#%&cking cute kitten pic.png'
+        attachment.save!
+        attachment.urlname.should == 'f-cking-cute-kitten-pic.png'
+      end
+
+      it "should sanitize lot of dots in the name" do
+        attachment.file_name = 'cute.kitten.pic.png'
+        attachment.save!
+        attachment.urlname.should == 'cute-kitten-pic.png'
+      end
+
+      it "should sanitize umlauts in the name" do
+        attachment.file_name = 'süßes katzenbild.png'
+        attachment.save!
+        attachment.urlname.should == 'suesses-katzenbild.png'
+      end
+
+      after { attachment.destroy }
+    end
 
-        it "should escape as uri" do
-          subject.urlname.should == 'f___cking_cute_kitten_pic.png'
+    describe 'validations' do
+
+      context "having a png, but only pdf allowed" do
+        before { Config.stub!(:get).and_return({'allowed_filetypes' => {'attachments' => ['pdf']}}) }
+
+        it "should not be valid" do
+          attachment.should_not be_valid
         end
       end
 
-      context "with lot of dots in the name" do
-        subject { Attachment.new(:filename => 'cute.kitten.pic.png') }
+      context "having a png and everything allowed" do
+        before { Config.stub!(:get).and_return({'allowed_filetypes' => {'attachments' => ['*']}}) }
 
-        it "should convert dots in the name part into dashes" do
-          subject.urlname.should == 'cute-kitten-pic.png'
+        it "should be valid" do
+          attachment.should be_valid
         end
       end
 
     end
 
+    context 'PNG image' do
+      subject { stub_model(Attachment, :file_name => 'kitten.png') }
+      its(:extension) { should == "png" }
+    end
+
+    describe 'css classes' do
+      context 'mp3 file' do
+        subject { stub_model(Attachment, :file_mime_type => 'audio/mpeg') }
+        its(:icon_css_class) { should == "audio" }
+      end
+
+      context 'png file' do
+        subject { stub_model(Attachment, :file_mime_type => 'image/png') }
+        its(:icon_css_class) { should == "image" }
+      end
+
+      context 'vcf file' do
+        subject { stub_model(Attachment, :file_mime_type => 'application/vcard') }
+        its(:icon_css_class) { should == "vcard" }
+      end
+
+      context 'zip file' do
+        subject { stub_model(Attachment, :file_mime_type => 'application/zip') }
+        its(:icon_css_class) { should == "archive" }
+      end
+    end
+
   end
 end

data/spec/models/clipboard_spec.rb

@@ -46,7 +46,7 @@ module Alchemy
 
     context "full clipboard" do
 
-      before(:all) do
+      before do
         clipboard[:elements] = [{:id => 1}, {:id => 2}]
         clipboard[:pages] = [{:id => 2}, {:id => 3}]
       end

data/spec/models/element_spec.rb

@@ -422,5 +422,12 @@ module Alchemy
 
     end
 
+    describe '#save_contents' do
+      it "should return true if attributes hash is nil" do
+        element = FactoryGirl.create(:element, create_contents_after_create: true)
+        element.save_contents(nil).should be_true
+      end
+    end
+
   end
 end

data/spec/models/page_spec.rb

@@ -176,6 +176,16 @@ module Alchemy
             page.legacy_urls.should be_empty
           end
 
+          it "should not store legacy url twice for same urlname" do
+            page.urlname = 'new-urlname'
+            page.save!
+            page.urlname = 'my-testpage'
+            page.save!
+            page.urlname = 'another-urlname'
+            page.save!
+            page.legacy_urls.select { |u| u.urlname == 'my-testpage' }.size.should == 1
+          end
+
         end
 
         context "urlname has not changed" do
@@ -340,6 +350,7 @@ module Alchemy
     end
 
     describe "#elements_grouped_by_cells" do
+      let(:page) { FactoryGirl.create(:public_page, :do_not_autogenerate => false) }
 
       before do
         PageLayout.stub(:get).and_return({
@@ -352,16 +363,16 @@ module Alchemy
           'name' => "header",
           'elements' => ["header"]
         }])
-        @page = FactoryGirl.create(:public_page, :do_not_autogenerate => false)
       end
 
       it "should return elements grouped by cell" do
-        @page.elements_grouped_by_cells.keys.first.should be_instance_of(Cell)
-        @page.elements_grouped_by_cells.values.first.first.should be_instance_of(Element)
+        elements = page.elements_grouped_by_cells
+        elements.keys.first.should be_instance_of(Cell)
+        elements.values.first.first.should be_instance_of(Element)
       end
 
       it "should only include elements beeing in a cell " do
-        @page.elements_grouped_by_cells.keys.should_not include(nil)
+        page.elements_grouped_by_cells.keys.should_not include(nil)
       end
 
     end
@@ -410,35 +421,54 @@ module Alchemy
 
     end
 
-    describe "validations" do
+    describe "Validations: " do
 
-      context "saving a normal content page" do
+      context "Creating a normal content page" do
 
-        it "should be possible to save when its urlname already exists in the scope of global pages" do
-          contentpage = FactoryGirl.create(:page, :urlname => "existing_twice")
-          global_with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice", :layoutpage => true)
-          contentpage.title = "new Title"
-          contentpage.save.should == true
-        end
+        let(:contentpage) { FactoryGirl.build(:page) }
 
-      end
-
-      context "creating a normal content page" do
-
-        before do
-          @contentpage = FactoryGirl.build(:page)
+        context "when its urlname exists as global page" do
+          it "it should be possible to save." do
+            contentpage.urlname = "existing_twice"
+            global_with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice", :layoutpage => true)
+            contentpage.should be_valid
+          end
         end
 
         it "should validate the page_layout" do
-          @contentpage.page_layout = nil
-          @contentpage.save
-          @contentpage.should have(1).error_on(:page_layout)
+          contentpage.page_layout = nil
+          contentpage.save
+          contentpage.should have(1).error_on(:page_layout)
         end
 
         it "should validate the parent_id" do
-          @contentpage.parent_id = nil
-          @contentpage.save
-          @contentpage.should have(1).error_on(:parent_id)
+          contentpage.parent_id = nil
+          contentpage.save
+          contentpage.should have(1).error_on(:parent_id)
+        end
+
+        it "should validate the uniqueness of urlname" do
+          with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice")
+          contentpage.urlname = 'existing_twice'
+          contentpage.should_not be_valid
+        end
+
+        context "with url_nesting set to true" do
+          before { Config.stub!(:get).and_return(true) }
+
+          it "should only validate urlname dependent of parent" do
+            other_parent = FactoryGirl.create(:page, parent_id: Page.root.id)
+            with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice")
+            contentpage.urlname = 'existing_twice'
+            contentpage.parent_id = other_parent.id
+            contentpage.should be_valid
+          end
+
+          it "should validate urlname dependent of parent" do
+            with_same_urlname = FactoryGirl.create(:page, :urlname => "existing_twice")
+            contentpage.urlname = 'existing_twice'
+            contentpage.should_not be_valid
+          end
         end
 
       end
@@ -763,7 +793,7 @@ module Alchemy
     end
 
     describe "#publish!" do
-      let(:page) { stub_model(Page, public: false, name: "page", parent_id: 1, urlname: "page", language: stub_model(Language), page_layout: "bla") }
+      let(:page) { FactoryGirl.create(:page) }
       before { page.publish! }
 
       it "sets public attribute to true" do
@@ -771,5 +801,94 @@ module Alchemy
       end
     end
 
+    describe 'urlname updating' do
+      let(:parentparent) { FactoryGirl.create(:page, name: 'parentparent', visible: true) }
+      let(:parent)       { FactoryGirl.create(:page, parent_id: parentparent.id, name: 'parent', visible: true) }
+      let(:page)         { FactoryGirl.create(:page, parent_id: parent.id, name: 'page', visible: true) }
+      let(:invisible)    { FactoryGirl.create(:page, parent_id: page.id, name: 'invisible', visible: false) }
+      let(:contact)      { FactoryGirl.create(:page, parent_id: invisible.id, name: 'contact', visible: true) }
+
+      context "with activated url_nesting" do
+        before { Config.stub!(:get).and_return(true) }
+
+        it "should store all parents urlnames delimited by slash" do
+          page.urlname.should == 'parentparent/parent/page'
+        end
+
+        it "should not include the root page" do
+          page.urlname.should_not =~ /root/
+        end
+
+        it "should not include the language root page" do
+          page.urlname.should_not =~ /startseite/
+        end
+
+        it "should not include invisible pages" do
+          contact.urlname.should_not =~ /invisible/
+        end
+
+        context "after changing my urlname" do
+          it "should update urlnames of descendants" do
+            page
+            parentparent.urlname = 'new-urlname'
+            parentparent.save!
+            page.reload
+            page.urlname.should == 'new-urlname/parent/page'
+          end
+
+          it "should create a legacy url" do
+            page.stub!(:slug).and_return('foo')
+            page.update_urlname!
+            page.legacy_urls.should_not be_empty
+            page.legacy_urls.collect(&:urlname).should include('parentparent/parent/page')
+          end
+        end
+
+        context "after updating my visibility" do
+          it "should update urlnames of descendants" do
+            page
+            parentparent.visible = false
+            parentparent.save!
+            page.reload
+            page.urlname.should == 'parent/page'
+          end
+        end
+      end
+
+      context "with disabled url_nesting" do
+        before { Config.stub!(:get).and_return(false) }
+
+        it "should only store my urlname" do
+          page.urlname.should == 'page'
+        end
+      end
+    end
+
+    describe '#slug' do
+      context "with parents path saved in urlname" do
+        let(:page) { FactoryGirl.build(:page, urlname: 'root/parent/my-name')}
+
+        it "should return the last part of the urlname" do
+          page.slug.should == 'my-name'
+        end
+      end
+
+      context "with single urlname" do
+        let(:page) { FactoryGirl.build(:page, urlname: 'my-name')}
+
+        it "should return the last part of the urlname" do
+          page.slug.should == 'my-name'
+        end
+      end
+
+      context "with nil as urlname" do
+        let(:page) { FactoryGirl.build(:page, urlname: nil)}
+
+        it "should return nil" do
+          page.slug.should be_nil
+        end
+      end
+    end
+
   end
 end

data/spec/models/picture_spec.rb

@@ -52,21 +52,21 @@ module Alchemy
       it "should return a humanized version of original filename" do
         pic = stub_model(Picture, :image_file_name => 'cute_kitten.JPG')
         pic.stub(:image_file).and_return(OpenStruct.new({:ext => 'jpg'}))
-        pic.humanized_name.should == "Cute kitten"
+        pic.humanized_name.should == "cute kitten"
       end
 
       it "should not remove incidents of suffix from filename" do
         pic = stub_model(Picture, :image_file_name => 'cute_kitten_mo.jpgi.JPG')
         pic.stub(:image_file).and_return(OpenStruct.new({:ext => 'jpg'}))
-        pic.humanized_name.should == "Cute kitten mo.jpgi"
-        pic.humanized_name.should_not == "Cute kitten moi"
+        pic.humanized_name.should == "cute kitten mo.jpgi"
+        pic.humanized_name.should_not == "cute kitten moi"
       end
 
       context "image has no suffix" do
         it "should return humanized name" do
           pic = stub_model(Picture, :image_file_name => 'cute_kitten')
           pic.stub(:suffix).and_return("")
-          pic.humanized_name.should == "Cute kitten"
+          pic.humanized_name.should == "cute kitten"
         end
       end
 
@@ -116,7 +116,7 @@ module Alchemy
 
     describe '.recent' do
 
-      before(:all) do
+      before do
         now = Time.now
         @recent = Picture.create!(:image_file => image_file)
         @old_picture = Picture.create!(:image_file => image_file)

data/spec/models/resource_spec.rb

@@ -44,9 +44,9 @@ module Alchemy
       end
     end
 
-    describe "#model_name" do
+    describe "#resource_name" do
       it "should return the model name (singularized and as a string)" do
-        resource.model_name.should == "event"
+        resource.resource_name.should == "event"
       end
     end
 
@@ -94,28 +94,65 @@ module Alchemy
 
       context "when resource_relations defined as class-method in the model" do
         before do
+          ::ActiveSupport::Deprecation.silenced = true
           Event.class_eval do
             def self.resource_relations
               {
-                :location_id => {:attr_method => "location#name", :attr_type => :string},
-                :organizer_id => {:attr_method => "organizer#name", :attr_type => :string}
+                :location => {:attr_method => "location#name", :attr_type => :string}
               }
             end
           end
         end
+
+        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 "should 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
+
+        it "should add _id to relation key" do
+          resource.resource_relations[:location_id].should_not be_nil
+        end
+
+        it "should store the relation name" do
+          relation = resource.resource_relations[:location_id]
+          relation.keys.should include(:name)
+          relation[:name].should == 'location'
+        end
+
+        context "with old hash delimited attr_method style" do
+          it "should show deprecation warnings" do
+            ActiveSupport::Deprecation.should_receive(:warn)
+            resource.resource_relations
+          end
+
+          it "should return the last part as attr_method" do
+            resource.resource_relations[:location_id][:attr_method].should == 'name'
+          end
+        end
+
+        context "#attributes" do
+          it "should contain the relation" do
+            resource.attributes.detect { |a| a[:name] == 'location_id' }.keys.should include(:relation)
+          end
+
+          it "should have the relation column type as type" do
+            resource.attributes.detect { |a| a[:name] == "location_id" }[:type].should == :string
+          end
+        end
+
         after do
+          ::ActiveSupport::Deprecation.silenced = false
           Event.class_eval do
             class << self
               undef :resource_relations
             end
           end
         end
-        it "should use the attribute location#name instead of location_id" do
-          resource.attributes.detect { |a| a[:name] == "location#name" }.should == {:name => "location#name", :type => :string}
-        end
-        it "should use the attribute organizer#name instead of organizer_id" do
-          resource.attributes.detect { |a| a[:name] == "organizer#name" }.should == {:name => "organizer#name", :type => :string}
-        end
       end
 
       context "when resource_relation is not defined" do