xmpp4r 0.3.1 → 0.3.2

data/test/tc_streamComponent.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/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
+
+  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(true)
+      @server.add_xml_callback do |xml|
+        if xml.prefix == 'stream' and xml.name == 'stream'
+          @server.send('<stream: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
+    @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

@@ -8,18 +8,48 @@ require 'xmpp4r/client'
 include Jabber
 
 class ConnectionErrorTest < Test::Unit::TestCase
+  @@SOCKET_PORT = 65225
+
+  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
-    @conn, @server = IO.pipe
-    @stream = Stream::new(false)
+    @stream = Stream::new
     error = false
     @stream.on_exception do |e, o, w|
-      assert_equal(RuntimeError, e.class)
+      # strange exception, it's caused by REXML, actually
+      assert_equal(NameError, e.class)
       assert_equal(Jabber::Stream, o.class)
       assert_equal(:start, w)
       error = true
     end
     assert(!error)
-    @stream.start(nil)
+    begin
+      # wrong port on purpose
+      conn = TCPSocket::new('localhost', 1)
+    rescue
+    end
+    @stream.start(conn)
     sleep 0.2
     assert(error)
     @server.close
@@ -27,8 +57,7 @@ class ConnectionErrorTest < Test::Unit::TestCase
   end
 
   def test_connectionError_parse_withexcblock
-    @conn, @server = IO.pipe
-    @stream = Stream::new(false)
+    @stream = Stream::new
     error = false
     @stream.start(@conn)
     @stream.on_exception do |e, o, w|
@@ -40,9 +69,7 @@ class ConnectionErrorTest < Test::Unit::TestCase
     @server.puts('<stream:stream>')
     @server.flush
     assert(!error)
-    assert_raise(Errno::EPIPE) {
-      @server.puts('</blop>')
-    }
+    @server.puts('</blop>')
     @server.flush
     sleep 0.2
     assert(error)
@@ -51,37 +78,48 @@ class ConnectionErrorTest < Test::Unit::TestCase
   end
 
   def test_connectionError_send_withexcblock
-    @conn, @server = IO.pipe
-    @stream = Stream::new(false)
-    error = false
+    @stream = Stream::new
+    error = 0
     @stream.start(@conn)
-    @stream.on_exception do |e, o, w|
-      assert_equal(IOError, e.class)
-      assert_equal(Jabber::Stream, o.class)
-      assert_equal(:sending, w)
-      error = true
+    @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)
+      else
+        assert(false)
+      end
+      error += 1
     end
     @server.puts('<stream:stream>')
     @server.flush
-    assert(!error)
-    @stream.send('</test>')
-    sleep 0.2
-    assert(error)
+    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
-    @conn, @server = IO.pipe
-    @stream = Stream::new(false)
+    @stream = Stream::new
     @stream.start(@conn)
     @server.puts('<stream:stream>')
     @server.flush
-    assert_raise(IOError) { @stream.send('</test>') }
-    @server.close
-    @stream.close
+    assert_raise(Errno::EPIPE) 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

@@ -17,7 +17,7 @@ class StreamSendTest < Test::Unit::TestCase
     @servlisten = UNIXServer::new(@tmpfilepath)
     thServer = Thread.new { @server = @servlisten.accept }
     @iostream = UNIXSocket::new(@tmpfilepath)
-    @stream = Stream::new(false)
+    @stream = Stream::new
     @stream.start(@iostream)
 
     thServer.join

data/test/tc_xmppstanza.rb

