skates 0.5.0 → 0.5.3

data/spec/lib/skates/generator_spec.rb

@@ -1,10 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe Skates::Generator::ApplicationGenerator do
-  # Hum, how do we spec Templater?
-end
-
-
-describe Skates::Generator::ControllerGenerator do
-  # Hum, how do we spec Templater?
-end

data/spec/lib/skates/router/dsl_spec.rb

@@ -1,46 +0,0 @@
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-describe Skates::Router::DSL do
-  before(:each) do
-    Skates.router = Skates::StanzaRouter.new
-    Skates.router.purge_routes!
-    class ControllerController; end
-  end
-
-  it "raises an exception if the route lacks a controller" do
-    lambda { Skates.router.draw do
-      xpath("/test").to(:action => "foo")
-    end }.should raise_error(/controller/)
-  end
-
-  it "raises an exception if the route lacks an action" do
-    lambda { Skates.router.draw do
-      xpath("/test").to(:controller => "foo")
-    end }.should raise_error(/action/)
-  end
-
-  it "raises an exception if the route has no destination" do
-    lambda { Skates.router.draw do
-      xpath("//test")
-    end }.should raise_error(/destination/)
-  end
-
-  it "creates a route with the specified xpath, controller, action and priority" do
-    Skates.router.draw do
-      xpath("//test"
-      ).to(:controller => "controller", :action => "action").priority(5)
-    end
-    routes = Skates.router.instance_variable_get("@routes")
-    routes.length.should == 1
-  end
-  
-  it "should create routes with the right namespace" do
-    Skates.router.draw do
-      xpath("//ns:test", {"ns" => "http://my.namespace.uri"}
-      ).to(:controller => "controller", :action => "action").priority(5)
-    end
-    route = Skates.router.instance_variable_get("@routes").first
-    route.xpath.should == ["//ns:test", {"ns"=>"http://my.namespace.uri"}]
-  end
-  
-end

data/spec/lib/skates/router_spec.rb

