xmpp4r 0.3.2 → 0.4

data/test/tc_iq.rb

@@ -6,52 +6,55 @@ 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()
+    x = Iq.new()
     assert_equal("iq", x.name)
     assert_equal("jabber:client", x.namespace)
-    assert_equal("<iq xmlns='jabber:client'/>", x.to_s)
+    assert_equal_xml("<iq xmlns='jabber:client'/>", x)
   end
 
   def test_iqauth
-    x = Iq::new_authset(JID::new('node@domain/resource'), 'password')
-    assert_equal("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:auth'><username>node</username><password>password</password><resource>resource</resource></query></iq>", x.to_s)
+    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("<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.to_s)
+    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("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:register'/></iq>", x1.to_s)
-    x2 = Iq::new_register('node')
-    assert_equal("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:register'><username>node</username></query></iq>", x2.to_s)
-    x3 = Iq::new_register('node', 'password')
-    assert_equal("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:register'><username>node</username><password>password</password></query></iq>", x3.to_s)
+    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("<iq type='get' xmlns='jabber:client'><query xmlns='jabber:iq:roster'/></iq>", x.to_s)
+    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("<iq type='set' xmlns='jabber:client'><query xmlns='jabber:iq:roster'/></iq>", x.to_s)
+    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("<iq type='get' xmlns='jabber:client'><query xmlns='jabber:iq:browse'/></iq>", x.to_s)
+    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
+    iq = Iq.new
     assert_equal(nil, iq.type)
     iq.type = :get
     assert_equal(:get, iq.type)
@@ -66,16 +69,16 @@ class IqTest < Test::Unit::TestCase
   end
 
   def test_query
-    x = Iq::new(:set)
+    x = Iq.new(:set)
     assert_equal(nil, x.queryns)
-    query = REXML::Element::new('query')
+    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')
+    query2 = REXML::Element.new('query')
     x.query = query2
     assert_equal('jabber:client', x.queryns)
     query2.add_namespace('jabber:iq:register')
@@ -83,24 +86,24 @@ class IqTest < Test::Unit::TestCase
   end
 
   def test_vcard
-    x = Iq::new
+    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 = 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)
+    # 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'))
+    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)

data/test/tc_iqquery.rb

@@ -9,13 +9,13 @@ include Jabber
 
 class IqQueryTest < Test::Unit::TestCase
   def test_create
-    x = IqQuery::new()
+    x = IqQuery.new()
     assert_equal("query", x.name)
     assert_equal("<query/>", x.to_s)
   end
 
   def test_import
-    q = IqQuery::new
+    q = IqQuery.new
     assert_equal(IqQuery, q.class)
 
     e = REXML::Element.new('query')

data/test/tc_jid.rb

@@ -4,19 +4,21 @@ $:.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')
+    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)
+    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)
@@ -24,7 +26,7 @@ class JIDTest < Test::Unit::TestCase
   end
 
   def test_create3
-    j = JID::new('a@b/c')
+    j = JID.new('a@b/c')
     assert_equal('a', j.node)
     assert_equal('b', j.domain)
     assert_equal('c', j.resource)
@@ -32,7 +34,7 @@ class JIDTest < Test::Unit::TestCase
   end
 
   def test_create4
-    j = JID::new('a@b')
+    j = JID.new('a@b')
     assert_equal('a', j.node)
     assert_equal('b', j.domain)
     assert_equal(nil, j.resource)
@@ -40,7 +42,7 @@ class JIDTest < Test::Unit::TestCase
   end
 
   def test_create5
-    j = JID::new
+    j = JID.new
     assert_equal(nil, j.node)
     assert_equal(nil, j.domain)
     assert_equal(nil, j.resource)
@@ -48,7 +50,7 @@ class JIDTest < Test::Unit::TestCase
   end
 
   def test_create6
-    j = JID::new('dom')
+    j = JID.new('dom')
     assert_equal(nil, j.node)
     assert_equal('dom', j.domain)
     assert_equal(nil, j.resource)
@@ -56,7 +58,7 @@ class JIDTest < Test::Unit::TestCase
   end
 
   def test_create7
-    j = JID::new('dom/res')
+    j = JID.new('dom/res')
     assert_equal(nil, j.node)
     assert_equal('dom', j.domain)
     assert_equal('res', j.resource)
@@ -64,7 +66,7 @@ class JIDTest < Test::Unit::TestCase
   end
 
   def test_create8
-    j = JID::new('dom/a@b')
+    j = JID.new('dom/a@b')
     assert_equal(nil, j.node)
     assert_equal('dom', j.domain)
     assert_equal('a@b', j.resource)
@@ -72,14 +74,14 @@ class JIDTest < Test::Unit::TestCase
   end
 
   def test_create9
-    assert_nothing_raised { JID::new("#{'n'*1023}@#{'d'*1023}/#{'r'*1023}") }
-    assert_raises(ArgumentError) { JID::new("#{'n'*1024}@#{'d'*1023}/#{'r'*1023}") }
-    assert_raises(ArgumentError) { JID::new("#{'n'*1023}@#{'d'*1024}/#{'r'*1023}") }
-    assert_raises(ArgumentError) { JID::new("#{'n'*1023}@#{'d'*1023}/#{'r'*1024}") }
+    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')
+    j = JID.new('@b/c')
     assert_equal('', j.node)
     assert_equal('b', j.domain)
     assert_equal('c', j.resource)
