blather 0.6.2 → 0.7.0

data/spec/blather/roster_item_spec.rb

@@ -4,68 +4,68 @@ 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
+    i.jid.should == 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
+    i.jid.should == 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
+    i.jid.should == 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
+    Blather::RosterItem.new(control).should be 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
+    i.jid.should == 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
+    i.subscription.should == :remove
   end
 
   it 'forces the type of subscription' do
-    proc { Blather::RosterItem.new(nil).subscription = 'foo' }.must_raise Blather::ArgumentError
+    proc { Blather::RosterItem.new(nil).subscription = 'foo' }.should raise_error Blather::ArgumentError
   end
 
   it 'returns :none if the subscription field is blank' do
-    Blather::RosterItem.new(nil).subscription.must_equal :none
+    Blather::RosterItem.new(nil).subscription.should == :none
   end
 
   it 'ensure #ask is a symbol' do
     i = Blather::RosterItem.new(nil)
     i.ask = 'subscribe'
-    i.ask.must_equal :subscribe
+    i.ask.should == :subscribe
   end
 
   it 'forces #ask to be :subscribe or nothing at all' do
-    proc { Blather::RosterItem.new(nil).ask = 'foo' }.must_raise Blather::ArgumentError
+    proc { Blather::RosterItem.new(nil).ask = 'foo' }.should raise_error 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
+    s.should be_kind_of Blather::Stanza::Iq::Roster
+    s.items.first.jid.should == jid.stripped
   end
 
   it 'returns status based on priority' do
     setup_item_with_presences
-    @i.status.must_equal @p3
+    @i.status.should == @p3
   end
 
   it 'returns status based on priority and state' do
@@ -77,12 +77,12 @@ describe Blather::RosterItem do
     @p4.priority = 15
     @i.status = @p4
 
-    @i.status.must_equal @p3
+    @i.status.should == @p3
   end
 
   it 'returns status based on resource' do
     setup_item_with_presences
-    @i.status('a').must_equal @p
+    @i.status('a').should == @p
   end
 
   def setup_item_with_presences
@@ -116,12 +116,12 @@ describe Blather::RosterItem do
       @i.status = p
     end
 
-    @i.statuses.size.must_equal 4
+    @i.statuses.size.should == 4
   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]
+    i.groups.should == [nil]
   end
 
   it 'can determine equality' do
@@ -129,6 +129,6 @@ describe Blather::RosterItem do
     item2 = Blather::RosterItem.new 'n@d'
     item1.groups = %w[group1 group2]
     item2.groups = %w[group1 group2]
-    (item1 == item2).must_equal true
+    (item1 == item2).should == true
   end
 end

data/spec/blather/roster_spec.rb

@@ -13,31 +13,31 @@ describe Blather::Roster do
   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)
