alchemy_cms 2.9.1 → 3.0.0.rc5

data/spec/libraries/kaminari/scoped_pagination_url_helper_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Kaminari::Helpers::Tag do
+  subject { Kaminari::Helpers::Tag.new(template, options) }
+
+  let(:template) { double(params: {}) }
+  let(:scope)    { double(url_for: '') }
+
+  describe '#page_url_for' do
+    context "with scope option given" do
+      let(:options) { {scope: scope} }
+
+      it "calls url_for on that url proxy scope." do
+        template.should_not_receive(:url_for)
+        scope.should_receive(:url_for)
+        subject.page_url_for(1)
+      end
+    end
+
+    context "with no scope option given" do
+      let(:options) { {} }
+
+      it "calls url_for on the template." do
+        template.should_receive(:url_for)
+        scope.should_not_receive(:url_for)
+        subject.page_url_for(1)
+      end
+    end
+  end
+end

data/spec/libraries/modules_spec.rb

@@ -46,5 +46,22 @@ module Alchemy
         end
       end
     end
+
+    describe '.register_module' do
+      let(:alchemy_module) do
+        {
+          'name' => 'module',
+          'navigation' => {
+            'controller' => 'admin/controller_name',
+            'action' => 'index'
+          }
+        }
+      end
+
+      it "registers a module definition into global list of modules" do
+        Modules.register_module(alchemy_module)
+        Modules.alchemy_modules.should include(alchemy_module)
+      end
+    end
   end
 end

data/spec/libraries/mount_point_spec.rb

@@ -6,18 +6,18 @@ describe Alchemy::MountPoint do
   describe '.get' do
 
     it "returns the path of alchemy's mount point" do
-      Alchemy::MountPoint.stub!(:mount_point).and_return('/cms')
+      Alchemy::MountPoint.stub(:mount_point).and_return('/cms')
       Alchemy::MountPoint.get.should == '/cms'
     end
 
     it "removes the leading slash if root mount point" do
-      Alchemy::MountPoint.stub!(:mount_point).and_return('/')
+      Alchemy::MountPoint.stub(:mount_point).and_return('/')
       Alchemy::MountPoint.get.should == ''
     end
 
     context "with remove_leading_slash_if_blank set to false" do
       before {
-        Alchemy::MountPoint.stub!(:mount_point).and_return('/')
+        Alchemy::MountPoint.stub(:mount_point).and_return('/')
       }
 
       it "does not remove the leading white slash of path" do
@@ -26,7 +26,7 @@ describe Alchemy::MountPoint do
 
       context "and with mount point not root" do
         before {
-          Alchemy::MountPoint.stub!(:mount_point).and_return('/cms')
+          Alchemy::MountPoint.stub(:mount_point).and_return('/cms')
         }
 
         it "does not remove the leading white slash of path" do
@@ -38,19 +38,19 @@ describe Alchemy::MountPoint do
 
   describe '.routes' do
     it "returns the routes object from alchemy engine" do
-      Alchemy::MountPoint.routes.should be_instance_of(Journey::Route)
+      Alchemy::MountPoint.routes.should be_instance_of(ActionDispatch::Journey::Route)
     end
   end
 
   describe '.mount_point' do
     it 'returns the raw mount point path from routes' do
-      Alchemy::MountPoint.stub!(:routes).and_return(OpenStruct.new(path: OpenStruct.new(spec: '/cms')))
+      Alchemy::MountPoint.stub(:routes).and_return(OpenStruct.new(path: OpenStruct.new(spec: '/cms')))
       Alchemy::MountPoint.mount_point.should == '/cms'
     end
 
     context "Alchemy routes could not be found" do
       before {
-        Alchemy::MountPoint.stub!(:routes).and_return(nil)
+        Alchemy::MountPoint.stub(:routes).and_return(nil)
       }
 
       it "falls back to root path" do

data/spec/libraries/page_layout_spec.rb

@@ -60,7 +60,7 @@ module Alchemy
     end
 
     describe '.selectable_layouts' do
-      let(:language) { Language.get_default }
+      let(:language) { Language.default }
       before { language }
       subject { PageLayout.selectable_layouts(language.id) }
 

