crystal 0.0.10 → 0.0.12

data/spec/controller/controller_render_spec.rb

@@ -0,0 +1,192 @@
+require 'rspec_ext'
+require "#{__FILE__.dirname}/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

data/spec/controller/error_handling_spec/views/diferrent_error_handling_spec/a.erb

@@ -0,0 +1 @@
+a

data/spec/controller/error_handling_spec/views/diferrent_error_handling_spec/b.erb

@@ -0,0 +1 @@
+b

data/spec/controller/error_handling_spec/views/diferrent_error_handling_spec/c.erb

@@ -0,0 +1 @@
+<% raise 'error in template' %>

data/spec/controller/error_handling_spec.rb

@@ -0,0 +1,97 @@
+require 'rspec_ext'
+require "#{__FILE__.dirname}/helper"
+
+describe "Error handling" do
+  with_environment :test
+  
+  before :all do    
+    @dir = "#{File.expand_path(File.dirname(__FILE__))}/error_handling_spec"    
+    $LOAD_PATH << @dir
+    AbstractController = Crystal::AbstractController
+    
+    crystal.before :environment do
+      crystal.config.test_error_template = crystal.config.development_error_template!
+    end
+  
+    crystal.after :environment do
+      crystal.conveyors.web do |web|
+        web.use Crystal::Processors::ControllerErrorHandling, :content
+        web.use Crystal::Processors::ControllerCaller, :content
+      end 
+    end
+  end
+  
+  after :all do
+    $LOAD_PATH.delete @dir
+    remove_constants %w(
+      DisplayErrorWithFormat
+      DiferrentErrorHandlingSpec
+      AbstractController
+    )
+  end
+  
+  it "should correctly display error messages in :development (with correct format)" do
+    class ::DisplayErrorWithFormat
+      inherit AbstractController
+      
+      def method
+        raise params.error 
+      end
+    end
+    
+    config.environment = :development
+    silence_logger!
+    
+    error = StandardError.new('some error')
+    
+    ccall(
+      DisplayErrorWithFormat, :method, 
+      {:error => error, :format => :html}
+    ).content.should =~ /html.+some error/m
+    
+    ccall(
+      DisplayErrorWithFormat, :method,
+      {:error => error, :format => :js}
+    ).content.should =~ /some error/
+    
+    ccall(
+      DisplayErrorWithFormat, :method,
+      {:error => error, :format => :non_existing_mime}
+    ).content.should =~ /some error/
+  end
+    
+  describe "should be different in :test, :development and :production" do
+    before :all do
+      class ::DiferrentErrorHandlingSpec
+        inherit AbstractController
+  
+        def a; end  
+        def b
+          raise 'error in remote'
+        end  
+        def c; end
+      end
+    end
+    
+    it "in :production errors shouldn't be shown to user"
+    
+    it "in development errors should be catched" do
+      config.environment = :development
+      silence_logger!
+      
+      # with view
+      ccall(DiferrentErrorHandlingSpec, :a).content.should == 'a'  
+      ccall(DiferrentErrorHandlingSpec, :b).content.should =~ /error in remote/              
+      ccall(DiferrentErrorHandlingSpec, :c).content.should =~ /error in template/
+    end
+  
+    it "should not catch errors in :test environment" do
+      config.environment = :test
+    
+      # with render
+      ccall(DiferrentErrorHandlingSpec, :a).content.should == 'a'    
+      lambda{ccall(DiferrentErrorHandlingSpec, :b)}.should raise_error(/error in remote/)
+      lambda{ccall(DiferrentErrorHandlingSpec, :c)}.should raise_error(/error in template/)
+    end
+  end
+end

data/spec/controller/helper.rb

@@ -0,0 +1,21 @@
+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 'crystal/controller'
+require 'crystal/http'
+
+require 'crystal/spec'
+
+RSpec::Core::ExampleGroup.class_eval do
+  def self.with_abstract_controller_spec
+    before :all do
+      crystal.after :environment do
+        crystal.conveyors.web do |web|
+          web.use Crystal::Processors::ControllerCaller, :content
+        end
+      end
+    end
+  end
+end

data/spec/controller/http_controller_spec.rb