+    @roster.items.map { |_,i| i.jid.to_s }.should == (@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)
+    proc { @roster.process(s.to_stanza) }.should change(@roster, :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)
+    proc { @roster.process(s) }.should change(@roster, :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
+    proc { @roster.push(jid) }.should change(@roster, :length).by 1
+    @roster[jid].should_not 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
+    proc { @roster.push(item) }.should change(@roster, :length).by 1
+    @roster[jid].should_not be_nil
   end
 
   it 'aliases #<< to #push and returns self to allow for chaining' do
@@ -45,9 +45,9 @@ describe Blather::Roster do
     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
+    proc { @roster << item << item2 }.should change(@roster, :length).by 2
+    @roster[jid].should_not be_nil
+    @roster[jid2].should_not be_nil
   end
 
   it 'sends a @roster addition over the wire' do
@@ -57,7 +57,7 @@ describe Blather::Roster do
   end
 
   it 'removes a Blather::JID' do
-    proc { @roster.delete 'n@d' }.must_change('@roster.items.length', :by => -1)
+    proc { @roster.delete 'n@d' }.should change(@roster, :length).by -1
   end
 
   it 'sends a @roster removal over the wire' do
@@ -68,26 +68,26 @@ describe Blather::Roster do
 
   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')
+    item.should be_kind_of Blather::RosterItem
+    item.jid.should == Blather::JID.new('n@d')
   end
 
   it 'responds to #each' do
-    @roster.must_respond_to :each
+    @roster.should respond_to :each
   end
 
   it 'cycles through all the items using #each' do
-    @roster.map { |i| i }.sort.must_equal(@roster.items.values.sort)
+    @roster.map { |i| i }.sort.should ==(@roster.items.values.sort)
   end
 
   it 'yields RosterItems from #each' do
-    @roster.map { |i| i.must_be_kind_of Blather::RosterItem }
+    @roster.map { |i| i.should be_kind_of Blather::RosterItem }
   end
 
   it 'returns a duplicate of items through #items' do
     items = @roster.items
     items.delete 'n@d'
-    items.wont_equal @roster.items
+    items.should_not equal @roster.items
   end
 
   it 'will group roster items' do
@@ -98,7 +98,7 @@ describe Blather::Roster do
     item2.groups = ['group1', 'group3']
     @roster << item1 << item2
 
-    @roster.grouped.must_equal({
+    @roster.grouped.should ==({
       'group1' => [item1, item2],
       'group2' => [item1],
       'group3' => [item2]

data/spec/blather/stanza/discos/disco_info_spec.rb

@@ -21,61 +21,60 @@ end
 
 describe Blather::Stanza::Iq::DiscoInfo do
   it 'registers itself' do
-    Blather::XMPPNode.class_from_registration(:query, 'http://jabber.org/protocol/disco#info').must_equal Blather::Stanza::Iq::DiscoInfo
+    Blather::XMPPNode.class_from_registration(:query, 'http://jabber.org/protocol/disco#info').should == Blather::Stanza::Iq::DiscoInfo
   end
 
   it 'must be importable' do
-    doc = parse_stanza disco_info_xml
-    Blather::XMPPNode.import(doc.root).must_be_instance_of Blather::Stanza::Iq::DiscoInfo
+    Blather::XMPPNode.parse(disco_info_xml).should be_instance_of Blather::Stanza::Iq::DiscoInfo
   end
 
   it 'has a node attribute' do
     n = Blather::Stanza::Iq::DiscoInfo.new nil, 'music', [], []
-    n.node.must_equal 'music'
+    n.node.should == 'music'
     n.node = :foo
-    n.node.must_equal 'foo'
+    n.node.should == 'foo'
   end
 
   it 'inherits a list of identities' do
     n = parse_stanza disco_info_xml
     r = Blather::Stanza::Iq::DiscoInfo.new.inherit n.root
-    r.identities.size.must_equal 1
-    r.identities.map { |i| i.class }.uniq.must_equal [Blather::Stanza::Iq::DiscoInfo::Identity]
+    r.identities.size.should == 1
+    r.identities.map { |i| i.class }.uniq.should == [Blather::Stanza::Iq::DiscoInfo::Identity]
   end
 
   it 'inherits a list of features' do
     n = parse_stanza disco_info_xml
     r = Blather::Stanza::Iq::DiscoInfo.new.inherit n.root
-    r.features.size.must_equal 2
-    r.features.map { |i| i.class }.uniq.must_equal [Blather::Stanza::Iq::DiscoInfo::Feature]
+    r.features.size.should == 2
+    r.features.map { |i| i.class }.uniq.should == [Blather::Stanza::Iq::DiscoInfo::Feature]
   end
 
   it 'is constructed properly' do
     n = Blather::Stanza::Iq::DiscoInfo.new :get, '/path/to/node'
     n.to = 'to@jid.com'
-    n.find("/iq[@to='to@jid.com' and @type='get' and @id='#{n.id}']/ns:query[@node='/path/to/node']", :ns => Blather::Stanza::Iq::DiscoInfo.registered_ns).wont_be_empty
+    n.find("/iq[@to='to@jid.com' and @type='get' and @id='#{n.id}']/ns:query[@node='/path/to/node']", :ns => Blather::Stanza::Iq::DiscoInfo.registered_ns).should_not be_empty
   end
 
   it 'allows adding of identities' do
     di = Blather::Stanza::Iq::DiscoInfo.new
-    di.identities.size.must_equal 0
+    di.identities.size.should == 0
     di.identities = [{:name => 'name', :type => 'type', :category => 'category'}]
-    di.identities.size.must_equal 1
+    di.identities.size.should == 1
     di.identities += [Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category])]
-    di.identities.size.must_equal 2
+    di.identities.size.should == 2
     di.identities = nil
-    di.identities.size.must_equal 0
+    di.identities.size.should == 0
   end
 
   it 'allows adding of features' do
     di = Blather::Stanza::Iq::DiscoInfo.new
-    di.features.size.must_equal 0
+    di.features.size.should == 0
     di.features = ["feature1"]
-    di.features.size.must_equal 1
+    di.features.size.should == 1
     di.features += [Blather::Stanza::Iq::DiscoInfo::Feature.new("feature2")]
-    di.features.size.must_equal 2
+    di.features.size.should == 2
     di.features = nil
-    di.features.size.must_equal 0
+    di.features.size.should == 0
   end
 
 end
@@ -91,8 +90,8 @@ describe 'Blather::Stanza::Iq::DiscoInfo identities' do
                 Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1])]
 
     di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, ids
