xmpp4r 0.3.1 → 0.3.2

data/test/roster/tc_iqqueryroster.rb

@@ -5,6 +5,8 @@ $:.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
@@ -25,6 +27,37 @@ class Roster::IqQueryRosterTest < Test::Unit::TestCase
     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)

data/test/roster/tc_xroster.rb

@@ -10,9 +10,12 @@ 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)
+    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

data/test/rpc/tc_helper.rb

@@ -0,0 +1,84 @@
+#!/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
+      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 test_simple
+    give_client_jid!
+
+    sv = RPC::Server.new(@server)
+    sv.add_handler("echo") do |s| s end
+
+    cl = RPC::Client.new(@client, 'a@b/c')
+    assert_equal('Test string', cl.call("echo", 'Test string'))
+  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_100calls
+    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
+    100.times {
+      a, b = rand(1000), rand(1000)
+      correct &&= (cl.call('add', a, b) == a + b)
+    }
+
+    assert(correct)
+  end
+end
+

data/test/tc_callbacks.rb

@@ -3,7 +3,8 @@
 $:.unshift '../lib'
 
 require 'test/unit'
-require 'callbacks'
+require 'xmpp4r/callbacks'
+include Jabber
 
 class CallbacksTest < Test::Unit::TestCase
   def test_test1

data/test/tc_class_names.rb

@@ -29,7 +29,8 @@ class JIDTest < Test::Unit::TestCase
     assert_kind_of(Class, Jabber::Stream)
     assert_kind_of(Class, Jabber::StreamParser)
     assert_kind_of(Class, Jabber::X)
-    assert_kind_of(Class, Jabber::XMLStanza)
+    assert_kind_of(Class, Jabber::XMPPElement)
+    assert_kind_of(Class, Jabber::XMPPStanza)
   end
 
   def test_roster
@@ -126,4 +127,11 @@ class JIDTest < Test::Unit::TestCase
     assert_kind_of(Class, Jabber::Version::SimpleResponder)
     assert_kind_of(Class, Jabber::Version::IqQueryVersion)
   end
+
+  def test_rpc
+    require 'xmpp4r/rpc'
+    assert_kind_of(Module, Jabber::RPC)
+    assert_kind_of(Class, Jabber::RPC::Server)
+    assert_kind_of(Class, Jabber::RPC::Client)
+  end
 end

data/test/tc_error.rb

@@ -3,6 +3,7 @@
 $:.unshift '../lib'
 
 require 'test/unit'
+require 'xmpp4r'
 require 'xmpp4r/rexmladdons'
 require 'xmpp4r/error'
 require 'xmpp4r/message'

data/test/tc_iq.rb

@@ -12,41 +12,42 @@ class IqTest < Test::Unit::TestCase
   def test_create
     x = Iq::new()
     assert_equal("iq", x.name)
-    assert_equal("<iq/>", x.to_s)
+    assert_equal("jabber:client", x.namespace)
+    assert_equal("<iq xmlns='jabber:client'/>", x.to_s)
   end
 
   def test_iqauth
     x = Iq::new_authset(JID::new('node@domain/resource'), 'password')
-    assert_equal("<iq type='set'><query xmlns='jabber:iq:auth'><username>node</username><password>password</password><resource>resource</resource></query></iq>", x.to_s)
+    assert_equal("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:auth'><username>node</username><password>password</password><resource>resource</resource></query></iq>", x.to_s)
   end
 
   def test_iqauth_digest
     x = Iq::new_authset_digest(JID::new('node@domain/resource'), '', 'password')
-    assert_equal("<iq type='set'><query xmlns='jabber:iq:auth'><username>node</username><digest>#{Digest::SHA1.hexdigest('password')}</digest><resource>resource</resource></query></iq>", x.to_s)
+    assert_equal("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:auth'><username>node</username><digest>#{Digest::SHA1.hexdigest('password')}</digest><resource>resource</resource></query></iq>", x.to_s)
   end
 
   def test_register
     x1 = Iq::new_register
-    assert_equal("<iq type='set'><query xmlns='jabber:iq:register'/></iq>", x1.to_s)
+    assert_equal("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:register'/></iq>", x1.to_s)
     x2 = Iq::new_register('node')
