gmcmillan-xmpp4r 0.5

data/test/tc_stream.rb

@@ -0,0 +1,193 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+$:.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
+  include ClientTester
+
+  def busywait(&block)
+    n = 0
+    while not block.call and n < 10000
+      Thread::pass
+      n += 1
+    end
+  end
+
+  ##
+  # tests that connection really waits the call to process() to dispatch
+  # stanzas to filters
+  def test_process
+    called = false
+    @client.add_xml_callback { called = true }
+    assert(!called)
+    @server.send('<iq/>')
+    busywait { called }
+    assert(called)
+  end
+
+  def test_process20
+    done = Semaphore.new
+    n = 0
+    @client.add_message_callback {
+      n += 1
+      done.run if n % 20 == 0
+    }
+
+    20.times {
+      @server.send('<message/>')
+    }
+
+    done.wait
+    assert_equal(20, n)
+
+    @server.send('<message/>' * 20)
+
+    done.wait
+    assert_equal(40, n)
+  end
+
+  def test_send
+    sem = Semaphore::new
+    @server.add_xml_callback { |e|
+      @server.send(Iq.new(:result))
+      sem.run
+    }
+
+    called = 0
+    @client.send(Iq.new(:get)) { |reply|
+      called += 1
+      if reply.kind_of? Iq and reply.type == :result
+        true
+      else
+        false
+      end
+    }
+    sem.wait
+    busywait { called }
+    assert_equal(1, called)
+  end
+
+  def test_send_with_callback_timeout_from_block
+    sem = Semaphore::new
+    @server.add_xml_callback { |e|
+      @server.send(Iq.new(:result))
+      sem.run
+    }
+
+    assert_raise Timeout::Error do
+      @client.send(Iq.new(:get), 1) { |reply|
+        sleep(2)
+        true
+      }
+    end
+
+    sem.wait
+  end
+
+  def test_send_with_callback_timeout_from_no_stanza
+    assert_raise Timeout::Error do
+      @client.send(Iq.new(:get), 1) { |reply|
+        true
+      }
+    end
+  end
+
+  def test_send_nested
+    finished = Semaphore.new
+
+    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
+
+    @client.send(Iq.new(:get)) do |reply|
+      called_outer += 1
+      assert_kind_of(Iq, reply)
+      assert_equal(:result, reply.type)
+
+      if reply.id == '1'
+        @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)
+
+          @client.send(Iq.new(:get))
+
+          true
+        end
+        false
+      elsif reply.id == '3'
+        true
+      else
+        false
+      end
+    end
+
+    assert_equal(2, called_outer)
+    assert_equal(1, called_inner)
+  end
+
+  def test_send_in_callback
+    finished = Semaphore.new
+
+    @client.add_message_callback {
+      @client.send_with_id(Iq.new(:get)) { |reply|
+        assert_equal(:result, reply.type)
+        finished.run
+      }
+    }
+
+    @server.add_iq_callback { |iq|
+      @server.send(Iq.new(:result).set_id(iq.id))
+    }
+
+    @server.send(Message.new)
+    finished.wait
+  end
+
+  def test_similar_children
+    n = 0
+    @client.add_message_callback { n += 1 }
+    assert_equal(0, n)
+    @server.send("<message/>")
+    busywait { n == 1 }
+    assert_equal(1, n)
+    @server.send('<message>')
+    assert_equal(1, n)
+    @server.send('<message/>')
+    assert_equal(1, n)
+    @server.send('</message>')
+    busywait { n == 2 }
+    assert_equal(2, n)
+    @server.send("<message><stream:stream><message/></stream:stream>")
+    assert_equal(2, n)
+    @server.send('</message>')
+    busywait { n == 3 }
+    assert_equal(3, n)
+  end
+end

data/test/tc_streamComponent.rb

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+
+$:.unshift '../lib'
+
+require 'tempfile'
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/component'
+require 'xmpp4r/bytestreams'
+require 'xmpp4r/semaphore'
+require 'xmpp4r'
+include Jabber
+
+class StreamComponentTest < Test::Unit::TestCase
+  @@SOCKET_PORT = 65224
+  STREAM = 'stream:stream xmlns:stream="http://etherx.jabber.org/streams"'
+
+  def setup
+    servlisten = TCPServer.new(@@SOCKET_PORT)
+    serverwait = Semaphore.new
+    Thread.new do
+      Thread.current.abort_on_exception = true
+      serversock = servlisten.accept
+      servlisten.close
+      serversock.sync = true
+      @server = Stream.new
+      @server.add_xml_callback do |xml|
+        if xml.prefix == 'stream' and xml.name == 'stream'
+          @server.send("<#{STREAM} xmlns='jabber:component:accept'>")
+          true
+        else
+          false
+        end
+      end
+      @server.start(serversock)
+
+      serverwait.run
+    end
+
+    @stream = Component.new('test')
+    @stream.connect('localhost', @@SOCKET_PORT)
+
+    serverwait.wait
+  end
+
+  def teardown
+    n = 0
+    while @stream.processing > 0 and n < 1000
+      Thread::pass
+      n += 1
+    end
+    n = 0
+    while @server.processing > 0 and n < 1000
+      Thread::pass
+      n += 1
+    end
+    #@stream.close
+    @server.close
+  end
+
+  def test_process
+    stanzas = 0
+    message_lock = Semaphore.new
+    iq_lock = Semaphore.new
+    presence_lock = Semaphore.new
+
+    @stream.add_message_callback { |msg|
+      assert_kind_of(Message, msg)
+      stanzas += 1
+      message_lock.run
+    }
+    @stream.add_iq_callback { |iq|
+      assert_kind_of(Iq, iq)
+      stanzas += 1
+      iq_lock.run
+    }
+    @stream.add_presence_callback { |pres|
+      assert_kind_of(Presence, pres)
+      stanzas += 1
+      presence_lock.run
+    }
+
+    @server.send('<message/>')
+    @server.send('<iq/>')
+    @server.send('<presence/>')
+
+    message_lock.wait
+    iq_lock.wait
+    presence_lock.wait
+
+    assert_equal(3, stanzas)
+  end
+
+  def test_outgoing
+    received_wait = Semaphore.new
+
+    @server.add_message_callback { |msg|
+      assert_kind_of(Message, msg)
+      received_wait.run
+    }
+
+    @stream.send(Message.new)
+    received_wait.wait
+  end
+end

