alchemy_cms 2.9.1 → 3.0.0.rc5

data/spec/libraries/resources_helper_spec.rb

@@ -1,4 +1,5 @@
-require 'spec_helper'
+require File.dirname(__FILE__) + "/../../lib/alchemy/resource"
+require File.dirname(__FILE__) + "/../../lib/alchemy/resources_helper"
 
 module Namespace
   class MyResource
@@ -9,136 +10,135 @@ module EngineResource
 end
 
 class ResourcesController
+  include Alchemy::ResourcesHelper
+
   def resource_handler
-    @resource_handler = Alchemy::Resource.new('admin/namespace/my_resources')
+    @resource_handler ||= Alchemy::Resource.new('admin/namespace/my_resources')
   end
-
-  include Alchemy::ResourcesHelper
 end
 
 class ResourcesControllerForEngine
+  include Alchemy::ResourcesHelper
+
   def resource_handler
-    @resource_handler = Alchemy::Resource.new('admin/engine_resources', {'engine_name' => 'my_engine'})
+    @resource_handler ||= Alchemy::Resource.new('admin/engine_resources', {'engine_name' => 'my_engine'})
   end
-
-  include Alchemy::ResourcesHelper
 end
 
 
 describe Alchemy::ResourcesHelper do
+  let(:controller) { ResourcesController.new }
+  let(:resource_item) { double('resource-item') }
 
-  before :each do
-    @controller = ResourcesController.new
-    @controller.stub(:main_app).and_return 'main_app_proxy'
-    @resource_item = stub('resource-item')
-    @controller.instance_variable_set('@my_resource', @resource_item)
-    @controller.instance_variable_set('@my_resources', [@resource_item])
-  end
+  before {
+    controller.stub(:main_app).and_return 'main_app_proxy'
+    controller.instance_variable_set('@my_resource', resource_item)
+    controller.instance_variable_set('@my_resources', [resource_item])
+  }
 
   describe "path-helpers" do
-
     describe "#resource_url_proxy" do
-
       it "returns the current proxy for url-helper-methods" do
-        @controller.resource_url_proxy.should == 'main_app_proxy'
+        controller.resource_url_proxy.should == 'main_app_proxy'
       end
 
       context "when resource is in engine" do
+        let(:controller_for_engine) { ResourcesControllerForEngine.new }
+        before { controller_for_engine.stub('my_engine').and_return('my_engine_proxy') }
+
         it "returns the engine's proxy" do
-          @controller_for_engine = ResourcesControllerForEngine.new
-          @controller_for_engine.stub('my_engine').and_return 'my_engine_proxy'
-          @controller_for_engine.resource_url_proxy.should == 'my_engine_proxy'
+          controller_for_engine.resource_url_proxy.should == 'my_engine_proxy'
         end
       end
-
     end
 
     describe "#resource_scope" do
       it "returns an array containing a proxy and namespaces for url_for-based helper-methods" do
-        @controller.resource_scope.should == %W[main_app_proxy admin]
+        controller.resource_scope.should == %W[main_app_proxy admin]
       end
     end
 
     describe "#resource_path" do
-
       it "invokes polymorphic-path with correct scope and object" do
-        my_resource_item = stub
-        @controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", my_resource_item], {})
-        @controller.resource_path(my_resource_item)
+        my_resource_item = double
+        controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", my_resource_item], {})
+        controller.resource_path(my_resource_item)
       end
 
       it "uses resource_name when no object is given" do
-        @controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", "my_resource"], {})
-        @controller.resource_path
+        controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", "my_resource"], {})
+        controller.resource_path
       end
-
     end
 
     describe "#resources_path" do
       it "invokes polymorphic-path with correct scope and resources_name" do
-        @controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", "my_resources"], {})
-        @controller.resources_path
+        controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", "my_resources"], {})
+        controller.resources_path
       end
     end
 
     describe "#new_resource_path" do
       it "invokes new_polymorphic_path with correct scope and resource_name" do
-        @controller.should_receive(:new_polymorphic_path).with(["main_app_proxy", "admin", "my_resource"], {})
-        @controller.new_resource_path
+        controller.should_receive(:new_polymorphic_path).with(["main_app_proxy", "admin", "my_resource"], {})
+        controller.new_resource_path
       end
     end
 
-
     describe "#edit_resource_path" do
       it "invokes edit_polymorphic_path with correct scope and resource_name" do
-        my_resource_item = stub
-        @controller.should_receive(:edit_polymorphic_path).with(["main_app_proxy", "admin", my_resource_item], {})
-        @controller.edit_resource_path(my_resource_item)
+        my_resource_item = double
+        controller.should_receive(:edit_polymorphic_path).with(["main_app_proxy", "admin", my_resource_item], {})
+        controller.edit_resource_path(my_resource_item)
       end
     end
