xmpp4r 0.3.1 → 0.3.2

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/lib/clienttester.rb

@@ -2,6 +2,7 @@ $:.unshift '../lib'
 require 'xmpp4r'
 require 'test/unit'
 require 'socket'
+require 'xmpp4r/semaphore'
 
 # Turn $VERBOSE off to suppress warnings about redefinition
 oldverbose = $VERBOSE
@@ -22,53 +23,50 @@ module Jabber
     @@SOCKET_PORT = 65223
 
     def setup
-      Thread::abort_on_exception = true
-
       servlisten = TCPServer.new(@@SOCKET_PORT)
-      serverwait = Mutex.new
-      serverwait.lock
-      Thread.new {
+      serverwait = Semaphore.new
+      Thread.new do
+        Thread.current.abort_on_exception = true
         serversock = servlisten.accept
         servlisten.close
         serversock.sync = true
         @server = Stream.new(true)
-        @server.add_xml_callback { |xml|
+        @server.add_xml_callback do |xml|
           if xml.prefix == 'stream' and xml.name == 'stream'
             send('<stream:stream>')
             true
           else
             false
           end
-        }
+        end
         @server.start(serversock)
 
-        serverwait.unlock
-      }
+        serverwait.run
+      end
 
       clientsock = TCPSocket.new('localhost', @@SOCKET_PORT)
       clientsock.sync = true
       @client = Stream.new(true)
       @client.start(clientsock)
 
-      @client.send('<stream:stream>') { |reply|
-        true
-      }
+      @client.send('<stream:stream>') { |reply| true }
 
       @state = 0
       @states = []
-      @state_wait = Mutex.new
-      @state_wait.lock
+      @state_wait = Semaphore.new
+      @state_wait2 = Semaphore.new
       @server.add_stanza_callback { |stanza|
         if @state < @states.size
           @states[@state].call(stanza)
           @state += 1
+          @state_wait2.wait
+          @state_wait.run
         end
-        @state_wait.unlock
 
         false
       }
 
-      serverwait.lock
+      serverwait.wait
     end
 
     def teardown
@@ -101,7 +99,12 @@ module Jabber
     end
 
     def wait_state
-      @state_wait.lock
+      @state_wait2.run
+      @state_wait.wait
+    end
+
+    def skip_state
+      @state_wait2.run
     end
   end
 end

data/test/muc/tc_muc_mucclient.rb

@@ -6,6 +6,7 @@ $:.unshift File::dirname(__FILE__) + '/../../lib'
 require 'test/unit'
 require File::dirname(__FILE__) + '/../lib/clienttester'
 require 'xmpp4r/muc'
+require 'xmpp4r/semaphore'
 include Jabber
 
 class MUCClientTest < Test::Unit::TestCase
@@ -54,10 +55,12 @@ class MUCClientTest < Test::Unit::TestCase
     assert_raises(ErrorException) {
       m.join('darkcave@macbeth.shakespeare.lit/thirdwitch')
     }
+    wait_state
     assert(!m.active?)
     assert_nil(m.room)
 
     assert_equal(m, m.join('darkcave@macbeth.shakespeare.lit/thirdwitch'))
+    wait_state
     assert(m.active?)
     assert_equal('darkcave', m.room)
     assert_equal(3, m.roster.size)
@@ -104,15 +107,17 @@ class MUCClientTest < Test::Unit::TestCase
            "<x xmlns='http://jabber.org/protocol/muc#user'><item affiliation='member' role='participant'/></x>" +
            "</presence>")
     }
-    
+
     m = MUC::MUCClient.new(@client)
     m.my_jid = 'hag66@shakespeare.lit/pda'
     assert_raises(ErrorException) {
       m.join('darkcave@macbeth.shakespeare.lit/thirdwitch')
     }
+    wait_state
     assert(!m.active?)
 
     assert_equal(m, m.join('darkcave@macbeth.shakespeare.lit/thirdwitch', 'cauldron'))
+    wait_state
     assert(m.active?)
   end
 
@@ -130,6 +135,8 @@ class MUCClientTest < Test::Unit::TestCase
       m.join('darkcave@macbeth.shakespeare.lit/thirdwitch')
     }
     assert(!m.active?)
+
+    wait_state
   end
 
   def test_banned_users
@@ -146,6 +153,8 @@ class MUCClientTest < Test::Unit::TestCase
       m.join('darkcave@macbeth.shakespeare.lit/thirdwitch')
     }
     assert(!m.active?)
+
+    wait_state
   end
 
   def test_nickname_conflict
@@ -162,6 +171,8 @@ class MUCClientTest < Test::Unit::TestCase
       m.join('darkcave@macbeth.shakespeare.lit/thirdwitch')
     }
     assert(!m.active?)
