xmpp4r 0.3

data/test/tc_jid.rb

@@ -0,0 +1,202 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'xmpp4r/jid'
+include Jabber
+
+class JIDTest < Test::Unit::TestCase
+  def test_create1
+    j = JID::new('a', 'b', 'c')
+    assert_equal('a', j.node)
+    assert_equal('b', j.domain)
+    assert_equal('c', j.resource)
+  end
+
+  def test_create2
+    j = JID::new('a', 'b', 'c')
+    j2 = JID::new(j)
+    assert_equal('a', j2.node)
+    assert_equal('b', j2.domain)
+    assert_equal('c', j2.resource)
+    assert_equal('a@b/c', j.to_s)
+  end
+
+  def test_create3
+    j = JID::new('a@b/c')
+    assert_equal('a', j.node)
+    assert_equal('b', j.domain)
+    assert_equal('c', j.resource)
+    assert_equal('a@b/c', j.to_s)
+  end
+
+  def test_create4
+    j = JID::new('a@b')
+    assert_equal('a', j.node)
+    assert_equal('b', j.domain)
+    assert_equal(nil, j.resource)
+    assert_equal('a@b', j.to_s)
+  end
+
+  def test_create5
+    j = JID::new
+    assert_equal(nil, j.node)
+    assert_equal(nil, j.domain)
+    assert_equal(nil, j.resource)
+    assert_equal('', j.to_s)
+  end
+
+  def test_create6
+    j = JID::new('dom')
+    assert_equal(nil, j.node)
+    assert_equal('dom', j.domain)
+    assert_equal(nil, j.resource)
+    assert_equal('dom', j.to_s)
+  end
+
+  def test_create7
+    j = JID::new('dom/res')
+    assert_equal(nil, j.node)
+    assert_equal('dom', j.domain)
+    assert_equal('res', j.resource)
+    assert_equal('dom/res', j.to_s)
+  end
+
+  def test_create8
+    j = JID::new('dom/a@b')
+    assert_equal(nil, j.node)
+    assert_equal('dom', j.domain)
+    assert_equal('a@b', j.resource)
+    assert_equal('dom/a@b', j.to_s)
+  end
+
+  def test_create9
+    assert_nothing_raised { JID::new("#{'n'*1023}@#{'d'*1023}/#{'r'*1023}") }
+    assert_raises(ArgumentError) { JID::new("#{'n'*1024}@#{'d'*1023}/#{'r'*1023}") }
+    assert_raises(ArgumentError) { JID::new("#{'n'*1023}@#{'d'*1024}/#{'r'*1023}") }
+    assert_raises(ArgumentError) { JID::new("#{'n'*1023}@#{'d'*1023}/#{'r'*1024}") }
+  end
+
+  def test_create10
+    j = JID::new('@b/c')
+    assert_equal('', j.node)
+    assert_equal('b', j.domain)
+    assert_equal('c', j.resource)
+    assert_equal('@b/c', j.to_s)
+  end
+
+  def test_create11
+    j = JID::new('@b')
+    assert_equal('', j.node)
+    assert_equal('b', j.domain)
+    assert_equal(nil, j.resource)
+    assert_equal('@b', j.to_s)
+  end
+
+  def test_create12
+    j = JID::new('@b/')
+    assert_equal('', j.node)
+    assert_equal('b', j.domain)
+    assert_equal('', j.resource)
+    assert_equal('@b/', j.to_s)
+  end
+
+  def test_create13
+    j = JID::new('a@b/')
+    assert_equal('a', j.node)
+    assert_equal('b', j.domain)
+    assert_equal('', j.resource)
+    assert_equal('a@b/', j.to_s)
+  end
+
+  def test_create14
+    j = JID::new('nOdE@dOmAiN/rEsOuRcE')
+    assert_equal('node', j.node)
+    assert_equal('domain', j.domain)
+    assert_equal('rEsOuRcE', j.resource)
+    assert_equal('node@domain/rEsOuRcE', j.to_s)
+  end
+
+  def test_tos
+    assert_equal('', JID::new.to_s)
+    assert_equal('domain.fr', JID::new('domain.fr').to_s)
+    assert_equal('l@domain.fr', JID::new('l','domain.fr').to_s)
+    assert_equal('l@domain.fr/res', JID::new('l','domain.fr','res').to_s)
+    assert_equal('domain.fr/res', JID::new(nil,'domain.fr','res').to_s)
+  end
+
+  def test_equal
+    assert_equal(JID::new('domain.fr'), JID::new('domain.fr'))
+    assert_equal(JID::new('domain.fr'), JID::new(nil, 'domain.fr'))
+    assert_equal(JID::new('l@domain.fr'), JID::new('l@domain.fr'))
+    assert_equal(JID::new('l@domain.fr'), JID::new('l', 'domain.fr'))
+    assert_equal(JID::new('l@domain.fr/res'), JID::new('l@domain.fr/res'))
+    assert_equal(JID::new('l@domain.fr/res'), JID::new('l', 'domain.fr', 'res'))
+  end
+
+  def test_hash
+    h = {}
+    j = JID::new('l@domain.fr/res')
+    h[j] = 'a'
+    assert_equal(h[j], h[JID::new('l@domain.fr/res')])
+  end
+
+  def test_strip
+    assert_equal(JID::new('l@domain.fr'), JID::new('l@domain.fr/res').strip)
+    assert_equal(JID::new('l@domain.fr'), JID::new('l@domain.fr').strip)
+    assert_equal(JID::new('l@domain.fr'), JID::new('l@domain.fr/res').bare)
+    jid = JID::new('l@domain.fr/res')
+    jid.strip!
+    assert_equal(JID::new('l@domain.fr'), jid)
+
+    jid = JID::new('l@domain.fr/res')
+    jid.bare!
+    assert_equal(JID::new('l@domain.fr'), jid)
+  end
+
+  def test_change1
+    j = JID::new('a@b/c')
+    j.node = 'd'
+    assert_equal('d@b/c', j.to_s)
+    j.domain = 'e'
+    assert_equal('d@e/c', j.to_s)
+    j.resource = 'f'
+    assert_equal('d@e/f', j.to_s)
+  end
+
+  def test_escaping
+    j = JID::new('user1@server1')
+    j2 = JID::new(JID::escape(j), 'server2', 'res2')
+    assert_equal('user1%server1@server2/res2', j2.to_s)
+  end
+
+if defined?(libidnbug) # this crashes the interpreter
+  def test_invalidnode
+#    assert_raises(IDN::Stringprep::StringprepError) { JID::new('toto@a/a', 'server', 'res') }
+    assert_raises(IDN::Stringprep::StringprepError) { IDN::Stringprep.nodeprep('toto@a/a') }
+  end
+end
+
+  def test_empty
+    assert(JID.new.empty?)
+    assert(!JID.new("test").empty?)
+  end
+
+  def test_stripped
+    assert(JID.new("node@domain").stripped?)
+    assert(!JID.new("node@domain/res").stripped?)
+    assert(JID.new("node@domain").bared?)
+    assert(!JID.new("node@domain/res").bared?)
+  end
+
+  def test_sort
+    assert_equal(-1, JID.new('a@b') <=> JID.new('b@b'))
+    assert_equal(0, JID.new('a@b') <=> JID.new('a@b'))
+    assert_equal(1, JID.new('a@b/r') <=> JID.new('a@b'))
+
+    jids = [JID.new('b@b'), JID.new('a@b/r'), JID.new('a@b')]
+    jids.sort!
+    assert_equal([JID.new('a@b'), JID.new('a@b/r'), JID.new('b@b')], jids)
+  end
+end

