tp-blather 0.8.2

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

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+def c_xml
+  <<-XML
+    <presence from='bard@shakespeare.lit/globe'>
+      <c xmlns='http://jabber.org/protocol/caps'
+         hash='sha-1'
+         node='http://www.chatopus.com'
+         ver='zHyEOgxTrkpSdGcQKH8EFPLsriY='/>
+    </presence>
+  XML
+end
+
+describe 'Blather::Stanza::Presence::C' do
+  it 'registers itself' do
+    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.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 }.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.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.should == :md5
+  end
+
+  it 'can set a node on creation' do
+    c = Blather::Stanza::Presence::C.new '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.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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+def muc_xml
+  <<-XML
+    <presence from='hag66@shakespeare.lit/pda'
+              id='n13mt3l'
+              to='coven@chat.shakespeare.lit/thirdwitch'>
+      <x xmlns='http://jabber.org/protocol/muc'/>
+    </presence>
+  XML
+end
+
+describe 'Blather::Stanza::Presence::MUC' do
+  it 'registers itself' do
+    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.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).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).should 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

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+def muc_user_xml
+  <<-XML
+    <presence from='hag66@shakespeare.lit/pda'
+              id='n13mt3l'
+              to='coven@chat.shakespeare.lit/thirdwitch'>
+      <x xmlns='http://jabber.org/protocol/muc#user'>
+        <item affiliation='none'
+              jid='hag66@shakespeare.lit/pda'
+              role='participant'/>
+        <status code='100'/>
+        <status code='110'/>
+        <password>foobar</password>
+      </x>
+    </presence>
+  XML
+end
+
+describe 'Blather::Stanza::Presence::MUCUser' do
+  it 'must be importable' do
+    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).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).should 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.should == nil
+    muc_user.affiliation = :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.should == nil
+    muc_user.role = :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.should == nil
+    muc_user.jid = '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.should == []
+    muc_user.status_codes = [100, 110]
+    muc_user.status_codes.should == [100, 110]
+    muc_user.status_codes = [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.should == nil
+    muc_user.password = 'barbaz'
+    muc_user.password.should == 'barbaz'
+    muc_user.password = 'hello_world'
+    muc_user.password.should == 'hello_world'
+  end
+end

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

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe Blather::Stanza::Presence::Status do
+  it 'registers itself' do
+    Blather::XMPPNode.class_from_registration(:status, nil).should == Blather::Stanza::Presence::Status
+  end
+
+  it 'must be importable as unavailable' do
+    Blather::XMPPNode.parse('<presence type="unavailable"/>').should be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
+  end
+
+  it 'must be importable as nil' do
+    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.should == :away
+  end
+
+  it 'can set a message on creation' do
+    status = Blather::Stanza::Presence::Status.new nil, '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 }.should raise_error(Blather::ArgumentError)
+
+    [nil, :unavailable].each do |valid_type|
+      status.type = 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 }.should raise_error(Blather::ArgumentError)
+
+    Blather::Stanza::Presence::Status::VALID_STATES.each do |valid_state|
+      status.state = valid_state
+      status.state.should == valid_state
+    end
+  end
+
+  it 'returns :available if state is nil' do
+    Blather::Stanza::Presence::Status.new.state.should == :available
+  end
+
+  it 'returns :available if <show/> is blank' do
+    status = Blather::XMPPNode.parse(<<-NODE)
+      <presence><show/></presence>
+    NODE
+    status.state.should == :available
+  end
+
+  it 'returns :unavailable if type is :unavailable' do
+    status = Blather::Stanza::Presence::Status.new
+    status.type = :unavailable
+    status.state.should == :unavailable
+  end
+
+  it 'ensures priority is not greater than 127' do
+    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 }.should raise_error(Blather::ArgumentError)
+  end
+
+  it 'has "attr_accessor" for priority' do
+    status = Blather::Stanza::Presence::Status.new
+    status.priority.should == 0
+
+    status.priority = 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.should be_nil
+
+    status.message = '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
+    jid = Blather::JID.new 'a@b/c'
+
+    status1 = Blather::Stanza::Presence::Status.new
+    status1.from = jid
+
+    status2 = Blather::Stanza::Presence::Status.new
+    status2.from = jid
+
+    status1.priority = 1
+    status2.priority = -1
+    (status1 <=> status2).should == 1
+    (status2 <=> status1).should == -1
+
+    status2.priority = 1
+    (status1 <=> status2).should == 0
+  end
+
+  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 = Blather::Stanza::Presence::Status.new
+    status2.from = 'd@e/f'
+
+    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.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.should respond_to method
+      stat.__send__(method).should == true
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Blather::Stanza::Presence::Subscription do
+  it 'registers itself' do
+    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
+      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.should == 'a@b'
+  end
+
+  it 'can set a type on creation' do
+    sub = Blather::Stanza::Presence::Subscription.new nil, :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.should == 'a@b'
+  end
+
+  it 'generates an approval using #approve!' do
+    sub = Blather::Stanza.import Nokogiri::XML('<presence from="a@b" type="subscribe"><status/></presence>').root
+    sub.approve!
+    sub.to.should == 'a@b'
+    sub.type.should == :subscribed
+  end
+
+  it 'generates a refusal using #refuse!' do
+    jid = Blather::JID.new 'a@b'
+    sub = Blather::Stanza::Presence::Subscription.new
+    sub.from = jid
+    sub.refuse!
+    sub.to.should == jid
+    sub.type.should == :unsubscribed
+  end
+
+  it 'generates an unsubscript using #unsubscribe!' do
+    jid = Blather::JID.new 'a@b'
+    sub = Blather::Stanza::Presence::Subscription.new
+    sub.from = jid
+    sub.unsubscribe!
+    sub.to.should == jid
+    sub.type.should == :unsubscribe
+  end
+
+  it 'generates a cancellation using #cancel!' do
+    jid = Blather::JID.new 'a@b'
+    sub = Blather::Stanza::Presence::Subscription.new
+    sub.from = jid
+    sub.cancel!
+    sub.to.should == jid
+    sub.type.should == :unsubscribed
+  end
+
+  it 'generates a request using #request!' do
+    jid = Blather::JID.new 'a@b'
+    sub = Blather::Stanza::Presence::Subscription.new
+    sub.from = jid
+    sub.request!
+    sub.to.should == jid
+    sub.type.should == :subscribe
+  end
+
+  it 'has a #request? helper' do
+    sub = Blather::Stanza::Presence::Subscription.new
+    sub.should respond_to :request?
+    sub.type = :subscribe
+    sub.request?.should == true
+  end
+
+  it "successfully routes chained actions" do
+    from = Blather::JID.new("foo@bar.com")
+    to = Blather::JID.new("baz@quux.com")
+    sub = Blather::Stanza::Presence::Subscription.new
+    sub.from = from
+    sub.to = to
+    sub.cancel!
+    sub.unsubscribe!
+    sub.type.should == :unsubscribe
+    sub.to.should == from
+    sub.from.should == to
+  end
+
+  it "will inherit only another node's attributes" do
+    inheritable = Blather::XMPPNode.new 'foo'
+    inheritable[:bar] = 'baz'
+
+    sub = Blather::Stanza::Presence::Subscription.new
+    sub.should respond_to :inherit
+
+    sub.inherit inheritable
+    sub[:bar].should == 'baz'
+  end
+end