@@ -0,0 +1,90 @@
+require 'rspec_ext'
+require "#{__FILE__.dirname}/helper"
+
+describe "HttpController" do
+  with_environment :test
+  with_http
+  
+  before :all do
+    @dir = "#{File.expand_path(File.dirname(__FILE__))}/http_controller_spec"    
+    $LOAD_PATH << @dir
+    HttpController = Crystal::HttpController
+    
+    crystal.after :environment do
+      crystal.conveyors.web do |web|
+        web.use Crystal::Processors::HttpWriter, :content
+        web.use Crystal::Processors::ControllerCaller, :content
+      end
+    end
+  end
+  
+  after :all do
+    $LOAD_PATH.delete @dir
+    remove_constants %w(
+      HttpController
+      ContentTypeSpec
+      StatusSpec
+      LocationSpec
+      ForbidGetSpec
+    )
+  end
+    
+  describe 'render' do
+    it "should take :content_type option" do
+      class ::ContentTypeSpec
+        inherit HttpController
+        
+        def action
+          render :inline => "some content", :content_type => Mime['js']          
+        end
+      end
+      
+      wcall(ContentTypeSpec, :action)
+      response.content_type.should == "application/javascript"
+    end
+    
+    it "should take :status option" do
+      class ::StatusSpec
+        inherit HttpController
+        
+        def action
+          render :inline => "some content", :status => 220
+        end
+      end
+      
+      wcall(StatusSpec, :action)
+      response.status.should == 220
+    end
+
+    it "should take :location option" do
+      class ::LocationSpec
+        inherit HttpController
+        
+        def action
+          render :location => "/", :status => 220
+        end
+      end
+      
+      wcall(LocationSpec, :action)
+      response.location.should == "/"
+      response.status.should == 220
+    end
+  end    
+  
+  it "should be able to protect methods from GET request" do
+    class ::ForbidGetSpec
+      inherit HttpController
+      allow_get_for :get_action
+      
+      def get_action; end
+      def post_action; end
+    end
+    
+    workspace = {:env => {'REQUEST_METHOD' => 'GET'}}
+    
+    wcall(ForbidGetSpec, :get_action, workspace, {})
+    lambda{
+      wcall(ForbidGetSpec, :post_action, workspace, {})
+    }.should raise_error(/not allowed/)
+  end
+end

data/spec/conveyor/conveyor_spec.rb

@@ -0,0 +1,124 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+
+describe "Conveyor" do
+  inject :conveyors => :conveyors
+  
+  with_environment :development
+  
+  def call_conveyor
+    r = conveyors.web.call(:result => [])
+    r.result
+  end
+  
+  it "smoke test" do
+    class SmokeTestASpec < Crystal::Processor      
+      def call
+        workspace.result << :a_before          
+        next_processor.call
+        workspace.result << :a_after
+      end
+    end
+
+    class SmokeTestBSpec < Crystal::Processor      
+      def call      
+        crystal[:workspace].result << :b_before      
+        next_processor.call
+        crystal[:workspace].result << :b_after
+      end
+    end
+    
+    conveyors.web.use SmokeTestASpec
+    conveyors.web.use SmokeTestBSpec
+    call_conveyor.should == [:a_before, :b_before, :b_after, :a_after]
+  end
+  
+  describe "error handling" do
+    it "common case" do
+      class CommonCaseASpec < Crystal::Processor
+        def call
+          workspace.result << :a_before
+              
+          begin
+            next_processor.call
+          rescue StandardError => e
+            workspace.result << e.message
+          end
+        end
+      end    
+  
+      class CommonCaseBSpec < Crystal::Processor
+        def call
+          workspace.result << :b_before
+          raise 'error before'
+        end
+      end
+  
+      conveyors.web.use CommonCaseASpec
+      conveyors.web.use CommonCaseBSpec
+      call_conveyor.should == [:a_before, :b_before, "error before"]
+    end
+  
+    it "should raise error if not catched" do
+      class NotCatchedErrorSpec < Crystal::Processor
+        def call
+          workspace.result << :before
+          raise 'error before'
+        end
+      end
+            
+      conveyors.web.use NotCatchedErrorSpec
+      lambda{call_conveyor}.should raise_error(/error before/)
+    end
+  
+    it "in after block" do
+      class ErrorInAfterBlockASpec < Crystal::Processor
+        def call
+          workspace.result << :a_before
+  
+          begin
+            next_processor.call
+          rescue StandardError => e
+            workspace.result << e.message
+          end
+        end
+      end    
+  
+  
+      class ErrorInAfterBlockBSpec < Crystal::Processor
+        def call
+          workspace.result << :b_before
+          next_processor.call
+          raise 'error after'          
+        end
+      end
+  
+  
+      conveyors.web.use ErrorInAfterBlockASpec
+      conveyors.web.use ErrorInAfterBlockBSpec
+      call_conveyor.should == [:a_before, :b_before, "error after"]
+    end
+  
+    it "bubbling (from error)" do
+      class ErrorBubblingASpec < Crystal::Processor
+        def call
+          begin
+            next_processor.call
+          rescue RuntimeError => e
+            workspace.result << e.message
+          end
+        end
+      end
+      
+      class ErrorBubblingBSpec < Crystal::Processor
+        def call
+          raise 'error'
+        end
+      end      
+      
+      conveyors.web.use ErrorBubblingASpec
+      conveyors.web.use ErrorBubblingBSpec
+      
+      call_conveyor.should == ['error']
+    end
+  end
+end

data/spec/conveyor/helper.rb

@@ -0,0 +1,8 @@
+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 'crystal/conveyor'
+
+require 'crystal/spec/environment'

data/spec/environment/_dependency_resolver_spec.rb