-
   end
 
   describe "#resource_instance_variable" do
     it "returns the resource_item" do
-      @controller.resource_instance_variable.should == @resource_item
+      controller.resource_instance_variable.should == resource_item
     end
   end
 
   describe "#resources_instance_variable" do
     it "returns a collection of resource_items" do
-      @controller.resources_instance_variable.should == [@resource_item]
+      controller.resources_instance_variable.should == [resource_item]
     end
   end
 
   describe "#resource_window_size" do
     it "returns overlay size string depending on resource attributes length" do
-      @controller.stub(:resource_handler).and_return(OpenStruct.new(:attributes => OpenStruct.new(:length => 4)))
-      @controller.resource_window_size.should == "420x260"
+      controller.stub_chain(:resource_handler, :attributes, :length).and_return(4)
+      controller.resource_window_size.should == "420x260"
     end
   end
 
   describe "#render_attribute" do
     it "should return the value from resource attribute" do
-      @resource_item.stub!(:name).and_return('my-name')
-      @controller.render_attribute(@resource_item, {:name => 'name'}).should == 'my-name'
+      resource_item.stub(:name).and_return('my-name')
+      controller.render_attribute(resource_item, {name: 'name'}).should == 'my-name'
     end
 
     context "resource having a relation" do
+      let(:associated_object) { double("location", title: 'Title of related object') }
+      let(:associated_klass) { double("klass", find: associated_object) }
+      let(:relation) {
+        {
+          attr_method: 'title',
+          model_association: OpenStruct.new(klass: associated_klass)
+        }
+      }
+
       it "should return the value from the related object attribute" do
-        @resource_item.stub!(:name).and_return('my-name')
-        associated_object = double("location", :title => 'Title of related object')
-        associated_klass = double("klass", :find => associated_object)
-        relation = {:attr_method => :title, :model_association => OpenStruct.new(:klass => associated_klass)}
-        @controller.render_attribute(@resource_item, {:name => 'name', :relation => relation}).should == 'Title of related object'
+        resource_item.stub(:name).and_return('my-name')
+        controller.render_attribute(resource_item, {name: 'name', relation: relation}).should == 'Title of related object'
       end
     end
   end
 
   describe "#resource_name" do
     it "returns resource_handler.resource_name" do
-      @controller.resource_name.should == "my_resource"
+      controller.resource_name.should == "my_resource"
     end
   end
-
 end

data/spec/libraries/shell_spec.rb

@@ -10,11 +10,11 @@ module Alchemy
 
   describe Shell do
 
-    before { MyToDoList.stub!(:puts) }
+    before { MyToDoList.stub(:puts) }
 
     describe '.todo' do
       it "should add given string as a todo by delegating to .add_todo" do
-        MyToDoList.should_receive(:add_todo).with("new todo")
+        MyToDoList.should_receive(:add_todo).with(["", "new todo"])
         MyToDoList.todo("new todo")
       end
     end
@@ -36,11 +36,11 @@ module Alchemy
     describe '.display_todos' do
       context 'if there are todos in the list' do
         before do
-          MyToDoList.stub!(:todos).and_return(['My first todo', 'My second todo'])
+          MyToDoList.stub(:todos).and_return(['My first todo', 'My second todo'])
         end
 
         it "should log them" do
-          MyToDoList.should_receive(:log).any_number_of_times
+          MyToDoList.should_receive(:log).at_least(1).times
           MyToDoList.display_todos
         end
 
@@ -52,7 +52,7 @@ module Alchemy
 
       context 'if there are todos in the list' do
         before do
-          MyToDoList.stub!(:todos).and_return([])
+          MyToDoList.stub(:todos).and_return([])
         end
 
         it "should not log anything" do
@@ -63,7 +63,6 @@ module Alchemy
     end
 
     describe '.log' do
-
       context 'if the message type is "skip"' do
         it "the output color should be yellow and cleared again" do
           MyToDoList.should_receive(:color).with(:yellow)
@@ -100,7 +99,7 @@ module Alchemy
 
       context 'if given name is a constant of Thor::Shell::Color' do
         before do
-          Thor::Shell::Color.stub!(:const_defined?).and_return(true)
+          Thor::Shell::Color.stub(:const_defined?).and_return(true)
         end
 
         it "should call the constant" do
@@ -111,7 +110,7 @@ module Alchemy
 
       context 'if given name is not a defined constant of Thor::Shell::Color' do
         before do
-          Thor::Shell::Color.stub!(:const_defined?).and_return(false)
+          Thor::Shell::Color.stub(:const_defined?).and_return(false)
         end
 
         it "should return en empty string" do