@@ -87,7 +89,7 @@ class JIDTest < Test::Unit::TestCase
   end
 
   def test_create11
-    j = JID::new('@b')
+    j = JID.new('@b')
     assert_equal('', j.node)
     assert_equal('b', j.domain)
     assert_equal(nil, j.resource)
@@ -95,7 +97,7 @@ class JIDTest < Test::Unit::TestCase
   end
 
   def test_create12
-    j = JID::new('@b/')
+    j = JID.new('@b/')
     assert_equal('', j.node)
     assert_equal('b', j.domain)
     assert_equal('', j.resource)
@@ -103,7 +105,7 @@ class JIDTest < Test::Unit::TestCase
   end
 
   def test_create13
-    j = JID::new('a@b/')
+    j = JID.new('a@b/')
     assert_equal('a', j.node)
     assert_equal('b', j.domain)
     assert_equal('', j.resource)
@@ -111,7 +113,7 @@ class JIDTest < Test::Unit::TestCase
   end
 
   def test_create14
-    j = JID::new('nOdE@dOmAiN/rEsOuRcE')
+    j = JID.new('nOdE@dOmAiN/rEsOuRcE')
     assert_equal('node', j.node)
     assert_equal('domain', j.domain)
     assert_equal('rEsOuRcE', j.resource)
@@ -119,44 +121,44 @@ class JIDTest < Test::Unit::TestCase
   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)
+    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'))
+    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')
+    j = JID.new('l@domain.fr/res')
     h[j] = 'a'
-    assert_equal(h[j], h[JID::new('l@domain.fr/res')])
+    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')
+    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)
+    assert_equal(JID.new('l@domain.fr'), jid)
 
-    jid = JID::new('l@domain.fr/res')
+    jid = JID.new('l@domain.fr/res')
     jid.bare!
-    assert_equal(JID::new('l@domain.fr'), jid)
+    assert_equal(JID.new('l@domain.fr'), jid)
   end
 
   def test_change1
-    j = JID::new('a@b/c')
+    j = JID.new('a@b/c')
     j.node = 'd'
     assert_equal('d@b/c', j.to_s)
     j.domain = 'e'
@@ -166,14 +168,14 @@ class JIDTest < Test::Unit::TestCase
   end
 
   def test_escaping
-    j = JID::new('user1@server1')
-    j2 = JID::new(JID::escape(j), 'server2', 'res2')
+    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) { JID.new('toto@a/a', 'server', 'res') }
     assert_raises(IDN::Stringprep::StringprepError) { IDN::Stringprep.nodeprep('toto@a/a') }
   end
 end

data/test/tc_message.rb

@@ -6,24 +6,25 @@ 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()
+    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")
+    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
+    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)
@@ -47,7 +48,7 @@ class MessageTest < Test::Unit::TestCase
   end
 
   def test_body
-    x = Message::new()
+    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)
@@ -56,7 +57,7 @@ class MessageTest < Test::Unit::TestCase
   end
 
   def test_subject
-    x = Message::new
+    x = Message.new
     assert_equal(nil, x.subject)
     subject = REXML::Element.new('subject')
     subject.text = 'A'
@@ -70,7 +71,7 @@ class MessageTest < Test::Unit::TestCase
   end
 
   def test_thread
-    x = Message::new
+    x = Message.new
     assert_equal(nil, x.thread)
     thread = REXML::Element.new('thread')
     thread.text = '123'
@@ -84,18 +85,18 @@ class MessageTest < Test::Unit::TestCase
   end
 
   def test_error
-    x = Message::new()
+    x = Message.new()
     assert_equal(nil, x.error)
-    e = REXML::Element::new('error')
+    e = REXML::Element.new('error')
     x.add(e)
     # test if, after an import, the error element is successfully changed
-    # into an Error object.
-    x2 = Message::new.import(x)
-    assert_equal(Error, x2.first_element('error').class)
+    # 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 = Message.new
     orig.from = 'a@b'
     orig.to = 'b@a'
     orig.id = '123'

data/test/tc_presence.rb

@@ -6,11 +6,12 @@ require 'test/unit'
 require 'socket'
 require 'xmpp4r/rexmladdons'
 require 'xmpp4r/presence'
+require 'xmpp4r/errors'
 include Jabber
 
 class PresenceTest < Test::Unit::TestCase
   def test_create
-    x = Presence::new()
+    x = Presence.new()
     assert_equal("presence", x.name)
     assert_equal("jabber:client", x.namespace)
     assert_equal(nil, x.to)
@@ -18,7 +19,7 @@ class PresenceTest < Test::Unit::TestCase
     assert_equal(nil, x.status)
     assert_equal(nil, x.priority)
 
