xmpp4r 0.4 → 0.5

data/test/reliable/tc_disconnect_exception.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/ruby
+
+$:.unshift "#{File.dirname(__FILE__)}/../../lib"
+
+require 'test/unit'
+require 'xmpp4r'
+
+class DisconnectExceptionTest < Test::Unit::TestCase
+  class Listener
+    def receive(element)
+    end
+  end
+  
+  def test_streamparser
+    rd, wr = IO.pipe
+    listener = Listener.new
+    exception_raised = nil
+    
+    Thread.new do
+      begin
+        parser = Jabber::StreamParser.new(rd, listener)
+        parser.parse
+      rescue => e
+        exception_raised = e
+      end
+    end
+    
+    wr.write("<hi/>")
+    wr.close
+    sleep(0.1)
+    
+    assert exception_raised
+    assert exception_raised.is_a?(Jabber::ServerDisconnected), "Expected a Jabber::ServerDisconnected but got #{exception_raised}"
+    # puts exception_raised.inspect
+  end
+  
+end

data/test/reliable/tc_listener_mocked_test.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/ruby
+
+$:.unshift "#{File.dirname(__FILE__)}/../../lib"
+
+require 'test/unit'
+require 'xmpp4r'
+
+# Jabber::debug = true
+
+class ReliableListenerTest < Test::Unit::TestCase
+  
+  class TestListener < Jabber::Reliable::Listener
+    attr_accessor :received_messages
+    
+    def on_message(got_message)
+      self.received_messages ||= []
+      self.received_messages << got_message
+    end
+    
+  end
+  
+  def test_listener
+    listener = TestListener.new("listener1@localhost/hi", "test", {:servers => "127.0.0.1", :presence_message => "hi"})
+    Jabber::Test::ListenerMocker.mock_out(listener)
+    listener.start
+    
+    message_to_send = Jabber::Message.new
+    message_to_send.to = "listener1@localhost/hi"
+    message_to_send.body = "hi"
+    
+    listener.send_message(message_to_send)
+    
+    assert_equal(1, listener.received_messages.size)
+    
+    first_message = listener.received_messages[0]
+    assert_equal("hi", first_message.body)
+    listener.stop
+  end
+  
+  def test_listener_stop_and_start
+    listener = TestListener.new("listener1@localhost/hi", "test", {:servers => "127.0.0.1", :presence_message => "hi"})
+    Jabber::Test::ListenerMocker.mock_out(listener)
+    listener.start
+    
+    message_to_send = Jabber::Message.new
+    message_to_send.to = "listener1@localhost/hi"
+    message_to_send.body = "hi"
+    
+    listener.send_message(message_to_send)
+    
+    assert_equal(1, listener.received_messages.size)
+    
+    first_message = listener.received_messages[0]
+    assert_equal("hi", first_message.body)
+    listener.stop
+    
+    assert_raises(ArgumentError){
+      listener.send_message(message_to_send)      
+    }
+    
+    listener.start
+    listener.send_message(message_to_send)    
+
+    assert_equal(2, listener.received_messages.size)
+    listener.stop
+  end
+  
+end

data/test/reliable/tc_reliable_connection.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/ruby
+
+$:.unshift "#{File.dirname(__FILE__)}/../../lib"
+
+require 'test/unit'
+require 'xmpp4r'
+
+# Jabber::debug = true
+
+class ReliableConnectionTest < Test::Unit::TestCase
+    
+  def test_connection_retry
+    @created_sockets = []
+    callback_proc = Proc.new do |socket_init_args|
+      @created_sockets << socket_init_args[0]
+      raise RuntimeError, "Fail to create socket"
+    end
+    Jabber::Test::ListenerMocker.with_socket_mocked(callback_proc) do
+      conn = Jabber::Reliable::Connection.new("listener1@localhost/hi", {
+          :servers => ["server 1", "server 2", "server 3", "server 4"], 
+          :port => 12345,
+          :max_retry => 3, #3 retries = 4 total tries
+          :retry_sleep => 0.1})
+      assert_raises(RuntimeError) do
+        conn.connect
+      end
+      assert_equal(["server 1", "server 2", "server 3", "server 4"], @created_sockets.sort)
+    end
+  end
+  
+end

