alchemy_cms 2.5.3.1 → 2.6.0.rc5

data/spec/libraries/resource_spec.rb

@@ -1,5 +1,6 @@
 require 'rspec'
 require File.dirname(__FILE__) + '/../../lib/alchemy/resource'
+require File.dirname(__FILE__) + '/../../lib/alchemy/errors'
 
 class Event
 end
@@ -16,126 +17,264 @@ module Namespace
   end
 end
 
-module Engine
+module EventEngine
   module Namespace
     class Event
     end
   end
 end
 
+# Alchemy's standard module definition. Only engine_name is relevant here
+def module_definition
+  {
+    "name" => "event_list",
+    "engine_name" => "event_engine",
+    "navigation" => {
+      "name" => "modules.event_list",
+      "controller" => "admin/events",
+      "action" => "index",
+      "image" => "/assets/event_list_module.png"
+    }
+  }
+end
+
 module Alchemy
   describe Resource do
 
-    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
+    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}),
+      ]
+      Event.stub(:columns).and_return columns
+      #Alchemy::Config.stub(:get).and_return {}
     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 "#initialize" do
 
-      it "deletes 'admin' if found hence our model isn't in the admin-namespace by convention" do
+      it "should set an instance variable that holds the controller path" do
         resource = Resource.new("admin/events")
-        resource.model_array.should eql(['events'])
+        resource.instance_variable_get(:@controller_path).should == "admin/events"
       end
-    end
 
-    describe "instance methods" do
-      let(:resource) { Resource.new("admin/events") }
+      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.instance_variable_get(:@module_definition).should == module_definition
+        end
+      end
 
-      describe "model" do
-        it "returns resource's model-class" do
-          resource.model.should be(Event)
+      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
         end
+      end
 
-        describe "resources_name" do
-          it "returns plural name (like events for model Event)" do
-            resource.resources_name.should == 'events'
-          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
         end
+      end
 
-        describe "model_name" do
-          it "returns model_name (like event for model Event" do
-            resource.model_name.should == 'event'
+      context "when model has resource_relations defined" do
+        before do
+          Event.class_eval do
+            def self.resource_relations
+              {location: {attr_method: 'name', type: 'string'}}
+            end
           end
+          Event.stub!(:respond_to?).and_return { |arg|
+            case arg
+            when :reflect_on_all_associations
+              then false
+            when :resource_relations
+              then true
+            end
+          }
         end
 
-        describe "permission_scope" do
-          it "should return the permissions_scope usable in declarative authorization" do
-            resource.permission_scope.should == :admin_events
+        context ", but not an ActiveRecord association" do
+          it "should raise error." do
+            expect { Resource.new("admin/events") }.to raise_error(MissingActiveRecordAssociation)
           end
         end
 
-        describe "namespace_for_scope" do
-          it "returns a scope for use in url_for-based path-helpers" do
-            resource.namespace_for_scope.should == ['admin']
+        after do
+          Event.class_eval do
+            class << self
+              undef resource_relations
+            end
           end
         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
-            Config.stub(:get).and_return {}
-          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}]
-          end
+    describe "#resource_array" do
 
-          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 "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])
+      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
+      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])
+      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
+
+    describe "#model" do
+      it "returns the @model instance variable" do
+        resource = Resource.new("admin/events")
+        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"
+      end
+    end
+
+    describe "#resource_name" do
+      it "returns the resources name as singular" do
+        resource = Resource.new("admin/events")
+        resource.resource_name.should == "event"
+      end
+    end
+
+    describe "#model_name" do
+      it "is deprecated" do
+        ActiveSupport::Deprecation.should_receive(:warn)
+        Resource.new("admin/events").model_name
+      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'
+      end
+
+      it "equals resource_name if resource not namespaced" do
+        namespaced_resource = Resource.new("admin/events")
+        namespaced_resource.namespaced_resource_name.should == 'event'
+      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'
+      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 "namespaced_model_name" do
+    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
+      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.namespace_for_scope.should == %W[admin]
+      end
+    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'
+    describe "#attributes" do
+      let(:resource) { Resource.new("admin/events") }
+
+      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},
+          {:name => "location_id", :type => :integer},
+          {:name => "organizer_id", :type => :integer},
+        ]
+      end
+
+      it "skips attributes returned by skip_attributes" do
+        # attr_accessor, hence skip_attributes= works
+        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
+    end
+
+
+    describe "#skip_attributes" do
+      let(:resource) { Resource.new("admin/events") }
+
+      it "returns a set of default attributes (Rails' default database attributes)" do
+        # read from Resource::DEFAULT_SKIPPED_ATTRIBUTES
+        default_skipped_attributes = %W[id updated_at created_at creator_id updater_id]
+        resource.skip_attributes = default_skipped_attributes
+      end
+
+      context "when skip_attributes is defined as class-method in the model" do
+        before do
+          Event.class_eval do
+            def self.skip_attributes
+              %W[hidden_name]
+            end
+          end
+        end
+        after do
+          Event.class_eval do
+            class << self
+              undef skip_attributes
+            end
+          end
         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'