data/test/tc_message.rb

@@ -0,0 +1,114 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/message'
+include Jabber
+
+class MessageTest < Test::Unit::TestCase
+  def test_create
+    x = Message::new()
+    assert_equal("message", x.name)
+    assert_equal(nil, x.to)
+    assert_equal(nil, x.body)
+
+    x = Message::new("lucas@linux.ensimag.fr", "coucou")
+    assert_equal("message", x.name)
+    assert_equal("lucas@linux.ensimag.fr", x.to.to_s)
+    assert_equal("coucou", x.body)
+  end
+
+  def test_import
+    x = Message::new
+    assert_kind_of(REXML::Element, x.typed_add(REXML::Element.new('thread')))
+    assert_kind_of(X, x.typed_add(REXML::Element.new('x')))
+    assert_kind_of(X, x.x)
+  end
+
+  def test_type
+    x = Message.new
+    assert_equal(nil, x.type)
+    x.type = :chat
+    assert_equal(:chat, x.type)
+    assert_equal(x, x.set_type(:error))
+    assert_equal(:error, x.type)
+    x.type = :groupchat
+    assert_equal(:groupchat, x.type)
+    x.type = :headline
+    assert_equal(:headline, x.type)
+    x.type = :normal
+    assert_equal(:normal, x.type)
+    x.type = :invalid
+    assert_equal(nil, x.type)
+  end
+
+  def test_body
+    x = Message::new()
+    assert_equal(nil, x.body)
+    assert_equal(x, x.set_body("trezrze ezfrezr ezr zer ezr ezrezrez ezr z"))
+    assert_equal("trezrze ezfrezr ezr zer ezr ezrezrez ezr z", x.body)
+    x.body = "2"
+    assert_equal("2", x.body)
+  end
+
+  def test_subject
+    x = Message::new
+    assert_equal(nil, x.subject)
+    subject = REXML::Element.new('subject')
+    subject.text = 'A'
+    x.add(subject)
+    assert_equal('A', x.subject)
+    x.subject = 'Test message'
+    assert_equal('Test message', x.subject)
+    x.each_element('subject') { |s| assert_equal('Test message', s.text) }
+    assert_equal(x, x.set_subject('Breaking news'))
+    assert_equal('Breaking news', x.subject)
+  end
+
+  def test_thread
+    x = Message::new
+    assert_equal(nil, x.thread)
+    thread = REXML::Element.new('thread')
+    thread.text = '123'
+    x.add(thread)
+    assert_equal('123', x.thread)
+    x.thread = '321'
+    assert_equal('321', x.thread)
+    x.each_element('thread') { |s| assert_equal('321', s.text) }
+    assert_equal(x, x.set_thread('abc'))
+    assert_equal('abc', x.thread)
+  end
+
+  def test_error
+    x = Message::new()
+    assert_equal(nil, x.error)
+    e = REXML::Element::new('error')
+    x.add(e)
+    # test if, after an import, the error element is successfully changed
+    # into an Error object.
+    x2 = Message::new.import(x)
+    assert_equal(Error, x2.first_element('error').class)
+  end
+
+  def test_answer
+    orig = Message::new
+    orig.from = 'a@b'
+    orig.to = 'b@a'
+    orig.id = '123'
+    orig.type = :chat
+    orig.add(REXML::Element.new('x'))
+
+    answer = orig.answer
+    assert_equal(JID.new('b@a'), answer.from)
+    assert_equal(JID.new('a@b'), answer.to)
+    assert_equal('123', answer.id)
+    assert_equal(:chat, answer.type)
+    answer.each_element { |e|
+      assert_equal('x', e.name)
+      assert_kind_of(X, e)
+    }
+  end
+end