@@ -1,252 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe Skates::Route do
-  before(:each) do
-    @controller = "bar"
-    @action     = "bar"
-    @xpath     = "//message"
-    Kernel.stub!(:const_get).with("#{@controller.capitalize}Controller")
-  end
-
-  describe ".initialize" do
-    it "should raise an exception if no controller is specified" do
-      lambda { Skates::Route.new("action" => @action, "xpath" => @xpath) }.should raise_error(/controller/)
-    end
-    it "should raise an exception if no action is specified" do
-      lambda { Skates::Route.new("controller" => @controller, "xpath" => @xpath) }.should raise_error(/action/)
-    end
-    it "should raise an exception if no xpath is specified" do
-      lambda { Skates::Route.new("action" => @action, "controller" => @controller) }.should raise_error(/xpath/)
-    end
-  end
-
-  describe ".accepts?" do
-    it "should check the stanza with Xpath" do
-      mock_stanza = mock(Object)
-      route = Skates::Route.new("controller" => "bar", "action" => "bar", "xpath" => ["//message", {}])
-      mock_stanza.should_receive(:xpath).with("//message", {}).and_return([])
-      route.accepts?(mock_stanza)
-    end
-  end
-end
-
-
-describe Skates::StanzaRouter do 
-
-  before(:each) do
-    @router = Skates::StanzaRouter.new
-  end
-
-  describe "initialize" do
-    it "should have an empty array as routes" do
-      @router.routes.should == []
-    end
-  end
-
-  describe "connected" do
-    it "should set the connection" do
-      connection = mock(Object)
-      @router.connected(connection)
-      @router.connection.should == connection
-    end
-  end
-
-  describe "route" do
-    before(:each) do
-      @xml = mock(Nokogiri::XML::Node)
-      3.times do |t|
-        @router.routes << mock(Skates::Route, :accepts? => false)
-      end
-    end
-
-    context "when the before_route callback is defined" do
-      before(:each) do
-        @proc = Proc.new { |stanza|  
-        }
-        @router.before_route(&@proc)
-      end
-      
-      it "should call the callback" do
-        @proc.should_receive(:call).with(@xml)
-        @router.route(@xml)
-      end
-      
-      context "when the callback returns true" do
-        before(:each) do
-          @proc = Proc.new { |stanza| 
-            true 
-          }
-          @router.before_route(&@proc)
-        end
-        
-        it "should not even check if a route accepts this stanza" do
-          @router.routes.each do |r|
-            r.should_not_receive(:accepts?).with(@xml)
-          end
-          @router.route(@xml)
-        end
-      end
-      
-      context "when the callback returns false" do
-        before(:each) do
-          @proc = Proc.new { |stanza| 
-            false 
-          }
-          @router.before_route(&@proc)
-        end
-        
-        it "should check if a route accepts this stanza" do
-          @router.routes.each do |r|
-            r.should_receive(:accepts?).with(@xml)
-          end
-          @router.route(@xml)
-        end
-      end
-      
-      context "when the callback raises an error" do
-        before(:each) do
-          @proc = Proc.new { |stanza| 
-            raise 
-          }
-          @router.before_route(&@proc)
-        end
-        
-        it "should check if a route accepts this stanza" do
-          @router.routes.each do |r|
-            r.should_receive(:accepts?).with(@xml)
-          end
-          @router.route(@xml)
-        end
-      end
-      
-    end
-    
-    context "when the before_route callback is not defined" do
-      it "should check each routes to see if they match the stanza and take the first of the matching" do
-        @router.routes.each do |r|
-          r.should_receive(:accepts?).with(@xml)
-        end
-        @router.route(@xml)
-      end
-    
-      context "if one route is found" do 
-        before(:each) do
-          @accepting_route = mock(Skates::Route, :accepts? => true, :action => "action", :controller => "controller", :xpath => "xpath")
-          @router.routes << @accepting_route
-        end
-
-        it "should call execute_route" do
-          @router.should_receive(:execute_route).with(@accepting_route.controller, @accepting_route.action, @xml)
-          @router.route(@xml)
-        end
-      end
-
-      context "if no route matches the stanza" do
-        it "should return false" do
-          @router.route(@xml).should be_false
-        end
-      end
-    end
-  end
-
-  describe "execute_route" do
-    before(:each) do
-      @action = "action"
-      @controller = Skates::Base::Controller
-      @xml = mock(Nokogiri::XML::Node)
-      @mock_stanza = mock(Skates::Base::Stanza)
-      @mock_controller = mock(Skates::Base::Controller, {:new => true, :evaluate => "hello world"})
-      Kernel.stub!(:const_get).with(@action.capitalize).and_return(Skates::Base::Stanza) 
-      Skates::Base::Stanza.stub!(:new).with(@xml).and_return(@mock_stanza)
-      @connection = mock(Skates::XmppConnection, :send_xml => true)
-      @router.stub!(:connection).and_return(@connection)
-      @controller.stub!(:new).and_return(@mock_controller)
-      @mock_controller.stub!(:perform).with(@action)
-    end
-
-    describe "when the Stanza class exists" do
-      it "should instantiate the route's stanza " do
-        Kernel.should_receive(:const_get).with(@action.capitalize).and_return(Skates::Base::Stanza) 
-        Skates::Base::Stanza.should_receive(:new).with(@xml).and_return(@mock_stanza)
-        @router.execute_route(@controller, @action, @xml)
-      end
-      
-      it "should instantiate the route's controller" do
-        @controller.should_receive(:new).with(@mock_stanza).and_return(@mock_controller)
-        @router.execute_route(@controller, @action, @xml)
-      end
-    end
-    
-    describe "when the stanza class doesn't exist" do
-      it "should instantiate the route's controller with the xml" do
-        Kernel.should_receive(:const_get).with(@action.capitalize).and_raise(NameError) 
-        @controller.should_receive(:new).with(@xml).and_return(@mock_controller)
-        @router.execute_route(@controller, @action, @xml)
-      end
-    end
-
-    it "should call perform on the controller with the action's name" do
-      @mock_controller.should_receive(:perform).with(@action)
-      @router.execute_route(@controller, @action, @xml)
-    end
-    
-    it "should send the controller's response to the connection" do
-      @connection.should_receive(:send_xml).with(@mock_controller.evaluate)
-      @router.execute_route(@controller, @action, @xml)
-    end
-  end
-
-  describe "purge_routes!" do
-    it "should delete all routes" do
-      @router.instance_variable_set("@routes", [mock(Skates::Route), mock(Skates::Route)])
-      @router.purge_routes!
-      @router.routes.should == []
-    end
-  end
-  
-  describe "draw" do
-    before(:each) do
-      @dsl = Skates::Router::DSL.new 
-      Skates::Router::DSL.stub!(:new).and_return(@dsl) 
-      @routes = [mock(Skates::Route, :is_a? => true), mock(Skates::Route, :is_a? => true), mock(Skates::Route, :is_a? => true)]
-      @router.stub!(:sort)
-      @dsl.stub!(:routes).and_return(@routes)
-    end
-    
-    it "shoudl instantiate a new DSL" do
-      Skates::Router::DSL.should_receive(:new).and_return(@dsl) 
-      @router.draw {}
-    end
-    
-    it "should instance_eval the block" do
-      block = Proc.new {}
-      @dsl.should_receive(:instance_eval).with(&block)
-      @router.draw &block
-    end
-    
-    it "should check that each route is a Route" do
-      @dsl.should_receive(:routes).twice.and_return(@routes)
-      @router.draw {}
-    end
-    
-    it "should raise an error if one of the routes is not valid" do
-      @dsl.should_receive(:routes).and_return([mock(Skates::Route, :is_a? => false)])
-      lambda {
-        @router.draw {}
-      }.should raise_error()
-    end
-    
-    it "should assign the dsl routes as @routes" do
-      @dsl.should_receive(:routes).twice.and_return(@routes)
-      @router.draw {}
-      @router.routes.should == @routes
-    end
-    
-    it "should sort the routes" do
-      @router.should_receive(:sort)
-      @router.draw {}
-    end
-    
-  end
-
-end