-    x = Presence::new(:away, "I am away", 23)
+    x = Presence.new(:away, "I am away", 23)
     assert_equal("presence", x.name)
     assert_equal(:away, x.show)
     assert_equal("away", x.show.to_s)
@@ -27,7 +28,7 @@ class PresenceTest < Test::Unit::TestCase
   end
 
   def test_show
-    x = Presence::new()
+    x = Presence.new()
     assert_equal(nil, x.show)
     assert_raise(RuntimeError) { x.show = "a" }
     assert_equal(nil, x.show)
@@ -49,7 +50,7 @@ class PresenceTest < Test::Unit::TestCase
   end
 
   def test_status
-    x = Presence::new()
+    x = Presence.new()
     assert_equal(nil, x.status)
     x.status = "b"
     assert_equal("b", x.status)
@@ -62,7 +63,7 @@ class PresenceTest < Test::Unit::TestCase
   end
 
   def test_priority
-    x = Presence::new()
+    x = Presence.new()
     assert_equal(nil, x.priority)
     x.priority = 5
     assert_equal(5, x.priority)
@@ -75,7 +76,7 @@ class PresenceTest < Test::Unit::TestCase
   end
 
   def test_type
-    x = Presence::new()
+    x = Presence.new()
     assert_equal(nil, x.type)
     x.type = :delete
     assert_equal(nil, x.type)
@@ -90,7 +91,7 @@ class PresenceTest < Test::Unit::TestCase
   end
 
   def test_chaining
-    x = Presence::new()
+    x = Presence.new()
     x.set_show(:xa).set_status("Plundering the fridge.").set_priority(0)
     assert_equal(:xa, x.show)
     assert_equal("Plundering the fridge.", x.status)
@@ -98,17 +99,17 @@ class PresenceTest < Test::Unit::TestCase
   end
 
   def test_error
-    x = Presence::new()
-    e = REXML::Element::new('error')
+    x = Presence.new()
+    e = REXML::Element.new('error')
     x.add(e)
-    x2 = Presence::new.import(x)
+    x2 = Presence.new.import(x)
     # test if, after an import, the error element is successfully changed
-    # into an Error object.
-    assert_equal(Error, x2.first_element('error').class)
+    # into an ErrorResponse object.
+    assert_equal(ErrorResponse, x2.first_element('error').class)
   end
 
   def test_sample
-    x = Presence::new
+    x = Presence.new
     require 'rexml/document'
     d = REXML::Document.new("<presence from='astro@spaceboyz.net/versionbot' to='astro@spaceboyz.net/edgarr' xmlns='jabber:client'>\n    <x from='astro@spaceboyz.net/versionbot' stamp='20050823T02:18:42' xmlns='jabber:x:delay'/><show>xa</show>\n    <status>I am the evil fingerprinting robot</status>\n  </presence>")
     x.import(d.root)
@@ -129,21 +130,21 @@ class PresenceTest < Test::Unit::TestCase
   end
 
   def test_compare_prio
-    assert_equal(0, Presence::new(:chat, '', 5) <=> Presence::new(:chat, '', 5))
-    assert_equal(-1, Presence::new(:chat, '', 4) <=> Presence::new(:chat, '', 5))
-    assert_equal(1, Presence::new(:chat, '', 4) <=> Presence::new(:chat, '', 3))
-    assert_equal(-1, Presence::new(:chat, '', nil) <=> Presence::new(:chat, '', 3))
-    assert_equal(1, Presence::new(:chat, '', 10) <=> Presence::new(:chat, '', nil))
-    assert_equal(0, Presence::new(:chat, '', nil) <=> Presence::new(:chat, '', nil))
+    assert_equal(0, Presence.new(:chat, '', 5) <=> Presence.new(:chat, '', 5))
+    assert_equal(-1, Presence.new(:chat, '', 4) <=> Presence.new(:chat, '', 5))
+    assert_equal(1, Presence.new(:chat, '', 4) <=> Presence.new(:chat, '', 3))
+    assert_equal(-1, Presence.new(:chat, '', nil) <=> Presence.new(:chat, '', 3))
+    assert_equal(1, Presence.new(:chat, '', 10) <=> Presence.new(:chat, '', nil))
+    assert_equal(0, Presence.new(:chat, '', nil) <=> Presence.new(:chat, '', nil))
   end
 
   def test_compare_interest
-    unav = Presence::new.set_type(:unavailable)
+    unav = Presence.new.set_type(:unavailable)
     assert_equal(0, unav.cmp_interest(unav))
-    assert_equal(1, unav.cmp_interest(Presence::new))
-    assert_equal(-1, Presence::new.cmp_interest(unav))
-    assert_equal(1, Presence::new(:chat).cmp_interest(Presence::new))
-    assert_equal(-1, Presence::new(:away).cmp_interest(Presence::new(:dnd)))
+    assert_equal(1, unav.cmp_interest(Presence.new))
+    assert_equal(-1, Presence.new.cmp_interest(unav))
+    assert_equal(1, Presence.new(:chat).cmp_interest(Presence.new))
+    assert_equal(-1, Presence.new(:away).cmp_interest(Presence.new(:dnd)))
   end
 
 end