@@ -0,0 +1,125 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/xmppstanza'
+require 'xmpp4r/iq'
+require 'xmpp4r/feature_negotiation'
+require 'xmpp4r/dataforms'
+include Jabber
+
+class XMPPStanzaTest < Test::Unit::TestCase
+
+  ##
+  # Hack: XMPPStanza derives from XMPPElement
+  # which enforces element classes to be named at declaration time
+  class MyXMPPStanza < XMPPStanza
+    name_xmlns 'stanza', 'http://home.gna.org/xmpp4r'
+  end
+
+  class MyStanza < XMPPStanza
+  end
+
+  def test_from
+    x = MyXMPPStanza::new
+    assert_equal(nil, x.from)
+    assert_equal(x, x.set_from("blop"))
+    assert_equal("blop", x.from.to_s)
+    x.from = "tada"
+    assert_equal("tada", x.from.to_s)
+  end
+
+  def test_to
+    x = MyXMPPStanza::new
+    assert_equal(nil, x.to)
+    assert_equal(x, x.set_to("blop"))
+    assert_equal("blop", x.to.to_s)
+    x.to = "tada"
+    assert_equal("tada", x.to.to_s)
+  end
+
+  def test_id
+    x = MyXMPPStanza::new
+    assert_equal(nil, x.id)
+    assert_equal(x, x.set_id("blop"))
+    assert_equal("blop", x.id)
+    x.id = "tada"
+    assert_equal("tada", x.id)
+  end
+
+  def test_type
+    x = MyXMPPStanza::new
+    assert_equal(nil, x.type)
+    assert_equal(x, x.set_type("blop"))
+    assert_equal("blop", x.type)
+    x.type = "tada"
+    assert_equal("tada", x.type)
+  end
+
+  def test_import
+    x = MyXMPPStanza::new
+    x.id = "heya"
+    q = x.add_element("query")
+    q.add_namespace("about:blank")
+    q.add_element("b").text = "I am b"
+    q.add_text("I am text")
+    q.add_element("a").add_attribute("href", "http://home.gna.org/xmpp4r/")
+    x.add_text("yow")
+    x.add_element("query")
+
+    assert_raise(RuntimeError) { iq = Iq.import(x) }
+    x.name = 'iq'
+    iq = Iq.import(x)
+    
+    assert_equal(x.id, iq.id)
+    assert_equal(q.to_s, iq.query.to_s)
+    assert_equal(x.to_s, iq.to_s)
+    assert_equal(q.namespace, iq.queryns)
+  end
+
+  def test_import2
+    feature = FeatureNegotiation::IqFeature.new
+    xdata = feature.add(Dataforms::XData.new(:form))
+    field = xdata.add(Dataforms::XDataField.new('stream-method', :list_single))
+
+    feature2 = FeatureNegotiation::IqFeature.new.import(feature)
+    assert_equal(field.var, feature2.x.fields.first.var)
+    assert_equal(field.type, feature2.x.fields.first.type)
+  end
+
+  def test_error
+    x = MyXMPPStanza::new
+    assert_equal(nil, x.error)
+    x.typed_add(REXML::Element.new('error'))
+    assert_equal('<error/>', x.error.to_s)
+    assert_equal(Error, x.error.class)
+  end
+
+  def test_clone_and_dup
+    x = MyXMPPStanza::new
+    x.attributes['xyz'] = '123'
+    x.text = 'abc'
+
+    assert_equal(x.attributes['xyz'], '123')
+    assert_equal(x.text, 'abc')
+
+    x2 = x.clone
+    assert_kind_of(MyXMPPStanza, x2)
+    assert_equal('123', x2.attributes['xyz'])
+    assert_nil(x2.text)
+
+    x3 = x.dup
+    assert_kind_of(MyXMPPStanza, x3)
+    assert_equal('123', x3.attributes['xyz'])
+    assert_equal('abc', x3.text)
+  end
+
+  def test_raise
+    assert_raises(NoNameXmlnsRegistered) {
+      XMPPStanza.name_xmlns_for_class(MyStanza)
+    }
+  end
+end

data/test/ts_xmpp4r.rb

@@ -1,35 +1,44 @@
 #!/usr/bin/ruby -w
 
-
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
 $:.unshift File.join(File.dirname(__FILE__), '..', 'test')
 $:.unshift File.join(File.dirname(__FILE__), 'lib')
 $:.unshift File.join(File.dirname(__FILE__), 'test')
 
-require 'tc_streamThreaded'
-require 'bytestreams/tc_ibb'
-require 'bytestreams/tc_socks5bytestreams'
-require 'delay/tc_xdelay'
-require 'muc/tc_muc_simplemucclient'
-require 'muc/tc_muc_mucclient'
-require 'tc_error'
-require 'tc_stream'
-require 'tc_idgenerator'
-require 'tc_iqquery'
-#require 'tc_streamError'
-require 'tc_presence'
-require 'vcard/tc_iqvcard'
-require 'roster/tc_iqqueryroster'
-require 'roster/tc_xroster'
-#require 'roster/tc_helper'
-require 'version/tc_iqqueryversion'
-require 'version/tc_helper'
-require 'tc_streamSend'
-require 'tc_jid'
-require 'tc_iq'
-require 'tc_client'
-require 'tc_callbacks'
-require 'tc_xmlstanza'
-require 'tc_message'
-require 'tc_class_names'
-require 'tc_rexml'
+# This is allowed here, to make sure it's enabled in all test.
+Thread::abort_on_exception = true
+
+require 'xmpp4r'
+require 'find'
+
+# List files' basenames, not full path!
+# EXCLUDED_FILES = [ 'tc_muc_simplemucclient.rb' ]
+EXCLUDED_FILES = []
+
+tc_files = []
+tc_subdirs = []
+Find.find(File.dirname(__FILE__)) do |f|
+  if File::directory?(f)
+    if f == '.'
+      # do nothing
+    elsif File::basename(f) != '.svn'
+      tc_subdirs << f
+      Find.prune
+    end
+  elsif File::basename(f) =~ /^tc.*\.rb$/
+    tc_files << f
+  end
+end 
+
+tc_subdirs.each do |dir|
+  Find.find(dir) do |f|
+    if File::file?(f) and File::basename(f) =~ /^tc.*\.rb$/
+      tc_files << f
+    end
+  end
+end
+
+tc_files.each do |f|
+  next if EXCLUDED_FILES.include?(File::basename(f))
+  require f
+end

data/test/version/tc_helper.rb

@@ -7,6 +7,7 @@ require File::dirname(__FILE__) + '/../lib/clienttester'
 
 require 'xmpp4r'
 require 'xmpp4r/version/helper/responder'
+require 'xmpp4r/version/helper/simpleresponder'
 include Jabber
 
 class Version::HelperTest < Test::Unit::TestCase
@@ -43,4 +44,17 @@ class Version::HelperTest < Test::Unit::TestCase
     }
     assert_equal(1, calls)
   end
+
+  def test_simple
+    h = Version::SimpleResponder.new(@client, 'Test program', '1.0', 'Ruby Test::Unit')
+
+    # Send a query
+    @server.send("<iq type='get'><query xmlns='jabber:iq:version'/></iq>") { |reply|
+      assert_equal('Test program', reply.query.iname)
+      assert_equal('1.0', reply.query.version)
+      assert_equal('Ruby Test::Unit', reply.query.os)
+      true
+    }
+
+  end
 end