ln-xmpp4r 0.5

data/test/tc_class_names.rb

@@ -0,0 +1,146 @@
+#!/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::JabberError)
+    assert_kind_of(Class, Jabber::ErrorResponse)
+    assert_kind_of(Class, Jabber::ClientAuthenticationFailure)
+    assert_kind_of(Class, Jabber::ComponentAuthenticationFailure)
+    assert_kind_of(Class, Jabber::Client)
+    assert_kind_of(Class, Jabber::Component)
+    assert_kind_of(Class, Jabber::Connection)
+    assert_kind_of(Class, Jabber::ErrorResponse)
+    assert_kind_of(Class, Jabber::ServerError)
+    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::XMPPElement)
+    assert_kind_of(Class, Jabber::XMPPStanza)
+  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(Class, Jabber::SOCKS5Error)
+    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::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
+
+  def test_rpc
+    require 'xmpp4r/rpc'
+    assert_kind_of(Module, Jabber::RPC)
+    assert_kind_of(Class, Jabber::RPC::Server)
+    assert_kind_of(Class, Jabber::RPC::Client)
+  end
+
+  def test_pubsub
+    require 'xmpp4r/pubsub'
+    assert_kind_of(Module, Jabber::PubSub)
+    assert_kind_of(Class, Jabber::PubSub::ServiceHelper)
+  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_errors.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'xmpp4r'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/message'
+include Jabber
+
+class ServerErrorTest < Test::Unit::TestCase
+
+  def test_create_with_empty_error
+    e = ErrorResponse.new()
+    ee = ServerError.new(e)
+    assert_equal(nil, e.error)
+  end
+
+  def test_create_with_error_code
+    e = ErrorResponse.new('payment-required')
+    ee = ServerError.new(e)
+    assert_equal("payment-required: ", ee.to_s)
+  end
+
+  def test_create_invalid
+    assert_raise(Jabber::ArgumentError) {
+      e = ErrorResponse.new('invalid error')
+      ee = ServerError.new(e)
+    }
+  end
+
+  def test_to_s_with_error_code_but_no_text
+    e = ErrorResponse.new('payment-required')
+    ee = ServerError.new(e)
+    assert_equal("payment-required: ", ee.to_s)
+    assert_equal('payment-required', e.error)
+    assert_equal(402, ee.error.code)
+    assert_equal(:auth, ee.error.type)
+    assert_equal(nil, ee.error.text)
+  end
+
+  def test_to_s_with_error_code_and_text
+    e = ErrorResponse.new('payment-required', 'cuz you are a deadbeat.')
+    ee = ServerError.new(e)
+    assert_equal("payment-required: cuz you are a deadbeat.", ee.to_s)
+    assert_equal('payment-required', e.error)
+    assert_equal(402, ee.error.code)
+    assert_equal(:auth, ee.error.type)
+    assert_equal("cuz you are a deadbeat.", ee.error.text)
+  end
+
+end
+
+class ErrorTest < Test::Unit::TestCase
+  def test_create
+    e = ErrorResponse.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 = ErrorResponse.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 = ErrorResponse.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(Jabber::ArgumentError) {
+      e = ErrorResponse.new('invalid error')
+    }
+  end
+
+  def test_type
+    e = ErrorResponse.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 = ErrorResponse.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 = ErrorResponse.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(ErrorResponse.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 = ErrorResponse.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 = ErrorResponse.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,113 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/iq'
+require 'xmpp4r/errors'
+include Jabber
+
+require File::dirname(__FILE__) + '/lib/assert_equal_xml'
+
+class IqTest < Test::Unit::TestCase
+  def test_create
+    x = Iq.new()
+    assert_equal("iq", x.name)
+    assert_equal("jabber:client", x.namespace)
+    assert_equal_xml("<iq xmlns='jabber:client'/>", x)
+  end
+
+  def test_iqauth
+    x = Iq.new_authset(JID.new('node@domain/resource'), 'password')
+    assert_equal_xml("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:auth'><username>node</username><password>password</password><resource>resource</resource></query></iq>", x)
+  end
+
+  def test_iqauth_digest
+    x = Iq.new_authset_digest(JID.new('node@domain/resource'), '', 'password')
+    assert_equal_xml("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:auth'><username>node</username><digest>#{Digest::SHA1.hexdigest('password')}</digest><resource>resource</resource></query></iq>", x)
+  end
+
+  def test_register
+    x1 = Iq.new_register
+    assert_equal_xml("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:register'/></iq>", x1)
+    x2 = Iq.new_register('node')
+    assert_equal_xml("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:register'><username>node</username></query></iq>", x2)
+    x3 = Iq.new_register('node', 'password')
+    assert_equal_xml("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:register'><username>node</username><password>password</password></query></iq>", x3)
+  end
+
+  def test_rosterget
+    x = Iq.new_rosterget
+    assert_equal_xml("<iq type='get' xmlns='jabber:client'><query xmlns='jabber:iq:roster'/></iq>", x)
+  end
+
+  def test_rosterset
+    x = Iq.new_rosterset
+    assert_equal_xml("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:roster'/></iq>", x)
+  end
+
+  def test_browseget
+    x = Iq.new_browseget
+    assert_equal_xml("<iq type='get' xmlns='jabber:client'><query xmlns='jabber:iq:browse'/></iq>", x)
+  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('jabber:client', 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('jabber:client', 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 ErrorResponse object.
+    x2 = Iq.new.import(x)
+    assert_equal(ErrorResponse, 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('jabber:client', x.queryns)
+  end
+end