radamanthus-skates 0.3.5

data/spec/lib/skates/base/stanza_spec.rb

@@ -0,0 +1,120 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Skates::Base::Stanza do
+
+  describe "initialize" do
+
+    context "when the stanza is an IQ" do
+
+      before(:each) do
+        xml = <<-EOXML 
+        <iq type='get'
+        from='romeo@montague.net/orchard'
+        to='plays.shakespeare.lit'
+        id='info1'>
+        <query xmlns='http://jabber.org/protocol/disco#configuration'/>
+        </iq>
+        EOXML
+        xml = Nokogiri::XML(xml)
+        @stanza = Skates::Base::Stanza.new(xml.root)
+      end
+
+      it "should have the right from" do
+        @stanza.from.should == "romeo@montague.net/orchard"
+      end
+
+      it "should have the right id" do
+        @stanza.id.should == "info1"
+      end
+
+      it "should have the right to" do
+        @stanza.to.should == "plays.shakespeare.lit"
+      end
+
+      it "should have the right type" do
+        @stanza.type.should == "get"
+      end
+
+      it "should have the right name" do
+        @stanza.name.should == "iq"
+      end
+      
+    end
+    
+    
+    
+    context "when the stanza is a presence" do
+
+      before(:each) do
+        xml = <<-EOXML 
+        <presence from='firehoser-test.superfeedr.com' to='testparsr@superfeedr.com/skates_client_7008465' type='error' />
+        EOXML
+        xml = Nokogiri::XML(xml)
+        @stanza = Skates::Base::Stanza.new(xml.root)
+      end
+
+      it "should have the right from" do
+        @stanza.from.should == "firehoser-test.superfeedr.com"
+      end
+
+      it "should have the right id" do
+        @stanza.id.should be_nil
+      end
+
+      it "should have the right to" do
+        @stanza.to.should == "testparsr@superfeedr.com/skates_client_7008465"
+      end
+
+      it "should have the right type" do
+        @stanza.type.should == "error"
+      end
+
+      it "should have the right name" do
+        @stanza.name.should == "presence"
+      end
+      
+    end
+    
+    context "when the stanza is a message" do
+
+      before(:each) do
+        xml = <<-EOXML 
+        <message to="monitor@superfeedr.com" from="test-firehoser.superfeedr.com">
+          <event xmlns="http://jabber.org/protocol/pubsub#event">
+            <status xmlns="http://superfeedr.com/xmpp-pubsub-ext" feed="http://domain.tld/feed.xml">
+              <http code="200">All went very fine. Thanks for asking!</http>
+              <next_fetch>2010-02-03T01:32:58+01:00</next_fetch>
+              <title></title>
+            </status>
+          </event>
+        </message>
+        EOXML
+        xml = Nokogiri::XML(xml)
+        @stanza = Skates::Base::Stanza.new(xml.root)
+      end
+
+      it "should have the right from" do
+        @stanza.from.should == "test-firehoser.superfeedr.com"
+      end
+
+      it "should have the right id" do
+        @stanza.id.should be_nil
+      end
+
+      it "should have the right to" do
+        @stanza.to.should == "monitor@superfeedr.com"
+      end
+
+      it "should have the right type" do
+        @stanza.type.should be_nil
+      end
+
+      it "should have the right name" do
+        @stanza.name.should == "message"
+      end
+      
+    end
+    
+  end
+
+end

