blather 0.3.4 → 0.4.0

data/spec/blather/stanza/iq/query_spec.rb

@@ -1,41 +1,64 @@
 require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
 
-describe 'Blather::Stanza::Iq::Query' do
+describe Blather::Stanza::Iq::Query do
   it 'registers itself' do
-    XMPPNode.class_from_registration(:query, nil).must_equal Stanza::Iq::Query
+    Blather::XMPPNode.class_from_registration(:query, nil).must_equal Blather::Stanza::Iq::Query
+  end
+
+  it 'can be imported' do
+    doc = parse_stanza <<-XML
+      <iq from='juliet@example.com/balcony' type='set' id='roster_4'>
+        <query>
+          <item jid='nurse@example.com' subscription='remove'/>
+        </query>
+      </iq>
+    XML
+    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Iq::Query
   end
 
   it 'ensures a query node is present on create' do
-    query = Stanza::Iq::Query.new
-    query.children.detect { |n| n.element_name == 'query' }.wont_be_nil
+    query = Blather::Stanza::Iq::Query.new
+    query.xpath('query').wont_be_empty
   end
 
   it 'ensures a query node exists when calling #query' do
-    query = Stanza::Iq::Query.new
+    query = Blather::Stanza::Iq::Query.new
     query.remove_child :query
-    query.children.detect { |n| n.element_name == 'query' }.must_be_nil
+    query.xpath('query').must_be_empty
 
     query.query.wont_be_nil
-    query.children.detect { |n| n.element_name == 'query' }.wont_be_nil
+    query.xpath('query').wont_be_empty
   end
 
   [:get, :set, :result, :error].each do |type|
     it "can be set as \"#{type}\"" do
-      query = Stanza::Iq::Query.new type
+      query = Blather::Stanza::Iq::Query.new type
       query.type.must_equal type
     end
   end
 
   it 'sets type to "result" on reply' do
-    query = Stanza::Iq::Query.new
+    query = Blather::Stanza::Iq::Query.new
     query.type.must_equal :get
     reply = query.reply.type.must_equal :result
   end
 
   it 'sets type to "result" on reply!' do
-    query = Stanza::Iq::Query.new
+    query = Blather::Stanza::Iq::Query.new
     query.type.must_equal :get
     query.reply!
     query.type.must_equal :result
   end
-end
+
+  it 'can be registered under a namespace' do
+    class QueryNs < Blather::Stanza::Iq::Query; register :query_ns, nil, 'query:ns'; end
+    Blather::XMPPNode.class_from_registration(:query, 'query:ns').must_equal QueryNs
+    query_ns = QueryNs.new
+    query_ns.xpath('query').must_be_empty
+    query_ns.xpath('ns:query', :ns => 'query:ns').size.must_equal 1
+
+    query_ns.query
+    query_ns.query
+    query_ns.xpath('ns:query', :ns => 'query:ns').size.must_equal 1
+  end
+end

data/spec/blather/stanza/iq/roster_spec.rb

@@ -24,59 +24,76 @@ def roster_xml
 XML
 end
 
-describe 'Blather::Stanza::Iq::Roster' do
+describe Blather::Stanza::Iq::Roster do
   it 'registers itself' do
-    XMPPNode.class_from_registration(:query, 'jabber:iq:roster').must_equal Stanza::Iq::Roster
+    Blather::XMPPNode.class_from_registration(:query, 'jabber:iq:roster').must_equal Blather::Stanza::Iq::Roster
   end
 
   it 'ensures newly inherited items are RosterItem objects' do
-    n = XML::Document.string roster_xml
-    r = Stanza::Iq::Roster.new.inherit n.root
-    r.items.map { |i| i.class }.uniq.must_equal [Stanza::Iq::Roster::RosterItem]
+    n = parse_stanza roster_xml
+    r = Blather::Stanza::Iq::Roster.new.inherit n.root
+    r.items.map { |i| i.class }.uniq.must_equal [Blather::Stanza::Iq::Roster::RosterItem]
+  end
+
+  it 'can be created with #import' do
+    doc = parse_stanza roster_xml
+    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Iq::Roster
   end
 end
 
