sprsquish-blather 0.1 → 0.2.3

data/spec/blather/stanza/iq/discos/disco_items_spec.rb

@@ -0,0 +1,136 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. .. spec_helper])
+
+def disco_items_xml
+  <<-XML
+  <iq type='result'
+      from='catalog.shakespeare.lit'
+      to='romeo@montague.net/orchard'
+      id='items2'>
+    <query xmlns='http://jabber.org/protocol/disco#items'>
+      <item jid='catalog.shakespeare.lit'
+            node='books'
+            name='Books by and about Shakespeare'/>
+      <item jid='catalog.shakespeare.lit'
+            node='clothing'
+            name='Wear your literary taste with pride'/>
+      <item jid='catalog.shakespeare.lit'
+            node='music'
+            name='Music from the time of Shakespeare'/>
+    </query>
+  </iq>
+  XML
+end
+
+describe 'Blather::Stanza::Iq::DiscoItems' do
+  it 'registers itself' do
+    XMPPNode.class_from_registration(:query, 'http://jabber.org/protocol/disco#items').must_equal Blather::Stanza::Iq::DiscoItems
+  end
+
+  it 'has a node attribute' do
+    n = Blather::Stanza::Iq::DiscoItems.new nil, 'music', []
+    n.node.must_equal 'music'
+    n.node = :foo
+    n.node.must_equal 'foo'
+  end
+
+  it 'inherits a list of identities' do
+    n = XML::Document.string disco_items_xml
+    r = Stanza::Iq::DiscoItems.new.inherit n.root
+    r.items.size.must_equal 3
+    r.items.map { |i| i.class }.uniq.must_equal [Stanza::Iq::DiscoItems::Item]
+  end
+end
+
+describe 'Blather::Stanza::Iq::DiscoItems items' do
+  it 'takes a list of hashes for items' do
+    items = [
+      {:jid => 'foo@bar/baz', :node => 'node', :name => 'name'},
+      {:jid => 'baz@foo/bar', :node => 'node1', :name => 'name1'},
+    ]
+
+    control = [ Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name]),
+                Stanza::Iq::DiscoItems::Item.new(*%w[baz@foo/bar node1 name1])]
+
+    di = Stanza::Iq::DiscoItems.new nil, nil, items
+    di.items.size.must_equal 2
+    di.items.each { |i| control.include?(i).must_equal true }
+  end
+
+  it 'takes a list of Item objects as items' do
+    control = [ Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name]),
+                Stanza::Iq::DiscoItems::Item.new(*%w[baz@foo/bar node1 name1])]
+
+    di = Stanza::Iq::DiscoItems.new nil, nil, control
+    di.items.size.must_equal 2
+    di.items.each { |i| control.include?(i).must_equal true }
+  end
+
+  it 'takes a single hash as identity' do
+    control = [Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name])]
+
+    di = Stanza::Iq::DiscoItems.new nil, nil, {:jid => 'foo@bar/baz', :node => 'node', :name => 'name'}
+    di.items.size.must_equal 1
+    di.items.each { |i| control.include?(i).must_equal true }
+  end
+
+  it 'takes a single identity object as identity' do
+    control = [Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name])]
+
+    di = Stanza::Iq::DiscoItems.new nil, nil, control.first
+    di.items.size.must_equal 1
+    di.items.each { |i| control.include?(i).must_equal true }
+  end
+
+  it 'takes a mix of hashes and identity objects as items' do
+    items = [
+      {:jid => 'foo@bar/baz', :node => 'node', :name => 'name'},
+      Stanza::Iq::DiscoItems::Item.new(*%w[baz@foo/bar node1 name1]),
+    ]
+
+    control = [ Stanza::Iq::DiscoItems::Item.new(*%w[foo@bar/baz node name]),
+                Stanza::Iq::DiscoItems::Item.new(*%w[baz@foo/bar node1 name1])]
+
+    di = Stanza::Iq::DiscoItems.new nil, nil, items
+    di.items.size.must_equal 2
+    di.items.each { |i| control.include?(i).must_equal true }
+  end
+end
+
+describe 'Blather::Stanza::Iq::DiscoItems::Item' do
+  it 'will auto-inherit nodes' do
+    n = XML::Document.string "<item jid='foo@bar/baz' node='music' name='Music from the time of Shakespeare' />"
+    i = Stanza::Iq::DiscoItems::Item.new n.root
+    i.jid.must_equal JID.new('foo@bar/baz')
+    i.node.must_equal 'music'
+    i.name.must_equal 'Music from the time of Shakespeare'
+  end
+
+  it 'has a jid attribute' do
+    n = Stanza::Iq::DiscoItems::Item.new 'foo@bar/baz'
+    n.jid.must_be_kind_of JID
+    n.jid.must_equal JID.new('foo@bar/baz')
+    n.jid = 'baz@foo/bar'
+    n.jid.must_equal JID.new('baz@foo/bar')
+  end
+
+  it 'has a node attribute' do
+    n = Stanza::Iq::DiscoItems::Item.new 'foo@bar/baz', 'music'
+    n.node.must_equal 'music'
+    n.node = 'book'
+    n.node.must_equal 'book'
+  end
+
+  it 'has a name attribute' do
+    n = Stanza::Iq::DiscoItems::Item.new 'foo@bar/baz', nil, 'Music from the time of Shakespeare'
+    n.name.must_equal 'Music from the time of Shakespeare'
+    n.name = 'Books by and about Shakespeare'
+    n.name.must_equal 'Books by and about Shakespeare'
+  end
+
+  it 'can determine equality' do
+    a = Stanza::Iq::DiscoItems::Item.new('foo@bar/baz')
+    a.must_respond_to :eql?
+    a.must_equal Stanza::Iq::DiscoItems::Item.new('foo@bar/baz')
+    a.wont_equal "<item jid='foo@bar/baz' node='music' name='Music from the time of Shakespeare' />"
+  end
+end

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

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
+
+describe 'Blather::Stanza::Iq::Query' do
+  it 'registers itself' do
+    XMPPNode.class_from_registration(:query, nil).must_equal 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
+  end
+
+  it 'ensures a query node exists when calling #query' do
+    query = Stanza::Iq::Query.new
+    query.remove_child :query
+    query.children.detect { |n| n.element_name == 'query' }.must_be_nil
+
+    query.query.wont_be_nil
+    query.children.detect { |n| n.element_name == 'query' }.wont_be_nil
+  end
+
+  it 'sets type to "result" on reply' do
+    query = 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.type.must_equal :get
+    query.reply!
+    query.type.must_equal :result
+  end
+end

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