-    assert_equal("<iq type='set'><query xmlns='jabber:iq:register'><username>node</username></query></iq>", x2.to_s)
+    assert_equal("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:register'><username>node</username></query></iq>", x2.to_s)
     x3 = Iq::new_register('node', 'password')
-    assert_equal("<iq type='set'><query xmlns='jabber:iq:register'><username>node</username><password>password</password></query></iq>", x3.to_s)
+    assert_equal("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:register'><username>node</username><password>password</password></query></iq>", x3.to_s)
   end
 
   def test_rosterget
     x = Iq::new_rosterget
-    assert_equal("<iq type='get'><query xmlns='jabber:iq:roster'/></iq>", x.to_s)
+    assert_equal("<iq type='get' xmlns='jabber:client'><query xmlns='jabber:iq:roster'/></iq>", x.to_s)
   end
 
   def test_rosterset
     x = Iq::new_rosterset
-    assert_equal("<iq type='set'><query xmlns='jabber:iq:roster'/></iq>", x.to_s)
+    assert_equal("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:roster'/></iq>", x.to_s)
   end
 
   def test_browseget
     x = Iq::new_browseget
-    assert_equal("<iq type='get'><query xmlns='jabber:iq:browse'/></iq>", x.to_s)
+    assert_equal("<iq type='get' xmlns='jabber:client'><query xmlns='jabber:iq:browse'/></iq>", x.to_s)
   end
 
   def test_types
@@ -69,14 +70,14 @@ class IqTest < Test::Unit::TestCase
     assert_equal(nil, x.queryns)
     query = REXML::Element::new('query')
     x.add(query)
-    assert_equal('', x.queryns)
+    assert_equal('jabber:client', x.queryns)
     query.add_namespace('jabber:iq:auth')
     assert_equal(query.to_s, x.query.to_s)
     assert_equal('jabber:iq:auth', x.queryns)
 
     query2 = REXML::Element::new('query')
     x.query = query2
-    assert_equal('', x.queryns)
+    assert_equal('jabber:client', x.queryns)
     query2.add_namespace('jabber:iq:register')
     assert_equal('jabber:iq:register', x.queryns)
   end
@@ -104,6 +105,6 @@ class IqTest < Test::Unit::TestCase
     assert_equal(nil, x.from)
     assert_equal(JID.new('a@b/c'), x.to)
     assert_kind_of(IqQuery, x.query)
-    assert_equal('', x.queryns)
+    assert_equal('jabber:client', x.queryns)
   end
 end

data/test/tc_message.rb

@@ -12,6 +12,7 @@ class MessageTest < Test::Unit::TestCase
   def test_create
     x = Message::new()
     assert_equal("message", x.name)
+    assert_equal("jabber:client", x.namespace)
     assert_equal(nil, x.to)
     assert_equal(nil, x.body)
 

data/test/tc_presence.rb

@@ -12,6 +12,7 @@ class PresenceTest < Test::Unit::TestCase
   def test_create
     x = Presence::new()
     assert_equal("presence", x.name)
+    assert_equal("jabber:client", x.namespace)
     assert_equal(nil, x.to)
     assert_equal(nil, x.show)
     assert_equal(nil, x.status)

data/test/tc_rexml.rb

@@ -51,7 +51,7 @@ class REXMLTest < Test::Unit::TestCase
     e.attributes['x'] = '&'
     assert_equal('&', e.attributes['x'])
     e.attributes['x'] = '&amp;'
-    assert_equal('&amp;', e.attributes['x'])
+    assert_equal('&', e.attributes['x']) # this one should not be escaped
     e.attributes['x'] = '&nbsp'
     assert_equal('&nbsp', e.attributes['x'])
     e.attributes['x'] = '&nbsp;'

data/test/tc_stream.rb

@@ -6,24 +6,23 @@ require 'tempfile'
 require 'test/unit'
 require 'socket'
 require 'xmpp4r/stream'
+require 'xmpp4r/semaphore'
 include Jabber
 
