xmpp4r 0.3

data/test/tc_callbacks.rb

@@ -0,0 +1,128 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'callbacks'
+
+class CallbacksTest < Test::Unit::TestCase
+  def test_test1
+    called = 0
+    cb = Callback::new(5, "toto", Proc::new { called += 1 })
+    assert_equal(5, cb.priority)
+    assert_equal("toto", cb.ref)
+    cb.block.call
+    assert_equal(1, called)
+    cb.block.call
+    assert_equal(2, called)
+  end
+
+  def test_callbacklist1
+    cbl = CallbackList::new
+    called1 = false
+    called2 = false
+    called3 = false
+    called4 = false
+    cbl.add(5, "ref1") { called1 = true ; true }
+    cbl.add(7, "ref1") { |e| called2 = true ; false}
+    cbl.add(9, "ref1") { called3 = true ;false }
+    cbl.add(11, "ref1") { called4 = true ; false }
+    o = "aaaa"
+    assert(cbl.process(o))
+    assert(called1)
+    assert(called2)
+    assert(called3)
+    assert(called4)
+  end
+
+  def test_callbacklist2
+    cbl = CallbackList::new
+    assert(0, cbl.length)
+    cbl.add(5, "ref1") { called1 = true }
+    assert(1, cbl.length)
+    cbl.add(7, "ref2") { |e| called2 = true ; e.consume }
+    assert(2, cbl.length)
+    cbl.delete("ref2")
+    assert(1, cbl.length)
+    cbl.add(9, "ref3") { called3 = true }
+    assert(2, cbl.length)
+  end
+
+  def test_callbacklist4
+    cbl = CallbackList::new
+    cbl.add(5, "ref1") { false }
+    cbl.add(7, "ref1") { false }
+    o = "o"
+    assert(!cbl.process(o))
+   end
+
+  def test_callbacklist5
+    cbl = CallbackList::new
+    cbl.add(5, "ref1") { true }
+    cbl.add(7, "ref1") { false }
+    o = "o"
+    assert(cbl.process(o))
+   end
+
+  def test_callbacklist6
+    cbl = CallbackList::new
+    ok = false
+    c = 'a'
+    d = 'b'
+    cbl.add(5, "ref1") { |a, b|
+      if a == 'a' and b == 'b'
+        ok = true
+      end
+      false
+    }
+    assert(!cbl.process(c, d))
+    assert(ok)
+   end
+
+  def test_callbacklist7
+    cbl = CallbackList::new
+    called1 = false
+    called2 = false
+    called3 = false
+    called4 = false
+    cbl.add(3, "ref1") { called4 = true ; true }
+    cbl.add(5, "ref1") { called1 = true ; true }
+    cbl.add(7, "ref1") { called2 = true ; 'a'}
+    cbl.add(9, "ref1") { called3 = true ;1 }
+    o = "aaaa"
+    assert(cbl.process(o))
+    assert(called1)
+    assert(called2)
+    assert(called3)
+    assert(!called4)
+  end
+
+  def test_nested
+    cbl = CallbackList.new
+    called_outer = 0
+    called_inner = 0
+
+    cbl.add(100, nil) {
+      called_outer += 1
+
+      if called_outer == 1
+        cbl.add(200, nil) {
+          called_inner += 1
+        }
+      end
+    }
+
+    assert_equal(0, called_inner)
+    assert_equal(0, called_outer)
+
+    cbl.process
+
+    assert_equal(0, called_inner)
+    assert_equal(1, called_outer)
+
+    cbl.process
+
+    assert_equal(1, called_inner)
+    assert_equal(2, called_outer)
+  end
+end