+
+    wait_state
   end
 
   def test_max_users
@@ -178,11 +189,12 @@ class MUCClientTest < Test::Unit::TestCase
       m.join('darkcave@macbeth.shakespeare.lit/thirdwitch')
     }
     assert(!m.active?)
+
+    wait_state
   end
 
   def test_locked_room
     state { |pres|
-      assert_kind_of(Presence, pres)
       send("<presence from='darkcave@macbeth.shakespeare.lit' to='hag66@shakespeare.lit/pda' type='error'>" + 
            "<error code='404' type='cancel'><item-not-found xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/></error>" +
            "</presence>")
@@ -194,6 +206,7 @@ class MUCClientTest < Test::Unit::TestCase
       m.join('darkcave@macbeth.shakespeare.lit/thirdwitch')
     }
     assert(!m.active?)
+    wait_state
   end
 
   def test_exit_room
@@ -221,15 +234,17 @@ class MUCClientTest < Test::Unit::TestCase
     @client.add_stanza_callback { |stanza|
       ignored_stanzas += 1
     }
-    
+
     m = MUC::MUCClient.new(@client)
     m.my_jid = 'hag66@shakespeare.lit/pda'
     assert_equal(0, ignored_stanzas)
     assert_equal(m, m.join('darkcave@macbeth.shakespeare.lit/thirdwitch'))
+    wait_state
     assert(m.active?)
 
     assert_equal(0, ignored_stanzas)
     assert_equal(m, m.exit)
+    wait_state
     assert(!m.active?)
     assert_equal(1, ignored_stanzas)
   end
@@ -251,14 +266,16 @@ class MUCClientTest < Test::Unit::TestCase
            "<x xmlns='http://jabber.org/protocol/muc#user'><item affiliation='member' role='none'/></x>" +
            "</presence>")
     }
-    
+
     m = MUC::MUCClient.new(@client)
     m.my_jid = 'hag66@shakespeare.lit/pda'
     assert_equal(m, m.join('darkcave@macbeth.shakespeare.lit/thirdwitch'))
     assert(m.active?)
+    wait_state
 
     assert_equal(m, m.exit('gone where the goblins go'))
     assert(!m.active?)
+    wait_state
   end
 
   def test_joins
@@ -304,6 +321,7 @@ class MUCClientTest < Test::Unit::TestCase
     m = MUC::MUCClient.new(@client)
     m.my_jid = 'hag66@shakespeare.lit/pda'
     assert_equal(m, m.join('darkcave@macbeth.shakespeare.lit/thirdwitch'))
+    wait_state
     assert(m.active?)
 
     assert_raises(RuntimeError) { m.join('darkcave@macbeth.shakespeare.lit/thirdwitch') }
@@ -311,11 +329,13 @@ class MUCClientTest < Test::Unit::TestCase
     assert(m.active?)
 
     assert_equal(m, m.exit)
+    wait_state
     assert(!m.active?)
     assert_raises(RuntimeError) { m.exit }
     assert(!m.active?)
 
     assert_equal(m, m.join('darkcave@macbeth.shakespeare.lit/fourthwitch'))
+    wait_state
     assert(m.active?)
 
     assert_raises(RuntimeError) { m.join('darkcave@macbeth.shakespeare.lit/thirdwitch') }
@@ -323,6 +343,7 @@ class MUCClientTest < Test::Unit::TestCase
     assert(m.active?)
 
     assert_equal(m, m.exit('Exiting one last time'))
+    wait_state
     assert(!m.active?)
     assert_raises(RuntimeError) { m.exit }
     assert(!m.active?)
@@ -337,13 +358,12 @@ class MUCClientTest < Test::Unit::TestCase
            "</presence>")
     }
 
-    message_lock = Mutex.new
-    message_lock.lock
+    message_lock = Semaphore.new
 
     messages_client = 0
     @client.add_message_callback { |msg|
       messages_client += 1
-      message_lock.unlock
+      message_lock.run
     }
     
     m = MUC::MUCClient.new(@client)
@@ -351,12 +371,12 @@ class MUCClientTest < Test::Unit::TestCase
     messages_muc = 0
     m.add_message_callback { |msg|
       messages_muc += 1
-      message_lock.unlock
+      message_lock.run
     }
     messages_muc_private = 0
     m.add_private_message_callback { |msg|
       messages_muc_private += 1
-      message_lock.unlock
+      message_lock.run
     }
 
     assert_equal(m, m.join('darkcave@macbeth.shakespeare.lit/thirdwitch', 'cauldron'))
@@ -367,26 +387,28 @@ class MUCClientTest < Test::Unit::TestCase
     assert_equal(0, messages_muc_private)
 
     send("<message from='darkcave@macbeth.shakespeare.lit/firstwitch' to='hag66@shakespeare.lit/pda'><body>Hello</body></message>")