-describe 'Blather::Stanza::Iq::Roster::RosterItem' do
-  it 'can be initialized with just a JID' do
-    i = Stanza::Iq::Roster::RosterItem.new 'n@d/r'
-    i.jid.must_equal JID.new('n@d/r')
+describe Blather::Stanza::Iq::Roster::RosterItem do
+  it 'can be initialized with just a Blather::JID' do
+    i = Blather::Stanza::Iq::Roster::RosterItem.new 'n@d/r'
+    i.jid.must_equal Blather::JID.new('n@d/r')
   end
 
   it 'can be initialized with a name' do
-    i = Stanza::Iq::Roster::RosterItem.new nil, 'foobar'
+    i = Blather::Stanza::Iq::Roster::RosterItem.new nil, 'foobar'
     i.name.must_equal 'foobar'
   end
 
   it 'can be initialized with a subscription' do
-    i = Stanza::Iq::Roster::RosterItem.new nil, nil, :both
+    i = Blather::Stanza::Iq::Roster::RosterItem.new nil, nil, :both
     i.subscription.must_equal :both
   end
 
   it 'can be initialized with ask (subscription sub-type)' do
-    i = Stanza::Iq::Roster::RosterItem.new nil, nil, nil, :subscribe
+    i = Blather::Stanza::Iq::Roster::RosterItem.new nil, nil, nil, :subscribe
     i.ask.must_equal :subscribe
   end
 
+  it 'can be initailized with a hash' do
+    control = { :jid          => 'j@d/r',
+                :name         => 'name',
+                :subscription => :both,
+                :ask          => :subscribe }
+    i = Blather::Stanza::Iq::Roster::RosterItem.new control
+    i.jid.must_equal Blather::JID.new(control[:jid])
+    i.name.must_equal control[:name]
+    i.subscription.must_equal control[:subscription]
+    i.ask.must_equal control[:ask]
+  end
+
   it 'inherits a node when initialized with one' do
-    n = XMPPNode.new 'item'
-    n['jid'] = 'n@d/r'
-    n['subscription'] = 'both'
+    n = Blather::XMPPNode.new 'item'
+    n[:jid] = 'n@d/r'
+    n[:subscription] = 'both'
 
-    i = Stanza::Iq::Roster::RosterItem.new n
-    i.jid.must_equal JID.new('n@d/r')
+    i = Blather::Stanza::Iq::Roster::RosterItem.new n
+    i.jid.must_equal Blather::JID.new('n@d/r')
     i.subscription.must_equal :both
   end
 
   it 'has a #groups helper that gives an array of groups' do
-    n = XML::Document.string "<item jid='romeo@example.net' subscription='both'><group>foo</group><group>bar</group><group>baz</group></item>"
-    i = Stanza::Iq::Roster::RosterItem.new n.root
+    n = parse_stanza "<item jid='romeo@example.net' subscription='both'><group>foo</group><group>bar</group><group>baz</group></item>"
+    i = Blather::Stanza::Iq::Roster::RosterItem.new n.root
     i.must_respond_to :groups
     i.groups.sort.must_equal %w[bar baz foo]
   end
 
   it 'has a helper to set the groups' do
-    n = XML::Document.string "<item jid='romeo@example.net' subscription='both'><group>foo</group><group>bar</group><group>baz</group></item>"
-    i = Stanza::Iq::Roster::RosterItem.new n.root
+    n = parse_stanza "<item jid='romeo@example.net' subscription='both'><group>foo</group><group>bar</group><group>baz</group></item>"
+    i = Blather::Stanza::Iq::Roster::RosterItem.new n.root
     i.must_respond_to :groups=
     i.groups.sort.must_equal %w[bar baz foo]
     i.groups = %w[a b c]
@@ -85,38 +102,38 @@ describe 'Blather::Stanza::Iq::Roster::RosterItem' do
 
   it 'can be easily converted into a proper stanza' do
     xml = "<item jid='romeo@example.net' subscription='both'><group>foo</group><group>bar</group><group>baz</group></item>"
-    n = XML::Document.string xml
-    i = Stanza::Iq::Roster::RosterItem.new n.root
+    n = parse_stanza xml
+    i = Blather::Stanza::Iq::Roster::RosterItem.new n.root
     i.must_respond_to :to_stanza
     s = i.to_stanza