data/spec/libraries/permissions_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+require 'cancan/matchers'
+
+describe Alchemy::Permissions do
+  subject { ability }
+
+  let(:ability)                 { Alchemy::Permissions.new(user) }
+  let(:attachment)              { mock_model(Alchemy::Attachment, restricted?: false) }
+  let(:restricted_attachment)   { mock_model(Alchemy::Attachment, restricted?: true) }
+  let(:picture)                 { mock_model(Alchemy::Picture, restricted?: false) }
+  let(:restricted_picture)      { mock_model(Alchemy::Picture, restricted?: true) }
+  let(:public_page)             { build_stubbed(:public_page, restricted: false) }
+  let(:unpublic_page)           { build_stubbed(:page, public: false) }
+  let(:visible_page)            { build_stubbed(:page, restricted: false, visible: true) }
+  let(:not_visible_page)        { build_stubbed(:public_page, restricted: false, visible: false) }
+  let(:restricted_page)         { build_stubbed(:public_page, public: true, restricted: true) }
+  let(:visible_restricted_page) { build_stubbed(:page, visible: true, restricted: true) }
+  let(:published_element)       { mock_model(Alchemy::Element, public: true, page: public_page) }
+  let(:restricted_element)      { mock_model(Alchemy::Element, public: true, page: restricted_page) }
+
+  context "A guest user" do
+    let(:user) { nil }
+
+    it "can only download not restricted attachments" do
+      should be_able_to(:download, attachment)
+      should_not be_able_to(:download, restricted_attachment)
+    end
+
+    it "can only see not restricted attachments" do
+      should be_able_to(:show, attachment)
+      should_not be_able_to(:show, restricted_attachment)
+    end
+
+    it "can only download not restricted pictures" do
+      should be_able_to(:download, picture)
+      should_not be_able_to(:download, restricted_picture)
+    end
+
+    it "can only see not restricted pictures" do
+      should be_able_to(:show, picture)
+      should_not be_able_to(:show, restricted_picture)
+    end
+
+    it "can only visit not restricted pages" do
+      should be_able_to(:show, public_page)
+      should_not be_able_to(:show, restricted_page)
+    end
+
+    it "can only see visible not restricted pages" do
+      should be_able_to(:see, visible_page)
+      should_not be_able_to(:see, not_visible_page)
+    end
+
+    it "can only see public not restricted elements" do
+      should be_able_to(:show, published_element)
+      should_not be_able_to(:show, restricted_element)
+    end
+  end
+
+  context "A member" do
+    let(:user) { member_user }
+
+    it "can download all attachments" do
+      should be_able_to(:download, attachment)
+      should be_able_to(:download, restricted_attachment)
+    end
+
+    it "can see all attachments" do
+      should be_able_to(:show, attachment)
+      should be_able_to(:show, restricted_attachment)
+    end
+
+    it "can download all pictures" do
+      should be_able_to(:download, picture)
+      should be_able_to(:download, restricted_picture)
+    end
+
+    it "can see all pictures" do
+      should be_able_to(:show, picture)
+      should be_able_to(:show, restricted_picture)
+    end
+
+    it "can visit restricted pages" do
+      should be_able_to(:show, public_page)
+      should be_able_to(:show, restricted_page)
+    end
+
+    it "can see visible restricted pages" do
+      should be_able_to(:see, visible_page)
+      should be_able_to(:see, visible_restricted_page)
+    end
+
+    it "can not see invisible pages" do
+      should_not be_able_to(:see, not_visible_page)
+    end
+
+    it "can see public restricted elements" do
+      should be_able_to(:show, published_element)
+      should be_able_to(:show, restricted_element)
+    end
+  end
+
+  context "An author" do
+    let(:user) { author_user }
+
+    it "can visit the dashboard" do
+      should be_able_to(:index, :alchemy_admin_dashboard)
+      should be_able_to(:info, :alchemy_admin_dashboard)
+    end
+
+    it "can see picture thumbnails" do
+      should be_able_to(:thumbnail, Alchemy::Picture)
+    end
+
+    it "can edit page content" do
+      should be_able_to(:show, unpublic_page)
+      should be_able_to(:index, Alchemy::Page)
+      should be_able_to(:info, Alchemy::Page)
+      should be_able_to(:configure, Alchemy::Page)
+      should be_able_to(:update, Alchemy::Page)
+      should be_able_to(:fold, Alchemy::Page)
+      should be_able_to(:link, Alchemy::Page)
+      should be_able_to(:visit, Alchemy::Page)
+      should be_able_to(:unlock, Alchemy::Page)
+      should be_able_to(:publish, Alchemy::Page)
+    end
+
+    it "can manage elements" do
+      should be_able_to(:manage, Alchemy::Element)
+    end
+
+    it "can see all attachments" do
+      should be_able_to(:read, Alchemy::Attachment)
+      should be_able_to(:download, Alchemy::Attachment)
+    end
+
+    it "can see all pictures" do
+      should be_able_to(:read, Alchemy::Picture)
+      should be_able_to(:info, Alchemy::Picture)
+    end
+
+    it "can manage contents" do
+      should be_able_to(:manage, Alchemy::Content)
+    end
+
+    it "can manage essences" do
+      should be_able_to(:manage, Alchemy::EssencePicture)
+      should be_able_to(:manage, Alchemy::EssenceFile)
+    end
+
+    it "can see the trash" do
+      should be_able_to(:index, :trash)
+    end
+
+    it "can manage the clipboard" do
+      should be_able_to(:manage, Alchemy::Clipboard)
+    end
+
+    it "can see tags" do
+      should be_able_to(:read, Alchemy::Tag)
+      should be_able_to(:autocomplete, Alchemy::Tag)
+    end
+
+    it "can index layoutpages" do
+      should be_able_to(:index, :alchemy_admin_layoutpages)
+    end
+  end
+
+  context "An editor" do
+    let(:user) { editor_user }
+
+    it "can manage pages" do
+      should be_able_to(:copy, Alchemy::Page)
+      should be_able_to(:copy_language_tree, Alchemy::Page)
+      should be_able_to(:create, Alchemy::Page)
+      should be_able_to(:destroy, Alchemy::Page)
+      should be_able_to(:flush, Alchemy::Page)
+      should be_able_to(:order, Alchemy::Page)
+      should be_able_to(:sort, Alchemy::Page)
+      should be_able_to(:switch_language, Alchemy::Page)
+    end
+
+    it "can not see invisible pages" do
+      should_not be_able_to(:see, not_visible_page)
+    end
+
+    it "can clear the trash" do
+      should be_able_to(:clear, :trash)
+    end
+
+    it "can manage attachments" do
+      should be_able_to(:manage, Alchemy::Attachment)
+    end
+
+    it "can manage pictures" do
+      should be_able_to(:manage, Alchemy::Picture)
+    end
+
+    it "can manage tags" do
+      should be_able_to(:manage, Alchemy::Tag)
+    end
+  end
+
+  context "An admin" do
+    let(:user) { admin_user }
+
+    it "can check for alchemy updates" do
+      should be_able_to(:update_check, :alchemy_admin_dashboard)
+    end
+
+    it "can manage languages" do
+      should be_able_to(:manage, Alchemy::Language)
+    end
+
+    it "can manage sites" do
+      should be_able_to(:manage, Alchemy::Site)
+    end
+  end
+end

