mojodna-xmpp4r 0.4.0.2

data/test/tc_presence.rb

@@ -0,0 +1,150 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/presence'
+require 'xmpp4r/errors'
+include Jabber
+
+class PresenceTest < Test::Unit::TestCase
+  def test_create
+    x = Presence.new()
+    assert_equal("presence", x.name)
+    assert_equal("jabber:client", x.namespace)
+    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 ErrorResponse object.
+    assert_equal(ErrorResponse, 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_rexml.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/ruby
+
+$:.unshift File::dirname(__FILE__) + '/../lib'
+
+require 'test/unit'
+require 'xmpp4r/rexmladdons'
+
+class REXMLTest < Test::Unit::TestCase
+  def test_simple
+    e = REXML::Element.new('e')
+    assert_kind_of(REXML::Element, e)
+    assert_nil(e.text)
+    assert_nil(e.attributes['x'])
+  end
+
+  def test_normalize
+    assert_equal('&amp;', REXML::Text::normalize('&'))
+    assert_equal('&amp;amp;', REXML::Text::normalize('&amp;'))
+    assert_equal('&amp;amp;amp;', REXML::Text::normalize('&amp;amp;'))
+    assert_equal('&amp;nbsp;', REXML::Text::normalize('&nbsp;'))
+  end
+
+  def test_unnormalize
+    assert_equal('&', REXML::Text::unnormalize('&amp;'))
+    assert_equal('&amp;', REXML::Text::unnormalize('&amp;amp;'))
+    assert_equal('&amp;amp;', REXML::Text::unnormalize('&amp;amp;amp;'))
+    assert_equal('&nbsp;', REXML::Text::unnormalize('&amp;nbsp;'))
+    assert_equal('&nbsp;', REXML::Text::unnormalize('&nbsp;'))  # ?
+  end
+
+  def test_text_entities
+    e = REXML::Element.new('e')
+    e.text = '&'
+    assert_equal('<e>&amp;</e>', e.to_s)
+    e.text = '&amp;'
+    assert_equal('<e>&amp;amp;</e>', e.to_s)
+    e.text = '&nbsp'
+    assert_equal('<e>&amp;nbsp</e>', e.to_s)
+    e.text = '&nbsp;'
+    assert_equal('<e>&amp;nbsp;</e>', e.to_s)
+    e.text = '&<;'
+    assert_equal('<e>&amp;&lt;;</e>', e.to_s)
+    e.text = '<>"\''
+    assert_equal('<e>&lt;&gt;&quot;&apos;</e>', e.to_s)
+    e.text = '<x>&amp;</x>'
+    assert_equal('<e>&lt;x&gt;&amp;amp;&lt;/x&gt;</e>', e.to_s)
+  end
+
+  def test_attribute_entites
+    e = REXML::Element.new('e')
+    e.attributes['x'] = '&'
+    assert_equal('&', e.attributes['x'])
+    e.attributes['x'] = '&amp;'
+    # bug in REXML 3.1.6 unescaped the ampersand
+    # assert_equal('&', e.attributes['x'])
+    # substituting a test that works with 3.1.5, 3.1.6, and 3.1.7
+    assert_equal('&amp;amp;', e.attribute('x').to_s)
+    e.attributes['x'] = '&nbsp'
+    assert_equal('&nbsp', e.attributes['x'])
+    e.attributes['x'] = '&nbsp;'
+    assert_equal('&nbsp;', e.attributes['x'])
+  end
+
+  # test '==(o)'
+
+  def test_passing_in_non_rexml_element_as_self
+    o = Object.new
+    assert_not_equal(o, REXML::Element.new('foo'))
+  end
+
+  def test_passing_in_non_rexml_element_as_comparison_object
+    o = Object.new
+    assert_not_equal(REXML::Element.new('foo'), o)
+  end
+
+  def test_element_equal_simple
+    assert_equal(REXML::Element.new('foo'), REXML::Element.new('foo'))
+  end
+
+  def test_element_not_equal_simple
+    assert_not_equal(REXML::Element.new('foo'), REXML::Element.new('bar'))
+  end
+
+  def test_element_equal_when_all_are_same
+    e1 = REXML::Element.new('foo')
+    e1.add_namespace('a', 'urn:test:foo')
+    e1.attributes['a:bar'] = 'baz'
+    e2 = REXML::Element.new('foo')
+    e2.add_namespace('a', 'urn:test:foo')
+    e2.attributes['a:bar'] = 'baz'
+
+    assert_equal(e1, e2)
+  end
+
+  def test_element_not_equal_when_namespace_name_differs
+    e1 = REXML::Element.new('foo')
+    e1.add_namespace('a', 'urn:test:foo')
+    e1.attributes['a:bar'] = 'baz'
+    e2 = REXML::Element.new('foo')
+    e2.add_namespace('b', 'urn:test:foo')
+    e2.attributes['a:bar'] = 'baz'
+
+    assert_not_equal(e1, e2)
+  end
+
+  def test_element_not_equal_when_namespace_value_differs
+    e1 = REXML::Element.new('foo')
+    e1.add_namespace('a', 'urn:test:foo')
+    e1.attributes['a:bar'] = 'baz'
+    e2 = REXML::Element.new('foo')
+    e2.add_namespace('a', 'urn:test:bar')
+    e2.attributes['a:bar'] = 'baz'
+
+    assert_not_equal(e1, e2)
+  end
+
+  def test_element_not_equal_when_attribute_name_differs
+    e1 = REXML::Element.new('foo')
+    e1.add_namespace('a', 'urn:test:foo')
+    e1.attributes['a:bar'] = 'baz'
+    e2 = REXML::Element.new('foo')
+    e1.add_namespace('a', 'urn:test:foo')
+    e2.attributes['b:bar'] = 'baz'
+
+    assert_not_equal(e1, e2)
+  end
+
+  def test_element_not_equal_when_attribute_value_differs
+    e1 = REXML::Element.new('foo')
+    e1.add_namespace('a', 'urn:test:foo')
+    e1.attributes['a:bar'] = 'baz'
+    e2 = REXML::Element.new('foo')
+    e1.add_namespace('a', 'urn:test:foo')
+    e2.attributes['a:bar'] = 'bar'
+
+    assert_not_equal(e1, e2)
+  end
+
+end

data/test/tc_stream.rb

@@ -0,0 +1,229 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'tempfile'
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/stream'
+require 'xmpp4r/semaphore'
+include Jabber
+
+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)
+    n = 0
+    while not defined? @server and n < 10
+      sleep 0.1
+      n += 1
+    end
+    @stream = Stream.new
+    @stream.start(@iostream)
+  end
+
+  def teardown
+    @stream.close
+    @server.close
+  end
+
+  ##
+  # tests that connection really waits the call to process() to dispatch
+  # stanzas to filters
+  def test_process
+    called = false
+    @stream.add_xml_callback { called = true }
+    assert(!called)
+    @server.puts(STREAM)
+    @server.flush
+    assert(called)
+  end
+
+  def test_process100
+    @server.puts(STREAM)
+    @server.flush
+
+    done = Semaphore.new
+    n = 0
+    @stream.add_message_callback {
+      n += 1
+      done.run if n % 100 == 0
+    }
+
+    100.times {
+      @server.puts('<message/>')
+      @server.flush
+    }
+
+    done.wait
+    assert_equal(100, n)
+
+    @server.puts('<message/>' * 100)
+    @server.flush
+
+    done.wait
+    assert_equal(200, 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))
+    }
+
+    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
+
+  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
+    }
+
+    called_outer = 0
+    called_inner = 0
+
+    @stream.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|
+          called_inner += 1
+          assert_kind_of(Iq, reply2)
+          assert_equal(:result, reply2.type)
+          assert_equal('2', reply2.id)
+
+          @stream.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)
+
+    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|
+        assert_equal(:result, reply.type)
+      }
+    }
+
+    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
+      }
+    }
+
+    finished.wait
+    assert(ok)
+  end
+
+  def test_similar_children
+    delay = 0.1
+    n = 0
+    @stream.add_message_callback { n += 1 }
+    assert_equal(0, n)
+    @server.puts("#{STREAM}<message/>")
+    @server.flush
+    sleep delay
+    assert_equal(1, n)
+    @server.puts('<message>')
+    @server.flush
+    sleep delay
+    assert_equal(1, n)
+    @server.puts('<message/>')
+    @server.flush
+    sleep delay
+    assert_equal(1, n)
+    @server.puts('</message>')
+    @server.flush
+    sleep delay
+    assert_equal(2, n)
+    @server.puts("<message>#{STREAM}<message/></stream:stream>")
+    @server.flush
+    sleep delay
+    assert_equal(2, n)
+    @server.puts('</message>')
+    @server.flush
+    sleep delay
+    assert_equal(3, n)
+  end
+end

data/test/tc_streamComponent.rb

@@ -0,0 +1,95 @@
+#!/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
+  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
+    @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