data/spec/libraries/template_tracker_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+module Alchemy
+  module CacheDigests
+    describe TemplateTracker do
+      subject { TemplateTracker.call(name, nil) }
+
+      describe '#dependencies' do
+        context 'with alchemy/pages/show given as template name' do
+          let(:name) { 'alchemy/pages/show' }
+          before { PageLayout.stub(:all).and_return([{'name' => 'intro'}, {'name' => 'contact'}]) }
+
+          it "returns all page layout view partial names" do
+            should include('alchemy/page_layouts/_intro', 'alchemy/page_layouts/_contact')
+          end
+        end
+
+        context 'with a page layout given as template name' do
+          let(:name) { 'alchemy/page_layouts/_intro' }
+          let(:page_layout) { {'name' => 'intro', 'elements' => ['text']} }
+          before { PageLayout.stub(:get).and_return(page_layout) }
+
+          it "returns all element layout view partial names for that layout" do
+            should include('alchemy/elements/_text_view')
+          end
+
+          context 'and page layout having cells' do
+            let(:page_layout) { {'name' => 'intro', 'elements' => ['text'], 'cells' => ['header']} }
+
+            it "returns all cell view partial names for that layout" do
+              should include('alchemy/cells/_header')
+            end
+          end
+        end
+
+        context 'with a cell given as template name' do
+          let(:name) { 'alchemy/cells/_header' }
+          before { Cell.stub(:definition_for).and_return({'name' => 'header', 'elements' => ['text']}) }
+
+          it "returns all element layout view partial names for that cell" do
+            should include('alchemy/elements/_text_view')
+          end
+        end
+
+        context 'with an element given as name' do
+          let(:name) { 'alchemy/elements/_text_view' }
+          let(:elements) { [{'name' => 'text', 'contents' => [{'type' => 'EssenceText'}]}] }
+
+          context 'that is having a description' do
+            before { Element.stub(:descriptions).and_return(elements) }
+
+            it "returns all essence layout view partial names for that element" do
+              should include('alchemy/essences/_essence_text_view')
+            end
+
+            context 'and element has picture_gallery enabled' do
+              let(:elements) { [{'name' => 'text', 'picture_gallery' => true}] }
+
+              it "has EssencePicture as template dependency" do
+                should include('alchemy/essences/_essence_picture_view')
+              end
+            end
+
+            context 'and element has available_contents defined' do
+              let(:elements) { [{'name' => 'text', 'available_contents' => ['type' => 'EssenceFile']}] }
+
+              it "has these essences as template dependency" do
+                should include('alchemy/essences/_essence_file_view')
+              end
+            end
+          end
+
+          context 'that has no description' do
+            before { Element.stub(:descriptions).and_return([]) }
+
+            it "returns empty array" do
+              should be_empty
+            end
+          end
+        end
+
+        context 'with not an alchemy template given as name' do
+          let(:name) { 'shop/cart' }
+
+          it "calls rails template tracker" do
+            ActionView::DependencyTracker::ERBTracker.should_receive(:call).with(name, nil)
+            subject
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/libraries/tinymce_spec.rb

@@ -42,18 +42,6 @@ module Alchemy
           let(:content_definition) { {'name' => 'text'} }
           it { should eq([]) }
         end
-      end
-
-      describe '.page_custom_config_contents' do
-        let(:page) { FactoryGirl.build_stubbed(:page) }
-        subject { Tinymce.page_custom_config_contents(page) }
-
-        before { page.stub(:element_definitions).and_return([element_definition]) }
-
-        it "returns an array of content definitions that contain custom tinymce config for page" do
-          should be_an(Array)
-          should include({'element' => element_definition['name']}.merge(content_definition))
-        end
 
         context 'with element definition having nil as contents value' do
           let(:element_definition) { {'name' => 'element', 'contents' => nil} }

data/spec/libraries/userstamp_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'Alchemy::AuthAccessors' do
+  describe '.user_class' do
+    it "injects userstamp class methods" do
+      Alchemy.user_class.should respond_to(:stamper_class_name)
+      Alchemy.user_class.stamper_class_name.should eq(:DummyUser)
+    end
+  end
+end

data/spec/models/attachment_spec.rb

@@ -3,8 +3,15 @@ require 'spec_helper'
 
 module Alchemy
   describe Attachment do
-    let(:file) { File.new(File.expand_path('../../fixtures/image with spaces.png', __FILE__)) }
-    let(:attachment) { Attachment.new(:file => file) }
+    let(:file)       { File.new(File.expand_path('../../fixtures/image with spaces.png', __FILE__)) }
+    let(:attachment) { Attachment.new(file: file) }
+
+    describe 'after assign' do
+      it "stores the file mime type into database" do
+        attachment.update(file: file)
+        attachment.file_mime_type.should_not be_blank
+      end
+    end
 
     describe 'after create' do
       before { attachment.save! }
