mack-notifier 0.8.1 → 0.8.2

data/lib/gems/xmpp4r-0.4/test/tc_streamError.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/client'
+include Jabber
+
+class ConnectionErrorTest < Test::Unit::TestCase
+  @@SOCKET_PORT = 65225
+  STREAM = '<stream:stream xmlns:stream="http://etherx.jabber.org/streams">'
+
+  def setup
+    servlisten = TCPServer.new(@@SOCKET_PORT)
+    serverwait = Semaphore.new
+    @server = nil
+    Thread.new do
+      Thread.current.abort_on_exception = true
+      @server = servlisten.accept
+      servlisten.close
+      @server.sync = true
+
+      serverwait.run
+    end
+
+    @conn = TCPSocket.new('localhost', @@SOCKET_PORT)
+
+    serverwait.wait
+  end
+
+  def teardown
+    @conn.close if not @conn.closed?
+    @server.close if not @conn.closed?
+  end
+
+  def test_connectionError_start_withexcblock
+    @stream = Stream.new
+    error = false
+    @stream.on_exception do |e, o, w|
+      # strange exception, it's caused by REXML, actually
+      assert_kind_of(StandardError, e)
+      assert_equal(Jabber::Stream, o.class)
+      assert_equal(:start, w)
+      error = true
+    end
+    assert(!error)
+    begin
+      # wrong port on purpose
+      conn = TCPSocket.new('localhost', 1)
+    rescue
+    end
+    @stream.start(conn)
+    sleep 0.2
+    assert(error)
+    @server.close
+    @stream.close
+  end
+
+  def test_connectionError_parse_withexcblock
+    @stream = Stream.new
+    error = false
+    @stream.start(@conn)
+    @stream.on_exception do |e, o, w|
+      if w == :disconnected
+        assert_equal(nil, e)
+        assert_equal(Jabber::Stream, o.class)
+      else
+        assert_equal(REXML::ParseException, e.class)
+        assert_equal(Jabber::Stream, o.class)
+        assert_equal(:parser, w)
+        error = true
+      end
+    end
+    @server.puts(STREAM)
+    @server.flush
+    assert(!error)
+    @server.puts('</blop>')
+    @server.flush
+    sleep 0.2
+    assert(error)
+    @server.close
+    @stream.close
+  end
+
+  def test_connectionError_send_withexcblock
+    @stream = Stream.new
+    error = 0
+    @stream.start(@conn)
+    @stream.on_exception do |exc, o, w|
+      case w
+      when :sending
+        assert_equal(IOError, exc.class)
+        assert_equal(Jabber::Stream, o.class)
+      when :disconnected
+        assert_equal(nil, exc)
+        assert_equal(Jabber::Stream, o.class)
+      else
+        assert(false)
+      end
+      error += 1
+    end
+    @server.puts(STREAM)
+    @server.flush
+    assert_equal(0, error)
+    @server.close
+    sleep 0.1
+    assert_equal(1, error)
+    @stream.send('</test>')
+    sleep 0.1
+    @stream.send('</test>')
+    sleep 0.1
+    assert_equal(3, error)
+    @stream.close
+  end
+
+  def test_connectionError_send_withoutexcblock
+    @stream = Stream.new
+    @stream.start(@conn)
+    @server.puts(STREAM)
+    @server.flush
+    assert_raise(Errno::EPIPE) do
+      @server.close
+     sleep 0.1
+      @stream.send('</test>')
+      sleep 0.1
+      @stream.send('</test>')
+      sleep 0.1
+    end
+  end
+end

data/lib/gems/xmpp4r-0.4/test/tc_streamSend.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'socket'
+require 'tempfile'
+require 'io/wait'
+require 'xmpp4r'
+include Jabber
+
+class StreamSendTest < Test::Unit::TestCase
+  def setup
+    @tmpfile = Tempfile.new("StreamSendTest")
+    @tmpfilepath = @tmpfile.path()
+    @tmpfile.unlink
+    @servlisten = UNIXServer.new(@tmpfilepath)
+    thServer = Thread.new { @server = @servlisten.accept }
+    @iostream = UNIXSocket.new(@tmpfilepath)
+    @stream = Stream.new
+    @stream.start(@iostream)
+
+    thServer.join
+  end
+
+  def teardown
+    @stream.close
+    @server.close
+    @servlisten.close
+  end
+
+  def mysend(s)
+    @stream.send(s)
+    @stream.send("\n") #needed for easy test writing
+  end
+
+  ##
+  # Tries to send a basic message
+  def test_sendbasic
+    mysend(Message.new)
+    assert_equal("<message/>\n", @server.gets)
+  end
+
+  def test_sendmessage
+    mysend(Message.new('lucas@linux.ensimag.fr', 'coucou'))
+    assert_equal("<message to='lucas@linux.ensimag.fr'><body>coucou</body></message>\n", @server.gets)
+  end
+
+  def test_sendpresence
+    mysend(Presence.new)
+    assert_equal("<presence/>\n", @server.gets)
+  end
+
+  def test_sendiq
+    mysend(Iq.new)
+    assert_equal("<iq/>\n", @server.gets)
+  end
+
+end