-    di.identities.size.must_equal 2
-    di.identities.each { |i| control.include?(i).must_equal true }
+    di.identities.size.should == 2
+    di.identities.each { |i| control.include?(i).should == true }
   end
 
   it 'takes a list of Identity objects as identities' do
@@ -100,24 +99,24 @@ describe 'Blather::Stanza::Iq::DiscoInfo identities' do
                 Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1])]
 
     di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, control
-    di.identities.size.must_equal 2
-    di.identities.each { |i| control.include?(i).must_equal true }
+    di.identities.size.should == 2
+    di.identities.each { |i| control.include?(i).should == true }
   end
 
   it 'takes a single hash as identity' do
     control = [Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category])]
 
     di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, {:name => 'name', :type => 'type', :category => 'category'}
-    di.identities.size.must_equal 1
-    di.identities.each { |i| control.include?(i).must_equal true }
+    di.identities.size.should == 1
+    di.identities.each { |i| control.include?(i).should == true }
   end
 
   it 'takes a single identity object as identity' do
     control = [Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type category])]
 
     di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, control.first
-    di.identities.size.must_equal 1
-    di.identities.each { |i| control.include?(i).must_equal true }
+    di.identities.size.should == 1
+    di.identities.each { |i| control.include?(i).should == true }
   end
 
   it 'takes a mix of hashes and identity objects as identities' do
@@ -130,8 +129,8 @@ describe 'Blather::Stanza::Iq::DiscoInfo identities' do
                 Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name1 type1 category1])]
 
     di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, ids
-    di.identities.size.must_equal 2
-    di.identities.each { |i| control.include?(i).must_equal true }
+    di.identities.size.should == 2
+    di.identities.each { |i| control.include?(i).should == true }
   end
 end
 
@@ -141,8 +140,8 @@ describe 'Blather::Stanza::Iq::DiscoInfo features' do
     control = features.map { |f| Blather::Stanza::Iq::DiscoInfo::Feature.new f }
 
     di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, [], features
-    di.features.size.must_equal 3
-    di.features.each { |f| control.include?(f).must_equal true }
+    di.features.size.should == 3
+    di.features.each { |f| control.include?(f).should == true }
   end
 
   it 'takes a list of features as Feature objects' do
@@ -150,24 +149,24 @@ describe 'Blather::Stanza::Iq::DiscoInfo features' do
     control = features.map { |f| Blather::Stanza::Iq::DiscoInfo::Feature.new f }
 
     di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, [], control
-    di.features.size.must_equal 3
-    di.features.each { |f| control.include?(f).must_equal true }
+    di.features.size.should == 3
+    di.features.each { |f| control.include?(f).should == true }
   end
 
   it 'takes a single string' do
     control = [Blather::Stanza::Iq::DiscoInfo::Feature.new('feature1')]
 
     di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, [], 'feature1'
