xmpp4r 0.4 → 0.5

data/lib/xmpp4r/streamparser.rb

@@ -43,7 +43,11 @@ module Jabber
           e.add_attributes attributes
           @current = @current.nil? ? e : @current.add_element(e)
 
-          if @current.name == 'stream' and !@started
+          # Handling <stream:stream> not only when it is being
+          # received as a top-level tag but also as a child of the
+          # top-level element itself. This way, we handle stream
+          # restarts (ie. after SASL authentication).
+          if @current.name == 'stream' and @current.parent.nil?
             @started = true
             @listener.receive(@current)
             @current = nil
@@ -60,6 +64,10 @@ module Jabber
           end
         end
 
+        parser.listen( :end_document ) do
+          raise Jabber::ServerDisconnected, "Server Disconnected!"
+        end
+
         parser.listen( :characters ) do | text |
           @current.add(REXML::Text.new(text.to_s, @current.whitespace, nil, true)) if @current
         end

data/lib/xmpp4r/test/listener_mocker.rb

@@ -0,0 +1,118 @@
+module Jabber
+  module Test
+    class ListenerMocker
+      
+      class << self
+        attr_accessor :with_socket_mocked_callback_proc
+      end
+      
+      def self.with_socket_mocked(callback_proc)
+        TCPSocket.class_eval{ ListenerMocker.with_socket_mocked_callback_proc = callback_proc }
+        TCPSocket.class_eval do
+          alias_method :initialize_old, :initialize
+          def initialize(*args)
+            initialize_old(*args) if ListenerMocker.with_socket_mocked_callback_proc.call(args)
+          end
+        end
+        yield
+      ensure
+        TCPSocket.class_eval do
+          if method_defined?(:initialize_old)
+            alias_method :initialize, :initialize_old
+          end
+        end
+      end
+      
+      class << self
+        attr_accessor :mock_clients, :tracker_of_callers
+      end
+      
+      def self.mocker_proc
+        Proc.new do      
+          attr_accessor :messagecbs, :connected
+          ListenerMocker.mock_clients ||= {}
+          ListenerMocker.tracker_of_callers ||= {}
+      
+          def connect
+            Jabber::debuglog("(in mock) connected #{@jid.bare}")
+            self.connected = true          
+          end
+      
+          def close!
+            ListenerMocker.mock_clients[@jid.bare.to_s] = nil
+            ListenerMocker.tracker_of_callers[@jid.bare.to_s] = nil
+            self.connected = false
+          end
+      
+          def auth(password)
+            auth_nonsasl(password)
+          end
+      
+          def auth_nonsasl(password, digest=true)
+            Jabber::debuglog("(in mock) authed #{@jid.bare}") 
+      
+            if(ListenerMocker.mock_clients[@jid.bare.to_s])
+              #raise a stack trace about multiple clients
+              raise "\n\n ---> READ ME: this is actualy 2 stack traces: <---- \n\n"+
+              "There is already a client connected on that jid #{@jid.bare.to_s}. "+
+              "The mock library cannot support multiple listeners connected as the same user! originally called in:\n"+
+              ListenerMocker.tracker_of_callers[@jid.bare.to_s].backtrace.join("\n")+"\n\n second trace: \n"
+            else
+              #store a stack trace so that next time we have multiple client, we can alert about it...
+              begin
+                throw "just saving a stack trace"
+              rescue => e
+                ListenerMocker.tracker_of_callers[@jid.bare.to_s] = e
+              end
+            end
+
+            ListenerMocker.mock_clients[@jid.bare.to_s] = self
+            true
+          end
+      
+          def send(xml, &block)
+            Jabber::debuglog("(in mock) sending #{xml} #{xml.class}")
+            if(xml.is_a?(Jabber::Message))
+              xml.from = @jid
+              # unless xml.to
+              #   raise "no jid!"
+              # end
+              if ListenerMocker.mock_clients[xml.to.bare.to_s]
+                Jabber::debuglog("(in mock) to #{xml.to.bare.to_s}")
+                ListenerMocker.mock_clients[xml.to.bare.to_s].messagecbs.process(xml)
+              else
+                Jabber::debuglog("(in mock) no client listening as #{xml.to.bare.to_s}")
+              end
+            end
+          end          
+      
+          def is_connected?
+            self.connected
+          end                
+        end    
+      end
+      
+      def self.mock_out_all_connections
+        Jabber::Reliable::Connection.class_eval(&Jabber::Test::ListenerMocker.mocker_proc)
+      end
+  
+      def self.mock_out(listener)
+        listener.instance_eval do
+          class << self
+            def setup_connection
+              super
+              @connection.instance_eval do
+                class << self
+                  self.class_eval(&Jabber::Test::ListenerMocker.mocker_proc)
+                end
+              end
+            end
+          end
+        end
+    
+        listener
+      end
+  
+    end
+  end
+end

