vines 0.1.0

data/test/ext/nokogiri.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+module Nokogiri
+  module XML
+    class Node
+      # Override equality testing so we can use MiniTest::Mock#expect with
+      # Nokogiri::XML::Node arguments. Node's default behavior considers
+      # all nodes unequal.
+      def ==(node)
+        self.to_s == node.to_s
+      end
+    end
+  end
+end

data/test/jid_test.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'test/unit'
+
+class JidTest < Test::Unit::TestCase
+  def test_nil_and_empty_jids
+    [nil, ''].each do |text|
+      assert_nothing_raised { Vines::JID.new(text) }
+      jid = Vines::JID.new(text)
+      assert_nil jid.node
+      assert_nil jid.resource
+      assert_equal '', jid.domain
+      assert_equal '', jid.to_s
+      assert_equal '', jid.bare.to_s
+    end
+  end
+
+  def test_jid_too_long_error
+    assert_nothing_raised { Vines::JID.new('n' * 1023) }
+    assert_raises(ArgumentError) { Vines::JID.new('n' * 1024) }
+    assert_raises(ArgumentError) { Vines::JID.new('n', 'd' * 1024) }
+    assert_raises(ArgumentError) { Vines::JID.new('n', 'd', 'r' * 1024) }
+    assert_nothing_raised { Vines::JID.new('n' * 1023, 'd' * 1023, 'r' * 1023) }
+  end
+
+  def test_domain_only
+    jid = Vines::JID.new('wonderland.lit')
+    assert_equal 'wonderland.lit', jid.to_s
+    assert_equal 'wonderland.lit', jid.domain
+    assert_nil jid.node
+    assert_nil jid.resource
+    assert_equal jid, jid.bare
+  end
+
+  def test_bare_jid
+    jid = Vines::JID.new('alice', 'wonderland.lit')
+    assert_equal 'alice@wonderland.lit', jid.to_s
+    assert_equal 'wonderland.lit', jid.domain
+    assert_equal 'alice', jid.node
+    assert_nil jid.resource
+    assert_equal jid, jid.bare
+  end
+
+  def test_parsed_bare_jid
+    jid = Vines::JID.new('alice@wonderland.lit')
+    assert_equal 'alice@wonderland.lit', jid.to_s
+    assert_equal 'wonderland.lit', jid.domain
+    assert_equal 'alice', jid.node
+    assert_nil jid.resource
+    assert_equal jid, jid.bare
+  end
+
+  def test_full_jid
+    jid = Vines::JID.new('alice', 'wonderland.lit', 'tea')
+    assert_equal 'alice@wonderland.lit/tea', jid.to_s
+    assert_equal 'wonderland.lit', jid.domain
+    assert_equal 'alice', jid.node
+    assert_equal 'tea', jid.resource
+    assert_not_equal jid, jid.bare
+  end
+
+  def test_parsed_full_jid
+    jid = Vines::JID.new('alice@wonderland.lit/tea')
+    assert_equal 'alice@wonderland.lit/tea', jid.to_s
+    assert_equal 'wonderland.lit', jid.domain
+    assert_equal 'alice', jid.node
+    assert_equal 'tea', jid.resource
+    assert_not_equal jid, jid.bare
+  end
+end