-    message_lock.lock
+    message_lock.wait
 
     assert_equal(0, messages_client)
     assert_equal(1, messages_muc)
     assert_equal(0, messages_muc_private)
 
     send("<message from='user@domain/resource' to='hag66@shakespeare.lit/pda'><body>Hello</body></message>")
-    message_lock.lock
+    message_lock.wait
 
     assert_equal(1, messages_client)
     assert_equal(1, messages_muc)
     assert_equal(0, messages_muc_private)
 
     send("<message type='chat' from='darkcave@macbeth.shakespeare.lit/firstwitch' to='hag66@shakespeare.lit/pda'><body>Hello</body></message>")
-    message_lock.lock
+    message_lock.wait
 
     assert_equal(1, messages_client)
     assert_equal(1, messages_muc)
     assert_equal(1, messages_muc_private)
-  end
+
+    wait_state
+   end
 
   def test_presence_callbacks
     state { |pres|
@@ -397,30 +419,29 @@ class MUCClientTest < Test::Unit::TestCase
            "</presence>")
     }
 
-    presence_lock = Mutex.new
-    presence_lock.lock
+    presence_lock = Semaphore.new
 
     presences_client = 0
     @client.add_presence_callback { |pres|
       presences_client += 1
-      presence_lock.unlock
+      presence_lock.run
     }   
     m = MUC::MUCClient.new(@client)
     m.my_jid = 'hag66@shakespeare.lit/pda'
     presences_join = 0
     m.add_join_callback { |pres|
       presences_join += 1
-      presence_lock.unlock
+      presence_lock.run
     }
     presences_leave = 0
     m.add_leave_callback { |pres|
       presences_leave += 1
-      presence_lock.unlock
+      presence_lock.run
     }
     presences_muc = 0
     m.add_presence_callback { |pres|
       presences_muc += 1
-      presence_lock.unlock
+      presence_lock.run
     }
 
     assert_equal(0, presences_client)
@@ -439,7 +460,7 @@ class MUCClientTest < Test::Unit::TestCase
     send("<presence from='darkcave@macbeth.shakespeare.lit/firstwitch' to='hag66@shakespeare.lit/pda'>" +
          "<x xmlns='http://jabber.org/protocol/muc#user'><item affiliation='member' role='participant'/></x>" +
          "</presence>")
-    presence_lock.lock
+    presence_lock.wait
     assert_equal(0, presences_client)
     assert_equal(1, presences_join)
     assert_equal(0, presences_leave)
@@ -448,7 +469,7 @@ class MUCClientTest < Test::Unit::TestCase
     send("<presence from='user@domain/resource' to='hag66@shakespeare.lit/pda'>" +
          "<show>chat</show>" +
          "</presence>")
-    presence_lock.lock
+    presence_lock.wait
     assert_equal(1, presences_client)
     assert_equal(1, presences_join)
     assert_equal(0, presences_leave)
@@ -457,18 +478,19 @@ class MUCClientTest < Test::Unit::TestCase
     send("<presence from='darkcave@macbeth.shakespeare.lit/firstwitch' to='hag66@shakespeare.lit/pda'>" +
          "<x xmlns='http://jabber.org/protocol/muc#user'><item affiliation='member' role='participant'/></x>" +
          "<show>away</show></presence>")
-    presence_lock.lock
+    presence_lock.wait
     assert_equal(1, presences_client)
     assert_equal(1, presences_join)
     assert_equal(0, presences_leave)
     assert_equal(1, presences_muc)
 
     send("<presence from='darkcave@macbeth.shakespeare.lit/firstwitch' to='hag66@shakespeare.lit/pda' type='unavailable'/>")
-    presence_lock.lock
+    presence_lock.wait
     assert_equal(1, presences_client)
     assert_equal(1, presences_join)
     assert_equal(1, presences_leave)
     assert_equal(1, presences_muc)
+    wait_state
   end
 
   def test_send
@@ -553,16 +575,19 @@ class MUCClientTest < Test::Unit::TestCase
     m.my_jid = 'hag66@shakespeare.lit/pda'
 
     assert_equal(m, m.join('darkcave@macbeth.shakespeare.lit/thirdwitch'))
+    wait_state
     assert(m.active?)
     assert_equal('thirdwitch', m.nick)
 
     assert_raises(ErrorException) {
       m.nick = 'secondwitch'
     }
+    wait_state
     assert(m.active?)
     assert_equal('thirdwitch', m.nick)
 
     m.nick = 'oldhag'
+    wait_state
     assert(m.active?)
     assert_equal('oldhag', m.nick)
   end