blather 0.6.2 → 0.7.0

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

@@ -13,34 +13,44 @@ end
 
 describe 'Blather::Stanza::Presence::C' do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:c, 'http://jabber.org/protocol/caps' ).must_equal Blather::Stanza::Presence::C
+    Blather::XMPPNode.class_from_registration(:c, 'http://jabber.org/protocol/caps' ).should == Blather::Stanza::Presence::C
   end
 
   it 'must be importable' do
-    c = Blather::XMPPNode.import(parse_stanza(c_xml).root).must_be_instance_of Blather::Stanza::Presence::C
+    c = Blather::XMPPNode.parse c_xml
+    c.should be_kind_of Blather::Stanza::Presence::C::InstanceMethods
+    c.hash.should == :'sha-1'
+    c.node.should == 'http://www.chatopus.com'
+    c.ver.should == 'zHyEOgxTrkpSdGcQKH8EFPLsriY='
   end
 
   it 'ensures hash is one of Blather::Stanza::Presence::C::VALID_HASH_TYPES' do
-    lambda { Blather::Stanza::Presence::C.new nil, nil, :invalid_type_name }.must_raise(Blather::ArgumentError)
+    lambda { Blather::Stanza::Presence::C.new nil, nil, :invalid_type_name }.should raise_error(Blather::ArgumentError)
 
     Blather::Stanza::Presence::C::VALID_HASH_TYPES.each do |valid_hash|
       c = Blather::Stanza::Presence::C.new nil, nil, valid_hash
-      c.hash.must_equal valid_hash.to_sym
+      c.hash.should == valid_hash.to_sym
     end
   end
 
   it 'can set a hash on creation' do
     c = Blather::Stanza::Presence::C.new nil, nil, :md5
-    c.hash.must_equal :md5
+    c.hash.should == :md5
   end
 
   it 'can set a node on creation' do
     c = Blather::Stanza::Presence::C.new 'http://www.chatopus.com'
-    c.node.must_equal 'http://www.chatopus.com'
+    c.node.should == 'http://www.chatopus.com'
   end
 
   it 'can set a ver on creation' do
     c = Blather::Stanza::Presence::C.new nil, 'zHyEOgxTrkpSdGcQKH8EFPLsriY='
-    c.ver.must_equal 'zHyEOgxTrkpSdGcQKH8EFPLsriY='
+    c.ver.should == 'zHyEOgxTrkpSdGcQKH8EFPLsriY='
+  end
+
+  it 'is equal on import and creation' do
+    p = Blather::XMPPNode.parse c_xml
+    c = Blather::Stanza::Presence::C.new 'http://www.chatopus.com', 'zHyEOgxTrkpSdGcQKH8EFPLsriY=', 'sha-1'
+    p.should == c
   end
 end

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

@@ -12,26 +12,26 @@ end
 
 describe 'Blather::Stanza::Presence::MUC' do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:x, 'http://jabber.org/protocol/muc' ).must_equal Blather::Stanza::Presence::MUC
+    Blather::XMPPNode.class_from_registration(:x, 'http://jabber.org/protocol/muc' ).should == Blather::Stanza::Presence::MUC
   end
 
   it 'must be importable' do
-    c = Blather::XMPPNode.import(parse_stanza(muc_xml).root)
-    c.must_be_instance_of Blather::Stanza::Presence::MUC
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).count.must_equal 1
+    c = Blather::XMPPNode.parse(muc_xml)
+    c.should be_kind_of Blather::Stanza::Presence::MUC::InstanceMethods
+    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).count.should == 1
   end
 
   it 'ensures a form node is present on create' do
     c = Blather::Stanza::Presence::MUC.new
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).wont_be_empty
+    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).should_not be_empty
   end
 
   it 'ensures a form node exists when calling #muc' do
     c = Blather::Stanza::Presence::MUC.new
     c.remove_children :x
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).must_be_empty
+    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).should be_empty
 
-    c.muc.wont_be_nil
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).wont_be_empty
+    c.muc.should_not be_nil
+    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUC.registered_ns).should_not be_empty
   end
 end

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

@@ -19,65 +19,65 @@ end
 
 describe 'Blather::Stanza::Presence::MUCUser' do
   it 'must be importable' do