@@ -0,0 +1,123 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
+
+def roster_xml
+  <<-XML
+  <iq to='juliet@example.com/balcony' type='result' id='roster_1'>
+    <query xmlns='jabber:iq:roster'>
+      <item jid='romeo@example.net'
+            name='Romeo'
+            subscription='both'>
+        <group>Friends</group>
+      </item>
+      <item jid='mercutio@example.org'
+            name='Mercutio'
+            subscription='from'>
+        <group>Friends</group>
+      </item>
+      <item jid='benvolio@example.org'
+            name='Benvolio'
+            subscription='both'>
+        <group>Friends</group>
+      </item>
+    </query>
+  </iq>
+  XML
+end
+
+describe 'Blather::Stanza::Iq::Roster' do
+  it 'registers itself' do
+    XMPPNode.class_from_registration(:query, 'jabber:iq:roster').must_equal 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]
+  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')
+  end
+
+  it 'can be initialized with a name' do
+    i = 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.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.ask.must_equal :subscribe
+  end
+
+  it 'inherits a node when initialized with one' do
+    n = 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.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
+    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
+    i.must_respond_to :groups=
+    i.groups.sort.must_equal %w[bar baz foo]
+    i.groups = %w[a b c]
+    i.groups.sort.must_equal %w[a b c]
+  end
+
+  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
+    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.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.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')
+  end
+
+  it 'has a name attribute' do
+    i = 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.subscription = :both
+    i.subscription.must_equal :both
+  end
+
+  it 'has an ask attribute' do
+    i = Stanza::Iq::Roster::RosterItem.new
+    i.ask = :subscribe
+    i.ask.must_equal :subscribe
+  end
+end

data/spec/blather/stanza/iq_spec.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe 'Blather::Stanza::Iq' do
+  it 'registers itself' do
+    XMPPNode.class_from_registration(:iq, nil).must_equal Stanza::Iq
+  end
+
+  it 'creates a new Iq stanza defaulted as a get' do
+    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)
+  end
+
+  it 'creates a new Stanza::Iq object on import' do
+    Stanza::Iq.import(XMPPNode.new('iq')).must_be_kind_of 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
+  end
+
+  it 'ensures type is one of Stanza::Iq::VALID_TYPES' do
+    lambda { Stanza::Iq.new :invalid_type_name }.must_raise(Blather::ArgumentError)
+
+    Stanza::Iq::VALID_TYPES.each do |valid_type|
+      n = Stanza::Iq.new valid_type
+      n.type.must_equal valid_type
+    end
+  end
+
+  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}?"
+    end
+  end
+end