data/spec/blather/stanza/presence_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe Blather::Stanza::Presence do
+  it 'registers itself' do
+    Blather::XMPPNode.class_from_registration(:presence, nil).should == Blather::Stanza::Presence
+  end
+
+  it 'must be importable' do
+    Blather::XMPPNode.parse('<presence type="probe"/>').should be_instance_of Blather::Stanza::Presence
+  end
+
+  it 'ensures type is one of Blather::Stanza::Presence::VALID_TYPES' do
+    presence = Blather::Stanza::Presence.new
+    lambda { presence.type = :invalid_type_name }.should raise_error(Blather::ArgumentError)
+
+    Blather::Stanza::Presence::VALID_TYPES.each do |valid_type|
+      presence.type = valid_type
+      presence.type.should == valid_type
+    end
+  end
+
+  Blather::Stanza::Presence::VALID_TYPES.each do |valid_type|
+    it "provides a helper (#{valid_type}?) for type #{valid_type}" do
+      Blather::Stanza::Presence.new.should respond_to :"#{valid_type}?"
+    end
+
+    it "returns true on call to (#{valid_type}?) if type == #{valid_type}" do
+      method = "#{valid_type}?".to_sym
+      pres = Blather::Stanza::Presence.new
+      pres.type = valid_type
+      pres.should respond_to method
+      pres.__send__(method).should == true
+    end
+  end
+
+  it 'creates a C object when importing a node with a c child' do
+    string = <<-XML
+      <presence from='bard@shakespeare.lit/globe'>
+        <c xmlns='http://jabber.org/protocol/caps'
+           hash='sha-1'
+           node='http://www.chatopus.com'
+           ver='zHyEOgxTrkpSdGcQKH8EFPLsriY='/>
+      </presence>
+    XML
+    s = Blather::Stanza::Presence.parse string
+    s.should be_kind_of Blather::Stanza::Presence::C::InstanceMethods
+    s.node.should == 'http://www.chatopus.com'
+    s.handler_hierarchy.should include(:c)
+  end
+
+  it 'creates a Status object when importing a node with type == nil' do
+    s = Blather::Stanza::Presence.parse('<presence/>')
+    s.should be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
+    s.state.should == :available
+    s.handler_hierarchy.should include(Blather::Stanza::Presence::Status.registered_name.to_sym)
+  end
+
+  it 'creates a Status object when importing a node with type == "unavailable"' do
+    s = Blather::Stanza::Presence.parse('<presence type="unavailable"/>')
+    s.should be_kind_of Blather::Stanza::Presence::Status::InstanceMethods
+    s.state.should == :unavailable
+    s.handler_hierarchy.should include(Blather::Stanza::Presence::Status.registered_name.to_sym)
+  end
+
+  it 'creates a Subscription object when importing a node with type == "subscribe"' do
+    s = Blather::Stanza::Presence.parse('<presence type="subscribe"/>')
+    s.should be_kind_of Blather::Stanza::Presence::Subscription::InstanceMethods
+    s.type.should == :subscribe
+    s.handler_hierarchy.should include(Blather::Stanza::Presence::Subscription.registered_name.to_sym)
+  end
+
+  it 'creates a MUC object when importing a node with a form in the MUC namespace' do
+    string = <<-XML
+      <presence from='bard@shakespeare.lit/globe'>
+        <x xmlns='http://jabber.org/protocol/muc'/>
+      </presence>
+    XML
+    s = Blather::Stanza::Presence.parse string
+    s.should be_kind_of Blather::Stanza::Presence::MUC::InstanceMethods
+  end
+
+  it 'creates a MUCUser object when importing a node with a form in the MUC#user namespace' do
+    string = <<-XML
+      <presence from='bard@shakespeare.lit/globe'>
+        <x xmlns='http://jabber.org/protocol/muc#user'/>
+      </presence>
+    XML
+    s = Blather::Stanza::Presence.parse string
+    s.should be_kind_of Blather::Stanza::Presence::MUCUser::InstanceMethods
+  end
+
+  it 'creates a Presence object when importing a node with type equal to something unknown' do
+    string = "<presence from='bard@shakespeare.lit/globe' type='foo'/>"
+    s = Blather::Stanza::Presence.parse string
+    s.should be_kind_of Blather::Stanza::Presence
+    s.type.should == :foo
+    s.handler_hierarchy.should include(Blather::Stanza::Presence.registered_name.to_sym)
+  end
+
+  it 'behaves like a C, a Status, and a MUCUser when all types of children are present' do
+    string = <<-XML
+      <presence from='bard@shakespeare.lit/globe'>
+        <show>chat</show>
+        <c xmlns='http://jabber.org/protocol/caps'
+           hash='sha-1'
+           node='http://www.chatopus.com'
+           ver='zHyEOgxTrkpSdGcQKH8EFPLsriY='/>
+        <x xmlns='http://jabber.org/protocol/muc#user'>
+          <item affiliation='none'
+                jid='hag66@shakespeare.lit/pda'
+                role='participant'/>
+          <status code='100'/>
+          <status code='110'/>
+          <password>foobar</password>
+        </x>
+      </presence>
+    XML
+    s = Blather::Stanza::Presence.parse string
+    s.state.should == :chat
+    s.node.should == 'http://www.chatopus.com'
+    s.role.should == :participant
+    s.handler_hierarchy.should include(Blather::Stanza::Presence::C.registered_name.to_sym)
+    s.handler_hierarchy.should include(Blather::Stanza::Presence::Status.registered_name.to_sym)
+  end
+end