bryanl-xmpp4r 0.3.2

data/test/caps/tc_helper.rb

@@ -0,0 +1,156 @@
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require File::dirname(__FILE__) + '/../lib/clienttester'
+
+require 'xmpp4r/discovery'
+require 'xmpp4r/caps/helper/helper'
+require 'xmpp4r/dataforms'
+include Jabber
+
+class Caps::HelperTest < Test::Unit::TestCase
+  include ClientTester
+
+  ##
+  # Walk through the client/ server conversation defined
+  # in http://www.xmpp.org/extensions/xep-0115.html#usecases
+  # and assert conformance.
+  def test_caps_reply
+    # This will be invoked by 'wait_state' below...
+    state { |presence|
+      assert_kind_of(Jabber::Presence, presence)
+      c = presence.first_element('c')
+      assert_kind_of(Jabber::Caps::C, c)
+
+      # see http://www.xmpp.org/extensions/xep-0115.html#ver
+      assert_equal('SrFo9ar2CCk2EnOH4q4QANeuxLQ=', c.ver)
+
+      # version 1.5 of xep 0115 indicates that the <c /> stanzq MUST feature a 'hash' attribute
+      assert_equal('sha-1', c.hash)
+
+      assert_equal("http://home.gna.org/xmpp4r/##{Jabber::XMPP4R_VERSION}", c.node)
+
+      send(iq_discovering_capabilities)
+    }
+
+    # Construct Caps::Helper which will send a <presence>
+    # stanza (with embedded <c/> advert) to the 'server'
+    h = Caps::Helper.new(@client, identities, features)
+
+    # The 'server' will receive the <presence> stanza and
+    # yield it to the 'state' block above, where an <iq> query
+    # will be sent back to the 'client,' to discover its capabilities.
+    # Wait here until the block has been executed.
+    wait_state
+
+    # The Caps::Helper will process the <iq> query from the 'server'
+    # and reply with an <iq> result providing the details of its
+    # identities and features.
+
+    state { |iq|
+      assert_kind_of(Jabber::Iq, iq)
+      assert_equal(:result, iq.type)
+      assert_equal('1867999907', iq.id)
+      assert_equal('new-big-computer.local', iq.to.to_s)
+
+      assert_kind_of(Jabber::Discovery::IqQueryDiscoInfo, iq.query)
+      assert_equal(iq.query.identities.size, identities.size)
+      get_category_iname_type = lambda{ |i| [i.category,i.iname,i.type] }
+      assert_equal(iq.query.identities.map(&get_category_iname_type).sort!, identities.map(&get_category_iname_type).sort!)
+
+      assert_equal(3, iq.query.features.size)
+      get_var = lambda { |f| f.var }
+      assert_equal(iq.query.features.sort, features.map(&get_var).sort)
+    }
+
+    # The 'server' will receive the <iq> result from the
+    # 'client' and yield it to the block above. Wait here
+    # until that block exits.
+    wait_state
+  end
+
+  def test_custom_node
+    client_id='http://new-big-computer.local/client#321'
+
+    state { |presence|
+      c = presence.first_element('c')
+      assert_kind_of(Jabber::Caps::C, c)
+      assert_equal(client_id, c.node)
+      assert_equal('SrFo9ar2CCk2EnOH4q4QANeuxLQ=', c.ver)
+    }
+    h = Caps::Helper.new(@client, identities, features, client_id)
+    wait_state
+  end
+
+  def identities
+    [Jabber::Discovery::Identity.new('client', 'Exodus 0.9.1', 'pc')]
+  end
+
+  def features
+    [Jabber::Discovery::Feature.new("http://jabber.org/protocol/disco#info"),
+     Jabber::Discovery::Feature.new("http://jabber.org/protocol/disco#items"),
+     Jabber::Discovery::Feature.new("http://jabber.org/protocol/muc")]
+  end
+
+  def iq_discovering_capabilities
+    "<iq from='new-big-computer.local' type='get' to='matt@new-big-computer.local/capable_client' id='1867999907' xmlns='jabber:client'><query xmlns='http://jabber.org/protocol/disco#info'/></iq>"
+  end
+
+  ##
+  # http://www.xmpp.org/extensions/xep-0115.html#ver-gen-complex
+  def test_caps_complex
+    form = Dataforms::XData.new(:result)
+    form.add(Dataforms::XDataField.new('FORM_TYPE', :hidden)).value = 'urn:xmpp:dataforms:softwareinfo'
+    form.add(Dataforms::XDataField.new('ip_version')).values = ['ipv4', 'ipv6']
+    form.add(Dataforms::XDataField.new('software')).value = 'Psi' # re-ordered
+    form.add(Dataforms::XDataField.new('software_version')).value = '0.11'
+    form.add(Dataforms::XDataField.new('os')).value = 'Mac'
+    form.add(Dataforms::XDataField.new('os_version')).value = '10.5.1'
+    ver = Caps::generate_ver([Discovery::Identity.new('client', 'Psi 0.9.1', 'pc').set_xml_lang('en'),
+                              Discovery::Identity.new('client', 'Ψ 0.9.1', 'pc').set_xml_lang('el')],
+                             [Discovery::Feature.new('http://jabber.org/protocol/muc'), # re-ordered
+                              Discovery::Feature.new('http://jabber.org/protocol/disco#info'),
+                              Discovery::Feature.new('http://jabber.org/protocol/disco#items')],
+                             [form])
+    assert_equal('8lu+88MRxmKM7yO3MEzY7YmTsWs=', ver)
+  end
+
+  ##
+  # http://www.xmpp.org/extensions/xep-0115.html#ver-gen-complex
+  def test_caps_complex_imported
+    query = IqQuery::import(REXML::Document.new(<<END).root)
+<query xmlns='http://jabber.org/protocol/disco#info'
+         node='http://psi-im.org#8lu+88MRxmKM7yO3MEzY7YmTsWs='>
+    <identity xml:lang='en' category='client' name='Psi 0.9.1' type='pc'/>
+    <identity xml:lang='el' category='client' name='Ψ 0.9.1' type='pc'/>
+    <feature var='http://jabber.org/protocol/disco#info'/>
+    <feature var='http://jabber.org/protocol/disco#items'/>
+    <feature var='http://jabber.org/protocol/muc'/>
+    <x xmlns='jabber:x:data' type='result'>
+      <field var='FORM_TYPE' type='hidden'>
+        <value>urn:xmpp:dataforms:softwareinfo</value>
+      </field>
+      <field var='ip_version'>
+        <value>ipv4</value>
+        <value>ipv6</value>
+      </field>
+      <field var='os'>
+        <value>Mac</value>
+      </field>
+      <field var='os_version'>
+        <value>10.5.1</value>
+      </field>
+      <field var='software'>
+        <value>Psi</value>
+      </field>
+      <field var='software_version'>
+        <value>0.11</value>
+      </field>
+    </x>
+  </query>
+END
+    assert_equal('8lu+88MRxmKM7yO3MEzY7YmTsWs=',
+                 Caps::generate_ver_from_discoinfo(query))
+  end
+end

data/test/dataforms/tc_data.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/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/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/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/lib/clienttester.rb

@@ -0,0 +1,120 @@
+# =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'
+
+# 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">'
+
+      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)
+      @client.send(stream) { |reply| true }
+
+      @state = 0
+      @states = []
+      @state_wait = Semaphore.new
+      @state_wait2 = Semaphore.new
+      @server.add_stanza_callback { |stanza|
+        if @state < @states.size
+          begin
+            @states[@state].call(stanza)
+          rescue
+            puts "Exception in state: #{$!.class}: #{$!}\n#{$!.join("\n")}"
+          end
+          @state += 1
+          @state_wait2.wait
+          @state_wait.run
+        end
+
+        false
+      }
+
+      serverwait.wait
+    end
+
+    def teardown
+      @client.close
+      @server.close
+    end
+
+    def send(xml)
+      @server.send(xml)
+    end
+
+    def state(&block)
+      @states << block
+    end
+
+    def wait_state
+      @state_wait2.run
+      @state_wait.wait
+    end
+
+    def skip_state
+      @state_wait2.run
+    end
+  end
+end
+
+# Restore the old $VERBOSE setting
+$VERBOSE = oldverbose