-    muc_user = Blather::XMPPNode.import(parse_stanza(muc_user_xml).root)
-    muc_user.must_be_instance_of Blather::Stanza::Presence::MUCUser
-    muc_user.affiliation.must_equal :none
-    muc_user.jid.must_equal 'hag66@shakespeare.lit/pda'
-    muc_user.role.must_equal :participant
-    muc_user.status_codes.must_equal [100, 110]
-    muc_user.password.must_equal 'foobar'
+    muc_user = Blather::XMPPNode.parse(muc_user_xml)
+    muc_user.should be_kind_of Blather::Stanza::Presence::MUCUser::InstanceMethods
+    muc_user.affiliation.should == :none
+    muc_user.jid.should == 'hag66@shakespeare.lit/pda'
+    muc_user.role.should == :participant
+    muc_user.status_codes.should == [100, 110]
+    muc_user.password.should == 'foobar'
   end
 
   it 'ensures a form node is present on create' do
     c = Blather::Stanza::Presence::MUCUser.new
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUCUser.registered_ns).wont_be_empty
+    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUCUser.registered_ns).should_not be_empty
   end
 
   it 'ensures a form node exists when calling #muc' do
     c = Blather::Stanza::Presence::MUCUser.new
     c.remove_children :x
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUCUser.registered_ns).must_be_empty
+    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUCUser.registered_ns).should be_empty
 
-    c.muc_user.wont_be_nil
-    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUCUser.registered_ns).wont_be_empty
+    c.muc_user.should_not be_nil
+    c.xpath('ns:x', :ns => Blather::Stanza::Presence::MUCUser.registered_ns).should_not be_empty
   end
 
   it "must be able to set the affiliation" do
     muc_user = Blather::Stanza::Presence::MUCUser.new
-    muc_user.affiliation.must_equal nil
+    muc_user.affiliation.should == nil
     muc_user.affiliation = :none
-    muc_user.affiliation.must_equal :none
+    muc_user.affiliation.should == :none
   end
 
   it "must be able to set the role" do
     muc_user = Blather::Stanza::Presence::MUCUser.new
-    muc_user.role.must_equal nil
+    muc_user.role.should == nil
     muc_user.role = :participant
-    muc_user.role.must_equal :participant
+    muc_user.role.should == :participant
   end
 
   it "must be able to set the jid" do
     muc_user = Blather::Stanza::Presence::MUCUser.new
-    muc_user.jid.must_equal nil
+    muc_user.jid.should == nil
     muc_user.jid = 'foo@bar.com'
-    muc_user.jid.must_equal 'foo@bar.com'
+    muc_user.jid.should == 'foo@bar.com'
   end
 
   it "must be able to set the status codes" do
     muc_user = Blather::Stanza::Presence::MUCUser.new
-    muc_user.status_codes.must_equal []
+    muc_user.status_codes.should == []
     muc_user.status_codes = [100, 110]
-    muc_user.status_codes.must_equal [100, 110]
+    muc_user.status_codes.should == [100, 110]
     muc_user.status_codes = [500]
-    muc_user.status_codes.must_equal [500]
+    muc_user.status_codes.should == [500]
   end
 
   it "must be able to set the password" do
     muc_user = Blather::Stanza::Presence::MUCUser.new
-    muc_user.password.must_equal nil
+    muc_user.password.should == nil
     muc_user.password = 'barbaz'
-    muc_user.password.must_equal 'barbaz'
+    muc_user.password.should == 'barbaz'
     muc_user.password = 'hello_world'
-    muc_user.password.must_equal 'hello_world'
+    muc_user.password.should == 'hello_world'
   end
 end

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

@@ -2,90 +2,102 @@ require 'spec_helper'
 
 describe Blather::Stanza::Presence::Status do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:status, nil).must_equal Blather::Stanza::Presence::Status
+    Blather::XMPPNode.class_from_registration(:status, nil).should == 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
+    Blather::XMPPNode.parse('<presence type="unavailable"/>').should be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
   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
+    Blather::XMPPNode.parse('<presence/>').should be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
+  end
+
+  it 'must be importable with show, status and priority children' do
+    n = Blather::XMPPNode.parse <<-XML
+      <presence from='bard@shakespeare.lit/globe'>
+        <show>chat</show>
+        <status>Talk to me!</status>
+        <priority>10</priority>
+      </presence>
+    XML
+    n.should be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
+    n.state.should == :chat
+    n.message.should == 'Talk to me!'
+    n.priority.should == 10
   end
 
   it 'can set state on creation' do
     status = Blather::Stanza::Presence::Status.new :away
-    status.state.must_equal :away
+    status.state.should == :away
   end
 
   it 'can set a message on creation' do
     status = Blather::Stanza::Presence::Status.new nil, 'Say hello!'