data/spec/lib/skates/runner_spec.rb

@@ -1,233 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../em_mock'
-
-describe Skates::Runner do 
-  before(:all) do
-    FileUtils.chdir("#{FileUtils.pwd}/templates/skates")  unless ("#{FileUtils.pwd}" =~ /\/templates\/skates/ )
-  end
-  
-  describe ".prepare" do
-    before(:each) do
-      @config = {"production"=>{"port"=>5278, "auto-reconnect"=>true, "jid"=>"component.server.com", "host"=>"localhost", "password"=>"password"}, "development"=>{"auto-reconnect"=>true, "jid"=>"user@server.com", "application_type"=>"client", "password"=>"password"}, "test"=>{"port"=>5278, "auto-reconnect"=>true, "jid"=>"component.server.com", "host"=>"localhost", "password"=>"password"}}
-      Skates.config_file = "config/config.yaml"
-      YAML.stub(:load_file).and_return(@config)
-      Skates::Runner.stub!(:require_directory).and_return(true)
-    end
-
-    it "should add the environment log file as an outputter to skates's default log" do
-      Skates.should_receive(:reopen_logs)  
-      Skates::Runner.prepare("test")
-    end
-
-    it "should require all models" do
-      Skates::Runner.should_receive(:require_directory).with('app/models/*.rb').and_return(true)
-      Skates::Runner.prepare("test")
-    end
-
-    it "should require all stanzas" do
-      Skates::Runner.should_receive(:require_directory).with('app/stanzas/*.rb').and_return(true)
-      Skates::Runner.prepare("test")
-    end
-
-    it "should require all controllers" do
-      Skates::Runner.should_receive(:require_directory).with('app/controllers/*_controller.rb').and_return(true)
-      Skates::Runner.prepare("test")
-    end
-
-    it "should create a router" do
-      router = Skates::StanzaRouter.new
-      Skates::StanzaRouter.should_receive(:new).and_return(router)
-      Skates.should_receive(:router=).with(router) 
-      Skates::Runner.prepare("test")
-    end
-
-    it "should load the routes" do
-      Skates::Runner.should_receive(:require).with('config/routes.rb')
-      Skates::Runner.prepare("test")
-    end
-
-    it "should load the configuration file" do
-      YAML.should_receive(:load_file).with('config/config.yaml').and_return(@config)
-      Skates::Runner.prepare("test")
-    end
-
-    it "should assign the configuration" do
-      Skates::Runner.prepare("test")
-      Skates.config.should == {"port"=>5278, "jid"=>"component.server.com", "auto-reconnect"=>true, "host"=>"localhost", "password"=>"password"}
-    end
-
-    it "should cache the views" do
-      Skates.should_receive(:cache_views)
-      Skates::Runner.prepare("test")
-    end
-  end
-
-  describe "require_directory" do
-    before(:each) do
-      @dir = "/my/dir"
-      @files = ["hello.rb", "byebye.rb"]
-      Dir.stub!(:glob).with(@dir).and_return(@files)
-      @files.each do |f|
-        Skates::Runner.stub!(:require).with(f).and_return(true)
-      end
-    end
-    it "should list all files in the directory" do
-      Dir.should_receive(:glob).with(@dir).and_return(@files)
-      Skates::Runner.require_directory(@dir)
-    end
-    it "should require each of the files" do
-      @files.each do |f|
-        Skates::Runner.should_receive(:require).with(f).and_return(true)
-      end
-      Skates::Runner.require_directory(@dir)      
-    end
-  end
-
-  describe ".run" do
-    before(:each) do
-      Skates::ClientConnection.stub!(:connect).and_return(true)
-      Skates::ComponentConnection.stub!(:connect).and_return(true)
-      EventMachine.stub!(:run).and_yield
-    end
-
-    it "should set the environment" do
-      Skates::Runner.run("test")
-      Skates.environment.should == "test" 
-    end
-
-    it "should epoll the EventMachine" do
-      EventMachine.should_receive(:epoll)
-      Skates::Runner.run("test") 
-    end
-
-    it "should run the EventMachine" do
-      EventMachine.should_receive(:run)
-      Skates::Runner.run("test") 
-    end
-
-    it "should call prepare" do
-      Skates::Runner.should_receive(:prepare).with("test")
-      Skates::Runner.run("test") 
-    end
-
-    it "should connect the client connection if specified by the config" do
-      Skates.stub!(:config).and_return({"application_type" => "client"})
-      Skates::ClientConnection.should_receive(:connect).with(Skates.config, Skates::Runner)
-      Skates::Runner.run("test") 
-    end
-
-    it "should connect the component connection if no application_type specified by the config" do
-      Skates.stub!(:config).and_return({})
-      Skates::ComponentConnection.should_receive(:connect).with(Skates.config, Skates::Runner)
-      Skates::Runner.run("test") 
-    end
-
-  end
-
-  describe ".connection_observers" do
-    it "should return an array" do
-      Skates::Runner.connection_observers.should be_an_instance_of(Array)
-    end
-  end
-
-  describe ".add_connection_observer" do
-    before(:each) do
-      class MyController < Skates::Base::Controller; end
-    end
-
-    it "should not accept non-Skates::Base::Controller subclasses" do
-      Skates::Runner.add_connection_observer(Object).should be_false
-    end
-
-    it "should accept" do
-      Skates::Runner.add_connection_observer(MyController).should be_true
-    end
-
-    it "should add it to the list of observers" do
-      observers = Skates::Runner.connection_observers
-      Skates::Runner.add_connection_observer(MyController)
-      observers.include?(MyController).should be_true
-    end
-
-    it "should not add it twice" do
-      observers = Skates::Runner.connection_observers
-      Skates::Runner.add_connection_observer(MyController)
-      Skates::Runner.add_connection_observer(MyController)
-      observers.should == [MyController]
-    end
-
-  end
-
-  describe ".on_connected" do
-    before(:each) do
-      @connection = mock(Object)
-      Skates.router = Skates::StanzaRouter.new
-      Skates.router.stub!(:connected).with(@connection)
-      Skates.router.stub!(:execute_route).with(MyController, "on_connected")
-    end
-
-    it "should call connected on StanzaRouter" do
-      Skates.router.should_receive(:connected).with(@connection)
-      Skates::Runner.on_connected(@connection)
-    end
-
-    it "should call on_connected on the various observers and send the corresponding response" do
-      Skates::Runner.add_connection_observer(MyController)
-      Skates.router.should_receive(:execute_route).with(MyController, "on_connected")
-      Skates::Runner.on_connected(@connection)
-    end
-  end
-
-  describe ".on_disconnected" do
-    it "should call on_disconnected on the various observers" do
-      class MyObserver < Skates::Base::Controller; def on_disconnected; end; end
-      my_observer = MyObserver.new
-      Skates::Runner.add_connection_observer(MyObserver)
-      MyObserver.should_receive(:new).and_return(my_observer)
-      my_observer.should_receive(:on_disconnected)
-      Skates::Runner.on_disconnected
-    end
-    
-    context "when the application should auto-reconnect" do
-      before(:each) do
-        Skates.config["auto-reconnect"] = true
-        EventMachine.stub!(:reactor_running?).and_return(false)
-        EventMachine.stub!(:add_timer).and_yield()
-        @delay = 15
-        Skates::Runner.stub!(:fib).and_return(@delay)
-      end
-      
-      it "should determine when is the best time to reconnect with fibonacci" do
-        Skates::Runner.should_receive(:fib).and_return(@delay)
-        Skates::Runner.on_disconnected()
-      end
-      
-      it "should try to reconnect at the determined time" do
-        EventMachine.stub!(:reactor_running?).and_return(true)
-        Skates::Runner.should_receive(:reconnect)
-        EventMachine.should_receive(:add_timer).with(@delay).and_yield()
-        Skates::Runner.on_disconnected()
-      end
-    end
-    
-    context "when the application should not auto-reconnect" do
-      before(:each) do
-        Skates.config["auto-reconnect"] = false
-      end
-      
-      it "should stop the event loop" do
-        connection = mock(Object)
-        EventMachine.should_receive(:stop_event_loop)
-        Skates::Runner.on_disconnected()
-      end
-    end
-  end
-
-  describe ".on_stanza" do
-    it "should call route on StanzaRouter" do
-      stanza = mock(Object)
-      Skates.router.should_receive(:route).with(stanza)
-      Skates::Runner.on_stanza(stanza)
-    end
-  end
-end