gmcmillan-xmpp4r 0.5

data/test/dataforms/tc_data.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require 'xmpp4r/dataforms'
+include Jabber
+
+class DataFormsTest < Test::Unit::TestCase
+
+  def test_create_defaults
+    v = Dataforms::XDataTitle.new
+    assert_nil(v.title)
+    assert_equal("", v.to_s)
+
+    v = Dataforms::XDataInstructions.new
+    assert_nil(v.instructions)
+    assert_equal("", v.to_s)
+
+    v = Dataforms::XDataField.new
+    assert_nil(v.label)
+    assert_nil(v.var)
+    assert_nil(v.type)
+    assert_equal(false, v.required?)
+    assert_equal([], v.values)
+    assert_equal({}, v.options)
+
+    v = Dataforms::XData.new
+    assert_equal([], v.fields)
+    assert_nil(v.type)
+  end
+
+  def test_create
+    v = Dataforms::XDataTitle.new "This is the title"
+    assert_equal("This is the title",v.title)
+    assert_equal("This is the title", v.to_s)
+
+    v = Dataforms::XDataInstructions.new "Instructions"
+    assert_equal("Instructions",v.instructions)
+    assert_equal("Instructions", v.to_s)
+
+    f = Dataforms::XDataField.new "botname", :text_single
+    assert_nil(f.label)
+    assert_equal("botname", f.var)
+    assert_equal(:text_single, f.type)
+    assert_equal(false, f.required?)
+    assert_equal([], f.values)
+    assert_equal({}, f.options)
+    f.label = "The name of your bot"
+    assert_equal("The name of your bot", f.label)
+    [:boolean, :fixed, :hidden, :jid_multi, :jid_single,
+     :list_multi, :list_single, :text_multi, :text_private,
+     :text_single].each do |type|
+      f.type = type
+      assert_equal(type, f.type)
+    end
+    f.type = :wrong_type
+    assert_nil(f.type)
+    f.required= true
+    assert_equal(true, f.required?)
+    f.values = ["the value"]
+    assert_equal(["the value"], f.values)
+    f.options = { "option 1" => "Label 1", "option 2" => "Label 2", "option 3" => nil }
+    assert_equal({ "option 1" => "Label 1", "option 2" => "Label 2", "option 3" => nil }, f.options)
+
+
+    f = Dataforms::XDataField.new "test", :text_single
+    v = Dataforms::XData.new :form
+    assert_equal([], v.fields)
+    assert_equal(:form, v.type)
+    [:form, :result, :submit, :cancel].each do |type|
+      v.type = type
+      assert_equal(type, v.type)
+    end
+    v.add f
+    assert_equal(f, v.field('test'))
+    assert_nil(v.field('wrong field'))
+    assert_equal([f], v.fields)
+  end
+
+end

data/test/delay/tc_xdelay.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env 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/discovery/tc_responder.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require File::dirname(__FILE__) + '/../lib/clienttester'
+
+require 'xmpp4r/discovery/helper/responder'
+include Jabber
+
+class Discovery::ResponderTest < Test::Unit::TestCase
+  include ClientTester
+
+  def test_new
+    r = Discovery::Responder.new(@client)
+    assert_nil(r.node)
+    assert_equal([], r.identities)
+    assert_equal([], r.features)
+    assert_equal([], r.forms)
+    assert_equal([], r.items)
+  end
+
+  def test_new2
+    r = Discovery::Responder.new(@client, 'xmpp4r',
+                                 [Discovery::Identity.new('client', 'XMPP4R', 'bot'),
+                                  Discovery::Identity.new('pubsub', 'Personal events', 'pep')],
+                                 ['ipv6', Discovery::Feature.new('sslc2s')],
+                                 [Discovery::Item.new('foo@bar', 'Foo', nil), Discovery::Item.new('bar@baz', 'Bar', 'barbaz')])
+    assert_equal('xmpp4r', r.node)
+    assert_equal([Discovery::Identity.new('client', 'XMPP4R', 'bot'),
+                  Discovery::Identity.new('pubsub', 'Personal events', 'pep')], r.identities)
+    assert_equal([Discovery::Feature.new('ipv6'), Discovery::Feature.new('sslc2s')], r.features)
+    assert_equal([], r.forms)
+    assert_equal([Discovery::Item.new('foo@bar', 'Foo', nil), Discovery::Item.new('bar@baz', 'Bar', 'barbaz')], r.items)
+  end
+
+  def test_generate_item
+    r = Discovery::Responder.new(@client, nil, [Discovery::Identity.new('client', 'XMPP4R', 'bot')])
+    assert_equal(Discovery::Item.new(@client.jid, 'XMPP4R'), r.generate_item)
+  end
+
+  def test_query
+    Discovery::Responder.new(@client, nil,
+                             [Discovery::Identity.new('client', 'XMPP4R', 'bot')],
+                             ['ipv6'],
+                             [Discovery::Item.new('foo@bar', 'Foo', nil)])
+
+    iq1 = Iq.new(:get)
+    iq1.add(Discovery::IqQueryDiscoInfo.new)
+    reply1 = @server.send_with_id(iq1)
+    assert_equal(:result, reply1.type)
+    assert_kind_of(Discovery::IqQueryDiscoInfo, reply1.query)
+    assert_nil(reply1.query.node)
+    assert_equal(1, reply1.query.identities.size)
+    assert_equal('XMPP4R', reply1.query.identities[0].iname)
+    assert_equal(['ipv6'], reply1.query.features)
+
+    iq2 = Iq.new(:get)
+    iq2.add(Discovery::IqQueryDiscoItems.new)
+    reply2 = @server.send_with_id(iq2)
+    assert_equal(:result, reply2.type)
+    assert_kind_of(Discovery::IqQueryDiscoItems, reply2.query)
+    assert_nil(reply2.query.node)
+    assert_equal(1, reply2.query.items.size)
+    assert_equal(JID.new('foo@bar'), reply2.query.items[0].jid)
+  end
+
+  def test_linked
+    class << @client
+      remove_method(:jid) # avoids warning
+      def jid
+        JID.new('foo@bar/baz')
+      end
+    end
+    r1 = Discovery::Responder.new(@client, 'child',
+                                   [Discovery::Identity.new('client', 'Child', 'bot')])
+    r2 = Discovery::Responder.new(@client, nil,
+                                   [], [],
+                                   [r1])
+
+    iq = Iq.new(:get)
+    iq.add(Discovery::IqQueryDiscoItems.new)
+    reply = @server.send_with_id(iq)
+    assert_kind_of(Discovery::IqQueryDiscoItems, reply.query)
+    assert_nil(reply.query.node)
+    assert_equal(1, reply.query.items.size)
+    assert_equal(JID.new('foo@bar/baz'), reply.query.items[0].jid)
+    assert_equal('Child', reply.query.items[0].iname)
+    assert_equal('child', reply.query.items[0].node)
+  end
+end

