radamanthus-skates 0.3.5

data/spec/lib/skates/runner_spec.rb

@@ -0,0 +1,233 @@
+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

data/spec/lib/skates/xmpp_connection_spec.rb

@@ -0,0 +1,222 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../../em_mock'
+
+describe Skates::XmppConnection do
+  
+  include SkatesSpecHelper
+  
+  before(:each) do
+    @params = {"jid" => "jid@server", "password" => "password", "port" => 1234, "host" => "myhost.com"}
+    @connection = Skates::XmppConnection._connect(@params, handler_mock)
+  end
+  
+  describe "_connect" do    
+    it "should connect EventMachine and return it" do
+      EventMachine.should_receive(:connect).with(@params["host"], @params["port"], Skates::XmppConnection, hash_including("handler" => handler_mock)).and_return(@connection)
+      Skates::XmppConnection._connect(@params, handler_mock).should == @connection
+    end
+    
+    it "should rescue Connection Errors" do
+      EventMachine.stub!(:connect).with(@params["host"], @params["port"], Skates::XmppConnection, hash_including("handler" => handler_mock)).and_raise(RuntimeError)
+      lambda {
+        Skates::XmppConnection._connect(@params, handler_mock)
+      }.should raise_error(Skates::NotConnected)
+    end
+
+  end
+  
+  describe "connect" do
+    describe "connect" do
+      it "should not try to resolve the dns if a host IP has been provided" do
+        @params["host"] = "123.123.123.123"
+        Skates::XmppConnection.should_not_receive(:resolve)
+        Skates::XmppConnection.connect(@params, handler_mock) 
+      end
+
+      describe "when a host is provided, which is not an IP" do
+        it "should resolve it" do
+          @params["host"] = "domain.tld"
+          Skates::XmppConnection.should_receive(:resolve)
+          Skates::XmppConnection.connect(@params, handler_mock) 
+        end
+      end
+
+      describe "when no host is provided, and no port either" do
+        it "should resolve the host to an IP" do
+          Skates::XmppConnection.should_receive(:resolve)
+          Skates::XmppConnection.connect(@params, handler_mock) 
+        end
+      end
+    end
+  end
+  
+  describe "initialize" do
+    it "should assign @connected to false" do
+      @connection.instance_variable_get("@connected").should be_false
+    end
+    
+    it "should assign @jid to params['jid']" do
+      @connection.instance_variable_get("@jid").should == @params["jid"]
+    end
+    
+    it "should assign @password to params['password']" do
+      @connection.instance_variable_get("@password").should == @params["password"]
+    end
+    
+    it "should assign @host to params['host']" do
+      @connection.instance_variable_get("@host").should == @params["host"]
+    end
+    
+    it "should assign @port to params['port']" do
+      @connection.instance_variable_get("@port").should == @params["port"]
+    end
+    
+    it "should assign @handler to params['handler']" do
+      @connection.instance_variable_get("@handler").should == handler_mock
+    end
+    
+    it "should assign @buffer to ''" do
+      @connection.instance_variable_get("@buffer").should == ""
+    end
+  end
+  
+  describe "post_init" do
+    it "assigne a new parser" do
+      parser = Skates::XmppParser.new(@connection.method(:receive_stanza))
+      Skates::XmppParser.should_receive(:new).and_return(parser)
+      @connection.post_init
+      @connection.instance_variable_get("@parser").should == parser
+    end
+  end
+  
+  describe "connection_completed" do
+    it "should set @connected to true" do
+      @connection.connection_completed
+      @connection.instance_variable_get("@connected").should be_true
+    end
+  end
+  
+  describe "unbind" do
+    it "should set @connected to false" do
+      @connection.connection_completed
+      @connection.unbind
+      @connection.instance_variable_get("@connected").should be_false
+    end
+  end
+  
+  describe "receive_stanza" do
+    
+    before(:each) do
+      @doc = Nokogiri::XML::Document.new
+    end
+    
+    describe "with an stanza that starts with stream:error" do
+      
+      before(:each) do
+        @error_stanza = Nokogiri::XML::Node.new("stream:error", @doc)
+      end
+      
+      it "should close the connection" do
+        @connection.should_receive(:close_connection)
+        @connection.receive_stanza(@error_stanza)
+      end
+      
+      describe "with a malformed stanza error" do
+         before(:each) do
+           @xml_not_well_formed_stanza = Nokogiri::XML::Node.new("xml-not-well-formed", @doc)
+           @xml_not_well_formed_stanza.add_namespace("xmlns", "urn:ietf:params:xml:ns:xmpp-streams")
+           @error_stanza.add_child(@xml_not_well_formed_stanza)
+         end
+      
+      end
+    end
+    
+    describe "with a stanza that is not an error" do
+      it "should call the on_stanza block" do
+        stanza = Nokogiri::XML::Node.new("message", @doc)
+        handler_mock.should_receive(:on_stanza)
+        @connection.receive_stanza(stanza)
+      end
+    end
+    
+  end
+  
+  describe "send_chunk" do
+    it "should raise an error if not connected" do
+      @connection.instance_variable_set("@connected", false)
+      lambda {
+        @connection.__send__(:send_chunk, "hello world")
+      }.should raise_error(Skates::NotConnected)
+    end
+    
+    it "should raise an error if the stanza size is above the limit" do
+      @connection.instance_variable_set("@connected", true)
+      string = "a" * (Skates::XmppConnection.max_stanza_size + 1)
+      lambda {
+        @connection.__send__(:send_chunk, string)
+      }.should raise_error(Skates::StanzaTooBig)
+    end
+    
+    it "should return if the string is blank" do
+      @connection.instance_variable_set("@connected", true)
+      @connection.should_not_receive(:send_data)
+      @connection.__send__(:send_chunk, "")
+    end
+    
+    it "should cann send_data with the string" do
+      @connection.instance_variable_set("@connected", true)
+      string = "hello world"
+      @connection.should_receive(:send_data).with(string)
+      @connection.__send__(:send_chunk, string)    
+    end
+    
+  end
+  
+  describe "send_xml" do
+    
+    before(:each) do
+      @connection.instance_variable_set("@connected", true)
+      @connection.stub!(:send_chunk).and_return(true)
+      @doc = Nokogiri::XML::Document.new
+    end
+    
+    describe "with a nodeset as argument" do
+      before(:each) do
+        iq = Nokogiri::XML::Node.new("iq", @doc)
+        message = Nokogiri::XML::Node.new("message", @doc)
+        presence = Nokogiri::XML::Node.new("presence", @doc)
+        @node_set = Nokogiri::XML::NodeSet.new(@doc, [message, presence, iq])
+      end
+      
+      it "should call send_chunk for each of the nodes in the set" do
+        @node_set.each do |node|
+          @connection.should_receive(:send_chunk).with(node.to_s)
+        end
+        @connection.send_xml(@node_set)
+      end
+    end
+    
+    describe "with an argument with is not a NodeSet" do
+      before(:each) do
+        @message = Nokogiri::XML::Node.new("message", @doc)
+      end
+      it "should call send_chunk for the node" do
+        @connection.should_receive(:send_chunk).with(@message.to_s)
+        @connection.send_xml(@message)
+      end
+    end
+  end
+  
+  describe "receive_data" do
+    before(:each) do
+      @connection.instance_variable_get("@parser").stub!(:push).and_return(true)
+    end
+    
+    it "should push the received data to the parser" do
+      data = "<hello>hello world!</hello>"
+      @connection.instance_variable_get("@parser").should_receive(:push).with(data).and_return(true)
+      @connection.__send__(:receive_data, data)
+    end
+  end
+  
+end