-    status.message.must_equal 'Say hello!'
+    status.message.should == 'Say hello!'
   end
 
   it 'ensures type is nil or :unavailable' do
     status = Blather::Stanza::Presence::Status.new
-    lambda { status.type = :invalid_type_name }.must_raise(Blather::ArgumentError)
+    lambda { status.type = :invalid_type_name }.should raise_error(Blather::ArgumentError)
 
     [nil, :unavailable].each do |valid_type|
       status.type = valid_type
-      status.type.must_equal valid_type
+      status.type.should == valid_type
     end
   end
 
   it 'ensures state is one of Presence::Status::VALID_STATES' do
     status = Blather::Stanza::Presence::Status.new
-    lambda { status.state = :invalid_type_name }.must_raise(Blather::ArgumentError)
+    lambda { status.state = :invalid_type_name }.should raise_error(Blather::ArgumentError)
 
     Blather::Stanza::Presence::Status::VALID_STATES.each do |valid_state|
       status.state = valid_state
-      status.state.must_equal valid_state
+      status.state.should == valid_state
     end
   end
 
   it 'returns :available if state is nil' do
-    Blather::Stanza::Presence::Status.new.state.must_equal :available
+    Blather::Stanza::Presence::Status.new.state.should == :available
   end
 
   it 'returns :available if <show/> is blank' do
-    status = Blather::XMPPNode.import(parse_stanza(<<-NODE).root)
+    status = Blather::XMPPNode.parse(<<-NODE)
       <presence><show/></presence>
     NODE
-    status.state.must_equal :available
+    status.state.should == :available
   end
 
   it 'returns :unavailable if type is :unavailable' do
     status = Blather::Stanza::Presence::Status.new
     status.type = :unavailable
-    status.state.must_equal :unavailable
+    status.state.should == :unavailable
   end
 
   it 'ensures priority is not greater than 127' do
-    lambda { Blather::Stanza::Presence::Status.new.priority = 128 }.must_raise(Blather::ArgumentError)
+    lambda { Blather::Stanza::Presence::Status.new.priority = 128 }.should raise_error(Blather::ArgumentError)
   end
 
   it 'ensures priority is not less than -128' do
-    lambda { Blather::Stanza::Presence::Status.new.priority = -129 }.must_raise(Blather::ArgumentError)
+    lambda { Blather::Stanza::Presence::Status.new.priority = -129 }.should raise_error(Blather::ArgumentError)
   end
 
   it 'has "attr_accessor" for priority' do
     status = Blather::Stanza::Presence::Status.new
-    status.priority.must_equal 0
+    status.priority.should == 0
 
     status.priority = 10
-    status.children.detect { |n| n.element_name == 'priority' }.wont_be_nil
-    status.priority.must_equal 10
+    status.children.detect { |n| n.element_name == 'priority' }.should_not be_nil
+    status.priority.should == 10
   end
 
   it 'has "attr_accessor" for message' do
     status = Blather::Stanza::Presence::Status.new
-    status.message.must_be_nil
+    status.message.should be_nil
 
     status.message = 'new message'
-    status.children.detect { |n| n.element_name == 'status' }.wont_be_nil
-    status.message.must_equal 'new message'
+    status.children.detect { |n| n.element_name == 'status' }.should_not be_nil
+    status.message.should == 'new message'
   end
 
   it 'must be comparable by priority' do
@@ -99,11 +111,11 @@ describe Blather::Stanza::Presence::Status do
 
     status1.priority = 1
     status2.priority = -1
-    (status1 <=> status2).must_equal 1
-    (status2 <=> status1).must_equal -1
+    (status1 <=> status2).should == 1
+    (status2 <=> status1).should == -1
 
     status2.priority = 1
-    (status1 <=> status2).must_equal 0
+    (status1 <=> status2).should == 0
   end
 
   it 'raises an argument error if compared to a status with a different Blather::JID' do
@@ -113,20 +125,20 @@ describe Blather::Stanza::Presence::Status do
     status2 = Blather::Stanza::Presence::Status.new
     status2.from = 'd@e/f'
 
-    lambda { status1 <=> status2 }.must_raise(Blather::ArgumentError)
+    lambda { status1 <=> status2 }.should raise_error(Blather::ArgumentError)
   end
 
   ([:available] + 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}?"
+      Blather::Stanza::Presence::Status.new.should 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
+      stat.should respond_to method
+      stat.__send__(method).should == true
     end
   end
 end

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

@@ -2,29 +2,28 @@ require 'spec_helper'
 
 describe Blather::Stanza::Presence::Subscription do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:subscription, nil).must_equal Blather::Stanza::Presence::Subscription