data/test/kit_test.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'test/unit'
+
+class KitTest < Test::Unit::TestCase
+  def test_hmac
+    assert_equal(128, Vines::Kit.hmac('secret', 'username').length)
+    assert_equal(Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s1', 'u1'))
+    assert_not_equal(Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s2', 'u1'))
+    assert_not_equal(Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s1', 'u2'))
+  end
+
+  def test_uuid
+    ids = Array.new(1000) { Vines::Kit.uuid }
+    assert(ids.all? {|id| !id.nil? })
+    assert(ids.all? {|id| id.length == 36 })
+    assert(ids.all? {|id| id.match(/\w{8}-\w{4}-[4]\w{3}-[89ab]\w{3}-\w{12}/) })
+    assert_equal(ids.length, ids.uniq.length)
+  end
+end

data/test/router_test.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'minitest/mock'
+require 'test/unit'
+
+class RouterTest < Test::Unit::TestCase
+  def setup
+    @router = Vines::Router.new
+  end
+
+  def test_non_routable_stanza_is_local
+    stanza = MiniTest::Mock.new
+    stanza.expect(:name, 'auth')
+    assert @router.local?(stanza)
+    assert stanza.verify
+  end
+
+  def test_stanza_missing_to_is_local
+    stanza = MiniTest::Mock.new
+    stanza.expect(:name, 'message')
+    stanza.expect(:[], nil, ['to'])
+    assert @router.local?(stanza)
+    assert stanza.verify
+  end
+
+  def test_stanza_with_local_jid_is_local
+    config = MiniTest::Mock.new
+    config.expect(:vhost?, true, ['wonderland.lit'])
+    stream = MiniTest::Mock.new
+    stream.expect(:config, config)
+    @router << stream
+
+    stanza = MiniTest::Mock.new
+    stanza.expect(:name, 'message')
+    stanza.expect(:[], 'alice@wonderland.lit', ['to'])
+    assert @router.local?(stanza)
+
+    assert stanza.verify
+    assert stream.verify
+    assert config.verify
+  end
+
+  def test_stanza_with_remote_jid_is_not_local
+    config = MiniTest::Mock.new
+    config.expect(:vhost?, false, ['wonderland.lit'])
+    stream = MiniTest::Mock.new
+    stream.expect(:config, config)
+    @router << stream
+
+    stanza = MiniTest::Mock.new
+    stanza.expect(:name, 'message')
+    stanza.expect(:[], 'alice@wonderland.lit', ['to'])
+    assert !@router.local?(stanza)
+
+    assert stanza.verify
+    assert stream.verify
+    assert config.verify
+  end
+end

data/test/stanza/iq/roster_test.rb

@@ -0,0 +1,198 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'ext/nokogiri'
+require 'minitest/mock'
+require 'test/unit'
+
+class RosterTest < Test::Unit::TestCase
+  def setup
+    @stream = MiniTest::Mock.new
+  end
+
+  def test_roster_get_with_empty_roster
+    alice = Vines::User.new(:jid => 'alice@wonderland.lit')
+    expected = node(%q{<iq id="42" type="result"><query xmlns="jabber:iq:roster"/></iq>})
+    @stream.expect(:write, nil, [expected])
+    @stream.expect(:requested_roster!, nil)
+    @stream.expect(:user, alice)
+
+    node = node(%q{<iq id="42" type="get"><query xmlns='jabber:iq:roster'/></iq>})
+    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
+    stanza.process
+    assert @stream.verify
+  end
+
+  def test_roster_get_with_non_empty_roster
+    alice = Vines::User.new(:jid => 'alice@wonderland.lit')
+    alice.roster << Vines::Contact.new(:jid => 'hatter@wonderland.lit')
+    alice.roster << Vines::Contact.new(:jid => 'cat@wonderland.lit', :groups => ['Friends', 'Cats'])
+
+    expected = node(%q{
+      <iq id="42" type="result">
+        <query xmlns="jabber:iq:roster">
+          <item jid="cat@wonderland.lit" subscription="none">
+            <group>Cats</group>
+            <group>Friends</group>
+          </item>
+          <item jid="hatter@wonderland.lit" subscription="none"/>
+        </query>
+      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+
+    @stream.expect(:write, nil, [expected])
+    @stream.expect(:requested_roster!, nil)
+    @stream.expect(:user, alice)
+
+    node = node(%q{<iq id="42" type="get"><query xmlns='jabber:iq:roster'/></iq>})
+    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
+    stanza.process
+    assert @stream.verify
+  end
+
+  def test_roster_set_with_invalid_to_address
+    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
+    @stream.expect(:user, alice)
+
+    node = node(%q{
+      <iq id="42" type="set" to="romeo@verona.lit">
+        <query xmlns="jabber:iq:roster"/>
+      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+
+    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
+    assert_raise(Vines::StanzaErrors::Forbidden) { stanza.process }
+    assert @stream.verify
+  end
+
+  def test_roster_set_with_no_items
+    node = node(%q{
+      <iq id="42" type="set">
+        <query xmlns="jabber:iq:roster"/>
+      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+
+    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
+    assert_raise(Vines::StanzaErrors::BadRequest) { stanza.process }
+    assert @stream.verify
+  end
+
+  def test_roster_set_with_two_items
+    node = node(%q{
+      <iq id="42" type="set">
+        <query xmlns="jabber:iq:roster">
+          <item jid="hatter@wonderland.lit"/>
+          <item jid="cat@wonderland.lit"/>
+        </query>
+      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+
+    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
+    assert_raise(Vines::StanzaErrors::BadRequest) { stanza.process }
+    assert @stream.verify
+  end
+
+  def test_roster_set_missing_jid
+    node = node(%q{
+      <iq id="42" type="set">
+        <query xmlns="jabber:iq:roster">
+          <item name="Mad Hatter"/>
+        </query>
+      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+
+    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
+    assert_raise(Vines::StanzaErrors::BadRequest) { stanza.process }
+    assert @stream.verify
+  end
+
+  def test_roster_set_with_duplicate_groups
+    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
+    @stream.expect(:user, alice)
+
+    node = node(%q{
+      <iq id="42" type="set">
+        <query xmlns="jabber:iq:roster">
+          <item jid="hatter@wonderland.lit" name="Mad Hatter">
+            <group>Friends</group>
+            <group>Friends</group>
+          </item>
+        </query>
+      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+
+    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
+    assert_raise(Vines::StanzaErrors::BadRequest) { stanza.process }
+    assert @stream.verify
+  end
+
+  def test_roster_set_with_empty_group
+    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
+    @stream.expect(:user, alice)
+
+    node = node(%q{
+      <iq id="42" type="set">
+        <query xmlns="jabber:iq:roster">
+          <item jid="hatter@wonderland.lit" name="Mad Hatter">
+            <group></group>
+          </item>
+        </query>
+      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+
+    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
+    assert_raise(Vines::StanzaErrors::NotAcceptable) { stanza.process }
+    assert @stream.verify
+  end
+
+  def test_roster_set_sends_results
+    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
+    storage = MiniTest::Mock.new
+    storage.expect(:save_user, nil, [alice])
+
+    recipient = MiniTest::Mock.new
+    recipient.expect(:user, alice)
+    def recipient.nodes; @nodes; end
+    def recipient.write(node)
+      @nodes ||= []
+      @nodes << node
+    end
+
+    router = MiniTest::Mock.new
+    router.expect(:interested_resources, [recipient], [alice.jid])
+
+    @stream.expect(:user, alice)
+    @stream.expect(:update_user_streams, nil, [alice])
+    @stream.expect(:router, router)
+    @stream.expect(:domain, 'wonderland.lit')
+    @stream.expect(:storage, storage, ['wonderland.lit'])
+    expected = node(%q{<iq id="42" type="result"/>})
+    @stream.expect(:write, nil, [expected])
+
+    node = node(%q{
+      <iq id="42" type="set">
+        <query xmlns="jabber:iq:roster">
+          <item jid="hatter@wonderland.lit" name="Mad Hatter">
+            <group>Friends</group>
+          </item>
+        </query>
+      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+
+    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
+    stanza.process
+    assert_nothing_raised { stanza.process }
+    assert @stream.verify
+    assert storage.verify
+    assert router.verify
+
+    expected = node(%q{
+      <iq type="set" to="alice@wonderland.lit/tea">
+        <query xmlns="jabber:iq:roster">
+          <item jid="hatter@wonderland.lit" name="Mad Hatter" subscription="none">
+            <group>Friends</group>
+          </item>
+        </query>
+      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+    recipient.nodes[0].remove_attribute('id') # id is random
+    assert_equal expected, recipient.nodes[0]
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end

data/test/stanza/iq/session_test.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'ext/nokogiri'
+require 'minitest/mock'
+require 'test/unit'
+
+class SessionTest < Test::Unit::TestCase
+  def test_session
+    stream = MiniTest::Mock.new
+    stream.expect(:domain, 'wonderland.lit')
+    expected = node(%q{<iq from="wonderland.lit" id="42" type="result"/>})
+    stream.expect(:write, nil, [expected])
+
+    node = node(
+      %q{<iq id="42" to="wonderland.lit" type="set">
+        <session xmlns="urn:ietf:params:xml:ns:xmpp-session"/>
+      </iq>})
+
+    stanza = Vines::Stanza::Iq::Session.new(node, stream)
+    stanza.process
+    assert stream.verify
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end

data/test/stanza/iq/vcard_test.rb

@@ -0,0 +1,159 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'ext/nokogiri'
+require 'minitest/mock'
+require 'test/unit'
+
+class VcardTest < Test::Unit::TestCase
+  def setup
+    @stream = MiniTest::Mock.new
+  end
+
+  def test_vcard_get_on_remote_jid_routes
+    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
+    node = node(%q{<iq id="42" to="romeo@verona.lit" type="get"><vCard xmlns="vcard-temp"/></iq>})
+
+    router = MiniTest::Mock.new
+    router.expect(:local?, false, [node])
+    router.expect(:route, nil, [node])
+
+    @stream.expect(:user, alice)
+    @stream.expect(:router, router)
+
+    stanza = Vines::Stanza::Iq::Vcard.new(node, @stream)
+    stanza.process
+    assert @stream.verify
+    assert router.verify
+  end
+
+  def test_vcard_get_missing_to_address
+    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
+    node = node(%q{<iq id="42" type="get"><vCard xmlns="vcard-temp"/></iq>})
+
+    router = MiniTest::Mock.new
+    router.expect(:local?, true, [node])
+
+    card = node(%q{<vCard xmlns="vcard-temp"><FN>Alice in Wonderland</FN></vCard>})
+
+    storage = MiniTest::Mock.new
+    storage.expect(:find_vcard, card, [alice.jid.bare])
+
+    @stream.expect(:user, alice)
+    @stream.expect(:router, router)
+    @stream.expect(:domain, 'wonderland.lit')
+    @stream.expect(:storage, storage, ['wonderland.lit'])
+    expected = node(%q{
+      <iq id="42" to="alice@wonderland.lit/tea" type="result">
+        <vCard xmlns="vcard-temp">
+          <FN>Alice in Wonderland</FN>
+        </vCard>
+      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+    @stream.expect(:write, nil, [expected])
+
+    stanza = Vines::Stanza::Iq::Vcard.new(node, @stream)
+    stanza.process
+    assert @stream.verify
+    assert router.verify
+    assert storage.verify
+  end
+
+  def test_vcard_get_another_user_includes_from_address
+    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
+    node = node(%q{<iq id="42" to="hatter@wonderland.lit" type="get"><vCard xmlns="vcard-temp"/></iq>})
+
+    router = MiniTest::Mock.new
+    router.expect(:local?, true, [node])
+
+    card = node(%q{<vCard xmlns="vcard-temp"><FN>Mad Hatter</FN></vCard>})
+
+    storage = MiniTest::Mock.new
+    storage.expect(:find_vcard, card, [Vines::JID.new('hatter@wonderland.lit')])
+
+    @stream.expect(:user, alice)
+    @stream.expect(:router, router)
+    @stream.expect(:domain, 'wonderland.lit')
+    @stream.expect(:storage, storage, ['wonderland.lit'])
+    expected = node(%q{
+      <iq from="hatter@wonderland.lit" id="42" to="alice@wonderland.lit/tea" type="result">
+        <vCard xmlns="vcard-temp">
+          <FN>Mad Hatter</FN>
+        </vCard>
+      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+    @stream.expect(:write, nil, [expected])
+
+    stanza = Vines::Stanza::Iq::Vcard.new(node, @stream)
+    stanza.process
+    assert @stream.verify
+    assert router.verify
+    assert storage.verify
+  end
+
+  def test_missing_vcard_get_returns_item_not_found
+    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
+    node = node(%q{<iq id="42" type="get"><vCard xmlns="vcard-temp"/></iq>})
+
+    router = MiniTest::Mock.new
+    router.expect(:local?, true, [node])
+
+    storage = MiniTest::Mock.new
+    storage.expect(:find_vcard, nil, [alice.jid.bare])
+
+    @stream.expect(:user, alice)
+    @stream.expect(:router, router)
+    @stream.expect(:domain, 'wonderland.lit')
+    @stream.expect(:storage, storage, ['wonderland.lit'])
+
+    stanza = Vines::Stanza::Iq::Vcard.new(node, @stream)
+    assert_raise(Vines::StanzaErrors::ItemNotFound) { stanza.process }
+    assert @stream.verify
+    assert router.verify
+    assert storage.verify
+  end
+
+  def test_vcard_set_on_another_user_returns_forbidden
+    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
+    node = node(%q{<iq id="42" to="hatter@wonderland.lit" type="set"><vCard xmlns="vcard-temp"><FN>Alice</FN></vCard></iq>})
+
+    router = MiniTest::Mock.new
+    router.expect(:local?, true, [node])
+
+    @stream.expect(:user, alice)
+    @stream.expect(:router, router)
+
+    stanza = Vines::Stanza::Iq::Vcard.new(node, @stream)
+    assert_raise(Vines::StanzaErrors::Forbidden) { stanza.process }
+    assert @stream.verify
+  end
+
+  def test_vcard_set_returns_result
+    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
+    node = node(%q{<iq id="42" type="set"><vCard xmlns="vcard-temp"><FN>Alice</FN></vCard></iq>})
+    card = node(%q{<vCard xmlns="vcard-temp"><FN>Alice</FN></vCard>})
+
+    router = MiniTest::Mock.new
+    router.expect(:local?, true, [node])
+
+    storage = MiniTest::Mock.new
+    storage.expect(:save_vcard, nil, [alice.jid, card])
+
+    @stream.expect(:user, alice)
+    @stream.expect(:router, router)
+    @stream.expect(:domain, 'wonderland.lit')
+    @stream.expect(:storage, storage, ['wonderland.lit'])
+    expected = node(%q{<iq id="42" to="alice@wonderland.lit/tea" type="result"/>})
+    @stream.expect(:write, nil, [expected])
+
+    stanza = Vines::Stanza::Iq::Vcard.new(node, @stream)
+    stanza.process
+    assert @stream.verify
+    assert router.verify
+    assert storage.verify
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end