data/test/roster/tc_helper.rb

@@ -31,10 +31,11 @@ class Roster::HelperTest < Test::Unit::TestCase
     }
 
     query_waiter = Semaphore.new
-    h = Roster::Helper.new(@client)
+    h = Roster::Helper.new(@client, false)
     h.add_query_callback { |iq|
       query_waiter.run
     }
+    h.get_roster
     wait_state
     query_waiter.wait
 
@@ -74,8 +75,9 @@ class Roster::HelperTest < Test::Unit::TestCase
     }
 
     query_waiter = Semaphore.new
-    h = Roster::Helper.new(@client)
+    h = Roster::Helper.new(@client, false)
     h.add_query_callback { |iq| query_waiter.run }
+    h.get_roster
     wait_state
     query_waiter.wait
 
@@ -142,7 +144,7 @@ class Roster::HelperTest < Test::Unit::TestCase
 
     query_waiter = Semaphore.new
     presence_waiter = Semaphore.new
-    h = Roster::Helper.new(@client)
+    h = Roster::Helper.new(@client, false)
     h.add_query_callback { |iq|
       query_waiter.run
     }
@@ -156,7 +158,7 @@ class Roster::HelperTest < Test::Unit::TestCase
       cb_item, cb_op, cb_p = item, oldpres, pres
       presence_waiter.run
     }
-
+    h.get_roster
     wait_state
     query_waiter.wait
 
@@ -289,8 +291,9 @@ class Roster::HelperTest < Test::Unit::TestCase
     }
 
     query_waiter = Semaphore.new
-    h = Roster::Helper.new(@client)
+    h = Roster::Helper.new(@client, false)
     h.add_query_callback { |iq| query_waiter.run }
+    h.get_roster
     wait_state
     query_waiter.wait
 
@@ -326,8 +329,9 @@ class Roster::HelperTest < Test::Unit::TestCase
     }
 
     query_waiter = Semaphore.new
-    h = Roster::Helper.new(@client)
+    h = Roster::Helper.new(@client, false)
     h.add_query_callback { |iq| query_waiter.run }
+    h.get_roster
     wait_state
     query_waiter.wait
 
@@ -362,15 +366,18 @@ class Roster::HelperTest < Test::Unit::TestCase
   end
 
   def test_decline_subscription
+    query_waiter = Semaphore.new
+
     state { |iq|
       send("<iq type='result' id='#{iq.id}'>
               <query xmlns='jabber:iq:roster'/>
             </iq>")
     }
 
-    query_waiter = Semaphore.new
-    h = Roster::Helper.new(@client)
+    h = Roster::Helper.new(@client, false)
     h.add_query_callback { |iq| query_waiter.run }
+    h.get_roster
+
     wait_state
     query_waiter.wait
 
@@ -406,8 +413,9 @@ class Roster::HelperTest < Test::Unit::TestCase
     }
 
     query_waiter = Semaphore.new
-    h = Roster::Helper.new(@client)
+    h = Roster::Helper.new(@client, false)
     h.add_query_callback { query_waiter.run }
+    h.get_roster
     wait_state
     query_waiter.wait
 
@@ -434,8 +442,9 @@ class Roster::HelperTest < Test::Unit::TestCase
     }
 
     query_waiter = Semaphore.new
-    h = Roster::Helper.new(@client)
+    h = Roster::Helper.new(@client, false)
     h.add_query_callback { query_waiter.run }
+    h.get_roster
     wait_state
     query_waiter.wait
 
@@ -474,11 +483,12 @@ class Roster::HelperTest < Test::Unit::TestCase
     update_args = nil
     update_waiter = Semaphore.new
 
-    h = Roster::Helper.new(@client)
+    h = Roster::Helper.new(@client, false)
     h.add_update_callback { |*a|
       update_args = a
       update_waiter.run
     }
