ln-xmpp4r 0.5

data/test/roster/tc_iqqueryroster.rb

@@ -0,0 +1,173 @@
+#!/usr/bin/ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/roster/iq/roster'
+require 'xmpp4r/jid'
+require 'xmpp4r/iq'
+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_answer
+    iq = Iq.new_rosterget
+    assert_equal(:get, iq.type)
+    assert_nil(iq.to)
+    assert_equal('jabber:client', iq.namespace)
+    assert_equal('jabber:iq:roster', iq.queryns)
+    assert_equal(0, iq.query.children.size)
+
+    iq2 = iq.answer(true)
+    assert_equal(:get, iq2.type)
+    assert_nil(iq2.from)
+    assert_equal('jabber:client', iq2.namespace)
+    assert_equal('jabber:iq:roster', iq2.queryns)
+    assert_equal(0, iq2.query.children.size)
+  end
+
+  def test_xmlns
+    ri = Roster::RosterItem.new
+    assert_equal('jabber:iq:roster', ri.namespace)
+    assert_equal('jabber:iq:roster', ri.attributes['xmlns'])
+
+    r = Roster::IqQueryRoster.new
+    assert_equal('jabber:iq:roster', r.namespace)
+    assert_equal('jabber:iq:roster', r.attributes['xmlns'])
+
+    r.add(ri)
+
+    assert_equal('jabber:iq:roster', ri.namespace)
+    assert_nil(ri.attributes['xmlns'])
+  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,73 @@
+#!/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
+    r1 = Roster::XRoster.new
+    assert_equal('x', r1.name)
+    assert_equal('jabber:x:roster', r1.namespace)
+    r2 = Roster::RosterX.new
+    assert_equal('x', r2.name)
+    assert_equal('http://jabber.org/protocol/rosterx', r2.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

data/test/rpc/tc_helper.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require File::dirname(__FILE__) + '/../lib/clienttester'
+
+require 'xmpp4r'
+require 'xmpp4r/rpc/helper/client'
+require 'xmpp4r/rpc/helper/server'
+include Jabber
+
+class RPC::HelperTest < Test::Unit::TestCase
+  include ClientTester
+
+  def give_client_jid!
+    class << @client
+      remove_method(:jid) # avoids warning
+      def jid; Jabber::JID.new('client@test.com/clienttester'); end
+    end
+  end
+
+  def test_create
+    give_client_jid!
+
+    cl = RPC::Client.new(@client, 'a@b/c')
+    assert_kind_of(RPC::Client, cl)
+    sv = RPC::Server.new(@server)
+    assert_kind_of(RPC::Server, sv)
+  end
+
+  def echo(msg = nil)
+    msg
+  end
+
+  def test_simple
+    give_client_jid!
+
+    sv = RPC::Server.new(@server)
+    sv.add_handler("echo", &method(:echo))
+
+    cl = RPC::Client.new(@client, 'a@b/c')
+    assert_nothing_raised do
+      assert_equal('Test string', cl.call("echo", 'Test string'))
+    end
+
+    # exception during serialisation bug identified on xmpp4r-devel
+    # https://mail.gna.org/public/xmpp4r-devel/2008-05/msg00010.html
+    assert_raise XMLRPC::FaultException do
+      cl.call("echo")
+    end
+  end
+
+  def test_introspection
+    give_client_jid!
+
+    sv = RPC::Server.new(@server)
+    sv.add_introspection
+
+    cl = RPC::Client.new(@client, 'a@b/c')
+    cl_methods = cl.call("system.listMethods")
+    assert(cl_methods.size > 0)
+    cl_methods.each { |method|
+      assert_kind_of(String, method)
+      assert(method =~ /^system\./)
+    }
+  end
+
+  def test_multicall
+    give_client_jid!
+
+    sv = RPC::Server.new(@server)
+    sv.add_multicall
+    sv.add_handler("reverse") do |s| s.reverse end
+    sv.add_handler("upcase") do |s| s.upcase end
+
+    cl = RPC::Client.new(@client, 'a@b/c')
+    assert_equal(['tseT', 'TEST'], cl.multicall(['reverse', 'Test'], ['upcase', 'Test']))
+  end
+
+  def test_10calls
+    give_client_jid!
+
+    sv = RPC::Server.new(@server)
+    sv.add_handler("add") do |a,b| a+b end
+
+    cl = RPC::Client.new(@client, 'a@b/c')
+    correct = true
+    10.times {
+      a, b = rand(1000), rand(1000)
+      correct &&= (cl.call('add', a, b) == a + b)
+    }
+
+    assert(correct)
+  end
+end

data/test/tc_callbacks.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'xmpp4r/callbacks'
+include Jabber
+
+class CallbacksTest < Test::Unit::TestCase
+  def test_test1
+    called = 0
+    cb = Callback.new(5, "toto", Proc.new { called += 1 })
+    assert_equal(5, cb.priority)
+    assert_equal("toto", cb.ref)
+    cb.block.call
+    assert_equal(1, called)
+    cb.block.call
+    assert_equal(2, called)
+  end
+
+  def test_callbacklist1
+    cbl = CallbackList.new
+    called1 = false
+    called2 = false
+    called3 = false
+    called4 = false
+    cbl.add(5, "ref1") { called1 = true ; true }
+    cbl.add(7, "ref1") { |e| called2 = true ; false}
+    cbl.add(9, "ref1") { called3 = true ;false }
+    cbl.add(11, "ref1") { called4 = true ; false }
+    o = "aaaa"
+    assert(cbl.process(o))
+    assert(called1)
+    assert(called2)
+    assert(called3)
+    assert(called4)
+  end
+
+  def test_callbacklist2
+    cbl = CallbackList.new
+    assert(0, cbl.length)
+    cbl.add(5, "ref1") { called1 = true }
+    assert(1, cbl.length)
+    cbl.add(7, "ref2") { |e| called2 = true ; e.consume }
+    assert(2, cbl.length)
+    cbl.delete("ref2")
+    assert(1, cbl.length)
+    cbl.add(9, "ref3") { called3 = true }
+    assert(2, cbl.length)
+  end
+
+  def test_callbacklist4
+    cbl = CallbackList.new
+    cbl.add(5, "ref1") { false }
+    cbl.add(7, "ref1") { false }
+    o = "o"
+    assert(!cbl.process(o))
+  end
+
+  def test_callbacklist5
+    cbl = CallbackList.new
+    cbl.add(5, "ref1") { true }
+    cbl.add(7, "ref1") { false }
+    o = "o"
+    assert(cbl.process(o))
+  end
+
+  def test_callbacklist6
+    cbl = CallbackList.new
+    ok = false
+    c = 'a'
+    d = 'b'
+    cbl.add(5, "ref1") { |a, b|
+      if a == 'a' and b == 'b'
+        ok = true
+      end
+      false
+    }
+    assert(!cbl.process(c, d))
+    assert(ok)
+  end
+
+  def test_callbacklist7
+    cbl = CallbackList.new
+    called1 = false
+    called2 = false
+    called3 = false
+    called4 = false
+    cbl.add(3, "ref1") { called4 = true ; true }
+    cbl.add(5, "ref1") { called1 = true ; true }
+    cbl.add(7, "ref1") { called2 = true ; 'a'}
+    cbl.add(9, "ref1") { called3 = true ;1 }
+    o = "aaaa"
+    assert(cbl.process(o))
+    assert(called1)
+    assert(called2)
+    assert(called3)
+    assert(!called4)
+  end
+
+  def test_nested
+    cbl = CallbackList.new
+    called_outer = 0
+    called_inner = 0
+
+    cbl.add(100, nil) {
+      called_outer += 1
+
+      if called_outer == 1
+        cbl.add(200, nil) {
+          called_inner += 1
+        }
+      end
+    }
+
+    assert_equal(0, called_inner)
+    assert_equal(0, called_outer)
+
+    cbl.process
+
+    assert_equal(0, called_inner)
+    assert_equal(1, called_outer)
+
+    cbl.process
+
+    assert_equal(1, called_inner)
+    assert_equal(2, called_outer)
+  end
+end