tp-blather 0.8.2

data/spec/blather/client/dsl_spec.rb

@@ -0,0 +1,266 @@
+require 'spec_helper'
+require 'blather/client/dsl'
+
+describe Blather::DSL do
+  before do
+    @client = Blather::Client.new
+    @stream = mock()
+    @stream.stubs(:send)
+    @client.post_init @stream, Blather::JID.new('n@d/r')
+    @dsl = Class.new { include Blather::DSL }.new
+    Blather::Client.stubs(:new).returns(@client)
+  end
+
+  it 'wraps the setup' do
+    args = ['jid', 'pass', 'host', 0000]
+    @client.expects(:setup).with *(args + [nil, nil, nil])
+    @dsl.setup *args
+  end
+
+  it 'allows host to be nil in setup' do
+    args = ['jid', 'pass']
+    @client.expects(:setup).with *(args + [nil, nil, nil, nil])
+    @dsl.setup *args
+  end
+
+  it 'allows port to be nil in setup' do
+    args = ['jid', 'pass', 'host']
+    @client.expects(:setup).with *(args + [nil, nil, nil])
+    @dsl.setup *args
+  end
+
+  it 'allows certs to be nil in setup' do
+    args = ['jid', 'pass', 'host', 'port']
+    @client.expects(:setup).with *(args + [nil, nil])
+    @dsl.setup *args
+  end
+
+  it 'accepts certs in setup' do
+    args = ['jid', 'pass', 'host', 'port', 'certs']
+    @client.expects(:setup).with *(args + [nil])
+    @dsl.setup *args
+  end
+
+  it 'accepts connection timeout in setup' do
+    args = ['jid', 'pass', 'host', 'port', 'certs', 30]
+    @client.expects(:setup).with *args
+    @dsl.setup *args
+  end
+
+  it 'stops when shutdown is called' do
+    @client.expects(:close)
+    @dsl.shutdown
+  end
+
+  it 'can throw a halt' do
+    catch(:halt) { @dsl.halt }
+  end
+
+  it 'can throw a pass' do
+    catch(:pass) { @dsl.pass }
+  end
+
+  it 'can setup before filters' do
+    guards = [:chat?, {:body => 'exit'}]
+    @client.expects(:register_filter).with :before, nil, *guards
+    @dsl.before nil, *guards
+  end
+
+  it 'can setup after filters' do
+    guards = [:chat?, {:body => 'exit'}]
+    @client.expects(:register_filter).with :after, nil, *guards
+    @dsl.after nil, *guards
+  end
+
+  it 'sets up handlers' do
+    type = :message
+    guards = [:chat?, {:body => 'exit'}]
+    @client.expects(:register_handler).with type, *guards
+    @dsl.handle type, *guards
+  end
+
+  it 'sets up handler methods' do
+    @client.expects(:register_handler).with :presence, :unavailable?
+    @dsl.presence :unavailable?
+  end
+
+  it 'provides a helper for ready state' do
+    @client.expects(:register_handler).with :ready
+    @dsl.when_ready
+  end
+
+  it 'provides a helper for disconnected' do
+    @client.expects(:register_handler).with :disconnected
+    @dsl.disconnected
+  end
+
+  it 'sets the initial status' do
+    state = :away
+    msg = 'do not disturb'
+    @client.expects(:status=).with [state, msg]
+    @dsl.set_status state, msg
+  end
+
+  it 'provides a roster accessor' do
+    @client.expects :roster
+    @dsl.my_roster
+  end
+
+  it 'provides a << style writer that provides chaining' do
+    stanza = Blather::Stanza::Iq.new
+    @client.expects(:write).with stanza
+    (@dsl << stanza).should == @dsl
+  end
+
+  it 'provides a writer' do
+    stanza = Blather::Stanza::Iq.new
+    @client.expects(:write).with stanza
+    @dsl.write_to_stream stanza
+  end
+
+  describe "#join" do
+    context "providing room and service as separate args" do
+      it "should join to a muc room with a specified nick" do
+        presence = Blather::Stanza::Presence::MUC.new
+        presence.to = "rabbit_hole@wonderland.lit/alice"
+        @client.expects(:write).with presence
+        @dsl.join 'rabbit_hole', 'wonderland.lit', 'alice'
+      end
+    end
+
+    context "providing a room JID" do
+      it "should join to a muc room with a specified nick" do
+        presence = Blather::Stanza::Presence::MUC.new
+        presence.to = "rabbit_hole@wonderland.lit/alice"
+        @client.expects(:write).with presence
+        @dsl.join 'rabbit_hole@wonderland.lit', 'alice'
+      end
+    end
+  end
+
+  it 'provides a "say" helper' do
+    to, msg, type = 'me@me.com', 'hello!', :groupchat
+    Blather::Stanza::Message.stubs(:next_id).returns 0
+    @client.expects(:write).with Blather::Stanza::Message.new(to, msg, type)
+    @dsl.say to, msg, type
+  end
+
+  it 'provides a JID accessor' do
+    @client.expects :jid
+    @dsl.jid
+  end
+
+  it 'provides a disco helper for items' do
+    what, who, where = :items, 'me@me.com', 'my/node'
+    Blather::Stanza::Disco::DiscoItems.stubs(:next_id).returns 0
+    @client.expects(:register_tmp_handler).with '0'
+    expected_stanza = Blather::Stanza::Disco::DiscoItems.new
+    expected_stanza.to = who
+    expected_stanza.node = where
+    @client.expects(:write).with expected_stanza
+    @dsl.discover what, who, where
+  end
+
+  it 'provides a disco helper for info' do
+    what, who, where = :info, 'me@me.com', 'my/node'
+    Blather::Stanza::Disco::DiscoInfo.stubs(:next_id).returns 0
+    @client.expects(:register_tmp_handler).with '0'
+    expected_stanza = Blather::Stanza::Disco::DiscoInfo.new
+    expected_stanza.to = who
+    expected_stanza.node = where
+    @client.expects(:write).with expected_stanza
+    @dsl.discover what, who, where
+  end
+
+  it 'provides a caps set helper' do
+    @dsl.should respond_to :set_caps
+    node = 'http://code.google.com/p/exodus'
+    identities = [Blather::Stanza::Iq::DiscoInfo::Identity.new({:name => 'Exodus 0.9.1', :type => 'pc', :category => 'client'})]
+    features = %w{
+                  http://jabber.org/protocol/caps
+                  http://jabber.org/protocol/disco#info
+                  http://jabber.org/protocol/disco#items
+                  http://jabber.org/protocol/muc
+                }
+    @dsl.set_caps node, identities, features
+    @client.caps.node.should == "#{node}##{@client.caps.ver}"
+    @client.caps.identities.should == identities
+    @client.caps.features.map{ |f| f.var }.should == features
+  end
+
+  it 'provides a caps send helper' do
+    @dsl.should respond_to :send_caps
+    @client.caps.node = 'http://code.google.com/p/exodus'
+    @client.caps.identities = [Blather::Stanza::Iq::DiscoInfo::Identity.new({:name => 'Exodus 0.9.1', :type => 'pc', :category => 'client'})]
+    @client.caps.features = %w{
+                          http://jabber.org/protocol/caps
+                          http://jabber.org/protocol/disco#info
+                          http://jabber.org/protocol/disco#items
+                          http://jabber.org/protocol/muc
+                        }
+    expected_stanza = Blather::Stanza.parse(<<-XML)
+      <presence>
+        <c xmlns="http://jabber.org/protocol/caps" hash="sha-1"
+           node="http://code.google.com/p/exodus"
+           ver="QgayPKawpkPSDYmwT/WM94uAlu0="
+        />
+      </presence>
+    XML
+    @client.expects(:write).with expected_stanza
+    @client.expects(:register_handler).with(:disco_info, :type => :get, :node => "http://code.google.com/p/exodus#QgayPKawpkPSDYmwT/WM94uAlu0=")
+    @dsl.send_caps
+  end
+
+  it 'responds with correct disco stanza after sending caps and receiving query' do
+    @client.caps.node = 'http://code.google.com/p/exodus'
+    @client.caps.identities = [Blather::Stanza::Iq::DiscoInfo::Identity.new({:name => 'Exodus 0.9.1', :type => 'pc', :category => 'client'})]
+    @client.caps.features = %w{
+                          http://jabber.org/protocol/caps
+                          http://jabber.org/protocol/disco#info
+                          http://jabber.org/protocol/disco#items
+                          http://jabber.org/protocol/muc
+                        }
+    stanza = <<-XML
+      <iq from='juliet@capulet.lit/chamber'
+          id='disco1'
+          to='romeo@montague.lit/orchard'
+          type='get'>
+        <query xmlns='http://jabber.org/protocol/disco#info'
+               node='http://code.google.com/p/exodus#QgayPKawpkPSDYmwT/WM94uAlu0='/>
+      </iq>
+    XML
+    @stanza = Blather::Stanza.parse(stanza)
+
+    expected_stanza = Blather::Stanza.parse(<<-XML)
+      <iq type="result" id="disco1" to="juliet@capulet.lit/chamber">
+        <query xmlns="http://jabber.org/protocol/disco#info" node="http://code.google.com/p/exodus#QgayPKawpkPSDYmwT/WM94uAlu0=">
+          <identity name="Exodus 0.9.1" category="client" type="pc"/>
+          <feature var="http://jabber.org/protocol/caps"/>
+          <feature var="http://jabber.org/protocol/disco#info"/>
+          <feature var="http://jabber.org/protocol/disco#items"/>
+          <feature var="http://jabber.org/protocol/muc"/>
+        </query>
+      </iq>
+    XML
+    @dsl.send_caps
+    # client writes a Client::Cap object but it's the same as a DiscoInfo
+    # this is a hack to pass the same-class check in XMPPNode#eql?
+    @client.expects(:write).with { |n| Blather::Stanza.import(n) == expected_stanza }
+    @client.receive_data @stanza
+  end
+
+  Blather::Stanza.handler_list.each do |handler_method|
+    it "provides a helper method for #{handler_method}" do
+      guards = [:chat?, {:body => 'exit'}]
+      @client.expects(:register_handler).with handler_method, *guards
+      @dsl.__send__(handler_method, *guards)
+    end
+  end
+
+  it 'has a pubsub helper set to the jid domain' do
+    jid = Blather::JID.new('jid@domain/resource')
+    @client.stubs(:jid).returns jid
+    @dsl.pubsub.should be_instance_of Blather::DSL::PubSub
+    @dsl.pubsub.host.should == jid.domain
+  end
+end