data/spec/lib/skates/base/view_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Skates::Base::View do
+  describe :initialize do
+    
+    before(:each) do
+      @view = Skates::Base::View.new("/a/path/to/views/file", {:a => "a", :b => 123, :c => {:d => "d", :e => "123"}})
+    end
+    
+    it "should assign @view_template to path" do
+      @view.view_template == "/a/path/to/views/file"
+    end
+    
+    it "should assign any variable passed in hash" do
+      {:a => "a", :b => 123, :c => {:d => "d", :e => "123"}}.each do |key, value|
+        @view.instance_variable_get("@#{key}").should == value
+      end
+    end
+  end
+
+  describe :evaluate do
+    before(:each) do
+      @view_template = "/a/path/to/views/file"
+      @view = Skates::Base::View.new(@view_template, {:a => "a", :b => 123, :c => {:d => "d", :e => "123"}})
+      @xml_string = <<-eoxml
+        xml.message(:to => "you", :from => "me", :type => :chat) do
+          xml.body("salut") 
+       end
+      eoxml
+      Skates.views.stub!(:[]).with(@view_template).and_return(@xml_string)
+    end
+        
+    it "should read the template file" do
+      Skates.views.should_receive(:[]).twice.with(@view_template).and_return(@xml_string)
+      @view.evaluate
+    end
+    
+    it "should raise an error if the view file couldn't be found" do
+      Skates.views.stub!(:[]).with(@view_template).and_raise(nil)
+      lambda {
+        @view.evaluate
+      }.should raise_error(Skates::Base::ViewFileNotFound)
+    end
+    
+    it "should return a Nokogiri NodeSet" do
+      Skates.views.stub!(:[]).with(@view_template).and_return(@xml_string)
+      @view.evaluate.should be_an_instance_of(Nokogiri::XML::NodeSet)
+    end
+    
+    it "should call eval on the view file" do
+      Skates.views.stub!(:[]).with(@view_template).and_return(@xml_string)
+      @view.should_receive(:eval).with(@xml_string, an_instance_of(Binding), @view_template, 1)
+      @view.evaluate
+    end
+    
+    it "should be able to access context's variables" do
+      @view = Skates::Base::View.new("/a/path/to/views/file", {:a => "a", :b => 123, :c => {:d => "d", :e => "123"}})
+      @view.instance_variable_get("@a").should == "a"
+      @view.instance_variable_get("@b").should == 123
+      @view.instance_variable_get("@c").should == {:e=>"123", :d=>"d"}
+    end
+  end
+  
+  describe :render do
+    before(:each) do
+      @view_template = "/a/path/to/views/file"
+      @view = Skates::Base::View.new(@view_template, {:a => "a", :b => 123, :c => {:d => "d", :e => "123"}})
+      
+      @xml_string = <<-eoxml
+        xml.message(:to => "you", :from => "me", :type => :chat) do |message|
+          message.body("salut") 
+          render(message, {:partial => "partial", :locals => {:subtitle => "bonjour monde"}})
+          render(message, {:partial => "../other_views/partial", :locals => {:subtitle => "bonjour monde", :name => "Joe"}})
+       end
+      eoxml
+      
+      @partial_string = <<-eoxml
+        xml.title("hello word")
+        xml.subtitle(subtitle)
+      eoxml
+
+      @partial_in_annother_controller_string = <<-eoxml
+        xml.name(name)
+      eoxml
+      
+      Skates.views.stub!(:[]).with(@view_template).and_return(@xml_string)      
+      Skates.views.stub!(:[]).with("/a/path/to/views/partial.xml.builder").and_return(@partial_string)      
+      Skates.views.stub!(:[]).with("/a/path/to/other_views/partial.xml.builder").and_return(@partial_in_annother_controller_string) 
+    end
+    
+    it "should render the partial in the right context" do
+      @view.evaluate.xpath("//message/title").text.should == "hello word"
+    end
+    
+    it "should allocate the locals variables" do
+      @view.evaluate.xpath("//message/subtitle").text.should == "bonjour monde"
+    end
+    
+    it "should cleanup the path so only canonical paths are used" do
+      @view.evaluate.xpath("//message/name").text.should == "Joe"
+    end
+    
+  end
+  
+end

data/spec/lib/skates/client_connection_spec.rb