-
 class StreamTest < Test::Unit::TestCase
   def setup
     @tmpfile = Tempfile::new("StreamSendTest")
     @tmpfilepath = @tmpfile.path()
     @tmpfile.unlink
     @servlisten = UNIXServer::new(@tmpfilepath)
-    @server = nil
     thServer = Thread.new { @server = @servlisten.accept }
     @iostream = UNIXSocket::new(@tmpfilepath)
     n = 0
-    while @server.nil? and n < 10
+    while not defined? @server and n < 10
       sleep 0.1
       n += 1
     end
-    @stream = Stream::new(false)
+    @stream = Stream::new
     @stream.start(@iostream)
   end
 
@@ -33,150 +32,196 @@ class StreamTest < Test::Unit::TestCase
   end
 
   ##
-  # tests that stream really waits the call to process() to dispatch
+  # tests that connection really waits the call to process() to dispatch
   # stanzas to filters
   def test_process
-=begin
-Disabled, because non-threaded mode is broken
-
     called = false
     @stream.add_xml_callback { called = true }
     assert(!called)
     @server.puts('<stream:stream>')
     @server.flush
-    sleep 0.1
-    assert(!called)
-    @stream.process
     assert(called)
-=end
   end
 
-  ##
-  # tests that you can select how many messages you want to get with process
-  def test_process_multi
-=begin
-Disabled, because non-threaded mode is broken
+  def test_process100
+    @server.puts('<stream:stream>')
+    @server.flush
 