+        it "returns the result of Model.skip_attributes" do
+          custom_skipped_attributes = %W[hidden_name]
+          resource.skip_attributes = custom_skipped_attributes
         end
 
-        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
+
+      describe "#searchable_attributes" do
+        it "returns all attributes of type string" do
+          resource = Resource.new("admin/events")
+          resource.skip_attributes = []
+          resource.searchable_attributes.should == [
+            {:name => "name", :type => :string},
+            {:name => "hidden_value", :type => :string},
+            {:name => "description", :type => :string}
+          ]
         end
       end
 
+      describe "#namespaced_model_name" do
+        it "is deprecated" do
+          ActiveSupport::Deprecation.should_receive(:warn)
+          resource = Resource.new("admin/events")
+          resource.namespaced_model_name
+        end
+      end
 
     end
   end

data/spec/libraries/resources_helper_spec.rb

@@ -1,3 +1,4 @@
+require 'rspec'
 require 'ostruct'
 require File.dirname(__FILE__) + "/../../lib/alchemy/resource"
 require File.dirname(__FILE__) + "/../../lib/alchemy/resources_helper"
@@ -39,74 +40,115 @@ describe Alchemy::ResourcesHelper do
 
   describe "path-helpers" do
 
-    describe "resource_url_proxy" do
-      it "should return the current proxy for use in url-helper-methods" do
+    describe "#resource_url_proxy" do
+
+      it "returns the current proxy for url-helper-methods" do
         @controller.resource_url_proxy.should == 'main_app_proxy'
       end
-      it "should return the engine's proxy object when resource is in engine" 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'
+
+      context "when resource is in engine" do
+        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'
+        end
       end
+
     end
 
-    describe "resource_scope" do
-      it "should provide an array containing a proxy and namespaces for use in url_for-based helper-methods" do
+    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]
       end
     end
 
-    describe "resource_path" do
+    describe "#resource_path" do
 
-      it "should invoke polymorphic-path with correct scope and object" 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)
       end
 
-      it "use resource's class when no object is given" do
-        @controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", Namespace::MyResource], {})
+      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
       end
 
     end
 
-    describe "resources_path method" do
-      it "should invoke polymorphic-path with correct scope and resource class-name" do
-        @controller.should_receive(:polymorphic_path).with(["main_app_proxy", "admin", Namespace::MyResource], {})
+    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
       end
     end
 
-    it "should provide a new_resource_path method" do
-      @controller.should_receive(:new_polymorphic_path).with(["main_app_proxy", "admin", Namespace::MyResource], {})
-      @controller.new_resource_path
+    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
+      end
     end
 
-    it "should provide a edit_resource_path method" 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)
+
+    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)
+      end
     end
 
   end
 
-  describe "resource_instance_variable" do
-    it "should return the resource_item" do
+  describe "#resource_instance_variable" do
+    it "returns the resource_item" do
       @controller.resource_instance_variable.should == @resource_item
     end
   end
 
-  describe "resources_instance_variable" do
-    it "should return a collection of resource_items" do
+  describe "#resources_instance_variable" do
+    it "returns a collection of resource_items" do
       @controller.resources_instance_variable.should == [@resource_item]
     end
   end
 
-  describe "resource_window_size" do
-    it "should return overlay size string depending on resource attributes length" do
+  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"
     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'
+    end
+
+    context "resource having a relation" do
+      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'
+      end
+    end
+  end
+
+  describe "#resource_model_name" do
+    it "is deprecated" do
+      ActiveSupport::Deprecation.should_receive(:warn)
+      @controller.resource_model_name
+    end
+  end
+
+  describe "#resource_name" do
+    it "returns resource_handler.resource_name" do
+      @controller.resource_name.should == "my_resource"
+    end
+  end
+
 end