data/test/tc_class_names.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'xmpp4r'
+# No include Jabber, test full namespace
+
+class JIDTest < Test::Unit::TestCase
+  def test_base
+    assert_kind_of(Module, Jabber)
+    assert_kind_of(Class, Jabber::AuthenticationFailure)
+    assert_kind_of(Class, Jabber::Client)
+    assert_kind_of(Class, Jabber::Component)
+    assert_kind_of(Class, Jabber::Connection)
+    assert_kind_of(Class, Jabber::Error)
+    assert_kind_of(Class, Jabber::ErrorException)
+    assert_kind_of(Class, Jabber::IdGenerator)
+    assert_kind_of(Class, Jabber::Iq)
+    assert_kind_of(Class, Jabber::IqQuery)
+    assert_kind_of(Class, Jabber::JID)
+    assert_kind_of(Class, Jabber::Message)
+    assert_kind_of(Class, Jabber::Presence)
+    assert_kind_of(Module, Jabber::SASL)
+    assert_respond_to(Jabber::SASL, :new)
+    assert_kind_of(Class, Jabber::SASL::Base)
+    assert_kind_of(Class, Jabber::SASL::Plain)
+    assert_kind_of(Class, Jabber::SASL::DigestMD5)
+    assert_kind_of(Class, Jabber::Stream)
+    assert_kind_of(Class, Jabber::StreamParser)
+    assert_kind_of(Class, Jabber::X)
+    assert_kind_of(Class, Jabber::XMLStanza)
+  end
+
+  def test_roster
+    require 'xmpp4r/roster'
+    assert_kind_of(Module, Jabber::Roster)
+    assert_kind_of(Class, Jabber::Roster::Helper)
+    assert_kind_of(Class, Jabber::Roster::Helper::RosterItem)
+    assert_kind_of(Class, Jabber::Roster::RosterItem)
+    assert_kind_of(Class, Jabber::Roster::IqQueryRoster)
+    assert_kind_of(Class, Jabber::Roster::XRoster)
+    assert_kind_of(Class, Jabber::Roster::XRosterItem)
+  end
+
+  def test_muc
+    require 'xmpp4r/muc'
+    assert_kind_of(Module, Jabber::MUC)
+    assert_kind_of(Class, Jabber::MUC::MUCBrowser)
+    assert_kind_of(Class, Jabber::MUC::MUCClient)
+    assert_kind_of(Class, Jabber::MUC::SimpleMUCClient)
+    assert_kind_of(Class, Jabber::MUC::XMUC)
+    assert_kind_of(Class, Jabber::MUC::XMUCUser)
+    assert_kind_of(Class, Jabber::MUC::XMUCUserInvite)
+  end
+
+  def test_bytestreams
+    require 'xmpp4r/bytestreams'
+    assert_kind_of(Module, Jabber::FileTransfer)
+    assert_kind_of(Module, Jabber::FileTransfer::TransferSource)
+    assert_kind_of(Class, Jabber::FileTransfer::FileSource)
+    assert_kind_of(Class, Jabber::FileTransfer::Helper)
+    assert_kind_of(Class, Jabber::Bytestreams::SOCKS5BytestreamsServer)
+    assert_kind_of(Class, Jabber::Bytestreams::SOCKS5BytestreamsServerStreamHost)
+    assert_kind_of(Class, Jabber::Bytestreams::SOCKS5BytestreamsPeer)
+    assert_kind_of(Class, Jabber::Bytestreams::IqQueryBytestreams)
+    assert_kind_of(Class, Jabber::Bytestreams::StreamHost)
+    assert_kind_of(Class, Jabber::Bytestreams::StreamHostUsed)
+    assert_kind_of(Class, Jabber::Bytestreams::IqSi)
+    assert_kind_of(Class, Jabber::Bytestreams::IqSiFile)
+    assert_kind_of(Class, Jabber::Bytestreams::IqSiFileRange)
+    assert_kind_of(Class, Jabber::Bytestreams::IBB)
+    assert_kind_of(Class, Jabber::Bytestreams::IBBQueueItem)
+    assert_kind_of(Class, Jabber::Bytestreams::IBBInitiator)
+    assert_kind_of(Class, Jabber::Bytestreams::IBBTarget)
+    assert_kind_of(Class, Jabber::Bytestreams::SOCKS5Bytestreams)
+    assert_kind_of(Class, Jabber::Bytestreams::SOCKS5BytestreamsInitiator)
+    assert_kind_of(Class, Jabber::Bytestreams::SOCKS5BytestreamsTarget)
+    assert_kind_of(Class, Jabber::Bytestreams::SOCKS5Error)
+    assert_kind_of(Class, Jabber::Bytestreams::SOCKS5Socket)
+  end
+  
+  def test_dataforms
+    require 'xmpp4r/dataforms'
+    assert_kind_of(Module, Jabber::Dataforms)
+    assert_kind_of(Class, Jabber::Dataforms::XData)
+    assert_kind_of(Class, Jabber::Dataforms::XDataTitle)
+    assert_kind_of(Class, Jabber::Dataforms::XDataInstructions)
+    assert_kind_of(Class, Jabber::Dataforms::XDataField)
+    assert_kind_of(Class, Jabber::Dataforms::XDataReported)
+  end
+  
+  def test_delay
+    require 'xmpp4r/delay'
+    assert_kind_of(Module, Jabber::Delay)
+    assert_kind_of(Class, Jabber::Delay::XDelay)
+  end
+
+  def test_discovery
+    require 'xmpp4r/discovery'
+    assert_kind_of(Module, Jabber::Discovery)
+    assert_kind_of(Class, Jabber::Discovery::IqQueryDiscoInfo)
+    assert_kind_of(Class, Jabber::Discovery::Identity)
+    assert_kind_of(Class, Jabber::Discovery::Feature)
+    assert_kind_of(Class, Jabber::Discovery::IqQueryDiscoItems)
+    assert_kind_of(Class, Jabber::Discovery::Item)
+  end
+
+  def test_feature_negotiation
+    require 'xmpp4r/feature_negotiation'
+    assert_kind_of(Module, Jabber::FeatureNegotiation)
+    assert_kind_of(Class, Jabber::FeatureNegotiation::IqFeature)
+  end
+
+  def test_vcard
+    require 'xmpp4r/vcard'
+    assert_kind_of(Module, Jabber::Vcard)
+    assert_kind_of(Class, Jabber::Vcard::Helper)
+    assert_kind_of(Class, Jabber::Vcard::IqVcard)
+  end
+
+  def test_version
+    require 'xmpp4r/version'
+    assert_kind_of(Module, Jabber::Version)
+    assert_kind_of(Class, Jabber::Version::Responder)
+    assert_kind_of(Class, Jabber::Version::SimpleResponder)
+    assert_kind_of(Class, Jabber::Version::IqQueryVersion)
+  end
+end

