crystal_ext 0.0.7 → 0.0.11

data/spec/integration/basic_spec/views/smoke_test_spec/action.erb

@@ -0,0 +1 @@
+some content

data/spec/integration/helper.rb

@@ -0,0 +1,10 @@
+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/profiles/web_require'
+
+
+require 'crystal/spec'

data/spec/remote/helper.rb

@@ -0,0 +1,20 @@
+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/remote'
+
+require 'crystal/spec/remote'
+
+Spec::Example::ExampleGroup.class_eval do
+  def self.with_remote_spec
+    before :all do
+      crystal.after :environment do
+        crystal.conveyors.services do |ss|
+          ss.use Crystal::Processors::RemoteCaller, :content
+        end
+      end
+    end
+  end
+end

data/spec/remote/remote_spec.rb

@@ -0,0 +1,75 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+
+describe "Remote Basic" do
+  with_environment :test
+  with_remote_spec
+  
+  it "basic" do
+    class BasicSpec
+      inherit Crystal::Remote
+      
+      def call
+        {:result => 'some result'}
+      end
+    end
+    
+    workspace = rcall BasicSpec, :call, :format => 'json'
+    
+    workspace.delete(:remote_object).should be_a(BasicSpec)
+    expected_result = {      
+      :params => {"format" => "json"},
+      
+      :class => BasicSpec,   
+      :method_name => "call", 
+      
+      :remote_result => {:result => "some result"},
+      :content => %({"result":"some result"})
+    }
+    workspace.to_h(true).symbolize_keys.subset(expected_result.keys).should == expected_result
+  end
+  
+  describe "error handling should behave different in :production, :development and :test modes" do
+    it "error in :development mode" do    
+      class JsonErrorSpec
+        inherit Crystal::Remote
+      
+        def call_with_error
+          raise 'some error'
+        end
+      end
+    
+      config.environment = :development
+      silence_logger!
+    
+      workspace = rcall JsonErrorSpec, 'call_with_error', :format => 'json'
+    
+      workspace.delete(:remote_object).should be_a(JsonErrorSpec)
+      workspace.include?(:remote_result).should be_false
+      expected_result = {
+        :params => {"format" => "json"},
+      
+        :class => JsonErrorSpec,   
+        :method_name => "call_with_error", 
+      
+        :content => %({"error":"some error"})
+      }
+      workspace.to_h.symbolize_keys.subset(expected_result.keys).should == expected_result
+    end
+  end
+  
+  it "should be able to protect methods from GET request"
+  
+  it "should not allow unregistered object types be used as return value" do
+    class UnregisteredReturnValueSpec
+      inherit Crystal::Remote
+      
+      def call
+        Object.new
+      end
+    end
+   
+    lambda{
+      rcall UnregisteredReturnValueSpec, 'call', :format => 'json'
+    }.should raise_error(/You can't use object of type 'Object' as Remote's return value!/)
+  end
+end

data/spec/router/basic_spec.rb