data/lib/xmpp4r/xmpp4r.rb

@@ -8,11 +8,13 @@ module Jabber
   # XMPP4R Version number.  This is the ONLY place where the version number
   # should be specified.  This constant is used to determine the version of
   # package tarballs and generated gems.
-  XMPP4R_VERSION = '0.4'
+  XMPP4R_VERSION = '0.5'
 end
 
 require 'xmpp4r/client'
+require 'xmpp4r/reliable'
 require 'xmpp4r/component'
 require 'xmpp4r/debuglog'
 require 'xmpp4r/errors'
 
+require 'xmpp4r/test/listener_mocker'

data/test/bytestreams/tc_ibb.rb

@@ -30,6 +30,7 @@ class IBBTest < Test::Unit::TestCase
       target.close
     end
 
+    target.accept_wait
 
     initiator.open
 
@@ -50,10 +51,9 @@ class IBBTest < Test::Unit::TestCase
     buffer = create_buffer(9999)
 
     Thread.new do
-      Thread.pass
+      target.accept_wait
       initiator.open
       initiator.write(buffer)
-      Thread.pass
       initiator.close
     end
 
@@ -100,6 +100,7 @@ class IBBTest < Test::Unit::TestCase
     assert_equal(1, ignored_stanzas)
 
 
+    target.accept_wait
     initiator.open
 
 
@@ -116,8 +117,8 @@ class IBBTest < Test::Unit::TestCase
     assert_equal(3, ignored_stanzas)
 
 
-    10.times do
-      buf = create_buffer(9999)
+    5.times do
+      buf = create_buffer(100)
       initiator.write(buf)
       initiator.flush
 
@@ -147,6 +148,7 @@ class IBBTest < Test::Unit::TestCase
     end
 
 
+    target.accept_wait
     initiator.open
 
     assert_nil(initiator.read)

data/test/bytestreams/tc_socks5bytestreams.rb

@@ -44,6 +44,8 @@ class SOCKS5BytestreamsTest < Test::Unit::TestCase
       target2.close
     end
 
+    target1.accept_wait
+    target2.accept_wait
     initiator1.open
     initiator2.open
 
@@ -70,7 +72,6 @@ class SOCKS5BytestreamsTest < Test::Unit::TestCase
     initiator = Bytestreams::SOCKS5BytestreamsInitiator.new(@client, '1', '1@a.com/1', '1@a.com/2')
     initiator.add_streamhost(@@server)
 
-
     Thread.new do
       target.accept
 
@@ -81,7 +82,7 @@ class SOCKS5BytestreamsTest < Test::Unit::TestCase
 
       target.close
     end
-
+    target.accept_wait
 
     initiator.open
 

data/test/caps/tc_helper.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 
 $:.unshift File::dirname(__FILE__) + '/../../lib'
 