data/test/tc_presence.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/presence'
+include Jabber
+
+class PresenceTest < Test::Unit::TestCase
+  def test_create
+    x = Presence::new()
+    assert_equal("presence", x.name)
+    assert_equal(nil, x.to)
+    assert_equal(nil, x.show)
+    assert_equal(nil, x.status)
+    assert_equal(nil, x.priority)
+
+    x = Presence::new(:away, "I am away", 23)
+    assert_equal("presence", x.name)
+    assert_equal(:away, x.show)
+    assert_equal("away", x.show.to_s)
+    assert_equal("I am away", x.status)
+    assert_equal(23, x.priority)
+  end
+
+  def test_show
+    x = Presence::new()
+    assert_equal(nil, x.show)
+    assert_raise(RuntimeError) { x.show = "a" }
+    assert_equal(nil, x.show)
+    assert_raise(RuntimeError) { x.show = 'away' }
+    assert_equal(nil, x.show)
+    x.show = :away
+    assert_equal(:away, x.show)
+    x.each_element('show') { |e| assert(e.class == REXML::Element, "<show/> is not REXML::Element") }
+    x.show = nil
+    assert_equal(nil, x.show)
+    x.each_element('show') { |e| assert(true, "<show/> exists after 'show=nil'") }
+    x.show = nil
+    assert_equal(nil, x.show)
+
+    showelement = REXML::Element.new('show')
+    showelement.text = 'chat'
+    x.add(showelement)
+    assert_equal(:chat, x.show)
+  end
+
+  def test_status
+    x = Presence::new()
+    assert_equal(nil, x.status)
+    x.status = "b"
+    assert_equal("b", x.status)
+    x.each_element('status') { |e| assert(e.class == REXML::Element, "<status/> is not REXML::Element") }
+    x.status = nil
+    assert_equal(nil, x.status)
+    x.each_element('status') { |e| assert(true, "<status/> exists after 'status=nil'") }
+    x.status = nil
+    assert_equal(nil, x.status)
+  end
+
+  def test_priority
+    x = Presence::new()
+    assert_equal(nil, x.priority)
+    x.priority = 5
+    assert_equal(5, x.priority)
+    x.each_element('priority') { |e| assert(e.class == REXML::Element, "<priority/> is not REXML::Element") }
+    x.priority = "5"
+    assert_equal(5, x.priority)
+    x.priority = nil
+    assert_equal(nil, x.priority)
+    x.each_element('priority') { |e| assert(true, "<priority/> exists after 'priority=nil'") }
+  end
+
+  def test_type
+    x = Presence::new()
+    assert_equal(nil, x.type)
+    x.type = :delete
+    assert_equal(nil, x.type)
+    x.type = nil
+    assert_equal(nil, x.type)
+    x.type = nil
+    assert_equal(nil, x.type)
+    [:error, :probe, :subscribe, :subscribed, :unavailable, :unsubscribe, :unsubscribed, nil].each { |type|
+      x.type = type
+      assert_equal(type, x.type)
+    }
+  end
+
+  def test_chaining
+    x = Presence::new()
+    x.set_show(:xa).set_status("Plundering the fridge.").set_priority(0)
+    assert_equal(:xa, x.show)
+    assert_equal("Plundering the fridge.", x.status)
+    assert_equal(0, x.priority)
+  end
+
+  def test_error
+    x = Presence::new()
+    e = REXML::Element::new('error')
+    x.add(e)
+    x2 = Presence::new.import(x)
+    # test if, after an import, the error element is successfully changed
+    # into an Error object.
+    assert_equal(Error, x2.first_element('error').class)
+  end
+
+  def test_sample
+    x = Presence::new
+    require 'rexml/document'
+    d = REXML::Document.new("<presence from='astro@spaceboyz.net/versionbot' to='astro@spaceboyz.net/edgarr' xmlns='jabber:client'>\n    <x from='astro@spaceboyz.net/versionbot' stamp='20050823T02:18:42' xmlns='jabber:x:delay'/><show>xa</show>\n    <status>I am the evil fingerprinting robot</status>\n  </presence>")
+    x.import(d.root)
+    num = 0
+    x.each_element('show') { num += 1 }
+    assert_equal(1, num)
+    assert_equal(:xa, x.show)
+    assert_equal('I am the evil fingerprinting robot', x.status)
+  end
+
+  def test_xpathbug
+    require 'rexml/document'
+    d = REXML::Document.new("<tag1 xmlns='ns1'><tag2 xmlns='ns2'/><tada>xa</tada></tag1>")
+    x = d.root
+    num = 0
+    x.each_element('tada') {  num += 1 }
+    assert_equal(1, num)
+  end
+
+  def test_compare_prio
+    assert_equal(0, Presence::new(:chat, '', 5) <=> Presence::new(:chat, '', 5))
+    assert_equal(-1, Presence::new(:chat, '', 4) <=> Presence::new(:chat, '', 5))
+    assert_equal(1, Presence::new(:chat, '', 4) <=> Presence::new(:chat, '', 3))
+    assert_equal(-1, Presence::new(:chat, '', nil) <=> Presence::new(:chat, '', 3))
+    assert_equal(1, Presence::new(:chat, '', 10) <=> Presence::new(:chat, '', nil))
+    assert_equal(0, Presence::new(:chat, '', nil) <=> Presence::new(:chat, '', nil))
+  end
+
+  def test_compare_interest
+    unav = Presence::new.set_type(:unavailable)
+    assert_equal(0, unav.cmp_interest(unav))
+    assert_equal(1, unav.cmp_interest(Presence::new))
+    assert_equal(-1, Presence::new.cmp_interest(unav))
+    assert_equal(1, Presence::new(:chat).cmp_interest(Presence::new))
+    assert_equal(-1, Presence::new(:away).cmp_interest(Presence::new(:dnd)))
+  end
+
+end