data/test/tc_client.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'xmpp4r/client'
+include Jabber
+
+class ClientTest < Test::Unit::TestCase
+  def test_client1
+=begin
+    c = Client::new(JID::new('client1@localhost/res'))
+    assert_nothing_raised("Couldn't connect") {
+      c.connect
+    }
+    assert_nothing_raised("Couldn't authenticate") {
+      c.auth('pw')
+    }
+=end
+  end
+
+  def test_jid_is_jid
+    c1 = Client::new(JID::new('user@host/resource'))
+    assert_kind_of(JID, c1.jid)
+    assert_equal('user@host/resource', c1.jid.to_s)
+    c2 = Client::new('user@host/resource')
+    assert_kind_of(JID, c2.jid)
+    assert_equal('user@host/resource', c2.jid.to_s)
+  end
+end

data/test/tc_error.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/error'
+require 'xmpp4r/message'
+include Jabber
+
+class ErrorTest < Test::Unit::TestCase
+  def test_create
+    e = Error::new
+    assert_equal(nil, e.error)
+    assert_equal(nil, e.code)
+    assert_equal(nil, e.type)
+    assert_equal(nil, e.text)
+  end
+
+  def test_create2
+    e = Error::new('payment-required')
+    assert_equal('payment-required', e.error)
+    assert_equal(402, e.code)
+    assert_equal(:auth, e.type)
+    assert_equal(nil, e.text)
+  end
+
+  def test_create3
+    e = Error::new('gone', 'User moved to afterlife.gov')
+    assert_equal('gone', e.error)
+    assert_equal(302, e.code)
+    assert_equal(:modify, e.type)
+    assert_equal('User moved to afterlife.gov', e.text)
+  end
+
+  def test_create_invalid
+    assert_raise(RuntimeError) {
+      e = Error::new('invalid error')
+    }
+  end
+
+  def test_type
+    e = Error::new
+    assert_nil(e.type)
+    e.type = :auth
+    assert_equal(:auth, e.type)
+    e.type = :cancel
+    assert_equal(:cancel, e.type)
+    e.type = :continue
+    assert_equal(:continue, e.type)
+    e.type = :modify
+    assert_equal(:modify, e.type)
+    e.type = :wait
+    assert_equal(:wait, e.type)
+    e.type = nil
+    assert_nil(e.type)
+  end
+
+  def test_code
+    e = Error::new
+    assert_nil(e.code)
+    e.code = 404
+    assert_equal(404, e.code)
+    assert_equal("<error code='404'/>", e.to_s)
+    e.code = nil
+    assert_nil(e.code)
+  end
+
+  def test_error
+    e = Error::new
+    assert_nil(e.error)
+    e.error = 'gone'
+    assert_equal('gone', e.error)
+    assert_raise(RuntimeError) {
+      e.error = nil
+    }
+  end
+
+  def test_stanzas
+    m = Message.new
+    assert_equal(nil, m.error)
+    m.typed_add(Error.new)
+    assert_equal('<error/>', m.error.to_s)
+  end
+
+  def test_sample_normal
+    src = '<error code="302" type="modify"><gone xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"/><text xmlns="urn:ietf:params:xml:ns:xmpp-stanzas">...</text></error>'
+    e = Error.new.import(REXML::Document.new(src).root)
+    assert_equal(:modify, e.type)
+    assert_equal(302, e.code)
+    assert_equal('gone', e.error)
+    assert_equal('...', e.text)
+  end
+
+  def test_sample_muc
+    src = '<error code="409">Please choose a different nickname.</error>'
+    e = Error.new.import(REXML::Document.new(src).root)
+    assert_equal(nil, e.type)
+    assert_equal(409, e.code)
+    assert_equal(nil, e.error)
+    assert_equal('Please choose a different nickname.', e.text)
+  end
+end