+    h.get_roster
 
     send("<iq type='set'>
             <query xmlns='jabber:iq:roster'>

data/test/rpc/tc_helper.rb

@@ -78,7 +78,7 @@ class RPC::HelperTest < Test::Unit::TestCase
     assert_equal(['tseT', 'TEST'], cl.multicall(['reverse', 'Test'], ['upcase', 'Test']))
   end
 
-  def test_100calls
+  def test_10calls
     give_client_jid!
 
     sv = RPC::Server.new(@server)
@@ -86,7 +86,7 @@ class RPC::HelperTest < Test::Unit::TestCase
 
     cl = RPC::Client.new(@client, 'a@b/c')
     correct = true
-    100.times {
+    10.times {
       a, b = rand(1000), rand(1000)
       correct &&= (cl.call('add', a, b) == a + b)
     }

data/test/tc_callbacks.rb

@@ -55,7 +55,7 @@ class CallbacksTest < Test::Unit::TestCase
     cbl.add(7, "ref1") { false }
     o = "o"
     assert(!cbl.process(o))
-   end
+  end
 
   def test_callbacklist5
     cbl = CallbackList.new
@@ -63,7 +63,7 @@ class CallbacksTest < Test::Unit::TestCase
     cbl.add(7, "ref1") { false }
     o = "o"
     assert(cbl.process(o))
-   end
+  end
 
   def test_callbacklist6
     cbl = CallbackList.new
@@ -78,7 +78,7 @@ class CallbacksTest < Test::Unit::TestCase
     }
     assert(!cbl.process(c, d))
     assert(ok)
-   end
+  end
 
   def test_callbacklist7
     cbl = CallbackList.new

data/test/tc_message.rb

@@ -84,6 +84,21 @@ class MessageTest < Test::Unit::TestCase
     assert_equal('abc', x.thread)
   end
 
+  def test_chat_state
+    x = Message.new
+    assert_equal(nil, x.chat_state)
+    chat_state = REXML::Element.new('active')
+    chat_state.add_namespace('http://jabber.org/protocol/chatstates')
+    x.add(chat_state)
+    assert_equal(:active, x.chat_state)
+    x.chat_state = :gone
+    assert_equal(:gone, x.chat_state)
+    assert_raise(InvalidChatState) do
+      x.chat_state = :some_invalid_state
+    end
+    assert_equal true, x.gone?
+  end
+
   def test_error
     x = Message.new()
     assert_equal(nil, x.error)

data/test/tc_stream.rb

@@ -1,36 +1,27 @@
 #!/usr/bin/ruby
 
 $:.unshift '../lib'
+$:.unshift './lib/'
 
 require 'tempfile'
 require 'test/unit'
 require 'socket'
 require 'xmpp4r/stream'
 require 'xmpp4r/semaphore'
+require 'clienttester'
 include Jabber
 
+# Jabber::debug = true
+
 class StreamTest < Test::Unit::TestCase
-  STREAM = '<stream:stream xmlns:stream="http://etherx.jabber.org/streams">'
-
-  def setup
-    @tmpfile = Tempfile.new("StreamSendTest")
-    @tmpfilepath = @tmpfile.path()
-    @tmpfile.unlink
-    @servlisten = UNIXServer.new(@tmpfilepath)
-    thServer = Thread.new { @server = @servlisten.accept }
-    @iostream = UNIXSocket.new(@tmpfilepath)
+  include ClientTester
+
+  def busywait(&block)
     n = 0
-    while not defined? @server and n < 10
-      sleep 0.1
+    while not block.yield and n < 1000
+      Thread::pass
       n += 1
     end
-    @stream = Stream.new
-    @stream.start(@iostream)
-  end
-
-  def teardown
-    @stream.close
-    @server.close
   end
 
   ##
@@ -38,50 +29,43 @@ class StreamTest < Test::Unit::TestCase
   # stanzas to filters
   def test_process
     called = false
-    @stream.add_xml_callback { called = true }
+    @client.add_xml_callback { called = true }
     assert(!called)
-    @server.puts(STREAM)
-    @server.flush
+    @server.send('<iq/>')
+    busywait { called }
     assert(called)
   end
 
-  def test_process100
-    @server.puts(STREAM)
-    @server.flush
-
+  def test_process20
     done = Semaphore.new
     n = 0
-    @stream.add_message_callback {
+    @client.add_message_callback {
       n += 1
-      done.run if n % 100 == 0
+      done.run if n % 20 == 0
     }
 
-    100.times {
-      @server.puts('<message/>')
-      @server.flush
+    20.times {
+      @server.send('<message/>')
     }
 
     done.wait
-    assert_equal(100, n)
+    assert_equal(20, n)
 
-    @server.puts('<message/>' * 100)
-    @server.flush
+    @server.send('<message/>' * 20)
 
     done.wait
-    assert_equal(200, n)
+    assert_equal(40, n)
   end
 
   def test_send
-    @server.puts(STREAM)
-    @server.flush
-
-    Thread.new {
-      assert_equal(Iq.new(:get).delete_namespace.to_s, @server.gets('>'))
-      @stream.receive(Iq.new(:result))
+    sem = Semaphore::new
+    @server.add_xml_callback { |e|
+      @server.send(Iq.new(:result))
+      sem.run
     }
 
     called = 0
-    @stream.send(Iq.new(:get)) { |reply|
+    @client.send(Iq.new(:get)) { |reply|
       called += 1
       if reply.kind_of? Iq and reply.type == :result
         true
@@ -89,45 +73,44 @@ class StreamTest < Test::Unit::TestCase
         false
       end
     }
-
+    sem.wait
+    busywait { called }
     assert_equal(1, called)
   end
 
   def test_send_nested
-    @server.puts(STREAM)
-    @server.flush
     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
-    }
+    id = 0
+    @server.add_xml_callback do |e|
+      id += 1
+      if id == 1
+        @server.send(Iq.new(:result).set_id('1').delete_namespace)
+      elsif id == 2
+        @server.send(Iq.new(:result).set_id('2').delete_namespace)
+      elsif id == 3
+        @server.send(Iq.new(:result).set_id('3').delete_namespace)
+      else
+        p e
+       end
+    end
 
     called_outer = 0
     called_inner = 0
 
-    @stream.send(Iq.new(:get)) do |reply|
+    @client.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|
+        @client.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))
+          @client.send(Iq.new(:get))
 
           true
         end
@@ -141,89 +124,44 @@ class StreamTest < Test::Unit::TestCase
 
     assert_equal(2, called_outer)
     assert_equal(1, called_inner)
-
-    finished.wait
   end
 
   def test_send_in_callback
-    @server.puts(STREAM)
-    @server.flush
     finished = Semaphore.new
 
-    @stream.add_message_callback {
-      @stream.send_with_id(Iq.new(:get)) { |reply|
+    @client.add_message_callback {
+      @client.send_with_id(Iq.new(:get)) { |reply|
         assert_equal(:result, reply.type)
+        finished.run
       }
     }
 
-    Thread.new {
-      @server.gets('>')
-      @server.puts(Iq.new(:result))
-      finished.run
-    }
-
-    @server.puts(Message.new)
-    finished.wait
-  end
-
-  def test_bidi
-    @server.puts(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
-      }
+    @server.add_iq_callback { |iq|
+      @server.send(Iq.new(:result).set_id(iq.id))
     }
 
+    @server.send(Message.new)
     finished.wait
-    assert(ok)
   end
 
   def test_similar_children
-    delay = 0.1
     n = 0
-    @stream.add_message_callback { n += 1 }
+    @client.add_message_callback { n += 1 }
     assert_equal(0, n)
-    @server.puts("#{STREAM}<message/>")
-    @server.flush
-    sleep delay
+    @server.send("<message/>")
+    busywait { n == 1 }
     assert_equal(1, n)
-    @server.puts('<message>')
-    @server.flush
-    sleep delay
+    @server.send('<message>')
     assert_equal(1, n)
-    @server.puts('<message/>')
-    @server.flush
-    sleep delay
+    @server.send('<message/>')
     assert_equal(1, n)
-    @server.puts('</message>')
-    @server.flush
-    sleep delay
+    @server.send('</message>')
+    busywait { n == 2 }
     assert_equal(2, n)
-    @server.puts("<message>#{STREAM}<message/></stream:stream>")
-    @server.flush
-    sleep delay
+    @server.send("<message><stream:stream><message/></stream:stream>")
     assert_equal(2, n)
-    @server.puts('</message>')
-    @server.flush
-    sleep delay
+    @server.send('</message>')
+    busywait { n == 3 }
     assert_equal(3, n)
   end
 end