-    nbcalls = 0
-    called = false
-    @stream.add_xml_callback { |element|
-      nbcalls += 1
-      if element.name == "message"
-        called = true
-      end
+    done = Semaphore.new
+    n = 0
+    @stream.add_message_callback {
+      n += 1
+      done.run if n % 100 == 0
     }
-    assert(!called)
-    @server.puts('<stream:stream/>')
-    @server.flush
-    assert(!called)
-    @stream.process
-    assert(!called)
-    assert_equal(1, nbcalls)
-    for i in 1..10
-      @server.puts('<presence/>')
+
+    100.times {
+      @server.puts('<message/>')
       @server.flush
-    end
-    @server.puts('<message/>')
+    }
+
+    done.wait
+    assert_equal(100, n)
+
+    @server.puts('<message/>' * 100)
     @server.flush
-    assert(!called)
-    assert_equal(1, nbcalls)
-    @stream.process(8)
-    assert_equal(9, nbcalls)
-    assert(!called)
-    @stream.process(2)
-    assert_equal(11, nbcalls)
-    assert(!called)
-    @stream.process(1)
-    assert_equal(12, nbcalls)
-    assert(called)
-=end
+
+    done.wait
+    assert_equal(200, n)
   end
 
-  # tests that you can get all waiting messages if you don't use a parameter
-  def test_process_multi2
-=begin
-Disabled, because non-threaded mode is broken
-
-    @called = false
-    @nbcalls = 0
-    @stream.add_xml_callback { |element|
-      @nbcalls += 1
-      if element.name == "message"
-        @called = true
+  def test_send
+    @server.puts('<stream:stream>')
+    @server.flush
+
+    Thread.new {
+      assert_equal(Iq.new(:get).delete_namespace.to_s, @server.gets('>'))
+      @stream.receive(Iq.new(:result))
+    }
+
+    called = 0
+    @stream.send(Iq.new(:get)) { |reply|
+      called += 1
+      if reply.kind_of? Iq and reply.type == :result
+        true
+      else
+        false
       end
     }
-    assert(!@called)
+
+    assert_equal(1, called)
+  end
+
+  def test_send_nested
     @server.puts('<stream:stream>')
     @server.flush
-    assert(!@called)
-    @stream.process
-    assert(!@called)
-    assert_equal(1, @nbcalls)
-    for i in 1..20
-      @server.puts('<iq/>')
+    finished = Semaphore.new
+
+    Thread.new {
+      assert_equal(Iq.new(:get).delete_namespace.to_s, @server.gets('>'))
+      @server.puts(Iq.new(:result).set_id('1').delete_namespace.to_s)
+      @server.flush
+      assert_equal(Iq.new(:set).delete_namespace.to_s, @server.gets('>'))
+      @server.puts(Iq.new(:result).set_id('2').delete_namespace.to_s)
+      @server.flush
+      assert_equal(Iq.new(:get).delete_namespace.to_s, @server.gets('>'))
+      @server.puts(Iq.new(:result).set_id('3').delete_namespace.to_s)
       @server.flush
+
+      finished.run
+    }
+
+    called_outer = 0
+    called_inner = 0
+
+    @stream.send(Iq.new(:get)) do |reply|
+      called_outer += 1
+      assert_kind_of(Iq, reply)
+      assert_equal(:result, reply.type)
+      
+      if reply.id == '1'
+        @stream.send(Iq.new(:set)) do |reply2|
+          called_inner += 1
+          assert_kind_of(Iq, reply2)
+          assert_equal(:result, reply2.type)
+          assert_equal('2', reply2.id)
+
+          @stream.send(Iq.new(:get))
+
+          true
+        end
+        false
+      elsif reply.id == '3'
+        true
+      else
+        false
+      end
     end
-    @server.puts('<message/>')
+
+    assert_equal(2, called_outer)
+    assert_equal(1, called_inner)
+
+    finished.wait
+  end
+
+  def test_send_in_callback
+    @server.puts('<stream:stream>')
     @server.flush
-    assert(!@called)
-    assert_equal(1, @nbcalls)
-    @stream.process
-    assert_equal(22, @nbcalls)
-    assert(@called)
-=end
+    finished = Semaphore.new
+
+    @stream.add_message_callback {
+      @stream.send_with_id(Iq.new(:get)) { |reply|
+        assert_equal(:result, reply.type)
+      }
+    }
+
+    Thread.new {
+      @server.gets('>')
+      @server.puts(Iq.new(:result))
+      finished.run
+    }
+
+    @server.puts(Message.new)
+    finished.wait
+  end
+
+  def test_bidi
+    @server.puts('<stream:stream>')
+    @server.flush
+    finished = Semaphore.new
+    ok = true
+    n = 100
+
+    Thread.new {
+      n.times { |i|
+        ok &&= (Iq.new(:get).set_id(i).delete_namespace.to_s == @server.gets('>'))
+        @server.puts(Iq.new(:result).set_id(i).to_s)
+        @server.flush
+      }
+
+      finished.run
+    }
+
+    n.times { |i|
+      @stream.send(Iq.new(:get).set_id(i)) { |reply|
+        ok &&= reply.kind_of? Iq
+        ok &&= (:result == reply.type)
+        ok &&= (i.to_s == reply.id)
+        true
+      }
+    }
+
+    finished.wait
+    assert(ok)
   end
 
-  # Check that <message><message/></message> is recognized as one Message
   def test_similar_children
+    delay = 0.1
     n = 0
     @stream.add_message_callback { n += 1 }
     assert_equal(0, n)
     @server.puts('<stream:stream><message/>')
     @server.flush
-    @stream.process
+    sleep delay
     assert_equal(1, n)
     @server.puts('<message>')
     @server.flush
-    @stream.process
+    sleep delay
     assert_equal(1, n)
     @server.puts('<message/>')
     @server.flush
-    @stream.process
+    sleep delay
     assert_equal(1, n)
     @server.puts('</message>')
     @server.flush
-    @stream.process
+    sleep delay
     assert_equal(2, n)
     @server.puts('<message><stream:stream><message/></stream:stream>')
     @server.flush
-    @stream.process
+    sleep delay
     assert_equal(2, n)
     @server.puts('</message>')
     @server.flush
-    @stream.process
+    sleep delay
     assert_equal(3, n)
   end
-
-  def test_send
-    @server.puts('<stream:stream>')
-    @server.flush
-    @stream.process
-
-    Thread.new {
-      assert_equal(Iq.new(:get).to_s, @server.gets('>'))
-      @stream.receive(Iq.new(:result))
-    }
-
-    called = 0
-    @stream.send(Iq.new(:get)) { |reply|
-      called += 1
-      if reply.kind_of? Iq and reply.type == :result
-        true
-      else
-        false
-      end
-    }
-
-    assert_equal(1, called)
-  end
 end