@@ -45,7 +52,7 @@ module Alchemy
     describe 'validations' do
 
       context "having a png, but only pdf allowed" do
-        before { Config.stub!(:get).and_return({'allowed_filetypes' => {'attachments' => ['pdf']}}) }
+        before { Config.stub(:get).and_return({'allowed_filetypes' => {'attachments' => ['pdf']}}) }
 
         it "should not be valid" do
           attachment.should_not be_valid
@@ -53,7 +60,7 @@ module Alchemy
       end
 
       context "having a png and everything allowed" do
-        before { Config.stub!(:get).and_return({'allowed_filetypes' => {'attachments' => ['*']}}) }
+        before { Config.stub(:get).and_return({'allowed_filetypes' => {'attachments' => ['*']}}) }
 
         it "should be valid" do
           attachment.should be_valid
@@ -63,76 +70,102 @@ module Alchemy
     end
 
     context 'PNG image' do
-      subject { stub_model(Attachment, :file_name => 'kitten.png') }
+      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') }
+        subject { stub_model(Attachment, file_mime_type: 'audio/mpeg') }
         its(:icon_css_class) { should == "audio" }
       end
 
       context 'video file' do
-        subject { stub_model(Attachment, :file_mime_type => 'video/mpeg') }
+        subject { stub_model(Attachment, file_mime_type: 'video/mpeg') }
         its(:icon_css_class) { should == "video" }
       end
 
       context 'png file' do
-        subject { stub_model(Attachment, :file_mime_type => 'image/png') }
+        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') }
+        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') }
+        subject { stub_model(Attachment, file_mime_type: 'application/zip') }
         its(:icon_css_class) { should == "archive" }
       end
 
       context 'flash file' do
-        subject { stub_model(Attachment, :file_mime_type => 'application/x-shockwave-flash') }
+        subject { stub_model(Attachment, file_mime_type: 'application/x-shockwave-flash') }
         its(:icon_css_class) { should == "flash" }
       end
 
       context 'photoshop file' do
-        subject { stub_model(Attachment, :file_mime_type => 'image/x-psd') }
+        subject { stub_model(Attachment, file_mime_type: 'image/x-psd') }
         its(:icon_css_class) { should == "psd" }
       end
 
       context 'text file' do
-        subject { stub_model(Attachment, :file_mime_type => 'text/plain') }
+        subject { stub_model(Attachment, file_mime_type: 'text/plain') }
         its(:icon_css_class) { should == "text" }
       end
 
       context 'rtf file' do
-        subject { stub_model(Attachment, :file_mime_type => 'application/rtf') }
+        subject { stub_model(Attachment, file_mime_type: 'application/rtf') }
         its(:icon_css_class) { should == "rtf" }
       end
 
       context 'pdf file' do
-        subject { stub_model(Attachment, :file_mime_type => 'application/pdf') }
+        subject { stub_model(Attachment, file_mime_type: 'application/pdf') }
         its(:icon_css_class) { should == "pdf" }
       end
 
       context 'word file' do
-        subject { stub_model(Attachment, :file_mime_type => 'application/msword') }
+        subject { stub_model(Attachment, file_mime_type: 'application/msword') }
         its(:icon_css_class) { should == "word" }
       end
 
       context 'excel file' do
-        subject { stub_model(Attachment, :file_mime_type => 'application/vnd.ms-excel') }
+        subject { stub_model(Attachment, file_mime_type: 'application/vnd.ms-excel') }
         its(:icon_css_class) { should == "excel" }
       end
 
       context 'unknown file' do
-        subject { stub_model(Attachment, :file_mime_type => '') }
+        subject { stub_model(Attachment, file_mime_type: '') }
         its(:icon_css_class) { should == "file" }
       end
     end
 
+    describe '#restricted?' do
+      subject { attachment.restricted? }
+
+      context 'if only on restricted pages' do
+        before do
+          pages = double(any?: true)
+          pages.should_receive(:not_restricted).and_return([])
+          attachment.should_receive(:pages).twice.and_return(pages)
+        end
+
+        it { should be_true }
+      end
+
+      context 'if not only on restricted pages' do
+        let(:page) { mock_model(Page) }
+
+        before do
+          pages = double(any?: true)
+          pages.should_receive(:not_restricted).and_return([page])
+          attachment.should_receive(:pages).twice.and_return(pages)
+        end
+
+        it { should be_false }
+      end
+    end
+
   end
 end