@@ -0,0 +1,130 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+
+describe "Router Basic" do
+  
+  before :all do
+    class ::SomeController
+      def call; end
+    end
+  end
+  
+  after :all do
+    remove_constants %w(
+      SomeController 
+      BlogControllerSpec
+    )
+  end
+  
+  before :each do
+    @router = Crystal::Router.new :class
+    # @router.routes.push :default_router, Crystal::DefaultRouter.new
+    
+    @params = OpenObject.new
+    @router.stub(:workspace).and_return({:params => @params}.to_openobject)
+  end
+  
+  it "encode" do
+    @router.encode(SomeController, :call, :format => :json).should == ["/some_controller/call.json", {}]
+  end
+  
+  it "decode" do
+    @router.decode("/some_controller/call", {}).should == [SomeController, 'call', {}]
+  end
+  
+  describe "named routes" do
+    before :all do
+      class BlogControllerSpec
+        def call; end
+      end
+    end
+    
+    before :each do
+      @router.routes.unshift :named_router, Crystal::NamedRouter.new
+      @router.routes[:named_router].add 'some/path', SomeController
+      @router.routes[:named_router].add 'blog', BlogControllerSpec
+      
+      @named_router = @router.routes[:named_router]
+      
+      @helper = Object.new
+      @helper.extend Crystal::NamedRouter::Helper
+    end
+    
+    it "should encode and decode using named route" do
+      @router.encode(SomeController, :call, :format => :json).should == ["/some/path/call.json", {}]
+      @router.decode("/some/path/call", {}).should == [SomeController, 'call', {}]
+      
+      @router.encode(BlogControllerSpec, :call, :format => :json).should == ["/blog/call.json", {}]
+      @router.decode("/blog/call", {}).should == [BlogControllerSpec, 'call', {}]
+    end
+    
+    it "should generate <method_name>_<route_name>_path methods (on the fly)" do
+      @named_router.encode_route_method('show_blog_path').should == ["/blog/show", {}]
+      lambda{@named_router.encode_route_method('show_unknown_path')}.should raise_error(/Unknown route/)
+    end
+    
+    it "should provide helper" do
+      crystal.register :router
+      crystal[:router] = @router
+      @helper.show_blog_path.should == ["/blog/show", {}]
+      lambda{@helper.show_blog}.should raise_error(/undefined method/)      
+    end
+  end
+  
+  describe "url_for" do
+    it "should convert complex params to json" do
+      @router.url_for(SomeController, :call, :a => :b, :as_json => true).should == %(/some_controller/call?json=%7B%22a%22%3A%22b%22%7D)
+    end
+    
+    it "should escape params" do
+      @router.url_for(SomeController, :call, :a => 'b/c').should == "/some_controller/call?a=b%2Fc"
+    end
+    
+    it "url_for_remote" do
+      @router.stub(:current_class).and_return(SomeController)
+    
+      @router.url_for(SomeController, :call, :format => :json).should == "/some_controller/call.json"    
+      @router.url_for(:call, :format => :json).should == "/some_controller/call.json"
+        
+      @router.url_for(SomeController, :call).should == "/some_controller/call"
+      @router.url_for(:call).should == "/some_controller/call"
+      @router.url_for('call').should == "/some_controller/call"
+    end
+      
+    it "url_for_path should recognize first slash as to use url_for_path" do
+      @router.url_for('/some_path', :key => :value).should == "/some_path?key=value"
+      @router.url_for('/some_path').should == "/some_path"
+    end
+    
+    it "should mark url string with format" do
+      @router.stub(:current_class).and_return(SomeController)      
+      @router.url_for(:call, :format => :js).marks.format.to_s.should == 'js'
+      
+      @router.url_for('/path').marks.format.should be_nil
+      @router.url_for('/path', :format => :js).marks.format.to_s.should == 'js'      
+    end
+  end
+  
+  describe "persistent params" do
+    before :each do
+      @router.global_persistent_params << :l
+    end
+    
+    it "global persistent params" do                  
+      @params.l, @params.id = 'ru', 1
+
+      @router.url_for('/path').should == "/path?l=ru"      
+      @router.url_for('/path', :l => 'en').should == "/path?l=en"
+    end
+        
+    it "should persist params with begining underscore" do
+      @params._space, @params.id = 'space_id', 1
+      
+      @router.url_for('/path').should == '/path'
+      
+      @router.persist_params do
+        @router.url_for('/path').should == '/path?_space=space_id'
+        @router.url_for('/path', :_space => 'another_id').should == '/path?_space=another_id'
+      end
+    end
+  end
+end

data/spec/router/configurator_spec.rb

@@ -0,0 +1,29 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+
+describe "Configurator" do  
+  
+  before :all do
+    class ::BlogControllerSpec; end    
+  end
+  
+  after :all do
+    remove_constants %w(BlogControllerSpec)
+  end
+  
+  before :each do
+    @named_router = Crystal::NamedRouter.new
+    
+    @router = Crystal::Router.new :class
+    @router.routes.unshift :named_router, @named_router
+    
+    Crystal::Routes::Configurator.stub(:router).and_return(@router)
+  end
+  
+  it "named routes" do
+    crystal.routes do |config|
+      config.named_route 'blog', BlogControllerSpec
+    end
+    
+    @named_router.names.should include('blog')
+  end
+end

data/spec/router/helper.rb

@@ -0,0 +1,24 @@
+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/http'
+require 'crystal/router'
+
+require 'spec_ext'
+require 'crystal/spec/environment'
+
+Spec::Example::ExampleGroup.class_eval do
+  def self.with_router_spec
+    before :all do
+      crystal.after :environment do        
+        crystal.register :router, :depends_on => :environment do
+          Crystal::Router.new(:class, [[:default_router, Crystal::DefaultRouter.new]])
+        end
+      
+        crystal.conveyors.web.use Crystal::Processors::Router, :class_variable, :method_variable
+      end
+    end
+  end
+end

data/spec/router/integration_spec.rb

@@ -0,0 +1,42 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+
+describe "Remote Basic" do  
+  with_environment :test
+  with_router_spec
+  
+  before :all do
+    class ::AnRemote
+      def call; end
+    end
+  end
+  
+  after :all do
+    remove_constants %w(AnRemote)
+  end
+  
+  def call_router path, params 
+    crystal.conveyors.web.call :path => path, :params => Crystal::Params.new(params)
+  end
+  
+  it "basic" do    
+    workspace = call_router '/an_remote/call', :format => 'json'
+    
+    expected_result = {      
+      :path => "/an_remote/call", 
+      :params => {"format" => "json"}, #, 'method_name' => 'call', 'class_name' => 'AnRemote'},
+      
+      :class_variable => AnRemote,       
+      :method_variable => "call"
+    }
+    workspace.to_h(true).symbolize_keys.subset(expected_result.keys).should == expected_result
+  end
+  
+  it "params must be casted to string" do
+    workspace = call_router '/an_remote/call', :a => 'b'
+    workspace.params.to_h.subset('a').should == {'a' => 'b'}
+  end
+  
+  it "default router should raise error if route is invalid" do
+    lambda{call_router '/invalid/call', :format => 'json'}.should raise_error(/uninitialized constant Invalid/)
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/support/callbacks_spec.rb

