mohiam-babylon 0.1.7

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

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Babylon::Router::DSL do
+  before(:each) do
+    Babylon.router = Babylon::StanzaRouter.new
+    Babylon.router.purge_routes!
+    class ControllerController; end
+  end
+
+  it "raises an exception if the route lacks a controller" do
+    lambda { Babylon.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 { Babylon.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 { Babylon.router.draw do
+      xpath("//test")
+    end }.should raise_error(/destination/)
+  end
+
+  it "creates a route with the specified xpath, controller and action" do
+    Babylon.router.draw do
+      xpath("//test"
+      ).to(:controller => "controller", :action => "action")
+    end
+    routes = Babylon.router.instance_variable_get("@routes")
+    routes.length.should == 1
+  end
+  
+  describe :disco_info do
+    it "matches the root disco#info namespace" do
+      Babylon.router.draw do
+        disco_info.to(:controller => "controller", :action => "action")
+      end
+      route = Babylon.router.instance_variable_get("@routes").last
+      route.xpath.should == "//iq[@type='get']/*[namespace(., 'query', 'http://jabber.org/protocol/disco#info')]"
+    end
+
+    it "matches the disco#info namespace for the specified node" do
+      Babylon.router.draw do
+        disco_info("test").to(:controller => "controller", :action => "action")
+      end
+      route = Babylon.router.instance_variable_get("@routes").last
+      route.xpath.should == "//iq[@type='get']/*[namespace(., 'query', 'http://jabber.org/protocol/disco#info') and @node = 'test']"
+    end
+  end
+
+  describe :disco_items do
+    it "matches the root disco#items namespace" do
+      Babylon.router.draw do
+        disco_items.to(:controller => "controller", :action => "action")
+      end
+      route = Babylon.router.instance_variable_get("@routes").last
+      route.xpath.should == "//iq[@type='get']/*[namespace(., 'query', 'http://jabber.org/protocol/disco#items')]"
+    end
+
+    it "matches the disco#items namespace for the specified node" do
+      Babylon.router.draw do
+        disco_items("test").to(:controller => "controller", :action => "action")
+      end
+      route = Babylon.router.instance_variable_get("@routes").last
+      route.xpath.should == "//iq[@type='get']/*[namespace(., 'query', 'http://jabber.org/protocol/disco#items') and @node = 'test']"
+    end
+  end
+end

data/spec/lib/babylon/router_spec.rb

@@ -0,0 +1,189 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Babylon::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 { Babylon::Route.new("action" => @action, "xpath" => @xpath) }.should raise_error(/controller/)
+    end
+    it "should raise an exception if no action is specified" do
+      lambda { Babylon::Route.new("controller" => @controller, "xpath" => @xpath) }.should raise_error(/action/)
+    end
+    it "should raise an exception if no xpath is specified" do
+      lambda { Babylon::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 = Babylon::Route.new("controller" => "bar", "action" => "bar", "xpath" => "//message")
+      mock_stanza.should_receive(:xpath).with(route.xpath, instance_of(Babylon::XpathHelper)).and_return([])
+      route.accepts?(mock_stanza)
+    end
+  end
+end
+
+
+describe Babylon::StanzaRouter do 
+
+  before(:each) do
+    @router = Babylon::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(Babylon::Route, :accepts? => false)
+      end
+    end
+
+    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
+
+    describe "if one route is found" do 
+      before(:each) do
+        @accepting_route = mock(Babylon::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
+
+    describe "if no route matches the stanza" do
+      it "should return false" do
+        @router.route(@xml).should be_false
+      end
+    end
+
+  end
+
+  describe "execute_route" do
+    before(:each) do
+      @action = "action"
+      @controller = Babylon::Base::Controller
+      @xml = mock(Nokogiri::XML::Node)
+      @mock_stanza = mock(Babylon::Base::Stanza)
+      @mock_controller = mock(Babylon::Base::Controller, {:new => true, :evaluate => "hello world"})
+      Kernel.stub!(:const_get).with(@action.capitalize).and_return(Babylon::Base::Stanza) 
+      Babylon::Base::Stanza.stub!(:new).with(@xml).and_return(@mock_stanza)
+      @connection = mock(Babylon::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(Babylon::Base::Stanza) 
+        Babylon::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(Babylon::Route), mock(Babylon::Route)])
+      @router.purge_routes!
+      @router.routes.should == []
+    end
+  end
+  
+  describe "draw" do
+    before(:each) do
+      @dsl = Babylon::Router::DSL.new 
+      Babylon::Router::DSL.stub!(:new).and_return(@dsl) 
+      @routes = [mock(Babylon::Route, :is_a? => true), mock(Babylon::Route, :is_a? => true), mock(Babylon::Route, :is_a? => true)]
+      @router.stub!(:sort)
+      @dsl.stub!(:routes).and_return(@routes)
+    end
+    
+    it "shoudl instantiate a new DSL" do
+      Babylon::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(Babylon::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/babylon/runner_spec.rb

@@ -0,0 +1,213 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../../em_mock'
+
+describe Babylon::Runner do 
+
+  before(:all) do
+    FileUtils.chdir("#{FileUtils.pwd}/templates/babylon")  unless ("#{FileUtils.pwd}" =~ /\/templates\/babylon/ )
+  end
+
+  describe ".prepare" do
+
+    before(:each) do
+      @stub_config_file = File.open("config/config.yaml")
+      @stub_config_content = File.read("config/config.yaml")
+      File.stub!(:open).with('config/config.yaml').and_return(@stub_config_file)
+      Babylon::Runner.stub!(:require_directory).and_return(true)
+    end
+
+    it "should add the environment log file as an outputter to babylon's default log" do
+      @logger = Log4r::RollingFileOutputter.new("#{Babylon.environment}", :filename => "log/#{Babylon.environment}.log", :trunc => false)
+      Log4r::RollingFileOutputter.should_receive(:new).with("test", :filename => "log/test.log", :trunc => false).and_return(@logger)
+      Babylon.logger.should_receive(:add).with(@logger)
+      Babylon::Runner.prepare("test")
+    end
+
+    it "should require all models" do
+      Babylon::Runner.should_receive(:require_directory).with('app/models/*.rb').and_return(true)
+      Babylon::Runner.prepare("test")
+    end
+
+    it "should require all stanzas" do
+      Babylon::Runner.should_receive(:require_directory).with('app/stanzas/*.rb').and_return(true)
+      Babylon::Runner.prepare("test")
+    end
+
+    it "should require all controllers" do
+      Babylon::Runner.should_receive(:require_directory).with('app/controllers/*_controller.rb').and_return(true)
+      Babylon::Runner.prepare("test")
+    end
+
+    it "should create a router" do
+      router = Babylon::StanzaRouter.new
+      Babylon::StanzaRouter.should_receive(:new).and_return(router)
+      Babylon.should_receive(:router=).with(router) 
+      Babylon::Runner.prepare("test")
+    end
+
+    it "should load the routes" do
+      Babylon::Runner.should_receive(:require).with('config/routes.rb')
+      Babylon::Runner.prepare("test")
+    end
+
+    it "should load the configuration file" do
+      File.should_receive(:open).with('config/config.yaml').and_return(@stub_config_file)
+      Babylon::Runner.prepare("test")
+    end
+
+    it "should assign the configuration" do
+      Babylon::Runner.prepare("test")
+      Babylon.config.should == YAML.load(@stub_config_content)["test"]
+    end
+
+    it "should cache the views" do
+      Babylon.should_receive(:cache_views)
+      Babylon::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|
+        Babylon::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)
+      Babylon::Runner.require_directory(@dir)
+    end
+    it "should require each of the files" do
+      @files.each do |f|
+        Babylon::Runner.should_receive(:require).with(f).and_return(true)
+      end
+      Babylon::Runner.require_directory(@dir)      
+    end
+  end
+
+  describe ".run" do
+
+    before(:each) do
+      Babylon::ClientConnection.stub!(:connect).and_return(true)
+      Babylon::ComponentConnection.stub!(:connect).and_return(true)
+      EventMachine.stub!(:run).and_yield
+    end
+
+    it "should set the environment" do
+      Babylon::Runner.run("test")
+      Babylon.environment.should == "test" 
+    end
+
+    it "should epoll the EventMachine" do
+      EventMachine.should_receive(:epoll)
+      Babylon::Runner.run("test") 
+    end
+
+    it "should run the EventMachine" do
+      EventMachine.should_receive(:run)
+      Babylon::Runner.run("test") 
+    end
+
+    it "should call prepare" do
+      Babylon::Runner.should_receive(:prepare).with("test")
+      Babylon::Runner.run("test") 
+    end
+
+    it "should connect the client connection if specified by the config" do
+      Babylon.stub!(:config).and_return({"application_type" => "client"})
+      Babylon::ClientConnection.should_receive(:connect).with(Babylon.config, Babylon::Runner)
+      Babylon::Runner.run("test") 
+    end
+
+    it "should connect the component connection if no application_type specified by the config" do
+      Babylon.stub!(:config).and_return({})
+      Babylon::ComponentConnection.should_receive(:connect).with(Babylon.config, Babylon::Runner)
+      Babylon::Runner.run("test") 
+    end
+
+  end
+
+  describe ".connection_observers" do
+    it "should return an array" do
+      Babylon::Runner.connection_observers.should be_an_instance_of(Array)
+    end
+  end
+
+  describe ".add_connection_observer" do
+    before(:each) do
+      class MyController < Babylon::Base::Controller; end
+    end
+
+    it "should not accept non-Babylon::Base::Controller subclasses" do
+      Babylon::Runner.add_connection_observer(Object).should be_false
+    end
+
+    it "should accept" do
+      Babylon::Runner.add_connection_observer(MyController).should be_true
+    end
+
+    it "should add it to the list of observers" do
+      observers = Babylon::Runner.connection_observers
+      Babylon::Runner.add_connection_observer(MyController)
+      observers.include?(MyController).should be_true
+    end
+
+    it "should not add it twice" do
+      observers = Babylon::Runner.connection_observers
+      Babylon::Runner.add_connection_observer(MyController)
+      Babylon::Runner.add_connection_observer(MyController)
+      observers.should == [MyController]
+    end
+
+  end
+
+  describe ".on_connected" do
+    before(:each) do
+      @connection = mock(Object)
+      Babylon.router = Babylon::StanzaRouter.new
+      Babylon.router.stub!(:connected).with(@connection)
+      Babylon.router.stub!(:execute_route).with(MyController, "on_connected")
+    end
+
+    it "should call connected on StanzaRouter" do
+      Babylon.router.should_receive(:connected).with(@connection)
+      Babylon::Runner.on_connected(@connection)
+    end
+
+    it "should call on_connected on the various observers and send the corresponding response" do
+      Babylon::Runner.add_connection_observer(MyController)
+      Babylon.router.should_receive(:execute_route).with(MyController, "on_connected")
+      Babylon::Runner.on_connected(@connection)
+    end
+  end
+
+  describe ".on_disconnected" do
+    it "should stop the event loop" do
+      connection = mock(Object)
+      EventMachine.should_receive(:stop_event_loop)
+      Babylon::Runner.on_disconnected()
+    end
+
+    it "should call on_disconnected on the various observers" do
+      class MyObserver < Babylon::Base::Controller
+        def on_disconnected
+        end
+      end
+      my_observer = MyObserver.new
+      Babylon::Runner.add_connection_observer(MyObserver)
+      MyObserver.should_receive(:new).and_return(my_observer)
+      my_observer.should_receive(:on_disconnected)
+      Babylon::Runner.on_disconnected
+    end
+  end
+
+  describe ".on_stanza" do
+    it "should call route on StanzaRouter" do
+      stanza = mock(Object)
+      Babylon.router.should_receive(:route).with(stanza)
+      Babylon::Runner.on_stanza(stanza)
+    end
+  end
+end