-    di.features.size.must_equal 1
-    di.features.each { |f| control.include?(f).must_equal true }
+    di.features.size.should == 1
+    di.features.each { |f| control.include?(f).should == true }
   end
 
   it 'takes a single Feature object' do
     control = [Blather::Stanza::Iq::DiscoInfo::Feature.new('feature1')]
 
     di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, [], control.first
-    di.features.size.must_equal 1
-    di.features.each { |f| control.include?(f).must_equal true }
+    di.features.size.should == 1
+    di.features.each { |f| control.include?(f).should == true }
   end
 
   it 'takes a mixed list of features as Feature objects and strings' do
@@ -176,8 +175,8 @@ describe 'Blather::Stanza::Iq::DiscoInfo features' do
     features[1] = control[1]
 
     di = Blather::Stanza::Iq::DiscoInfo.new nil, nil, [], features
-    di.features.size.must_equal 3
-    di.features.each { |f| control.include?(f).must_equal true }
+    di.features.size.should == 3
+    di.features.each { |f| control.include?(f).should == true }
   end
 end
 
@@ -185,44 +184,44 @@ describe Blather::Stanza::Iq::DiscoInfo::Identity do
   it 'will auto-inherit nodes' do
     n = parse_stanza "<identity name='Personal Events' type='pep' category='pubsub' node='publish' xml:lang='en' />"
     i = Blather::Stanza::Iq::DiscoInfo::Identity.new n.root
-    i.name.must_equal 'Personal Events'
-    i.type.must_equal :pep
-    i.category.must_equal :pubsub
-    i.xml_lang.must_equal 'en'
+    i.name.should == 'Personal Events'
+    i.type.should == :pep
+    i.category.should == :pubsub
+    i.xml_lang.should == 'en'
   end
 
   it 'has a category attribute' do
     n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
-    n.category.must_equal :cat
+    n.category.should == :cat
     n.category = :foo
-    n.category.must_equal :foo
+    n.category.should == :foo
   end
 
   it 'has a type attribute' do
     n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
-    n.type.must_equal :type
+    n.type.should == :type
     n.type = :foo
-    n.type.must_equal :foo
+    n.type.should == :foo
   end
 
   it 'has a name attribute' do
     n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
-    n.name.must_equal 'name'
+    n.name.should == 'name'
     n.name = :foo
-    n.name.must_equal 'foo'
+    n.name.should == 'foo'
   end
 
   it 'has an xml:lang attribute' do
     n = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat en])
-    n.xml_lang.must_equal 'en'
+    n.xml_lang.should == 'en'
     n.xml_lang = 'de'
-    n.xml_lang.must_equal 'de'
+    n.xml_lang.should == 'de'
   end
 
   it 'can determine equality' do
     a = Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
-    a.must_equal Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
-    a.wont_equal Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[not-name not-type not-cat])
+    a.should == Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[name type cat])
+    a.should_not equal Blather::Stanza::Iq::DiscoInfo::Identity.new(*%w[not-name not-type not-cat])
   end
 end
 
@@ -230,19 +229,19 @@ describe Blather::Stanza::Iq::DiscoInfo::Feature do
   it 'will auto-inherit nodes' do
     n = parse_stanza "<feature var='ipv6' />"
     i = Blather::Stanza::Iq::DiscoInfo::Feature.new n.root
-    i.var.must_equal 'ipv6'
+    i.var.should == 'ipv6'
   end
 
   it 'has a var attribute' do
     n = Blather::Stanza::Iq::DiscoInfo::Feature.new 'var'
-    n.var.must_equal 'var'
+    n.var.should == 'var'
     n.var = :foo
-    n.var.must_equal 'foo'
+    n.var.should == 'foo'
   end
 
   it 'can determine equality' do
     a = Blather::Stanza::Iq::DiscoInfo::Feature.new('var')
-    a.must_equal Blather::Stanza::Iq::DiscoInfo::Feature.new('var')
-    a.wont_equal Blather::Stanza::Iq::DiscoInfo::Feature.new('not-var')
+    a.should == Blather::Stanza::Iq::DiscoInfo::Feature.new('var')
+    a.should_not equal Blather::Stanza::Iq::DiscoInfo::Feature.new('not-var')
   end
 end