@@ -0,0 +1,153 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+require "crystal/support/callbacks"
+
+describe "Callbacks" do
+  before :all do
+    class BasicCallbacksSpec
+      inherit Crystal::Callbacks
+
+      set_callback :callback_name, :before, :before_callback
+      set_callback :callback_name, :after, :after_callback
+      set_callback :callback_name, :around, :around_callback
+
+      protected
+        def around_callback
+          around_callback_called
+          yield
+        end
+    end
+  end
+  
+  it "basic" do
+    o = BasicCallbacksSpec.new
+    o.should_receive :before_callback
+    o.should_receive :around_callback_called
+    o.should_receive :after_callback
+    o.run_callbacks(:callback_name){"result"}.should == "result"
+  end
+
+  it "blocks" do
+    class BlockCallbacksSpec
+      inherit Crystal::Callbacks
+      
+      set_callback(:callback_name, :before){|controller| controller.result << :before}
+      set_callback :callback_name, :around do |controller, block|
+        begin
+          controller.result << :around_begin
+          block.call
+        ensure
+          controller.result << :around_end
+        end
+      end
+      set_callback(:callback_name, :after){|controller| controller.result << :after}      
+
+      def result
+        @result ||= []
+      end
+    end
+    
+    o = BlockCallbacksSpec.new
+    o.run_callbacks(:callback_name){"result"}.should == "result"
+    o.result.should == [:before, :around_begin, :after, :around_end]
+  end
+
+  it "inheritance" do
+    class InheritedCallbacksSpec < BasicCallbacksSpec
+      set_callback :callback_name, :before, :before_callback2
+    end
+    
+    o = InheritedCallbacksSpec.new
+    o.should_receive :before_callback
+    o.should_receive :before_callback2
+    o.should_receive :around_callback_called
+    o.should_receive :after_callback
+    o.run_callbacks(:callback_name){"result"}.should == "result"
+  end
+  
+  it 'terminator' do
+    class CallbackTerminatorSpec
+      inherit Crystal::Callbacks
+
+      set_callback :callback_name, :before, :before_callback, :terminator => false
+      set_callback :callback_name, :before, :before_callback2      
+
+      def method
+        run_callbacks :callback_name do
+          "result"
+        end
+      end
+
+      protected
+        def before_callback
+          false 
+        end
+    end
+    
+    o = CallbackTerminatorSpec.new
+    o.should_not_receive :before_callback2
+    o.run_callbacks(:callback_name){"result"}.should_not == "result"
+  end
+  
+  it 'conditions' do
+    class CallbackConditionsSpec
+      inherit Crystal::Callbacks
+
+      set_callback :callback_name, :before, :before_callback, :only => :another_method
+    end
+    
+    o = CallbackConditionsSpec.new
+    o.should_not_receive :before_callback
+    o.run_callbacks(:callback_name, :method => :method){"result"}.should == 'result'
+    
+    o = CallbackConditionsSpec.new
+    o.should_receive :before_callback
+    o.run_callbacks(:callback_name, :method => :another_method){"result"}.should == 'result'
+  end
+  
+  it "if, unless conditions" do
+    c = Crystal::Callbacks::AbstractCallback.new
+    c.conditions = {:if => lambda{|target, inf| true}}
+    c.run?(nil, {}).should be_true
+    
+    c.conditions = {:if => lambda{|target, inf| false}}
+    c.run?(nil, {}).should be_false
+    
+    c.conditions = {:unless => lambda{|target, inf| true}}
+    c.run?(nil, {}).should be_false
+    
+    c.conditions = {:unless => lambda{|target, inf| false}}
+    c.run?(nil, {}).should be_true
+  end
+  
+  it "only, except conditions" do
+    c = Crystal::Callbacks::AbstractCallback.new
+    c.conditions = {:only => :a}
+    c.run?(nil, {:method => :a}).should be_true
+    
+    c.conditions = {:only => :b}
+    c.run?(nil, {:method => :a}).should be_false
+    
+    c.conditions = {:except => :a}
+    c.run?(nil, {:method => :a}).should be_false
+    
+    c.conditions = {:except => :b}
+    c.run?(nil, {:method => :a}).should be_true
+  end
+  
+  
+  it "around callback should be able to change result value" do
+    class ChangeResultValueSpec
+      inherit Crystal::Callbacks
+  
+      set_callback :callback_name, :around, :around_callback
+      
+      def around_callback        
+        yield
+        'another result'
+      end
+    end
+    
+    o = ChangeResultValueSpec.new
+    o.run_callbacks(:callback_name){"result"}.should == 'another result'
+  end
+end