-    s.must_be_kind_of Stanza::Iq::Roster
-    s.items.first.jid.must_equal JID.new('romeo@example.net')
+    s.must_be_kind_of Blather::Stanza::Iq::Roster
+    s.items.first.jid.must_equal Blather::JID.new('romeo@example.net')
     s.items.first.groups.sort.must_equal %w[bar baz foo]
   end
 
   it 'has an "attr_accessor" for jid' do
-    i = Stanza::Iq::Roster::RosterItem.new
+    i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.must_respond_to :jid
     i.jid.must_be_nil
     i.must_respond_to :jid=
     i.jid = 'n@d/r'
-    i.jid.must_equal JID.new('n@d/r')
+    i.jid.must_equal Blather::JID.new('n@d/r')
   end
 
   it 'has a name attribute' do
-    i = Stanza::Iq::Roster::RosterItem.new
+    i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.name = 'name'
     i.name.must_equal 'name'
   end
 
   it 'has a subscription attribute' do
-    i = Stanza::Iq::Roster::RosterItem.new
+    i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.subscription = :both
     i.subscription.must_equal :both
   end
 
   it 'has an ask attribute' do
-    i = Stanza::Iq::Roster::RosterItem.new
+    i = Blather::Stanza::Iq::Roster::RosterItem.new
     i.ask = :subscribe
     i.ask.must_equal :subscribe
   end

data/spec/blather/stanza/iq_spec.rb

@@ -1,40 +1,45 @@
 require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
 
-describe 'Blather::Stanza::Iq' do
+describe Blather::Stanza::Iq do
   it 'registers itself' do
-    XMPPNode.class_from_registration(:iq, nil).must_equal Stanza::Iq
+    Blather::XMPPNode.class_from_registration(:iq, nil).must_equal Blather::Stanza::Iq
+  end
+
+  it 'must be importable' do
+    doc = parse_stanza "<iq from='juliet@example.com/balcony' type='set' id='roster_4'></iq>"
+    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Iq
   end
 
   it 'creates a new Iq stanza defaulted as a get' do
-    Stanza::Iq.new.type.must_equal :get
+    Blather::Stanza::Iq.new.type.must_equal :get
   end
 
-  it 'wont import non-iq stanzas' do
-    lambda { Stanza::Iq.import(XMPPNode.new('foo')) }.must_raise(Blather::ArgumentError)
+  it 'sets the id when created' do
+    Blather::Stanza::Iq.new.id.wont_be_nil
   end
 
   it 'creates a new Stanza::Iq object on import' do
-    Stanza::Iq.import(XMPPNode.new('iq')).must_be_kind_of Stanza::Iq
+    Blather::Stanza::Iq.import(Blather::XMPPNode.new('iq')).must_be_kind_of Blather::Stanza::Iq
   end
 
   it 'creates a proper object based on its children' do
-    n = XMPPNode.new('iq')
-    n << XMPPNode.new('query')
-    Stanza::Iq.import(n).must_be_kind_of Stanza::Iq::Query
+    n = Blather::XMPPNode.new('iq')
+    n << Blather::XMPPNode.new('query', n.document)
+    Blather::Stanza::Iq.import(n).must_be_kind_of Blather::Stanza::Iq::Query
   end
 
   it 'ensures type is one of Stanza::Iq::VALID_TYPES' do
-    lambda { Stanza::Iq.new :invalid_type_name }.must_raise(Blather::ArgumentError)
+    lambda { Blather::Stanza::Iq.new :invalid_type_name }.must_raise(Blather::ArgumentError)
 
-    Stanza::Iq::VALID_TYPES.each do |valid_type|
-      n = Stanza::Iq.new valid_type
+    Blather::Stanza::Iq::VALID_TYPES.each do |valid_type|
+      n = Blather::Stanza::Iq.new valid_type
       n.type.must_equal valid_type
     end
   end
 
-  Stanza::Iq::VALID_TYPES.each do |valid_type|
+  Blather::Stanza::Iq::VALID_TYPES.each do |valid_type|
     it "provides a helper (#{valid_type}?) for type #{valid_type}" do
-      Stanza::Iq.new.must_respond_to :"#{valid_type}?"
+      Blather::Stanza::Iq.new.must_respond_to :"#{valid_type}?"
     end
   end
 end

data/spec/blather/stanza/message_spec.rb

@@ -1,52 +1,65 @@
 require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
 
-describe 'Blather::Stanza::Message' do
+describe Blather::Stanza::Message do
   it 'registers itself' do
