mojodna-xmpp4r 0.4.0.2

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

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

data/test/tc_jid.rb

@@ -0,0 +1,204 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'xmpp4r/jid'
+require 'xmpp4r/xmppelement'
+require 'xmpp4r/errors'
+include Jabber
+
+class JIDTest < Test::Unit::TestCase
+  def test_create1
+    j = JID.new('a', 'b', 'c')
+    assert_equal('a', j.node)
+    assert_equal('b', j.domain)
+    assert_equal('c', j.resource)
+  end
+
+  def test_create2
+    j = JID.new('a', 'b', 'c')
+    j2 = JID.new(j)
+    assert_equal('a', j2.node)
+    assert_equal('b', j2.domain)
+    assert_equal('c', j2.resource)
+    assert_equal('a@b/c', j.to_s)
+  end
+
+  def test_create3
+    j = JID.new('a@b/c')
+    assert_equal('a', j.node)
+    assert_equal('b', j.domain)
+    assert_equal('c', j.resource)
+    assert_equal('a@b/c', j.to_s)
+  end
+
+  def test_create4
+    j = JID.new('a@b')
+    assert_equal('a', j.node)
+    assert_equal('b', j.domain)
+    assert_equal(nil, j.resource)
+    assert_equal('a@b', j.to_s)
+  end
+
+  def test_create5
+    j = JID.new
+    assert_equal(nil, j.node)
+    assert_equal(nil, j.domain)
+    assert_equal(nil, j.resource)
+    assert_equal('', j.to_s)
+  end
+
+  def test_create6
+    j = JID.new('dom')
+    assert_equal(nil, j.node)
+    assert_equal('dom', j.domain)
+    assert_equal(nil, j.resource)
+    assert_equal('dom', j.to_s)
+  end
+
+  def test_create7
+    j = JID.new('dom/res')
+    assert_equal(nil, j.node)
+    assert_equal('dom', j.domain)
+    assert_equal('res', j.resource)
+    assert_equal('dom/res', j.to_s)
+  end
+
+  def test_create8
+    j = JID.new('dom/a@b')
+    assert_equal(nil, j.node)
+    assert_equal('dom', j.domain)
+    assert_equal('a@b', j.resource)
+    assert_equal('dom/a@b', j.to_s)
+  end
+
+  def test_create9
+    assert_nothing_raised { JID.new("#{'n'*1023}@#{'d'*1023}/#{'r'*1023}") }
+    assert_raises(Jabber::ArgumentError) { JID.new("#{'n'*1024}@#{'d'*1023}/#{'r'*1023}") }
+    assert_raises(Jabber::ArgumentError) { JID.new("#{'n'*1023}@#{'d'*1024}/#{'r'*1023}") }
+    assert_raises(Jabber::ArgumentError) { JID.new("#{'n'*1023}@#{'d'*1023}/#{'r'*1024}") }
+  end
+
+  def test_create10
+    j = JID.new('@b/c')
+    assert_equal('', j.node)
+    assert_equal('b', j.domain)
+    assert_equal('c', j.resource)
+    assert_equal('@b/c', j.to_s)
+  end
+
+  def test_create11
+    j = JID.new('@b')
+    assert_equal('', j.node)
+    assert_equal('b', j.domain)
+    assert_equal(nil, j.resource)
+    assert_equal('@b', j.to_s)
+  end
+
+  def test_create12
+    j = JID.new('@b/')
+    assert_equal('', j.node)
+    assert_equal('b', j.domain)
+    assert_equal('', j.resource)
+    assert_equal('@b/', j.to_s)
+  end
+
+  def test_create13
+    j = JID.new('a@b/')
+    assert_equal('a', j.node)
+    assert_equal('b', j.domain)
+    assert_equal('', j.resource)
+    assert_equal('a@b/', j.to_s)
+  end
+
+  def test_create14
+    j = JID.new('nOdE@dOmAiN/rEsOuRcE')
+    assert_equal('node', j.node)
+    assert_equal('domain', j.domain)
+    assert_equal('rEsOuRcE', j.resource)
+    assert_equal('node@domain/rEsOuRcE', j.to_s)
+  end
+
+  def test_tos
+    assert_equal('', JID.new.to_s)
+    assert_equal('domain.fr', JID.new('domain.fr').to_s)
+    assert_equal('l@domain.fr', JID.new('l','domain.fr').to_s)
+    assert_equal('l@domain.fr/res', JID.new('l','domain.fr','res').to_s)
+    assert_equal('domain.fr/res', JID.new(nil,'domain.fr','res').to_s)
+  end
+
+  def test_equal
+    assert_equal(JID.new('domain.fr'), JID.new('domain.fr'))
+    assert_equal(JID.new('domain.fr'), JID.new(nil, 'domain.fr'))
+    assert_equal(JID.new('l@domain.fr'), JID.new('l@domain.fr'))
+    assert_equal(JID.new('l@domain.fr'), JID.new('l', 'domain.fr'))
+    assert_equal(JID.new('l@domain.fr/res'), JID.new('l@domain.fr/res'))
+    assert_equal(JID.new('l@domain.fr/res'), JID.new('l', 'domain.fr', 'res'))
+  end
+
+  def test_hash
+    h = {}
+    j = JID.new('l@domain.fr/res')
+    h[j] = 'a'
+    assert_equal(h[j], h[JID.new('l@domain.fr/res')])
+  end
+
+  def test_strip
+    assert_equal(JID.new('l@domain.fr'), JID.new('l@domain.fr/res').strip)
+    assert_equal(JID.new('l@domain.fr'), JID.new('l@domain.fr').strip)
+    assert_equal(JID.new('l@domain.fr'), JID.new('l@domain.fr/res').bare)
+    jid = JID.new('l@domain.fr/res')
+    jid.strip!
+    assert_equal(JID.new('l@domain.fr'), jid)
+
+    jid = JID.new('l@domain.fr/res')
+    jid.bare!
+    assert_equal(JID.new('l@domain.fr'), jid)
+  end
+
+  def test_change1
+    j = JID.new('a@b/c')
+    j.node = 'd'
+    assert_equal('d@b/c', j.to_s)
+    j.domain = 'e'
+    assert_equal('d@e/c', j.to_s)
+    j.resource = 'f'
+    assert_equal('d@e/f', j.to_s)
+  end
+
+  def test_escaping
+    j = JID.new('user1@server1')
+    j2 = JID.new(JID::escape(j), 'server2', 'res2')
+    assert_equal('user1%server1@server2/res2', j2.to_s)
+  end
+
+if defined?(libidnbug) # this crashes the interpreter
+  def test_invalidnode
+#    assert_raises(IDN::Stringprep::StringprepError) { JID.new('toto@a/a', 'server', 'res') }
+    assert_raises(IDN::Stringprep::StringprepError) { IDN::Stringprep.nodeprep('toto@a/a') }
+  end
+end
+
+  def test_empty
+    assert(JID.new.empty?)
+    assert(!JID.new("test").empty?)
+  end
+
+  def test_stripped
+    assert(JID.new("node@domain").stripped?)
+    assert(!JID.new("node@domain/res").stripped?)
+    assert(JID.new("node@domain").bared?)
+    assert(!JID.new("node@domain/res").bared?)
+  end
+
+  def test_sort
+    assert_equal(-1, JID.new('a@b') <=> JID.new('b@b'))
+    assert_equal(0, JID.new('a@b') <=> JID.new('a@b'))
+    assert_equal(1, JID.new('a@b/r') <=> JID.new('a@b'))
+
+    jids = [JID.new('b@b'), JID.new('a@b/r'), JID.new('a@b')]
+    jids.sort!
+    assert_equal([JID.new('a@b'), JID.new('a@b/r'), JID.new('b@b')], jids)
+  end
+end

