xmpp4r 0.3

data/test/bytestreams/tc_ibb.rb

@@ -0,0 +1,186 @@
+#!/usr/bin/ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require File::dirname(__FILE__) + '/../lib/clienttester'
+
+require 'xmpp4r'
+require 'xmpp4r/bytestreams'
+include Jabber
+
+class IBBTest < Test::Unit::TestCase
+  include ClientTester
+
+  def create_buffer(size)
+    ([nil] * size).collect { rand(256).chr }.join
+  end
+
+  def test_ibb_target2initiator
+    target = Bytestreams::IBBTarget.new(@server, '1', nil, '1@a.com/1')
+    initiator = Bytestreams::IBBInitiator.new(@client, '1', nil, '1@a.com/1')
+
+    buffer = create_buffer(9999)
+
+    Thread.new do
+      target.accept
+      target.write(buffer)
+      Thread.pass
+      target.close
+    end
+
+
+    initiator.open
+
+    received = ''
+    while buf = initiator.read
+      received += buf
+    end
+
+    initiator.close
+
+    assert_equal(buffer, received)
+  end
+
+  def test_ibb_initiator2target
+    target = Bytestreams::IBBTarget.new(@server, '1', nil, '1@a.com/1')
+    initiator = Bytestreams::IBBInitiator.new(@client, '1', nil, '1@a.com/1')
+
+    buffer = create_buffer(9999)
+
+    Thread.new do
+      Thread.pass
+      initiator.open
+      initiator.write(buffer)
+      Thread.pass
+      initiator.close
+    end
+
+
+    target.accept
+
+    received = ''
+    while buf = target.read
+      received += buf
+    end
+
+    target.close
+
+    assert_equal(buffer, received)
+  end
+  
+  def test_ibb_pingpong
+    ignored_stanzas = 0
+    wait = Mutex.new
+    wait.lock
+    @server.add_message_callback { ignored_stanzas += 1; wait.unlock }
+    @server.add_iq_callback { ignored_stanzas += 1; wait.unlock }
+
+
+    target = Bytestreams::IBBTarget.new(@server, '1', nil, '1@a.com/1')
+    initiator = Bytestreams::IBBInitiator.new(@client, '1', nil, '1@a.com/1')
+
+    Thread.new do
+      target.accept
+
+      while buf = target.read
+        target.write(buf)
+        target.flush
+      end
+
+      target.close
+    end
+
+
+    assert_equal(0, ignored_stanzas)
+    @client.send("<iq from='1@a.com/1' type='set'>
+                    <close xmlns='http://jabber.org/protocol/ibb' sid='another session id'/>
+                  </iq>")
+    wait.lock
+    assert_equal(1, ignored_stanzas)
+
+
+    initiator.open
+
+
+    assert_equal(1, ignored_stanzas)
+    @client.send("<message from='1@a.com/1' type='error'>
+                    <data xmlns='http://jabber.org/protocol/ibb' sid='another session id' seq='0'/>
+                  </message>")
+    wait.lock
+    assert_equal(2, ignored_stanzas)
+    @client.send("<iq from='1@a.com/1' type='set'>
+                    <close xmlns='http://jabber.org/protocol/ibb' sid='another session id'/>
+                  </iq>")
+    wait.lock
+    assert_equal(3, ignored_stanzas)
+
+
+    10.times do
+      buf = create_buffer(9999)
+      initiator.write(buf)
+      initiator.flush
+
+      bufr = ''
+      begin
+        bufr += initiator.read
+      end while bufr.size < buf.size
+      assert_equal(buf, bufr)
+    end
+
+    initiator.close
+
+
+    assert_equal(3, ignored_stanzas)
+  end
+  
+  def test_ibb_error
+    target = Bytestreams::IBBTarget.new(@server, '1', nil, '1@a.com/1')
+    initiator = Bytestreams::IBBInitiator.new(@client, '1', nil, '1@a.com/1')
+
+    Thread.new do
+      target.accept
+
+      @server.send("<message from='1@a.com/1' type='error'>
+                      <data xmlns='http://jabber.org/protocol/ibb' sid='#{target.instance_variable_get(:@session_id)}' seq='0'/>
+                    </message>")
+    end
+
+
+    initiator.open
+
+    assert_nil(initiator.read)
+
+    initiator.close
+  end
+
+  def test_ibb_inactive
+    target = Bytestreams::IBBTarget.new(@server, '1', nil, '1@a.com/1')
+    initiator = Bytestreams::IBBInitiator.new(@client, '1', nil, '1@a.com/1')
+
+    assert_nil(target.read)
+    assert_nil(initiator.read)
+
+    assert_raise(RuntimeError) {
+      target.write('a' * target.block_size)
+    }
+    assert_raise(RuntimeError) {
+      initiator.write('a' * initiator.block_size)
+    }
+  end
+
+  def test_ibb_queueitem
+    i1 = Bytestreams::IBBQueueItem.new(:close)
+    assert_equal(:close, i1.type)
+    assert_nil(i1.seq)
+
+    i2 = Bytestreams::IBBQueueItem.new(:data, 1, Base64::encode64('blah'))
+    assert_equal(:data, i2.type)
+    assert_equal(1, i2.seq)
+    assert_equal('blah', i2.data)
+
+    assert_raise(RuntimeError) {
+      i3 = Bytestreams::IBBQueueItem.new(:invalid)
+    }
+  end
+end

data/test/bytestreams/tc_socks5bytestreams.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require File::dirname(__FILE__) + '/../lib/clienttester'
+
+require 'xmpp4r'
+require 'xmpp4r/bytestreams'
+include Jabber
+
+class SOCKS5BytestreamsTest < Test::Unit::TestCase
+  include ClientTester
+
+  @@server = Bytestreams::SOCKS5BytestreamsServer.new(65005)
+  @@server.add_address('localhost')
+
+  def create_buffer(size)
+    ([nil] * size).collect { rand(256).chr }.join
+  end
+
+  def test_pingpong
+    target = Bytestreams::SOCKS5BytestreamsTarget.new(@server, '1', '1@a.com/1', '1@a.com/2')
+    initiator = Bytestreams::SOCKS5BytestreamsInitiator.new(@client, '1', '1@a.com/1', '1@a.com/2')
+    initiator.add_streamhost(@@server)
+
+
+    Thread.new do
+      target.accept
+
+      while buf = target.read(256)
+        target.write(buf)
+        target.flush
+      end
+
+      target.close
+    end
+
+
+    initiator.open
+
+    10.times do
+      buf = create_buffer(8192)
+      initiator.write(buf)
+      initiator.flush
+
+      bufr = ''
+      begin
+        bufr += initiator.read(256)
+      end while bufr.size < buf.size
+      assert_equal(buf, bufr)
+    end
+
+    initiator.close
+  end
+  
+end

data/test/delay/tc_xdelay.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/delay/x/delay'
+include Jabber
+
+class XDelayTest < Test::Unit::TestCase
+  def test_create1
+    d = Delay::XDelay.new(false)
+    assert_equal(nil, d.stamp)
+    assert_equal(nil, d.from)
+    assert_equal('jabber:x:delay', d.namespace)
+  end
+
+  def test_create2
+    d = Delay::XDelay.new
+    # Hopefully the seconds don't change here...
+    assert_equal(Time.now.to_s, d.stamp.to_s)
+    assert_equal(nil, d.from)
+    assert_equal('jabber:x:delay', d.namespace)
+  end
+
+  def test_from
+    d = Delay::XDelay.new
+    assert_equal(nil, d.from)
+    d.from = JID::new('astro@spaceboyz.net')
+    assert_equal(JID::new('astro@spaceboyz.net'), d.from)
+    assert_equal(d, d.set_from(nil))
+    assert_equal(nil, d.from)
+  end
+
+  def test_stamp
+    d = Delay::XDelay.new(false)
+    assert_equal(nil, d.stamp)
+    now = Time.now
+    d.stamp = now
+    assert_equal(now.to_s, d.stamp.to_s)
+    assert_equal(d, d.set_stamp(nil))
+    assert_equal(nil, d.stamp)
+  end
+
+  def test_import
+    x1 = X.new
+    x1.add_namespace('jabber:x:delay')
+    x2 = X::import(x1)
+    assert_equal(Delay::XDelay, x2.class)
+  end
+end

data/test/lib/clienttester.rb

@@ -0,0 +1,110 @@
+$:.unshift '../lib'
+require 'xmpp4r'
+require 'test/unit'
+require 'socket'
+
+# Turn $VERBOSE off to suppress warnings about redefinition
+oldverbose = $VERBOSE
+$VERBOSE = false
+
+module Jabber
+  ##
+  # The ClientTester is a mix-in which provides a setup and teardown
+  # method to prepare a Stream object (@client) and two methods
+  # interfacing as the "server side":
+  # * send(xml):: Send a stanza to @client
+  # * receive:: (Wait and) retrieve a stanza sent by the client (in order)
+  #
+  # The server side is a stream, too: add your callbacks to @server
+  #
+  # ClientTester is written to test complex helper classes.
+  module ClientTester
+    @@SOCKET_PORT = 65223
+
+    def setup
+      Thread::abort_on_exception = true
+
+      servlisten = TCPServer.new(@@SOCKET_PORT)
+      serverwait = Mutex.new
+      serverwait.lock
+      Thread.new {
+        serversock = servlisten.accept
+        servlisten.close
+        serversock.sync = true
+        @server = Stream.new(true)
+        @server.add_xml_callback { |xml|
+          if xml.prefix == 'stream' and xml.name == 'stream'
+            send('<stream:stream>')
+            true
+          else
+            false
+          end
+        }
+        @server.start(serversock)
+
+        serverwait.unlock
+      }
+
+      clientsock = TCPSocket.new('localhost', @@SOCKET_PORT)
+      clientsock.sync = true
+      @client = Stream.new(true)
+      @client.start(clientsock)
+
+      @client.send('<stream:stream>') { |reply|
+        true
+      }
+
+      @state = 0
+      @states = []
+      @state_wait = Mutex.new
+      @state_wait.lock
+      @server.add_stanza_callback { |stanza|
+        if @state < @states.size
+          @states[@state].call(stanza)
+          @state += 1
+        end
+        @state_wait.unlock
+
+        false
+      }
+
+      serverwait.lock
+    end
+
+    def teardown
+      @client.close
+      @server.close
+    end
+
+    def send(xml)
+      @server.send(xml)
+    end
+
+    def receive
+      @receive_lock.lock
+
+      loop {
+        @stanzas_lock.synchronize {
+          if @stanzas.size > 0
+            @receive_lock.unlock
+            return @stanzas.shift
+          end
+        }
+
+        @receive_lock.lock
+        @receive_lock.unlock
+      }
+    end
+
+    def state(&block)
+      @states << block
+    end
+
+    def wait_state
+      @state_wait.lock
+    end
+  end
+end
+
+# Restore the old $VERBOSE setting
+$VERBOSE = oldverbose