data/test/tc_stream.rb

@@ -0,0 +1,182 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'tempfile'
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/stream'
+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
+      sleep 0.1
+      n += 1
+    end
+    @stream = Stream::new(false)
+    @stream.start(@iostream)
+  end
+
+  def teardown
+    @stream.close
+    @server.close
+  end
+
+  ##
+  # tests that stream 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
+
+    nbcalls = 0
+    called = false
+    @stream.add_xml_callback { |element|
+      nbcalls += 1
+      if element.name == "message"
+        called = true
+      end
+    }
+    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/>')
+      @server.flush
+    end
+    @server.puts('<message/>')
+    @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
+  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
+      end
+    }
+    assert(!@called)
+    @server.puts('<stream:stream>')
+    @server.flush
+    assert(!@called)
+    @stream.process
+    assert(!@called)
+    assert_equal(1, @nbcalls)
+    for i in 1..20
+      @server.puts('<iq/>')
+      @server.flush
+    end
+    @server.puts('<message/>')
+    @server.flush
+    assert(!@called)
+    assert_equal(1, @nbcalls)
+    @stream.process
+    assert_equal(22, @nbcalls)
+    assert(@called)
+=end
+  end
+
+  # Check that <message><message/></message> is recognized as one Message
+  def test_similar_children
+    n = 0
+    @stream.add_message_callback { n += 1 }
+    assert_equal(0, n)
+    @server.puts('<stream:stream><message/>')
+    @server.flush
+    @stream.process
+    assert_equal(1, n)
+    @server.puts('<message>')
+    @server.flush
+    @stream.process
+    assert_equal(1, n)
+    @server.puts('<message/>')
+    @server.flush
+    @stream.process
+    assert_equal(1, n)
+    @server.puts('</message>')
+    @server.flush
+    @stream.process
+    assert_equal(2, n)
+    @server.puts('<message><stream:stream><message/></stream:stream>')
+    @server.flush
+    @stream.process
+    assert_equal(2, n)
+    @server.puts('</message>')
+    @server.flush
+    @stream.process
+    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