data/test/tc_streamError.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/client'
+include Jabber
+
+class ConnectionErrorTest < Test::Unit::TestCase
+  @@SOCKET_PORT = 65225
+  STREAM = '<stream:stream xmlns:stream="http://etherx.jabber.org/streams">'
+
+  def setup
+    servlisten = TCPServer.new(@@SOCKET_PORT)
+    serverwait = Semaphore.new
+    @server = nil
+    Thread.new do
+      Thread.current.abort_on_exception = true
+      @server = servlisten.accept
+      servlisten.close
+      @server.sync = true
+
+      serverwait.run
+    end
+
+    @conn = TCPSocket.new('localhost', @@SOCKET_PORT)
+
+    serverwait.wait
+  end
+
+  def teardown
+    @conn.close if not @conn.closed?
+    @server.close if not @conn.closed?
+  end
+
+  def test_connectionError_start_withexcblock
+    @stream = Stream.new
+    error = false
+    @stream.on_exception do |e, o, w|
+      # strange exception, it's caused by REXML, actually
+      assert_kind_of(StandardError, e)
+      assert_equal(Jabber::Stream, o.class)
+      assert_equal(:start, w)
+      error = true
+    end
+    assert(!error)
+    begin
+      # wrong port on purpose
+      conn = TCPSocket.new('localhost', 1)
+    rescue
+    end
+    @stream.start(conn)
+    sleep 0.2
+    assert(error)
+    @server.close
+    @stream.close
+  end
+
+  def test_connectionError_parse_withexcblock
+    @stream = Stream.new
+    error = false
+    @stream.start(@conn)
+    @stream.on_exception do |e, o, w|
+      if w == :disconnected
+        assert_equal(nil, e)
+        assert_equal(Jabber::Stream, o.class)
+      else
+        assert_equal(REXML::ParseException, e.class)
+        assert_equal(Jabber::Stream, o.class)
+        assert_equal(:parser, w)
+        error = true
+      end
+    end
+    @server.puts(STREAM)
+    @server.flush
+    assert(!error)
+    @server.puts('</blop>')
+    @server.flush
+    sleep 0.2
+    assert(error)
+    @server.close
+    @stream.close
+  end
+
+  def test_connectionError_send_withexcblock
+    @stream = Stream.new
+    error = 0
+    @stream.start(@conn)
+    @stream.on_exception do |exc, o, w|
+      case w
+      when :sending
+        assert_equal(IOError, exc.class)
+        assert_equal(Jabber::Stream, o.class)
+      when :disconnected
+        assert_equal(nil, exc)
+        assert_equal(Jabber::Stream, o.class)
+      end
+      error += 1
+    end
+    @server.puts(STREAM)
+    @server.flush
+    assert_equal(0, error)
+    @server.close
+    sleep 0.1
+    assert_equal(1, error)
+    @stream.send('</test>')
+    sleep 0.1
+    @stream.send('</test>')
+    sleep 0.1
+    assert_equal(3, error)
+    @stream.close
+  end
+
+  def test_connectionError_send_withoutexcblock
+    @stream = Stream.new
+    @stream.start(@conn)
+    @server.puts(STREAM)
+    @server.flush
+    assert_raise(IOError) do
+      @server.close
+     sleep 0.1
+      @stream.send('</test>')
+      sleep 0.1
+      @stream.send('</test>')
+      sleep 0.1
+    end
+  end
+end

data/test/tc_streamSend.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'socket'
+require 'tempfile'
+require 'io/wait'
+require 'xmpp4r'
+include Jabber
+
+class StreamSendTest < Test::Unit::TestCase
+  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)
+    @stream = Stream.new
+    @stream.start(@iostream)
+
+    thServer.join
+  end
+
+  def teardown
+    @stream.close
+    @server.close
+    @servlisten.close
+  end
+
+  def mysend(s)
+    @stream.send(s)
+    @stream.send("\n") #needed for easy test writing
+  end
+
+  ##
+  # Tries to send a basic message
+  def test_sendbasic
+    mysend(Message.new)
+    assert_equal("<message/>\n", @server.gets)
+  end
+
+  def test_sendmessage
+    mysend(Message.new('lucas@linux.ensimag.fr', 'coucou'))
+    assert_equal("<message to='lucas@linux.ensimag.fr'><body>coucou</body></message>\n", @server.gets)
+  end
+
+  def test_sendpresence
+    mysend(Presence.new)
+    assert_equal("<presence/>\n", @server.gets)
+  end
+
+  def test_sendiq
+    mysend(Iq.new)
+    assert_equal("<iq/>\n", @server.gets)
+  end
+
+end