rad_core 0.0.13

data/spec/remote/remote_spec.rb

@@ -0,0 +1,75 @@
+require 'remote/spec_helper'
+
+describe "Remote Basic" do
+  with_environment
+  with_remote_spec
+  
+  it "basic" do
+    class BasicSpec
+      inherit Rad::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).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 Rad::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.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 Rad::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/remote/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'rspec_ext'
+
+require 'rad/remote'
+
+require 'rad/spec/remote'
+
+rspec do
+  def self.with_remote_spec
+    before :all do
+      rad.after :environment do
+        rad.conveyors.services do |ss|
+          ss.use Rad::Processors::RemoteCaller, :content
+        end
+      end
+    end
+  end
+end

data/spec/router/alias_router_spec.rb

@@ -0,0 +1,98 @@
+require 'router/spec_helper'
+
+describe "AliasRouter" do  
+  before :all do
+    class SomeController
+    end
+  end
+  
+  after :all do
+    remove_constants %w(SomeController)
+  end
+  
+  before :each do
+    @router = Rad::AliasRouter.new
+  end
+    
+  it "encode / decode" do
+    @router.add '/login', class: SomeController, method: :login
+
+    @router.encode(SomeController, :login, {}).should == ["/login", {}]
+    @router.encode_method('login_path').should == [SomeController, :login] 
+    @router.decode("/login", {}).should == [SomeController, :login, {}]
+  end
+  
+  it "should differentiate aliases with similar path elements" do
+    @router.add '/login', class: SomeController, method: :login
+    @router.add '/login/twitter', class: SomeController, method: :twitter
+    
+    @router.encode(SomeController, :login, {}).should == ["/login", {}]
+    @router.decode("/login", {}).should == [SomeController, :login, {}]
+    
+    @router.encode(SomeController, :twitter, {}).should == ["/login/twitter", {}]
+    @router.decode("/login/twitter", {}).should == [SomeController, :twitter, {}]
+  end
+  
+  it "input validation" do
+    lambda{@router.add :login, class: SomeController, method: :login}.should raise_error(/\//)
+    lambda{@router.add '/login', class: SomeController}.should raise_error(/method/)
+    lambda{@router.add '/login', method: :login}.should raise_error(/class/)    
+    lambda{@router.add '/login', class: SomeController, method: :login, invalid: 'value'}.should raise_error(/unknown/)
+    lambda{@router.add '/login', class: SomeController, method: :login, url_root: 'users'}.should raise_error(/\//)
+    lambda{@router.add '/login', class: SomeController, method: :login, prefix: []}.should raise_error(/empty/)
+  end
+  
+  it "should use :url_root" do
+    @router.add '/login', class: SomeController, method: :login, url_root: '/space'
+    
+    @router.encode(SomeController, :login, {}).should == ["/space/login", {}]
+    @router.decode("/space/login", {}).should == [SomeController, :login, {}]
+  end  
+  
+  it "should return nil if route unknown" do
+    @router.encode(SomeController, :unknown, {}).should be_nil
+    @router.encode_method(:unknown_path).should be_nil
+    @router.decode("/login", {}).should be_nil
+  end
+  
+  it 'root alias' do
+    @router.add '/', class: SomeController, method: :home
+
+    @router.encode(SomeController, :home, {}).should == ["/", {}]
+    @router.decode("/", {}).should == [SomeController, :home, {}]
+    
+    # should not support url_root
+    -> {@router.add '/', class: SomeController, method: :home, url_root: '/space'}.should raise_error(/url_root/)
+  end
+  
+  describe "prefixes" do
+    it "basics" do
+      @router.add '/statistics', class: SomeController, method: :statistics, prefix: [:l, :space]
+    
+      @router.encode(SomeController, :statistics, l: 'en', space: 'personal').should == ["/l/en/space/personal/statistics", {}]
+      @router.encode_method("statistics_path").should == [SomeController, :statistics]
+      @router.decode("/l/en/space/personal/statistics", {}).should == [SomeController, :statistics, {l: 'en', space: 'personal'}]
+    end
+    
+    it "should also works with path with slashes" do
+      @router.add '/blogs/show', class: SomeController, method: :show, prefix: [:l, :space]
+    
+      @router.encode(SomeController, :show, l: 'en', space: 'personal').should == ["/l/en/space/personal/blogs/show", {}]
+      @router.decode("/l/en/space/personal/blogs/show", {}).should == [SomeController, :show, {l: 'en', space: 'personal'}]
+    end
+    
+    it "should raise error if prefixes not provided" do
+      @router.add '/login', class: SomeController, method: :login, prefix: [:l]
+      
+      lambda{@router.encode(SomeController, :login, {})}.should raise_error(/prefix/)
+      lambda{@router.decode('/login', {})}.should raise_error(/prefix/)
+    end
+    
+    it "should works with :url_root" do
+      @router.add '/blogs/show', class: SomeController, method: :show, prefix: [:l], url_root: '/users'
+    
+      @router.encode(SomeController, :show, l: 'en').should == ["/users/l/en/blogs/show", {}]
+      @router.decode("/users/l/en/blogs/show", {}).should == [SomeController, :show, {l: 'en'}]
+    end
+  end
+end

data/spec/router/basic_spec.rb

@@ -0,0 +1,111 @@
+require 'router/spec_helper'
+
+describe "Router Basic" do
+  
+  before :all do
+    class ::BlogsController
+      include Rad::CoreRoutingHelper
+      
+      def show; end
+    end
+  end
+  
+  after :all do
+    remove_constants %w(BlogsController)
+  end
+  
+  before :each do
+    @router = Rad::Router.new :class
+    
+    @params = Rad::Params.new
+    @router.stub(:safe_workspace).and_return({params: @params}.to_openobject)
+  end
+  
+  it "encode" do
+    @router.encode(BlogsController, :show, format: 'json').should == ["/blogs_controller/show.json", {}]
+  end
+  
+  it "encode_method" do
+    lambda{@router.encode_method :class_method}.should raise_error(/route method/)    
+    @router.routes.first.should_receive(:encode_method).and_return([BlogsController, :show])
+    @router.encode_method(:class_method).should == [BlogsController, :show]
+  end
+    
+  it "decode" do    
+    @router.decode("/blogs_controller/show", {}).should == [BlogsController, :show, {}]
+  end  
+  
+  it "skip" do
+    @router.skip(/\/fs/)
+    
+    skip = catch :skip do
+      @router.decode("/fs/user/avatar", {})
+      nil
+    end
+    skip.should_not be_nil
+  end
+    
+  describe "url_for" do
+    it "should convert complex params to json" do
+      @router.url_for(BlogsController, :show, a: :b, as_json: true).should == %(/blogs_controller/show?json=%7B%22a%22%3A%22b%22%7D)
+    end
+    
+    it "should escape params" do
+      @router.url_for(BlogsController, :show, a: 'b/c').should == "/blogs_controller/show?a=b%2Fc"
+    end
+    
+    it "url_for" do
+      @router.stub(:current_class).and_return(BlogsController)
+    
+      @router.url_for(BlogsController, :show, format: 'json').should == "/blogs_controller/show.json"    
+      @router.url_for(:show, format: 'json').should == "/blogs_controller/show.json"
+        
+      @router.url_for(BlogsController, :show).should == "/blogs_controller/show"
+      @router.url_for(:show).should == "/blogs_controller/show"
+      @router.url_for(:show).should == "/blogs_controller/show"
+    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(BlogsController)      
+      @router.url_for(:show, format: 'js').marks.format.should == 'js'
+      
+      @router.url_for('/path').marks.format.should be_nil
+      @router.url_for('/path', format: 'js').marks.format.should == 'js'
+    end
+    
+    it "shouldn't modify arguments (from error)" do
+      options = {format: :js}
+      @router.url_for(BlogsController, :show, options).should == "/blogs_controller/show.js"
+      options.should == {format: :js}
+    end
+  end
+  
+  describe "persistent params" do
+    before :each do
+      @router.persistent_params << :l
+    end
+    
+    it "global persistent params" do                  
+      @params.l, @params.id = 'ru', 1
+
+      @router.url_for(BlogsController, :show).should == "/blogs_controller/show?l=ru"      
+      @router.url_for(BlogsController, :show, l: 'en').should == "/blogs_controller/show?l=en"
+    end
+        
+    it "should persist params with begining underscore" do
+      @params._space, @params.id = 'space_id', 1
+      
+      @router.url_for(BlogsController, :show).should == '/blogs_controller/show'
+      
+      @router.persist_params do
+        @router.url_for(BlogsController, :show).should == '/blogs_controller/show?_space=space_id'
+        @router.url_for(BlogsController, :show, _space: 'another_id').should == '/blogs_controller/show?_space=another_id'
+      end
+    end
+  end
+end

data/spec/router/configurator_spec.rb

@@ -0,0 +1,18 @@
+require 'router/spec_helper'
+
+describe "Configurator" do  
+  before :each do
+    @router = Rad::Router.new :class
+    Rad::Routes::Configurator.stub(:router).and_return(@router)
+  end
+  
+  it "named routes" do
+    rad.routes do |config|
+      config.stub(:router).and_return(@router)
+      
+      config.skip(/^\/favicon/)
+    end
+    
+    @router.skip.size.should > 0
+  end
+end

data/spec/router/integration_spec.rb

@@ -0,0 +1,42 @@
+require 'router/spec_helper'
+
+describe "Remote Basic" do  
+  with_environment
+  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 
+    rad.conveyors.web.call path: path, params: Rad::Params.new(params)
+  end
+  
+  it "basic" do    
+    workspace = call_router '/an_remote/call', format: 'json'
+    
+    expected_result = {      
+      path: "/an_remote/call", 
+      params: {format: 'json'},
+      
+      class_variable: AnRemote,       
+      method_variable: :call
+    }
+    workspace.to_h(true).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/router/persistent_params_spec.rb

@@ -0,0 +1,65 @@
+require 'router/spec_helper'
+
+describe "Persistent Params" do
+  after :all do
+    remove_constants %w(PathParamsRouter)
+  end
+  
+  before :each do
+    @router = Rad::Router.new :class
+
+    @params = Rad::Params.new
+    @router.stub(:safe_workspace).and_return({params: @params}.to_openobject)
+
+    @router.persistent_params << :l
+  end
+  
+  describe 'Basics' do  
+    it "global persistent params" do                  
+      @params.merge! l: 'ru', id: 1
+
+      @router.encode(Object, :send).should == ["/object/send", {l: 'ru'}]
+      @router.encode(Object, :send, l: 'en').should == ["/object/send", {l: 'en'}]
+    end
+      
+    it "should persist params with begining underscore" do
+      @params.merge! _space: 'space_id', id: 1
+    
+      @router.encode(Object, :send).should == ['/object/send', {}]
+    
+      @router.persist_params do
+        @router.encode(Object, :send).should == ["/object/send", {_space: 'space_id'}]
+        @router.encode(Object, :send, _space: 'another_id').should == ["/object/send", {_space: 'another_id'}]
+      end
+    end
+  end
+  
+  describe "Micelaneous checks" do
+    it "should not persist special params" do
+      @params.merge! _method: 'get'
+      
+      @router.persist_params do        
+        @router.encode(Object, :send).should == ["/object/send", {}]
+      end
+    end    
+  end
+  
+  it "should correctly works when params are encoded in url path" do
+    class PathParamsRouter
+      def encode klass, method, params
+        [%(#{klass.name}/#{method}#{'/' unless params.empty?}#{params.to_a.collect{|k, v| "#{k}/#{v}"}.join('/')}), {}]
+      end
+      
+      def decode path, params
+      end
+    end
+    
+    router = Rad::Router.new :class, [[:prefix_router, PathParamsRouter.new]]
+    router.persistent_params << :l    
+    params = Rad::Params.new
+    params.l = 'en'    
+    router.stub(:safe_workspace).and_return({params: params}.to_openobject)            
+    
+    router.encode(Object, :send).should == ["Object/send/l/en", {}]
+  end
+end

data/spec/router/restful_router_spec.rb

@@ -0,0 +1,120 @@
+require 'router/spec_helper'
+
+describe "RestfulRouter" do  
+  before :all do
+    class ::BlogControllerSpec
+      def show; end
+    end    
+  end
+  
+  after :all do
+    remove_constants %w(BlogControllerSpec)
+  end
+      
+  before :each do
+    @router = Rad::RestfulRouter.new
+  end
+  
+  describe 'core API' do      
+    it "singleton resource" do
+      @router.add :blogs, class: BlogControllerSpec
+    
+      @router.encode(BlogControllerSpec, :show, {}).should == ["/blogs/show", {}]
+      @router.encode_method('show_blog_path').should == [BlogControllerSpec, :show]
+      @router.encode_method('show_blogs_path').should == [BlogControllerSpec, :show]
+      @router.decode("/blogs/show", {}).should == [BlogControllerSpec, :show, {}]
+    end
+    
+    it "object resource" do
+      @router.add :blogs, class: BlogControllerSpec
+      
+      @router.encode(BlogControllerSpec, :show, id: '10', view: 'full').should == ["/blogs/10/show", {view: 'full'}]
+      @router.encode_method('show_blog_path').should == [BlogControllerSpec, :show]
+      @router.encode_method('show_blogs_path').should == [BlogControllerSpec, :show]
+      @router.decode("/blogs/10/show", {view: 'full'}).should == [BlogControllerSpec, :show, {id: '10', view: 'full'}]
+    end    
+  end
+  
+  describe "prefixes" do
+    it "singleton resource" do
+      @router.add :blogs, class: BlogControllerSpec, prefix: [:l, :space]
+      
+      @router.encode(BlogControllerSpec, :show, l: 'en', space: 'personal').should == ["/l/en/space/personal/blogs/show", {}]
+      @router.decode("/l/en/space/personal/blogs/show", {}).should == [BlogControllerSpec, :show, {l: 'en', space: 'personal'}]
+    end
+    
+    it "object resource" do
+      @router.add :blogs, class: BlogControllerSpec, prefix: [:l, :space]
+      
+      @router.encode(BlogControllerSpec, :show, id: '10', l: 'en', space: 'personal').should == ["/l/en/space/personal/blogs/10/show", {}]
+      @router.decode("/l/en/space/personal/blogs/10/show", {}).should == [BlogControllerSpec, :show, {id: '10', l: 'en', space: 'personal'}]
+    end
+        
+    it "should raise error or return nil if prefixes not provided" do      
+      @router.add :blogs, class: BlogControllerSpec, prefix: [:l]
+      
+      lambda{@router.encode(BlogControllerSpec, :show, {})}.should raise_error(/prefix/)      
+      @router.decode('/blogs/show', {}).should be_nil
+      
+      lambda{@router.encode(BlogControllerSpec, :show, id: '10')}.should raise_error(/prefix/)      
+      @router.decode('/blogs/10/show', {}).should be_nil
+    end
+    
+    it "should works with :url_root" do
+      @router.add :blogs, class: BlogControllerSpec, prefix: [:l], url_root: '/users'
+            
+      @router.encode(BlogControllerSpec, :show, l: 'en').should == ["/users/l/en/blogs/show", {}]
+      @router.decode("/users/l/en/blogs/show", {}).should == [BlogControllerSpec, :show, {l: 'en'}]
+      
+      @router.encode(BlogControllerSpec, :show, id: '10', l: 'en').should == ["/users/l/en/blogs/10/show", {}]
+      @router.decode("/users/l/en/blogs/10/show", {}).should == [BlogControllerSpec, :show, {id: '10', l: 'en'}]
+    end
+    
+    it "should be able to use alias for prefix parameter" do
+      @router.add :blogs, class: BlogControllerSpec, prefix: [:l, [:space_id, 'space']]
+      
+      @router.encode(BlogControllerSpec, :show, l: 'en', space_id: 'personal').should == ["/l/en/space/personal/blogs/show", {}]
+      @router.decode("/l/en/space/personal/blogs/show", {}).should == [BlogControllerSpec, :show, {l: 'en', space_id: 'personal'}]
+    end
+  end
+  
+  describe "micelaneous check" do    
+    it "should allow only plural form in resource definition" do      
+      lambda{@router.add :blog, class: BlogControllerSpec}.should raise_error(/plural/)
+      @router.add :blogs, class: BlogControllerSpec
+    end
+    
+    it "shouldn't allow slashes in resource name" do
+      lambda{@router.add '/admin/blogs', class: BlogControllerSpec}.should raise_error(/\//)
+    end
+    
+    it "should correctly works with unknown routes" do
+      @router.encode(BlogControllerSpec, :show, {}).should be_nil
+      @router.encode_method('show_blog_path').should be_nil
+      @router.encode_method('show_blogs_path').should be_nil
+      @router.decode("/blogs/show", {}).should be_nil
+            
+      @router.encode(BlogControllerSpec, :show, id: '10', view: 'full').should be_nil
+      @router.encode_method('show_blog_path').should be_nil
+      @router.encode_method('show_blogs_path').should be_nil
+      @router.decode("/blogs/10/show", view: 'full').should be_nil
+    end
+  end
+  
+  it "should use :url_root" do
+    @router.add :blogs, class: BlogControllerSpec, url_root: '/users'
+    
+    @router.encode(BlogControllerSpec, :show, {}).should == ["/users/blogs/show", {}]
+    @router.decode("/users/blogs/show", {}).should == [BlogControllerSpec, :show, {}]
+        
+    @router.encode(BlogControllerSpec, :show, id: '10').should == ["/users/blogs/10/show", {}]
+    @router.decode("/users/blogs/10/show", {}).should == [BlogControllerSpec, :show, {id: '10'}]
+  end  
+  
+  it "input validation" do
+    lambda{@router.add :blogs, class: BlogControllerSpec, invalid: 'value'}.should raise_error(/unknown/)
+    lambda{@router.add :blogs}.should raise_error(/class/)    
+    lambda{@router.add :blogs, class: BlogControllerSpec, url_root: 'users'}.should raise_error(/\//)
+    lambda{@router.add :blogs, class: BlogControllerSpec, prefix: []}.should raise_error(/empty/)
+  end
+end

data/spec/router/routing_helper_spec.rb

@@ -0,0 +1,55 @@
+require 'router/spec_helper'
+
+describe "Routing Helper" do
+  
+  before :all do
+    class ::BlogsController
+      include Rad::CoreRoutingHelper
+      
+      def show; end
+    end
+  end
+  
+  after :all do
+    remove_constants %w(BlogsController)
+  end
+  
+  before :each do
+    @router = Rad::Router.new :class
+    
+    @params = Rad::Params.new
+    @router.stub(:safe_workspace).and_return({params: @params}.to_openobject)
+    
+    @controller = BlogsController.new
+    @controller.stub(:router).and_return(@router)
+  end
+      
+  it "basic" do          
+    @router.stub(:encode_method).and_return([BlogsController, :show])      
+    @controller.show_blogs_path.should == "/blogs_controller/show"
+  end
+  
+  it "correct works if there's no route" do
+    lambda{@controller.undefined_path}.should raise_error(/no route for/)
+    lambda{@controller.show_blogs}.should raise_error(/undefined method/) 
+  end
+  
+  it "argument parsing" do
+    @router.stub(:encode_method).and_return([BlogsController, :show])      
+    
+    @controller.show_blogs_path.should == "/blogs_controller/show"
+    @controller.show_blogs_path(a: 'b').should == "/blogs_controller/show?a=b"
+    @controller.show_blogs_path(10, a: 'b').should == "/blogs_controller/show?a=b&id=10"      
+  end
+  
+  it "helper_method should take any object as :id" do      
+    class IdStub
+      def to_param
+        'some_id'
+      end
+    end
+
+    @router.stub(:encode_method).and_return([BlogsController, :show])      
+    @controller.show_blogs_path(IdStub.new, a: 'b').should == "/blogs_controller/show?a=b&id=some_id"
+  end
+end

data/spec/router/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'rspec_ext'
+
+require 'rad/http'
+require 'rad/router'
+
+require 'rad/spec/environment'
+
+rspec do
+  def self.with_router_spec
+    before :all do
+      rad.after :environment do        
+        rad.register :router, depends_on: :environment do
+          Rad::Router.new(:class, [[:default_router, Rad::SimpleRouter.new]])
+        end
+      
+        rad.conveyors.web.use Rad::Processors::Router, :class_variable, :method_variable
+      end
+    end
+  end
+end