data/spec/libraries/resource_spec.rb

@@ -1,23 +1,24 @@
-require 'spec_helper'
+require File.dirname(__FILE__) + '/../../lib/alchemy/resource'
+require File.dirname(__FILE__) + '/../../lib/alchemy/errors'
 
-class Event
+class Party
 end
 
 module Namespace1
   module Namespace2
-    class Event
+    class Party
     end
   end
 end
 
 module Namespace
-  class Event
+  class Party
   end
 end
 
-module EventEngine
+module PartyEngine
   module Namespace
-    class Event
+    class Party
     end
   end
 end
@@ -25,13 +26,13 @@ end
 # Alchemy's standard module definition. Only engine_name is relevant here
 def module_definition
   {
-    "name" => "event_list",
-    "engine_name" => "event_engine",
+    "name" => "party_list",
+    "engine_name" => "party_engine",
     "navigation" => {
-      "name" => "modules.event_list",
-      "controller" => "admin/events",
+      "name" => "modules.party_list",
+      "controller" => "/admin/parties",
       "action" => "index",
-      "image" => "/assets/event_list_module.png"
+      "image" => "/assets/party_list_module.png"
     }
   }
 end
@@ -42,59 +43,58 @@ module Alchemy
     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}),
-        mock(:column, {:name => 'location_id', :type => :integer}),
-        mock(:column, {:name => 'organizer_id', :type => :integer}),
+        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}),
       ]
-      Event.stub(:columns).and_return columns
-      #Alchemy::Config.stub(:get).and_return {}
+      Party.stub(:columns).and_return columns
     end
 
     describe "#initialize" do
 
       it "should set an instance variable that holds the controller path" do
-        resource = Resource.new("admin/events")
-        resource.instance_variable_get(:@controller_path).should == "admin/events"
+        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/events", module_definition)
+          resource = Resource.new("admin/parties", module_definition)
           resource.instance_variable_get(:@module_definition).should == module_definition
         end
       end
 
       context "when initialized with a custom model" do
         it "sets @model to custom model" do
-          CustomEvent = Class.new
-          resource = Resource.new("admin/events", nil, CustomEvent)
-          resource.instance_variable_get(:@model).should == CustomEvent
+          CustomParty = Class.new
+          resource = Resource.new("admin/parties", nil, CustomParty)
+          resource.instance_variable_get(:@model).should == CustomParty
         end
       end
 
       context "when initialized without custom model" do
         it "guesses the model by the controller_path" do
-          resource = Resource.new("admin/events", nil, nil)
-          resource.instance_variable_get(:@model).should == Event
+          resource = Resource.new("admin/parties", nil, nil)
+          resource.instance_variable_get(:@model).should == Party
         end
       end
 
-      context "when model has resource_relations defined" do
+      context "when model has alchemy_resource_relations defined" do
         before do