@@ -0,0 +1,50 @@
+# require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+# require 'crystal/support'
+# require 'crystal/environment/dependency_resolver'
+# 
+# describe "Dependency resolver" do    
+#   before :each do
+#     @dr = Crystal::DependencyResolver.new
+#     @result = []
+#   end
+#   
+#   attr_reader :result
+#   
+#   def add s
+#     @result << s
+#   end
+#   
+#   def run *args, &block
+#     @dr.run *args, &block
+#   end
+#   
+#   def load token
+#     @dr.call(token)
+#   end
+#   
+#   it "should be ordered" do
+#     run(:init){add :init}
+#     run(:a, :after => :init){add :a}  
+#     run(:b, :after => :a){add :b}
+#     run(:c, :after => :b){add :c}
+#   
+#     load :init
+#     
+#     result.should == [:init, :a, :b, :c]
+#   end  
+#   
+#   it "should be ordered 2 (from error)" do
+#     run(:init){add :init}
+#     run(:_b, :before => :init){add :_b}
+#     run(:b_, :after => :init){add :b_}
+#     
+#     run(:_c, :before => :_b){add :_c}
+#     run(:c_, :after => :b_){add :c_}
+#         
+#     run(:_a, :before => :init){add :_a}
+#     run(:a_, :after => :init){add :a_}
+#       
+#     load :init    
+#     result.should == [:_c, :_b, :_a, :init, :b_, :a_, :c_]
+#   end
+# end

data/spec/environment/environment_spec/app/app_plugin/config/ec_layout

@@ -0,0 +1 @@
+app layout

data/spec/environment/environment_spec/app/app_plugin/ec_some_file

@@ -0,0 +1 @@
+some file

data/spec/environment/environment_spec/app/config/config.test.yml

@@ -0,0 +1 @@
+key2: value2test

data/spec/environment/environment_spec/app/config/config.yml

@@ -0,0 +1,2 @@
+key: value
+key2: value2

data/spec/environment/environment_spec/gem_plugin/config/ec_layout

@@ -0,0 +1 @@
+plugin layouts

data/spec/environment/environment_spec.rb

@@ -0,0 +1,87 @@
+require 'rspec_ext'
+require "#{__FILE__.dirname}/helper"
+
+require 'crystal/environment'
+require 'crystal/spec/environment'
+
+describe "Environment basic spec" do    
+  inject :env => :environment
+
+  before :all do
+    @dir = File.expand_path(File.dirname(__FILE__))
+    
+    $APP_DIR = "#{@dir}/environment_spec/app"
+    
+    @app_plugin_dir = "#{@dir}/environment_spec/app/app_plugin"
+    @gem_plugin_dir = "#{@dir}/environment_spec/gem_plugin"
+    
+    $LOAD_PATH << @app_plugin_dir
+    $LOAD_PATH << @gem_plugin_dir
+    
+    Crystal::Config::DEFAULTS['environment'] = 'test'
+  end
+  
+  after :all do
+    $LOAD_PATH.delete @app_plugin_dir
+    $LOAD_PATH.delete @gem_plugin_dir
+    
+    $APP_DIR = nil
+  end
+  
+  describe 'files' do    
+    with_environment :test
+    
+    it "find_files?" do
+      env.file_exist?('/config/ec_layout').should be_true
+      env.file_exist?('/ec_some_file').should be_true
+    end
+  
+    it "find_file" do
+      lambda{env.find_file('/config/ec_layout')}.should raise_error(/Found multiple files/)
+      env.find_file('/ec_some_file').should == "#{@app_plugin_dir}/ec_some_file"
+      lambda{env.find_file('ec_some_file')}.should raise_error(AssertionError)
+    end
+  
+    it "find_files" do
+      env.find_files('/config/ec_layout').sort.should == ["#{@app_plugin_dir}/config/ec_layout", "#{@gem_plugin_dir}/config/ec_layout"]
+    end
+  
+    it "find_files_by_pattern" do
+      env.find_files_by_pattern('/*/ec_layout').sort.should == ["#{@app_plugin_dir}/config/ec_layout", "#{@gem_plugin_dir}/config/ec_layout"]
+    end
+  end
+  
+  describe 'config' do
+    with_environment :test
+    
+    it "should merge 'APP_DIR/config/config.yml' into config" do
+      config.key?.should be_true
+      config.key!.should == 'value'
+    end
+    
+    it "should merge 'APP_DIR/config/config.environment.yml' into config" do
+      config.key2?.should be_true
+      config.key2!.should == 'value2test'
+    end
+  end
+  
+  describe "spec should be isolated (via swap_metadata)" do
+    describe "first spec" do
+      with_environment
+    
+      before :all do
+        crystal.register(:spec_component)
+      end
+      
+      it "check" do
+        Micon.metadata.should include(:spec_component)
+      end
+    end
+    
+    describe "second spec" do
+      it "check" do
+        Micon.metadata.should_not include(:spec_component)
+      end
+    end
+  end
+end