@@ -0,0 +1,309 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../../em_mock'
+
+describe Skates::ClientConnection do
+  
+  include SkatesSpecHelper
+
+  before(:each) do
+    @params = {"jid" => "jid@server.tld", "password" => "password"}
+    @client = Skates::ClientConnection.connect(@params.merge({"host" => "0.0.0.0", "port" => 5222}), handler_mock) 
+    @client.stub!(:send_xml).and_return(true) 
+  end
+  
+  describe "initialize" do
+    it "should set the state to :wait_for_stream" do
+      @client.instance_variable_get("@state").should == :wait_for_stream
+    end
+  end
+  
+  describe "connect" do
+  end
+  
+  describe "when resolving the hostname" do
+    before(:each) do
+      @params.delete("host")
+      @params.delete("port")
+      @srv = [
+        mock(Resolv::DNS::Resource, :priority => 10, :target => "12.13.14.15", :port => 1234),
+        mock(Resolv::DNS::Resource, :priority => 3, :target => "12.13.14.16", :port => 4567),
+        mock(Resolv::DNS::Resource, :priority => 100, :target => "12.13.14.17", :port => 8910)
+        ]
+      @mock_dns = mock(Object)
+      Resolv::DNS.stub!(:open).and_yield(@mock_dns)
+      @mock_dns.stub!(:getresources).and_return(@srv)
+    end
+    
+    it "should get resources assiated with _xmpp-client._tcp.host.tld}" do
+      Resolv::DNS.should_receive(:open).and_yield(@mock_dns)
+      @mock_dns.should_receive(:getresources).with("_xmpp-client._tcp.server.tld", Resolv::DNS::Resource::IN::SRV).and_return(@srv)
+      Skates::ClientConnection.resolve("server.tld") 
+    end
+    
+    it "should call the block with the highest priority" do
+      Skates::ClientConnection.resolve("xmpp.server.tld") do |params|
+        params["host"].should == "12.13.14.16"
+        params["port"].should == 4567
+        true
+      end 
+    end
+    
+    it "should call the block as many times as needed if they're not connecting" do
+      conn = mock(Skates::ClientConnection, :_connect => false)
+      conn.should_receive(:_connect).exactly(3).times
+      Skates::ClientConnection.resolve("xmpp.server.tld") do |ip, port|
+        conn._connect(ip, port)
+      end
+    end
+  end
+  
+  describe "stream_stanza" do
+    it "should be of the right form" do
+      @client.stream_stanza.should == "<?xml version=\"1.0\"?>\n<stream:stream xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" to=\"server.tld\" version=\"1.0\">\n  "
+    end
+  end
+  
+  describe "connection_completed" do
+    it "should send_xml the stream_stanza" do
+      @client.should_receive(:send_xml).with(@client.stream_stanza)
+      @client.connection_completed
+    end
+  end
+  
+  describe "receive_stanza" do
+    before(:each) do
+      @doc = Nokogiri::XML::Document.new
+    end
+    describe "when connected" do
+      before(:each) do
+        @client.instance_variable_set("@state", :connected)
+      end
+      it "should call super"
+    end
+    
+    describe "when wait_for_stream_authenticated" do
+      before(:each) do
+        @client.instance_variable_set("@state", :wait_for_stream_authenticated)
+        @stanza = Nokogiri::XML::Node.new("stream:stream", @doc)
+        @stanza["id"] = "123"
+      end
+      it "should change state to wait_for_bind if the stanza is stream:stream with an id" do
+        @client.receive_stanza(@stanza)
+        @client.instance_variable_get("@state").should == :wait_for_bind
+      end
+    end
+    
+    describe "when wait_for_stream" do
+      before(:each) do
+        @client.instance_variable_set("@state", :wait_for_stream)
+        @stanza = Nokogiri::XML::Node.new("stream:stream", @doc)
+        @stanza["id"] = "123"
+      end
+      it "should change state to wait_for_auth_mechanisms if the stanza is stream:stream with an id" do
+        @client.receive_stanza(@stanza)
+        @client.instance_variable_get("@state").should == :wait_for_auth_mechanisms
+      end
+    end
+    
+    describe "when wait_for_auth_mechanisms" do
+      before(:each) do
+        @client.instance_variable_set("@state", :wait_for_auth_mechanisms)
+      end
+      
+      describe "if the stanza is stream:features" do
+        before(:each) do
+          @stanza = Nokogiri::XML::Node.new("stream:features", @doc)
+          @stanza["id"] = "123"
+        end
+        
+        describe "if the stanza has startls" do
+          before(:each) do
+            @stanza.add_child(Nokogiri::XML::Node.new("starttls", @doc))
+          end
+          it "should send start tls" do
+            @client.should_receive(:send_xml).with('<starttls xmlns="urn:ietf:params:xml:ns:xmpp-tls"/>')
+            @client.receive_stanza(@stanza)
+          end
+        end
+        
+        describe "if the stanza has mechanisms" do
+          before(:each) do
+            mechanisms = Nokogiri::XML::Node.new("mechanisms", @doc)
+            mechanism = Nokogiri::XML::Node.new("mechanism", @doc)
+            mechanism.content = "PLAIN"
+            mechanisms.add_child(mechanism)
+            @stanza.add_child(mechanisms)
+          end
+                    
+          it "should send authentication" do
+            @client.should_receive(:send_xml).with("<auth mechanism=\"PLAIN\" xmlns=\"urn:ietf:params:xml:ns:xmpp-sasl\">amlkQHNlcnZlci50bGQAamlkAHBhc3N3b3Jk</auth>")
+            @client.receive_stanza(@stanza)
+          end
+        end
+        
+      end
+    end
+    
+    describe "when wait_for_success" do
+      before(:each) do
+        @client.instance_variable_set("@state", :wait_for_success)
+      end
+      describe "when stanza is success" do
+        before(:each) do
+          @stanza = Nokogiri::XML::Node.new("success", @doc)
+        end
+        
+        it "should reset the parser" do
+          @client.instance_variable_get("@parser").should_receive(:reset)
+          @client.receive_stanza(@stanza)
+        end
+        
+        it "should send stream_stanza" do
+          @client.should_receive(:send_xml).with("<?xml version=\"1.0\"?>\n<stream:stream xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" to=\"server.tld\" version=\"1.0\">\n  ")
+          @client.receive_stanza(@stanza)
+        end
+        
+        it "should change state to wait_for_stream_authenticated" do
+          @client.receive_stanza(@stanza)
+          @client.instance_variable_get("@state").should == :wait_for_stream_authenticated
+        end
+        
+      end
+      describe "when stanza is failure" do
+        before(:each) do
+          @stanza = Nokogiri::XML::Node.new("failure", @doc)
+        end
+        it "should raise AuthenticationError if stanza has bad-auth" do
+          @stanza.add_child(Nokogiri::XML::Node.new("bad-auth", @doc))
+          lambda {
+            @client.receive_stanza(@stanza)
+          }.should raise_error(Skates::AuthenticationError)
+        end
+        
+        it "should raise AuthenticationError if stanza has not-authorized" do
+          @stanza.add_child(Nokogiri::XML::Node.new("not-authorized", @doc))
+          lambda {
+            @client.receive_stanza(@stanza)
+          }.should raise_error(Skates::AuthenticationError)
+        end
+      end
+    end
+    
+    describe "when wait_for_bind" do
+      before(:each) do
+        @client.instance_variable_set("@state", :wait_for_bind)
+      end
+      
+      describe "if stanza is stream:features" do
+        before(:each) do
+          @stanza = Nokogiri::XML::Node.new("stream:features", @doc)
+        end
+        
+        describe "if stanza has bind" do
+          before(:each) do
+            bind = Nokogiri::XML::Node.new("bind", @doc)
+            @stanza.add_child(bind)
+          end
+          
+          it "should send_xml with the bind iq" do
+            @client.should_receive(:binding_iq_id).twice.and_return(123)
+            @client.should_receive(:send_xml).with("<iq type=\"set\" id=\"123\">\n  <bind xmlns=\"urn:ietf:params:xml:ns:xmpp-bind\">\n    <resource>skates_client_123</resource>\n  </bind>\n</iq>")
+            @client.receive_stanza(@stanza)
+          end
+          
+          it "should set the state to :wait_for_confirmed_binding" do
+            @client.receive_stanza(@stanza)
+            @client.instance_variable_get("@state").should == :wait_for_confirmed_binding
+          end
+        end
+      end
+    end
+    
+    describe "when wait_for_confirmed_binding" do
+      before(:each) do
+        @client.instance_variable_set("@state", :wait_for_confirmed_binding)
+      end
+      describe "if stanza is iq with type=result and the righ binding_iq_id" do
+        before(:each) do
+          binding_iq_id = 123
+          @stanza = Nokogiri::XML::Node.new("iq", @doc)
+          @stanza["type"] = "result"
+          @stanza["id"] = binding_iq_id.to_s
+          @client.stub!(:binding_iq_id).and_return(binding_iq_id)
+        end
+        
+          it "should send_xml with the session iq" do
+            @client.should_receive(:session_iq_id).and_return(123)
+            @client.should_receive(:send_xml).with("<iq type=\"set\" id=\"123\">\n  <session xmlns=\"urn:ietf:params:xml:ns:xmpp-session\"/>\n</iq>")
+            @client.receive_stanza(@stanza)
+          end
+          
+          it "should set the state to :wait_for_confirmed_session" do
+            @client.receive_stanza(@stanza)
+            @client.instance_variable_get("@state").should == :wait_for_confirmed_session
+          end
+      end
+      
+    end
+    
+    describe "when wait_for_confirmed_session" do
+      before(:each) do
+        @client.instance_variable_set("@state", :wait_for_confirmed_session)
+      end
+      
+      describe "if stanza is iq with type=result and the righ session_iq_id" do
+        before(:each) do
+          session_iq_id = 123
+          @stanza = Nokogiri::XML::Node.new("iq", @doc)
+          @stanza["type"] = "result"
+          @stanza["id"] = session_iq_id.to_s
+          @client.stub!(:session_iq_id).and_return(session_iq_id)
+        end
+        
+        it "should send_xml the initial presence" do
+          @client.should_receive(:send_xml).with("<presence/>")
+          @client.receive_stanza(@stanza)
+        end
+        
+        it "should set the state to :connected" do
+          @client.receive_stanza(@stanza)
+          @client.instance_variable_get("@state").should == :connected
+        end
+      end
+    end
+    
+    describe "when wait_for_proceed" do
+      before(:each) do
+        @client.instance_variable_set("@state", :wait_for_proceed)
+        @client.stub!(:start_tls).and_return(true)
+      end
+      
+      it "should start_tls" do
+        @client.should_receive(:start_tls)
+        @client.receive_stanza(@stanza)
+      end
+      
+      it "reset the parser" do
+        @client.instance_variable_get("@parser").should_receive(:reset)
+        @client.receive_stanza(@stanza)        
+      end
+      
+      it "should set the state to :wait_for_stream" do
+        @client.receive_stanza(@stanza)
+        @client.instance_variable_get("@state").should == :wait_for_stream
+      end
+      
+      it "should send the stream stanza" do
+        @client.should_receive(:send_xml).with("<?xml version=\"1.0\"?>\n<stream:stream xmlns=\"jabber:client\" xmlns:stream=\"http://etherx.jabber.org/streams\" to=\"server.tld\" version=\"1.0\">\n  ")
+        @client.receive_stanza(@stanza)
+      end 
+    end 
+  end 
+  
+  describe "stream_namespace" do
+    it "should return jabber:client" do
+      @client.stream_namespace.should == "jabber:client"
+    end
+  end
+  
+end