data/test/tc_idgenerator.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'xmpp4r/idgenerator'
+include Jabber
+
+class IdGeneratorTest < Test::Unit::TestCase
+  def test_instances
+    assert_equal(Jabber::IdGenerator.instance, Jabber::IdGenerator.instance)
+  end
+
+  def test_unique
+    ids = []
+    100.times { ids.push(Jabber::IdGenerator.generate_id) }
+
+    ok = true
+    ids.each_index { |a|
+      ids.each_index { |b|
+        if a == b
+          ok = false if ids[a] != ids[b]
+        else
+          ok = false if ids[a] == ids[b]
+        end
+      }
+    }
+    assert(ok)
+  end
+end

data/test/tc_iq.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/iq'
+include Jabber
+
+class IqTest < Test::Unit::TestCase
+  def test_create
+    x = Iq::new()
+    assert_equal("iq", x.name)
+    assert_equal("<iq/>", x.to_s)
+  end
+
+  def test_iqauth
+    x = Iq::new_authset(JID::new('node@domain/resource'), 'password')
+    assert_equal("<iq type='set'><query xmlns='jabber:iq:auth'><username>node</username><password>password</password><resource>resource</resource></query></iq>", x.to_s)
+  end
+
+  def test_iqauth_digest
+    x = Iq::new_authset_digest(JID::new('node@domain/resource'), '', 'password')
+    assert_equal("<iq type='set'><query xmlns='jabber:iq:auth'><username>node</username><digest>#{Digest::SHA1.new('password').hexdigest}</digest><resource>resource</resource></query></iq>", x.to_s)
+  end
+
+  def test_register
+    x1 = Iq::new_register
+    assert_equal("<iq type='set'><query xmlns='jabber:iq:register'/></iq>", x1.to_s)
+    x2 = Iq::new_register('node')
+    assert_equal("<iq type='set'><query xmlns='jabber:iq:register'><username>node</username></query></iq>", x2.to_s)
+    x3 = Iq::new_register('node', 'password')
+    assert_equal("<iq type='set'><query xmlns='jabber:iq:register'><username>node</username><password>password</password></query></iq>", x3.to_s)
+  end
+
+  def test_rosterget
+    x = Iq::new_rosterget
+    assert_equal("<iq type='get'><query xmlns='jabber:iq:roster'/></iq>", x.to_s)
+  end
+
+  def test_rosterset
+    x = Iq::new_rosterset
+    assert_equal("<iq type='set'><query xmlns='jabber:iq:roster'/></iq>", x.to_s)
+  end
+
+  def test_browseget
+    x = Iq::new_browseget
+    assert_equal("<iq type='get'><query xmlns='jabber:iq:browse'/></iq>", x.to_s)
+  end
+
+  def test_types
+    iq = Iq::new
+    assert_equal(nil, iq.type)
+    iq.type = :get
+    assert_equal(:get, iq.type)
+    iq.type = :set
+    assert_equal(:set, iq.type)
+    iq.type = :result
+    assert_equal(:result, iq.type)
+    iq.type = :error
+    assert_equal(:error, iq.type)
+    iq.type = :invalid
+    assert_equal(nil, iq.type)
+  end
+
+  def test_query
+    x = Iq::new(:set)
+    assert_equal(nil, x.queryns)
+    query = REXML::Element::new('query')
+    x.add(query)
+    assert_equal('', x.queryns)
+    query.add_namespace('jabber:iq:auth')
+    assert_equal(query.to_s, x.query.to_s)
+    assert_equal('jabber:iq:auth', x.queryns)
+
+    query2 = REXML::Element::new('query')
+    x.query = query2
+    assert_equal('', x.queryns)
+    query2.add_namespace('jabber:iq:register')
+    assert_equal('jabber:iq:register', x.queryns)
+  end
+
+  def test_vcard
+    x = Iq::new
+    assert_equal(nil, x.vcard)
+    x.add(vcard = REXML::Element.new('vCard'))
+    assert_equal(vcard, x.vcard)
+  end
+
+  def test_error
+    x = Iq::new(:set)
+    e = REXML::Element::new('error')
+    x.add(e)
+    # test if, after an import, the error element is successfully changed
+    # into an Error object.
+    x2 = Iq::new.import(x)
+    assert_equal(Error, x2.first_element('error').class)
+  end
+
+  def test_new_query
+    x = Iq::new_query(:get, JID.new('a@b/c'))
+    assert_equal(:get, x.type)
+    assert_equal(nil, x.from)
+    assert_equal(JID.new('a@b/c'), x.to)
+    assert_kind_of(IqQuery, x.query)
+    assert_equal('', x.queryns)
+  end
+end

data/test/tc_iqquery.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/query'
+include Jabber
+
+class IqQueryTest < Test::Unit::TestCase
+  def test_create
+    x = IqQuery::new()
+    assert_equal("query", x.name)
+    assert_equal("<query/>", x.to_s)
+  end
+
+  def test_import
+    q = IqQuery::new
+    assert_equal(IqQuery, q.class)
+
+    e = REXML::Element.new('query')
+    e.add_namespace('jabber:iq:roster')
+    # kind_of? only checks that the class belongs to the IqQuery class
+    # hierarchy. See IqQueryRosterTest#test_import for a more strict
+    # check.
+    assert_kind_of(IqQuery, IqQuery.import(e))
+
+    # Importing specific derivates is to be tested in the test case of the derivate
+    # (e.g. tc_iqqueryroster.rb)
+  end
+end