+    Blather::XMPPNode.class_from_registration(:subscription, nil).should == Blather::Stanza::Presence::Subscription
   end
 
   [:subscribe, :subscribed, :unsubscribe, :unsubscribed].each do |type|
     it "must be importable as #{type}" do
-      doc = parse_stanza "<presence type='#{type}'/>"
-      Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Presence::Subscription
+      Blather::XMPPNode.parse("<presence type='#{type}'/>").should be_kind_of Blather::Stanza::Presence::Subscription::InstanceMethods
     end
   end
 
   it 'can set to on creation' do
     sub = Blather::Stanza::Presence::Subscription.new 'a@b'
-    sub.to.to_s.must_equal 'a@b'
+    sub.to.to_s.should == 'a@b'
   end
 
   it 'can set a type on creation' do
     sub = Blather::Stanza::Presence::Subscription.new nil, :subscribed
-    sub.type.must_equal :subscribed
+    sub.type.should == :subscribed
   end
 
   it 'strips Blather::JIDs when setting #to' do
     sub = Blather::Stanza::Presence::Subscription.new 'a@b/c'
-    sub.to.to_s.must_equal 'a@b'
+    sub.to.to_s.should == 'a@b'
   end
 
   it 'generates an approval using #approve!' do
@@ -32,8 +31,8 @@ describe Blather::Stanza::Presence::Subscription do
     sub = Blather::Stanza::Presence::Subscription.new
     sub.from = jid
     sub.approve!
-    sub.to.must_equal jid
-    sub.type.must_equal :subscribed
+    sub.to.should == jid
+    sub.type.should == :subscribed
   end
 
   it 'generates a refusal using #refuse!' do
@@ -41,8 +40,8 @@ describe Blather::Stanza::Presence::Subscription do
     sub = Blather::Stanza::Presence::Subscription.new
     sub.from = jid
     sub.refuse!
-    sub.to.must_equal jid
-    sub.type.must_equal :unsubscribed
+    sub.to.should == jid
+    sub.type.should == :unsubscribed
   end
 
   it 'generates an unsubscript using #unsubscribe!' do
@@ -50,8 +49,8 @@ describe Blather::Stanza::Presence::Subscription do
     sub = Blather::Stanza::Presence::Subscription.new
     sub.from = jid
     sub.unsubscribe!
-    sub.to.must_equal jid
-    sub.type.must_equal :unsubscribe
+    sub.to.should == jid
+    sub.type.should == :unsubscribe
   end
 
   it 'generates a cancellation using #cancel!' do
@@ -59,8 +58,8 @@ describe Blather::Stanza::Presence::Subscription do
     sub = Blather::Stanza::Presence::Subscription.new
     sub.from = jid
     sub.cancel!
-    sub.to.must_equal jid
-    sub.type.must_equal :unsubscribed
+    sub.to.should == jid
+    sub.type.should == :unsubscribed
   end
 
   it 'generates a request using #request!' do
@@ -68,15 +67,15 @@ describe Blather::Stanza::Presence::Subscription do
     sub = Blather::Stanza::Presence::Subscription.new
     sub.from = jid
     sub.request!
-    sub.to.must_equal jid
-    sub.type.must_equal :subscribe
+    sub.to.should == jid
+    sub.type.should == :subscribe
   end
 
   it 'has a #request? helper' do
     sub = Blather::Stanza::Presence::Subscription.new
-    sub.must_respond_to :request?
+    sub.should respond_to :request?
     sub.type = :subscribe
-    sub.request?.must_equal true
+    sub.request?.should == true
   end
 
   it "successfully routes chained actions" do
@@ -87,9 +86,9 @@ describe Blather::Stanza::Presence::Subscription do
     sub.to = to
     sub.cancel!
     sub.unsubscribe!
-    sub.type.must_equal :unsubscribe
-    sub.to.must_equal from
-    sub.from.must_equal to
+    sub.type.should == :unsubscribe
+    sub.to.should == from
+    sub.from.should == to
   end
 
   it "will inherit only another node's attributes" do
@@ -97,9 +96,9 @@ describe Blather::Stanza::Presence::Subscription do
     inheritable[:bar] = 'baz'
 
     sub = Blather::Stanza::Presence::Subscription.new
-    sub.must_respond_to :inherit
+    sub.should respond_to :inherit
 
     sub.inherit inheritable
-    sub[:bar].must_equal 'baz'
+    sub[:bar].should == 'baz'
   end
 end