data/spec/blather/stanza/message_spec.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe 'Blather::Stanza::Message' do
+  it 'registers itself' do
+    XMPPNode.class_from_registration(:message, nil).must_equal Stanza::Message
+  end
+
+  it 'provides "attr_accessor" for body' do
+    s = Stanza::Message.new
+    s.body.must_be_nil
+    s.detect { |n| n.element_name == 'body' }.must_be_nil
+
+    s.body = 'test message'
+    s.body.wont_be_nil
+    s.detect { |n| n.element_name == 'body' }.wont_be_nil
+  end
+
+  it 'provides "attr_accessor" for subject' do
+    s = Stanza::Message.new
+    s.subject.must_be_nil
+    s.detect { |n| n.element_name == 'subject' }.must_be_nil
+
+    s.subject = 'test subject'
+    s.subject.wont_be_nil
+    s.detect { |n| n.element_name == 'subject' }.wont_be_nil
+  end
+
+  it 'provides "attr_accessor" for thread' do
+    s = Stanza::Message.new
+    s.thread.must_be_nil
+    s.detect { |n| n.element_name == 'thread' }.must_be_nil
+
+    s.thread = 1234
+    s.thread.wont_be_nil
+    s.detect { |n| n.element_name == 'thread' }.wont_be_nil
+  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)
+
+    Stanza::Message::VALID_TYPES.each do |valid_type|
+      msg = Stanza::Message.new nil, nil, valid_type
+      msg.type.must_equal valid_type
+    end
+  end
+
+  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}?"
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
+
+describe 'Blather::Stanza::Presence::Status' do
+  it 'registers itself' do
+    XMPPNode.class_from_registration(:status, nil).must_equal Stanza::Presence::Status
+  end
+
+  it 'can set state on creation' do
+    status = 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.message.must_equal 'Say hello!'
+  end
+
+  it 'ensures type is nil or :unavailable' do
+    status = Stanza::Presence::Status.new
+    lambda { status.type = :invalid_type_name }.must_raise(Blather::ArgumentError)
+
+    [nil, :unavailable].each do |valid_type|
+      status.type = valid_type
+      status.type.must_equal valid_type
+    end
+  end
+
+  it 'ensures state is one of Presence::Status::VALID_STATES' do
+    status = Stanza::Presence::Status.new
+    lambda { status.state = :invalid_type_name }.must_raise(Blather::ArgumentError)
+
+    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
+  end
+
+  it 'returns :unavailable if type is :unavailable' do
+    status = 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)
+  end
+
+  it 'ensures priority is not less than -128' do
+    lambda { Stanza::Presence::Status.new.priority = -129 }.must_raise(Blather::ArgumentError)
+  end
+
+  it 'has "attr_accessor" for priority' do
+    status = Stanza::Presence::Status.new
+    status.priority.must_equal 0
+
+    status.priority = 10
+    status.children.detect { |n| n.element_name == 'priority' }.wont_be_nil
+    status.priority.must_equal 10
+  end
+
+  it 'has "attr_accessor" for message' do
+    status = Stanza::Presence::Status.new
+    status.message.must_be_nil
+
+    status.message = 'new message'
+    status.children.detect { |n| n.element_name == 'status' }.wont_be_nil
+    status.message.must_equal 'new message'
+  end
+
+  it 'must be comparable by priority' do
+    jid = JID.new 'a@b/c'
+
+    status1 = Stanza::Presence::Status.new
+    status1.from = jid
+
+    status2 = Stanza::Presence::Status.new
+    status2.from = jid
+
+    status1.priority = 1
+    status2.priority = -1
+    (status1 <=> status2).must_equal 1
+    (status2 <=> status1).must_equal -1
+
+    status2.priority = 1
+    (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
+    status1.from = 'a@b/c'
+
+    status2 = Stanza::Presence::Status.new
+    status2.from = 'd@e/f'
+
+    lambda { status1 <=> status2 }.must_raise(Blather::ArgumentError)
+  end
+end
+

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

@@ -0,0 +1,85 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
+
+describe 'Blather::Stanza::Presence::Subscription' do
+  it 'registers itself' do
+    XMPPNode.class_from_registration(:subscription, nil).must_equal Stanza::Presence::Subscription
+  end
+
+  it 'can set to on creation' do
+    sub = Stanza::Presence::Subscription.new 'a@b'
+    sub.to.to_s.must_equal 'a@b'
+  end
+
+  it 'can set a type on creation' do
+    sub = Stanza::Presence::Subscription.new nil, :subscribed
+    sub.type.must_equal :subscribed
+  end
+
+  it 'strips JIDs when setting #to' do
+    sub = Stanza::Presence::Subscription.new 'a@b/c'
+    sub.to.to_s.must_equal 'a@b'
+  end
+
+  it 'generates an approval using #approve!' do
+    jid = JID.new 'a@b'
+    sub = Stanza::Presence::Subscription.new
+    sub.from = jid
+    sub.approve!
+    sub.to.must_equal jid
+    sub.type.must_equal :subscribed
+  end
+
+  it 'generates a refusal using #refuse!' do
+    jid = JID.new 'a@b'
+    sub = Stanza::Presence::Subscription.new
+    sub.from = jid
+    sub.refuse!
+    sub.to.must_equal jid
+    sub.type.must_equal :unsubscribed
+  end
+
+  it 'generates an unsubscript using #unsubscribe!' do
+    jid = JID.new 'a@b'
+    sub = Stanza::Presence::Subscription.new
+    sub.from = jid
+    sub.unsubscribe!
+    sub.to.must_equal jid
+    sub.type.must_equal :unsubscribe
+  end
+
+  it 'generates a cancellation using #cancel!' do
+    jid = JID.new 'a@b'
+    sub = Stanza::Presence::Subscription.new
+    sub.from = jid
+    sub.cancel!
+    sub.to.must_equal jid
+    sub.type.must_equal :unsubscribed
+  end
+
+  it 'generates a request using #request!' do
+    jid = JID.new 'a@b'
+    sub = Stanza::Presence::Subscription.new
+    sub.from = jid
+    sub.request!
+    sub.to.must_equal jid
+    sub.type.must_equal :subscribe
+  end
+
+  it 'has a #request? helper' do
+    sub = Stanza::Presence::Subscription.new
+    sub.must_respond_to :request?
+    sub.type = :subscribe
+    sub.request?.must_equal true
+  end
+
+  it "will inherit only another node's attributes" do
+    inheritable = XMPPNode.new 'foo'
+    inheritable.attributes[:bar] = 'baz'
+
+    sub = Stanza::Presence::Subscription.new
+    sub.must_respond_to :inherit
+
+    sub.inherit inheritable
+    sub.attributes[:bar].must_equal 'baz'
+  end
+end

data/spec/blather/stanza/presence_spec.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe 'Blather::Stanza::Presence' do
+  it 'registers itself' do
+    XMPPNode.class_from_registration(:presence, nil).must_equal Stanza::Presence
+  end
+
+  it 'ensures type is one of Stanza::Presence::VALID_TYPES' do
+    presence = Stanza::Presence.new
+    lambda { presence.type = :invalid_type_name }.must_raise(Blather::ArgumentError)
+
+    Stanza::Presence::VALID_TYPES.each do |valid_type|
+      presence.type = valid_type
+      presence.type.must_equal valid_type
+    end
+  end
+
+  Stanza::Presence::VALID_TYPES.each do |valid_type|
+    it "provides a helper (#{valid_type}?) for type #{valid_type}" do
+      Stanza::Presence.new.must_respond_to :"#{valid_type}?"
+    end
+  end
+
+  it 'creates a Status object when importing a node with type == nil' do
+    s = Stanza::Presence.import(XMPPNode.new)
+    s.must_be_kind_of Stanza::Presence::Status
+    s.state.must_equal :available
+  end
+
+  it 'creates a Status object when importing a node with type == "unavailable"' do
+    n = XMPPNode.new
+    n.attributes[:type] = :unavailable
+    s = Stanza::Presence.import(n)
+    s.must_be_kind_of Stanza::Presence::Status
+    s.state.must_equal :unavailable
+  end
+
+  it 'creates a Subscription object when importing a node with type == "subscribe"' do
+    n = XMPPNode.new
+    n.attributes[:type] = :subscribe
+    s = Stanza::Presence.import(n)
+    s.must_be_kind_of Stanza::Presence::Subscription
+    s.type.must_equal :subscribe
+  end
+
+  it 'creates a Presence object when importing a node with type equal to something unkown' do
+    n = XMPPNode.new
+    n.attributes[:type] = :foo
+    s = Stanza::Presence.import(n)
+    s.must_be_kind_of Stanza::Presence
+    s.type.must_equal :foo
+  end
+end

data/spec/blather/{core/stanza_spec.rb → stanza_spec.rb}

@@ -1,8 +1,8 @@
-require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+require File.join(File.dirname(__FILE__), *%w[.. spec_helper])
 
 describe 'Blather::Stanza' do
   it 'provides .next_id helper for generating new IDs' do
-    proc { Stanza.next_id }.must_change 'Stanza', :next_id
+    proc { Stanza.next_id }.must_change 'Stanza.next_id'
   end
 
   it 'can import a node' do
@@ -92,4 +92,16 @@ describe 'Blather::Stanza' do
     s.type.wont_be_nil
     s['type'].wont_be_nil
   end
+
+  it 'can be converted into an error by error name' do
+    s = Stanza.new('message')
+    err = s.as_error 'internal-server-error', 'cancel'
+    err.must_be_instance_of StanzaError::InternalServerError
+  end
+
+  it 'can be converted into an error by error class' do
+    s = Stanza.new('message')
+    err = s.as_error StanzaError::InternalServerError, 'cancel'
+    err.must_be_instance_of StanzaError::InternalServerError
+  end
 end