lego-core 0.0.1

data/spec/lego/controller/route_handler_spec.rb

@@ -0,0 +1,188 @@
+require File.join('spec', '/spec_helper')
+
+describe Lego::Controller::RouteHandler do
+
+  context '.match_all_routes with matching route' do
+    before do
+      @route_handler = empty_route_handler
+      @env = {}
+      @env["REQUEST_METHOD"] = 'GET'
+      @valid_route = {:path => '/myadmin'}
+      @other_route = {:path => '/foo'}
+      @fake_routes = {:get => [@other_route, @other_route, @valid_route], :post => [{}]}
+    end
+    
+    it 'should return matching route if found' do
+      @route_handler.should_receive(:routes).and_return(@fake_routes)
+      @route_handler.should_receive(:run_matchers).with(@other_route, @env).exactly(2).times.and_return(false)
+      @route_handler.should_receive(:run_matchers).with(@valid_route, @env).and_return(true)
+      @route_handler.match_all_routes(@env).should eql(@valid_route)
+    end
+    
+    it 'should return false when no matching route is found' do
+      @route_handler.should_receive(:routes).and_return({:get=> [{}]})
+      @route_handler.should_receive(:run_matchers).and_return(false)
+      @route_handler.match_all_routes(@env).should eql(nil)
+    end
+  end
+
+  context '.run_matchers' do
+    before do
+      @route_handler = empty_route_handler
+      @env = {}
+      @route = { :path => '/mypath' } 
+      module Match1; end
+      module Match2; end
+      @matchers = [Match1, Match2]
+    end
+    
+    it 'should return true when matching route found' do
+      Match1.should_receive(:match_route).with(@route, @env).and_return(false)
+      Match2.should_receive(:match_route).with(@route, @env).and_return(true)
+      @route_handler.should_receive(:matchers).and_return(@matchers)
+      @route_handler.run_matchers(@route, @env).should eql(true)
+    end
+    
+    it 'should return false when no matching route found' do
+      Match1.should_receive(:match_route).with(@route, @env).and_return(false)
+      Match2.should_receive(:match_route).with(@route, @env).and_return(false)
+      @route_handler.should_receive(:matchers).and_return(@matchers)
+      @route_handler.run_matchers(@route, @env).should eql(false)
+    end
+  end
+
+  context '.routes' do
+    before do
+      @route_handler = empty_route_handler
+    end
+
+    it 'should return empty routes when new' do
+      @route_handler.routes.should eql({
+        :get       => [],
+        :post      => [],
+        :put       => [],
+        :head      => [],
+        :delete    => [],
+        :not_found => nil
+      })
+    end
+  end
+
+  context '.add_route' do
+    before do
+      @route_handler = empty_route_handler
+    end
+
+    it 'should appen routes with their options' do
+      route_options1 = { :path => '/a_path1' }
+      route_options2 = { :path => '/a_path2' }
+      @route_handler.add_route(:get, route_options1)
+      @route_handler.add_route(:get, route_options2)
+      @route_handler.routes[:get].should eql([route_options1, route_options2])
+    end
+
+    it 'should set not_found route if method is :not_found' do
+      route_options = { :action_block => '{block}' }
+      @route_handler.add_route(:not_found, route_options)
+      @route_handler.routes[:not_found].should eql(route_options)
+    end
+  end
+
+  context '.matchers' do
+    before do
+      @route_handler = empty_route_handler
+    end
+
+    it 'should return an empty Array when new' do
+      @route_handler.matchers.should eql([])  
+    end
+
+  end
+
+  context '.add_matcher' do
+    before do
+      @route_handler = empty_route_handler
+      module ValidMatcher; def self.match_route(route, env); end; end
+      module BrokenMatcher; end
+    end
+
+    it 'should store route matchers if valid' do
+      @route_handler.add_matcher(ValidMatcher)
+      @route_handler.matchers.should eql([ValidMatcher])
+    end
+    
+    it 'should raise InvalidMatcher error if invalid' do
+      @route_handler.should_receive(:validate_matcher).and_return(false)
+      lambda { @route_handler.add_matcher(BrokenMatcher) }.should raise_error(Lego::Controller::RouteHandler::InvalidMatcher)
+      @route_handler.matchers.should == []
+    end
+  end
+
+  context '.validate_matcher' do
+    before do
+      @route_handler = empty_route_handler
+      module MyBrokenMatcher; end
+      module MyValidMatcher; def self.match_route(); end; end
+    end
+    
+    it 'should return true if a valid Matcher module' do
+      @route_handler.validate_matcher(MyValidMatcher).should be_true
+    end
+
+    it 'should return false if not a valid Matcher module' do
+      @route_handler.validate_matcher(MyBrokenMatcher).should be_false
+    end
+  end
+
+  context 'when extended' do
+    before do
+      reset_lego_base
+    end
+    it 'plugins should be copied from base class' do
+
+      module GlobalPlug
+        def self.register(lego)
+          lego.add_plugin :router, self
+        end
+
+        def another_routehandler 
+          add_route(:get, {})
+        end
+
+        def self.match_route(route, env); end
+      end
+
+      # Create two fake plugins
+      Object.const_set(:App1Plug, GlobalPlug.clone)
+      Object.const_set(:App2Plug, GlobalPlug.clone)
+
+      Lego.plugin GlobalPlug
+
+      create_new_app("MyApp1", Lego::Controller)
+      create_new_app("MyApp2", Lego::Controller)
+
+      MyApp1.plugin App1Plug
+      MyApp2.plugin App2Plug
+
+      Lego::Controller::RouteHandler.matchers.should eql([GlobalPlug])
+      MyApp1::RouteHandler.matchers.should eql([GlobalPlug, App1Plug])
+      MyApp2::RouteHandler.matchers.should eql([GlobalPlug, App2Plug])
+    end
+
+    after do
+      rm_const "GlobalPlug", "App1Plug", "App2Plug", "MyApp1", "MyApp2"
+    end
+  end
+
+end
+
+def empty_route_handler
+  route_handler = Lego::Controller::RouteHandler.clone
+  route_handler.class_eval "remove_instance_variable :@route_cache if @route_cache"
+  route_handler.class_eval "remove_instance_variable :@matcher_cache if @matcher_cache"
+  route_handler
+end
+
+
+
+

