vines 0.1.0

data/test/stream/client/ready_test.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'minitest/mock'
+require 'test/unit'
+
+class ClientReadyTest < Test::Unit::TestCase
+  STANZAS = []
+
+  def setup
+    @stream = MiniTest::Mock.new
+    @state = Vines::Stream::Client::Ready.new(@stream, nil)
+    def @state.to_stanza(node)
+      if node.name == 'bogus'
+        nil
+      else
+        MiniTest::Mock.new.tap do |stanza|
+          stanza.expect(:process, nil)
+          ClientReadyTest::STANZAS << stanza
+        end
+      end
+    end
+  end
+
+  def teardown
+    STANZAS.clear
+  end
+
+  def test_good_node_processes
+    node = node('<message/>')
+    assert_nothing_raised { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert STANZAS.map {|s| s.verify }.all?
+  end
+
+  def test_unsupported_stanza_type
+    node = node('<bogus/>')
+    assert_raise(Vines::StreamErrors::UnsupportedStanzaType) { @state.node(node) }
+    assert STANZAS.empty?
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end

data/test/stream/component/handshake_test.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'minitest/mock'
+require 'test/unit'
+
+class HandshakeTest < Test::Unit::TestCase
+  def setup
+    @stream = MiniTest::Mock.new
+    @state = Vines::Stream::Component::Handshake.new(@stream)
+  end
+
+  def test_invalid_element
+    node = node('<message/>')
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_text
+    @stream.expect(:secret, 'secr3t')
+    node = node('<handshake/>')
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+    assert @stream.verify
+  end
+
+  def test_invalid_secret
+    @stream.expect(:secret, 'secr3t')
+    node = node('<handshake>bogus</handshake>')
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+    assert @stream.verify
+  end
+
+  def test_valid_secret
+    @stream.expect(:secret, 'secr3t')
+    @stream.expect(:write, nil, ['<handshake/>'])
+    @stream.expect(:advance, nil, [Vines::Stream::Component::Ready.new(@stream)])
+    node = node('<handshake>secr3t</handshake>')
+    assert_nothing_raised { @state.node(node) }
+    assert @stream.verify
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end

data/test/stream/component/ready_test.rb

@@ -0,0 +1,105 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'ext/nokogiri'
+require 'minitest/mock'
+require 'test/unit'
+
+class ComponentReadyTest < Test::Unit::TestCase
+  STANZAS = []
+
+  def setup
+    @stream = MiniTest::Mock.new
+    @state = Vines::Stream::Component::Ready.new(@stream, nil)
+    def @state.to_stanza(node)
+      if node.name == 'bogus'
+        nil
+      else
+        MiniTest::Mock.new.tap do |stanza|
+          if node['to'] == 'hatter@wonderland.lit'
+            stanza.expect(:local?, true)
+          else
+            stanza.expect(:local?, false)
+            stanza.expect(:route, nil)
+          end
+          ComponentReadyTest::STANZAS << stanza
+        end
+      end
+    end
+  end
+
+  def teardown
+    STANZAS.clear
+  end
+
+  def test_missing_to_and_from_addresses
+    node = node('<message/>')
+    assert_raise(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert @stream.verify
+  end
+
+  def test_missing_from_address
+    @stream.expect(:remote_domain, 'tea.wonderland.lit')
+    node = node(%q{<message to="hatter@wonderland.lit"/>})
+    assert_raise(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert @stream.verify
+  end
+
+  def test_missing_to_address
+    node = node(%q{<message from="alice@tea.wonderland.lit"/>})
+    assert_raise(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert @stream.verify
+  end
+
+  def test_invalid_from_address
+    @stream.expect(:remote_domain, 'tea.wonderland.lit')
+    node = node(%q{<message from="alice@bogus.wonderland.lit" to="hatter@wonderland.lit"/>})
+    assert_raise(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert @stream.verify
+  end
+
+  def test_unsupported_stanza_type
+    node = node('<bogus/>')
+    assert_raise(Vines::StreamErrors::UnsupportedStanzaType) { @state.node(node) }
+    assert STANZAS.empty?
+    assert @stream.verify
+  end
+
+  def test_remote_message_routes
+    @stream.expect(:remote_domain, 'tea.wonderland.lit')
+    node = node(%q{<message from="alice@tea.wonderland.lit" to="romeo@verona.lit"/>})
+    assert_nothing_raised { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert STANZAS.map {|s| s.verify }.all?
+    assert @stream.verify
+  end
+
+  def test_local_message_processes
+    node = node(%q{<message from="alice@tea.wonderland.lit" to="hatter@wonderland.lit"/>})
+    @stream.expect(:remote_domain, 'tea.wonderland.lit')
+
+    @recipient = MiniTest::Mock.new
+    @recipient.expect(:write, nil, [node])
+
+    @router = MiniTest::Mock.new
+    @router.expect(:connected_resources, [@recipient], ['hatter@wonderland.lit'])
+    @stream.expect(:router, @router)
+
+    assert_nothing_raised { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert STANZAS.map {|s| s.verify }.all?
+    assert @stream.verify
+    assert @router.verify
+    assert @recipient.verify
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end

data/test/stream/component/start_test.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'minitest/mock'
+require 'test/unit'
+
+class ComponentStartTest < Test::Unit::TestCase
+  def setup
+    @stream = MiniTest::Mock.new
+    @state = Vines::Stream::Component::Start.new(@stream)
+  end
+
+  def test_invalid_element
+    node = node('<message/>')
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_stream_namespace
+    node = node('<stream:stream/>')
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_invalid_stream_namespace
+    node = node('<stream:stream xmlns="bogus"/>')
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_valid_stream_header
+    node = node(%q{<stream:stream xmlns:stream="http://etherx.jabber.org/streams" xmlns="jabber:component:accept" to="tea.wonderland.lit"/>})
+    @stream.expect(:start, nil, [node])
+    @stream.expect(:advance, nil, [Vines::Stream::Component::Handshake.new(@stream)])
+    assert_nothing_raised { @state.node(node) }
+    assert @stream.verify
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end

data/test/stream/parser_test.rb

@@ -0,0 +1,121 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'test/unit'
+
+class ParserTest < Test::Unit::TestCase
+  STREAM_START = '<stream:stream to="wonderland.lit" xmlns="jabber:client" xmlns:stream="http://etherx.jabber.org/streams">'.freeze
+
+  def setup
+    @events = []
+    @parser = Vines::Stream::Parser.new.tap do |p|
+      p.stream_open  {|el| @events << el }
+      p.stream_close {     @events << :close }
+      p.stanza       {|el| @events << el }
+    end
+  end
+
+  def test_xpath_to_subclass
+    expected = []
+    stanzas = [
+      ['<message></message>', Vines::Stanza::Message],
+      ['<presence/>', Vines::Stanza::Presence],
+      ['<presence type="bogus"/>', Vines::Stanza::Presence],
+      ['<presence type="error"/>', Vines::Stanza::Presence::Error],
+      ['<presence type="probe"/>', Vines::Stanza::Presence::Probe],
+      ['<presence type="subscribe"/>', Vines::Stanza::Presence::Subscribe],
+      ['<presence type="subscribed"/>', Vines::Stanza::Presence::Subscribed],
+      ['<presence type="unavailable"/>', Vines::Stanza::Presence::Unavailable],
+      ['<presence type="unsubscribe"/>', Vines::Stanza::Presence::Unsubscribe],
+      ['<presence type="unsubscribed"/>', Vines::Stanza::Presence::Unsubscribed],
+      ['<iq id="42" type="get"><query xmlns="http://jabber.org/protocol/disco#info"></query></iq>', Vines::Stanza::Iq::Query::DiscoInfo],
+      ['<iq id="42" type="get"><query xmlns="http://jabber.org/protocol/disco#items"></query></iq>', Vines::Stanza::Iq::Query::DiscoItems],
+      ['<iq id="42" type="error"></iq>', Vines::Stanza::Iq::Error],
+      ['<iq id="42" type="get"><ping xmlns="urn:xmpp:ping"/></iq>', Vines::Stanza::Iq::Ping],
+      ['<iq id="42" type="result"></iq>', Vines::Stanza::Iq::Result],
+      ['<iq id="42" type="get"><query xmlns="jabber:iq:roster"/></iq>', Vines::Stanza::Iq::Query::Roster],
+      ['<iq id="42" type="set"><query xmlns="jabber:iq:roster"/></iq>', Vines::Stanza::Iq::Query::Roster],
+      ['<iq id="42" type="set"><session xmlns="urn:ietf:params:xml:ns:xmpp-session"/></iq>', Vines::Stanza::Iq::Session],
+      ['<iq id="42" type="get"><vCard xmlns="vcard-temp"/></iq>', Vines::Stanza::Iq::Vcard],
+      ['<iq type="get"><vCard xmlns="vcard-temp"/></iq>', Vines::Stanza::Iq],
+      ['<iq id="42"><vCard xmlns="vcard-temp"/></iq>', Vines::Stanza::Iq],
+      ['<iq><vCard xmlns="vcard-temp"/></iq>', Vines::Stanza::Iq],
+      ['<bogus/>', NilClass],
+    ]
+    @parser << STREAM_START
+    stanzas.each do |stanza, klass|
+      @parser << stanza
+      expected << klass
+    end
+    @parser << '</stream:stream>'
+    assert_equal 'stream', @events.shift.name
+    assert_equal :close, @events.pop
+    assert_equal expected.size, @events.size
+    @events.each_with_index do |ev, ix|
+      assert_equal expected[ix], Vines::Stanza.from_node(ev, nil).class
+    end
+  end
+
+  def test_stream_namespace_with_default_prefix
+    @parser << STREAM_START
+    assert_equal 1, @events.size
+    stream = @events.shift
+    assert_equal 'stream', stream.name
+    assert_not_nil stream.namespace
+    assert_equal 'stream', stream.namespace.prefix
+    assert_equal 'http://etherx.jabber.org/streams', stream.namespace.href
+    expected = {'xmlns' => 'jabber:client', 'xmlns:stream' => 'http://etherx.jabber.org/streams'}
+    assert_equal expected, stream.namespaces
+  end
+
+  def test_stanzas_ignore_default_namespace
+    @parser << STREAM_START
+    @parser << '<message to="alice@wonderland.lit">hello!</message>'
+    assert_equal 2, @events.size
+    @events.shift # discard stream
+    msg = @events.shift
+    assert_equal 'message', msg.name
+    assert msg.namespaces.empty?
+    assert_nil msg.namespace
+  end
+
+  def test_nested_elements_have_namespace
+    @parser << STREAM_START
+    @parser << %q{
+      <iq from='alice@wonderland.lit/tea' id='42' type='set'>
+        <query xmlns='jabber:iq:roster'>
+          <item jid='hatter@wonderland.lit' name='Mad Hatter'>
+            <group>Tea Party</group>
+          </item>
+        </query>
+      </iq>
+    }
+    assert_equal 2, @events.size
+    @events.shift # discard stream
+    iq = @events.shift
+    assert_equal 'iq', iq.name
+    assert iq.namespaces.empty?
+    assert_nil iq.namespace
+
+    query = iq.elements.first
+    assert_not_nil query.namespace
+    assert_nil query.namespace.prefix
+    assert_equal 'jabber:iq:roster', query.namespace.href
+    expected = {'xmlns' => 'jabber:iq:roster'}
+    assert_equal expected, query.namespaces
+  end
+
+  def test_error_stanzas_have_stream_namespace
+    @parser << STREAM_START
+    @parser << '<stream:error><not-well-formed xmlns="urn:ietf:params:xml:ns:xmpp-streams"/></stream:error>'
+    assert_equal 2, @events.size
+    @events.shift # discard stream
+    error = @events.shift
+    assert_equal 'error', error.name
+    assert_not_nil error.namespace
+    assert_equal 'stream', error.namespace.prefix
+    assert_equal 'http://etherx.jabber.org/streams', error.namespace.href
+    expected = {'xmlns:stream' => 'http://etherx.jabber.org/streams'}
+    assert_equal expected, error.namespaces
+  end
+end

data/test/stream/server/outbound/auth_test.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'minitest/mock'
+require 'test/unit'
+
+class OutboundAuthTest < Test::Unit::TestCase
+  def setup
+    @stream = MiniTest::Mock.new
+    @state = Vines::Stream::Server::Outbound::Auth.new(@stream)
+  end
+
+  def test_invalid_element
+    node = node('<message/>')
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_invalid_sasl_element
+    node = node(%Q{<message xmlns="#{Vines::NAMESPACES[:sasl]}"/>})
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_namespace
+    node = node('<stream:features/>')
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_invalid_namespace
+    node = node('<stream:features xmlns="bogus"/>')
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_mechanisms
+    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams"/>})
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_mechanisms_namespace
+    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams"><mechanisms/></stream:features>})
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_mechanism
+    mechanisms = %q{<mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"/>}
+    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams">#{mechanisms}</stream:features>})
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_mechanism_text
+    mechanisms = %q{<mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><mechanism></mechanism></mechanisms>}
+    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams">#{mechanisms}</stream:features>})
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_invalid_mechanism_text
+    mechanisms = %q{<mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><mechanism>BOGUS</mechanism></mechanisms>}
+    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams">#{mechanisms}</stream:features>})
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_valid_mechanism
+    @stream.expect(:domain, 'wonderland.lit')
+    expected = %Q{<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="EXTERNAL">d29uZGVybGFuZC5saXQ=</auth>}
+    @stream.expect(:write, nil, [expected])
+    @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::AuthResult.new(@stream)])
+    mechanisms = %q{<mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><mechanism>EXTERNAL</mechanism></mechanisms>}
+    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams">#{mechanisms}</stream:features>})
+    assert_nothing_raised { @state.node(node) }
+    assert @stream.verify
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end

data/test/stream/server/ready_test.rb

@@ -0,0 +1,100 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'minitest/mock'
+require 'test/unit'
+
+class ServerReadyTest < Test::Unit::TestCase
+  STANZAS = []
+
+  def setup
+    @stream = MiniTest::Mock.new
+    @state = Vines::Stream::Server::Ready.new(@stream, nil)
+    def @state.to_stanza(node)
+      if node.name == 'bogus'
+        nil
+      else
+        MiniTest::Mock.new.tap do |stanza|
+          stanza.expect(:process, nil)
+          stanza.class.send(:define_method, :[]) do |a|
+            node[a]
+          end
+          ServerReadyTest::STANZAS << stanza
+        end
+      end
+    end
+  end
+
+  def teardown
+    STANZAS.clear
+  end
+
+  def test_good_node_processes
+    @stream.expect(:remote_domain, 'wonderland.lit')
+    @stream.expect(:domain, 'verona.lit')
+    @stream.expect(:user=, nil, [Vines::User.new(:jid => 'alice@wonderland.lit')])
+    node = node(%Q{<message from="alice@wonderland.lit" to="romeo@verona.lit"/>})
+    assert_nothing_raised { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert STANZAS.map {|s| s.verify }.all?
+    assert @stream.verify
+  end
+
+  def test_unsupported_stanza_type
+    node = node('<bogus/>')
+    assert_raise(Vines::StreamErrors::UnsupportedStanzaType) { @state.node(node) }
+    assert STANZAS.empty?
+    assert @stream.verify
+  end
+
+  def test_improper_addressing_missing_to
+    node = node(%Q{<message from="alice@wonderland.lit"/>})
+    assert_raise(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert @stream.verify
+  end
+
+  def test_improper_addressing_empty_to
+    node = node(%Q{<message from="alice@wonderland.lit" to=" "/>})
+    assert_raise(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert @stream.verify
+  end
+
+  def test_improper_addressing_missing_from
+    node = node(%Q{<message to="romeo@verona.lit"/>})
+    assert_raise(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert @stream.verify
+  end
+
+  def test_improper_addressing_empty_from
+    node = node(%Q{<message from=" " to="romeo@verona.lit"/>})
+    assert_raise(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert @stream.verify
+  end
+
+  def test_invalid_from
+    @stream.expect(:remote_domain, 'wonderland.lit')
+    node = node(%Q{<message from="alice@bogus.lit" to="romeo@verona.lit"/>})
+    assert_raise(Vines::StreamErrors::InvalidFrom) { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert @stream.verify
+  end
+
+  def test_host_unknown
+    @stream.expect(:remote_domain, 'wonderland.lit')
+    @stream.expect(:domain, 'verona.lit')
+    node = node(%Q{<message from="alice@wonderland.lit" to="romeo@bogus.lit"/>})
+    assert_raise(Vines::StreamErrors::HostUnknown) { @state.node(node) }
+    assert_equal 1, STANZAS.size
+    assert @stream.verify
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end