-    XMPPNode.class_from_registration(:message, nil).must_equal Stanza::Message
+    Blather::XMPPNode.class_from_registration(:message, nil).must_equal Blather::Stanza::Message
+  end
+
+  it 'must be importable' do
+    doc = parse_stanza <<-XML
+      <message
+          to='romeo@example.net'
+          from='juliet@example.com/balcony'
+          type='chat'
+          xml:lang='en'>
+        <body>Wherefore art thou, Romeo?</body>
+      </message>
+    XML
+    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Message
   end
 
   it 'provides "attr_accessor" for body' do
-    s = Stanza::Message.new
+    s = Blather::Stanza::Message.new
     s.body.must_be_nil
-    s.detect { |n| n.element_name == 'body' }.must_be_nil
+    s.xpath('body').must_be_empty
 
     s.body = 'test message'
     s.body.wont_be_nil
-    s.detect { |n| n.element_name == 'body' }.wont_be_nil
+    s.xpath('body').wont_be_empty
   end
 
   it 'provides "attr_accessor" for subject' do
-    s = Stanza::Message.new
+    s = Blather::Stanza::Message.new
     s.subject.must_be_nil
-    s.detect { |n| n.element_name == 'subject' }.must_be_nil
+    s.xpath('subject').must_be_empty
 
     s.subject = 'test subject'
     s.subject.wont_be_nil
-    s.detect { |n| n.element_name == 'subject' }.wont_be_nil
+    s.xpath('subject').wont_be_empty
   end
 
   it 'provides "attr_accessor" for thread' do
-    s = Stanza::Message.new
+    s = Blather::Stanza::Message.new
     s.thread.must_be_nil
-    s.detect { |n| n.element_name == 'thread' }.must_be_nil
+    s.xpath('thread').must_be_empty
 
     s.thread = 1234
     s.thread.wont_be_nil
-    s.detect { |n| n.element_name == 'thread' }.wont_be_nil
+    s.xpath('thread').wont_be_empty
   end
 
-  it 'ensures type is one of Stanza::Message::VALID_TYPES' do
-    lambda { Stanza::Message.new nil, nil, :invalid_type_name }.must_raise(Blather::ArgumentError)
+  it 'ensures type is one of Blather::Stanza::Message::VALID_TYPES' do
+    lambda { Blather::Stanza::Message.new nil, nil, :invalid_type_name }.must_raise(Blather::ArgumentError)
 
-    Stanza::Message::VALID_TYPES.each do |valid_type|
-      msg = Stanza::Message.new nil, nil, valid_type
+    Blather::Stanza::Message::VALID_TYPES.each do |valid_type|
+      msg = Blather::Stanza::Message.new nil, nil, valid_type
       msg.type.must_equal valid_type
     end
   end
 
-  Stanza::Message::VALID_TYPES.each do |valid_type|
+  Blather::Stanza::Message::VALID_TYPES.each do |valid_type|
     it "provides a helper (#{valid_type}?) for type #{valid_type}" do
-      Stanza::Message.new.must_respond_to :"#{valid_type}?"
+      Blather::Stanza::Message.new.must_respond_to :"#{valid_type}?"
     end
   end
 end

data/spec/blather/stanza/presence/status_spec.rb

@@ -1,22 +1,32 @@
 require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
 
-describe 'Blather::Stanza::Presence::Status' do
+describe Blather::Stanza::Presence::Status do
   it 'registers itself' do
-    XMPPNode.class_from_registration(:status, nil).must_equal Stanza::Presence::Status
+    Blather::XMPPNode.class_from_registration(:status, nil).must_equal Blather::Stanza::Presence::Status
+  end
+
+  it 'must be importable as unavailable' do
+    doc = parse_stanza '<presence type="unavailable"/>'
+    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Presence::Status
+  end
+
+  it 'must be importable as nil' do
+    doc = parse_stanza '<presence/>'
+    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Presence::Status
   end
 
   it 'can set state on creation' do
-    status = Stanza::Presence::Status.new :away
+    status = Blather::Stanza::Presence::Status.new :away
     status.state.must_equal :away
   end
 
   it 'can set a message on creation' do
-    status = Stanza::Presence::Status.new nil, 'Say hello!'
+    status = Blather::Stanza::Presence::Status.new nil, 'Say hello!'
     status.message.must_equal 'Say hello!'
   end
 
   it 'ensures type is nil or :unavailable' do