data/spec/lego/controller_spec.rb

@@ -0,0 +1,297 @@
+require File.join('spec', '/spec_helper')
+
+describe Lego::Controller do
+
+  it 'should contain an ActionContext Class' do
+    Lego::Controller::ActionContext.should be_kind_of(Class)
+  end
+
+  it 'should contain an RouteHandler Module' do
+    Lego::Controller::RouteHandler.should be_kind_of(Module)
+  end
+
+    it 'should load Lego::Plugin::Controller::NotFound by default' do
+      Lego::Controller.methods.should include('not_found')
+    end
+
+  context 'when inherited' do
+    before do
+      create_new_app("MyController", Lego::Controller)
+    end
+
+    it 'should create a new ActionContext for the inheriting class' do
+      MyController::ActionContext.object_id.should_not == Lego::Controller::ActionContext.object_id
+    end
+
+    it 'should setup a constant on ActionContext holding a reference to the application class' do
+      MyController::ActionContext::ApplicationClass.should eql(MyController)
+    end
+
+    it 'should create a new RouteHandler for the inheriting class' do
+      MyController::RouteHandler.object_id.should_not == Lego::Controller::RouteHandler.object_id
+    end
+
+    it 'should create a new Config for the inheriting class' do
+      MyController::Config.object_id.should_not == Lego::Controller::Config.object_id
+    end
+
+    it 'should create a new Config for every inheriting class' do
+      create_new_app "MyOtherController", Lego::Controller
+      MyController::Config.object_id.should_not == MyOtherController::Config.object_id
+    end
+  end
+
+  context '.plugin <plugin_module>' do
+    before do
+      create_new_app("MyApp", Lego::Controller)
+      module MyPlugin
+        def self.register(lego)
+          lego.register self
+        end
+      end
+    end
+
+    after do
+      rm_const "MyPlugin", "MyApp"
+    end
+
+    it 'should have a class method named plugin' do
+      MyApp.should respond_to(:plugin)
+    end
+
+    it 'should call self.register on <plugin_module>' do
+      MyPlugin.should_receive(:register).with(MyApp)
+      MyApp.plugin MyPlugin
+    end
+  end
+
+  context '.add_plugin :view, <plugin_module>' do
+    before do
+      create_new_app("MyApp", Lego::Controller)
+      module MyViewPlugin
+        def self.register(lego)
+          lego.add_plugin :view, self
+        end
+        def makebold(content)
+          "<b>#{content}</b>"
+        end
+      end
+    end
+
+    it 'should make plugin methods availibe to ActionContext' do
+      MyApp::ActionContext.instance_methods.should_not include('makebold')
+      MyApp.plugin MyViewPlugin
+      MyApp::ActionContext.instance_methods.should include('makebold')
+    end
+
+    after do
+      rm_const "MyViewPlugin", "MyApp"
+    end
+  end
+
+  context '.add_plugin :controller, <plugin_module>' do
+    before do
+      create_new_app("MyApp", Lego::Controller)
+      module MyPlugin2
+        def self.register(lego)
+          lego.add_plugin :controller, PluginMethods
+        end
+        module PluginMethods
+          def get_this;end
+        end
+      end
+    end
+
+    after do
+      rm_const "MyPlugin2", "MyApp"
+    end
+
+    it 'should extend controller with <plugin_module>' do
+      MyApp.should_not respond_to(:get_this)
+      MyApp.plugin MyPlugin2
+      MyApp.should respond_to(:get_this)
+    end
+  end
+
+  context '.add_route <method> <route>' do
+    before do
+      create_new_app("MyApp", Lego::Controller)
+    end
+
+    it 'should be defined' do
+      MyApp.should respond_to(:add_route)
+    end
+
+    it 'should add a route to RouteHandler' do
+      route = {:path => '/somewhere'}
+      method = :get
+      MyApp::RouteHandler.should_receive(:add_route).with(method, route)
+      MyApp.add_route(method, route)
+    end
+    after { rm_const 'MyApp' }
+  end
+
+  context '.add_plugin :router, <plugin_module>' do
+    before do
+      create_new_app("MyApp", Lego::Controller)
+      module MyRouter
+        def self.register(lego)
+          lego.add_plugin :router, RouterMethods 
+        end
+        module RouterMethods
+          extend self
+          def match_route
+          end
+        end
+      end
+    end
+
+    after do
+      rm_const "MyRouter", "MyApp"
+    end
+
+    it 'should not extend controller with <plugin_module>' do
+      MyApp.plugin MyRouter
+      MyApp.should_not respond_to(:match_route)
+    end
+
+    it 'should call add_matcher on RouteHandler with <plugin_module>' do
+      MyApp::RouteHandler.should_receive(:add_matcher).with(MyRouter::RouterMethods)
+      MyApp.plugin MyRouter
+    end
+  end
+
+  context '.call <env>' do
+    context 'with a route that matches' do
+      before do
+        @env = ["Environment"]
+        create_new_app("MyApp", Lego::Controller)
+        MyApp::RouteHandler.should_receive(:match_all_routes).with(@env).and_return("route")
+      end
+
+      it 'should create a new instance of ActionContext' do
+        mock = mock("ActionContext instance")
+        mock.should_receive(:run).with("route", @env)
+        MyApp::ActionContext.should_receive(:new).and_return(mock)
+      end
+
+      after do
+        MyApp.call(@env)
+        rm_const "MyApp"
+      end
+    end
+
+    context 'with a route that don\'t matches' do
+      before do
+        @env = ["Environment"]
+        create_new_app("MyApp", Lego::Controller)
+        MyApp::RouteHandler.should_receive(:match_all_routes).with(@env).and_return(nil)
+      end
+
+      it 'should create a new instance of ActionContext' do
+        MyApp::ActionContext.should_not_receive(:new)
+      end
+
+      after do
+        MyApp.call(@env).should eql(
+          [404, {'Content-Type' => 'text/html'}, '404 - Not found']
+        )
+        rm_const "MyApp"
+      end
+    end
+
+    context 'without matching route and a :not_found route defined' do
+      before do
+        @env = ["Rack Env"]
+        @routes = { :not_found => {}}
+        create_new_app("MyApp", Lego::Controller)
+        MyApp::RouteHandler.should_receive(:match_all_routes).with(@env).and_return(nil)
+        MyApp::RouteHandler.should_receive(:routes).and_return( @routes )
+      end
+
+      it 'should create a new ActionContext with the :not_found route' do
+        action_context = mock("ActionContext instance")
+        MyApp::ActionContext.should_receive(:new).and_return(action_context)
+        action_context.should_receive(:run).with(@routes[:not_found], @env)
+      end
+
+      after do
+        MyApp.call(@env)
+        rm_const "MyApp"
+      end
+    end
+  end
+
+  context ".set" do
+    context 'on Lego::Controller' do
+
+      it "should proxy the method call to its own Config" do
+        Lego::Controller::Config.should_receive(:set).and_return(nil)
+        Lego::Controller.set :foo => "bar"
+      end
+    end
+
+    context "on subclasses" do
+      
+      before do
+        create_new_app "MyApp", Lego::Controller
+      end
+
+      it "should proxy the method call to its own Confg" do
+        MyApp::Config.should_receive(:set).and_return(nil)
+        MyApp.set :foo => "bar"
+      end
+
+      after do
+        rm_const "MyApp"
+      end
+    end
+  end
+
+  context ".environment <env>" do
+    
+    context 'on Lego::Controller' do
+
+      before do
+        @config_block = lambda {}
+      end
+
+      it 'should proxy the method call to its own config' do
+        Lego::Controller::Config.should_receive(:environment).with(nil, &@config_block).and_return(nil)
+        Lego::Controller.environment(&@config_block)
+      end
+
+      it 'take an optional <env> argument' do
+        Lego::Controller::Config.should_receive(:environment).
+                                 with('development', &@config_block).
+                                 and_return(nil)
+
+        Lego::Controller.environment('development', &@config_block)
+      end
+
+      it 'should raise an ArgumentError if no block is provided' do
+        lambda { 
+          Lego::Controller.environment(:development) 
+        }.should raise_error(ArgumentError, "No block provided")
+      end
+    end
+
+    context 'on subclasses' do
+
+      before do
+        create_new_app "MyApp", Lego::Controller
+        @config_block = lambda {}
+      end
+
+      it 'should proxy the method call to its own config' do
+        MyApp::Config.should_receive(:environment).with(nil, &@config_block).and_return(nil)
+        MyApp.environment(&@config_block)
+      end
+
+      after do
+        rm_const "MyApp"
+      end
+    end
+  end
+end
+