crystal_ext 0.0.7 → 0.0.11

data/spec/_mailer/helper.rb

@@ -0,0 +1,7 @@
+dir = File.dirname __FILE__
+crystal_dir = File.expand_path "#{dir}/../.."
+lib_dir = "#{crystal_dir}/lib"
+$LOAD_PATH << lib_dir unless $LOAD_PATH.include? lib_dir
+
+require 'spec_ext'
+require 'crystal/mailer'

data/spec/controller/abstract_controller_spec.rb

@@ -0,0 +1,137 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+
+describe "AbstractController" do  
+  with_environment :test
+  with_abstract_controller_spec
+  
+  before :all do
+    @dir = "#{File.expand_path(File.dirname(__FILE__))}/abstract_controller_spec"    
+    $LOAD_PATH << @dir    
+    
+    AbstractController = Crystal::AbstractController
+  end
+  
+  after :all do
+    $LOAD_PATH.delete @dir
+    remove_constants %w(
+      WorkspaceVariablesSpec
+      SpecialResultSpec
+      RespondToSpec
+      ViewVariablesSpec
+      OperationsOrderSpec
+      NoTemplateSpec
+      AbstractController
+    )
+  end
+  
+  it "should set workspace variables" do
+    class ::WorkspaceVariablesSpec
+      inherit AbstractController
+  
+      def action; end    
+    end
+  
+    workspace = ccall WorkspaceVariablesSpec, 'action'    
+  
+    workspace.delete(:controller).should be_a(WorkspaceVariablesSpec)
+    expected_result = {      
+      :params => {},
+  
+      :class => WorkspaceVariablesSpec,   
+      :method_name => "action", 
+      :action => 'action',
+  
+      :content => ""
+    }
+    workspace.to_h(true).symbolize_keys.subset(expected_result.keys).should == expected_result
+  end
+    
+  it "should be able to throw :special_result in controller or view and that result must be assigned as result" do
+      class ::SpecialResultSpec
+        inherit AbstractController    
+        def action
+          throw :special_result, "some content"
+        end      
+      end
+      
+      ccall(SpecialResultSpec, :action).content.should == "some content"
+    end
+      
+    it "respond_to" do
+      class ::RespondToSpec
+        inherit AbstractController
+        
+        def action
+          respond_to do |format|
+            format.html{render :inline => 'html'}
+            format.json{render :json => {:a => 'b'}}
+          end
+        end
+      end
+      
+      ccall(RespondToSpec, :action, :format => 'html').content.should == 'html'
+      ccall(RespondToSpec, :action, :format => 'json').content.should == %({"a":"b"})
+      lambda{ccall(RespondToSpec, :action, :format => 'js')}.should raise_error(/Can't respond to js format/)
+    end
+    
+    it "controller's instance variables must be available in view, and also other variables" do
+      class ::ViewVariablesSpec
+        inherit AbstractController
+        
+        def action
+          @instance_variable = "iv value"
+        end
+      end
+      
+      ccall(
+        ViewVariablesSpec, :action, 
+        :param => 'param value', :format => Crystal::Format.new('html')
+      ).content.should == %(\
+controller: ViewVariablesSpec
+
+class: ViewVariablesSpec
+method_name: action
+action: action
+
+instance_variable: iv value
+
+params: param value
+format: html)
+    end
+    
+    it "operations order" do
+      class ::OperationsOrderSpec
+        inherit AbstractController
+        
+        def self.result
+          @result ||= []
+        end
+        
+        around do |controller, block|
+          begin
+            OperationsOrderSpec.result << :before
+            block.call
+          ensure
+            OperationsOrderSpec.result << :after
+          end
+        end
+        
+        def action
+          OperationsOrderSpec.result << :action
+        end
+      end
+      
+      ccall(OperationsOrderSpec, :action)
+      OperationsOrderSpec.result.should == [:before, :action, :template, :after]    
+    end
+    
+    it "should write empty response if no template for action" do
+      class NoTemplateSpec
+        inherit AbstractController
+        
+        def action; end
+      end
+      
+      ccall(NoTemplateSpec, :action).content.should == ""
+    end
+end

data/spec/controller/abstract_controller_spec/views/OperationsOrderSpec/action.erb

@@ -0,0 +1 @@
+<% OperationsOrderSpec.result << :template %>

data/spec/controller/abstract_controller_spec/views/ViewVariablesSpec/action.erb

@@ -0,0 +1,10 @@
+controller: <%= workspace.controller.class.name %>
+
+class: <%= workspace.class.name %>
+method_name: <%= workspace.method_name %>
+action: <%= workspace.action %>
+
+instance_variable: <%= @instance_variable %>
+
+params: <%= params.param %>
+format: <%= params.format %>

data/spec/controller/controller_context_spec.rb

@@ -0,0 +1,122 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+
+describe "ControllerContext" do
+  with_environment :development
+  
+  before :all do
+    @dir = "#{File.expand_path(File.dirname(__FILE__))}/controller_context_spec"
+    $LOAD_PATH << @dir
+    AbstractController = Crystal::AbstractController
+    
+    class ItemSpec
+      inherit AbstractController
+      
+      def show; end      
+      def update; end
+      def delete; end
+      def increase; end
+      def decrease; end      
+    end
+    
+    class PageSpec < ItemSpec
+      def show; end
+      def increase; end
+    end    
+    
+    module NamespaceSpec
+      class ClassSpec
+        inherit AbstractController
+        
+        def show; end
+        def update; end
+      end
+    end
+  end
+  
+  after :all do
+    $LOAD_PATH.delete @dir
+    remove_constants %w(
+      ItemSpec
+      PageSpec
+      NamespaceSpec      
+      ItemSpecHelper
+      PageSpecHelper
+      AbstractController
+    )    
+  end
+  
+  describe "basic" do
+    it "should provide template name for non-existing template" do
+      ItemSpec.template_name_for(:delete).should == "/ItemSpec/delete"
+      PageSpec.template_name_for(:delete).should == "/ItemSpec/delete"
+    end
+  
+    it "should provide template name for existing template" do
+      ItemSpec.template_name_for(:update).should == "/ItemSpec/update"
+    end
+  
+    it "should inherit template name for template existing in parent" do
+      PageSpec.template_name_for(:update).should == "/ItemSpec/update"
+    end
+  
+    it "should override template name for template existing in both self and parent" do
+      ItemSpec.template_name_for(:show).should == "/ItemSpec/show"
+      PageSpec.template_name_for(:show).should == "/PageSpec/show"
+    end
+  
+    it "should transfer namespaces into folders" do
+      NamespaceSpec::ClassSpec.template_name_for(:show).should == "/NamespaceSpec/ClassSpec/show"
+    end
+  end
+  
+  describe "actions" do
+    it "should be able to check for action inside of actions.xxx files" do
+      ItemSpec.template_name_for(:increase).should == "/ItemSpec/actions"
+    end
+  
+    it "should be able to check for action inside of actions.xxx files" do
+      ItemSpec.template_name_for(:increase).should == "/ItemSpec/actions"
+      ItemSpec.template_name_for(:decrease).should == "/ItemSpec/actions"
+    end
+  
+    it "should inherit actions.xxx" do
+      PageSpec.template_name_for(:increase).should == "/ItemSpec/actions"
+      PageSpec.template_name_for(:decrease).should == "/PageSpec/actions"
+    end
+  end
+  
+  describe "controller_context_class, helper" do
+    before :each do 
+      ItemSpec.instance_variable_set "@controller_context_class", nil
+      ItemSpec.instance_variable_set "@controller_context_class", nil
+    end
+    
+    it "controller_context_class" do
+      ItemSpec.controller_context_class.should == ItemSpec::ItemSpecControllerContext
+      PageSpec.controller_context_class.should == PageSpec::PageSpecControllerContext
+      PageSpec::PageSpecControllerContext.is?(PageSpec::ItemSpecControllerContext).should be_true
+    end
+    
+    it "helper" do
+      module ::ItemSpecHelper
+        def controller_item; end
+      end
+      
+      module ::PageSpecHelper
+        def controller_page; end
+      end
+      
+      ItemSpec.helper ItemSpecHelper
+      PageSpec.helper PageSpecHelper
+      
+      ItemSpec::ItemSpecControllerContext.instance_methods.should include('controller_item')
+      PageSpec::PageSpecControllerContext.instance_methods.should include('controller_page')
+    end
+  end
+  
+  describe "other" do
+    it "should understand underscored paths" do
+      NamespaceSpec::ClassSpec.template_name_for(:update).should == "/namespace_spec/class_spec/update"
+    end
+  end
+end

data/spec/controller/controller_context_spec/views/ItemSpec/actions.erb

@@ -0,0 +1,4 @@
+<% case value %>
+<% when :increase %>
+<% when :decrease %>
+<% end %>

data/spec/controller/controller_context_spec/views/PageSpec/actions.erb

@@ -0,0 +1,3 @@
+<% case value %>
+<% when :decrease %>
+<% end %>

data/spec/controller/controller_helper_spec.rb

@@ -0,0 +1,57 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+
+describe "AbstractController" do
+  with_environment :test
+  with_abstract_controller_spec
+  
+  before :all do
+    @dir = "#{File.expand_path(File.dirname(__FILE__))}/controller_helper_spec"    
+    $LOAD_PATH << @dir  
+    AbstractController = Crystal::AbstractController  
+  end
+  
+  after :all do
+    $LOAD_PATH.delete @dir
+    remove_constants %w(
+      SomeHelperSpec
+      HelperSpec
+      HelperMethodSpec
+      AbstractController
+    )
+  end
+  
+  it "helper_method" do
+    class ::HelperMethodSpec
+      inherit AbstractController
+      
+      def some_controller_method
+        "some controller value (rendered in cotext of #{self.class})"
+      end
+      helper_method :some_controller_method
+      
+      def action; end
+    end
+        
+    ccall(HelperMethodSpec, :action).content.
+      should == "some controller value (rendered in cotext of HelperMethodSpec)"
+  end
+  
+  it "helper" do
+    module ::SomeHelperSpec
+      def wiget
+        "some wighet (rendered in context of #{self.class.name})"
+      end
+    end
+    
+    class ::HelperSpec
+      inherit AbstractController
+      
+      helper SomeHelperSpec
+      
+      def action; end
+    end
+    
+    ccall(HelperSpec, :action).content.
+      should == "some wighet (rendered in context of HelperSpec::HelperSpecControllerContext)"
+  end  
+end

data/spec/controller/controller_helper_spec/views/HelperMethodSpec/action.erb

@@ -0,0 +1 @@
+<%= some_controller_method %>

data/spec/controller/controller_helper_spec/views/HelperSpec/action.erb

@@ -0,0 +1 @@
+<%= wiget %>

data/spec/controller/controller_render_spec.rb

@@ -0,0 +1,191 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+
+describe "Controller render" do
+  with_environment :test
+  with_abstract_controller_spec
+  
+  before :all do
+    @dir = "#{File.expand_path(File.dirname(__FILE__))}/controller_render_spec"    
+    $LOAD_PATH << @dir    
+    AbstractController = Crystal::AbstractController
+  end
+  
+  after :all do
+    $LOAD_PATH.delete @dir
+    remove_constants %w(
+      LayoutFiltersSpec
+      LayoutSpec
+      AnotherLayout
+      ExplicitRenderSpec
+      RenderInsideOfControllerSpec
+      ForbidPartialAsActionSpec
+      FormatSpec
+      AlreadyRenderedSpec
+      SpecialFormatSpec
+      AnotherActionSpec
+      InlineRenderSpec
+      AbstractController
+    )
+  end
+    
+  describe 'layout' do  
+    it "should use :except and :only in layout" do
+      class ::LayoutFiltersSpec
+        inherit AbstractController
+        layout '/layouts/app', :only => :action_with_layout
+        
+        def action_with_layout; end
+        def action_without_layout; end
+      end
+      
+      ccall(LayoutFiltersSpec, :action_with_layout).content.should == "Layout html, content"  
+      ccall(LayoutFiltersSpec, :action_without_layout).content.should == "content"
+    end
+    
+    it "should apply formats to layout" do
+      class LayoutSpec
+        inherit AbstractController
+        layout '/layouts/app'
+      
+        def action; end      
+      end
+    
+      ccall(LayoutSpec, :action, :format => :html).content.should == "Layout html, content"  
+      ccall(LayoutSpec, :action, :format => :js).content.should == "Layout js, content"
+    end  
+      
+    it "should take :layout => false or :layout => '/another_layout'" do
+      class AnotherLayout
+        inherit AbstractController
+        layout '/layout/app'
+        
+        def action; end
+        
+        def without_layout
+          render :action => 'action', :layout => false
+        end
+        
+        def another_layout
+          render :action => 'action', :layout => '/layouts/admin'
+        end        
+      end
+      
+      ccall(AnotherLayout, :without_layout).content.should == "action"
+      ccall(AnotherLayout, :another_layout).content.should == "Admin layout, action"
+    end
+      
+    
+    it "explicitly rendered action shold be rendered with layout but template without" do
+      class ::ExplicitRenderSpec
+        inherit AbstractController
+        layout '/layouts/app'
+        
+        def another_action; end
+        
+        def action          
+          render :action => 'another_action'
+        end
+        
+        def render_template
+          render '/some_template'
+        end
+      end
+      
+      ccall(ExplicitRenderSpec, :action).content.should == "Layout html, another action"
+      ccall(ExplicitRenderSpec, :render_template).content.should == "some template"
+    end    
+  end
+  
+  it "inside of controller" do
+    class ::RenderInsideOfControllerSpec
+      inherit AbstractController
+
+      def some_action
+        render '/some_template'
+      end    
+    end
+
+    ccall(RenderInsideOfControllerSpec, 'some_action').content.should == "some template"
+  end
+  
+  it "should not allow to render partials as actions" do
+    class ::ForbidPartialAsActionSpec
+      inherit AbstractController
+      def action; end
+    end
+
+    lambda{ccall ForbidPartialAsActionSpec, :action}.should raise_error(/No template/)
+  end
+  
+  it "should render view with right format" do
+    class FormatSpec
+      inherit AbstractController
+      def action; end
+    end
+
+    ccall(FormatSpec, :action, :format => :html).content.should == "html format"    
+    ccall(FormatSpec, :action, :format => :js).content.should == "js format"
+  end
+  
+  it "should be able to use Template.render for different purposes (mail for example)" do
+    Crystal::Template.render("/standalone", :locals => {:a => 'a'}).should == 'standalone usage, a'
+  end
+  
+  it "should not rener if already rendered in controller" do
+    class ::AlreadyRenderedSpec
+      inherit AbstractController
+
+      def action
+        render '/AlreadyRenderedSpec/custom_template'
+      end
+    end
+
+    ccall(AlreadyRenderedSpec, :action).content.should == 'custom content'
+  end
+  
+  it "should handle serialization :json => obj (:xml, :js)" do
+    class ::SpecialFormatSpec
+      inherit AbstractController
+      
+      def json_action
+        render :json => {:a => "b"}
+      end
+      
+      def xml_action
+        render :xml => {:a => "b"}
+      end
+    end
+    
+    ccall(SpecialFormatSpec, :json_action, :format => :json).content.should == %({"a":"b"})      
+    ccall(SpecialFormatSpec, :xml_action, :format => :xml).content.should =~ /<a>b<\/a>/      
+    lambda{
+      ccall(SpecialFormatSpec, :json_action, :format => :xml)
+    }.should raise_error(/responing with :json to the :xml/)
+  end
+  
+  it "should render another action via :action => :action_name" do
+    class ::AnotherActionSpec
+      inherit AbstractController
+  
+      def another_action; end
+      
+      def action          
+        render :action => 'another_action'
+      end
+    end
+    
+    ccall(AnotherActionSpec, :action).content.should == "another action"
+  end
+    
+  it "should take :inline => 'hi' option" do
+    class ::InlineRenderSpec
+      inherit AbstractController
+      
+      def action
+        render :inline => "content"
+      end
+    end
+    
+    ccall(InlineRenderSpec, :action).content.should == "content"
+  end
+end