-          Event.class_eval do
-            def self.resource_relations
+          Party.class_eval do
+            def self.alchemy_resource_relations
               {location: {attr_method: 'name', type: 'string'}}
             end
           end
-          Event.stub!(:respond_to?).and_return { |arg|
+          Party.stub(:respond_to?).and_return { |arg|
             case arg
             when :reflect_on_all_associations
               then false
-            when :resource_relations
+            when :alchemy_resource_relations
               then true
             end
           }
@@ -102,14 +102,14 @@ module Alchemy
 
         context ", but not an ActiveRecord association" do
           it "should raise error." do
-            expect { Resource.new("admin/events") }.to raise_error(MissingActiveRecordAssociation)
+            expect { Resource.new("admin/parties") }.to raise_error(MissingActiveRecordAssociation)
           end
         end
 
         after do
-          Event.class_eval do
+          Party.class_eval do
             class << self
-              undef resource_relations
+              undef alchemy_resource_relations
             end
           end
         end
@@ -120,80 +120,73 @@ module Alchemy
     describe "#resource_array" do
 
       it "splits the controller_path and returns it as array." do
-        resource = Resource.new("namespace1/namespace2/events")
-        resource.resource_array.should eql(%W[namespace1 namespace2 events])
+        resource = Resource.new("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/events")
-        resource.resource_array.should eql(%W[events])
+        resource = Resource.new("admin/parties")
+        resource.resource_array.should eql(%W[parties])
       end
 
     end
 
     describe "#model" do
       it "returns the @model instance variable" do
-        resource = Resource.new("admin/events")
+        resource = Resource.new("admin/parties")
         resource.model.should == resource.instance_variable_get(:@model)
       end
     end
 
     describe "#resources_name" do
-      it "returns plural name (like events for model Event)" do
-        resource = Resource.new("admin/events")
-        resource.resources_name.should == "events"
+      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/events")
-        resource.resource_name.should == "event"
+        resource = Resource.new("admin/parties")
+        resource.resource_name.should == "party"
       end
     end
 
     describe "#namespaced_resource_name" do
 
-      it "returns resource_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_resource_name.should == 'namespace_event'
+      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'
       end
 
       it "equals resource_name if resource not namespaced" do
-        namespaced_resource = Resource.new("admin/events")
-        namespaced_resource.namespaced_resource_name.should == 'event'
+        namespaced_resource = Resource.new("admin/parties")
+        namespaced_resource.namespaced_resource_name.should == 'party'
       end
 
       it "doesn't include the engine's name" do
-        namespaced_resource = Resource.new("admin/event_engine/namespace/events", module_definition)
-        namespaced_resource.namespaced_resource_name.should == 'namespace_event'
+        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
       it "should return the engine name of the module" do
-        resource = Resource.new("admin/event_engine/namespace/events", module_definition)
-        resource.engine_name.should == "event_engine"
-      end
-    end
-
-    describe "#permission_scope" do
-      it "returns a permission_scope usable in declarative authorization" do
-        resource = Resource.new("admin/events")
-        resource.permission_scope.should == :admin_events
+        resource = Resource.new("admin/party_engine/namespace/parties", module_definition)
+        resource.engine_name.should == "party_engine"
       end
     end
 
     describe "#namespace_for_scope" do
       it "returns a scope for use in url_for-based path-helpers" do
-        resource = Resource.new("admin/events")
+        resource = Resource.new("admin/parties")
         resource.namespace_for_scope.should == %W[admin]
       end
     end
 
     describe "#attributes" do
-      let(:resource) { Resource.new("admin/events") }
+      let(:resource) { Resource.new("admin/parties") }
 
       it "parses and returns the resource-model's attributes from ActiveRecord::ModelSchema" do
         resource.attributes.should == [
@@ -216,7 +209,7 @@ module Alchemy
 
 
     describe "#skip_attributes" do
-      let(:resource) { Resource.new("admin/events") }
+      let(:resource) { Resource.new("admin/parties") }
 
       it "returns a set of default attributes (Rails' default database attributes)" do
         # read from Resource::DEFAULT_SKIPPED_ATTRIBUTES
@@ -226,14 +219,14 @@ module Alchemy
 
       context "when skip_attributes is defined as class-method in the model" do
         before do
-          Event.class_eval do
+          Party.class_eval do
             def self.skip_attributes
               %W[hidden_name]
             end
           end
         end
         after do
-          Event.class_eval do
+          Party.class_eval do
             class << self
               undef skip_attributes
             end
@@ -249,7 +242,7 @@ module Alchemy
 
       describe "#searchable_attributes" do
         it "returns all attributes of type string" do
-          resource = Resource.new("admin/events")
+          resource = Resource.new("admin/parties")
           resource.skip_attributes = []
           resource.searchable_attributes.should == [
             {:name => "name", :type => :string},