shingara-blather 0.4.8

data/spec/blather/errors/sasl_error_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. 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.must_respond_to :import
+    e = Blather::SASLError.import sasl_error_node
+    e.must_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.must_equal error_type.gsub('-','_').to_sym
+      end
+    end
+  end
+end

data/spec/blather/errors/stanza_error_spec.rb

@@ -0,0 +1,129 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. 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.must_respond_to :import
+    e = Blather::StanzaError.import stanza_error_node
+    e.must_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 }.must_raise(Blather::ArgumentError)
+
+      Blather::StanzaError::VALID_TYPES.each do |valid_type|
+        msg = Blather::StanzaError.new @original, :gone, valid_type
+        msg.type.must_equal 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.must_respond_to :type
+      @err.type.must_equal @type.to_sym
+    end
+
+    it 'provides a name attribute' do
+      @err.must_respond_to :name
+      @err.name.must_equal @err_name.gsub('-','_').to_sym
+    end
+
+    it 'provides a text attribute' do
+      @err.must_respond_to :text
+      @err.text.must_equal @msg
+    end
+
+    it 'provides a reader to the original node' do
+      @err.must_respond_to :original
+      @err.original.must_be_instance_of Blather::Stanza::Message
+    end
+
+    it 'provides an extras attribute' do
+      @err.must_respond_to :extras
+      @err.extras.must_be_instance_of Array
+      @err.extras.first.element_name.must_equal 'extra-error'
+    end
+
+    it 'describes itself' do
+      @err.to_s.must_match(/#{@err_name}/)
+      @err.to_s.must_match(/#{@msg}/)
+
+      @err.inspect.must_match(/#{@err_name}/)
+      @err.inspect.must_match(/#{@msg}/)
+    end
+
+    it 'can be turned into xml' do
+      @err.must_respond_to :to_xml
+      doc = parse_stanza @err.to_xml
+
+      doc.xpath("/message[@from='error@jabber.local' and @type='error']").wont_be_empty
+      doc.xpath("/message/error").wont_be_empty
+      doc.xpath("/message/error/err_ns:internal-server-error", :err_ns => Blather::StanzaError::STANZA_ERR_NS).wont_be_empty
+      doc.xpath("/message/error/err_ns:text[.='the server has experienced a misconfiguration']", :err_ns => Blather::StanzaError::STANZA_ERR_NS).wont_be_empty
+      doc.xpath("/message/error/extra_ns:extra-error[.='Blather Error']", :extra_ns => 'blather:stanza:error').wont_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.must_equal error_type.gsub('-','_').to_sym
+        end
+      end
+  end
+end

data/spec/blather/errors/stream_error_spec.rb

@@ -0,0 +1,108 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. 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.must_respond_to :import
+    e = Blather::StreamError.import err
+    e.must_be_kind_of Blather::StreamError
+
+    e.name.must_equal :internal_server_error
+    e.text.must_equal 'the message'
+    e.extras.must_equal 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.must_respond_to :name
+    @err.name.must_equal @err_name.gsub('-','_').to_sym
+  end
+
+  it 'provides a text attribute' do
+    @err.must_respond_to :text
+    @err.text.must_equal @msg
+  end
+
+  it 'provides an extras attribute' do
+    @err.must_respond_to :extras
+    @err.extras.must_be_instance_of Array
+    @err.extras.size.must_equal 1
+    @err.extras.first.element_name.must_equal 'extra-error'
+  end
+
+  it 'describes itself' do
+    @err.to_s.must_match(/#{@type}/)
+    @err.to_s.must_match(/#{@msg}/)
+
+    @err.inspect.must_match(/#{@type}/)
+    @err.inspect.must_match(/#{@msg}/)
+  end
+
+  it 'can be turned into xml' do
+    @err.must_respond_to :to_xml
+    doc = parse_stanza @err.to_xml
+    doc.xpath("//err_ns:internal-server-error", :err_ns => Blather::StreamError::STREAM_ERR_NS).wont_be_empty
+    doc.xpath("//err_ns:text[.='the server has experienced a misconfiguration']", :err_ns => Blather::StreamError::STREAM_ERR_NS).wont_be_empty
+    doc.xpath("//err_ns:extra-error[.='Blather Error']", :err_ns => 'blather:stream:error').wont_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.must_equal error_type.gsub('-','_').to_sym
+      end
+    end
+end

data/spec/blather/errors_spec.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), *%w[.. spec_helper])
+
+describe Blather::BlatherError do
+  it 'is handled by :error' do
+    Blather::BlatherError.new.handler_hierarchy.must_equal [:error]
+  end
+end
+
+describe 'Blather::ParseError' do
+  before { @error = Blather::ParseError.new('</generate-parse-error>"') }
+
+  it 'is registers with the handler hierarchy' do
+    @error.handler_hierarchy.must_equal [:parse_error, :error]
+  end
+
+  it 'contains the error message' do
+    @error.must_respond_to :message
+    @error.message.must_equal '</generate-parse-error>"'
+  end
+end
+
+describe 'Blather::UnknownResponse' do
+  before { @error = Blather::UnknownResponse.new(Blather::XMPPNode.new('foo-bar')) }
+
+  it 'is registers with the handler hierarchy' do
+    @error.handler_hierarchy.must_equal [:unknown_response_error, :error]
+  end
+
+  it 'holds on to a copy of the failure node' do
+    @error.must_respond_to :node
+    @error.node.element_name.must_equal 'foo-bar'
+  end
+end

data/spec/blather/jid_spec.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(__FILE__), *%w[.. spec_helper])
+
+describe Blather::JID do
+  it 'does nothing if creaded from Blather::JID' do
+    jid = Blather::JID.new 'n@d/r'
+    Blather::JID.new(jid).object_id.must_equal jid.object_id
+  end
+
+  it 'creates a new Blather::JID from (n,d,r)' do
+    jid = Blather::JID.new('n', 'd', 'r')
+    jid.node.must_equal 'n'
+    jid.domain.must_equal 'd'
+    jid.resource.must_equal 'r'
+  end
+
+  it 'creates a new Blather::JID from (n,d)' do
+    jid = Blather::JID.new('n', 'd')
+    jid.node.must_equal 'n'
+    jid.domain.must_equal 'd'
+  end
+
+  it 'creates a new Blather::JID from (n@d)' do
+    jid = Blather::JID.new('n@d')
+    jid.node.must_equal 'n'
+    jid.domain.must_equal 'd'
+  end
+
+  it 'creates a new Blather::JID from (n@d/r)' do
+    jid = Blather::JID.new('n@d/r')
+    jid.node.must_equal 'n'
+    jid.domain.must_equal 'd'
+    jid.resource.must_equal 'r'
+  end
+
+  it 'requires at least a node' do
+    proc { Blather::JID.new }.must_raise ::ArgumentError
+  end
+
+  it 'ensures length of node is no more than 1023 characters' do
+    proc { Blather::JID.new('n'*1024) }.must_raise Blather::ArgumentError
+  end
+
+  it 'ensures length of domain is no more than 1023 characters' do
+    proc { Blather::JID.new('n', 'd'*1024) }.must_raise Blather::ArgumentError
+  end
+
+  it 'ensures length of resource is no more than 1023 characters' do
+    proc { Blather::JID.new('n', 'd', 'r'*1024) }.must_raise Blather::ArgumentError
+  end
+
+  it 'compares Blather::JIDs' do
+    (Blather::JID.new('a@b/c') <=> Blather::JID.new('d@e/f')).must_equal -1
+    (Blather::JID.new('a@b/c') <=> Blather::JID.new('a@b/c')).must_equal 0
+    (Blather::JID.new('d@e/f') <=> Blather::JID.new('a@b/c')).must_equal 1
+  end
+
+  it 'checks for equality' do
+    (Blather::JID.new('n@d/r') == Blather::JID.new('n@d/r')).must_equal true
+    Blather::JID.new('n@d/r').eql?(Blather::JID.new('n@d/r')).must_equal true
+  end
+
+  it 'will strip' do
+    jid = Blather::JID.new('n@d/r')
+    jid.stripped.must_equal Blather::JID.new('n@d')
+    jid.must_equal Blather::JID.new('n@d/r')
+  end
+
+  it 'will strip itself' do
+    jid = Blather::JID.new('n@d/r')
+    jid.strip!
+    jid.must_equal Blather::JID.new('n@d')
+  end
+
+  it 'has a string representation' do
+    Blather::JID.new('n@d/r').to_s.must_equal 'n@d/r'
+    Blather::JID.new('n', 'd', 'r').to_s.must_equal 'n@d/r'
+    Blather::JID.new('n', 'd').to_s.must_equal 'n@d'
+  end
+
+  it 'provides a #stripped? helper' do
+    jid = Blather::JID.new 'a@b/c'
+    jid.must_respond_to :stripped?
+    jid.stripped?.wont_equal true
+    jid.strip!
+    jid.stripped?.must_equal true
+  end
+end

data/spec/blather/roster_item_spec.rb

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), *%w[.. spec_helper])
+
+describe Blather::RosterItem do
+  it 'can be initialized with Blather::JID' do
+    jid = Blather::JID.new(jid)
+    i = Blather::RosterItem.new jid
+    i.jid.must_equal jid
+  end
+
+  it 'can be initialized with an Iq::RosterItem' do
+    jid = 'n@d/r'
+    i = Blather::RosterItem.new Blather::Stanza::Iq::Roster::RosterItem.new(jid)
+    i.jid.must_equal Blather::JID.new(jid).stripped
+  end
+
+  it 'can be initialized with a string' do
+    jid = 'n@d/r'
+    i = Blather::RosterItem.new jid
+    i.jid.must_equal Blather::JID.new(jid).stripped
+  end
+
+  it 'returns the same object when intialized with a Blather::RosterItem' do
+    control = Blather::RosterItem.new 'n@d/r'
+    Blather::RosterItem.new(control).must_be_same_as control
+  end
+
+  it 'has a Blather::JID setter that strips the Blather::JID' do
+    jid = Blather::JID.new('n@d/r')
+    i = Blather::RosterItem.new nil
+    i.jid = jid
+    i.jid.must_equal jid.stripped
+  end
+
+  it 'has a subscription setter that forces a symbol' do
+    i = Blather::RosterItem.new nil
+    i.subscription = 'remove'
+    i.subscription.must_equal :remove
+  end
+
+  it 'forces the type of subscription' do
+    proc { Blather::RosterItem.new(nil).subscription = 'foo' }.must_raise Blather::ArgumentError
+  end
+
+  it 'returns :none if the subscription field is blank' do
+    Blather::RosterItem.new(nil).subscription.must_equal :none
+  end
+
+  it 'ensure #ask is a symbol' do
+    i = Blather::RosterItem.new(nil)
+    i.ask = 'subscribe'
+    i.ask.must_equal :subscribe
+  end
+
+  it 'forces #ask to be :subscribe or nothing at all' do
+    proc { Blather::RosterItem.new(nil).ask = 'foo' }.must_raise Blather::ArgumentError
+  end
+
+  it 'generates a stanza with #to_stanza' do
+    jid = Blather::JID.new('n@d/r')
+    i = Blather::RosterItem.new jid
+    s = i.to_stanza
+    s.must_be_kind_of Blather::Stanza::Iq::Roster
+    s.items.first.jid.must_equal jid.stripped
+  end
+
+  it 'returns status based on priority' do
+    setup_item_with_presences
+    @i.status.must_equal @p2
+  end
+
+  it 'returns status based on resource' do
+    setup_item_with_presences
+    @i.status('a').must_equal @p
+  end
+
+  def setup_item_with_presences
+    @jid = Blather::JID.new('n@d/r')
+    @i = Blather::RosterItem.new @jid
+
+    @p = Blather::Stanza::Presence::Status.new(:away)
+    @p.from = 'n@d/a'
+    @p.priority = 0
+
+    @p2 = Blather::Stanza::Presence::Status.new(:dnd)
+    @p2.from = 'n@d/b'
+    @p2.priority = -1
+
+    @i.status = @p
+    @i.status = @p2
+  end
+
+  it 'initializes groups to [nil] if the item is not part of a group' do
+    i = Blather::RosterItem.new 'n@d'
+    i.groups.must_equal [nil]
+  end
+end

data/spec/blather/roster_spec.rb

@@ -0,0 +1,103 @@
+require File.join(File.dirname(__FILE__), *%w[.. spec_helper])
+
+describe Blather::Roster do
+  before do
+    @stream = mock()
+    @stream.stubs(:write)
+
+    @stanza = mock()
+    items = []; 4.times { |n| items << Blather::JID.new("n@d/#{n}r") }
+    @stanza.stubs(:items).returns(items)
+
+    @roster = Blather::Roster.new(@stream, @stanza)
+  end
+
+  it 'initializes with items' do
+    @roster.items.map { |_,i| i.jid.to_s }.must_equal(@stanza.items.map { |i| i.stripped.to_s }.uniq)
+  end
+
+  it 'processes @stanzas with remove requests' do
+    s = @roster['n@d/0r']
+    s.subscription = :remove
+    proc { @roster.process(s.to_stanza) }.must_change('@roster.items.length', :by => -1)
+  end
+
+  it 'processes @stanzas with add requests' do
+    s = Blather::Stanza::Iq::Roster::RosterItem.new('a@b/c').to_stanza
+    proc { @roster.process(s) }.must_change('@roster.items.length', :by => 1)
+  end
+
+  it 'allows a jid to be pushed' do
+    jid = 'a@b/c'
+    proc { @roster.push(jid) }.must_change('@roster.items.length', :by => 1)
+    @roster[jid].wont_be_nil
+  end
+
+  it 'allows an item to be pushed' do
+    jid = 'a@b/c'
+    item = Blather::RosterItem.new(Blather::JID.new(jid))
+    proc { @roster.push(item) }.must_change('@roster.items.length', :by => 1)
+    @roster[jid].wont_be_nil
+  end
+
+  it 'aliases #<< to #push and returns self to allow for chaining' do
+    jid = 'a@b/c'
+    item = Blather::RosterItem.new(Blather::JID.new(jid))
+    jid2 = 'd@e/f'
+    item2 = Blather::RosterItem.new(Blather::JID.new(jid2))
+    proc { @roster << item << item2 }.must_change('@roster.items.length', :by => 2)
+    @roster[jid].wont_be_nil
+    @roster[jid2].wont_be_nil
+  end
+
+  it 'sends a @roster addition over the wire' do
+    client = mock(:write => nil)
+    roster = Blather::Roster.new client, @stanza
+    roster.push('a@b/c')
+  end
+
+  it 'removes a Blather::JID' do
+    proc { @roster.delete 'n@d' }.must_change('@roster.items.length', :by => -1)
+  end
+
+  it 'sends a @roster removal over the wire' do
+    client = mock(:write => nil)
+    roster = Blather::Roster.new client, @stanza
+    roster.delete('a@b/c')
+  end
+
+  it 'returns an item through []' do
+    item = @roster['n@d']
+    item.must_be_kind_of Blather::RosterItem
+    item.jid.must_equal Blather::JID.new('n@d')
+  end
+
+  it 'responds to #each' do
+    @roster.must_respond_to :each
+  end
+
+  it 'cycles through the items using #each' do
+    @roster.map { |i| i }.sort.must_equal(@roster.items.sort)
+  end
+
+  it 'returns a duplicate of items through #items' do
+    items = @roster.items
+    items.delete 'n@d'
+    items.wont_equal @roster.items
+  end
+
+  it 'will group roster items' do
+    @roster.delete 'n@d'
+    item1 = Blather::RosterItem.new("n1@d")
+    item1.groups = ['group1', 'group2']
+    item2 = Blather::RosterItem.new("n2@d")
+    item2.groups = ['group1', 'group3']
+    @roster << item1 << item2
+
+    @roster.grouped.must_equal({
+      'group1' => [item1, item2],
+      'group2' => [item1],
+      'group3' => [item2]
+    })
+  end
+end