julien51-babylon 0.1.0 → 0.1.2

data/spec/lib/babylon/xmpp_connection_spec.rb

@@ -0,0 +1,222 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../../em_mock'
+
+describe Babylon::XmppConnection do
+  
+  include BabylonSpecHelper
+  
+  before(:each) do
+    @params = {"jid" => "jid@server", "password" => "password", "port" => 1234, "host" => "myhost.com"}
+    @connection = Babylon::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"], Babylon::XmppConnection, hash_including("handler" => handler_mock)).and_return(@connection)
+      Babylon::XmppConnection.connect(@params, handler_mock).should == @connection
+    end
+    
+    it "should rescue Connection Errors" do
+      EventMachine.stub!(:connect).with(@params["host"], @params["port"], Babylon::XmppConnection, hash_including("handler" => handler_mock)).and_raise(RuntimeError)
+      lambda {
+        Babylon::XmppConnection.connect(@params, handler_mock)
+      }.should raise_error(Babylon::NotConnected)
+    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 = Babylon::XmppParser.new(@connection.method(:receive_stanza))
+      Babylon::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 write a log message" do
+      Babylon.logger.should_receive(:debug).with("CONNECTED")
+      @connection.connection_completed
+    end
+    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 write a log message, and call on_disconnected" do
+      Babylon.logger.should_receive(:debug).with("DISCONNECTED")
+      handler_mock.should_receive(:on_disconnected)
+      @connection.unbind
+    end
+    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
+    
+    it "should write a log message for debug" do
+      Babylon.logger.should_receive(:debug).with(/PARSED/)
+      @connection.receive_stanza(Nokogiri::XML::Node.new("node", @doc))
+    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
+      
+        it "should write an error to the log and raise an error" do
+          Babylon.logger.should_receive(:error).with(/DISCONNECTED DUE TO MALFORMED STANZA/)
+          lambda {@connection.receive_stanza(@error_stanza)}.should raise_error(Babylon::XmlNotWellFormed)
+        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(Babylon::NotConnected)
+    end
+    
+    it "should raise an error if the stanza size is above the limit" do
+      @connection.instance_variable_set("@connected", true)
+      string = "a" * (Babylon::XmppConnection.max_stanza_size + 1)
+      lambda {
+        @connection.__send__(:send_chunk, string)
+      }.should raise_error(Babylon::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 show a message on the log" do
+      data = "<hello>hello world!</hello>"
+      Babylon.logger.should_receive(:debug).with("RECEIVED : #{data}")
+      @connection.__send__(:receive_data, data)
+    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

data/spec/lib/babylon/xmpp_parser_spec.rb

@@ -0,0 +1,268 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Babylon::XmppParser do
+
+  before(:each) do
+    @last_stanza = ""
+    @proc = mock(Proc, :call => true)
+    @parser = Babylon::XmppParser.new(@proc)
+  end
+
+  describe ".reset" do
+    it "should reset the document to nil" do
+      @parser.reset
+      @parser.elem.should be_nil
+    end
+
+    it "should reset the element to nil (no element is being parsed)" do
+      @parser.reset
+      @parser.elem.should be_nil
+    end
+    
+    it "should reset the parser to a parser" do
+      new_parser = Nokogiri::XML::SAX::PushParser.new(@parser, "UTF-8")
+      Nokogiri::XML::SAX::PushParser.should_receive(:new).with(@parser, "UTF-8").and_return(new_parser)
+      @parser.reset
+      @parser.parser.should == new_parser
+    end
+  end
+  
+  describe ".push" do
+    it "should send the data to the parser" do
+      data = "<name>me</name>"
+      @parser.parser.should_receive(:<<).with(data)
+      @parser.push(data)
+    end
+  end
+  
+  describe ".characters" do
+    before(:each) do 
+      @parser.doc = Nokogiri::XML::Document.new
+      @parser.elem = Nokogiri::XML::Element.new("element", @parser.doc)
+    end
+    
+    it "should add the characters to the buffer" do
+      chars = "hello my name is julien"
+      @parser.characters(chars)
+      @parser.instance_variable_get("@buffer").should == chars
+    end
+    
+    it "should concatenate the text if we receive in both pieces" do
+      chars = "hello my name is julien"
+      @parser.characters(chars)
+      @parser.instance_variable_get("@buffer").should == chars
+      chars2 = "and I'm french!"
+      @parser.characters(chars2)
+      @parser.instance_variable_get("@buffer").should == chars + chars2
+    end
+  end
+  
+  describe ".start_element" do
+    
+    before(:each) do
+      @new_elem_name = "new"
+      @new_elem_attributes = ["to", "you@yourserver.com/home", "xmlns", "http://ns.com"]
+    end
+    
+    it "should create a new doc if we don't have one" do
+      new_doc = Nokogiri::XML::Document.new
+      @parser.doc = nil
+      Nokogiri::XML::Document.should_receive(:new).and_return(new_doc)
+      @parser.start_element(@new_elem_name, @new_elem_attributes)
+      @parser.doc.should == new_doc
+    end
+    
+    it "should not create a new doc we already have one" do
+      @parser.doc = Nokogiri::XML::Document.new
+      Nokogiri::XML::Document.should_not_receive(:new)
+      @parser.start_element(@new_elem_name, @new_elem_attributes)
+    end
+    
+    it "should create a new element" do
+      @doc = Nokogiri::XML::Document.new
+      @parser.doc = @doc
+      @new_elem = Nokogiri::XML::Element.new(@new_elem_name, @parser.doc)
+      Nokogiri::XML::Element.should_receive(:new).and_return(@new_elem)
+      @parser.start_element(@new_elem_name, @new_elem_attributes)
+    end
+    
+    it "should add the new element as a child to the current element if there is one" do
+      @doc = Nokogiri::XML::Document.new
+      @parser.doc = @doc
+      @current = Nokogiri::XML::Element.new("element", @parser.doc)
+      @parser.elem = @current
+      @new_elem = Nokogiri::XML::Element.new(@new_elem_name, @parser.doc)
+      Nokogiri::XML::Element.stub!(:new).and_return(@new_elem)
+      @parser.start_element(@new_elem_name, @new_elem_attributes)
+      @new_elem.parent.should == @current
+    end
+    
+    it "should add the new element as the child of the doc if there is none" do
+      @doc = Nokogiri::XML::Document.new
+      @parser.doc = @doc
+      @new_elem = Nokogiri::XML::Element.new(@new_elem_name, @parser.doc)
+      Nokogiri::XML::Element.stub!(:new).and_return(@new_elem)
+      @parser.start_element(@new_elem_name, @new_elem_attributes)
+      @new_elem.parent.should == @doc      
+    end
+    
+    it "should add the right attributes and namespaces to the newly created element" do
+      @parser.start_element(@new_elem_name, @new_elem_attributes)
+      @parser.elem["to"].should == "you@yourserver.com/home"
+      # TODO : FIX NAMESPACES : @parser.elem.namespaces.should == {"xmlns"=>"http://ns.com"}
+      @parser.elem.namespaces.should == {}
+    end
+    
+    describe "when the new element is of name stream:stream" do
+      it "should callback" do
+        @proc.should_receive(:call)
+        @parser.start_element("stream:stream", [])
+      end
+      
+      it "should reinit to nil the doc and the elem" do
+        @parser.start_element("stream:stream", [])
+        @parser.doc.should == nil
+        @parser.elem.should == nil
+      end
+    end
+  end
+
+  describe ".end_element" do
+    before(:each) do
+      @doc = Nokogiri::XML::Document.new
+      @parser.doc = @doc
+      @current = Nokogiri::XML::Element.new("element", @parser.doc)
+      @parser.elem = @current
+    end
+    
+    it "should add the content of the buffer to the @elem" do
+      @elem = Nokogiri::XML::Element.new("element", @parser.doc)
+      chars = "hello world"
+      @parser.instance_variable_set("@buffer", chars)
+      @parser.elem = @elem
+      @parser.end_element("element")
+      @elem.content.should == chars
+    end
+    
+    describe "when we're finishing the doc's root" do
+      before(:each) do
+        @parser.doc.root = @current
+      end
+      
+      it "should callback" do
+        @proc.should_receive(:call)
+        @parser.end_element("element")
+      end
+      
+      it "should reinit to nil the doc and the elem" do
+        @parser.end_element("element")
+        @parser.doc.should == nil
+        @parser.elem.should == nil
+      end
+    end
+    
+    describe "when we're finishing another element" do
+      before(:each) do
+        @parser.doc.root = Nokogiri::XML::Element.new("root", @parser.doc)
+        @current.parent = @parser.doc.root
+      end
+      
+      it "should go back up one level" do
+        @parser.end_element("element")
+        @parser.elem = @current.parent
+      end
+    end
+  end
+  
+  describe ".add_namespaces_and_attributes_to_node" do
+    before(:each) do
+      @doc = Nokogiri::XML::Document.new
+      @parser.doc = @doc
+      @element = Nokogiri::XML::Element.new("element", @parser.doc)
+      @attrs = ["from", "me", "xmlns:atom", "http://www.w3.org/2005/Atom" ,"to", "you", "xmlns", "http://namespace.com"]
+      @parser.elem = @element
+    end
+    
+    it "should assign even elements to attributes value or namespaces urls" do
+      @parser.__send__(:add_namespaces_and_attributes_to_current_node, @attrs)
+      even = []
+      @attrs.size.times do |i|
+        even << @attrs[i*2]
+      end
+      even.compact!
+      @element.attributes.keys.each do |k|
+        even.should include(k)
+      end
+    end
+    
+    it "should assign odd elements to attributes names of namespaces prefixes" do
+      @parser.__send__(:add_namespaces_and_attributes_to_current_node, @attrs)
+      even = []
+      @attrs.size.times do |i|
+        even << @attrs[i*2+1]
+      end
+      even.compact!
+      @element.attributes.values.each do |v|
+        even.should include("#{v}")
+      end
+    end
+    
+    it "should add namespace for each attribute name that starts with xmlns" do
+      @parser.__send__(:add_namespaces_and_attributes_to_current_node, @attrs)
+      # TODO: FIX NAMESPACES @element.namespaces.values.should == ["http://www.w3.org/2005/Atom", "http://namespace.com"]
+      @element.namespaces.values.should == []
+    end
+  end
+  
+  describe "a communication with an XMPP Client" do
+    
+    before(:each) do
+      @stanzas = []
+      @proc = Proc.new { |stanza|
+        @stanzas << stanza 
+      }
+      @parser = Babylon::XmppParser.new(@proc)
+    end
+      
+    it "should parse the right information" do
+      string = "<stream:stream
+          xmlns:stream='http://etherx.jabber.org/streams'
+          xmlns='jabber:component:accept'
+          from='plays.shakespeare.lit'
+          id='3BF96D32'>
+          <handshake/>    
+          <message from='juliet@example.com'
+                        to='romeo@example.net'
+                        xml:lang='en'>
+          <body>Art thou not Romeo, and a Montague?</body>
+          <link href='http://sfbay.craigslist.org/search/sss?query=%2522mac+mini%2522+Intel+Core+Duo&amp;minAsk=min&amp;maxAsk=max&amp;format=rss&amp;format=rss' />
+        </message>"
+      pieces = rand(string.size/30)
+      # So we have to pick 'pieces' number between 0 and string.size
+      indices = []
+      pieces.times do |i|
+        indices[i] = rand(string.size)
+      end
+      # Now let's sort indices
+      indices.sort!
+      substrings = []
+      prev_index = 0
+      indices.each do |index|
+        substrings << string[prev_index, (index-prev_index)]
+        prev_index = index
+      end
+      substrings << string[prev_index, string.size]
+      #Just to make sure we split the string the right way!
+      substrings.join("").should == string
+      
+      substrings.each do |s|
+        @parser.push(s)
+      end
+      
+      @stanzas.join("").should == "<stream:stream xmlns:stream=\"http://etherx.jabber.org/streams\" xmlns=\"jabber:component:accept\" from=\"plays.shakespeare.lit\" id=\"3BF96D32\"/><handshake/><message from=\"juliet@example.com\" to=\"romeo@example.net\" xml:lang=\"en\">\n  <body>Art thou not Romeo, and a Montague?</body>\n  <link href=\"http://sfbay.craigslist.org/search/sss?query=%2522mac+mini%2522+Intel+Core+Duo&amp;minAsk=min&amp;maxAsk=max&amp;format=rss&amp;format=rss\"/>\n</message>"
+      @stanzas.last.at("link")["href"].should == "http://sfbay.craigslist.org/search/sss?query=%2522mac+mini%2522+Intel+Core+Duo&minAsk=min&maxAsk=max&format=rss&format=rss"
+    end
+    
+  end
+  
+end