xmpp4r 0.3

data/test/roster/tc_helper.rb

@@ -0,0 +1,389 @@
+#!/usr/bin/ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require File::dirname(__FILE__) + '/../lib/clienttester'
+
+require 'xmpp4r'
+require 'xmpp4r/roster/helper/roster'
+include Jabber
+
+class Roster::HelperTest < Test::Unit::TestCase
+  include ClientTester
+
+  def test_simple
+    state { |iq|
+      assert_kind_of(Iq, iq)
+      assert_equal(:get, iq.type)
+      assert_nil(iq.to)
+      assert_equal('jabber:iq:roster', iq.queryns)
+
+      send("<iq type='result'><query xmlns='jabber:iq:version'/></iq>")
+      send("<iq type='result' id='#{iq.id}'>
+              <query xmlns='jabber:iq:roster'>
+                <item jid='a@b.c' subscription='both'/>
+                <item jid='b@b.c' name='b guy' subscription='from' ask='subscribe'/>
+                <item jid='123@xyz' name='123' subscription='to'/>
+              </query>
+            </iq>")
+    }
+
+    query_waiter = Mutex.new
+    query_waiter.lock
+    h = Roster::Helper::new(@client)
+    h.add_query_callback { |iq|
+      query_waiter.unlock
+    }
+    wait_state
+    query_waiter.lock
+
+    assert_equal([nil], h.groups)
+    jids = h.find_by_group(nil).collect { |item| item.jid }.sort
+    assert_equal([JID.new('123@xyz'), JID.new('a@b.c'), JID.new('b@b.c')], jids)
+    assert_equal(1, h.find('123@xyz/res').size)
+
+    assert_kind_of(Roster::Helper::RosterItem, h['a@b.c'])
+    assert_equal(JID.new('a@b.c'), h['a@b.c'].jid)
+    assert_nil(h['a@b.c'].iname)
+    assert_equal(:both, h['a@b.c'].subscription)
+    assert_nil(h['a@b.c'].ask)
+
+    assert_kind_of(Roster::Helper::RosterItem, h[JID.new('b@b.c')])
+    assert_equal(JID.new('b@b.c'), h['b@b.c'].jid)
+    assert_equal('b guy', h['b@b.c'].iname)
+    assert_equal(:from, h['b@b.c'].subscription)
+    assert_equal(:subscribe, h['b@b.c'].ask)
+
+    assert_kind_of(Roster::Helper::RosterItem, h['123@xyz'])
+    assert_equal(JID.new('123@xyz'), h['123@xyz'].jid)
+    assert_equal('123', h['123@xyz'].iname)
+    assert_equal(:to, h['123@xyz'].subscription)
+    assert_nil(h['123@xyz'].ask)
+
+    assert_nil(h['c@b.c'])
+    assert_nil(h[JID.new('c@b.c')])
+  end
+
+  def test_rosterpush
+    state { |iq|
+      send("<iq type='result' id='#{iq.id}'>
+              <query xmlns='jabber:iq:roster'>
+              </query>
+            </iq>")
+    }
+
+    query_waiter = Mutex.new
+    query_waiter.lock
+    h = Roster::Helper::new(@client)
+    h.add_query_callback { |iq| query_waiter.unlock }
+    wait_state
+    query_waiter.lock
+
+    assert_equal([], h.groups)
+    assert_nil(h['a@b.c'])
+
+    send("<iq type='set'>
+            <query xmlns='jabber:iq:roster'>
+              <item jid='a@b.c'/>
+            </query>
+          </iq>")
+    query_waiter.lock
+
+    assert_kind_of(Roster::Helper::RosterItem, h['a@b.c'])
+    assert_equal(JID.new('a@b.c'), h['a@b.c'].jid)
+    assert_nil(h['a@b.c'].iname)
+    assert_nil(h['a@b.c'].subscription)
+    assert_nil(h['a@b.c'].ask)
+
+    send("<iq type='set'>
+            <query xmlns='jabber:iq:roster'>
+              <item jid='a@b.c' subscription='from' name='ABC' ask='subscribe'/>
+            </query>
+          </iq>")
+    query_waiter.lock
+
+    assert_kind_of(Roster::Helper::RosterItem, h['a@b.c'])
+    assert_equal(JID.new('a@b.c'), h['a@b.c'].jid)
+    assert_equal('ABC', h['a@b.c'].iname)
+    assert_equal(:from, h['a@b.c'].subscription)
+    assert_equal(:subscribe, h['a@b.c'].ask)
+
+    send("<iq type='set'>
+            <query xmlns='jabber:iq:roster'>
+              <item jid='a@b.c'/>
+            </query>
+          </iq>")
+    query_waiter.lock
+
+    assert_kind_of(Roster::Helper::RosterItem, h['a@b.c'])
+    assert_equal(JID.new('a@b.c'), h['a@b.c'].jid)
+    assert_nil(h['a@b.c'].iname)
+    assert_nil(h['a@b.c'].subscription)
+    assert_nil(h['a@b.c'].ask)
+
+    send("<iq type='set'>
+            <query xmlns='jabber:iq:roster'>
+              <item jid='a@b.c' subscription='remove'/>
+            </query>
+          </iq>")
+    query_waiter.lock
+
+    assert_nil(h['a@b.c'])
+  end
+
+  def test_presence
+    state { |iq|
+      send("<iq type='result' id='#{iq.id}'>
+              <query xmlns='jabber:iq:roster'>
+                <item jid='a@b.c' subscription='both'/>
+              </query>
+            </iq>")
+    }
+
+    query_waiter = Mutex.new
+    query_waiter.lock
+    presence_waiter = Mutex.new
+    presence_waiter.lock
+    h = Roster::Helper::new(@client)
+    h.add_query_callback { |iq|
+      query_waiter.unlock
+    }
+    cb_item, cb_op, cb_p = nil, nil, nil
+    h.add_presence_callback { |item,oldpres,pres|
+      cb_item, cb_op, cb_p = item, oldpres, pres
+      presence_waiter.unlock
+    }
+
+    wait_state
+    query_waiter.lock
+
+    assert_equal(false, h['a@b.c'].online?)
+    presences = 0
+    h['a@b.c'].each_presence { presences += 1 }
+    assert_equal(0, presences)
+
+    send("<presence from='a@b.c/r'/>")
+    presence_waiter.lock
+
+    assert_kind_of(Roster::Helper::RosterItem, cb_item)
+    assert_nil(cb_op)
+    assert_kind_of(Presence, cb_p)
+    assert_nil(cb_p.type)
+    assert_equal(true, h['a@b.c'].online?)
+    presences = 0
+    h['a@b.c'].each_presence { presences += 1 }
+    assert_equal(1, presences)
+
+    send("<presence from='a@b.c/r2'/>")
+    presence_waiter.lock
+
+    assert_kind_of(Roster::Helper::RosterItem, cb_item)
+    assert_nil(cb_op)
+    assert_kind_of(Presence, cb_p)
+    assert_nil(cb_p.type)
+    assert_equal(true, h['a@b.c'].online?)
+    presences = 0
+    h['a@b.c'].each_presence { presences += 1 }
+    assert_equal(2, presences)
+
+    send("<presence from='a@b.c/r'/>")
+    presence_waiter.lock
+
+    assert_kind_of(Roster::Helper::RosterItem, cb_item)
+    assert_kind_of(Presence, cb_op)
+    assert_nil(cb_op.type)
+    assert_kind_of(Presence, cb_p)
+    assert_nil(cb_p.type)
+    assert_equal(true, h['a@b.c'].online?)
+    presences = 0
+    h['a@b.c'].each_presence { presences += 1 }
+    assert_equal(2, presences)
+
+    send("<presence from='a@b.c/r' type='error'/>")
+    presence_waiter.lock
+
+    assert_kind_of(Roster::Helper::RosterItem, cb_item)
+    assert_kind_of(Presence, cb_op)
+    assert_nil(cb_op.type)
+    assert_kind_of(Presence, cb_p)
+    assert_equal(:error, cb_p.type)
+    assert_equal(true, h['a@b.c'].online?)
+    presences = 0
+    h['a@b.c'].each_presence { presences += 1 }
+    assert_equal(2, presences)
+
+    send("<presence from='a@b.c/r2' type='unavailable'/>")
+    presence_waiter.lock
+
+    assert_kind_of(Roster::Helper::RosterItem, cb_item)
+    assert_kind_of(Presence, cb_op)
+    assert_nil(cb_op.type)
+    assert_kind_of(Presence, cb_p)
+    assert_equal(:unavailable, cb_p.type)
+    assert_equal(false, h['a@b.c'].online?)
+    presences = 0
+    h['a@b.c'].each_presence { presences += 1 }
+    assert_equal(2, presences)
+
+    send("<presence from='a@b.c/r'/>")
+    presence_waiter.lock
+
+    assert_kind_of(Roster::Helper::RosterItem, cb_item)
+    assert_kind_of(Presence, cb_op)
+    assert_equal(:error, cb_op.type)
+    assert_kind_of(Presence, cb_p)
+    assert_nil(cb_p.type)
+    assert_equal(true, h['a@b.c'].online?)
+    presences = 0
+    h['a@b.c'].each_presence { presences += 1 }
+    assert_equal(2, presences)
+
+    send("<presence from='a@b.c/r2'/>")
+    presence_waiter.lock
+
+    assert_kind_of(Roster::Helper::RosterItem, cb_item)
+    assert_kind_of(Presence, cb_op)
+    assert_equal(:unavailable, cb_op.type)
+    assert_kind_of(Presence, cb_p)
+    assert_nil(cb_p.type)
+    assert_equal(true, h['a@b.c'].online?)
+    presences = 0
+    h['a@b.c'].each_presence { presences += 1 }
+    assert_equal(2, presences)
+
+    send("<presence from='a@b.c' type='error'/>")
+    2.times {
+      presence_waiter.lock
+
+      assert_kind_of(Roster::Helper::RosterItem, cb_item)
+      assert_kind_of(Presence, cb_op)
+      assert_kind_of(Presence, cb_p)
+      assert_equal(:error, cb_p.type)
+    }
+    assert_equal(false, h['a@b.c'].online?)
+    presences = 0
+    h['a@b.c'].each_presence { presences += 1 }
+    assert_equal(1, presences)
+
+    send("<presence from='a@b.c/r'/>")
+    presence_waiter.lock
+
+    assert_kind_of(Roster::Helper::RosterItem, cb_item)
+    assert_nil(cb_op)
+    assert_kind_of(Presence, cb_p)
+    assert_nil(cb_p.type)
+    assert_equal(true, h['a@b.c'].online?)
+    presences = 0
+    h['a@b.c'].each_presence { presences += 1 }
+    assert_equal(1, presences)
+  end
+
+  def test_subscribe
+    state { |iq|
+      send("<iq type='result' id='#{iq.id}'>
+              <query xmlns='jabber:iq:roster'/>
+            </iq>")
+    }
+
+    query_waiter = Mutex.new
+    query_waiter.lock
+    h = Roster::Helper::new(@client)
+    h.add_query_callback { |iq| query_waiter.unlock }
+    wait_state
+    query_waiter.lock
+
+    state { |iq|
+      assert_kind_of(Iq, iq)
+      assert_equal('jabber:iq:roster', iq.queryns)
+      assert_equal(JID.new('contact@example.org'), iq.query.first_element('item').jid)
+      assert_equal('MyContact', iq.query.first_element('item').iname)
+      send("<iq type='set'>
+              <query xmlns='jabber:iq:roster'>
+                <item jid='contact@example.org' subscription='none' name='MyContact'/>
+              </query>
+            </iq>
+            <iq type='result' id='#{iq.id}'/>")
+    }
+    state { |pres|
+      assert_kind_of(Presence, pres)
+      assert_equal(:subscribe, pres.type)
+      assert_equal(JID.new('contact@example.org'), pres.to)
+    }
+    h.add('contact@example.org', 'MyContact', true)
+    wait_state
+    query_waiter.lock
+    wait_state
+  end
+
+  def test_accept_subscription
+    state { |iq|
+      send("<iq type='result' id='#{iq.id}'>
+              <query xmlns='jabber:iq:roster'/>
+            </iq>")
+    }
+
+    query_waiter = Mutex.new
+    query_waiter.lock
+    h = Roster::Helper::new(@client)
+    h.add_query_callback { |iq| query_waiter.unlock }
+    wait_state
+    query_waiter.lock
+
+    cb_lock = Mutex.new
+    cb_lock.lock
+    h.add_subscription_request_callback { |item,pres|
+      assert_nil(item)
+      assert_kind_of(Presence, pres)
+      h.accept_subscription(pres.from)
+
+      cb_lock.unlock
+    }
+
+    send("<presence type='subscribe' from='contact@example.org' to='user@example.com'/>")
+    cb_lock.lock
+
+    state { |pres|
+      assert_kind_of(Presence, pres)
+      assert_equal(:subscribed, pres.type)
+      assert_equal(JID.new('contact@example.org'), pres.to)
+    }
+    wait_state
+  end
+
+  def test_decline_subscription
+    state { |iq|
+      send("<iq type='result' id='#{iq.id}'>
+              <query xmlns='jabber:iq:roster'/>
+            </iq>")
+    }
+
+    query_waiter = Mutex.new
+    query_waiter.lock
+    h = Roster::Helper::new(@client)
+    h.add_query_callback { |iq| query_waiter.unlock }
+    wait_state
+    query_waiter.lock
+
+    cb_lock = Mutex.new
+    cb_lock.lock
+    h.add_subscription_request_callback { |item,pres|
+      assert_nil(item)
+      assert_kind_of(Presence, pres)
+      h.decline_subscription(pres.from)
+
+      cb_lock.unlock
+    }
+
+    send("<presence type='subscribe' from='contact@example.org' to='user@example.com'/>")
+    cb_lock.lock
+
+    state { |pres|
+      assert_kind_of(Presence, pres)
+      assert_equal(:unsubscribed, pres.type)
+      assert_equal(JID.new('contact@example.org'), pres.to)
+    }
+    wait_state
+  end
+end
+

data/test/roster/tc_iqqueryroster.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/roster/iq/roster'
+include Jabber
+
+class Roster::IqQueryRosterTest < Test::Unit::TestCase
+  def test_create
+    r = Roster::IqQueryRoster::new
+    assert_equal('jabber:iq:roster', r.namespace)
+    assert_equal(r.to_a.size, 0)
+    assert_equal(r.to_a, [])
+    assert_equal(r.to_s, "<query xmlns='jabber:iq:roster'/>")
+  end
+
+  def test_import
+    iq = Iq::new
+    q = REXML::Element::new('query')
+    q.add_namespace('jabber:iq:roster')
+    iq.add(q)
+    iq2 = Iq::new.import(iq)
+    assert_equal(Roster::IqQueryRoster, iq2.query.class)
+  end
+
+  def test_items
+    r = Roster::IqQueryRoster::new
+    r.add(Roster::RosterItem.new)
+    r.add(Roster::RosterItem.new(JID.new('a@b/d'), 'ABC', :none, :subscribe)).groups = ['a']
+    itemstr = "<item jid='astro@spaceboyz.net' name='Astro' subscribtion='both'>" \
+            + "<group>SpaceBoyZ</group><group>xmpp4r</group></item>"
+    r.typed_add(REXML::Document.new(itemstr).root)
+
+    r.each { |item|
+      assert_equal(item, r[item.jid])
+    }
+
+    r.to_a.each { |item|
+      assert_equal(item, r[item.jid])
+    }
+
+    assert_equal(JID.new, r.to_a[0].jid)
+    assert_equal(nil, r.to_a[0].iname)
+    assert_equal(nil, r.to_a[0].subscription)
+    assert_equal(nil, r.to_a[0].ask)
+
+    assert_equal(JID.new('a@b/d'), r.to_a[1].jid)
+    assert_equal('ABC', r.to_a[1].iname)
+    assert_equal(:none, r.to_a[1].subscription)
+    assert_equal(:subscribe, r.to_a[1].ask)
+
+    assert_equal(REXML::Document.new(itemstr).root.to_s, r.to_a[2].to_s)
+  end
+
+  def test_dupitems
+    r = Roster::IqQueryRoster::new
+    jid = JID::new('a@b')
+    jid2 = JID::new('c@d')
+    ri = Roster::RosterItem::new(jid, 'ab')
+    r.add(ri)
+    assert_equal('ab', ri.iname)
+    assert_equal('ab', r[jid].iname)
+    ri.iname = 'cd'
+    assert_equal('cd', ri.iname)
+    # There are no shallow copies - everything is alright.
+    assert_equal('cd', r[jid].iname)
+
+    r.add(ri)
+    assert_equal('cd', r[jid].iname)
+    assert_equal(ri, r[jid])
+
+    ri.jid = jid2
+    assert_equal(nil, r[jid])
+    assert_equal(ri, r[jid2])
+    assert_equal(2, r.to_a.size)
+
+    r.each_element('item') { |item|
+      assert_equal(ri, item)
+      assert_equal(ri.jid, item.jid)
+      assert_equal(ri.iname, item.iname)
+      assert_equal(jid2, item.jid)
+      assert_equal('cd', item.iname)
+    }
+  end
+end
+
+class Roster::RosterItemTest < Test::Unit::TestCase
+  def test_create
+    ri = Roster::RosterItem::new
+    assert_equal(JID.new, ri.jid)
+    assert_equal(nil, ri.iname)
+    assert_equal(nil, ri.subscription)
+    assert_equal(nil, ri.ask)
+
+    ri = Roster::RosterItem::new(JID.new('a@b/c'), 'xyz', :both, nil)
+    assert_equal(JID.new('a@b/c'), ri.jid)
+    assert_equal('xyz', ri.iname)
+    assert_equal(:both, ri.subscription)
+    assert_equal(nil, ri.ask)
+  end
+
+  def test_modify
+    ri = Roster::RosterItem::new(JID.new('a@b/c'), 'xyz', :both, :subscribe)
+
+    assert_equal(JID.new('a@b/c'), ri.jid)
+    ri.jid = nil
+    assert_equal(JID::new, ri.jid)
+
+    assert_equal('xyz', ri.iname)
+    ri.iname = nil
+    assert_equal(nil, ri.iname)
+
+    assert_equal(:both, ri.subscription)
+    ri.subscription = nil
+    assert_equal(nil, ri.subscription)
+
+    assert_equal(:subscribe, ri.ask)
+    ri.ask = nil
+    assert_equal(nil, ri.ask)
+  end
+
+  def test_groupdeletion
+    ri = Roster::RosterItem::new
+    g1 = ['a', 'b', 'c']
+    ri.groups = g1
+    assert_equal(g1, ri.groups.sort)
+    g2 = ['c', 'd', 'e']
+    ri.groups = g2
+    assert_equal(g2, ri.groups.sort)
+  end
+
+  def test_dupgroups
+    ri = Roster::RosterItem::new
+    mygroups = ['a', 'a', 'b']
+    ri.groups = mygroups
+    assert_equal(mygroups.uniq, ri.groups)
+  end
+end

data/test/roster/tc_xroster.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/roster/x/roster'
+require 'xmpp4r/jid'
+include Jabber
+
+class Roster::XRosterTest < Test::Unit::TestCase
+  def test_create
+    r = Roster::XRoster.new
+    assert_equal('x', r.name)
+    assert_equal('http://jabber.org/protocol/rosterx', r.namespace)
+  end
+
+  def test_import
+    x1 = X.new
+    x1.add_namespace('jabber:x:roster')
+    x2 = X::import(x1)
+    assert_equal(Roster::XRoster, x2.class)
+    assert_equal('jabber:x:roster', x2.namespace)
+  end
+
+  def test_typed_add
+    x = REXML::Element.new('x')
+    x.add(REXML::Element.new('item'))
+    r = Roster::XRoster.new.import(x)
+    assert_kind_of(Roster::XRosterItem, r.first_element('item'))
+    assert_kind_of(Roster::XRosterItem, r.typed_add(REXML::Element.new('item')))
+  end
+  
+  def test_items
+    j1 = Roster::XRosterItem.new
+    assert_equal(JID.new(nil), j1.jid)
+    assert_equal(nil, j1.iname)
+
+    j2 = Roster::XRosterItem.new(JID.new('a@b/c'))
+    assert_equal(JID.new('a@b/c'), j2.jid)
+    assert_equal(nil, j2.iname)
+    j3 = Roster::XRosterItem.new(JID.new('a@b/c'), 'Mr. Abc')
+    assert_equal(JID.new('a@b/c'), j3.jid)
+    assert_equal('Mr. Abc', j3.iname)
+    assert_equal([], j3.groups)
+
+    j3.groups = ['X', 'Y', 'Z']
+    assert_equal(['X', 'Y', 'Z'], j3.groups)
+  end
+
+  def test_actions
+    j = Roster::XRosterItem.new
+    assert_equal(:add, j.action)
+
+    j.action = :modify
+    assert_equal(:modify, j.action)
+
+    j.action = :delete
+    assert_equal(:delete, j.action)
+
+    j.action = :invalid
+    assert_equal(:add, j.action)
+
+    j.attributes['action'] = 'modify'
+    assert_equal(:modify, j.action)
+
+    j.attributes['action'] = 'invalid'
+    assert_equal(:add, j.action)
+  end
+end