data/test/tc_message.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/message'
+require 'xmpp4r/errors'
+include Jabber
+
+class MessageTest < Test::Unit::TestCase
+  def test_create
+    x = Message.new()
+    assert_equal("message", x.name)
+    assert_equal("jabber:client", x.namespace)
+    assert_equal(nil, x.to)
+    assert_equal(nil, x.body)
+
+    x = Message.new("lucas@linux.ensimag.fr", "coucou")
+    assert_equal("message", x.name)
+    assert_equal("lucas@linux.ensimag.fr", x.to.to_s)
+    assert_equal("coucou", x.body)
+  end
+
+  def test_import
+    x = Message.new
+    assert_kind_of(REXML::Element, x.typed_add(REXML::Element.new('thread')))
+    assert_kind_of(X, x.typed_add(REXML::Element.new('x')))
+    assert_kind_of(X, x.x)
+  end
+
+  def test_type
+    x = Message.new
+    assert_equal(nil, x.type)
+    x.type = :chat
+    assert_equal(:chat, x.type)
+    assert_equal(x, x.set_type(:error))
+    assert_equal(:error, x.type)
+    x.type = :groupchat
+    assert_equal(:groupchat, x.type)
+    x.type = :headline
+    assert_equal(:headline, x.type)
+    x.type = :normal
+    assert_equal(:normal, x.type)
+    x.type = :invalid
+    assert_equal(nil, x.type)
+  end
+
+  def test_body
+    x = Message.new()
+    assert_equal(nil, x.body)
+    assert_equal(x, x.set_body("trezrze ezfrezr ezr zer ezr ezrezrez ezr z"))
+    assert_equal("trezrze ezfrezr ezr zer ezr ezrezrez ezr z", x.body)
+    x.body = "2"
+    assert_equal("2", x.body)
+  end
+
+  def test_subject
+    x = Message.new
+    assert_equal(nil, x.subject)
+    subject = REXML::Element.new('subject')
+    subject.text = 'A'
+    x.add(subject)
+    assert_equal('A', x.subject)
+    x.subject = 'Test message'
+    assert_equal('Test message', x.subject)
+    x.each_element('subject') { |s| assert_equal('Test message', s.text) }
+    assert_equal(x, x.set_subject('Breaking news'))
+    assert_equal('Breaking news', x.subject)
+  end
+
+  def test_thread
+    x = Message.new
+    assert_equal(nil, x.thread)
+    thread = REXML::Element.new('thread')
+    thread.text = '123'
+    x.add(thread)
+    assert_equal('123', x.thread)
+    x.thread = '321'
+    assert_equal('321', x.thread)
+    x.each_element('thread') { |s| assert_equal('321', s.text) }
+    assert_equal(x, x.set_thread('abc'))
+    assert_equal('abc', x.thread)
+  end
+
+  def test_chat_state
+    x = Message.new
+    assert_equal(:active, x.chat_state)
+    chat_state = REXML::Element.new('inactive')
+    chat_state.add_namespace('http://jabber.org/protocol/chatstates')
+    x.delete_element('active')
+    x.add(chat_state)
+    assert_equal(:inactive, x.chat_state)
+    x.chat_state = :gone
+    assert_equal(:gone, x.chat_state)
+    assert_raise(InvalidChatState) do
+      x.chat_state = :some_invalid_state
+    end
+    assert_equal true, x.gone?
+  end
+
+  def test_error
+    x = Message.new()
+    assert_equal(nil, x.error)
+    e = REXML::Element.new('error')
+    x.add(e)
+    # test if, after an import, the error element is successfully changed
+    # into an ErrorResponse object.
+    x2 = Message.new.import(x)
+    assert_equal(ErrorResponse, x2.first_element('error').class)
+  end
+
+  def test_answer
+    orig = Message.new
+    orig.from = 'a@b'
+    orig.to = 'b@a'
+    orig.id = '123'
+    orig.type = :chat
+    orig.add(REXML::Element.new('x'))
+
+    answer = orig.answer
+    assert_equal(JID.new('b@a'), answer.from)
+    assert_equal(JID.new('a@b'), answer.to)
+    assert_equal('123', answer.id)
+    assert_equal(:chat, answer.type)
+    answer.each_element { |e|
+      assert_equal('x', e.name)
+      assert_kind_of(X, e)
+    }
+  end
+end