data/spec/blather/errors/sasl_error_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+def sasl_error_node(err_name = 'aborted')
+  node = Blather::XMPPNode.new 'failure'
+  node.namespace = Blather::SASLError::SASL_ERR_NS
+
+  node << Blather::XMPPNode.new(err_name, node.document)
+  node
+end
+
+describe Blather::SASLError do
+  it 'can import a node' do
+    Blather::SASLError.should respond_to :import
+    e = Blather::SASLError.import sasl_error_node
+    e.should be_kind_of Blather::SASLError
+  end
+
+  describe 'each XMPP SASL error type' do
+    %w[ aborted
+        incorrect-encoding
+        invalid-authzid
+        invalid-mechanism
+        mechanism-too-weak
+        not-authorized
+        temporary-auth-failure
+    ].each do |error_type|
+      it "handles the name for #{error_type}" do
+        e = Blather::SASLError.import sasl_error_node(error_type)
+        e.name.should == error_type.gsub('-','_').to_sym
+      end
+    end
+  end
+end

data/spec/blather/errors/stanza_error_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+def stanza_error_node(type = 'cancel', error = 'internal-server-error', msg = nil)
+  node = Blather::Stanza::Message.new 'error@jabber.local', 'test message', :error
+
+  node << (error_node = Blather::XMPPNode.new('error'))
+  error_node['type'] = type.to_s
+
+  error_node << (err = Blather::XMPPNode.new(error, error_node.document))
+  err.namespace = 'urn:ietf:params:xml:ns:xmpp-stanzas'
+
+  if msg
+    error_node << (text = Blather::XMPPNode.new('text', error_node.document))
+    text.namespace = 'urn:ietf:params:xml:ns:xmpp-stanzas'
+    text.content = msg
+  end
+
+  error_node << (extra = Blather::XMPPNode.new('extra-error', error_node.document))
+  extra.namespace = 'blather:stanza:error'
+  extra.content = 'Blather Error'
+
+  node
+end
+
+describe Blather::StanzaError do
+  it 'can import a node' do
+    Blather::StanzaError.should respond_to :import
+    e = Blather::StanzaError.import stanza_error_node
+    e.should be_kind_of Blather::StanzaError
+  end
+
+  describe 'valid types' do
+    before { @original = Blather::Stanza::Message.new 'error@jabber.local', 'test message', :error }
+
+    it 'ensures type is one of Stanza::Message::VALID_TYPES' do
+      lambda { Blather::StanzaError.new @original, :gone, :invalid_type_name }.should raise_error(Blather::ArgumentError)
+
+      Blather::StanzaError::VALID_TYPES.each do |valid_type|
+        msg = Blather::StanzaError.new @original, :gone, valid_type
+        msg.type.should == valid_type
+      end
+    end
+  end
+
+  describe 'when instantiated' do
+    before do
+      @type = 'cancel'
+      @err_name = 'internal-server-error'
+      @msg = 'the server has experienced a misconfiguration'
+      @err = Blather::StanzaError.import stanza_error_node(@type, @err_name, @msg)
+    end
+
+    it 'provides a type attribute' do
+      @err.should respond_to :type
+      @err.type.should == @type.to_sym
+    end
+
+    it 'provides a name attribute' do
+      @err.should respond_to :name
+      @err.name.should == @err_name.gsub('-','_').to_sym
+    end
+
+    it 'provides a text attribute' do
+      @err.should respond_to :text
+      @err.text.should == @msg
+    end
+
+    it 'provides a reader to the original node' do
+      @err.should respond_to :original
+      @err.original.should be_instance_of Blather::Stanza::Message
+    end
+
+    it 'provides an extras attribute' do
+      @err.should respond_to :extras
+      @err.extras.should be_instance_of Array
+      @err.extras.first.element_name.should == 'extra-error'
+    end
+
+    it 'describes itself' do
+      @err.to_s.should match(/#{@err_name}/)
+      @err.to_s.should match(/#{@msg}/)
+
+      @err.inspect.should match(/#{@err_name}/)
+      @err.inspect.should match(/#{@msg}/)
+    end
+
+    it 'can be turned into xml' do
+      @err.should respond_to :to_xml
+      doc = parse_stanza @err.to_xml
+
+      doc.xpath("/message[@from='error@jabber.local' and @type='error']").should_not be_empty
+      doc.xpath("/message/error").should_not be_empty
+      doc.xpath("/message/error/err_ns:internal-server-error", :err_ns => Blather::StanzaError::STANZA_ERR_NS).should_not be_empty
+      doc.xpath("/message/error/err_ns:text[.='the server has experienced a misconfiguration']", :err_ns => Blather::StanzaError::STANZA_ERR_NS).should_not be_empty
+      doc.xpath("/message/error/extra_ns:extra-error[.='Blather Error']", :extra_ns => 'blather:stanza:error').should_not be_empty
+    end
+  end
+
+  describe 'each XMPP stanza error type' do
+    %w[ bad-request
+        conflict
+        feature-not-implemented
+        forbidden
+        gone
+        internal-server-error
+        item-not-found
+        jid-malformed
+        not-acceptable
+        not-allowed
+        not-authorized
+        payment-required
+        recipient-unavailable
+        redirect
+        registration-required
+        remote-server-not-found
+        remote-server-timeout
+        resource-constraint
+        service-unavailable
+        subscription-required
+        undefined-condition
+        unexpected-request
+      ].each do |error_type|
+        it "handles the name for #{error_type}" do
+          e = Blather::StanzaError.import stanza_error_node(:cancel, error_type)
+          e.name.should == error_type.gsub('-','_').to_sym
+        end
+      end
+  end
+end

data/spec/blather/errors/stream_error_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+def stream_error_node(error = 'internal-server-error', msg = nil)
+  node = Blather::XMPPNode.new('error')
+  node.namespace = {'stream' => Blather::Stream::STREAM_NS}
+
+  node << (err = Blather::XMPPNode.new(error, node.document))
+  err.namespace = 'urn:ietf:params:xml:ns:xmpp-streams'
+
+  if msg
+    node << (text = Blather::XMPPNode.new('text', node.document))
+    text.namespace = 'urn:ietf:params:xml:ns:xmpp-streams'
+    text.content = msg
+  end
+
+  node << (extra = Blather::XMPPNode.new('extra-error', node.document))
+  extra.namespace = 'blather:stream:error'
+  extra.content = 'Blather Error'
+
+  node
+end
+
+describe 'Blather::StreamError' do
+  it 'can import a node' do
+    err = stream_error_node 'internal-server-error', 'the message'
+    Blather::StreamError.should respond_to :import
+    e = Blather::StreamError.import err
+    e.should be_kind_of Blather::StreamError
+
+    e.name.should == :internal_server_error
+    e.text.should == 'the message'
+    e.extras.should == err.find('descendant::*[name()="extra-error"]', 'blather:stream:error').map {|n|n}
+  end
+end
+
+describe 'Blather::StreamError when instantiated' do
+  before do
+    @err_name = 'internal-server-error'
+    @msg = 'the server has experienced a misconfiguration'
+    @err = Blather::StreamError.import stream_error_node(@err_name, @msg)
+  end
+
+  it 'provides a err_name attribute' do
+    @err.should respond_to :name
+    @err.name.should == @err_name.gsub('-','_').to_sym
+  end
+
+  it 'provides a text attribute' do
+    @err.should respond_to :text
+    @err.text.should == @msg
+  end
+
+  it 'provides an extras attribute' do
+    @err.should respond_to :extras
+    @err.extras.should be_instance_of Array
+    @err.extras.size.should == 1
+    @err.extras.first.element_name.should == 'extra-error'
+  end
+
+  it 'describes itself' do
+    @err.to_s.should match(/#{@type}/)
+    @err.to_s.should match(/#{@msg}/)
+
+    @err.inspect.should match(/#{@type}/)
+    @err.inspect.should match(/#{@msg}/)
+  end
+
+  it 'can be turned into xml' do
+    @err.should respond_to :to_xml
+    doc = parse_stanza @err.to_xml
+    doc.xpath("//err_ns:internal-server-error", :err_ns => Blather::StreamError::STREAM_ERR_NS).should_not be_empty
+    doc.xpath("//err_ns:text[.='the server has experienced a misconfiguration']", :err_ns => Blather::StreamError::STREAM_ERR_NS).should_not be_empty
+    doc.xpath("//err_ns:extra-error[.='Blather Error']", :err_ns => 'blather:stream:error').should_not be_empty
+  end
+end
+
+describe 'Each XMPP stream error type' do
+  %w[ bad-format
+      bad-namespace-prefix
+      conflict
+      connection-timeout
+      host-gone
+      host-unknown
+      improper-addressing
+      internal-server-error
+      invalid-from
+      invalid-id
+      invalid-namespace
+      invalid-xml
+      not-authorized
+      policy-violation
+      remote-connection-failed
+      resource-constraint
+      restricted-xml
+      see-other-host
+      system-shutdown
+      undefined-condition
+      unsupported-encoding
+      unsupported-stanza-type
+      unsupported-version
+      xml-not-well-formed
+    ].each do |error_type|
+      it "handles the name for #{error_type}" do
+        e = Blather::StreamError.import stream_error_node(error_type)
+        e.name.should == error_type.gsub('-','_').to_sym
+      end
+    end
+end