-    status = Stanza::Presence::Status.new
+    status = Blather::Stanza::Presence::Status.new
     lambda { status.type = :invalid_type_name }.must_raise(Blather::ArgumentError)
 
     [nil, :unavailable].each do |valid_type|
@@ -26,35 +36,35 @@ describe 'Blather::Stanza::Presence::Status' do
   end
 
   it 'ensures state is one of Presence::Status::VALID_STATES' do
-    status = Stanza::Presence::Status.new
+    status = Blather::Stanza::Presence::Status.new
     lambda { status.state = :invalid_type_name }.must_raise(Blather::ArgumentError)
 
-    Stanza::Presence::Status::VALID_STATES.each do |valid_state|
+    Blather::Stanza::Presence::Status::VALID_STATES.each do |valid_state|
       status.state = valid_state
       status.state.must_equal valid_state
     end
   end
 
   it 'returns :available if state is nil' do
-    Stanza::Presence::Status.new.state.must_equal :available
+    Blather::Stanza::Presence::Status.new.state.must_equal :available
   end
 
   it 'returns :unavailable if type is :unavailable' do
-    status = Stanza::Presence::Status.new
+    status = Blather::Stanza::Presence::Status.new
     status.type = :unavailable
     status.state.must_equal :unavailable
   end
 
   it 'ensures priority is not greater than 127' do
-    lambda { Stanza::Presence::Status.new.priority = 128 }.must_raise(Blather::ArgumentError)
+    lambda { Blather::Stanza::Presence::Status.new.priority = 128 }.must_raise(Blather::ArgumentError)
   end
 
   it 'ensures priority is not less than -128' do
-    lambda { Stanza::Presence::Status.new.priority = -129 }.must_raise(Blather::ArgumentError)
+    lambda { Blather::Stanza::Presence::Status.new.priority = -129 }.must_raise(Blather::ArgumentError)
   end
 
   it 'has "attr_accessor" for priority' do
-    status = Stanza::Presence::Status.new
+    status = Blather::Stanza::Presence::Status.new
     status.priority.must_equal 0
 
     status.priority = 10
@@ -63,7 +73,7 @@ describe 'Blather::Stanza::Presence::Status' do
   end
 
   it 'has "attr_accessor" for message' do
-    status = Stanza::Presence::Status.new
+    status = Blather::Stanza::Presence::Status.new
     status.message.must_be_nil
 
     status.message = 'new message'
@@ -72,12 +82,12 @@ describe 'Blather::Stanza::Presence::Status' do
   end
 
   it 'must be comparable by priority' do
-    jid = JID.new 'a@b/c'
+    jid = Blather::JID.new 'a@b/c'
 
-    status1 = Stanza::Presence::Status.new
+    status1 = Blather::Stanza::Presence::Status.new
     status1.from = jid
 
-    status2 = Stanza::Presence::Status.new
+    status2 = Blather::Stanza::Presence::Status.new
     status2.from = jid
 
     status1.priority = 1
@@ -89,14 +99,27 @@ describe 'Blather::Stanza::Presence::Status' do
     (status1 <=> status2).must_equal 0
   end
 
-  it 'raises an argument error if compared to a status with a different JID' do
-    status1 = Stanza::Presence::Status.new
+  it 'raises an argument error if compared to a status with a different Blather::JID' do
+    status1 = Blather::Stanza::Presence::Status.new
     status1.from = 'a@b/c'
 
-    status2 = Stanza::Presence::Status.new
+    status2 = Blather::Stanza::Presence::Status.new
     status2.from = 'd@e/f'
 
     lambda { status1 <=> status2 }.must_raise(Blather::ArgumentError)
   end
-end
 
+  Blather::Stanza::Presence::Status::VALID_STATES.each do |valid_state|
+    it "provides a helper (#{valid_state}?) for state #{valid_state}" do
+      Blather::Stanza::Presence::Status.new.must_respond_to :"#{valid_state}?"
+    end
+
+    it "returns true on call to (#{valid_state}?) if state == #{valid_state}" do
+      method = "#{valid_state}?".to_sym
+      stat = Blather::Stanza::Presence::Status.new
+      stat.state = valid_state
+      stat.must_respond_to method
+      stat.__send__(method).must_equal true
+    end
+  end
+end