data/test/entity_time/tc_responder.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require File::dirname(__FILE__) + '/../lib/clienttester'
+
+require 'xmpp4r/entity_time/responder'
+include Jabber
+
+class EntityTime::ResponderTest < Test::Unit::TestCase
+  include ClientTester
+
+  def a_utc_time
+    Time.utc(2000,"jan",1,20,15,1) # xmlschema = "2000-01-01T20:15:01Z"
+  end
+
+  def test_entity_time_iq
+    el_time = EntityTime::IqTime.new(a_utc_time)
+
+    assert_equal('time', el_time.name, "element has wrong name")
+    assert_equal('urn:xmpp:time', el_time.namespace, "element has wrong namespace")
+
+    assert(el_time.elements["utc"], "element does not have a utc child")
+    assert_equal('2000-01-01T20:15:01Z', el_time.elements["utc"].text, "element/utc has the wrong text")
+
+    assert(el_time.elements["tzo"], "element does not have a tzo child")
+    assert_equal("+00:00", el_time.elements["tzo"].text, "element/tzo has the wrong time zone offset")
+  end
+
+=begin
+   http://xmpp.org/extensions/xep-0202.html
+   <iq type='get'
+       from='romeo@montague.net/orchard'
+       to='juliet@capulet.com/balcony'
+       id='time_1'>
+     <time xmlns='urn:xmpp:time'/>
+   </iq>
+=end
+  def test_query
+    EntityTime::Responder.new(@client)
+
+    iq = Iq.new(:get)
+    t = REXML::Element.new('time')
+    t.add_namespace('urn:xmpp:time')
+    iq.add_element(t)
+
+    reply = @server.send_with_id(iq)
+
+    assert_equal(:result, reply.type)
+    assert_equal('time', reply[0].name)
+    assert_equal('urn:xmpp:time', reply[0].namespace)
+
+    assert(reply[0].elements["utc"].has_text?, "element must have a utc time (actual time should be check here)")
+
+    tmp = Time.now
+    local_offset = Time.now.utc_offset
+    hour_offset = local_offset / 3600
+    min_offset = local_offset % 60
+    offset = "%+03d:%02d"%[hour_offset, min_offset]
+
+    assert_equal(offset, reply[0].elements["tzo"].text, "element should has an incorrect time zone offset")
+  end
+
+end

