skates 0.5.0 → 0.5.3

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

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

@@ -1,309 +0,0 @@
-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, :address => "12.13.14.15"),
-        mock(Resolv::DNS::Resource, :priority => 3, :target => "12.13.14.16", :port => 4567, :address => "12.13.14.16"),
-        mock(Resolv::DNS::Resource, :priority => 100, :target => "12.13.14.17", :port => 8910, :address => "12.13.14.17")
-        ]
-      @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("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", @doc)
-        @stanza["id"] = "123"
-      end
-      it "should change state to wait_for_bind if the stanza is 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", @doc)
-        @stanza["id"] = "123"
-      end
-      it "should change state to wait_for_auth_mechanisms if the stanza is 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 features" do
-        before(:each) do
-          @stanza = Nokogiri::XML::Node.new("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 features" do
-        before(:each) do
-          @stanza = Nokogiri::XML::Node.new("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

data/spec/lib/skates/component_connection_spec.rb

@@ -1,144 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../em_mock'
-
-describe Skates::ComponentConnection do
-
-  include SkatesSpecHelper
-
-  before(:each) do
-    @params = {"jid" => "jid@server", "password" => "password", "port" => 1234, "host" => "0.0.0.0"}
-    @component = Skates::ComponentConnection.connect(@params, handler_mock) 
-    @component.stub!(:send_xml).and_return(true) 
-  end
-
-  describe "initialize" do
-    it "should set the state to :wait_for_stream" do
-      @component.instance_variable_get("@state").should == :wait_for_stream
-    end
-  end
-
-  describe "connection_completed" do
-    it "should send a <stream> element that initiates the communication" do
-      @component.should_receive(:send_xml).with("<?xml version=\"1.0\"?>\n<stream:stream xmlns=\"jabber:component:accept\" xmlns:stream=\"http://etherx.jabber.org/streams\" to=\"jid@server\">\n  ")
-      @component.connection_completed
-    end
-  end
-
-  describe "receive_stanza" do
-
-    before(:each) do
-      @component.instance_variable_set("@connected", true)
-      @doc = Nokogiri::XML::Document.new
-      @stanza = Nokogiri::XML::Node.new("presence", @doc)
-    end
-
-    describe "when connected" do
-      before(:each) do
-        @component.instance_variable_set("@state", :connected)
-      end
-      it "should call the receive_stanza on super" 
-    end
-
-    describe "when waiting for stream" do
-      before(:each) do
-        @component.connection_completed
-        @component.instance_variable_set("@state", :wait_for_stream)
-      end
-
-      describe "if the stanza is stream" do
-        before(:each) do
-          @stanza = Nokogiri::XML::Node.new("stream", @doc)
-          @stanza["xmlns:stream"] = 'http://etherx.jabber.org/streams'
-          @stanza["xmlns"] = 'jabber:component:accept'
-          @stanza["from"] = 'plays.shakespeare.lit'
-          @stanza["id"] = "1234"
-        end
-
-        it "should send a handshake" do
-          @component.should_receive(:handshake)
-          @component.receive_stanza(@stanza)
-        end
-
-        it "should change state to wait_for_handshake" do
-          @component.receive_stanza(@stanza)
-          @component.instance_variable_get("@state").should == :wait_for_handshake
-        end
-
-      end
-
-      describe "if the stanza is not stream or deosn't have an id" do
-        it "should raise an error" do
-          lambda {@component.receive_stanza(Nokogiri::XML::Node.new("else", @doc))}.should raise_error
-        end
-      end
-
-    end
-
-    describe "when waiting for handshake" do
-      before(:each) do
-        @component.instance_variable_set("@state", :wait_for_handshake)
-      end
-
-      describe "if we actually get a handshake stanza" do
-
-        before(:each) do
-          @handshake = Nokogiri::XML::Node.new("handshake", @doc)
-        end
-
-        it "should set the status as connected" do
-          @component.receive_stanza(@handshake)
-          @component.instance_variable_get("@state").should == :connected
-        end
-
-        it "should call the connection callback" do
-          handler_mock.should_receive(:on_connected).with(@component)
-          @component.receive_stanza(@handshake)
-        end
-      end
-
-      describe "if we receive a stream:error" do
-        it "should raise an Authentication Error" do
-          lambda {@component.receive_stanza(Nokogiri::XML::Node.new("error", @doc))}.should raise_error(Skates::AuthenticationError)
-        end
-      end
-
-      describe "if we receive something else" do
-        it "should raise an error" do
-          lambda {@component.receive_stanza(Nokogiri::XML::Node.new("else", @doc))}.should raise_error
-        end
-      end
-
-    end
-
-  end
-
-  describe "stream_namespace" do
-    it "should return jabber:component:accept" do
-      @component.stream_namespace.should == 'jabber:component:accept'
-    end
-  end
-
-  describe "handshake" do
-    it "should build a handshake Element with the password and the id of the stanza" do
-      @component.connection_completed
-      doc = Nokogiri::XML::Document.new
-      stanza = Nokogiri::XML::Node.new("stream", doc)
-      stanza["xmlns:stream"] = 'http://etherx.jabber.org/streams'
-      stanza["xmlns"] = 'jabber:component:accept'
-      stanza["from"] = 'plays.shakespeare.lit'
-      stanza["id"] = "1234"
-      @component.__send__(:handshake, stanza).xpath("//handshake").first.content.should == Digest::SHA1::hexdigest(stanza.attributes['id'].content + @params["password"])
-    end
-    
-  end
-
-  describe "when resolving" do
-    it "should resolve records" do
-      Skates::ComponentConnection.resolve("xmpp2.superfeedr.com") do |res|
-        res["host"].should == "173.255.193.75"
-        true
-      end
-    end
-  end
-
-end