@@ -17,6 +18,7 @@ class Caps::HelperTest < Test::Unit::TestCase
   # in http://www.xmpp.org/extensions/xep-0115.html#usecases
   # and assert conformance.
   def test_caps_reply
+
     # This will be invoked by 'wait_state' below...
     state { |presence|
       assert_kind_of(Jabber::Presence, presence)
@@ -30,8 +32,6 @@ class Caps::HelperTest < Test::Unit::TestCase
       assert_equal('sha-1', c.hash)
 
       assert_equal("http://home.gna.org/xmpp4r/##{Jabber::XMPP4R_VERSION}", c.node)
-
-      send(iq_discovering_capabilities)
     }
 
     # Construct Caps::Helper which will send a <presence>
@@ -64,6 +64,8 @@ class Caps::HelperTest < Test::Unit::TestCase
       assert_equal(iq.query.features.sort, features.map(&get_var).sort)
     }
 
+    send(iq_discovering_capabilities)
+
     # The 'server' will receive the <iq> result from the
     # 'client' and yield it to the block above. Wait here
     # until that block exits.

data/test/dataforms/tc_data.rb

@@ -76,6 +76,6 @@ class DataFormsTest < Test::Unit::TestCase
     assert_equal(f, v.field('test'))
     assert_nil(v.field('wrong field'))
     assert_equal([f], v.fields)
-   end
+  end
 
 end