data/test/last/tc_helper.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require File::dirname(__FILE__) + '/../lib/clienttester'
+
+require 'xmpp4r'
+require 'xmpp4r/last/helper/helper'
+include Jabber
+
+
+class LastActivity::HelperTest < Test::Unit::TestCase
+  include ClientTester
+
+  def test_simple_query
+    state { |iq|
+      assert_kind_of(Iq, iq)
+      assert_equal(JID.new('juliet@capulet.com'), iq.to)
+      assert_equal(:get, iq.type)
+      assert_kind_of(LastActivity::IqQueryLastActivity, iq.query)
+      send("
+<iq type='result' from='#{iq.to}' to='#{iq.from}' id='#{iq.id}'>
+  <query xmlns='jabber:iq:last' seconds='903'/>
+</iq>")
+    }
+
+    res = LastActivity::Helper.new(@client).get_last_activity_from('juliet@capulet.com')
+    wait_state
+    assert_equal(903, res.seconds)
+    assert_nil(res.text)
+  end
+
+  def test_text_query
+    state { |iq|
+      send("
+<iq type='result' from='#{iq.to}' to='#{iq.from}' id='#{iq.id}'>
+  <query xmlns='jabber:iq:last' seconds='903'>Heading Home</query>
+</iq>")
+    }
+
+    res = LastActivity::Helper.new(@client).get_last_activity_from('juliet@capulet.com')
+    wait_state
+    assert_equal(903, res.seconds)
+    assert_equal('Heading Home', res.text)
+  end
+
+  def test_empty_query
+    state { |iq|
+      send("
+<iq type='result' from='#{iq.to}' to='#{iq.from}' id='#{iq.id}'>
+  <query xmlns='jabber:iq:last'/>
+</iq>")
+    }
+
+    res = LastActivity::Helper.new(@client).get_last_activity_from('juliet@capulet.com')
+    wait_state
+    assert_nil(res.seconds)
+    assert_nil(res.text)
+  end
+
+  def test_forbidden_query
+    state { |iq|
+      send("
+<iq type='error' from='#{iq.to}' to='#{iq.from}' id='#{iq.id}'>
+  <error type='auth'>
+    <forbidden xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
+  </error>
+</iq>")
+    }
+
+    assert_raises(ServerError) { LastActivity::Helper.new(@client).get_last_activity_from('juliet@capulet.com') }
+  end
+
+end

data/test/lib/assert_equal_xml.rb

@@ -0,0 +1,14 @@
+module Test::Unit::Assertions
+  public
+  ##
+  # Like assert_equal, but actual comparision switches parameters to
+  # make use of our attribute order agnostic REXML#==
+  def assert_equal_xml(expected, actual, message=nil)
+    full_message = build_message(message, <<EOT, expected, actual)
+<?> expected but was
+<?>.
+EOT
+    assert_block(full_message) { actual == expected }
+  end
+end
+

data/test/lib/clienttester.rb

@@ -0,0 +1,149 @@
+# =XMPP4R - XMPP Library for Ruby
+# License:: Ruby's license (see the LICENSE file) or GNU GPL, at your option.
+# Website::http://home.gna.org/xmpp4r/
+
+$:.unshift '../lib'
+require 'xmpp4r'
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/semaphore'
+
+# Jabber::debug = true
+$ctdebug = false
+# $ctdebug = true
+
+# This is sane for tests:
+Thread::abort_on_exception = true
+
+# 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 the method
+  # interfacing as the "server side":
+  # * send(xml):: Send a stanza to @client
+  #
+  # 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
+      servlisten = TCPServer.new(@@SOCKET_PORT)
+      serverwait = Semaphore.new
+      stream = '<stream:stream xmlns:stream="http://etherx.jabber.org/streams">'
+
+      @state = 0
+      @states = []
+
+      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'
+            send(stream)
+            true
+          else
+            false
+          end
+        end
+        @server.start(serversock)
+
+        serverwait.run
+      end
+
+      clientsock = TCPSocket.new('localhost', @@SOCKET_PORT)
+      clientsock.sync = true
+      @client = Stream.new
+#=begin
+      class << @client
+        def jid
+          begin
+            #raise
+          rescue
+            puts $!.backtrace.join("\n")
+          end
+          JID.new('test@test.com/test')
+        end
+      end
+#=end
+      @client.start(clientsock)
+
+      @processdone_wait = Semaphore.new
+      @nextstate_wait = Semaphore.new
+      serverwait.wait
+      @server.add_stanza_callback { |stanza|
+        # Client prepares everything, then calls wait_state. Problem: because
+        # of a race condition, it is possible that we receive the stanza before
+        # what to do with it is defined. We busy-wait on @states here.
+        n = 0
+        while @state >= @states.size and n < 1000
+          Thread.pass
+          n += 1
+        end
+        if n == 1000
+          puts "Unmanaged stanza in state. Maybe processed by helper?" if $ctdebug
+        else
+          begin
+            puts "Calling #{@states[@state]} for #{stanza.to_s}" if $ctdebug
+            @states[@state].call(stanza)
+          rescue Exception => e
+            puts "Exception in state: #{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+          end
+          @state += 1
+          @nextstate_wait.wait
+          @processdone_wait.run
+        end
+
+        false
+      }
+      @client.send(stream) { |reply| true }
+
+    end
+
+    def teardown
+      # In some cases, we might lost count of some stanzas
+      # (for example, if the handler raises an exception)
+      # so we can't block forever.
+      n = 0
+      while @client.processing > 0 and n < 1000
+        Thread::pass
+        n += 1
+      end
+      n = 0
+      while @server.processing > 0 and n < 1000
+        Thread::pass
+        n += 1
+      end
+      @client.close
+      @server.close
+    end
+
+    def send(xml)
+      @server.send(xml)
+    end
+
+    def state(&block)
+      @states << block
+    end
+
+    def wait_state
+      @nextstate_wait.run
+      @processdone_wait.wait
+    end
+
+    def skip_state
+      @nextstate_wait.run
+    end
+  end
+end
+
+# Restore the old $VERBOSE setting
+$VERBOSE = oldverbose