data/lib/gems/xmpp4r-0.4/test/tc_streamparser.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'tempfile'
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/streamparser'
+require 'xmpp4r/semaphore'
+include Jabber
+
+class MockListener
+  attr_reader :received
+
+  def receive(element)
+    @received = element
+  end
+
+  def parse_failure(exception)
+    raise exception
+  end
+end
+
+class StreamParserTest < Test::Unit::TestCase
+  STREAM = '<stream:stream xmlns:stream="http://etherx.jabber.org/streams">'
+
+  def setup
+    @listener = MockListener.new
+  end
+
+  def teardown
+    @listener = nil
+  end
+
+  def parse_simple_helper(fixture)
+    parser = StreamParser.new(STREAM + fixture, @listener)
+
+    parser.parse
+
+    yield parse_with_rexml(fixture)
+  end
+
+  def parse_with_rexml(fixture)
+    REXML::Document.new(fixture).root
+  end
+
+  def test_simple_text
+    parse_simple_helper( "<a>text</a>" ) do |desired|
+      assert_equal desired.name, @listener.received.name
+      assert_equal desired.text, @listener.received.text
+      assert_equal desired.cdatas, @listener.received.cdatas
+    end
+  end
+
+  def test_simple_cdata
+    parse_simple_helper( "<a><![CDATA[<cdata>]]></a>" ) do |desired|
+      assert_equal desired.name, @listener.received.name
+      assert_equal desired.text, @listener.received.text
+      assert_equal desired.cdatas, @listener.received.cdatas
+    end
+  end
+
+  def test_composite_text_cdata
+    parse_simple_helper( "<a>text<![CDATA[<cdata>]]></a>" ) do |desired|
+      assert_equal desired.name, @listener.received.name
+      assert_equal desired.text, @listener.received.text
+      assert_equal desired.cdatas, @listener.received.cdatas
+    end
+  end
+
+  def test_composite_cdata_text
+    parse_simple_helper( "<a><![CDATA[<cdata>]]>text</a>" ) do |desired|
+      assert_equal desired.name, @listener.received.name
+      assert_equal desired.text, @listener.received.text
+      assert_equal desired.cdatas, @listener.received.cdatas
+    end
+  end
+
+  def test_complex_composite_cdata_text
+    parse_simple_helper( "<a><![CDATA[<cdata>]]>text<![CDATA[<cdata>]]>text</a>" ) do |desired|
+      assert_equal desired.name, @listener.received.name
+      assert_equal desired.text, @listener.received.text
+      assert_equal desired.cdatas, @listener.received.cdatas
+    end
+  end
+
+  def test_entity_escaping1
+    parse_simple_helper( "<a>&apos;&amp;&quot;</a>" ) do |desired|
+      assert_equal "'&\"", @listener.received.text
+      assert_equal "<a>&apos;&amp;&quot;</a>", @listener.received.to_s
+    end
+  end
+
+  def test_entity_escaping2
+    parse_simple_helper( "<a>&amp;amp;amp;</a>" ) do |desired|
+      assert_equal "&amp;amp;", @listener.received.text
+      assert_equal "<a>&amp;amp;amp;</a>", @listener.received.to_s
+    end
+  end
+
+=begin
+  **********
+  * FIXME! *
+  **********
+
+  def test_unbound_prefix
+    parse_simple_helper("<message><soe:instantMessage/></message>") do |desired|
+      assert_equal desired.first_element('*').name, 'instantMessage'
+    end
+  end
+=end
+end

data/lib/gems/xmpp4r-0.4/test/tc_xmppstanza.rb