data/test/last/tc_helper.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/ruby
+
+$:.unshift File::dirname(__FILE__) + '/../../lib'
+
+require 'test/unit'
+require File::dirname(__FILE__) + '/../lib/clienttester'
+
+require 'xmpp4r'
+require 'xmpp4r/last/helper/helper'
+include Jabber
+
+
+class LastActivity::HelperTest < Test::Unit::TestCase
+  include ClientTester
+
+  def test_simple_query
+    state { |iq|
+      assert_kind_of(Iq, iq)
+      assert_equal(JID.new('juliet@capulet.com'), iq.to)
+      assert_equal(:get, iq.type)
+      assert_kind_of(LastActivity::IqQueryLastActivity, iq.query)
+      send("
+<iq type='result' from='#{iq.to}' to='#{iq.from}' id='#{iq.id}'>
+  <query xmlns='jabber:iq:last' seconds='903'/>
+</iq>")
+    }
+
+    res = LastActivity::Helper.new(@client).get_last_activity_from('juliet@capulet.com')
+    wait_state
+    assert_equal(903, res.seconds)
+    assert_nil(res.text)
+  end
+
+  def test_text_query
+    state { |iq|
+      send("
+<iq type='result' from='#{iq.to}' to='#{iq.from}' id='#{iq.id}'>
+  <query xmlns='jabber:iq:last' seconds='903'>Heading Home</query>
+</iq>")
+    }
+
+    res = LastActivity::Helper.new(@client).get_last_activity_from('juliet@capulet.com')
+    wait_state
+    assert_equal(903, res.seconds)
+    assert_equal('Heading Home', res.text)
+  end
+
+  def test_empty_query
+    state { |iq|
+      send("
+<iq type='result' from='#{iq.to}' to='#{iq.from}' id='#{iq.id}'>
+  <query xmlns='jabber:iq:last'/>
+</iq>")
+    }
+
+    res = LastActivity::Helper.new(@client).get_last_activity_from('juliet@capulet.com')
+    wait_state
+    assert_nil(res.seconds)
+    assert_nil(res.text)
+  end
+
+  def test_forbidden_query
+    state { |iq|
+      send("
+<iq type='error' from='#{iq.to}' to='#{iq.from}' id='#{iq.id}'>
+  <error type='auth'>
+    <forbidden xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
+  </error>
+</iq>")
+    }
+
+    assert_raises(ServerError) { LastActivity::Helper.new(@client).get_last_activity_from('juliet@capulet.com') }
+  end
+
+end

data/test/lib/clienttester.rb

@@ -8,6 +8,10 @@ require 'test/unit'
 require 'socket'
 require 'xmpp4r/semaphore'
 
+# Jabber::debug = true
+$ctdebug = false
+# $ctdebug = true
+
 # This is sane for tests:
 Thread::abort_on_exception = true
 
@@ -33,6 +37,9 @@ module Jabber
       serverwait = Semaphore.new
       stream = '<stream:stream xmlns:stream="http://etherx.jabber.org/streams">'
 
+      @state = 0
+      @states = []
+
       Thread.new do
         Thread.current.abort_on_exception = true
         serversock = servlisten.accept
@@ -68,31 +75,53 @@ module Jabber
       end
 #=end
       @client.start(clientsock)
-      @client.send(stream) { |reply| true }
 
-      @state = 0
-      @states = []
-      @state_wait = Semaphore.new
-      @state_wait2 = Semaphore.new
+      @processdone_wait = Semaphore.new
+      @nextstate_wait = Semaphore.new
+      serverwait.wait
       @server.add_stanza_callback { |stanza|
-        if @state < @states.size
+        # Client prepares everything, then calls wait_state. Problem: because
+        # of a race condition, it is possible that we receive the stanza before
+        # what to do with it is defined. We busy-wait on @states here.
+        n = 0
+        while @state >= @states.size and n < 1000
+          Thread.pass
+          n += 1
+        end
+        if n == 1000
+          puts "Unmanaged stanza in state. Maybe processed by helper?" if $ctdebug
+        else
           begin
+            puts "Calling #{@states[@state]} for #{stanza.to_s}" if $ctdebug
             @states[@state].call(stanza)
-          rescue
-            puts "Exception in state: #{$!.class}: #{$!}\n#{$!.join("\n")}"
+          rescue Exception => e
+            puts "Exception in state: #{e.class}: #{e}\n#{e.backtrace.join("\n")}"
           end
           @state += 1
-          @state_wait2.wait
-          @state_wait.run
+          @nextstate_wait.wait
+          @processdone_wait.run
         end
 
         false
       }
+      @client.send(stream) { |reply| true }
 
-      serverwait.wait
     end
 
     def teardown
+      # In some cases, we might lost count of some stanzas
+      # (for example, if the handler raises an exception)
+      # so we can't block forever.
+      n = 0
+      while @client.processing > 0 and n < 1000
+        Thread::pass
+        n += 1
+      end
+      n = 0
+      while @server.processing > 0 and n < 1000
+        Thread::pass
+        n += 1
+      end
       @client.close
       @server.close
     end
@@ -106,12 +135,12 @@ module Jabber
     end
 
     def wait_state
-      @state_wait2.run
-      @state_wait.wait
+      @nextstate_wait.run
+      @processdone_wait.wait
     end
 
     def skip_state
-      @state_wait2.run
+      @nextstate_wait.run
     end
   end
 end

data/test/muc/tc_muc_mucclient.rb

@@ -86,7 +86,11 @@ class MUCClientTest < Test::Unit::TestCase
     send("<presence from='darkcave@macbeth.shakespeare.lit/thirdwitch' to='crone1@shakespeare.lit/desktop'>" +
          "<x xmlns='http://jabber.org/protocol/muc#user'><item affiliation='none' jid='hag66@shakespeare.lit/pda' role='participant'/></x>" +
          "</presence>")
-    sleep 0.1
+    n = 0
+    while m.roster.size != 3 and n < 1000
+      Thread::pass
+      n += 1
+    end
     assert_equal(3, m.roster.size)
     assert_equal(:none, m.roster['thirdwitch'].x.items[0].affiliation)
     assert_equal(:participant, m.roster['thirdwitch'].x.items[0].role)
@@ -408,7 +412,7 @@ class MUCClientTest < Test::Unit::TestCase
     assert_equal(1, messages_muc_private)
 
     wait_state
-   end
+  end
 
   def test_presence_callbacks
     state { |pres|