@@ -0,0 +1,135 @@
+#!/usr/bin/ruby
+
+$:.unshift '../lib'
+
+require 'test/unit'
+require 'socket'
+require 'xmpp4r/rexmladdons'
+require 'xmpp4r/xmppstanza'
+require 'xmpp4r/iq'
+require 'xmpp4r/feature_negotiation'
+require 'xmpp4r/dataforms'
+require 'xmpp4r/errors'
+include Jabber
+
+class XMPPStanzaTest < Test::Unit::TestCase
+
+  ##
+  # Hack: XMPPStanza derives from XMPPElement
+  # which enforces element classes to be named at declaration time
+  class MyXMPPStanza < XMPPStanza
+    name_xmlns 'stanza', 'http://home.gna.org/xmpp4r'
+  end
+
+  class MyStanza < XMPPStanza
+  end
+
+  def test_from
+    x = MyXMPPStanza.new
+    assert_equal(nil, x.from)
+    assert_equal(x, x.set_from("blop"))
+    assert_equal("blop", x.from.to_s)
+    x.from = "tada"
+    assert_equal("tada", x.from.to_s)
+  end
+
+  def test_to
+    x = MyXMPPStanza.new
+    assert_equal(nil, x.to)
+    assert_equal(x, x.set_to("blop"))
+    assert_equal("blop", x.to.to_s)
+    x.to = "tada"
+    assert_equal("tada", x.to.to_s)
+  end
+
+  def test_id
+    x = MyXMPPStanza.new
+    assert_equal(nil, x.id)
+    assert_equal(x, x.set_id("blop"))
+    assert_equal("blop", x.id)
+    x.id = "tada"
+    assert_equal("tada", x.id)
+  end
+
+  def test_type
+    x = MyXMPPStanza.new
+    assert_equal(nil, x.type)
+    assert_equal(x, x.set_type("blop"))
+    assert_equal("blop", x.type)
+    x.type = "tada"
+    assert_equal("tada", x.type)
+  end
+
+  def test_import
+    x = MyXMPPStanza.new
+    x.id = "heya"
+    q = x.add_element("query")
+    q.add_namespace("about:blank")
+    q.add_element("b").text = "I am b"
+    q.add_text("I am text")
+    q.add_element("a").add_attribute("href", "http://home.gna.org/xmpp4r/")
+    x.add_text("yow")
+    x.add_element("query")
+
+    assert_raise(RuntimeError) { iq = Iq.import(x) }
+    x.name = 'iq'
+    iq = Iq.import(x)
+
+    assert_equal(x.id, iq.id)
+    assert_equal(q.to_s, iq.query.to_s)
+    assert_equal(x.to_s, iq.to_s)
+    assert_equal(q.namespace, iq.queryns)
+  end
+
+  def test_import2
+    feature = FeatureNegotiation::IqFeature.new
+    xdata = feature.add(Dataforms::XData.new(:form))
+    field = xdata.add(Dataforms::XDataField.new('stream-method', :list_single))
+
+    feature2 = FeatureNegotiation::IqFeature.new.import(feature)
+    assert_equal(field.var, feature2.x.fields.first.var)
+    assert_equal(field.type, feature2.x.fields.first.type)
+  end
+
+  def test_import_xml_entities
+    e = REXML::Element.new('e')
+    e.text = '&'
+    assert_equal('<e>&amp;</e>', e.to_s)
+
+    e2 = REXML::Element.new('e').import(e)
+    assert_equal('<e>&amp;</e>', e2.to_s)
+  end
+
+  def test_error
+    x = MyXMPPStanza.new
+    assert_equal(nil, x.error)
+    x.typed_add(REXML::Element.new('error'))
+    assert_equal('<error/>', x.error.to_s)
+    assert_equal(ErrorResponse, x.error.class)
+  end
+
+  def test_clone_and_dup
+    x = MyXMPPStanza.new
+    x.attributes['xyz'] = '123'
+    x.text = 'abc'
+
+    assert_equal(x.attributes['xyz'], '123')
+    assert_equal(x.text, 'abc')
+
+    x2 = x.clone
+    assert_kind_of(MyXMPPStanza, x2)
+    assert_equal('123', x2.attributes['xyz'])
+    assert_nil(x2.text)
+
+    x3 = x.dup
+    assert_kind_of(MyXMPPStanza, x3)
+    assert_equal('123', x3.attributes['xyz'])
+    assert_equal('abc', x3.text)
+  end
+
+  def test_raise
+    assert_raises(NoNameXmlnsRegistered) {
+      XMPPStanza.name_xmlns_for_class(MyStanza)
+    }
+  end
+end

data/lib/gems/xmpp4r-0.4/test/ts_xmpp4r.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/ruby -w
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+$:.unshift File.join(File.dirname(__FILE__), '..', 'test')
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+$:.unshift File.join(File.dirname(__FILE__), 'test')
+
+# This is allowed here, to make sure it's enabled in all test.
+Thread::abort_on_exception = true
+
+require 'xmpp4r'
+require 'find'
+
+# List files' basenames, not full path!
+# EXCLUDED_FILES = [ 'tc_muc_simplemucclient.rb' ]
+EXCLUDED_FILES = []
+
+tc_files = []
+tc_subdirs = []
+Find.find(File.dirname(__FILE__)) do |f|
+  if File::directory?(f)
+    if f == '.'
+      # do nothing
+    elsif File::basename(f) != '.svn'
+      tc_subdirs << f
+      Find.prune
+    end
+  elsif File::basename(f) =~ /^tc.*\.rb$/
+    tc_files << f
+  end
+end
+
+tc_subdirs.each do |dir|
+  Find.find(dir) do |f|
+    if File::file?(f) and File::basename(f) =~ /^tc.*\.rb$/
+
+      if (RUBY_VERSION.split('.').collect {|n| n.to_i} <=> [1,9,0]) >= 0
+        # TODO: at the moment, these two test cases have timing dependencies
+        # on threaded code.  While they may pass with the green thread
+        # implementation in Ruby 1.8, they often fail with real threads.
+        next if f =~ /tc_helper.rb/
+        next if f =~ /tc_stream.rb/
+      end
+
+      tc_files << f
+    end
+  end
+end
+
+tc_files.each do |f|
+  next if EXCLUDED_FILES.include?(File::basename(f))
+  require f
+end